AampEvent.h

Go to the documentation of this file.

/*
 * If not stated otherwise in this file or this component's license file the
 * following copyright and licenses apply:
 *
 * Copyright 2018 RDK Management
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
*/
 
/**
 * @file AampEvent.h
 * @brief Events supported by the AAMP player.
 */
 
#ifndef __AAMP_EVENTS_H__
#define __AAMP_EVENTS_H__
 
#include "vttCue.h" //Required for VTTCue
#include <memory>
#include <vector>
 
// Macros required for backward compatible AAMPEventListener implementation
#define MAX_LANGUAGE_COUNT 16
#define MAX_LANGUAGE_TAG_LENGTH 42 // <lang>-<role>
//(3+1+1) /* iso639-2 + optional 2..9 digit to disambiguate multiple same-language tracms, + nul terminator */
 
#define MAX_BITRATE_COUNT 10
#define MAX_SUPPORTED_SPEED_COUNT 12 /* [-64, -32, -16, -4, -1, 0, 0.5, 1, 4, 16, 32, 64] */
 
/**
 * @enum AAMPEventType 
 * @brief Type of the events sending to the JSPP player.
 */
typedef enum
{
        AAMP_EVENT_ALL_EVENTS = 0,              /**< 0,  All Events */
        AAMP_EVENT_TUNED = 1,                   /**< 1,  Tune success*/
        AAMP_EVENT_TUNE_FAILED,                 /**< 2,  Tune failure*/
        AAMP_EVENT_SPEED_CHANGED,               /**< 3,  Speed changed internally*/
        AAMP_EVENT_EOS,                         /**< 4,  End of stream*/
        AAMP_EVENT_PLAYLIST_INDEXED,            /**< 5,  Playlist downloaded and indexed*/
        AAMP_EVENT_PROGRESS,                    /**< 6,  Progress event with playback stats. Report interval configurable */
        AAMP_EVENT_CC_HANDLE_RECEIVED,          /**< 7,  Sent when video decoder handle retrieved */
        AAMP_EVENT_JS_EVENT,                    /**< 8,  Generic event generated by JavaScript binding */
        AAMP_EVENT_MEDIA_METADATA,              /**< 9,  Meta-data of asset currently playing*/
        AAMP_EVENT_ENTERING_LIVE,               /**< 10, Event when live point reached*/
        AAMP_EVENT_BITRATE_CHANGED,             /**< 11, Event when bitrate changes */
        AAMP_EVENT_TIMED_METADATA,              /**< 12, Meta-data of a subscribed tag parsed from manifest*/
        AAMP_EVENT_BULK_TIMED_METADATA,         /**< 13, Bulk Meta-data of a subscribed tag parsed from manifest*/
        AAMP_EVENT_STATE_CHANGED,               /**< 14, Event when player state changes */
        AAMP_EVENT_SPEEDS_CHANGED,              /**< 15, Event when supported playback speeds changes */
        AAMP_EVENT_SEEKED,                      /**< 16, Event when seek completes, including new position*/
        AAMP_EVENT_TUNE_PROFILING,              /**< 17, Event when micro event data sends*/
        AAMP_EVENT_BUFFERING_CHANGED,           /**< 18, Event when buffering starts/ends btw a playback*/
        AAMP_EVENT_DURATION_CHANGED,            /**< 19, Event when duration changed */
        AAMP_EVENT_AUDIO_TRACKS_CHANGED,        /**< 20, Event when available audio tracks changes */
        AAMP_EVENT_TEXT_TRACKS_CHANGED,         /**< 21, Event when available test tracks changes */
        AAMP_EVENT_AD_BREAKS_CHANGED,           /**< 22, Event when content/ad breaks changes */
        AAMP_EVENT_AD_STARTED,                  /**< 23, Ad playback started */
        AAMP_EVENT_AD_COMPLETED,                /**< 24, Ad playback completed */
        AAMP_EVENT_DRM_METADATA,                /**< 25, Event with DRM metadata info*/
        AAMP_EVENT_REPORT_ANOMALY,              /**< 26, Playback Anomaly reporting */
        AAMP_EVENT_WEBVTT_CUE_DATA,             /**< 27, WebVTT Cue data */
        AAMP_EVENT_AD_RESOLVED,                 /**< 28, Ad fulfill status */
        AAMP_EVENT_AD_RESERVATION_START,        /**< 29, Adbreak playback starts */
        AAMP_EVENT_AD_RESERVATION_END,          /**< 30, Adbreak playback ends */
        AAMP_EVENT_AD_PLACEMENT_START,          /**< 31, Ad playback starts */
        AAMP_EVENT_AD_PLACEMENT_END,            /**< 32, Ad playback ends */
        AAMP_EVENT_AD_PLACEMENT_ERROR,          /**< 33, Ad playback error */
        AAMP_EVENT_AD_PLACEMENT_PROGRESS,       /**< 34, Ad playback progress */
        AAMP_EVENT_REPORT_METRICS_DATA,         /**< 35, AAMP VideoEnd info reporting */
        AAMP_EVENT_ID3_METADATA,                /**< 36, ID3 metadata from audio stream */
        AAMP_EVENT_DRM_MESSAGE,                 /**< 37, Message from the DRM system */
        AAMP_EVENT_BLOCKED,                     /**< 38, ATSC AV BLOCKED Event*/
        AAMP_EVENT_CONTENT_GAP,                 /**< 39, Content gap event for progress gap reporting*/
        AAMP_EVENT_HTTP_RESPONSE_HEADER,        /**< 40, Http response header data */
        AAMP_EVENT_WATERMARK_SESSION_UPDATE,    /**< 41, Update on Watermark Session*/
        AAMP_EVENT_CONTENT_PROTECTION_DATA_UPDATE,      /**< 42, Update on Content Protection Data on Dynamic Key Rotation*/
        AAMP_MAX_NUM_EVENTS
} AAMPEventType;
 
 
/**
 * @enum AAMPEventMode
 * @brief AAMP event modes
 */
typedef enum
{
        AAMP_EVENT_DEFAULT_MODE = 0, /**< Aamp Default event mode */
        AAMP_EVENT_SYNC_MODE,        /**< Events handled in sync mode */
        AAMP_EVENT_ASYNC_MODE        /**< Events handled in Async mode */
}AAMPEventMode;
 
/**
 * @enum AAMPTuneFailure
 * @brief AAMP playback error codes
 */
