src/standards/Tizen/Call/plugin_config.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 #include <map>
  19 #include <utility>
  20
  21 #include <dpl/assert.h>
  22 #include <Commons/FunctionDefinition.h>
  23 #include <Commons/FunctionDeclaration.h>
  24 #include <Commons/Exception.h>
  25
  26 #define CALL_FEATURE_API "http://tizen.org/api/call"
  27 #define CALL_SIMPLE_FEATURE_API "http://tizen.org/api/call.simple"
  28 #define CALL_HISTORY_FEATURE_API "http://tizen.org/api/call.history"
  29 #define CALL_HISTORY_FEATURE_API_READ "http://tizen.org/api/call.history.read"
  30 #define CALL_HISTORY_FEATURE_API_WRITE "http://tizen.org/api/call.history.write"
  31
  32 namespace TizenApis {
  33 namespace Tizen1_0 {
  34
  35 const char* CALL_DEVICE_CAP_SIMPLE = "call.simple";
  36 const char* CALL_HISTORY_DEVICE_CAP_READ = "call.history.read";
  37 const char* CALL_HISTORY_DEVICE_CAP_WRITE = "call.history.write";
  38
  39 const char* CALL_HISTORY_FUNCTION_API_FIND = "find";
  40 const char* CALL_HISTORY_FUNCTION_API_REMOVE = "remove";
  41 const char* CALL_HISTORY_FUNCTION_API_REMOVE_BATCH = "removeBatch";
  42 const char* CALL_HISTORY_FUNCTION_API_REMOVE_ALL = "removeAll";
  43 const char* CALL_HISTORY_FUNCTION_API_ADDLISTENER = "addListener";
  44 const char* CALL_HISTORY_FUNCTION_API_REMOVELISTENER = "removeListener";
  45
  46 const char* CALL_FUNCTION_API_ISCALLINPROGRESS = "isCallInProgress";
  47 const char* CALL_FUNCTION_API_GETCALLSERVICES = "getCallServices";
  48 const char* CALL_FUNCTION_API_SENDUSSD = "sendUSSD";
  49 const char* CALL_FUNCTION_API_LAUNCHDIALER = "launchDialer";
  50
  51
  52 static WrtDeviceApis::Commons::FunctionMapping createCallFunctions();
  53
  54 static WrtDeviceApis::Commons::FunctionMapping CallFunctions = createCallFunctions();
  55
  56 DEFINE_FUNCTION_GETTER(Call, CallFunctions);
  57
  58 static WrtDeviceApis::Commons::FunctionMapping createCallFunctions()
  59 {
  60         using namespace WrtDeviceApis::Commons;
  61
  62         ACE_CREATE_DEVICE_CAP(DEVICE_CAP_CALL_SIMPLE, CALL_DEVICE_CAP_SIMPLE);
  63         ACE_CREATE_DEVICE_CAP(DEVICE_CAP_CALL_HISTORY_READ, CALL_HISTORY_DEVICE_CAP_READ);
  64         ACE_CREATE_DEVICE_CAP(DEVICE_CAP_CALL_HISTORY_WRITE, CALL_HISTORY_DEVICE_CAP_WRITE);
  65
  66         ACE_CREATE_DEVICE_CAPS_LIST(EMPTY_DEVICE_LIST);
  67
  68         ACE_CREATE_DEVICE_CAPS_LIST(DEVICE_LIST_CALL_SIMPLE);
  69         ACE_ADD_DEVICE_CAP(DEVICE_LIST_CALL_SIMPLE, DEVICE_CAP_CALL_SIMPLE);
  70
  71         ACE_CREATE_DEVICE_CAPS_LIST(DEVICE_LIST_CALL_HISTORY_READ);
  72         ACE_ADD_DEVICE_CAP(DEVICE_LIST_CALL_HISTORY_READ, DEVICE_CAP_CALL_HISTORY_READ);
  73
  74         ACE_CREATE_DEVICE_CAPS_LIST(DEVICE_LIST_CALL_HISTORY_WRITE);
  75         ACE_ADD_DEVICE_CAP(DEVICE_LIST_CALL_HISTORY_WRITE, DEVICE_CAP_CALL_HISTORY_WRITE);
  76
  77         ACE_CREATE_FEATURE(FEATURE_CALL, CALL_FEATURE_API);
  78         ACE_CREATE_FEATURE(FEATURE_CALL_SIMPLE, CALL_SIMPLE_FEATURE_API);
  79         ACE_CREATE_FEATURE(FEATURE_CALL_HISTORY, CALL_HISTORY_FEATURE_API);
  80         ACE_CREATE_FEATURE(FEATURE_CALL_HISTORY_READ, CALL_HISTORY_FEATURE_API_READ);
  81         ACE_CREATE_FEATURE(FEATURE_CALL_HISTORY_WRITE, CALL_HISTORY_FEATURE_API_WRITE);
  82
  83         ACE_CREATE_FEATURE_LIST(CALL_FEATURES_CALL_SIMPLE);
  84         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_SIMPLE, FEATURE_CALL);
  85         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_SIMPLE, FEATURE_CALL_SIMPLE);
  86
  87         ACE_CREATE_FEATURE_LIST(CALL_FEATURES_CALL_HISTORY_READ_WRITE);
  88         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_HISTORY_READ_WRITE, FEATURE_CALL);
  89         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_HISTORY_READ_WRITE, FEATURE_CALL_HISTORY);
  90         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_HISTORY_READ_WRITE, FEATURE_CALL_HISTORY_READ);
  91         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_HISTORY_READ_WRITE, FEATURE_CALL_HISTORY_WRITE);
  92
  93         ACE_CREATE_FEATURE_LIST(CALL_FEATURES_CALL_HISTORY_READ);
  94         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_HISTORY_READ, FEATURE_CALL);
  95         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_HISTORY_READ, FEATURE_CALL_HISTORY);
  96         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_HISTORY_READ, FEATURE_CALL_HISTORY_READ);
  97
  98         ACE_CREATE_FEATURE_LIST(CALL_FEATURES_CALL_HISTORY_WRITE);
  99         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_HISTORY_WRITE, FEATURE_CALL);
 100         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_HISTORY_WRITE, FEATURE_CALL_HISTORY);
 101         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_HISTORY_WRITE, FEATURE_CALL_HISTORY_WRITE);
 102
 103         FunctionMapping CallMapping;
 104
 105         AceFunction findFunc = ACE_CREATE_FUNCTION(
 106                         FUNCTION_FIND,
 107                         CALL_HISTORY_FUNCTION_API_FIND,
 108                         CALL_FEATURES_CALL_HISTORY_READ_WRITE,
 109                         EMPTY_DEVICE_LIST);
 110
 111         CallMapping.insert(std::make_pair(CALL_HISTORY_FUNCTION_API_FIND, findFunc));
 112
 113         AceFunction removeFunc = ACE_CREATE_FUNCTION(
 114                         FUNCTION_REMOVE,
 115                         CALL_HISTORY_FUNCTION_API_REMOVE,
 116                         CALL_FEATURES_CALL_HISTORY_WRITE,
 117                         EMPTY_DEVICE_LIST);
 118
 119         CallMapping.insert(std::make_pair(CALL_HISTORY_FUNCTION_API_REMOVE, removeFunc));
 120
 121         AceFunction removeBatchFunc = ACE_CREATE_FUNCTION(
 122                         FUNCTION_REMOVE_BATCH,
 123                         CALL_HISTORY_FUNCTION_API_REMOVE_BATCH,
 124                         CALL_FEATURES_CALL_HISTORY_WRITE,
 125                         EMPTY_DEVICE_LIST);
 126
 127         CallMapping.insert(std::make_pair(CALL_HISTORY_FUNCTION_API_REMOVE_BATCH, removeBatchFunc));
 128
 129         AceFunction removeAllFunc = ACE_CREATE_FUNCTION(
 130                         FUNCTION_REMOVE_ALL,
 131                         CALL_HISTORY_FUNCTION_API_REMOVE_ALL,
 132                         CALL_FEATURES_CALL_HISTORY_WRITE,
 133                         EMPTY_DEVICE_LIST);
 134
 135         CallMapping.insert(std::make_pair(CALL_HISTORY_FUNCTION_API_REMOVE_ALL, removeAllFunc));
 136
 137         AceFunction addListenerFunc = ACE_CREATE_FUNCTION(
 138                         FUNCTION_ADD_LISTENER,
 139                         CALL_HISTORY_FUNCTION_API_ADDLISTENER,
 140                         CALL_FEATURES_CALL_HISTORY_READ_WRITE,
 141                         EMPTY_DEVICE_LIST);
 142
 143         CallMapping.insert(std::make_pair(CALL_HISTORY_FUNCTION_API_ADDLISTENER, addListenerFunc));
 144
 145         AceFunction removeListenerFunc = ACE_CREATE_FUNCTION(
 146                         FUNCTION_REMOVE_LISTENER,
 147                         CALL_HISTORY_FUNCTION_API_REMOVELISTENER,
 148                         CALL_FEATURES_CALL_HISTORY_READ_WRITE,
 149                         EMPTY_DEVICE_LIST);
 150
 151         CallMapping.insert(std::make_pair(CALL_HISTORY_FUNCTION_API_REMOVELISTENER, removeListenerFunc));
 152
 153         AceFunction isCallInProgressFunc = ACE_CREATE_FUNCTION(
 154                         FUNCTION_IS_CALL_IN_PROGRESS,
 155                         CALL_FUNCTION_API_ISCALLINPROGRESS,
 156                         CALL_FEATURES_CALL_SIMPLE,
 157                         EMPTY_DEVICE_LIST);
 158
 159         CallMapping.insert(std::make_pair(CALL_FUNCTION_API_ISCALLINPROGRESS, isCallInProgressFunc));
 160
 161         AceFunction getCallServicesFunc = ACE_CREATE_FUNCTION(
 162                         FUNCTION_GET_CALL_SERVICES,
 163                         CALL_FUNCTION_API_GETCALLSERVICES,
 164                         CALL_FEATURES_CALL_SIMPLE,
 165                         EMPTY_DEVICE_LIST);
 166
 167         CallMapping.insert(std::make_pair(CALL_FUNCTION_API_GETCALLSERVICES, getCallServicesFunc));
 168
 169         AceFunction sendUSSDFunc = ACE_CREATE_FUNCTION(
 170                         FUNCTION_SEND_USSD,
 171                         CALL_FUNCTION_API_SENDUSSD,
 172                         CALL_FEATURES_CALL_SIMPLE,
 173                         EMPTY_DEVICE_LIST);
 174
 175         CallMapping.insert(std::make_pair(CALL_FUNCTION_API_SENDUSSD, sendUSSDFunc));
 176
 177         AceFunction launchDialerFunc = ACE_CREATE_FUNCTION(
 178                         FUNCTION_LAUNCH_DIALER,
 179                         CALL_FUNCTION_API_LAUNCHDIALER,
 180                         CALL_FEATURES_CALL_SIMPLE,
 181                         EMPTY_DEVICE_LIST);
 182
 183         CallMapping.insert(std::make_pair(CALL_FUNCTION_API_LAUNCHDIALER, launchDialerFunc));
 184
 185         return CallMapping;
 186 }
 187
 188 }
 189 }