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