typedef enum
{
        AAMP_TUNE_INIT_FAILED,                             /**< Tune failure due to initialization error*/
        AAMP_TUNE_INIT_FAILED_MANIFEST_DNLD_ERROR,         /**< Tune failure due to manifest download error*/
        AAMP_TUNE_INIT_FAILED_MANIFEST_CONTENT_ERROR,      /**< Tune failure due to manifest content error*/
        AAMP_TUNE_INIT_FAILED_MANIFEST_PARSE_ERROR,        /**< Tune failure due to manifest parse error*/
        AAMP_TUNE_INIT_FAILED_PLAYLIST_VIDEO_DNLD_ERROR,   /**< Tune failure due to video playlist download error*/
        AAMP_TUNE_INIT_FAILED_PLAYLIST_AUDIO_DNLD_ERROR,   /**< Tune failure due to audio playlist download error*/
        AAMP_TUNE_INIT_FAILED_TRACK_SYNC_ERROR,            /**< Tune failure due to A/V track sync error*/
        AAMP_TUNE_MANIFEST_REQ_FAILED,                     /**< Tune failure caused by manifest fetch failure*/
        AAMP_TUNE_AUTHORISATION_FAILURE,                   /**< Not authorised to view the content*/
        AAMP_TUNE_FRAGMENT_DOWNLOAD_FAILURE,               /**< When fragment download fails for 5 consecutive fragments*/
        AAMP_TUNE_INIT_FRAGMENT_DOWNLOAD_FAILURE,          /**< Unable to download init fragment*/
        AAMP_TUNE_UNTRACKED_DRM_ERROR,                     /**< DRM error*/
        AAMP_TUNE_DRM_INIT_FAILED,                         /**< DRM initialization failure */
        AAMP_TUNE_DRM_DATA_BIND_FAILED,                    /**< InitData binding with DRM failed */
        AAMP_TUNE_DRM_SESSIONID_EMPTY,                     /**< DRM session ID empty */
        AAMP_TUNE_DRM_CHALLENGE_FAILED,                    /**< DRM key request challenge generation failed */
        AAMP_TUNE_LICENCE_TIMEOUT,                         /**< DRM license request timeout */
        AAMP_TUNE_LICENCE_REQUEST_FAILED,                  /**< DRM license got invalid response */
        AAMP_TUNE_INVALID_DRM_KEY,                         /**< DRM reporting invalid license key */
        AAMP_TUNE_UNSUPPORTED_STREAM_TYPE,                 /**< Unsupported stream type */
        AAMP_TUNE_UNSUPPORTED_AUDIO_TYPE,                  /**< Unsupported audio type in manifest */
        AAMP_TUNE_FAILED_TO_GET_KEYID,                     /**< Failed to parse key id from init data*/
        AAMP_TUNE_FAILED_TO_GET_ACCESS_TOKEN,              /**< Failed to get session token from AuthService*/
        AAMP_TUNE_CORRUPT_DRM_DATA,                        /**< DRM failure due to corrupt drm data, self heal might clear further errors*/
        AAMP_TUNE_CORRUPT_DRM_METADATA,                    /**< DRM failure due to corrupt drm metadata in the stream*/
        AAMP_TUNE_DRM_DECRYPT_FAILED,                      /**< DRM Decryption Failed for Fragments */
        AAMP_TUNE_DRM_UNSUPPORTED,                         /**< DRM Format Unsupported */
        AAMP_TUNE_DRM_SELF_ABORT,                          /**< Download activity is aborted by player */
        AAMP_TUNE_GST_PIPELINE_ERROR,                      /**< Playback failure due to error from GStreamer pipeline or associated plugins */
        AAMP_TUNE_PLAYBACK_STALLED,                        /**< Playback was stalled due to valid fragments not available in playlist */
        AAMP_TUNE_CONTENT_NOT_FOUND,                       /**< The resource was not found at the URL provided (HTTP 404) */
        AAMP_TUNE_DRM_KEY_UPDATE_FAILED,                   /**< Failed to process DRM key, see the error code returned from Update() for more info */
        AAMP_TUNE_DEVICE_NOT_PROVISIONED,                  /**< STB not provisioned/corrupted; need to re-provision. */
        AAMP_TUNE_HDCP_COMPLIANCE_ERROR,                   /**< HDCP Compliance Check failure.Not compatible hdcp version for playback */
        AAMP_TUNE_INVALID_MANIFEST_FAILURE,                /**< Manifest is invalid */
        AAMP_TUNE_FAILED_PTS_ERROR,                        /**< Playback failed due to PTS error */
        AAMP_TUNE_MP4_INIT_FRAGMENT_MISSING,               /**< Init fragments missing in playlist */
        AAMP_TUNE_FAILURE_UNKNOWN                          /**<  Unknown failure */
} AAMPTuneFailure;
 
/**
 * @enum PrivAAMPState
 * @brief  Mapping all required status codes based on JS player requirement. These requirements may be
 * forced by psdk player.AAMP may not use all the statuses mentioned below:
 * Mainly required states - idle, initializing, initialized, preparing, prepared, playing, paused, seek, complete and error
 */
typedef enum
{
        eSTATE_IDLE,         /**< 0  - Player is idle */
        eSTATE_INITIALIZING, /**< 1  - Player is initializing a particular content */
        eSTATE_INITIALIZED,  /**< 2  - Player has initialized for a content successfully */
        eSTATE_PREPARING,    /**< 3  - Player is loading all associated resources */
        eSTATE_PREPARED,     /**< 4  - Player has loaded all associated resources successfully */
        eSTATE_BUFFERING,    /**< 5  - Player is in buffering state */
        eSTATE_PAUSED,       /**< 6  - Playback is paused */
        eSTATE_SEEKING,      /**< 7  - Seek is in progress */
        eSTATE_PLAYING,      /**< 8  - Playback is in progress */
        eSTATE_STOPPING,     /**< 9  - Player is stopping the playback */
        eSTATE_STOPPED,      /**< 10 - Player has stopped playback successfully */
        eSTATE_COMPLETE,     /**< 11 - Playback completed */
        eSTATE_ERROR,        /**< 12 - Error encountered and playback stopped */
        eSTATE_RELEASED,     /**< 13 - Player has released all resources for playback */
        eSTATE_BLOCKED       /**< 14 - Player has blocked and cant play content*/
} PrivAAMPState;
 
/**
 * @enum MetricsDataType
 * @brief AAMP metric data types
 */
typedef enum E_MetricsDataType
{
        AAMP_DATA_NONE,
        AAMP_DATA_VIDEO_END
} MetricsDataType;
 
/**
 * @enum VideoScanType Video Scan Type
 *
 * @brief VideoScanType - Progressive/Interlaced
 * */
typedef enum
{
        eVIDEOSCAN_PROGRESSIVE, /**< Progressive Video */
        eVIDEOSCAN_INTERLACED,  /**< Interlaced Video */
        eVIDEOSCAN_UNKNOWN      /**< Unknown Video */
}VideoScanType;
 
/**
 * @struct AAMPEvent
 * @brief Structure of the AAMP events.
 * Recommend new AAMP integration layers to use AAMPEventObject based listener
 * For new event definition, should use AAMPEventObject class
 * TODO: Deperecate in future, kept for backward compatibility only
 */
struct AAMPEvent
{
        AAMPEventType type;             /**< Event type */
 
        union
        {
                struct
                {
                        int severity;   /**< informative number indicates severity of msg, e.g Warning, Error, Trace etc */
                        const char *msg;
                } anomalyReport;
 
                struct
                {
                        const char *microData;   /**< micro event data for profiling */
                } tuneProfile;
 
                struct
                {
                        MetricsDataType type;           /**< type of data , e.g AAMP_DATA_VIDEO_END for VideoEndEvent data */
                        const char *metricUUID;         /**< unique session id passed during tune */
                        const char *data;               /**< data for event  */
                } metricsData;
 
                /**
                 * @brief Structure of the progress event data
                 */
                struct
                {
                        double durationMiliseconds;             /**< current size of time shift buffer */
                        double positionMiliseconds;             /**< current play/pause position relative to tune time - starts at zero) */
                        float playbackSpeed;                    /**< current trick speed (1.0 for normal play rate) */
                        double startMiliseconds;                /**< time shift buffer start position (relative to tune time - starts at zero) */
                        double endMiliseconds;                  /**< time shift buffer end position (relative to tune time - starts at zero) */
                        long long videoPTS;                     /**< Video Presentation 90 Khz time-stamp  */
                        double videoBufferedMiliseconds;        /**< current duration of buffered video ready to playback */
                        const char* timecode;                   /**< SEI Timecode information */
                } progress;
 
                /**
                 * @brief Structure of the seeked event data
                 */
                struct
                {
                        double positionMiliseconds;     /**< new seeked position in milliseconds */
                } seeked;
 
                /**
                 * @brief Structure of the speed change event
                 */
                struct
                {
                        float rate; /**< Playback rate */
                } speedChanged;
 
                /**
                 * @brief Structure of the bitrate change event
                 */
                struct
                {
                        int time;                   /**< Playback time */
                        long bitrate;               /**< Playback bitrate */
                        const char *description;    /**< Description */
                        int width;                  /**< Video width */
                        int height;                 /**< Video height */
                        double framerate;           /**< FrameRate */
                        double position;            /**< bitrate changed position*/
                        bool cappedProfile;         /**< profile capped status*/
                        int displayWidth;           /**< output display width*/
                        int displayHeight;          /**< output display height*/
                        VideoScanType videoScanType;/**< video scan type*/
                        int aspectRatioWidth;       /**< aspect ratio width*/
                        int aspectRatioHeight;      /**< aspect ratio height*/
                } bitrateChanged;
 
                /**
                 * @brief Structure of the metadata event
                 */
                struct
                {
                        long durationMiliseconds;                                       /**< Asset duration */
                        int languageCount;                                              /**< Available language count */
                        char languages[MAX_LANGUAGE_COUNT][MAX_LANGUAGE_TAG_LENGTH];    /**< Available languages */
                        int bitrateCount;                                               /**< Available bitrate count */
                        long bitrates[MAX_BITRATE_COUNT];                               /**< Available bitrates */
                        int width;                                                      /**< Maximum video width */
                        int height;                                                     /**< Maximum video height */
                        bool hasDrm;                                                    /**< Drm enabled */
                        int supportedSpeedCount;                                        /**< Supported playback speed count */
                        float supportedSpeeds[MAX_SUPPORTED_SPEED_COUNT];                 /**< Supported playback speeds */
                        double programStartTime;                                        /**< Program/Availability start time */
                } metadata;
 
                /**
                 * @brief Structure of the closed caption handle event
                 */
                struct
                {
                        unsigned long handle;   /**< Closed caption handle */
                } ccHandle;
 
