src/Application/plugin_config.cpp

   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 #include <Commons/FunctionDefinition.h>
  20 #include <Commons/FunctionDeclaration.h>
  21 #include <iostream>
  22 #include <Commons/Exception.h>
  23 #include <dpl/exception.h>
  24 #include <map>
  25
  26 #include "plugin_config.h"
  27
  28 #define APPLICATION_FEATURE_API_LAUNCH  "http://tizen.org/privilege/application.launch"
  29 #define APPLICATION_FEATURE_API_KILL    "http://tizen.org/privilege/application.kill"
  30 #define APPLICATION_FEATURE_API_KILL2   "http://tizen.org/privilege/appmanager.kill"
  31 #define APPLICATION_FEATURE_API_CERT    "http://tizen.org/privilege/appmanager.certificate"
  32
  33 // for backword compatibility
  34 #define APPLICATION_FEATURE_API_READ    "http://tizen.org/privilege/application.read"
  35 //#define APPLICATION_FEATURE_API_INSTALL       "http://tizen.org/privilege/application.install"
  36
  37 #define APPLICATION_DEVICE_CAP_LAUNCH   "application.launch"
  38 #define APPLICATION_DEVICE_CAP_KILL             "appmanager.kill"
  39 #define APPLICATION_DEVICE_CAP_CERT             "appmanager.certificate"
  40
  41 //#define APPLICATION_DEVICE_CAP_READ           "application.read"
  42 //#define APPLICATION_DEVICE_CAP_INSTALL        "application.install"
  43
  44 using namespace WrtDeviceApis::Commons;
  45
  46 namespace DeviceAPI {
  47 namespace Application {
  48
  49 static FunctionMapping createApplicationFunctions();
  50
  51 static FunctionMapping ApplicationFunctions =
  52     createApplicationFunctions();
  53
  54 DEFINE_FUNCTION_GETTER(Application, ApplicationFunctions);
  55
  56 static FunctionMapping createApplicationFunctions()
  57 {
  58     /**
  59      * Device capabilities
  60      */
  61     ACE_CREATE_DEVICE_CAP(DEVICE_CAP_APPLICATION_LAUNCH, APPLICATION_DEVICE_CAP_LAUNCH);
  62     ACE_CREATE_DEVICE_CAP(DEVICE_CAP_APPLICATION_KILL, APPLICATION_DEVICE_CAP_KILL);
  63         ACE_CREATE_DEVICE_CAP(DEVICE_CAP_APPLICATION_CERT, APPLICATION_DEVICE_CAP_CERT);
  64
  65     ACE_CREATE_DEVICE_CAPS_LIST(DEVICE_LIST_APPLICATION_LAUNCH);
  66     ACE_CREATE_DEVICE_CAPS_LIST(DEVICE_LIST_APPLICATION_KILL);
  67         ACE_CREATE_DEVICE_CAPS_LIST(DEVICE_LIST_APPLICATION_CERT);
  68     ACE_ADD_DEVICE_CAP(DEVICE_LIST_APPLICATION_LAUNCH, DEVICE_CAP_APPLICATION_LAUNCH);
  69     ACE_ADD_DEVICE_CAP(DEVICE_LIST_APPLICATION_KILL, DEVICE_CAP_APPLICATION_KILL);
  70         ACE_ADD_DEVICE_CAP(DEVICE_LIST_APPLICATION_CERT, DEVICE_CAP_APPLICATION_CERT);
  71
  72 #if 0
  73         ACE_CREATE_DEVICE_CAPS_LIST(EMPTY_DEVICE_LIST);
  74
  75         ACE_CREATE_DEVICE_CAP(DEVICE_CAP_APPLICATION_READ, APPLICATION_DEVICE_CAP_READ);
  76         ACE_CREATE_DEVICE_CAP(DEVICE_CAP_APPLICATION_INSTALL, APPLICATION_DEVICE_CAP_INSTALL);
  77         ACE_CREATE_DEVICE_CAPS_LIST(DEVICE_LIST_APPLICATION_READ);
  78         ACE_CREATE_DEVICE_CAPS_LIST(DEVICE_LIST_APPLICATION_INSTALL);
  79         ACE_ADD_DEVICE_CAP(DEVICE_LIST_APPLICATION_READ, DEVICE_CAP_APPLICATION_READ);
  80         ACE_ADD_DEVICE_CAP(DEVICE_LIST_APPLICATION_INSTALL, DEVICE_CAP_APPLICATION_INSTALL);
  81 #endif
  82
  83     /**
  84      * Api Features
  85      */
  86     ACE_CREATE_FEATURE(FEATURE_APPLICATION_LAUNCH, APPLICATION_FEATURE_API_LAUNCH);
  87         ACE_CREATE_FEATURE(FEATURE_APPLICATION_KILL, APPLICATION_FEATURE_API_KILL);
  88         ACE_CREATE_FEATURE(FEATURE_APPLICATION_KILL2, APPLICATION_FEATURE_API_KILL2);
  89         ACE_CREATE_FEATURE(FEATURE_APPLICATION_CERT, APPLICATION_FEATURE_API_CERT);
  90         ACE_CREATE_FEATURE(FEATURE_APPLICATION_READ, APPLICATION_FEATURE_API_READ);
  91
  92
  93     ACE_CREATE_FEATURE_LIST(APPLICATION_FEATURES_APPLICATION_LAUNCH);
  94     ACE_ADD_API_FEATURE(APPLICATION_FEATURES_APPLICATION_LAUNCH, FEATURE_APPLICATION_LAUNCH);
  95
  96     ACE_CREATE_FEATURE_LIST(APPLICATION_FEATURES_APPLICATION_KILL);
  97     ACE_ADD_API_FEATURE(APPLICATION_FEATURES_APPLICATION_KILL, FEATURE_APPLICATION_KILL);
  98         ACE_ADD_API_FEATURE(APPLICATION_FEATURES_APPLICATION_KILL, FEATURE_APPLICATION_KILL2);
  99
 100         ACE_CREATE_FEATURE_LIST(APPLICATION_FEATURES_APPLICATION_CERT);
 101         ACE_ADD_API_FEATURE(APPLICATION_FEATURES_APPLICATION_CERT, FEATURE_APPLICATION_CERT);
 102         ACE_ADD_API_FEATURE(APPLICATION_FEATURES_APPLICATION_CERT, FEATURE_APPLICATION_READ);
 103
 104 #if 0
 105         ACE_CREATE_FEATURE(FEATURE_APPLICATION_READ, APPLICATION_FEATURE_API_READ);
 106         ACE_CREATE_FEATURE(FEATURE_APPLICATION_INSTALL, APPLICATION_FEATURE_API_INSTALL);
 107
 108     ACE_CREATE_FEATURE_LIST(APPLICATION_FEATURES_APPLICATION_READ);
 109     ACE_ADD_API_FEATURE(APPLICATION_FEATURES_APPLICATION_READ, FEATURE_APPLICATION_READ);
 110
 111     ACE_CREATE_FEATURE_LIST(APPLICATION_FEATURES_APPLICATION_INSTALL);
 112     ACE_ADD_API_FEATURE(APPLICATION_FEATURES_APPLICATION_INSTALL, FEATURE_APPLICATION_INSTALL);
 113 #endif
 114
 115     /**
 116      * Functions
 117      */
 118     FunctionMapping applicationMapping;
 119
 120     // launch
 121     AceFunction launchFunc = ACE_CREATE_FUNCTION(
 122             FUNCTION_LAUNCH,
 123             APPLICATION_FUNCTION_API_LAUNCH,
 124             APPLICATION_FEATURES_APPLICATION_LAUNCH,
 125             DEVICE_LIST_APPLICATION_LAUNCH);
 126
 127     applicationMapping.insert(std::make_pair(
 128                                APPLICATION_FUNCTION_API_LAUNCH,
 129                                launchFunc));
 130
 131     // launchAppControl
 132     AceFunction launchAppControlFunc = ACE_CREATE_FUNCTION(
 133             FUNCTION_LAUNCH_APP_CONTROL,
 134             APPLICATION_FUNCTION_API_LAUNCH_APP_CONTROL,
 135             APPLICATION_FEATURES_APPLICATION_LAUNCH,
 136             DEVICE_LIST_APPLICATION_LAUNCH);
 137
 138     applicationMapping.insert(std::make_pair(
 139                                APPLICATION_FUNCTION_API_LAUNCH_APP_CONTROL,
 140                                launchAppControlFunc));
 141
 142         // kill
 143     AceFunction killFunc = ACE_CREATE_FUNCTION(
 144             FUNCTION_KILL,
 145             APPLICATION_FUNCTION_API_KILL,
 146             APPLICATION_FEATURES_APPLICATION_KILL,
 147             DEVICE_LIST_APPLICATION_KILL);
 148
 149     applicationMapping.insert(std::make_pair(
 150                                APPLICATION_FUNCTION_API_KILL,
 151                                killFunc));
 152
 153
 154         // getAppCerts
 155         AceFunction getAppCertsFunc = ACE_CREATE_FUNCTION(
 156                         FUNCTION_GET_APP_CERTS,
 157                         APPLICATION_FUNCTION_API_GET_APP_CERTS,
 158                         APPLICATION_FEATURES_APPLICATION_CERT,
 159                         DEVICE_LIST_APPLICATION_CERT);
 160
 161         applicationMapping.insert(std::make_pair(
 162                                                            APPLICATION_FUNCTION_API_GET_APP_CERTS,
 163                                                            getAppCertsFunc));
 164
 165
 166 #if 0
 167
 168         // setUserAgent
 169         AceFunction setUserAgentFunc = ACE_CREATE_FUNCTION(
 170                         FUNCTION_SET_USER_AGENT,
 171                         APPLICATION_FUNCTION_API_SET_USER_AGENT,
 172                         APPLICATION_FEATURES_APPLICATION_READ,
 173                         EMPTY_DEVICE_LIST);
 174
 175         applicationMapping.insert(std::make_pair(
 176                                                            APPLICATION_FUNCTION_API_SET_USER_AGENT,
 177                                                            setUserAgentFunc));
 178
 179     // getAppsInfo
 180     AceFunction getAppsInfoFunc = ACE_CREATE_FUNCTION(
 181             FUNCTION_GET_APPLICATION_INFORMATIONS,
 182             APPLICATION_FUNCTION_API_GET_APPS_INFO,
 183             APPLICATION_FEATURES_APPLICATION_READ,
 184             DEVICE_LIST_APPLICATION_READ);
 185
 186     applicationMapping.insert(std::make_pair(
 187                                APPLICATION_FUNCTION_API_GET_APPS_INFO,
 188                                getAppsInfoFunc));
 189
 190     // getAppInfo
 191     AceFunction getAppInfoFunc = ACE_CREATE_FUNCTION(
 192             FUNCTION_GET_APPLICATION_INFORMATION,
 193             APPLICATION_FUNCTION_API_GET_APP_INFO,
 194             APPLICATION_FEATURES_APPLICATION_READ,
 195             DEVICE_LIST_APPLICATION_READ);
 196
 197     applicationMapping.insert(std::make_pair(
 198                                APPLICATION_FUNCTION_API_GET_APP_INFO,
 199                                getAppInfoFunc));
 200
 201     // getAppsContext
 202     AceFunction getAppsContextFunc = ACE_CREATE_FUNCTION(
 203             FUNCTION_GET_RUNNING_APPLICATION_CONTEXTS,
 204             APPLICATION_FUNCTION_API_GET_APPS_CONTEXT,
 205             APPLICATION_FEATURES_APPLICATION_READ,
 206             DEVICE_LIST_APPLICATION_READ);
 207
 208     applicationMapping.insert(std::make_pair(
 209                                APPLICATION_FUNCTION_API_GET_APPS_CONTEXT,
 210                                getAppsContextFunc));
 211
 212     // getAppContext
 213     AceFunction getAppContextFunc = ACE_CREATE_FUNCTION(
 214             FUNCTION_GET_CURRENT_APPLICATION_CONTEXT,
 215             APPLICATION_FUNCTION_API_GET_APP_CONTEXT,
 216             APPLICATION_FEATURES_APPLICATION_READ,
 217             DEVICE_LIST_APPLICATION_READ);
 218
 219     applicationMapping.insert(std::make_pair(
 220                                APPLICATION_FUNCTION_API_GET_APP_CONTEXT,
 221                                getAppContextFunc));
 222
 223     // getAppsContext
 224     AceFunction findAppControlFunc = ACE_CREATE_FUNCTION(
 225             FUNCTION_GET_RUNNING_APPLICATION_CONTEXTS,
 226             APPLICATION_FUNCTION_API_FIND_APP_CONTROL,
 227             APPLICATION_FEATURES_APPLICATION_READ,
 228             DEVICE_LIST_APPLICATION_READ);
 229
 230     applicationMapping.insert(std::make_pair(
 231                                APPLICATION_FUNCTION_API_FIND_APP_CONTROL,
 232                                findAppControlFunc));
 233
 234     // addAppInfoEventListener
 235     AceFunction addAppInfoEventListenerFunc = ACE_CREATE_FUNCTION(
 236             FUNCTION_ADD_APPLICATION_INFORMATION_EVENT_LISTENER,
 237             APPLICATION_FUNCTION_API_ADD_APP_INFO_EVENT_LISTENER,
 238             APPLICATION_FEATURES_APPLICATION_READ,
 239             DEVICE_LIST_APPLICATION_READ);
 240
 241     applicationMapping.insert(std::make_pair(
 242                                APPLICATION_FUNCTION_API_ADD_APP_INFO_EVENT_LISTENER,
 243                                addAppInfoEventListenerFunc));
 244
 245     // removeAppInfoEventListener
 246     AceFunction removeAppInfoEventListenerFunc = ACE_CREATE_FUNCTION(
 247             FUNCTION_REMOVE_APPLICATION_INFORMATION_EVENT_LISTENER,
 248             APPLICATION_FUNCTION_API_REMOVE_APP_INFO_EVENT_LISTENER,
 249             APPLICATION_FEATURES_APPLICATION_READ,
 250             DEVICE_LIST_APPLICATION_READ);
 251
 252     applicationMapping.insert(std::make_pair(
 253                                APPLICATION_FUNCTION_API_REMOVE_APP_INFO_EVENT_LISTENER,
 254                                removeAppInfoEventListenerFunc));
 255
 256     // install
 257     AceFunction installFunc = ACE_CREATE_FUNCTION(
 258             FUNCTION_INSTALL_APP,
 259             APPLICATION_FUNCTION_API_INSTALL_APP,
 260             APPLICATION_FEATURES_APPLICATION_INSTALL,
 261             DEVICE_LIST_APPLICATION_INSTALL);
 262     applicationMapping.insert(std::make_pair(
 263                                                            APPLICATION_FUNCTION_API_INSTALL_APP,
 264                                installFunc));
 265
 266     // uninstall
 267     AceFunction uninstallFunc = ACE_CREATE_FUNCTION(
 268             FUNCTION_UNINSTALL_APP,
 269             APPLICATION_FUNCTION_API_UNINSTALL_APP,
 270             APPLICATION_FEATURES_APPLICATION_INSTALL,
 271             DEVICE_LIST_APPLICATION_INSTALL);
 272     applicationMapping.insert(std::make_pair(
 273                                                            APPLICATION_FUNCTION_API_UNINSTALL_APP,
 274                                                            uninstallFunc));
 275
 276     // update
 277     AceFunction updateFunc = ACE_CREATE_FUNCTION(
 278             FUNCTION_UPDATE_APP,
 279             APPLICATION_FUNCTION_API_UPDATE_APP,
 280             APPLICATION_FEATURES_APPLICATION_INSTALL,
 281             DEVICE_LIST_APPLICATION_INSTALL);
 282     applicationMapping.insert(std::make_pair(
 283                                                            APPLICATION_FUNCTION_API_UPDATE_APP,
 284                                                            updateFunc));
 285 #endif
 286         return applicationMapping;
 287 }
 288
 289 }
 290 }