mv_surveillance/surveillance/include/EventManager.h

   1 /**
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #ifndef __MEDIA_VISION_EVENT_MANAGER_H__
  18 #define __MEDIA_VISION_EVENT_MANAGER_H__
  19
  20 /**
  21  * @file  EventManager.h
  22  * @brief This file contains functionality for event manager.
  23  */
  24
  25 #include "EventTrigger.h"
  26 #include "EventDefs.h"
  27
  28 namespace mediavision {
  29 namespace surveillance {
  30
  31 class EventManager;
  32
  33 /**
  34  * @class    EventManagerDestroyer
  35  * @brief    This class contains event manager destroyer functionality.
  36  *
  37  * @since_tizen 3.0
  38  */
  39 class EventManagerDestroyer {
  40 public:
  41         /**
  42          * @brief Default destructor.
  43          *
  44          * @since_tizen 3.0
  45          */
  46         ~EventManagerDestroyer();
  47
  48         /**
  49          * @brief Initializes pointer to EventManager which will be destroyed.
  50          *
  51          * @since_tizen 3.0
  52          * @param [in] pointer    The pointer to EventManager which will be destroyed
  53          */
  54         void initialize(EventManager *pointer);
  55
  56 private:
  57         EventManager *__pInstance;
  58 };
  59
  60 /**
  61  * @class    EventManager
  62  * @brief    This class contains event manager functionality.
  63  *
  64  * @since_tizen 3.0
  65  */
  66
  67 class EventManager {
  68 public:
  69         /**
  70          * @brief Gets EventManager instance.
  71          *
  72          * @since_tizen 3.0
  73          */
  74         static EventManager& getInstance();
  75
  76         /**
  77          * @brief Registers event.
  78          *
  79          * @since_tizen 3.0
  80          * @param [in] eventTrigger     The event trigger to be register (NULL if internal)
  81          * @param [in] triggerId        Unique event trigger identifier to be register
  82          * @param [in] eventType        Type of the event
  83          * @param [in] videoStreamId    Video stream identificator
  84          * @param [in] engineCfg        The engine configuration for event trigger
  85          * @param [in] callback         The callback to be called if event will be occured
  86          * @param [in] user_data        The user data to be passed to the callback function
  87          * @param [in] numberOfPoints    The number of ROI points
  88          * @param [in] roi               The intput array with ROI points
  89          * @return @c 0 on success, otherwise a negative error value
  90          */
  91         int registerEvent(
  92                 mv_surveillance_event_trigger_h eventTrigger,
  93                 long int triggerId,
  94                 const char *eventType,
  95                 int videoStreamId,
  96                 mv_engine_config_h engineCfg,
  97                 mv_surveillance_event_occurred_cb callback,
  98                 void *user_data,
  99                 int numberOfPoints,
 100                 mv_point_s *roi);
 101
 102     /**
 103      * @brief Unregisters event.
 104      *
 105      * @since_tizen 3.0
 106      * @param [in] triggerId       Unique event trigger identifier to be
 107      *                             unregister
 108      * @param [in] videoStreamId   Video stream identifier for which event
 109      *                             will be unregistered
 110      * @return @c 0 on success, otherwise a negative error value
 111      */
 112     int unregisterEvent(long int triggerId, int videoStreamId);
 113
 114         /**
 115          * @brief Pushes media source to run event triggers.
 116          *
 117          * @since_tizen 3.0
 118          * @param [in] source           The media source to be pushed
 119          * @param [in] videoStreamId    The video stream identificator for media source
 120          * @return @c 0 on success, otherwise a negative error value
 121          */
 122         int pushSource(mv_source_h source, int videoStreamId);
 123
 124         /**
 125          * @brief Gets supported event types.
 126          *
 127          * @since_tizen 3.0
 128          * @param [out] eventTypes    The supported event types
 129          * @return @c 0 on success, otherwise a negative error value
 130          */
 131         static int getSupportedEventTypes(StringVector& eventTypes);
 132
 133         /**
 134          * @brief Gets all supported event result value names.
 135          *
 136          * @since_tizen 3.0
 137          * @param [out] eventResValNames    The supported event result value names
 138          * @return @c 0 on success, otherwise a negative error value
 139          */
 140         static int getSupportedEventResultValueNames(StringVector& eventResValNames);
 141
 142         /**
 143          * @brief Gets supported event result value names for an event type.
 144          *
 145          * @since_tizen 3.0
 146          * @param [in]  eventTypeName       The name of the event type to return
 147          *                                  result value names for
 148          * @param [out] eventResValNames    The supported event result value names
 149          * @return @c 0 on success, otherwise a negative error value
 150          */
 151         static int getSupportedEventResultValueNames(
 152                 const std::string& eventTypeName,
 153                 StringVector& eventResValNames);
 154
 155 private:
 156         EventManager();
 157
 158         EventManager(const EventManager&);
 159
 160         EventManager& operator=(EventManager&);
 161
 162         ~EventManager();
 163
 164         static void setSupportedEventTypes();
 165
 166     EventTriggersIter isTriggerExists(EventTrigger *trigger, int videoStreamId);
 167
 168         friend class EventManagerDestroyer;
 169
 170 private:
 171         static EventManager *__pInstance;
 172
 173         static EventManagerDestroyer Destroyer;
 174
 175         static EventTypesMap SupportedEventTypes;
 176
 177 private:
 178         EventTriggersMap __eventTriggers;
 179 };
 180
 181 } /* surveillance */
 182 } /* mediavision */
 183
 184 #endif /* __MEDIA_VISION_EVENT_MANAGER_H__ */