                /**
                 * @brief Structure of the timed metadata event
                 */
                struct
                {
                        const char* szName;         /**< Metadata name */
                        const char* id;             /**< Id of the timedMetadata */
                        long long timeMilliseconds; /**< Playback position - relative to tune time - starts at zero */
                        double durationMilliSeconds;/**< Duration of the timed event. */
                        const char* szContent;      /**< Metadata content */
                } timedMetadata;
 
                /**
                 * @brief Structure of the bulk timed metadata event
                 */
                struct
                {
                        const char* szMetaContent;      /**< Metadata content */
                } bulktimedMetadata;
 
                /**
                 * @brief Structure of the Java Script event
                 */
                struct
                {
                        const char* szEventType;    /**< Event Type */
                        void*  jsObject;            /**< Pointer to the Java Scipt Object */
                } jsEvent;
 
                /**
                 * @brief Structure of the media error event
                 */
                struct
                {
                        AAMPTuneFailure failure;                            /**< Error Type */
                        int code;                                           /**< Error code */
                        const char *description;                            /**< Error description */
                        bool shouldRetry;                                   /**< If recovery on retry is possible */
                        int32_t classCode; /**< class Code */
                        int32_t reasonCode; /**<reason Code */
                        int32_t businessStatus; /**< business Status */
        
                } mediaError;
 
                struct
                {
                        AAMPTuneFailure failure;                            /**< Error Type */
                        const char *accessStatus;
                        int accessStatus_value;
                        long responseCode;
                        bool isSecClientError;
                } dash_drmmetadata;
 
                /**
                 * @brief Structure of the player state changed event
                 */
                struct
                {
                        PrivAAMPState state;        /**< Player state */
                } stateChanged;
 
                /**
                 * @brief Structure of the buffering changed event
                 */
                struct
                {
                        bool buffering;            /**< true if buffering started, false otherwise */
                } bufferingChanged;
 
                /**
                 * @brief Structure of the supported speeds changed event
                 */
                struct
                {
                        int supportedSpeedCount;                            /**< Supported playback speed count */
                        float supportedSpeeds[MAX_SUPPORTED_SPEED_COUNT];     /**< Supported playback speeds */
                } speedsChanged;
 
                /**
                 * @brief Structure of the WebVTT cue data
                 */
                struct
                {
                        VTTCue* cueData;
                } cue;
 
                /**
                 * @brief Structure for ad fulfill status event
                 */
                struct
                {
                        bool resolveStatus;
                        const char *adId;
                        uint64_t startMS;
                        uint64_t durationMs;
                } adResolved;
 
                /**
                 * @brief Structure for ad reservation events
                 */
                struct
                {
                        const char *adBreakId;     /**< Reservation Id */
                        uint64_t position;
                } adReservation;
 
                /**
                 * @brief Structure for ad placement events
                 */
                struct
                {
                        const char *adId;               /**< Placement Id */
                        uint32_t position;              /**<Ad Position relative to Reservation Start */
                        uint32_t offset;                /**<Ad start offset */
                        uint32_t duration;
                        int errorCode;
                } adPlacement;
 
                /** @brief Structure of the id3 metadata event
                 */
                struct
                {
                        uint8_t *data;           /**< Data pointer to ID3 metadata blob */
                        int32_t length;          /**< Length of the ID3 metadata blob */
                } id3Metadata;
 
                struct
                {
                        const char *data;
                } drmMessage;
 
                struct
                {
                        long long timeMilliseconds;     /**< Playback position - relative to tune time - starts at zero */
                        double durationMilliSeconds;    /**< Duration of the gap */
                } contentGap;
 
                /**
                 * @brief Structure of the http response header event
                 */
                struct
                {
                        const char* header;         /**< HTTP header name */
                        const char* response;       /**< HTTP response value */
                } httpResponseHeader;
 
                /**
                 * @brief Structure of the content protection data update event
                */
                struct
                {
                        uint8_t *keyID;                 /**< Session KeyID */
                        const char* streamType;         /**< Session StreamType */
                } contentProtectionData;
 
        } data;
 
        /**
         * @brief AAMPEvent Constructor
         */
        AAMPEvent() : type(AAMP_MAX_NUM_EVENTS), data()
        {
 
        }
 
        /**
         * @brief AAMPEvent Constructor
         *
         * @param[in] t Event type
         */
        AAMPEvent(AAMPEventType t) : type(t), data()
        {
 
        }
        /**
         * @brief Copy constructor disabled
         *
         */
        AAMPEvent(const AAMPEvent&) = delete;
        /**
         * @brief assignment operator disabled
         *
         */
        AAMPEvent& operator=(const AAMPEvent&) = delete;
};
 
/**
 * @brief Base class of all AAMP events.
 * New AAMP event object for ease of use
 * While defining new event objects inherit from this base class
 */
class AAMPEventObject
{
        AAMPEventType mType;            /**< Event type */
 
public:
 
        AAMPEventObject() = delete;
        /**
         * @brief Copy constructor disabled
         *
         */
        AAMPEventObject(const AAMPEventObject&) = delete;
        /**
         * @brief assignment operator disabled
         *
         */
        AAMPEventObject& operator=(const AAMPEventObject&) = delete;
 
        /**
         * @fn AAMPEventObject
         */      
        AAMPEventObject(AAMPEventType type);
 
        /**
         * @brief AAMPEvent Destructor
         */
        virtual ~AAMPEventObject() { }
 
        /**
         * @fn getType
         */
        AAMPEventType getType() const;
};
 
/**
 * @class MediaErrorEvent
 * @brief Class for the Media Error event
 */
class MediaErrorEvent: public AAMPEventObject
{
        AAMPTuneFailure mFailure;       /**< Error Type */
        int mCode;                      /**< Error code */
        std::string mDescription;       /**< Error description */
        bool mShouldRetry;              /**< If recovery on retry is possible */
        
        int32_t mSecManagerClass;       /**< Secmanager error class */
        int32_t mSecManagerReasonCode; /**< Secmanager reason  code */
        int32_t mBusinessStatus;        /**< secclient business reason  code */
 
public:
        MediaErrorEvent() = delete;
        MediaErrorEvent(const MediaErrorEvent&) = delete;
        MediaErrorEvent& operator=(const MediaErrorEvent&) = delete;
 
        /**
         * @fn MediaErrorEvent
         *
         * @param[in] failure     - Failure type
         * @param[in] code        - Error code
         * @param[in] desc        - Error description
         * @param[in] shouldRetry - Retry or not
         */
        MediaErrorEvent(AAMPTuneFailure failure, int code, const std::string &desc, bool shouldRetry, int32_t classCode, int32_t reason, int32_t businessStatus);
 
        /**
         * @brief MediaErrorEvent Destructor
         */
        virtual ~MediaErrorEvent() { }
 
        /**
         * @fn getFailure
         */
        AAMPTuneFailure getFailure() const;
 
        /**
         * @fn getCode
         */
        int getCode() const;
 
        /**
         * @fn getDescription
         */
        const std::string &getDescription() const;
 
        /**
         * @fn shouldRetry
         */      
        bool shouldRetry() const;
        
        /**
         * @fn getClass
         */
        int32_t getClass() const;
        
        /**
         * @fn getReason
         */
        int32_t getReason() const;
        
        /**
         * @fn getBusinessStatus
         */
        int32_t getBusinessStatus() const;
};
 
/**
 * @class SpeedChangedEvent
 * @brief Class for the Speed changed event
 */
class SpeedChangedEvent: public AAMPEventObject
{
        float mRate;            /**< Playback rate */
 
public:
        SpeedChangedEvent() = delete;
        SpeedChangedEvent(const SpeedChangedEvent&) = delete;
        SpeedChangedEvent& operator=(const SpeedChangedEvent&) = delete;
 
        /**
         * @fn SpeedChangedEvent
         *
         * @param[in]  rate - New speed
         */
        SpeedChangedEvent(float rate);
 
        /**
         * @brief SpeedChangedEvent Destructor
         */
        virtual ~SpeedChangedEvent() { }
 
        /**
         * @fn getRate
         */
        float getRate() const;
};
 
/**
 * @class ProgressEvent
 * @brief Class for the Progress event
 */
class ProgressEvent: public AAMPEventObject
{
        double mDuration;               /**< current size of time shift buffer in MS*/
        double mPosition;               /**< current play/pause position relative to tune time - starts at zero) in MS */
        double mStart;                  /**< time shift buffer start position (relative to tune time - starts at zero) in MS */
        double mEnd;                    /**< time shift buffer end position (relative to tune time - starts at zero) in MS */
        float mSpeed;                   /**< current trick speed (1.0 for normal play rate) */
        long long mPTS;                 /**< Video Presentation 90 Khz time-stamp  */
        double mBufferedDuration;       /**< current duration of buffered video ready to playback */
        std::string mSEITimecode;       /**< SEI Timecode information */
 
public:
        ProgressEvent() = delete;
        ProgressEvent(const ProgressEvent&) = delete;
        ProgressEvent& operator=(const ProgressEvent&) = delete;
 
