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