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_STATE_FEATURE_API "http://tizen.org/api/call.state"
  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_STATE = "call.state";
  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
  48
  49 static WrtDeviceApis::Commons::FunctionMapping createCallFunctions();
  50
  51 static WrtDeviceApis::Commons::FunctionMapping CallFunctions = createCallFunctions();
  52
  53 DEFINE_FUNCTION_GETTER(Call, CallFunctions);
  54
  55 static WrtDeviceApis::Commons::FunctionMapping createCallFunctions()
  56 {
  57         using namespace WrtDeviceApis::Commons;
  58
  59         ACE_CREATE_DEVICE_CAP(DEVICE_CAP_CALL_STATE, CALL_DEVICE_CAP_STATE);
  60         ACE_CREATE_DEVICE_CAP(DEVICE_CAP_CALL_HISTORY_READ, CALL_HISTORY_DEVICE_CAP_READ);
  61         ACE_CREATE_DEVICE_CAP(DEVICE_CAP_CALL_HISTORY_WRITE, CALL_HISTORY_DEVICE_CAP_WRITE);
  62
  63         ACE_CREATE_DEVICE_CAPS_LIST(EMPTY_DEVICE_LIST);
  64
  65         ACE_CREATE_DEVICE_CAPS_LIST(DEVICE_LIST_CALL_STATE);
  66         ACE_ADD_DEVICE_CAP(DEVICE_LIST_CALL_STATE, DEVICE_CAP_CALL_STATE);
  67
  68         ACE_CREATE_DEVICE_CAPS_LIST(DEVICE_LIST_CALL_HISTORY_READ);
  69         ACE_ADD_DEVICE_CAP(DEVICE_LIST_CALL_HISTORY_READ, DEVICE_CAP_CALL_HISTORY_READ);
  70
  71         ACE_CREATE_DEVICE_CAPS_LIST(DEVICE_LIST_CALL_HISTORY_WRITE);
  72         ACE_ADD_DEVICE_CAP(DEVICE_LIST_CALL_HISTORY_WRITE, DEVICE_CAP_CALL_HISTORY_WRITE);
  73
  74         ACE_CREATE_FEATURE(FEATURE_CALL, CALL_FEATURE_API);
  75         ACE_CREATE_FEATURE(FEATURE_CALL_STATE, CALL_STATE_FEATURE_API);
  76         ACE_CREATE_FEATURE(FEATURE_CALL_HISTORY, CALL_HISTORY_FEATURE_API);
  77         ACE_CREATE_FEATURE(FEATURE_CALL_HISTORY_READ, CALL_HISTORY_FEATURE_API_READ);
  78         ACE_CREATE_FEATURE(FEATURE_CALL_HISTORY_WRITE, CALL_HISTORY_FEATURE_API_WRITE);
  79
  80         ACE_CREATE_FEATURE_LIST(CALL_FEATURES_CALL_STATE);
  81         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_STATE, FEATURE_CALL);
  82         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_STATE, FEATURE_CALL_STATE);
  83
  84         ACE_CREATE_FEATURE_LIST(CALL_FEATURES_CALL_HISTORY_READ_WRITE);
  85         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_HISTORY_READ_WRITE, FEATURE_CALL);
  86         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_HISTORY_READ_WRITE, FEATURE_CALL_HISTORY);
  87         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_HISTORY_READ_WRITE, FEATURE_CALL_HISTORY_READ);
  88         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_HISTORY_READ_WRITE, FEATURE_CALL_HISTORY_WRITE);
  89
  90         ACE_CREATE_FEATURE_LIST(CALL_FEATURES_CALL_HISTORY_READ);
  91         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_HISTORY_READ, FEATURE_CALL);
  92         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_HISTORY_READ, FEATURE_CALL_HISTORY);
  93         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_HISTORY_READ, FEATURE_CALL_HISTORY_READ);
  94
  95         ACE_CREATE_FEATURE_LIST(CALL_FEATURES_CALL_HISTORY_WRITE);
  96         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_HISTORY_WRITE, FEATURE_CALL);
  97         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_HISTORY_WRITE, FEATURE_CALL_HISTORY);
  98         ACE_ADD_API_FEATURE(CALL_FEATURES_CALL_HISTORY_WRITE, FEATURE_CALL_HISTORY_WRITE);
  99
 100         FunctionMapping CallMapping;
 101
 102         AceFunction findFunc = ACE_CREATE_FUNCTION(
 103                         FUNCTION_FIND,
 104                         CALL_HISTORY_FUNCTION_API_FIND,
 105                         CALL_FEATURES_CALL_HISTORY_READ_WRITE,
 106                         EMPTY_DEVICE_LIST);
 107
 108         CallMapping.insert(std::make_pair(CALL_HISTORY_FUNCTION_API_FIND, findFunc));
 109
 110         AceFunction removeFunc = ACE_CREATE_FUNCTION(
 111                         FUNCTION_REMOVE,
 112                         CALL_HISTORY_FUNCTION_API_REMOVE,
 113                         CALL_FEATURES_CALL_HISTORY_WRITE,
 114                         EMPTY_DEVICE_LIST);
 115
 116         CallMapping.insert(std::make_pair(CALL_HISTORY_FUNCTION_API_REMOVE, removeFunc));
 117
 118         AceFunction removeBatchFunc = ACE_CREATE_FUNCTION(
 119                         FUNCTION_REMOVE_BATCH,
 120                         CALL_HISTORY_FUNCTION_API_REMOVE_BATCH,
 121                         CALL_FEATURES_CALL_HISTORY_WRITE,
 122                         EMPTY_DEVICE_LIST);
 123
 124         CallMapping.insert(std::make_pair(CALL_HISTORY_FUNCTION_API_REMOVE_BATCH, removeBatchFunc));
 125
 126         AceFunction removeAllFunc = ACE_CREATE_FUNCTION(
 127                         FUNCTION_REMOVE_ALL,
 128                         CALL_HISTORY_FUNCTION_API_REMOVE_ALL,
 129                         CALL_FEATURES_CALL_HISTORY_WRITE,
 130                         EMPTY_DEVICE_LIST);
 131
 132         CallMapping.insert(std::make_pair(CALL_HISTORY_FUNCTION_API_REMOVE_ALL, removeAllFunc));
 133
 134         AceFunction addListenerFunc = ACE_CREATE_FUNCTION(
 135                         FUNCTION_ADD_LISTENER,
 136                         CALL_HISTORY_FUNCTION_API_ADDLISTENER,
 137                         CALL_FEATURES_CALL_HISTORY_READ_WRITE,
 138                         EMPTY_DEVICE_LIST);
 139
 140         CallMapping.insert(std::make_pair(CALL_HISTORY_FUNCTION_API_ADDLISTENER, addListenerFunc));
 141
 142         AceFunction removeListenerFunc = ACE_CREATE_FUNCTION(
 143                         FUNCTION_REMOVE_LISTENER,
 144                         CALL_HISTORY_FUNCTION_API_REMOVELISTENER,
 145                         CALL_FEATURES_CALL_HISTORY_READ_WRITE,
 146                         EMPTY_DEVICE_LIST);
 147
 148         CallMapping.insert(std::make_pair(CALL_HISTORY_FUNCTION_API_REMOVELISTENER, removeListenerFunc));
 149
 150         AceFunction isCallInProgressFunc = ACE_CREATE_FUNCTION(
 151                         FUNCTION_IS_CALL_IN_PROGRESS,
 152                         CALL_FUNCTION_API_ISCALLINPROGRESS,
 153                         CALL_FEATURES_CALL_STATE,
 154                         EMPTY_DEVICE_LIST);
 155
 156         CallMapping.insert(std::make_pair(CALL_FUNCTION_API_ISCALLINPROGRESS, isCallInProgressFunc));
 157
 158         return CallMapping;
 159 }
 160
 161 }
 162 }