        /**
         * @fn ProgressEvent
         *
         * @param[in]  duration - Duration of Asset
         * @param[in]  position - Current Position
         * @param[in]  start    - Start Position
         * @param[in]  end      - End Position
         * @param[in]  speed    - Current Speed
         * @param[in]  pts      - Video PTS
         * @param[in]  bufferedDuration - buffered duration
         */
        ProgressEvent(double duration, double position, double start, double end, float speed, long long pts, double bufferedDuration, std::string seiTimecode);
 
        /**
         * @brief ProgressEvent Destructor
         */
        virtual ~ProgressEvent() { }
 
        /**
         * @fn getDuration
         */
        double getDuration() const;
 
        /**
         * @fn getPosition
         *
         */
        double getPosition() const;
 
        /**
         * @fn getStart
         *
         */
        double getStart() const;
 
        /**
         * @fn getEnd
         */
        double getEnd() const;
 
        /**
         * @fn getSpeed
         */
        float getSpeed() const;
 
        /**
         * @fn getPTS
         *
         */
        long long getPTS() const;
 
        /**
         * @fn getBufferedDuration
         */
        double getBufferedDuration() const;
 
        /**
         * @fn getSEITimeCode
         */
        const char* getSEITimeCode() const;
};
 
/**
 * @class CCHandleEvent
 * @brief Class for the Closed Caption Handle event
 */
class CCHandleEvent: public AAMPEventObject
{
        unsigned long mHandle;          /**< Closed caption handle */
 
public:
        CCHandleEvent() = delete;
        CCHandleEvent(const CCHandleEvent&) = delete;
        CCHandleEvent& operator=(const CCHandleEvent&) = delete;
 
        /**
         * @fn CCHandleEvent
         */
        CCHandleEvent(unsigned long handle);
 
        /**
         * @brief CCHandleEvent Destructor
         */
        virtual ~CCHandleEvent() { }
 
        /**
         * @fn getCCHandle
         */
        unsigned long getCCHandle() const;
};
 
/**
 * @class MediaMetadataEvent
 * @brief Class for the Media Metadata event
 */
class MediaMetadataEvent: public AAMPEventObject
{
        long mDuration;                     /**< Asset duration in MS */
        std::vector<std::string> mLanguages;/**< Available languages */
        std::vector<long> mBitrates;        /**< Available bitrates */
        int mWidth;                         /**< Maximum video width */
        int mHeight;                        /**< Maximum video height */
        bool mHasDrm;                       /**< Drm enabled */
        std::vector<float> mSupportedSpeeds;  /**< Supported playback speeds */
        bool mIsLive;                       /**< Is Live */
        std::string mDrmType;               /**< DRM type */
        double mProgramStartTime;           /**< Program/Availability start time */
 
        /* Additional data from ATSC playback  */
        std::string mPCRating;          /**< Parental control rating json string object  */
        int mSsi;                       /**<  Signal strength indicator 0-100 where 100 is a perfect signal. -1 indicates data not available  */
        /* Video info   */
        float mFrameRate;               /**< FrameRate */
        VideoScanType mVideoScanType;   /**< Video Scan Type progressive/interlaced */
        int mAspectRatioWidth;          /**< Aspect Ratio Width*/
        int mAspectRatioHeight;         /**< Aspect Ratio Height*/
        std::string mVideoCodec;        /**<  VideoCodec - E.g MPEG2.*/
        std::string mHdrType;           /**< type of HDR being played, in example "DOLBY_VISION" */
        std::string mMediaFormatName;   /*< Media format type */
 
        /* Audio Info   */
        std::vector<long> mAudioBitrates;         /**< Available Audio bitrates */
        std::string mAudioCodec;                  /**< AudioCodec E.g AC3.*/
        std::string mAudioMixType;                /**<  AudioMixType(- E.g STEREO. */
        bool  isAtmos;                            /**<  Is Atmos : 1 - True if audio playing is Dolby Atmos, 0 false ,  -1 indicates data not available */
 
public:
        MediaMetadataEvent() = delete;
        MediaMetadataEvent(const MediaMetadataEvent&) = delete;
        MediaMetadataEvent& operator=(const MediaMetadataEvent&) = delete;
 
        /**
         * @fn MediaMetadataEvent
         *
         * @param[in] duration - Duration of Media Metadata
         * @param[in] width    - Video width
         * @param[in] height   - Video height
         * @param[in] hasDrm   - Drm enablement status
         * @param[in] isLive   - Is Live
         * @param[in] DrmType  - DRM Type
         * @param[in] programStartTime  - Program/Availability start time
         */
        MediaMetadataEvent(long duration, int width, int height, bool hasDrm, bool isLive, const std::string &DrmType, double programStartTime);
 
        /**
         * @brief MediaMetadataEvent Destructor
         */
        virtual ~MediaMetadataEvent() { }
 
        /**
         * @fn getDuration
         */     
        long getDuration() const;
 
        /**
         * @fn getProgramStartTime
         */
        double getProgramStartTime() const;
 
        /**
         * @fn addLanguage
         *
         * @param[in] lang - Supported language
         * @return void
         */
        void addLanguage(const std::string &lang);
 
        /**
         * @fn getLanguages
         */
        const std::vector<std::string> &getLanguages() const;
 
        /**
         * @fn getLanguagesCount
         */
        int getLanguagesCount() const;
 
        /**
         * @fn addBitrate
         *
         * @param[in] bitrate - Supported bitrate
         * @return void
         */
        void addBitrate(long bitrate);
 
        /**
         * @fn getBitrates
         */
        const std::vector<long> &getBitrates() const;
 
        /**
         * @fn getBitratesCount
         */
        int getBitratesCount() const;
 
        /**
         * @fn getWidth
         */
        int getWidth() const;
 
        /**
         * @fn getHeight
         */
        int getHeight() const;
 
        /**
         * @fn hasDrmt
         */
        bool hasDrm() const;
 
        /**
         * @fn isLive
         */
        bool isLive() const;
 
        /**
         * @fn getDrmType
         */
        const std::string &getDrmType() const;
 
        /**
         * @fn addSupportedSpeed
         *
         * @param[in] speed - Supported speed
         * @return void
         */
        void addSupportedSpeed(float speed);
 
        /**
         * @fn getSupportedSpeeds
         */
        const std::vector<float> &getSupportedSpeeds() const;
 
        /**
         * @fn getSupportedSpeedCount
         */
        int getSupportedSpeedCount() const;
 
        /**
         * @fn SetVideoMetaData
         *
         * @param[in] mFrameRate - video framerate
         * @param[in] videoScanType   - Scan Type progressive/interlaced
         * @param[in] aspectRatioWidth   - Aspect Ratio Width
         * @param[in] aspectRatioHeight   - Aspect Ratio Height
         * @param[in] strVideoCodec  - VideoCodec(v1) - E.g MPEG2.
         * @param[in] strHdrType  - type of HDR being played, in example "DOLBY_VISION"
         * @param[in] strPCRating  - Parental control rating json string object
         * @param[int] ssi  - Signal strength indicator 0-100 where 100 is a perfect signal. -1 indicates data not available
         */
        void SetVideoMetaData(float frameRate,VideoScanType videoScanType,int aspectRatioWidth,int  aspectRatioHeight, const std::string &videoCodec, const std::string  & hdrType, const std::string & pcRating, int ssi);
 
        /**
         * @fn getAudioBitrates
         */
        const std::vector<long> &getAudioBitrates() const { return mAudioBitrates; }
 
        /**
         * @brief Sets additional metadata for Audio
         *
         * @param[in] strAudioCodec   - AudioCodec - E.g AC3.
         * @param[in] strMixType   - AudioMixType - E.g STEREO.
         * @param[in] iAtmos   - 1 - True if audio playing is Dolby Atmos, 0 false ,  -1 indicates data not available
         */
        void SetAudioMetaData(const std::string &audioCodec,const std::string & mixType,bool  isAtmos );
 
        /**
         * @brief Add a supported bitrate
         *
         * @param[in] bitrate - Supported bitrate
         * @return void
         */
        void addAudioBitrate(long bitrate) { return mAudioBitrates.push_back(bitrate); }
 
        /**
         * @brief get Parental control ratings
         *
         * @return ratings string
         */
        const std::string & getRatings() const { return mPCRating;}
 
