VehicleCameraControl.h

#pragma once

#include "MavlinkCameraControlInterface.h"
#include "QmlObjectListModel.h"

class QGCVideoStreamInfo;
class QNetworkAccessManager;
class QDomNode;
class QDomNodeList;

//-----------------------------------------------------------------------------
/// Camera option exclusions
class QGCCameraOptionExclusion : public QObject
{
public:
    QGCCameraOptionExclusion(QObject* parent, QString param_, QString value_, QStringList exclusions_);
    QString param;
    QString value;
    QStringList exclusions;
};

//-----------------------------------------------------------------------------
/// Camera option ranges
class QGCCameraOptionRange : public QObject
{
public:
    QGCCameraOptionRange(QObject* parent, QString param_, QString value_, QString targetParam_, QString condition_, QStringList optNames_, QStringList optValues_);
    QString param;
    QString value;
    QString targetParam;
    QString condition;
    QStringList  optNames;
    QStringList  optValues;
    QVariantList optVariants;
};

/// MAVLink Camera API controller - connected to a real mavlink v2 camera
class VehicleCameraControl : public MavlinkCameraControlInterface
{
public:
    VehicleCameraControl(const mavlink_camera_information_t* info, Vehicle* vehicle, int compID, QObject* parent = nullptr);
    virtual ~VehicleCameraControl();

    Q_INVOKABLE virtual void setCameraModeVideo();
    Q_INVOKABLE virtual void setCameraModePhoto();
    Q_INVOKABLE virtual void toggleCameraMode       ();
    Q_INVOKABLE virtual bool takePhoto              ();
    Q_INVOKABLE virtual bool stopTakePhoto          ();
    Q_INVOKABLE virtual bool startVideoRecording    ();
    Q_INVOKABLE virtual bool stopVideoRecording     ();
    Q_INVOKABLE virtual bool toggleVideoRecording   ();
    Q_INVOKABLE virtual void resetSettings          ();
    Q_INVOKABLE virtual void formatCard             (int id = 1);
    Q_INVOKABLE virtual void stepZoom               (int direction);
    Q_INVOKABLE virtual void startZoom              (int direction);
    Q_INVOKABLE virtual void stopZoom               ();
    Q_INVOKABLE virtual void stopStream             ();
    Q_INVOKABLE virtual void resumeStream           ();
    Q_INVOKABLE virtual void startTrackingRect      (QRectF rec);
    Q_INVOKABLE virtual void startTrackingPoint     (QPointF point, double radius);
    Q_INVOKABLE virtual void stopTracking           ();

    virtual int         version             () const { return _version; }
    virtual QString     modelName           () const { return _modelName; }
    virtual QString     vendor              () const { return _vendor; }
    virtual QString     firmwareVersion     () const;
    virtual qreal       focalLength         () const { return static_cast<qreal>(_mavlinkCameraInfo.focal_length); }
    virtual QSizeF      sensorSize          () const { return QSizeF(static_cast<qreal>(_mavlinkCameraInfo.sensor_size_h), static_cast<qreal>(_mavlinkCameraInfo.sensor_size_v)); }
    virtual QSize       resolution          () const { return QSize(_mavlinkCameraInfo.resolution_h, _mavlinkCameraInfo.resolution_v); }
    virtual bool        capturesVideo       () const;
    virtual bool        capturesPhotos      () const;
    virtual bool        hasModes            () const { return _mavlinkCameraInfo.flags & CAMERA_CAP_FLAGS_HAS_MODES; }
    virtual bool        hasZoom             () const { return _mavlinkCameraInfo.flags & CAMERA_CAP_FLAGS_HAS_BASIC_ZOOM; }
    virtual bool        hasFocus            () const { return _mavlinkCameraInfo.flags & CAMERA_CAP_FLAGS_HAS_BASIC_FOCUS; }
    virtual bool        hasTracking         () const { return _hasTrackingRectCapability || _hasTrackingPointCapability; }
    virtual bool        supportsTrackingPoint() const { return _hasTrackingPointCapability; }
    virtual bool        supportsTrackingRect () const { return _hasTrackingRectCapability; }
    virtual bool        hasVideoStream      () const { return _mavlinkCameraInfo.flags & CAMERA_CAP_FLAGS_HAS_VIDEO_STREAM; }
    virtual bool        photosInVideoMode   () const { return _mavlinkCameraInfo.flags & CAMERA_CAP_FLAGS_CAN_CAPTURE_IMAGE_IN_VIDEO_MODE; }
    virtual bool        videoInPhotoMode    () const { return _mavlinkCameraInfo.flags & CAMERA_CAP_FLAGS_CAN_CAPTURE_VIDEO_IN_IMAGE_MODE; }
    virtual CaptureVideoState captureVideoState() const;
    virtual CapturePhotosState capturePhotosState() const;

