src/Content/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 <Commons/Exception.h>
  22 #include <map>
  23
  24 #include "plugin_config.h"
  25
  26 using namespace WrtDeviceApis::Commons;
  27
  28 #define CONTENT_FEATURE_API_READ  "http://tizen.org/privilege/content.read"
  29 #define CONTENT_FEATURE_API_WRITE "http://tizen.org/privilege/content.write"
  30
  31 #define CONTENT_DEVICE_CAP_READ "content.read"
  32 #define CONTENT_DEVICE_CAP_WRITE "content.write"
  33
  34 namespace DeviceAPI {
  35 namespace Content {
  36
  37 // Extern variables declared in plugin_config.h
  38 #pragma GCC visibility push(default)
  39 const int CONTENT_TIME_TRACER_SHOW = 0;
  40 const char* CONTENT_TT_UPDATE_BATCH_TOTAL = "updateBatchTotal";
  41 const char* CONTENT_TT_SCAN_FILE_TOTAL = "scanFileTotal";
  42 const char* CONTENT_TT_FIND_TOTAL = "findTotal";
  43 const char* CONTENT_TT_GET_DIR_TOTAL = "getDirectoriesTotal";
  44 #pragma GCC visibility pop(default)
  45
  46 static FunctionMapping createContentFunctions();
  47 static FunctionMapping ContentFunctions = createContentFunctions();
  48
  49 #pragma GCC visibility push(default)
  50 DEFINE_FUNCTION_GETTER(Content, ContentFunctions);
  51 #pragma GCC visibility pop(default)
  52
  53 static FunctionMapping createContentFunctions()
  54 {
  55     /**
  56      * Device capabilities
  57      */
  58     ACE_CREATE_DEVICE_CAP(DEVICE_CAP_CONTENT_READ, CONTENT_DEVICE_CAP_READ);
  59     ACE_CREATE_DEVICE_CAP(DEVICE_CAP_CONTENT_WRITE, CONTENT_DEVICE_CAP_WRITE);
  60
  61     ACE_CREATE_DEVICE_CAPS_LIST(DEVICE_LIST_CONTENT_READ);
  62     ACE_ADD_DEVICE_CAP(DEVICE_LIST_CONTENT_READ, DEVICE_CAP_CONTENT_READ);
  63
  64     ACE_CREATE_DEVICE_CAPS_LIST(DEVICE_LIST_CONTENT_WRITE);
  65     ACE_ADD_DEVICE_CAP(DEVICE_LIST_CONTENT_WRITE, DEVICE_CAP_CONTENT_WRITE);
  66
  67     /**
  68      * Api Features
  69      */
  70     ACE_CREATE_FEATURE(FEATURE_CONTENT_READ, CONTENT_FEATURE_API_READ);
  71     ACE_CREATE_FEATURE(FEATURE_CONTENT_WRITE, CONTENT_FEATURE_API_WRITE);
  72
  73     ACE_CREATE_FEATURE_LIST(CONTENT_FEATURES_CONTENT_READ);
  74     ACE_ADD_API_FEATURE(CONTENT_FEATURES_CONTENT_READ, FEATURE_CONTENT_READ);
  75
  76     ACE_CREATE_FEATURE_LIST(CONTENT_FEATURES_CONTENT_WRITE);
  77     ACE_ADD_API_FEATURE(CONTENT_FEATURES_CONTENT_WRITE, FEATURE_CONTENT_WRITE);
  78
  79     FunctionMapping contentMapping;
  80
  81     //find
  82     AceFunction findFunc = ACE_CREATE_FUNCTION(
  83             FUNCTION_FIND,
  84             CONTENT_MANAGER_API_FIND,
  85             CONTENT_FEATURES_CONTENT_READ,
  86             DEVICE_LIST_CONTENT_READ);
  87
  88     contentMapping.insert(std::make_pair(
  89             CONTENT_MANAGER_API_FIND,
  90             findFunc));
  91
  92     //update
  93     AceFunction updateFunc = ACE_CREATE_FUNCTION(
  94             FUNCTION_UPDATE,
  95             CONTENT_MANAGER_API_UPDATE,
  96             CONTENT_FEATURES_CONTENT_WRITE,
  97             DEVICE_LIST_CONTENT_WRITE);
  98
  99     contentMapping.insert(std::make_pair(
 100             CONTENT_MANAGER_API_UPDATE,
 101             updateFunc));
 102
 103     //updateBatch
 104     AceFunction updateBatchFunc = ACE_CREATE_FUNCTION(
 105             FUNCTION_UPDATE_BATCH,
 106             CONTENT_MANAGER_API_UPDATE_BATCH,
 107             CONTENT_FEATURES_CONTENT_WRITE,
 108             DEVICE_LIST_CONTENT_WRITE);
 109
 110     contentMapping.insert(std::make_pair(
 111             CONTENT_MANAGER_API_UPDATE_BATCH,
 112             updateBatchFunc));
 113
 114     //scanFile
 115     AceFunction scanFileFunc = ACE_CREATE_FUNCTION(
 116             FUNCTION_SCAN_FILE,
 117             CONTENT_MANAGER_API_SCAN_FILE,
 118             CONTENT_FEATURES_CONTENT_WRITE,
 119             DEVICE_LIST_CONTENT_WRITE);
 120
 121     contentMapping.insert(std::make_pair(
 122             CONTENT_MANAGER_API_SCAN_FILE,
 123             scanFileFunc));
 124
 125     //setChangeListener
 126     AceFunction setListenerFunc = ACE_CREATE_FUNCTION(
 127             FUNCTION_SET_CHANGE_LISTENER,
 128             CONTENT_MANAGER_API_SET_CHANGE_LISTENER,
 129             CONTENT_FEATURES_CONTENT_READ,
 130             DEVICE_LIST_CONTENT_READ);
 131
 132     contentMapping.insert(std::make_pair(
 133             CONTENT_MANAGER_API_SET_CHANGE_LISTENER,
 134             setListenerFunc));
 135
 136     //unsetChangeListener
 137     AceFunction unsetListenerFunc = ACE_CREATE_FUNCTION(
 138             FUNCTION_UNSET_CHANGE_LISTENER,
 139             CONTENT_MANAGER_API_UNSET_CHANGE_LISTENER,
 140             CONTENT_FEATURES_CONTENT_READ,
 141             DEVICE_LIST_CONTENT_READ);
 142
 143     contentMapping.insert(std::make_pair(
 144             CONTENT_MANAGER_API_UNSET_CHANGE_LISTENER,
 145             unsetListenerFunc));
 146
 147     //getPlaylists
 148     AceFunction getPlaylistsFunc = ACE_CREATE_FUNCTION(
 149             FUNCTION_GET_PLAYLISTS,
 150             CONTENT_MANAGER_API_GET_PLAYLISTS,
 151             CONTENT_FEATURES_CONTENT_READ,
 152             DEVICE_LIST_CONTENT_READ);
 153
 154     contentMapping.insert(std::make_pair(
 155             CONTENT_MANAGER_API_GET_PLAYLISTS,
 156             getPlaylistsFunc));
 157
 158     //createPlaylist
 159     AceFunction createPlaylistFunc = ACE_CREATE_FUNCTION(
 160             FUNCTION_CREATE_PLAYLIST,
 161             CONTENT_MANAGER_API_CREATE_PLAYLIST,
 162             CONTENT_FEATURES_CONTENT_WRITE,
 163             DEVICE_LIST_CONTENT_WRITE);
 164
 165     contentMapping.insert(std::make_pair(
 166             CONTENT_MANAGER_API_CREATE_PLAYLIST,
 167             createPlaylistFunc));
 168
 169     //removePlaylist
 170     AceFunction removePlaylistFunc = ACE_CREATE_FUNCTION(
 171             FUNCTION_REMOVE_PLAYLIST,
 172             CONTENT_MANAGER_API_REMOVE_PLAYLIST,
 173             CONTENT_FEATURES_CONTENT_WRITE,
 174             DEVICE_LIST_CONTENT_WRITE);
 175
 176     contentMapping.insert(std::make_pair(
 177             CONTENT_MANAGER_API_REMOVE_PLAYLIST,
 178             removePlaylistFunc));
 179
 180     // add
 181     AceFunction addFunc = ACE_CREATE_FUNCTION(
 182             FUNCTION_ADD,
 183             PLAYLIST_FUNCTION_API_ADD,
 184             CONTENT_FEATURES_CONTENT_WRITE,
 185             DEVICE_LIST_CONTENT_WRITE);
 186
 187     contentMapping.insert(std::make_pair(
 188             PLAYLIST_FUNCTION_API_ADD,
 189             addFunc));
 190
 191     // addBatch
 192     AceFunction addBatchFunc = ACE_CREATE_FUNCTION(
 193             FUNCTION_ADD_BATCH,
 194             PLAYLIST_FUNCTION_API_ADD_BATCH,
 195             CONTENT_FEATURES_CONTENT_WRITE,
 196             DEVICE_LIST_CONTENT_WRITE);
 197
 198     contentMapping.insert(std::make_pair(
 199             PLAYLIST_FUNCTION_API_ADD_BATCH,
 200             addBatchFunc));
 201
 202     // remove
 203     AceFunction removeFunc = ACE_CREATE_FUNCTION(
 204             FUNCTION_REMOVE,
 205             PLAYLIST_FUNCTION_API_REMOVE,
 206             CONTENT_FEATURES_CONTENT_WRITE,
 207             DEVICE_LIST_CONTENT_WRITE);
 208
 209     contentMapping.insert(std::make_pair(
 210             PLAYLIST_FUNCTION_API_REMOVE,
 211             removeFunc));
 212
 213     // removeBatch
 214     AceFunction removeBatchFunc = ACE_CREATE_FUNCTION(
 215             FUNCTION_REMOVE_BATCH,
 216             PLAYLIST_FUNCTION_API_REMOVE_BATCH,
 217             CONTENT_FEATURES_CONTENT_WRITE,
 218             DEVICE_LIST_CONTENT_WRITE);
 219
 220     contentMapping.insert(std::make_pair(
 221             PLAYLIST_FUNCTION_API_REMOVE_BATCH,
 222             removeBatchFunc));
 223
 224     // getItems
 225     AceFunction getItemsFunc = ACE_CREATE_FUNCTION(
 226             FUNCTION_GET_ITEMS,
 227             PLAYLIST_FUNCTION_API_GET_ITEMS,
 228             CONTENT_FEATURES_CONTENT_READ,
 229             DEVICE_LIST_CONTENT_READ);
 230
 231     contentMapping.insert(std::make_pair(
 232             PLAYLIST_FUNCTION_API_GET_ITEMS,
 233             getItemsFunc));
 234
 235     // moveItem
 236     AceFunction moveItemFunc = ACE_CREATE_FUNCTION(
 237             FUNCTION_SET_ORDER,
 238             PLAYLIST_FUNCTION_API_MOVE_ITEM,
 239             CONTENT_FEATURES_CONTENT_WRITE,
 240             DEVICE_LIST_CONTENT_WRITE);
 241
 242     contentMapping.insert(std::make_pair(
 243             PLAYLIST_FUNCTION_API_MOVE_ITEM,
 244             moveItemFunc));
 245
 246     // setItemsOrder
 247     AceFunction setItemsOrderFunc = ACE_CREATE_FUNCTION(
 248             FUNCTION_SET_ORDER,
 249             PLAYLIST_FUNCTION_API_SET_ITEMS_ORDER,
 250             CONTENT_FEATURES_CONTENT_WRITE,
 251             DEVICE_LIST_CONTENT_WRITE);
 252
 253     contentMapping.insert(std::make_pair(
 254             PLAYLIST_FUNCTION_API_SET_ITEMS_ORDER,
 255             setItemsOrderFunc));
 256
 257     // setName
 258     AceFunction setNameFunc = ACE_CREATE_FUNCTION(
 259             FUNCTION_SET_NAME,
 260             PLAYLIST_FUNCTION_API_SET_NAME,
 261             CONTENT_FEATURES_CONTENT_WRITE,
 262             DEVICE_LIST_CONTENT_WRITE);
 263
 264     contentMapping.insert(std::make_pair(
 265             PLAYLIST_FUNCTION_API_SET_NAME,
 266             setNameFunc));
 267
 268     // setThumbnailURI
 269     AceFunction setThumbnailURIFunc = ACE_CREATE_FUNCTION(
 270             FUNCTION_SET_THUMBNAIL_URI,
 271             PLAYLIST_FUNCTION_API_SET_THUMBNAIL_URI,
 272             CONTENT_FEATURES_CONTENT_WRITE,
 273             DEVICE_LIST_CONTENT_WRITE);
 274
 275     contentMapping.insert(std::make_pair(
 276             PLAYLIST_FUNCTION_API_SET_THUMBNAIL_URI,
 277             setThumbnailURIFunc));
 278
 279     return contentMapping;
 280 }
 281
 282 } // Content
 283 } // DeviceAPI