        /**
         * @brief get Signal strength indicator
         *
         * @return ratings string
         */
        int getSsi() const { return mSsi;}
 
        /**
         * @brief get framerate
         *
         * @return ratings string
         */
        float getFrameRate() const {return mFrameRate;}
 
        /**
         * @brief Get VideoScanType
         *
         * @return VideoScanType
         */
        VideoScanType getVideoScanType() const { return mVideoScanType;}
 
        /**
         * @brief Get AspectRatioWidth
         *
         * @return AspectRatioWidth
         */
        int getAspectRatioWidth() const { return mAspectRatioWidth;}
 
        /**
         * @brief Get AspectRatioHeight
         *
         * @return AspectRatioHeight
         */
        int getAspectRatioHeight() const { return mAspectRatioHeight;}
 
        /**
         * @brief Get VideoCodec
         *
         * @return VideoCodec
         */
        const std::string & getVideoCodec() const { return mVideoCodec;}
 
        /**
         * @brief Get HdrType
         *
         * @return HdrType
         */
        const std::string & getHdrType() const { return mHdrType;}
 
        /**
         * @brief Get AudioCodec
         *
         * @return AudioCodec
         */
        const std::string & getAudioCodec() const {return mAudioCodec;}
 
        /**
         * @brief returns AudioMixType
         *
         * @return AudioMixType
         */
        const std::string & getAudioMixType() const {return mAudioMixType;}
 
        /**
         * @brief Get Atmos info
         *
         * @return true/false
         */
        bool getAtmosInfo() const {return  isAtmos;}
                /**
         * @brief Get Media format type
         *
         * @return mediaFormat
         */
        const std::string & getMediaFormat() { return mMediaFormatName; }
 
        /**
         * @brief Set Media format type
         *
         * @return void
         */
        void setMediaFormat(const std::string &mediaFormatName) { mMediaFormatName = mediaFormatName; }
};
 
/**
 * @class BitrateChangeEvent
 * @brief Class for the Bitrate change event
 */
class BitrateChangeEvent: public AAMPEventObject
{
        int mTime;                      /**< Playback time */
        long mBitrate;                  /**< Playback bitrate */
        std::string mDescription;       /**< Bitrate change reason */
        int mWidth;                     /**< Video width */
        int mHeight;                    /**< Video height */
        double mFrameRate;              /**< FrameRate */
        double mPosition;               /**< Position at which bitrate changed */
        bool mCappedProfile;            /**< Capped/Restricted profile status */
        int mDisplayWidth;              /**< TV display width */
        int mDisplayHeight;             /**< TV display height */
        VideoScanType mVideoScanType;   /**< Video Scan Type progressive/interlaced */
        int mAspectRatioWidth;          /**< Aspect Ratio Width*/
        int mAspectRatioHeight;         /**< Aspect Ratio Height*/
 
public:
        BitrateChangeEvent() = delete;
        BitrateChangeEvent(const BitrateChangeEvent&) = delete;
        BitrateChangeEvent& operator=(const BitrateChangeEvent&) = delete;
 
        /**
         * @fn BitrateChangeEvent
         *
         * @param[in] time       - Time of bitrate change
         * @param[in] bitrate    - New bitrate
         * @param[in] desc       - Reason of change
         * @param[in] width      - Video width
         * @param[in] height     - Video height
         * @param[in] frameRate  - Framerate
         * @param[in] position   - Position
         * @param[in] cappedProfile - Profile capping status
         * @param[in] displayWidth - Output tv display width
         * @param[in] displayHeight - Output tv dispay height
         * @param[in] videoScanType   - Video Scan Type
         * @param[in] position   - Aspect Ratio Width
         * @param[in] position   - Aspect Ratio Height
         */
        BitrateChangeEvent(int time, long bitrate, const std::string &desc, int width, int height, double frameRate, double position, bool mCappedProfile, int mDisplayWidth, int mDisplayHeight, VideoScanType videoScanType, int aspectRatioWidth, int aspectRatioHeight);
 
        /**
         * @brief BitrateChangeEvent Destructor
         */
        virtual ~BitrateChangeEvent() { }
 
        /**
         * @fn getTime
         */
        int getTime() const;
 
        /**
         * @fn getBitrate
         */
        long getBitrate() const;
 
        /**
         * @fn getDescription
         */
        const std::string &getDescription() const;
 
        /**
         * @fn getWidth
         */      
        int getWidth() const;
 
        /**
         * @fn getHeight
         */
        int getHeight() const;
 
        /**
         * @fn getFrameRate
         */
        double getFrameRate() const;
 
        /**
         * @fn getPosition
         */
        double getPosition() const;
 
        /**
         * @fn getCappedProfileStatus
         */
        bool getCappedProfileStatus() const;
 
        /**
         * @fn getDisplayWidth
         */
        int getDisplayWidth() const;
 
         /**
          * @fn getDisplayHeight
          */
        int getDisplayHeight() const;
 
        /**
         * @fn getScanType
         */
        VideoScanType getScanType() const;
        /**
         * @fn getAspectRatioWidth
         */
        int getAspectRatioWidth() const;
        /**
         * @fn getAspectRatioHeight
         */
        int getAspectRatioHeight() const;
};
 
/**
 * @class TimedMetadataEvent
 * @brief Class for the Timed Metadata event
 */
class TimedMetadataEvent: public AAMPEventObject
{
        std::string mName;              /**< Metadata name */
        std::string mId;                /**< Id of the timedMetadata */
        double mTime;                   /**< Playback position in MS- relative to tune time - starts at zero */
        double mDuration;               /**< Duration of the timed event in MS */
        std::string mContent;           /**< Metadata content */
 
public:
        TimedMetadataEvent() = delete;
        TimedMetadataEvent(const TimedMetadataEvent&) = delete;
        TimedMetadataEvent& operator=(const TimedMetadataEvent&) = delete;
 
        /**
         * @fn TimedMetadataEvent
         *
         * @param[in] name      - TimedMetadata name
         * @param[in] id        - TimedMetadata id
         * @param[in] time      - Time of event
         * @param[in] duration   - Duration of event
         * @param[in] content   - Content field of the TimedMetadata
         */
        TimedMetadataEvent(const std::string &name, const std::string &id, double time, double duration, const std::string &content);
 
        /**
         * @brief TimedMetadataEvent Destructor
         */
        virtual ~TimedMetadataEvent() { }
 
        /**
         * @fn getName
         */
        const std::string &getName() const;
 
        /**
         * @fn getId
         */
        const std::string &getId() const;
 
        /**
         * @fn getTime
         */
        double getTime() const;
 
        /**
         * @fn getDuration
         */
        double getDuration() const;
 
        /**
         * @fn getContent
         */
        const std::string &getContent() const;
};
 
/**
 * @class BulkTimedMetadataEvent
 * @brief Class for the Bulk TimedMetadata Event
 */
class BulkTimedMetadataEvent: public AAMPEventObject
{
        std::string mContent;           /**< Metadata content */
 
public:
        BulkTimedMetadataEvent() = delete;
        BulkTimedMetadataEvent(const BulkTimedMetadataEvent&) = delete;
        BulkTimedMetadataEvent& operator=(const BulkTimedMetadataEvent&) = delete;
 
        /**
         * @fn BulkTimedMetadataEvent
         *
         * @param[in] content - metadata serialized in JSON format
         */
        BulkTimedMetadataEvent(const std::string &content);
 
        /**
         * @brief BulkTimedMetadataEvent Destructor
         */
        virtual ~BulkTimedMetadataEvent() { }
 
        /**
         * @fn getContent
         */
        const std::string &getContent() const;
};
 
/**
 * @class StateChangedEvent
 * @brief Class for the Player State Changed event
 */
class StateChangedEvent: public AAMPEventObject
{
        PrivAAMPState mState;   /**< Player state */
 
public:
        StateChangedEvent() = delete;
        StateChangedEvent(const StateChangedEvent&) = delete;
        StateChangedEvent& operator=(const StateChangedEvent&) = delete;
 
        /**
         * @fn StateChangedEvent
         *
         * @param[in] state - New player state
         */
        StateChangedEvent(PrivAAMPState state);
 
        /**
         * @brief StateChangedEvent Destructor
         */
        virtual ~StateChangedEvent() { }
 
        /**
         * @brief Get Current Player State
         *
         * @return Player state
         */
        PrivAAMPState getState() const;
};
 
/**
 * @class SupportedSpeedsChangedEvent
 * @brief Class for the supported speeds changed event
 */
