Update change log and spec for wrt-plugins-tizen_0.4.66

[framework/web/wrt-plugins-tizen.git] / src / DataControl / DataControlAsyncCallbackManager.h

diff --git a/src/DataControl/DataControlAsyncCallbackManager.h b/src/DataControl/DataControlAsyncCallbackManager.h
index b052814..0cb5e78 100755 (executable)
--- a/src/DataControl/DataControlAsyncCallbackManager.h
+++ b/src/DataControl/DataControlAsyncCallbackManager.h
@@ -21,7 +21,8 @@
 #include <dpl/singleton.h>
 #include <AsyncCallbackManager.h>
 #include <dpl/mutex.h>
-#include "SqlDataControlConsumer.h"
+#include "DataControlPendingEvent.h"
+
 
 namespace DeviceAPI {
 namespace DataControl {
@@ -35,106 +36,86 @@ public:
 
        virtual ~DataControlAsyncCallbackManager()
        {
-               cleanupSQLUserData();
+               cleanupUserData();
        }
        
-       bool isSQLDataControlGC(void* address) 
+       bool isDataControlGC(void* address) 
        { 
                LoggerD(address);
 
-               if (m_sqlDataControlGCMap.find(address) == m_sqlDataControlGCMap.end())
+               if (m_dataControlGCMap.find(address) == m_dataControlGCMap.end())
                {
                        return true;
                }
 
-               return m_sqlDataControlGCMap[address];
+               return m_dataControlGCMap[address];
        }
-       bool isMappedDataControlGC(void* address) 
-       { 
-               LoggerD(address);
 
-               if (m_mappedDataControlGCMap.find(address) == m_mappedDataControlGCMap.end())
-               {
-                       return true;
-               }
-
-               return m_mappedDataControlGCMap[address];
-       }
-       void setSQLDataControlGC(void* address, bool gc) 
+       void setDataControlGC(void* address, bool gc) 
        { 
                LoggerD(address);
                        
                DPL::Mutex::ScopedLock lock(&m_mutex);                  
-               if (gc && m_sqlDataControlGCMap.find(address) != m_sqlDataControlGCMap.end())
+               if (gc && m_dataControlGCMap.find(address) != m_dataControlGCMap.end())
                {
-                       m_mappedDataControlGCMap.erase(address);
+                       m_dataControlGCMap.erase(address);
                }
-               m_sqlDataControlGCMap[address] = gc;
+               m_dataControlGCMap[address] = gc;
        }
 
-       void setMappedDataControlGC(void* address, bool gc) 
-       { 
-               LoggerD(address);
-               
-               DPL::Mutex::ScopedLock lock(&m_mutex);                  
-               if (gc && m_mappedDataControlGCMap.find(address) != m_mappedDataControlGCMap.end())
-               {
-                       m_mappedDataControlGCMap.erase(address);
-               }
-               m_mappedDataControlGCMap[address] = gc;
-       }
 
-       bool checkDoSQLOperation()
+       bool checkRequestIpcOperation()
        {
-//             return m_callbackSQLUserDataMap.empty();        
+//             return m_callbackUserDataMap.empty();   
                // limitation 128
-               if (m_callbackSQLUserDataMap.size() < 128)
+               if (m_callbackUserDataMap.size() < 128)
                        return true;
                else
                        return false;
        }
 
-       void* getRemainingSQLOperation()
+       void* getRemainingIpcOperation()
        {
                LoggerD("OK");
                void *retPtr = NULL;
 
-               if (m_callbackSQLUserDataMap.empty() == false)
+               if (m_callbackUserDataMap.empty() == false)
                {
-                       std::string key = m_sqlReqIdVector[0];
-                       retPtr = m_callbackSQLUserDataMap[key];
+                       std::string key = m_reqIdVector[0];
+                       retPtr = m_callbackUserDataMap[key];
                }
                return retPtr;  
        }
        
        bool checkReqIdUnique(std::string key) 
        {
-               if (m_callbackSQLUserDataMap.find(key) == m_callbackSQLUserDataMap.end())
+               if (m_callbackUserDataMap.find(key) == m_callbackUserDataMap.end())
                {
                        return true;
                }
                return false;
        }
+
        
        void addSQLUserData(std::string key, void* data) 
        { 
-               if (m_callbackSQLUserDataMap.find(key) != m_callbackSQLUserDataMap.end())
+               if (m_callbackUserDataMap.find(key) != m_callbackUserDataMap.end())
                {
                        ThrowMsg(WrtDeviceApis::Commons::PlatformException, "same id exist");
                }
 
-               m_sqlReqIdVector.push_back(key);
+               m_reqIdVector.push_back(key);
 
                LoggerD("Add OK ReqId : " << key);
 
                DPL::Mutex::ScopedLock lock(&m_mutex);          
-               m_callbackSQLUserDataMap[key] = data;
+               m_callbackUserDataMap[key] = data;
        }
        
        void* removeSQLUserData(std::string key) 
        {
                size_t index = 0;
-               if (m_callbackSQLUserDataMap.find(key) == m_callbackSQLUserDataMap.end())
+               if (m_callbackUserDataMap.find(key) == m_callbackUserDataMap.end())
                {
                        LoggerD("Fail ReqId : " << key);
                        ThrowMsg(WrtDeviceApis::Commons::PlatformException, "there is no key");
@@ -142,17 +123,17 @@ public:
                
 
                DPL::Mutex::ScopedLock lock(&m_mutex);                  
-               void* data = m_callbackSQLUserDataMap[key];
+               void* data = m_callbackUserDataMap[key];
                
        //      LoggerD(key << " : " << std::hex << data);
 
-               m_callbackSQLUserDataMap.erase(key);
+               m_callbackUserDataMap.erase(key);
 
-               for (index = 0; index < m_sqlReqIdVector.size(); index++)
+               for (index = 0; index < m_reqIdVector.size(); index++)
                {
-                       if (m_sqlReqIdVector[index] == key)
+                       if (m_reqIdVector[index] == key)
                        {
-                               m_sqlReqIdVector.erase(m_sqlReqIdVector.begin() + index);                               
+                               m_reqIdVector.erase(m_reqIdVector.begin() + index);                             
                                break;
                        }
                }
@@ -164,10 +145,10 @@ public:
        friend class DPL::Singleton<DataControlAsyncCallbackManager>;
        
 private:
-       void cleanupSQLUserData() 
+       void cleanupUserData() 
        {       
-               for (std::map<std::string, void*>::iterator it = m_callbackSQLUserDataMap.begin();
-                       it != m_callbackSQLUserDataMap.end(); ++it)
+               for (std::map<std::string, void*>::iterator it = m_callbackUserDataMap.begin();
+                       it != m_callbackUserDataMap.end(); ++it)
                {
                        CommonPendingEvent *event = (CommonPendingEvent*)it->second;
                        
@@ -206,13 +187,48 @@ private:
                                LoggerD("free delete");
                                delete deleteEvent;
                        }
+                       
+                       EventAddValuePendingEvent *addValueEvent = dynamic_cast<EventAddValuePendingEvent*>(event);
+               
+                       if (addValueEvent)
+                       {
+                               LoggerD("free addValue");
+                               delete addValueEvent;
+                               continue;
+                       }
+               
+                       
+                       EventGetValuePendingEvent *getValueEvent = dynamic_cast<EventGetValuePendingEvent*>(event);
+               
+                       if (getValueEvent) 
+                       {
+                               LoggerD("free getValue");
+                               delete getValueEvent;
+                               continue;
+                       }
+               
+                       EventUpdateValuePendingEvent *updateValueEvent = dynamic_cast<EventUpdateValuePendingEvent*>(event);
+               
+                       if (updateValueEvent) 
+                       {
+                               LoggerD("free updateValue");
+                               delete updateValueEvent;
+                               continue;
+                       }
+               
+                       EventRemoveValuePendingEvent *removeValueEvent = dynamic_cast<EventRemoveValuePendingEvent*>(event);
+                       
+                       if (removeValueEvent) 
+                       {
+                               LoggerD("free removeValue");
+                               delete removeValueEvent;
+                       }
                }
        }
        DPL::Mutex m_mutex;
-       std::map<void*, bool> m_sqlDataControlGCMap;
-       std::map<void*, bool> m_mappedDataControlGCMap;
-       std::map<std::string, void*> m_callbackSQLUserDataMap;
-       std::vector<std::string> m_sqlReqIdVector;
+       std::map<void*, bool> m_dataControlGCMap;
+       std::map<std::string, void*> m_callbackUserDataMap;
+       std::vector<std::string> m_reqIdVector;
        
 };