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