class SupportedSpeedsChangedEvent: public AAMPEventObject
{
        std::vector<float> mSupportedSpeeds;     /**< Supported playback speeds */
 
public:
        /**
         * @brief Copy constructor disabled
         *
         */
        SupportedSpeedsChangedEvent(const SupportedSpeedsChangedEvent&) = delete;
        /**
         * @brief assignment operator disabled
         *
         */
        SupportedSpeedsChangedEvent& operator=(const SupportedSpeedsChangedEvent&) = delete;
 
        /**
         * @fn SupportedSpeedsChangedEvent
         */
        SupportedSpeedsChangedEvent();
 
        /**
         * @brief SupportedSpeedsChangedEvent Destructor
         */
        virtual ~SupportedSpeedsChangedEvent() { }
 
        /**
         * @fn addSupportedSpeed
         *
         * @param[in] speed - Speed
         * @return void
         */
        void addSupportedSpeed(float speed);
 
        /**
         * @fn getSupportedSpeeds
         */
        const std::vector<float> &getSupportedSpeeds() const;
 
        /**
         * @fn getSupportedSpeedCount
         */
        int getSupportedSpeedCount() const;
};
 
/**
 * @class SeekedEvent
 * @brief Class for the Seeked Event
 */
class SeekedEvent: public AAMPEventObject
{
        double mPosition;               /**< new seeked position in milliseconds */
 
public:
        SeekedEvent() = delete;
        SeekedEvent(const SeekedEvent&) = delete;
        SeekedEvent& operator=(const SeekedEvent&) = delete;
 
        /**
         * @fn SeekedEvent
         */
        SeekedEvent(double positionMS);
 
        /**
         * @brief SeekedEvent Destructor
         */
        virtual ~SeekedEvent() { }
 
        /**
         * @fn getPosition
         */
        double getPosition() const;
};
 
/**
 * @class TuneProfilingEvent
 * @brief Class for the Tune Profilng Event
 */
class TuneProfilingEvent: public AAMPEventObject
{
        std::string mProfilingData;     /**< micro event data for profiling */
 
public:
        TuneProfilingEvent() = delete;
        TuneProfilingEvent(const TuneProfilingEvent&) = delete;
        TuneProfilingEvent& operator=(const TuneProfilingEvent&) = delete;
 
        /**
         * @fn TuneProfilingEvent
         *
         * @param[in] profilingData - tune profiling data
         */
        TuneProfilingEvent(std::string &profilingData);
 
        /**
         * @brief TuneProfilingEvent Destructor
         */
        virtual ~TuneProfilingEvent() { }
 
        /**
         * @fn getProfilingData
         */
        const std::string &getProfilingData() const;
};
 
/**
 * @class BufferingChangedEvent
 * @brief Class for the Buffering Changed event
 */
class BufferingChangedEvent: public AAMPEventObject
{
        bool mBuffering;        /**< true : Availability of buffer to play, false : Underflow / non-availability of buffer to play */
 
public:
        BufferingChangedEvent() = delete;
        BufferingChangedEvent(const BufferingChangedEvent&) = delete;
        BufferingChangedEvent& operator=(const BufferingChangedEvent&) = delete;
 
        /**
         * @fn BufferingChangedEvent
         *
         * @param[in] buffering - Buffering status
         */
        BufferingChangedEvent(bool buffering);
 
        /**
         * @brief BufferingChangedEvent Destructor
         */
        virtual ~BufferingChangedEvent() { }
 
        /**
         * @fn buffering
         */
        bool buffering() const;
};
 
/**
 * @brief Class for the Drm Metadata event
 */
class DrmMetaDataEvent: public AAMPEventObject
{
        AAMPTuneFailure mFailure;       /**< Error Type */
        std::string mAccessStatus;      /**< Access status */
        int mAccessStatusValue;         /**< Access status value */
        long mResponseCode;             /**< Response code */
        bool mSecclientError;           /**< Is secclient error */
        
        int32_t mSecManagerClass;       /**< Secmanager error class */
        int32_t mSecManagerReasonCode; /**< Secmanager reason  code */
        int32_t mBusinessStatus;        /**< secclient business reason  code */
public:
        DrmMetaDataEvent() = delete;
        DrmMetaDataEvent(const DrmMetaDataEvent&) = delete;
        DrmMetaDataEvent& operator=(const DrmMetaDataEvent&) = delete;
 
        /*
         * @brief DrmMetaDataEvent Constructor
         *
         * @param[in] failure      - Failure type
         * @param[in] accessStatus - Access status
         * @param[in] statusValue  - Access status value
         * @param[in] responseCode - Response code
         * @param[in] secclientErr - Is secclient error
         */
        DrmMetaDataEvent(AAMPTuneFailure failure, const std::string &accessStatus, int statusValue, long responseCode, bool secclientErr);
 
        /**
         * @brief DrmMetaDataEvent Destructor
         */
        virtual ~DrmMetaDataEvent() { }
 
        /**
         * @brief Get Failure type
         *
         * @return Tune failure type
         */
        AAMPTuneFailure getFailure() const;
 
        /**
         * @brief Set Failure type
         *
         * @param[in] failure - Failure type
         * @return void
         */
        void setFailure(AAMPTuneFailure failure);
 
        /**
         * @brief Get Access Status
         *
         * @return Access status string
         */
        const std::string &getAccessStatus() const;
 
        /**
         * @brief Set Access Status
         *
         * @param[in] status - Access status
         * @return void
         */
        void setAccessStatus(const std::string &status);
 
        /**
         * @brief Get Access Status
         *
         * @return Access status value
         */
        int getAccessStatusValue() const;
 
        /**
         * @brief Set Access Status Value
         *
         * @param[in] value - Access status value
         * @return void
         */
        void setAccessStatusValue(int value);
 
        /**
         * @brief Get Response Code
         *
         * @return Response code
         */
        long getResponseCode() const;
        
        /**
         * @brief Get Response Code
         *
         * @return Response code
         */
        int32_t getSecManagerReasonCode() const;
        
        /**
         * @brief Get Response Code
         *
         * @return Response code
         */
        int32_t getSecManagerClassCode() const;
        
        /**
         * @brief Get Response Code
         *
         * @return Response code
         */
        int32_t getBusinessStatus() const;
        
        /**
         * @brief Set Response Code
         *
         * @param[in] code - Response code
         * @return void
         */
        void setResponseCode(long code);
        
        /**
         * @brief Get Secmanager response code
         * @param[string] code - secmanager reason code
         * @return Response code
         */
        void setSecManagerReasonCode(int32_t code);
 
        /**
         * @brief Get secclient error status
         *
         * @return secclient error (true/false)
         */
        bool getSecclientError() const;
           
        /**
         * @brief Set secclient error status
         *
         * @param[in] sec client error status (true/false)
         * @return void
         */
        void setSecclientError(bool secclientError);
        
        /**
         * @brief Set the secmanager DRM error responses
         */
        void SetVerboseErrorCode(int32_t statusCode,  int32_t reasonCode, int32_t businessStatus );
 
        /**
         * @brief Convert the secclient DRM error code into secmanager error code to have a unified verbose error reported
         */
        void ConvertToVerboseErrorCode(int32_t httpCode, int32_t httpExtStatusCode );
};
 
 
/**
 * @class AnomalyReportEvent
 * @brief Class for the Anomaly Report Event.
 */
class AnomalyReportEvent: public AAMPEventObject
{
        int mSeverity;                  /**< informative number indicates severity of msg, e.g Warning, Error, Trace etc */
        std::string mMsg;               /**< Anomaly message */
 
public:
        AnomalyReportEvent() = delete;
        AnomalyReportEvent(const AnomalyReportEvent&) = delete;
        AnomalyReportEvent& operator=(const AnomalyReportEvent&) = delete;
 
        /**
         * @fn AnomalyReportEvent
         *
         * @param[in]  severity - Severity of message
         * @param[in]  msg      - Anomaly message
         */
        AnomalyReportEvent(int severity, const std::string &msg);
 
        /**
         * @brief AnomalyReportEvent Destructor
         */
        virtual ~AnomalyReportEvent() { }
 
        /**
         * @fn getSeverity
         */
        int getSeverity() const;
 
        /**
         * @fn getMessage
         */
        const std::string &getMessage() const;
};
 
/**
 * @class WebVttCueEvent
 * @brief Class for the Web VTT Cue Event
 */
class WebVttCueEvent: public AAMPEventObject
{
        VTTCue* mCueData;       /**< Web VTT cue data */
 
public:
        WebVttCueEvent() = delete;
        WebVttCueEvent(const WebVttCueEvent&) = delete;
        WebVttCueEvent& operator=(const WebVttCueEvent&) = delete;
 
        /**
         * @fn WebVttCueEvent
         *
         * @param[in] cueData - Pointer to VTT cue data
         */
        WebVttCueEvent(VTTCue* cueData);
 
