src/DataControl/DataControlAsyncCallbackManager.h

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 #ifndef _TIZEN_DATACONTROL_ASYNC_CALLBACK_MANAGER_H_
  19 #define _TIZEN_DATACONTROL_ASYNC_CALLBACK_MANAGER_H_
  20
  21 #include <dpl/singleton.h>
  22 #include <AsyncCallbackManager.h>
  23 #include <dpl/mutex.h>
  24 #include "DataControlPendingEvent.h"
  25
  26
  27 namespace DeviceAPI {
  28 namespace DataControl {
  29
  30 class DataControlAsyncCallbackManager : public DeviceAPI::Common::AsyncCallbackManager
  31 {
  32 public:
  33         DataControlAsyncCallbackManager()
  34         {
  35         }
  36
  37         virtual ~DataControlAsyncCallbackManager()
  38         {
  39                 cleanupUserData();
  40         }
  41
  42         bool isDataControlGC(void* address)
  43         {
  44                 LoggerD(address);
  45
  46                 if (m_dataControlGCMap.find(address) == m_dataControlGCMap.end())
  47                 {
  48                         return true;
  49                 }
  50
  51                 return m_dataControlGCMap[address];
  52         }
  53
  54         void setDataControlGC(void* address, bool gc)
  55         {
  56                 LoggerD(address);
  57
  58                 DPL::Mutex::ScopedLock lock(&m_mutex);
  59                 if (gc && m_dataControlGCMap.find(address) != m_dataControlGCMap.end())
  60                 {
  61                         m_dataControlGCMap.erase(address);
  62                 }
  63                 m_dataControlGCMap[address] = gc;
  64         }
  65
  66
  67         bool checkRequestIpcOperation()
  68         {
  69 //              return m_callbackUserDataMap.empty();
  70                 // limitation 128
  71                 if (m_callbackUserDataMap.size() < 128)
  72                         return true;
  73                 else
  74                         return false;
  75         }
  76
  77         void* getRemainingIpcOperation()
  78         {
  79                 LoggerD("OK");
  80                 void *retPtr = NULL;
  81
  82                 if (m_callbackUserDataMap.empty() == false)
  83                 {
  84                         std::string key = m_reqIdVector[0];
  85                         retPtr = m_callbackUserDataMap[key];
  86                 }
  87                 return retPtr;
  88         }
  89
  90         bool checkReqIdUnique(std::string key)
  91         {
  92                 if (m_callbackUserDataMap.find(key) == m_callbackUserDataMap.end())
  93                 {
  94                         return true;
  95                 }
  96                 return false;
  97         }
  98
  99
 100         void addSQLUserData(std::string key, void* data)
 101         {
 102                 if (m_callbackUserDataMap.find(key) != m_callbackUserDataMap.end())
 103                 {
 104                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "same id exist");
 105                 }
 106
 107                 m_reqIdVector.push_back(key);
 108
 109                 LoggerD("Add OK ReqId : " << key);
 110
 111                 DPL::Mutex::ScopedLock lock(&m_mutex);
 112                 m_callbackUserDataMap[key] = data;
 113         }
 114
 115         void* removeSQLUserData(std::string key)
 116         {
 117                 size_t index = 0;
 118                 if (m_callbackUserDataMap.find(key) == m_callbackUserDataMap.end())
 119                 {
 120                         LoggerD("Fail ReqId : " << key);
 121                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "there is no key");
 122                 }
 123
 124
 125                 DPL::Mutex::ScopedLock lock(&m_mutex);
 126                 void* data = m_callbackUserDataMap[key];
 127
 128         //      LoggerD(key << " : " << std::hex << data);
 129
 130                 m_callbackUserDataMap.erase(key);
 131
 132                 for (index = 0; index < m_reqIdVector.size(); index++)
 133                 {
 134                         if (m_reqIdVector[index] == key)
 135                         {
 136                                 m_reqIdVector.erase(m_reqIdVector.begin() + index);
 137                                 break;
 138                         }
 139                 }
 140
 141
 142                 return data;
 143         }
 144
 145         friend class DPL::Singleton<DataControlAsyncCallbackManager>;
 146
 147 private:
 148         void cleanupUserData()
 149         {
 150                 for (std::map<std::string, void*>::iterator it = m_callbackUserDataMap.begin();
 151                         it != m_callbackUserDataMap.end(); ++it)
 152                 {
 153                         CommonPendingEvent *event = (CommonPendingEvent*)it->second;
 154
 155                         EventInsertPendingEvent *insertEvent = dynamic_cast<EventInsertPendingEvent*>(event);
 156
 157                         if (insertEvent)
 158                         {
 159                                 LoggerD("free insert");
 160                                 delete insertEvent;
 161                                 continue;
 162                         }
 163
 164
 165                         EventSelectPendingEvent *selectEvent = dynamic_cast<EventSelectPendingEvent*>(event);
 166
 167                         if (selectEvent)
 168                         {
 169                                 LoggerD("free select");
 170                                 delete selectEvent;
 171                                 continue;
 172                         }
 173
 174                         EventUpdatePendingEvent *updateEvent = dynamic_cast<EventUpdatePendingEvent*>(event);
 175
 176                         if (updateEvent)
 177                         {
 178                                 LoggerD("free update");
 179                                 delete updateEvent;
 180                                 continue;
 181                         }
 182
 183                         EventDeletePendingEvent *deleteEvent = dynamic_cast<EventDeletePendingEvent*>(event);
 184
 185                         if (deleteEvent)
 186                         {
 187                                 LoggerD("free delete");
 188                                 delete deleteEvent;
 189                         }
 190
 191                         EventAddValuePendingEvent *addValueEvent = dynamic_cast<EventAddValuePendingEvent*>(event);
 192
 193                         if (addValueEvent)
 194                         {
 195                                 LoggerD("free addValue");
 196                                 delete addValueEvent;
 197                                 continue;
 198                         }
 199
 200
 201                         EventGetValuePendingEvent *getValueEvent = dynamic_cast<EventGetValuePendingEvent*>(event);
 202
 203                         if (getValueEvent)
 204                         {
 205                                 LoggerD("free getValue");
 206                                 delete getValueEvent;
 207                                 continue;
 208                         }
 209
 210                         EventUpdateValuePendingEvent *updateValueEvent = dynamic_cast<EventUpdateValuePendingEvent*>(event);
 211
 212                         if (updateValueEvent)
 213                         {
 214                                 LoggerD("free updateValue");
 215                                 delete updateValueEvent;
 216                                 continue;
 217                         }
 218
 219                         EventRemoveValuePendingEvent *removeValueEvent = dynamic_cast<EventRemoveValuePendingEvent*>(event);
 220
 221                         if (removeValueEvent)
 222                         {
 223                                 LoggerD("free removeValue");
 224                                 delete removeValueEvent;
 225                         }
 226                 }
 227         }
 228         DPL::Mutex m_mutex;
 229         std::map<void*, bool> m_dataControlGCMap;
 230         std::map<std::string, void*> m_callbackUserDataMap;
 231         std::vector<std::string> m_reqIdVector;
 232
 233 };
 234
 235 typedef DPL::Singleton<DataControlAsyncCallbackManager> DataControlAsyncCallbackManagerSingleton;
 236
 237 }
 238 }
 239
 240 #endif