src/Application/ApplicationManager.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
  19 #ifndef TIZENAPIS_PLATFORM_APPLICATION_H_
  20 #define TIZENAPIS_PLATFORM_APPLICATION_H_
  21
  22 #include <map>
  23 #include <set>
  24 #include <list>
  25 #include <Commons/Emitters.h>
  26 #include "IApplicationManager.h"
  27 #include "ApplicationFactory.h"
  28
  29 //#include <app_manager.h>
  30 #include <app_service.h>
  31
  32 #include "AppManagerWrapper.h"
  33
  34 namespace DeviceAPI {
  35 namespace Application {
  36
  37 class ApplicationManager: public IApplicationManager, public IAppManagerAppListChangedCallbacks {
  38     friend class ApplicationFactory;
  39
  40 public:
  41         ApplicationManager();
  42         virtual ~ApplicationManager();
  43         virtual void getCurrentApplication(const EventApplicationGetCurrAppPtr& event);
  44         virtual void launch(const EventApplicationLaunchPtr& event);
  45         virtual void kill(const EventApplicationKillPtr& event);
  46         virtual void launchAppControl(const EventApplicationLaunchAppControlPtr& event);
  47         virtual void findAppControl(const EventApplicationFindAppControlPtr& event);
  48         virtual void getAppsContext(const EventApplicationGetAppsContextPtr& event);
  49         virtual void getAppContext(const EventApplicationGetAppContextPtr& event);
  50         virtual void getAppsInfo(const EventApplicationGetAppsInfoPtr& event);
  51         virtual void getAppInfo(const EventApplicationGetAppInfoPtr& event);
  52         virtual void addAppInfoEventListener(const EventApplicationAddAppInfoEventListenerPtr& event);
  53         virtual void removeAppInfoEventListener(const EventApplicationRemoveAppInfoEventListenerPtr& event);
  54         virtual void getAppCerts(const EventApplicationGetAppCertsPtr& event);
  55
  56         void invokeManualAnswerLaunchAppControl(service_h request, service_h reply, service_result_e result,
  57                         EventApplicationLaunchAppControlReplyPtr &event);
  58         //void InstalledApplicationChanged(app_manger_event_type_e event_type,const char *package);
  59         void invokeManualAnswerKill(int pid);
  60
  61         static bool service_extra_data_callback(service_h service, const char *key, void* user_data);
  62
  63 protected:
  64         virtual void OnRequestReceived(const EventApplicationGetCurrAppPtr& event);
  65         virtual void OnRequestReceived(const EventApplicationLaunchPtr& event);
  66         virtual void OnRequestReceived(const EventApplicationKillPtr& event);
  67         virtual void OnRequestReceived(const EventApplicationLaunchAppControlPtr& event);
  68         virtual void OnRequestReceived(const EventApplicationLaunchAppControlReplyPtr& event);
  69         virtual void OnRequestReceived(const EventApplicationFindAppControlPtr& event);
  70         virtual void OnRequestReceived(const EventApplicationGetAppsContextPtr& event);
  71         virtual void OnRequestReceived(const EventApplicationGetAppContextPtr& event);
  72         virtual void OnRequestReceived(const EventApplicationGetAppsInfoPtr& event);
  73         virtual void OnRequestReceived(const EventApplicationGetAppInfoPtr& event);
  74         virtual void OnRequestReceived(const EventApplicationAddAppInfoEventListenerPtr& event);
  75         virtual void OnRequestReceived(const EventApplicationRemoveAppInfoEventListenerPtr& event);
  76         virtual void OnRequestReceived(const EventApplicationGetAppCertsPtr& event);
  77
  78         // inherited from IAppManagerAppListChangedCallbacks
  79         virtual void onAppManagerEventInstalled(const char *appId);
  80         virtual void onAppManagerEventUninstalled(const char *appId);
  81         virtual void onAppManagerEventUpdated(const char *appId);
  82
  83 private:
  84         void initialize();
  85
  86         DPL::Mutex m_initializationMutex;
  87         bool m_initialized;
  88
  89         std::map<int, EventApplicationKillPtr> m_killEventMap;
  90         mutable DPL::Mutex m_killMapLock;
  91
  92         typedef WrtDeviceApis::Commons::Emitters<EventApplicationAppInfoEventListenerEmitter> EventApplicationAppInfoEventListenerEmitters;
  93         typedef std::map<long, EventApplicationAppInfoEventListenerEmitter::IdType> WatchIdMap;
  94
  95         EventApplicationAppInfoEventListenerEmitters m_installedApplicationsEmitters;
  96         WatchIdMap      m_watchIdMap;
  97
  98         ApplicationPtr m_app;
  99 };
 100
 101 class LaunchAppControlPendingEvent
 102 {
 103 public:
 104         LaunchAppControlPendingEvent(void *thisObject, const EventApplicationLaunchAppControlReplyPtr &event) :
 105                 m_thisObject(thisObject),
 106                 m_event(event)
 107         {
 108         }
 109
 110         virtual ~LaunchAppControlPendingEvent()
 111         {
 112         }
 113
 114         void* getThisObject() const { return m_thisObject; }
 115         EventApplicationLaunchAppControlReplyPtr getEvent() const { return m_event; }
 116
 117 private:
 118         void *m_thisObject;
 119         EventApplicationLaunchAppControlReplyPtr m_event;
 120 };
 121
 122
 123 template <class KeyType, class DataType>
 124 class KeyMultiMap
 125 {
 126 public:
 127         typedef unsigned int                                DataKeyType;
 128         typedef DataType *                                  DataPtrType;
 129         typedef std::pair<KeyType, DataPtrType>             KeyDataPairType;
 130         typedef std::map<DataKeyType, KeyDataPairType>      DataMapType;
 131         typedef std::set<DataKeyType>                       DataKeySetType;
 132         typedef std::map<KeyType, DataKeySetType>           KeyMapType;
 133         typedef std::list<DataPtrType>                      DataPtrListType;
 134
 135         KeyMultiMap() :
 136                 m_keyAcc(0)
 137         {
 138         }
 139
 140         DataKeyType insert(const KeyType &key, const DataPtrType &dataPtr)
 141         {
 142                 DataKeyType dataKey = ++m_keyAcc;
 143
 144                 KeyDataPairType pair(key, dataPtr);
 145                 m_dataMap.insert(std::pair<DataKeyType, KeyDataPairType>(dataKey, pair));
 146
 147                 typename KeyMapType::iterator keyMapIter = m_keyMap.find(key);
 148                 if(keyMapIter == m_keyMap.end())
 149                 {
 150                         DataKeySetType newKeySet;
 151                         m_keyMap.insert(std::pair<KeyType, DataKeySetType>(key, newKeySet));
 152                         keyMapIter = m_keyMap.find(key);
 153                 }
 154
 155                 DataKeySetType &dataKeySet = keyMapIter->second;
 156
 157                 dataKeySet.insert(dataKey);
 158
 159                 return dataKey;
 160         }
 161
 162         DataPtrType getData(const DataKeyType &dataKey) const
 163         {
 164                 typename DataMapType::const_iterator dataMapIter = m_dataMap.find(dataKey);
 165
 166                 if(dataMapIter == m_dataMap.end())
 167                         return static_cast<DataPtrType>(NULL);
 168
 169                 return dataMapIter->second.second;
 170         }
 171
 172         DataPtrListType getDataPtrList(const KeyType &key)
 173         {
 174                 DataPtrListType dataPtrList;
 175
 176                 typename KeyMapType::const_iterator keyMapIter = m_keyMap.find(key);
 177                 if(keyMapIter == m_keyMap.end())
 178                         return dataPtrList;
 179
 180                 DataKeySetType keySet = keyMapIter->second;
 181                 DataKeySetType::iterator keySetIter = keySet.begin();
 182                 for(; keySetIter != keySet.end(); keySetIter++)
 183                 {
 184                         DataPtrType dataPtr = getData(*keySetIter);
 185                         if(dataPtr == NULL)
 186                         {
 187                                 LogWarning("No data for " << *keySetIter);
 188                                 break;
 189                         }
 190
 191                         dataPtrList.push_back(dataPtr);
 192                 }
 193
 194                 return dataPtrList;
 195         }
 196
 197         void eraseData(const DataKeyType &dataKey)
 198         {
 199                 typename DataMapType::iterator dataKeyIter = m_dataMap.find(dataKey);
 200
 201                 if(dataKeyIter == m_dataMap.end())
 202                 {
 203                         LogDebug("No data for " << dataKey);
 204                         return;
 205                 }
 206
 207                 KeyType key = dataKeyIter->second.first;
 208
 209                 m_dataMap.erase(dataKeyIter);
 210
 211                 typename KeyMapType::iterator keyMapIter = m_keyMap.find(key);
 212                 if(keyMapIter == m_keyMap.end())
 213                 {
 214                         LogWarning("No data for Key");
 215                         return;
 216                 }
 217
 218                 DataKeySetType &keySet = keyMapIter->second;
 219                 DataKeySetType::iterator keySetIter = keySet.find(dataKey);
 220                 if(keySetIter == keySet.end())
 221                 {
 222                         LogWarning("No data for " << dataKey);
 223                         return;
 224                 }
 225
 226                 keySet.erase(keySetIter);
 227         }
 228
 229         void eraseKey(const KeyType &key)
 230         {
 231                 typename KeyMapType::iterator keyMapIter = m_keyMap.find(key);
 232                 if(keyMapIter == m_keyMap.end())
 233                 {
 234                         LogDebug("No data to erase.");
 235                         return;
 236                 }
 237
 238                 DataKeySetType &keySet = keyMapIter->second;
 239                 DataKeySetType::iterator keySetIter = keySet.begin();
 240                 for(; keySetIter != keySet.end(); keySetIter++)
 241                 {
 242                         typename DataMapType::iterator dataKeyIter = m_dataMap.find(*keySetIter);
 243                         if(dataKeyIter == m_dataMap.end())
 244                         {
 245                                 LogWarning("No data to erase.");
 246                                 break;
 247                         }
 248
 249                         m_dataMap.erase(dataKeyIter);
 250                 }
 251
 252                 m_keyMap.erase(keyMapIter);
 253         }
 254
 255 private:
 256         DataKeyType m_keyAcc;
 257
 258         DataMapType m_dataMap;
 259         KeyMapType m_keyMap;
 260 };
 261
 262 }
 263 }
 264
 265 #endif