        /**
         * @brief WebVttCueEvent Destructor
         */
        virtual ~WebVttCueEvent() { }
 
        /**
         * @fn getCueData
         */
        VTTCue* getCueData() const;
};
 
/**
 * @class AdResolvedEvent
 * @brief Class for ad fulfill status event
 */
class AdResolvedEvent: public AAMPEventObject
{
        bool mResolveStatus;    /**<Ad resolve status */
        std::string mAdId;      /**<Ad identifier */
        uint64_t mStartMS;      /**<Ad's start position in MS */
        uint64_t mDurationMs;   /**<Ad's duration in MS */
 
public:
        AdResolvedEvent() = delete;
        AdResolvedEvent(const AdResolvedEvent&) = delete;
        AdResolvedEvent& operator=(const AdResolvedEvent&) = delete;
 
        /**
         * @fn AdResolvedEvent
         *
         * @param[in] resolveStatus - Ad resolve status
         * @param[in] adId          - Identifier of the Ad
         * @param[in] startMS       - Start position of Ad (relative to reservation start)
         * @param[in] durationMs    - Duration of the Ad in MS
         */
        AdResolvedEvent(bool resolveStatus, const std::string &adId, uint64_t startMS, uint64_t durationMs);
 
        /**
         * @brief AdResolvedEvent Destructor
         */
        virtual ~AdResolvedEvent() { }
 
        /**
         * @fn getResolveStatus
         */
        bool getResolveStatus() const;
 
        /**
         * @fn getAdId
         */
        const std::string &getAdId() const;
 
        /**
         * @fn getStart
         */
        uint64_t getStart() const;
 
        /**
         * @fn getDuration
         */
        uint64_t getDuration() const;
 
};
 
/**
 * @class AdReservationEvent
 * @brief Class for ad reservation events
 */
class AdReservationEvent: public AAMPEventObject
{
        std::string mAdBreakId; /**<Adbreak's id */
        uint64_t mPosition;     /**<Adbreak's start position */
 
public:
        AdReservationEvent() = delete;
        AdReservationEvent(const AdReservationEvent&) = delete;
        AdReservationEvent& operator=(const AdReservationEvent&) = delete;
 
        /**
         * @fn AdReservationEvent
         *
         * @param[in] evtType  - Event Type
         * @param[in] breakId  - Unique identifier of Ad reservation.
         * @param[in] position - Postion of reservation in content's PTS
         */
        AdReservationEvent(AAMPEventType evtType, const std::string &breakId, uint64_t position);
 
        /**
         * @brief AdReservationEvent Destructor
         */
        virtual ~AdReservationEvent() { }
 
        /**
         * @fn getAdBreakId
         */
        const std::string &getAdBreakId() const;
 
        /**
         * @fn getPosition
         */
        uint64_t getPosition() const;
};
 
/**
 * @class AdPlacementEvent
 * @brief Class for ad placement events
 */
class AdPlacementEvent: public AAMPEventObject
{
        std::string mAdId;      /**< Ad Id */
        uint32_t mPosition;     /**< Ad Position relative to Reservation Start */
        uint32_t mOffset;       /**< Ad start offset */
        uint32_t mDuration;     /**< Ad's duration */
        int mErrorCode;         /**< Error code, if any */
 
public:
        AdPlacementEvent() = delete;
        AdPlacementEvent(const AdPlacementEvent&) = delete;
        AdPlacementEvent& operator=(const AdPlacementEvent&) = delete;
 
        /**
         * @fn AdPlacementEvent
         *
         * @param[in] evtType   - Event type
         * @param[in] adId      - Ad Id
         * @param[in] position  - Ad's position (in channel's PTS)
         * @param[in] offset    - Ad's start offset
         * @param[in] duration  - Ad's duration in MS
         * @param[in] errorCode - Error code, in case of placement error
         */
        AdPlacementEvent(AAMPEventType evtType, const std::string &adId, uint32_t position, uint32_t offset=0, uint32_t duration=0, int errorCode=0);
 
        /**
         * @brief AdPlacementEvent Destructor
         */
        virtual ~AdPlacementEvent() { }
 
        /**
         * @fn getAdId
         */
        const std::string &getAdId() const;
 
        /**
         * @fn getPosition
         */
        uint32_t getPosition() const;
 
        /**
         * @fn getOffset
         */
        uint32_t getOffset() const;
 
        /**
         * @fn getDuration
         */
        uint32_t getDuration() const;
 
        /**
         * @fn getErrorCode
         */
        int getErrorCode() const;
};
 
/**
 * @class MetricsDataEvent 
 * @brief Class for the Metrics Data event
 */
class MetricsDataEvent: public AAMPEventObject
{
        MetricsDataType mMetricsDataType;       /**< type of data , e.g AAMP_DATA_VIDEO_END for VideoEndEvent data */
        std::string mMetricUUID;                /**< unique session id passed during tune */
        std::string mMetricsData;               /**< metrics data */
 
public:
        MetricsDataEvent() = delete;
        MetricsDataEvent(const MetricsDataEvent&) = delete;
        MetricsDataEvent& operator=(const MetricsDataEvent&) = delete;
 
        /**
         * @fn MetricsDataEvent
         *
         * @param[in]  dataType - Data type
         * @param[in]  uuid     - unique identifier
         * @param[in]  data     - Metrics data
         */
        MetricsDataEvent(MetricsDataType dataType, const std::string &uuid, const std::string &data);
 
        /**
         * @brief MetricsDataEvent Destructor
         */
        virtual ~MetricsDataEvent() { }
 
        /**
         * @fn getMetricsDataType
         *
         */
        MetricsDataType getMetricsDataType() const;
 
        /**
         * @fn getMetricUUID
         */
        const std::string &getMetricUUID() const;
 
        /**
         * @fn getMetricsData
         */
        const std::string &getMetricsData() const;
};
 
/**
 * @class ID3MetadataEvent
 * @brief Class for the ID3 Metadata Event
 */
class ID3MetadataEvent: public AAMPEventObject
{
        std::vector<uint8_t> mMetadata;         /**< ID3 Metadata content */
        std::string mSchemeIdUri; // schemeIduri
        std::string mValue;
        uint32_t mTimeScale;
        uint64_t mPresentationTime;
        uint32_t mEventDuration;
        uint32_t mId;
        uint64_t mTimestampOffset;
 
public:
        ID3MetadataEvent() = delete;
        ID3MetadataEvent(const ID3MetadataEvent&) = delete;
        ID3MetadataEvent& operator=(const ID3MetadataEvent&) = delete;
 
        /**
         * @brief ID3MetadataEvent
         *
         * @param[in] metadata - ID3 metadata
         * @param[in] timeScale - timeScale od ID3 data
         * @param[in] presentationTime - PTS value
         * @param[in] eventDuration - eventDuration
         * @param[in] id - id of ID3 data
         * @param[in] timestampOffset
         */
        ID3MetadataEvent(const std::vector<uint8_t> &metadata, const std::string &schIDUri, std::string &id3Value, uint32_t timeScale, uint64_t presentationTime, uint32_t eventDuration, uint32_t id, uint64_t timestampOffset);
 
        /**
         * @brief ID3MetadataEvent Destructor
         */
        virtual ~ID3MetadataEvent() { }
 
        /**
         * @fn getMetadata
         */
        const std::vector<uint8_t> &getMetadata() const;
 
        /**
         * @fn getMetadataSize
         */
        int getMetadataSize() const;
 
        /**
         * @fn getTimeScale
         */
        uint32_t getTimeScale() const;
 
        /**
         * @fn getEventDuration
         */
        uint32_t getEventDuration() const;
 
        /**
         * @fn getId
         */
        uint32_t getId() const;
 
        /**
         * @fn getTimestampOffset
         */
        uint64_t getTimestampOffset() const;
 
        /**
         * @fn getPresentationTime
         */
        uint64_t getPresentationTime() const;
 
        /**
         * @fn getSchemeIdUri
         */
        const std::string& getSchemeIdUri() const;
 
        /**
         * @fn getValue
         */
        const std::string& getValue() const;
};
 
/**
 * @class DrmMessageEvent
 * @brief Class for the DRM Message Event
 */
class DrmMessageEvent: public AAMPEventObject
{
        std::string mMessage;           /**< DRM Message */
 
public:
        DrmMessageEvent() = delete;
        DrmMessageEvent(const DrmMessageEvent&) = delete;
        DrmMessageEvent& operator=(const DrmMessageEvent&) = delete;
 
        /**
         * @fn DrmMessageEvent
         *
         * @param[in] msg - DRM message
         */
        DrmMessageEvent(const std::string &msg);
 
