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 "SqlDataControlConsumer.h"
  25
  26 namespace DeviceAPI {
  27 namespace DataControl {
  28
  29 class DataControlAsyncCallbackManager : public DeviceAPI::Common::AsyncCallbackManager
  30 {
  31 public:
  32         DataControlAsyncCallbackManager()
  33         {
  34         }
  35
  36         virtual ~DataControlAsyncCallbackManager()
  37         {
  38                 cleanupSQLUserData();
  39         }
  40
  41         bool isSQLDataControlGC(void* address)
  42         {
  43                 LoggerD(address);
  44
  45                 if (m_sqlDataControlGCMap.find(address) == m_sqlDataControlGCMap.end())
  46                 {
  47                         return true;
  48                 }
  49
  50                 return m_sqlDataControlGCMap[address];
  51         }
  52         bool isMappedDataControlGC(void* address)
  53         {
  54                 LoggerD(address);
  55
  56                 if (m_mappedDataControlGCMap.find(address) == m_mappedDataControlGCMap.end())
  57                 {
  58                         return true;
  59                 }
  60
  61                 return m_mappedDataControlGCMap[address];
  62         }
  63         void setSQLDataControlGC(void* address, bool gc)
  64         {
  65                 LoggerD(address);
  66
  67                 DPL::Mutex::ScopedLock lock(&m_mutex);
  68                 if (gc && m_sqlDataControlGCMap.find(address) != m_sqlDataControlGCMap.end())
  69                 {
  70                         m_mappedDataControlGCMap.erase(address);
  71                 }
  72                 m_sqlDataControlGCMap[address] = gc;
  73         }
  74
  75         void setMappedDataControlGC(void* address, bool gc)
  76         {
  77                 LoggerD(address);
  78
  79                 DPL::Mutex::ScopedLock lock(&m_mutex);
  80                 if (gc && m_mappedDataControlGCMap.find(address) != m_mappedDataControlGCMap.end())
  81                 {
  82                         m_mappedDataControlGCMap.erase(address);
  83                 }
  84                 m_mappedDataControlGCMap[address] = gc;
  85         }
  86
  87         bool checkReqIdUnique(std::string key)
  88         {
  89                 if (m_callbackSQLUserDataMap.find(key) == m_callbackSQLUserDataMap.end())
  90                 {
  91                         return true;
  92                 }
  93                 return false;
  94         }
  95
  96         void addSQLUserData(std::string key, void* data)
  97         {
  98                 if (m_callbackSQLUserDataMap.find(key) != m_callbackSQLUserDataMap.end())
  99                 {
 100                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "same id exist");
 101                 }
 102
 103                 LoggerD("Add OK ReqId : " << key);
 104
 105                 DPL::Mutex::ScopedLock lock(&m_mutex);
 106                 m_callbackSQLUserDataMap[key] = data;
 107         }
 108
 109         void* removeSQLUserData(std::string key)
 110         {
 111                 if (m_callbackSQLUserDataMap.find(key) == m_callbackSQLUserDataMap.end())
 112                 {
 113                         LoggerD("Fail ReqId : " << key);
 114                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "there is no key");
 115                 }
 116
 117
 118                 DPL::Mutex::ScopedLock lock(&m_mutex);
 119                 void* data = m_callbackSQLUserDataMap[key];
 120
 121         //      LoggerD(key << " : " << std::hex << data);
 122
 123                 m_callbackSQLUserDataMap.erase(key);
 124                 return data;
 125         }
 126
 127         friend class DPL::Singleton<DataControlAsyncCallbackManager>;
 128
 129 private:
 130         void cleanupSQLUserData()
 131         {
 132                 for (std::map<std::string, void*>::iterator it = m_callbackSQLUserDataMap.begin();
 133                         it != m_callbackSQLUserDataMap.end(); ++it)
 134                 {
 135                         CommonPendingEvent *event = (CommonPendingEvent*)it->second;
 136
 137                         EventInsertPendingEvent *insertEvent = dynamic_cast<EventInsertPendingEvent*>(event);
 138
 139                         if (insertEvent)
 140                         {
 141                                 LoggerD("free insert");
 142                                 delete insertEvent;
 143                                 continue;
 144                         }
 145
 146
 147                         EventSelectPendingEvent *selectEvent = dynamic_cast<EventSelectPendingEvent*>(event);
 148
 149                         if (selectEvent)
 150                         {
 151                                 LoggerD("free select");
 152                                 delete selectEvent;
 153                                 continue;
 154                         }
 155
 156                         EventUpdatePendingEvent *updateEvent = dynamic_cast<EventUpdatePendingEvent*>(event);
 157
 158                         if (updateEvent)
 159                         {
 160                                 LoggerD("free update");
 161                                 delete updateEvent;
 162                                 continue;
 163                         }
 164
 165                         EventDeletePendingEvent *deleteEvent = dynamic_cast<EventDeletePendingEvent*>(event);
 166
 167                         if (deleteEvent)
 168                         {
 169                                 LoggerD("free delete");
 170                                 delete deleteEvent;
 171                         }
 172                 }
 173         }
 174         DPL::Mutex m_mutex;
 175         std::map<void*, bool> m_sqlDataControlGCMap;
 176         std::map<void*, bool> m_mappedDataControlGCMap;
 177         std::map<std::string, void*> m_callbackSQLUserDataMap;
 178
 179 };
 180
 181 typedef DPL::Singleton<DataControlAsyncCallbackManager> DataControlAsyncCallbackManagerSingleton;
 182
 183 }
 184 }
 185
 186 #endif