src/standards/Tizen/Calendar/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 <Commons/FunctionDefinition.h>
  19 #include <Commons/FunctionDeclaration.h>
  20 #include <iostream>
  21 #include <Commons/Exception.h>
  22 #include <dpl/exception.h>
  23 #include <map>
  24
  25 #include "plugin_config.h"
  26
  27 #define CALENDAR_FEATURE_API "http://tizen.org/api/calendar"
  28 #define CALENDAR_FEATURE_API_READ  "http://tizen.org/api/calendar.read"
  29 #define CALENDAR_FEATURE_API_WRITE "http://tizen.org/api/calendar.write"
  30
  31 #define CALENDAR_DEVICE_CAP_READ "calendar.read"
  32 #define CALENDAR_DEVICE_CAP_WRITE "calendar.write"
  33
  34 using namespace WrtDeviceApis::Commons;
  35
  36 namespace TizenApis {
  37 namespace Tizen1_0 {
  38 namespace Calendar {
  39
  40 static FunctionMapping createCalendarFunctions();
  41
  42 static FunctionMapping CalendarFunctions =
  43     createCalendarFunctions();
  44
  45 DEFINE_FUNCTION_GETTER(Calendar, CalendarFunctions);
  46
  47 static FunctionMapping createCalendarFunctions()
  48 {
  49     /**
  50      * Device capabilities
  51      */
  52     ACE_CREATE_DEVICE_CAP(DEVICE_CAP_CALENDAR_READ, CALENDAR_DEVICE_CAP_READ);
  53     ACE_CREATE_DEVICE_CAP(DEVICE_CAP_CALENDAR_WRITE, CALENDAR_DEVICE_CAP_WRITE);
  54
  55     ACE_CREATE_DEVICE_CAPS_LIST(DEVICE_LIST_CALENDAR_READ);
  56     ACE_ADD_DEVICE_CAP(DEVICE_LIST_CALENDAR_READ, DEVICE_CAP_CALENDAR_READ);
  57
  58     ACE_CREATE_DEVICE_CAPS_LIST(DEVICE_LIST_CALENDAR_WRITE);
  59     ACE_ADD_DEVICE_CAP(DEVICE_LIST_CALENDAR_WRITE, DEVICE_CAP_CALENDAR_WRITE);
  60
  61     /**
  62      * Api Features
  63      */
  64     ACE_CREATE_FEATURE(FEATURE_CALENDAR, CALENDAR_FEATURE_API);
  65     ACE_CREATE_FEATURE(FEATURE_CALENDAR_READ, CALENDAR_FEATURE_API_READ);
  66     ACE_CREATE_FEATURE(FEATURE_CALENDAR_WRITE, CALENDAR_FEATURE_API_WRITE);
  67
  68     ACE_CREATE_FEATURE_LIST(CALENDAR_FEATURES_CALENDAR_READ_WRITE);
  69     ACE_ADD_API_FEATURE(CALENDAR_FEATURES_CALENDAR_READ_WRITE,
  70                         FEATURE_CALENDAR);
  71     ACE_ADD_API_FEATURE(CALENDAR_FEATURES_CALENDAR_READ_WRITE,
  72                         FEATURE_CALENDAR_READ);
  73     ACE_ADD_API_FEATURE(CALENDAR_FEATURES_CALENDAR_READ_WRITE,
  74                         FEATURE_CALENDAR_WRITE);
  75
  76     ACE_CREATE_FEATURE_LIST(CALENDAR_FEATURES_CALENDAR_READ);
  77     ACE_ADD_API_FEATURE(CALENDAR_FEATURES_CALENDAR_READ, FEATURE_CALENDAR);
  78     ACE_ADD_API_FEATURE(CALENDAR_FEATURES_CALENDAR_READ, FEATURE_CALENDAR_READ);
  79
  80     ACE_CREATE_FEATURE_LIST(CALENDAR_FEATURES_CALENDAR_WRITE);
  81     ACE_ADD_API_FEATURE(CALENDAR_FEATURES_CALENDAR_WRITE, FEATURE_CALENDAR);
  82     ACE_ADD_API_FEATURE(CALENDAR_FEATURES_CALENDAR_WRITE,
  83                         FEATURE_CALENDAR_WRITE);
  84
  85     /**
  86      * Functions
  87      */
  88     FunctionMapping calendarMapping;
  89
  90     //getCalendars
  91     AceFunction getCalendarsFunc = ACE_CREATE_FUNCTION(
  92             FUNCTION_GET_CALENDARS,
  93             CALENDAR_FUNCTION_API_GET_CALENDARS,
  94             CALENDAR_FEATURES_CALENDAR_READ_WRITE,
  95             DEVICE_LIST_CALENDAR_READ);
  96
  97     calendarMapping.insert(std::make_pair(
  98                                CALENDAR_FUNCTION_API_GET_CALENDARS,
  99                                getCalendarsFunc));
 100
 101     //getDefaultCalendar
 102     AceFunction getDefaultCalendarFunc = ACE_CREATE_FUNCTION(
 103             FUNCTION_GET_DEFAULT_CALENDAR,
 104             CALENDAR_FUNCTION_API_GET_DEFAULT_CALENDAR,
 105             CALENDAR_FEATURES_CALENDAR_READ_WRITE,
 106             DEVICE_LIST_CALENDAR_READ);
 107
 108     calendarMapping.insert(std::make_pair(
 109                                CALENDAR_FUNCTION_API_GET_DEFAULT_CALENDAR,
 110                                getDefaultCalendarFunc));
 111
 112     //getCalendar
 113     AceFunction getCalendarFunc = ACE_CREATE_FUNCTION(
 114             FUNCTION_GET_CALENDAR,
 115             CALENDAR_FUNCTION_API_GET_CALENDAR,
 116             CALENDAR_FEATURES_CALENDAR_READ_WRITE,
 117             DEVICE_LIST_CALENDAR_READ);
 118
 119     calendarMapping.insert(std::make_pair(
 120                                CALENDAR_FUNCTION_API_GET_CALENDAR,
 121                                getCalendarFunc));
 122
 123     //find
 124     AceFunction findFunc = ACE_CREATE_FUNCTION(
 125             FUNCTION_FIND,
 126             CALENDAR_FUNCTION_API_FIND,
 127             CALENDAR_FEATURES_CALENDAR_READ,
 128             DEVICE_LIST_CALENDAR_READ);
 129
 130     calendarMapping.insert(std::make_pair(
 131                                CALENDAR_FUNCTION_API_FIND,
 132                                findFunc));
 133
 134     //add
 135     AceFunction addFunc = ACE_CREATE_FUNCTION(
 136             FUNCTION_ADD,
 137             CALENDAR_FUNCTION_API_ADD,
 138             CALENDAR_FEATURES_CALENDAR_WRITE,
 139             DEVICE_LIST_CALENDAR_WRITE);
 140
 141     calendarMapping.insert(std::make_pair(
 142                                CALENDAR_FUNCTION_API_ADD,
 143                                addFunc));
 144
 145     //addBatch
 146     AceFunction addBatchFunc = ACE_CREATE_FUNCTION(
 147             FUNCTION_ADD_BATCH,
 148             CALENDAR_FUNCTION_API_ADD_BATCH,
 149             CALENDAR_FEATURES_CALENDAR_WRITE,
 150             DEVICE_LIST_CALENDAR_WRITE);
 151
 152     calendarMapping.insert(std::make_pair(
 153                                CALENDAR_FUNCTION_API_ADD_BATCH,
 154                                addBatchFunc));
 155
 156     //update
 157     AceFunction updateFunc = ACE_CREATE_FUNCTION(
 158             FUNCTION_UPDATE,
 159             CALENDAR_FUNCTION_API_UPDATE,
 160             CALENDAR_FEATURES_CALENDAR_WRITE,
 161             DEVICE_LIST_CALENDAR_WRITE);
 162
 163     calendarMapping.insert(std::make_pair(
 164                                CALENDAR_FUNCTION_API_UPDATE,
 165                                updateFunc));
 166
 167     //updateBatch
 168     AceFunction updateBatchFunc = ACE_CREATE_FUNCTION(
 169             FUNCTION_UPDATE_BATCH,
 170             CALENDAR_FUNCTION_API_UPDATE_BATCH,
 171             CALENDAR_FEATURES_CALENDAR_WRITE,
 172             DEVICE_LIST_CALENDAR_WRITE);
 173
 174     calendarMapping.insert(std::make_pair(
 175                                CALENDAR_FUNCTION_API_UPDATE_BATCH,
 176                                updateBatchFunc));
 177
 178     //remove
 179     AceFunction removeFunc = ACE_CREATE_FUNCTION(
 180             FUNCTION_REMOVE,
 181             CALENDAR_FUNCTION_API_REMOVE,
 182             CALENDAR_FEATURES_CALENDAR_WRITE,
 183             DEVICE_LIST_CALENDAR_WRITE);
 184
 185     calendarMapping.insert(std::make_pair(
 186                                CALENDAR_FUNCTION_API_REMOVE,
 187                                removeFunc));
 188
 189     //removeBatch
 190     AceFunction removeBatchFunc = ACE_CREATE_FUNCTION(
 191             FUNCTION_REMOVE_BATCH,
 192             CALENDAR_FUNCTION_API_REMOVE_BATCH,
 193             CALENDAR_FEATURES_CALENDAR_WRITE,
 194             DEVICE_LIST_CALENDAR_WRITE);
 195
 196     calendarMapping.insert(std::make_pair(
 197                                CALENDAR_FUNCTION_API_REMOVE_BATCH,
 198                                removeBatchFunc));
 199
 200     //convertFromString
 201     /*AceFunction convertFromStringFunc = ACE_CREATE_FUNCTION(
 202             FUNCTION_CONVERT_FROM_STRING,
 203             CALENDAR_FUNCTION_API_CONVERT_FROM_STRING,
 204             CALENDAR_FEATURES_CALENDAR_READ_WRITE,
 205             DEVICE_LIST_CALENDAR_READ);
 206
 207     calendarMapping.insert(std::make_pair(
 208                                CALENDAR_FUNCTION_API_CONVERT_FROM_STRING,
 209                                convertFromStringFunc));*/
 210
 211     //convertToString
 212     AceFunction convertToStringFunc = ACE_CREATE_FUNCTION(
 213             FUNCTION_CONVERT_TO_STRING,
 214             CALENDAR_FUNCTION_API_CONVERT_TO_STRING,
 215             CALENDAR_FEATURES_CALENDAR_READ_WRITE,
 216             DEVICE_LIST_CALENDAR_READ);
 217
 218     calendarMapping.insert(std::make_pair(
 219                                CALENDAR_FUNCTION_API_CONVERT_TO_STRING,
 220                                convertToStringFunc));
 221
 222     //addChangeListener
 223     AceFunction addChangeListenerFunc = ACE_CREATE_FUNCTION(
 224             FUNCTION_ADD_CHANGE_LISTENER,
 225             CALENDAR_FUNCTION_API_ADD_CHANGE_LISTENER,
 226             CALENDAR_FEATURES_CALENDAR_READ,
 227             DEVICE_LIST_CALENDAR_READ);
 228
 229     calendarMapping.insert(std::make_pair(
 230                                CALENDAR_FUNCTION_API_ADD_CHANGE_LISTENER,
 231                                addChangeListenerFunc));
 232
 233     //removeChangeListener
 234     AceFunction removeChangeListenerFunc = ACE_CREATE_FUNCTION(
 235             FUNCTION_REMOVE_CHANGE_LISTENER,
 236             CALENDAR_FUNCTION_API_REMOVE_CHANGE_LISTENER,
 237             CALENDAR_FEATURES_CALENDAR_READ,
 238             DEVICE_LIST_CALENDAR_READ);
 239
 240     calendarMapping.insert(std::make_pair(
 241                                CALENDAR_FUNCTION_API_REMOVE_CHANGE_LISTENER,
 242                                removeChangeListenerFunc));
 243
 244     //expandRecurrence
 245     AceFunction expandRecurrenceFunc = ACE_CREATE_FUNCTION(
 246             FUNCTION_EXPAND_RECURRENCE,
 247             CALENDAR_FUNCTION_API_EXPAND_RECURRENCE,
 248             CALENDAR_FEATURES_CALENDAR_READ,
 249             DEVICE_LIST_CALENDAR_READ);
 250
 251     calendarMapping.insert(std::make_pair(
 252                                CALENDAR_FUNCTION_API_EXPAND_RECURRENCE,
 253                                expandRecurrenceFunc));
 254
 255     //get
 256     AceFunction getFunc = ACE_CREATE_FUNCTION(
 257             FUNCTION_GET,
 258             CALENDAR_FUNCTION_API_GET,
 259             CALENDAR_FEATURES_CALENDAR_READ,
 260             DEVICE_LIST_CALENDAR_READ);
 261
 262     calendarMapping.insert(std::make_pair(
 263                                CALENDAR_FUNCTION_API_GET,
 264                                getFunc));
 265
 266     //clone
 267     AceFunction cloneFunc = ACE_CREATE_FUNCTION(
 268             FUNCTION_CLONE,
 269             CALENDAR_FUNCTION_API_CLONE,
 270             CALENDAR_FEATURES_CALENDAR_READ,
 271             DEVICE_LIST_CALENDAR_READ);
 272
 273     calendarMapping.insert(std::make_pair(
 274                                CALENDAR_FUNCTION_API_CLONE,
 275                                getFunc));
 276
 277     return calendarMapping;
 278 }
 279
 280 }
 281 }
 282 }