        /**
         * @brief DrmMessageEvent Destructor
         */
        virtual ~DrmMessageEvent() { }
 
        /**
         * @fn getMessage
         */
        const std::string &getMessage() const;
};
 
/**
 * @class BlockedEvent
 * @brief Class for the BlockedEvent   event
 */
class BlockedEvent: public AAMPEventObject
{
        std::string mReason;    /**< Blocked Reason  */
 
public:
        BlockedEvent() = delete;
        BlockedEvent(const BlockedEvent&) = delete;
        BlockedEvent& operator=(const BlockedEvent&) = delete;
 
        /**
         * @brief BlockedEvent Constructor
         * @param[in] reason     - Blocked Reason
         */
        BlockedEvent(const std::string &reason) : AAMPEventObject(AAMP_EVENT_BLOCKED) , mReason(reason)
        {}
 
        /**
         * @brief BlockedEvent Destructor
         */
        virtual ~BlockedEvent() { }
 
        /**
         * @brief Get Description
         *
         * @return Blocked Reason
         */
        const std::string &getReason() const { return mReason; }
};
 
/**
 * @class ContentGapEvent
 * @brief Class for the Content gap event
 */
class ContentGapEvent: public AAMPEventObject
{
        double mTime;                   /**< Playback position in MS- relative to tune time - starts at zero */
        double mDuration;               /**< Duration of the timed event in MS */
 
public:
        ContentGapEvent() = delete;
        ContentGapEvent(const ContentGapEvent&) = delete;
        ContentGapEvent& operator=(const ContentGapEvent&) = delete;
 
        /**
         * @fn ContentGapEvent
         * @param[in] time      - Time of event
         * @param[in] duration   - Duration of event
         */
        ContentGapEvent(double time, double duration);
 
        /**
         * @brief ContentGapEvent Destructor
         */
        virtual ~ContentGapEvent() { }
 
        /**
         * @fn getTime
         */
        double getTime() const;
 
        /**
         * @fn getDuration
         */
        double getDuration() const;
};
 
/**
 * @class HTTPResponseHeaderEvent
 * @brief Class for the HTTP Response Header event 
 */
class HTTPResponseHeaderEvent: public AAMPEventObject
{
        std::string mHeaderName;        /**< Header name */
        std::string mHeaderResponse;    /**< Header response */
 
public:
        HTTPResponseHeaderEvent() = delete;
        HTTPResponseHeaderEvent(const HTTPResponseHeaderEvent&) = delete;
        HTTPResponseHeaderEvent& operator=(const HTTPResponseHeaderEvent&) = delete;
 
        /**
         * @fn HTTPResponseHeaderEvent
         *
         * @param[in] name         - HTTPResponseHeader name
         * @param[in] response     - HTTPResponseHeader response
         */
        HTTPResponseHeaderEvent(const std::string &name, const std::string &response);
 
        /**
         * @brief HTTPResponseHeaderEvent Destructor
         */
        virtual ~HTTPResponseHeaderEvent() { }
 
        /**
         * @fn getHeader
         */
        const std::string &getHeader() const;
 
        /**
         * @fn getResponse
         */
        const std::string &getResponse() const;
 
};
 
/**
 * @class WatermarkSessionUpdateEvent
 * @brief Class for the watermarkSession event
 */
class WatermarkSessionUpdateEvent: public AAMPEventObject
{
        uint32_t mSessionHandle; /**< Playback session handle used to track and manage sessions  */
        uint32_t mStatus;        /**< Provides the status of the watermark session.  */
        std::string mSystem;     /**< Describes content watermarking protection provider  */
public:
        WatermarkSessionUpdateEvent() = delete;
        WatermarkSessionUpdateEvent(const WatermarkSessionUpdateEvent&) = delete;
        WatermarkSessionUpdateEvent& operator=(const WatermarkSessionUpdateEvent&) = delete;
 
        /**
         * @brief WatermarkSessionUpdateEvent Constructor
         * @param[in]  sessionHandle - Handle used to track and manage session
         * @param[in]  status - Status of the watermark session
         * @param[in]  system - Watermarking protection provider
         */
        WatermarkSessionUpdateEvent(uint32_t sessionHandle, uint32_t status, const std::string &system) : AAMPEventObject(AAMP_EVENT_WATERMARK_SESSION_UPDATE) , mSessionHandle(sessionHandle), mStatus(status), mSystem(system)
        {}
 
        /**
         * @brief WatermarkSessionUpdateEvent Destructor
         */
        virtual ~WatermarkSessionUpdateEvent() { }
 
        /**
         * @brief Get session handle
         *
         * @return session handle
         */
        uint32_t getSessionHandle() const { return mSessionHandle; }
 
            /**
         * @brief Get session status 
         *
         * @return status
         */
        uint32_t getStatus() const { return mStatus; }
 
        /**
         * @brief Get System
         *
         * @return System
         */
        const std::string &getSystem() const { return mSystem; }
};
 
/**
 * @brief Class for the Content Protection Data Update Event on Dynamic Key Rotation
 */
class ContentProtectionDataEvent: public AAMPEventObject
{
        std::vector<uint8_t> mKeyID;                    /**< Key ID */
        std::string mStreamType;                /**< Stream Type */
public:
        ContentProtectionDataEvent() = delete;
        ContentProtectionDataEvent(const ContentProtectionDataEvent&) = delete;
        ContentProtectionDataEvent& operator=(const ContentProtectionDataEvent&) = delete;
 
        /*
         * @brief ContentProtectionDataEvent Constructor
         *
         * @param[in] keyID - KeyID
         * @param[in] streamType - Current StreamType
         */
 
        ContentProtectionDataEvent(const std::vector<uint8_t> &keyID, const std::string &streamType);
 
        /**
         * @brief ContentProtectionDataEvent Destructor
         */
        virtual ~ContentProtectionDataEvent() { }
        /**
         * @brief Get Current Key ID
         *
         * @return Current KeyID
         */
        const std::vector<uint8_t> &getKeyID() const;
 
        /**
         * @brief Get Current Stream Type
         *
         * @return Current StreamType
         */
        const std::string &getStreamType() const;
};
 
 
using AAMPEventPtr = std::shared_ptr<AAMPEventObject>;
using MediaErrorEventPtr = std::shared_ptr<MediaErrorEvent>;
using SpeedChangedEventPtr = std::shared_ptr<SpeedChangedEvent>;
using ProgressEventPtr = std::shared_ptr<ProgressEvent>;
using CCHandleEventPtr = std::shared_ptr<CCHandleEvent>;
using MediaMetadataEventPtr = std::shared_ptr<MediaMetadataEvent>;
using BitrateChangeEventPtr = std::shared_ptr<BitrateChangeEvent>;
using TimedMetadataEventPtr = std::shared_ptr<TimedMetadataEvent>;
using BulkTimedMetadataEventPtr = std::shared_ptr<BulkTimedMetadataEvent>;
using StateChangedEventPtr = std::shared_ptr<StateChangedEvent>;
using SupportedSpeedsChangedEventPtr = std::shared_ptr<SupportedSpeedsChangedEvent>;
using SeekedEventPtr = std::shared_ptr<SeekedEvent>;
using TuneProfilingEventPtr = std::shared_ptr<TuneProfilingEvent>;
using BufferingChangedEventPtr = std::shared_ptr<BufferingChangedEvent>;
using DrmMetaDataEventPtr = std::shared_ptr<DrmMetaDataEvent>;
using AnomalyReportEventPtr = std::shared_ptr<AnomalyReportEvent>;
using WebVttCueEventPtr = std::shared_ptr<WebVttCueEvent>;
using AdResolvedEventPtr = std::shared_ptr<AdResolvedEvent>;
using AdReservationEventPtr = std::shared_ptr<AdReservationEvent>;
using AdPlacementEventPtr = std::shared_ptr<AdPlacementEvent>;
using MetricsDataEventPtr = std::shared_ptr<MetricsDataEvent>;
using ID3MetadataEventPtr = std::shared_ptr<ID3MetadataEvent>;
using DrmMessageEventPtr = std::shared_ptr<DrmMessageEvent>;
using BlockedEventPtr = std::shared_ptr<BlockedEvent>;
using ContentGapEventPtr = std::shared_ptr<ContentGapEvent>;
using HTTPResponseHeaderEventPtr = std::shared_ptr<HTTPResponseHeaderEvent>;
using WatermarkSessionUpdateEventPtr = std::shared_ptr<WatermarkSessionUpdateEvent>;
using ContentProtectionDataEventPtr = std::shared_ptr<ContentProtectionDataEvent>;
#endif /* __AAMP_EVENTS_H__ */