zebra_camera.h

/*
 * ©2019 Zebra Technologies Corp. and/or its affiliates.
 */
#ifndef ZEBRA_CAMERA_H_
#define ZEBRA_CAMERA_H_
 
#include <memory>
#include <vector>
#include <string>
#include <mutex>
#include <cstdint>
 
#include "camera_enums.h"
#include "camera_types.h"
#include "device_manager_types.h"
 
namespace zebra {
namespace camera_sdk {
 
class UvcDeviceAdapter;
class VideoFrameSink;
class FirmwareUpdater;
 
class ZebraCamera {
    friend class ZebraCameraManager;
    friend class VideoFrameSink;
    friend class FirmwareUpdater;
    template <typename T, CameraPropertyId ID> friend class Property;
    template <typename T, CameraPropertyId ID> friend class PropertyAuto;
public:
    virtual ~ZebraCamera();
 
    // Expert level API
    std::vector<uint8_t> GetProperty(Get function, uint8_t unit_or_terminal_id, uint8_t property_id);
 
    void SetProperty(Set function, uint8_t unit_or_terminal_id, uint8_t property_id, std::vector<uint8_t> value);
 
    AttributeInfo GetPropertyInfo(uint8_t unit_or_terminal_id, uint8_t property_id);
 
    bool IsPropertySupported(uint8_t unit_or_terminal_id, uint8_t property_id);
 
    // Asset tracking API
    std::string GetSerialNumber();
 
    std::string GetModelNumber();
 
    std::string GetDateOfManufacture();
 
    std::string GetDateOfFirstProgram();
 
    std::string GetFirstServiceDate();
 
    std::string GetFirmwareVersion();
 
    std::string GetHardwareVersion();
 
    // Video API
    std::vector<FrameType> GetSupportedFrameTypes();
 
    FrameType GetCurrentFrameType();
 
    void SetCurrentFrameType(FrameType frame_type);
 
    void AddContinuousImageEventListener(ContinuousImageEventListener& listener);
 
    void RemoveContinuousImageEventListener(ContinuousImageEventListener& listener);
 
    void AddSnapshotImageEventListener(SnapshotImageEventListener& listener);
 
    void RemoveSnapshotImageEventListener(SnapshotImageEventListener& listener);
 
    void AddProduceImageEventListener(ProduceImageEventListener& listener);
 
    void RemoveProduceImageEventListener(ProduceImageEventListener& listener);
 
    void AddDecodeImageEventListener(DecodeImageEventListener& listener);
 
    void RemoveDecodeImageEventListener(DecodeImageEventListener& listener);
 
    void AddDecodeSessionStatusChangeEventListener(DecodeSessionStatusChangeEventListener& listener);
 
    void RemoveDecodeSessionStatusChangeEventListener(DecodeSessionStatusChangeEventListener& listener);
 
    // Miscellaneous
    void SetDefaults();
 
    void WriteToFlash();
 
    Image CaptureSnapshot();
 
    // Standard properties of the Processing Unit
    Property<int16_t, CameraPropertyId::BRIGHTNESS> Brightness;
    PropertyAuto<int16_t, CameraPropertyId::CONTRAST> Contrast;
    Property<int16_t, CameraPropertyId::SATURATION> Saturation;
    Property<int16_t, CameraPropertyId::SHARPNESS> Sharpness;
    Property<int16_t, CameraPropertyId::GAMMA> Gamma;
    PropertyAuto<WhiteBalance, CameraPropertyId::WHITE_BALANCE_COMPONENT> WhiteBalanceComponent;
    Property<int16_t, CameraPropertyId::BACKLIGHT_COMPENSATION> BacklightCompensation;
    Property<int16_t, CameraPropertyId::GAIN> Gain;
 
    // Standard properties of the Camera Terminal
    PropertyAuto<uint32_t, CameraPropertyId::EXPOSURE_TIME_ABSOLUTE> AbsoluteExposureTime;
 
    // Extended properties
    PropertyEx<VideoMode, CameraPropertyId::VIDEO_MODE> VideoModeSetting;
    PropertyEx<IlluminationMode, CameraPropertyId::ILLUMINATION_MODE> IlluminationModeSetting;
    PropertyEx<PowerUserMode, CameraPropertyId::POWER_USER_MODE> PowerUserModeSetting;
 
private:
    ZebraCamera(std::unique_ptr<UvcDeviceAdapter> uvc_device_adapter);
    // Disable copy construction
    ZebraCamera(const ZebraCamera&) = delete;
 
    // Notify the observers of relevant image event.
    void DispatchContinuousImageEvent(ImageEventData image_data, ImageEventMetaData meta_data);
    void DispatchSnapshotImageEvent(ImageEventData image_data, ImageEventMetaData meta_data);
    void DispatchProduceImageEvent(ImageEventData image_data, ImageEventMetaData meta_data);
    void DispatchDecodeImageEvent(ImageEventData image_data, ImageEventMetaData meta_data);
 
    // Notify the observers of the decode session status change event.
    void DispatchDecodeSessionStatusChangeEvent(DecodeSessionStatus status);
 
    // Starts streaming if there are image event observers.
    void StartStreaming();
    // Stops streaming if there are no image event observers.
    void StopStreaming();
 
    std::string GetAssetTrackingPropertyValue(uint8_t property_id);
 
private:
    zebra::DeviceInfo camera_info_;
    std::unique_ptr<UvcDeviceAdapter> uvc_device_adapter_;
 
    std::mutex image_event_listeners_mutex_;
    std::vector<std::reference_wrapper<ContinuousImageEventListener>> continuous_image_listeners_;
    std::vector<std::reference_wrapper<SnapshotImageEventListener>> snapshot_image_listeners_;
    std::vector<std::reference_wrapper<ProduceImageEventListener>> produce_image_listeners_;
    std::vector<std::reference_wrapper<DecodeImageEventListener>> decode_image_listeners_;
 
    std::mutex session_status_event_listeners_mutex_;
    std::vector<std::reference_wrapper<DecodeSessionStatusChangeEventListener>> decode_session_status_change_listeners_;
 
    std::shared_ptr<VideoFrameSink> video_sink_;
};
 
} /* namespace camera_sdk */
} /* namespace zebra */
 
#endif /* ZEBRA_CAMERA_H_ */