    virtual int                 compID              () const { return _compID; }
    virtual bool                isBasic             () const { return _settings.size() == 0; }
    virtual StorageStatus       storageStatus       () const { return _storageStatus; }
    virtual QStringList         activeSettings      () const;
    virtual quint32             storageFree         () const { return _storageFree;  }
    virtual QString             storageFreeStr      () const;
    virtual quint32             storageTotal        () const { return _storageTotal; }
    virtual int                 batteryRemaining    () const { return _batteryRemaining; }
    virtual QString             batteryRemainingStr () const;
    virtual bool                paramComplete       () const { return _paramComplete; }
    virtual qreal               zoomLevel           () const { return _zoomLevel; }
    virtual qreal               focusLevel          () const { return _focusLevel; }

    virtual QmlObjectListModel* streams             () { return &_streams; }
    virtual QGCVideoStreamInfo* currentStreamInstance();
    virtual QGCVideoStreamInfo* thermalStreamInstance();
    virtual int                 currentStream       () const { return _currentStream; }
    virtual void                setCurrentStream    (int stream);
    virtual bool                autoStream          () const;
    virtual quint32             recordTime          () const { return _recordTime; }
    virtual QString             recordTimeStr       () const;

    virtual QStringList streamLabels        () const { return _streamLabels; }

    virtual ThermalViewMode thermalMode     () const { return _thermalMode; }
    virtual void        setThermalMode      (ThermalViewMode mode);
    virtual double      thermalOpacity      () const { return _thermalOpacity; }
    virtual void        setThermalOpacity   (double val);

    virtual void        setZoomLevel        (qreal level);
    virtual void        setFocusLevel       (qreal level);
    virtual void        setCameraMode(CameraMode cameraMode);
    virtual void        setPhotoCaptureMode        (PhotoCaptureMode mode);
    virtual void        setPhotoLapse       (qreal interval);
    virtual void        setPhotoLapseCount  (int count);

    virtual void        handleCameraSettings(const mavlink_camera_settings_t& settings);
    virtual void        handleCameraCaptureStatus(const mavlink_camera_capture_status_t& cameraCaptureStatus);
    virtual void        handleParamExtAck   (const mavlink_param_ext_ack_t& paramExtAck);
    virtual void        handleParamExtValue (const mavlink_param_ext_value_t& paramExtValue);
    virtual void        handleStorageInformation(const mavlink_storage_information_t& storageInformation);
    virtual void        handleBatteryStatus   (const mavlink_battery_status_t& bs);
    virtual void        handleBatteryStatusV2 (const mavlink_battery_status_v2_t& bs);
    virtual void        handleTrackingImageStatus(const mavlink_camera_tracking_image_status_t &trackingImageStatus);
    virtual void        handleVideoStreamInformation(const mavlink_video_stream_information_t &videoStreamInformation);
    virtual void        handleVideoStreamStatus(const mavlink_video_stream_status_t &videoStreamStatus);

    virtual bool        trackingEnabled     () const { return _trackingEnabled; }
    virtual void        setTrackingEnabled  (bool set);

    virtual bool trackingImageIsActive() const { return _trackingImageIsActive; }
    virtual bool trackingImageIsPoint() const { return _trackingImageIsPoint; }
    virtual QRectF trackingImageRect() const { return _trackingImageRect; }
    virtual QPointF trackingImagePoint() const { return _trackingImagePoint; }
    virtual qreal trackingImageRadius() const { return _trackingImageRadius; }

