src/Messaging/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 <map>
  20 #include <utility>
  21 #include <Commons/FunctionDefinition.h>
  22 #include <Commons/FunctionDeclaration.h>
  23 #include <Commons/Exception.h>
  24 #include "plugin_config.h"
  25
  26 #define MESSAGING_FEATURE_API_READ "http://tizen.org/privilege/messaging.read"
  27 #define MESSAGING_FEATURE_API_SEND "http://tizen.org/privilege/messaging.send"  // before sendMessage move to write privilege start
  28 #define MESSAGING_FEATURE_API_WRITE "http://tizen.org/privilege/messaging.write"
  29
  30 #define MESSAGING_DEVICE_CAP_READ "messaging.read"
  31 #define MESSAGING_DEVICE_CAP_SEND "messaging.send"      // before sendMessage move to write privilege start
  32 #define MESSAGING_DEVICE_CAP_WRITE "messaging.write"
  33
  34 namespace DeviceAPI {
  35 namespace Messaging {
  36
  37 using namespace WrtDeviceApis::Commons;
  38
  39 static WrtDeviceApis::Commons::FunctionMapping createMessagingFunctions();
  40 static WrtDeviceApis::Commons::FunctionMapping MessagingFunctions = createMessagingFunctions();
  41
  42 DEFINE_FUNCTION_GETTER(Messaging, MessagingFunctions);
  43
  44 static WrtDeviceApis::Commons::FunctionMapping createMessagingFunctions()
  45 {
  46      /**
  47      * Device capabilities
  48      */
  49
  50     ACE_CREATE_DEVICE_CAP(DEVICE_CAP_MESSAGING_READ, MESSAGING_DEVICE_CAP_READ);
  51     ACE_CREATE_DEVICE_CAP(DEVICE_CAP_MESSAGING_SEND, MESSAGING_DEVICE_CAP_SEND);
  52     ACE_CREATE_DEVICE_CAP(DEVICE_CAP_MESSAGING_WRITE, MESSAGING_DEVICE_CAP_WRITE);
  53
  54     ACE_CREATE_DEVICE_CAPS_LIST(EMPTY_DEVICE_LIST);
  55
  56     ACE_CREATE_DEVICE_CAPS_LIST(DEVICE_LIST_MESSAGING_READ);
  57     ACE_ADD_DEVICE_CAP(DEVICE_LIST_MESSAGING_READ, DEVICE_CAP_MESSAGING_READ);
  58
  59     ACE_CREATE_DEVICE_CAPS_LIST(DEVICE_LIST_MESSAGING_SEND);
  60     ACE_ADD_DEVICE_CAP(DEVICE_LIST_MESSAGING_SEND, DEVICE_CAP_MESSAGING_SEND);
  61
  62     ACE_CREATE_DEVICE_CAPS_LIST(DEVICE_LIST_MESSAGING_WRITE);
  63     ACE_ADD_DEVICE_CAP(DEVICE_LIST_MESSAGING_WRITE, DEVICE_CAP_MESSAGING_WRITE);
  64
  65     /**
  66     * API features
  67     */
  68     ACE_CREATE_FEATURE(FEATURE_MESSAGING_READ, MESSAGING_FEATURE_API_READ);
  69     ACE_CREATE_FEATURE(FEATURE_MESSAGING_SEND, MESSAGING_FEATURE_API_SEND);
  70     ACE_CREATE_FEATURE(FEATURE_MESSAGING_WRITE, MESSAGING_FEATURE_API_WRITE);
  71
  72     ACE_CREATE_FEATURE_LIST(MESSAGING_FEATURES_MESSAGING_READ_SEND_WRITE);
  73
  74     ACE_ADD_API_FEATURE(MESSAGING_FEATURES_MESSAGING_READ_SEND_WRITE, FEATURE_MESSAGING_READ);
  75     ACE_ADD_API_FEATURE(MESSAGING_FEATURES_MESSAGING_READ_SEND_WRITE, FEATURE_MESSAGING_SEND);
  76     ACE_ADD_API_FEATURE(MESSAGING_FEATURES_MESSAGING_READ_SEND_WRITE, FEATURE_MESSAGING_WRITE);
  77
  78     ACE_CREATE_FEATURE_LIST(MESSAGING_FEATURES_MESSAGING_READ);
  79     ACE_ADD_API_FEATURE(MESSAGING_FEATURES_MESSAGING_READ, FEATURE_MESSAGING_READ);
  80
  81     ACE_CREATE_FEATURE_LIST(MESSAGING_FEATURES_MESSAGING_SEND);
  82     ACE_ADD_API_FEATURE(MESSAGING_FEATURES_MESSAGING_SEND, FEATURE_MESSAGING_SEND);
  83
  84     ACE_CREATE_FEATURE_LIST(MESSAGING_FEATURES_MESSAGING_WRITE);
  85     ACE_ADD_API_FEATURE(MESSAGING_FEATURES_MESSAGING_WRITE, FEATURE_MESSAGING_WRITE);
  86
  87 // before sendMessage move to write privilege start
  88     ACE_CREATE_FEATURE_LIST(MESSAGING_FEATURES_MESSAGING_SEND_WRITE);
  89
  90         ACE_ADD_API_FEATURE(MESSAGING_FEATURES_MESSAGING_SEND_WRITE, FEATURE_MESSAGING_SEND);
  91         ACE_ADD_API_FEATURE(MESSAGING_FEATURES_MESSAGING_SEND_WRITE, FEATURE_MESSAGING_WRITE);
  92 // before sendMessage move to write privilege end
  93 #if 0
  94     ACE_CREATE_FEATURE_LIST(MESSAGING_FEATURES_MESSAGING);
  95     ACE_ADD_API_FEATURE(MESSAGING_FEATURES_MESSAGING, FEATURE_MESSAGING);
  96
  97     ACE_CREATE_FEATURE_LIST(MESSAGING_FEATURES_READ);
  98     ACE_ADD_API_FEATURE(MESSAGING_FEATURES_READ, FEATURE_MESSAGING_READ);
  99
 100     ACE_CREATE_FEATURE_LIST(MESSAGING_FEATURES_SEND);
 101     ACE_ADD_API_FEATURE(MESSAGING_FEATURES_SEND, FEATURE_MESSAGING_SEND);
 102
 103     ACE_CREATE_FEATURE_LIST(MESSAGING_FEATURES_WRITE);
 104     ACE_ADD_API_FEATURE(MESSAGING_FEATURES_WRITE, FEATURE_MESSAGING_WRITE);
 105 #endif
 106     /**
 107      * Functions
 108      */
 109
 110      FunctionMapping MessagingFunctions;
 111
 112         //get Message Service
 113         AceFunction getMessagingServiceFunc = ACE_CREATE_FUNCTION(
 114                         FUNCTION_GET_MGR_SERVICE,
 115                         MESSAGING_FUNCTION_API_GET_MESSAGING_SERVICE,
 116                         MESSAGING_FEATURES_MESSAGING_READ_SEND_WRITE,
 117                         EMPTY_DEVICE_LIST);
 118
 119         MessagingFunctions.insert(std::make_pair(
 120                         MESSAGING_FUNCTION_API_GET_MESSAGING_SERVICE,
 121                         getMessagingServiceFunc));
 122
 123       /**  Read  **/
 124
 125
 126         AceFunction cancelOpFolderFunc = ACE_CREATE_FUNCTION(
 127                           FUNCTION_GET_MGR_SERVICE,
 128                           MESSAGING_FUNCTION_API_CANCEL_OPERATION,
 129                           MESSAGING_FEATURES_MESSAGING_READ,
 130                           EMPTY_DEVICE_LIST);
 131
 132         MessagingFunctions.insert( std::make_pair(
 133                           MESSAGING_FUNCTION_API_CANCEL_OPERATION,
 134                           cancelOpFolderFunc));
 135
 136       AceFunction findMessagesFunc = ACE_CREATE_FUNCTION(
 137                         FUNCTION_GET_MGR_SERVICE,
 138                         MESSAGING_FUNCTION_API_FIND_MESSAGES,
 139                         MESSAGING_FEATURES_MESSAGING_READ,
 140                         EMPTY_DEVICE_LIST);
 141
 142         MessagingFunctions.insert( std::make_pair(
 143                         MESSAGING_FUNCTION_API_FIND_MESSAGES,
 144                         findMessagesFunc));
 145
 146       AceFunction findConversationsFunc = ACE_CREATE_FUNCTION(
 147                         FUNCTION_GET_MGR_SERVICE,
 148                         MESSAGING_FUNCTION_API_FIND_CONVERSATIONS,
 149                         MESSAGING_FEATURES_MESSAGING_READ,
 150                         EMPTY_DEVICE_LIST);
 151
 152         MessagingFunctions.insert( std::make_pair(
 153                         MESSAGING_FUNCTION_API_FIND_CONVERSATIONS,
 154                         findConversationsFunc));
 155
 156       AceFunction findFoldersFunc = ACE_CREATE_FUNCTION(
 157                         FUNCTION_GET_MGR_SERVICE,
 158                         MESSAGING_FUNCTION_API_FIND_FOLDERS,
 159                         MESSAGING_FEATURES_MESSAGING_READ,
 160                         EMPTY_DEVICE_LIST);
 161
 162         MessagingFunctions.insert( std::make_pair(
 163                         MESSAGING_FUNCTION_API_FIND_FOLDERS,
 164                         findFoldersFunc));
 165
 166       AceFunction addMessagesChangeListenerFunc = ACE_CREATE_FUNCTION(
 167                         FUNCTION_GET_MGR_SERVICE,
 168                         MESSAGING_FUNCTION_API_ADD_MESSAGES_CHANGE_LISTNER,
 169                         MESSAGING_FEATURES_MESSAGING_READ,
 170                         EMPTY_DEVICE_LIST);
 171
 172         MessagingFunctions.insert( std::make_pair(
 173                         MESSAGING_FUNCTION_API_ADD_MESSAGES_CHANGE_LISTNER,
 174                         addMessagesChangeListenerFunc));
 175
 176       AceFunction addConversationsChangeListenerFunc = ACE_CREATE_FUNCTION(
 177                         FUNCTION_GET_MGR_SERVICE,
 178                         MESSAGING_FUNCTION_API_ADD_CONVERSATIONS_CHANGE_LISTNER,
 179                         MESSAGING_FEATURES_MESSAGING_READ,
 180                         EMPTY_DEVICE_LIST);
 181
 182         MessagingFunctions.insert( std::make_pair(
 183                         MESSAGING_FUNCTION_API_ADD_CONVERSATIONS_CHANGE_LISTNER,
 184                         addConversationsChangeListenerFunc));
 185
 186       AceFunction addFoldersChangeListenerFunc = ACE_CREATE_FUNCTION(
 187                         FUNCTION_GET_MGR_SERVICE,
 188                         MESSAGING_FUNCTION_API_ADD_FOLDERS_CHANGE_LISTNER,
 189                         MESSAGING_FEATURES_MESSAGING_READ,
 190                         EMPTY_DEVICE_LIST);
 191
 192         MessagingFunctions.insert( std::make_pair(
 193                         MESSAGING_FUNCTION_API_ADD_FOLDERS_CHANGE_LISTNER,
 194                         addFoldersChangeListenerFunc));
 195
 196       AceFunction removeChangeListenerFunc = ACE_CREATE_FUNCTION(
 197                         FUNCTION_GET_MGR_SERVICE,
 198                         MESSAGING_FUNCTION_API_REMOVE_CHANGE_LISTENER,
 199                         MESSAGING_FEATURES_MESSAGING_READ,
 200                         EMPTY_DEVICE_LIST);
 201
 202         MessagingFunctions.insert( std::make_pair(
 203                         MESSAGING_FUNCTION_API_REMOVE_CHANGE_LISTENER,
 204                         removeChangeListenerFunc));
 205
 206
 207         /**  Send  **/
 208      //create Message
 209      AceFunction createMessageFunc = ACE_CREATE_FUNCTION(
 210                         FUNCTION_GET_MGR_SERVICE,
 211                         MESSAGING_FUNCTION_API_CREATE_MESSAGE,
 212                         MESSAGING_FEATURES_MESSAGING_SEND,
 213                         EMPTY_DEVICE_LIST);
 214
 215         MessagingFunctions.insert( std::make_pair(
 216                         MESSAGING_FUNCTION_API_CREATE_MESSAGE,
 217                         createMessageFunc));
 218
 219  // before sendMessage move to write privilege start
 220      AceFunction sendMessageFunc = ACE_CREATE_FUNCTION(
 221                         FUNCTION_GET_MGR_SERVICE,
 222                         MESSAGING_FUNCTION_API_SEND_MESSAGE,
 223                         MESSAGING_FEATURES_MESSAGING_SEND_WRITE,
 224                         EMPTY_DEVICE_LIST);
 225
 226         MessagingFunctions.insert( std::make_pair(
 227                         MESSAGING_FUNCTION_API_SEND_MESSAGE,
 228                         sendMessageFunc));
 229 // before sendMessage move to write privilege end
 230       /**  Write  **/
 231            AceFunction loadMessageBodyFunc = ACE_CREATE_FUNCTION(
 232                         FUNCTION_GET_MGR_SERVICE,
 233                         MESSAGING_FUNCTION_API_LOAD_MESSAGE_BODY,
 234                         MESSAGING_FEATURES_MESSAGING_WRITE,
 235                         EMPTY_DEVICE_LIST);
 236
 237         MessagingFunctions.insert( std::make_pair(
 238                         MESSAGING_FUNCTION_API_LOAD_MESSAGE_BODY,
 239                         loadMessageBodyFunc));
 240
 241       AceFunction loadMessageAttachmentFunc = ACE_CREATE_FUNCTION(
 242                         FUNCTION_GET_MGR_SERVICE,
 243                         MESSAGING_FUNCTION_API_LOAD_MESSAGE_ATTACHMENT,
 244                         MESSAGING_FEATURES_MESSAGING_WRITE,
 245                         EMPTY_DEVICE_LIST);
 246
 247         MessagingFunctions.insert( std::make_pair(
 248                         MESSAGING_FUNCTION_API_LOAD_MESSAGE_ATTACHMENT,
 249                         loadMessageAttachmentFunc));
 250
 251       AceFunction syncFunc = ACE_CREATE_FUNCTION(
 252                         FUNCTION_GET_MGR_SERVICE,
 253                         MESSAGING_FUNCTION_API_SYNC,
 254                         MESSAGING_FEATURES_MESSAGING_WRITE,
 255                         EMPTY_DEVICE_LIST);
 256
 257         MessagingFunctions.insert( std::make_pair(
 258                         MESSAGING_FUNCTION_API_SYNC,
 259                         syncFunc));
 260
 261       AceFunction syncFolderFunc = ACE_CREATE_FUNCTION(
 262                         FUNCTION_GET_MGR_SERVICE,
 263                         MESSAGING_FUNCTION_API_SYNC_FOLDER,
 264                         MESSAGING_FEATURES_MESSAGING_WRITE,
 265                         EMPTY_DEVICE_LIST);
 266
 267         MessagingFunctions.insert( std::make_pair(
 268                         MESSAGING_FUNCTION_API_SYNC_FOLDER,
 269                         syncFolderFunc));
 270
 271      AceFunction addDraftMessageFunc = ACE_CREATE_FUNCTION(
 272                         FUNCTION_GET_MGR_SERVICE,
 273                         MESSAGING_FUNCTION_API_ADD_DRAFT_MESSAGE,
 274                         MESSAGING_FEATURES_MESSAGING_WRITE,
 275                         EMPTY_DEVICE_LIST);
 276
 277         MessagingFunctions.insert( std::make_pair(
 278                         MESSAGING_FUNCTION_API_ADD_DRAFT_MESSAGE,
 279                         addDraftMessageFunc));
 280
 281      AceFunction removeMessagesFunc = ACE_CREATE_FUNCTION(
 282                         FUNCTION_GET_MGR_SERVICE,
 283                         MESSAGING_FUNCTION_API_REMOVE_MESSAGES,
 284                         MESSAGING_FEATURES_MESSAGING_WRITE,
 285                         EMPTY_DEVICE_LIST);
 286
 287         MessagingFunctions.insert( std::make_pair(
 288                         MESSAGING_FUNCTION_API_REMOVE_MESSAGES,
 289                         removeMessagesFunc));
 290
 291      AceFunction removeConversationsFunc = ACE_CREATE_FUNCTION(
 292                         FUNCTION_GET_MGR_SERVICE,
 293                         MESSAGING_FUNCTION_API_REMOVE_CONVERSATIONS,
 294                         MESSAGING_FEATURES_MESSAGING_WRITE,
 295                         EMPTY_DEVICE_LIST);
 296
 297         MessagingFunctions.insert( std::make_pair(
 298                         MESSAGING_FUNCTION_API_REMOVE_CONVERSATIONS,
 299                         removeConversationsFunc));
 300
 301      AceFunction updateMessagesFunc = ACE_CREATE_FUNCTION(
 302                         FUNCTION_GET_MGR_SERVICE,
 303                         MESSAGING_FUNCTION_API_UPDATE_MESSAGES,
 304                         MESSAGING_FEATURES_MESSAGING_WRITE,
 305                         EMPTY_DEVICE_LIST);
 306
 307         MessagingFunctions.insert( std::make_pair(
 308                         MESSAGING_FUNCTION_API_UPDATE_MESSAGES,
 309                         updateMessagesFunc));
 310
 311 // before sendMessage move to write privilege start
 312 /*
 313      AceFunction sendMessageFunc = ACE_CREATE_FUNCTION(
 314                         FUNCTION_GET_MGR_SERVICE,
 315                         MESSAGING_FUNCTION_API_SEND_MESSAGE,
 316                         MESSAGING_FEATURES_MESSAGING_WRITE,
 317                         EMPTY_DEVICE_LIST);
 318
 319         MessagingFunctions.insert( std::make_pair(
 320                         MESSAGING_FUNCTION_API_SEND_MESSAGE,
 321                         sendMessageFunc));
 322 */
 323 // before sendMessage move to write privilege end
 324     return MessagingFunctions;
 325 }
 326
 327
 328 }
 329 }
 330
 331 #undef MESSAGING_FEATURE_API
 332 #undef MESSAGING_FEATURE_API_READ
 333 #undef MESSAGING_FEATURE_API_SEND // before sendMessage move to write privilege start
 334 #undef MESSAGING_FEATURE_API_WRITE
 335 #undef MESSAGING_DEVICE_CAP_READ
 336 #undef MESSAGING_DEVICE_CAP_SEND // before sendMessage move to write privilege start
 337 #undef MESSAGING_DEVICE_CAP_WRITE
 338