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(key << " : " << std::hex << data);
 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                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "there is no key");
 114                 }
 115
 116
 117                 DPL::Mutex::ScopedLock lock(&m_mutex);
 118                 void* data = m_callbackSQLUserDataMap[key];
 119
 120         //      LoggerD(key << " : " << std::hex << data);
 121
 122                 m_callbackSQLUserDataMap.erase(key);
 123                 return data;
 124         }
 125
 126         friend class DPL::Singleton<DataControlAsyncCallbackManager>;
 127
 128 private:
 129         void cleanupSQLUserData()
 130         {
 131                 for (std::map<std::string, void*>::iterator it = m_callbackSQLUserDataMap.begin();
 132                         it != m_callbackSQLUserDataMap.end(); ++it)
 133                 {
 134                         CommonPendingEvent *event = (CommonPendingEvent*)it->second;
 135
 136                         EventInsertPendingEvent *insertEvent = dynamic_cast<EventInsertPendingEvent*>(event);
 137
 138                         if (insertEvent)
 139                         {
 140                                 LoggerD("free insert");
 141                                 delete insertEvent;
 142                                 continue;
 143                         }
 144
 145
 146                         EventSelectPendingEvent *selectEvent = dynamic_cast<EventSelectPendingEvent*>(event);
 147
 148                         if (selectEvent)
 149                         {
 150                                 LoggerD("free select");
 151                                 delete selectEvent;
 152                                 continue;
 153                         }
 154
 155                         EventUpdatePendingEvent *updateEvent = dynamic_cast<EventUpdatePendingEvent*>(event);
 156
 157                         if (updateEvent)
 158                         {
 159                                 LoggerD("free update");
 160                                 delete updateEvent;
 161                                 continue;
 162                         }
 163
 164                         EventDeletePendingEvent *deleteEvent = dynamic_cast<EventDeletePendingEvent*>(event);
 165
 166                         if (deleteEvent)
 167                         {
 168                                 LoggerD("free delete");
 169                                 delete deleteEvent;
 170                         }
 171                 }
 172         }
 173         DPL::Mutex m_mutex;
 174         std::map<void*, bool> m_sqlDataControlGCMap;
 175         std::map<void*, bool> m_mappedDataControlGCMap;
 176         std::map<std::string, void*> m_callbackSQLUserDataMap;
 177
 178 };
 179
 180 typedef DPL::Singleton<DataControlAsyncCallbackManager> DataControlAsyncCallbackManagerSingleton;
 181
 182 }
 183 }
 184
 185 #endif