    virtual Fact*   exposureMode        ();
    virtual Fact*   ev                  ();
    virtual Fact*   iso                 ();
    virtual Fact*   shutterSpeed        ();
    virtual Fact*   aperture            ();
    virtual Fact*   wb                  ();
    virtual Fact*   mode                ();
    virtual void    factChanged         (Fact* pFact);
    virtual bool    incomingParameter   (Fact* pFact, QVariant& newValue);
    virtual bool    validateParameter   (Fact* pFact, QVariant& newValue);

    static constexpr const char* kCondition       = "condition";
    static constexpr const char* kControl         = "control";
    static constexpr const char* kDefault         = "default";
    static constexpr const char* kDefnition       = "definition";
    static constexpr const char* kDescription     = "description";
    static constexpr const char* kExclusion       = "exclude";
    static constexpr const char* kExclusions      = "exclusions";
    static constexpr const char* kLocale          = "locale";
    static constexpr const char* kLocalization    = "localization";
    static constexpr const char* kMax             = "max";
    static constexpr const char* kMin             = "min";
    static constexpr const char* kModel           = "model";
    static constexpr const char* kName            = "name";
    static constexpr const char* kOption          = "option";
    static constexpr const char* kOptions         = "options";
    static constexpr const char* kOriginal        = "original";
    static constexpr const char* kParameter       = "parameter";
    static constexpr const char* kParameterrange  = "parameterrange";
    static constexpr const char* kParameterranges = "parameterranges";
    static constexpr const char* kParameters      = "parameters";
    static constexpr const char* kReadOnly        = "readonly";
    static constexpr const char* kWriteOnly       = "writeonly";
    static constexpr const char* kRoption         = "roption";
    static constexpr const char* kStep            = "step";
    static constexpr const char* kDecimalPlaces   = "decimalPlaces";
    static constexpr const char* kStrings         = "strings";
    static constexpr const char* kTranslated      = "translated";
    static constexpr const char* kType            = "type";
    static constexpr const char* kUnit            = "unit";
    static constexpr const char* kUpdate          = "update";
    static constexpr const char* kUpdates         = "updates";
    static constexpr const char* kValue           = "value";
    static constexpr const char* kVendor          = "vendor";
    static constexpr const char* kVersion         = "version";

    static constexpr const char* kPhotoMode       = "PhotoCaptureMode";
    static constexpr const char* kPhotoLapse      = "PhotoLapse";
    static constexpr const char* kPhotoLapseCount = "PhotoLapseCount";
    static constexpr const char* kThermalOpacity  = "ThermalOpacity";
    static constexpr const char* kThermalMode     = "ThermalMode";

    //-----------------------------------------------------------------------------
    // Known Parameters
    static constexpr const char* kCAM_EV          = "CAM_EV";
    static constexpr const char* kCAM_EXPMODE     = "CAM_EXPMODE";
    static constexpr const char* kCAM_ISO         = "CAM_ISO";
    static constexpr const char* kCAM_SHUTTERSPD  = "CAM_SHUTTERSPD";
    static constexpr const char* kCAM_APERTURE    = "CAM_APERTURE";
    static constexpr const char* kCAM_WBMODE      = "CAM_WBMODE";
    static constexpr const char* kCAM_MODE        = "CAM_MODE";

protected:
    virtual void    _setVideoCaptureStatus  (VideoCaptureStatus captureStatus);
    virtual void    _setPhotoCaptureStatus  (PhotoCaptureStatus captureStatus);
    virtual void    _setCameraMode          (CameraMode mode);
    virtual void    _requestStreamInfo      (uint8_t streamID);
    virtual void    _requestStreamStatus    (uint8_t streamID);
    virtual void    _requestTrackingStatus  ();
    virtual QGCVideoStreamInfo* _findStream (uint8_t streamID, bool report = true);
    virtual QGCVideoStreamInfo* _findStream (const QString name);

protected slots:
    virtual void    _initWhenReady          ();
    virtual void    _requestCameraSettings  ();
    virtual void    _requestAllParameters   ();
    virtual void    _requestParamUpdates    ();
    virtual void    _requestCaptureStatus   ();
    virtual void    _requestStorageInfo     ();
    virtual void    _downloadFinished       ();
    virtual void    _mavCommandResult       (int vehicleId, int component, int command, int result, int failureCode);
    virtual void    _dataReady              (QByteArray data);
    virtual void    _paramDone              ();
    virtual void    _streamInfoTimeout      ();
    virtual void    _streamStatusTimeout    ();
    virtual void    _cameraSettingsTimeout  ();
    virtual void    _storageInfoTimeout     ();
    virtual void    _recTimerHandler        ();
    virtual void    _checkForVideoStreams   ();
    virtual void    _onVideoManagerRecordingChanged  (bool recording);

private:
    bool    _handleLocalization             (QByteArray& bytes);
    bool    _replaceLocaleStrings           (const QDomNode node, QByteArray& bytes);
    bool    _loadCameraDefinitionFile       (QByteArray& bytes);
    bool    _loadConstants                  (const QDomNodeList nodeList);
    bool    _loadSettings                   (const QDomNodeList nodeList);
    void    _processRanges                  ();
    bool    _processCondition               (const QString condition);
    bool    _processConditionTest           (const QString conditionTest);
    bool    _loadNameValue                  (QDomNode option, const QString factName, FactMetaData* metaData, QString& optName, QString& optValue, QVariant& optVariant);
    bool    _loadRanges                     (QDomNode option, const QString factName, QString paramValue);
    void    _updateActiveList               ();
    void    _updateRanges                   (Fact* pFact);
    void    _httpRequest                    (const QString& url);
    void    _handleDefinitionFile           (const QString& url);
    void    _ftpDownloadComplete            (const QString& fileName, const QString& errorMsg);

    QStringList     _loadExclusions         (QDomNode option);
    QStringList     _loadUpdates            (QDomNode option);
    QString         _getParamName           (const char* param_id);

protected:
    int                                 _compID             = 0;
    mavlink_camera_information_t        _mavlinkCameraInfo;
    int                                 _version            = 0;
    bool                                _cached             = false;
    bool                                _paramComplete      = false;
    qreal                               _zoomLevel          = 0.0;
    qreal                               _focusLevel         = 0.0;
    uint32_t                            _storageFree        = 0;
    uint32_t                            _storageTotal       = 0;
    int                                 _batteryRemaining   = -1;
    QNetworkAccessManager*              _netManager         = nullptr;
    QString                             _modelName;
    QString                             _vendor;
    QString                             _cacheFile;
    StorageStatus                       _storageStatus      = STORAGE_NOT_SUPPORTED;
    QStringList                         _activeSettings;
    QStringList                         _settings;
    QTimer                              _captureStatusTimer;
    QList<QGCCameraOptionExclusion*>    _valueExclusions;
    QList<QGCCameraOptionRange*>        _optionRanges;
    QMap<QString, QStringList>          _originalOptNames;
    QMap<QString, QVariantList>         _originalOptValues;
    QMap<QString, QGCCameraParamIO*>    _paramIO;
    int                                 _cameraSettingsRetries = 0;
    int                                 _cameraCaptureStatusRetries = 0;
    int                                 _storageInfoRetries = 0;
    int                                 _captureInfoRetries = 0;
    bool                                _resetting          = false;
    QTime                               _recTime;
    uint32_t                            _recordTime         = 0;
    //-- Parameters that require a full update
    QMap<QString, QStringList>          _requestUpdates;
    QStringList                         _updatesToRequest;
    //-- Video Streams
    int                                 _videoStreamInfoRetries   = 0;
    int                                 _videoStreamStatusRetries = 0;
    int                                 _requestCount       = 0;
    int                                 _currentStream      = 0;
    int                                 _expectedCount      = 1;
    QTimer                              _streamInfoTimer;
    QTimer                              _streamStatusTimer;
    QTimer                              _cameraSettingsTimer;
    QTimer                              _storageInfoTimer;
    QmlObjectListModel                  _streams;
    QStringList                         _streamLabels;
    ThermalViewMode                     _thermalMode        = THERMAL_BLEND;
    double                              _thermalOpacity     = 85.0;
    bool                                _hasTrackingRectCapability = false;
    bool                                _hasTrackingPointCapability = false;
    bool                                _trackingEnabled      = false;
    bool                                    _trackingImageIsActive = false;
    bool                                    _trackingImageIsPoint = false;
    mavlink_camera_tracking_image_status_t  _trackingImageStatus{};
    QRectF                                  _trackingImageRect;
    QPointF                                 _trackingImagePoint;
    qreal                                   _trackingImageRadius = 0.0;
};