src/Filesystem/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 "plugin_config.h"
  22 #include <Commons/FunctionDefinition.h>
  23 #include <Commons/FunctionDeclaration.h>
  24 #include <Commons/Exception.h>
  25 #include "Enums.h"
  26
  27 #define FILESYSTEM_FEATURE_API_READ "http://tizen.org/privilege/filesystem.read"
  28 #define FILESYSTEM_FEATURE_API_WRITE "http://tizen.org/privilege/filesystem.write"
  29
  30 namespace DeviceAPI {
  31 namespace Filesystem {
  32
  33
  34
  35 static WrtDeviceApis::Commons::FunctionMapping createFilesystemFunctions();
  36
  37 static WrtDeviceApis::Commons::FunctionMapping FilesystemFunctions =
  38     createFilesystemFunctions();
  39
  40 DEFINE_FUNCTION_GETTER(Filesystem, FilesystemFunctions);
  41
  42 static WrtDeviceApis::Commons::FunctionMapping createFilesystemFunctions()
  43 {
  44         using namespace WrtDeviceApis::Commons;
  45
  46     /**
  47      * Device capabilities
  48      */
  49
  50     ACE_CREATE_DEVICE_CAP(DEVICE_CAP_FILESYSTEM_READ,
  51                           FILESYSTEM_DEVICE_CAP_READ);
  52     ACE_CREATE_DEVICE_CAP(DEVICE_CAP_FILESYSTEM_WRITE,
  53                           FILESYSTEM_DEVICE_CAP_WRITE);
  54
  55     ACE_CREATE_DEVICE_CAPS_LIST(EMPTY_DEVICE_LIST);
  56
  57     ACE_CREATE_DEVICE_CAPS_LIST(DEVICE_LIST_FILESYSTEM_READ);
  58     ACE_ADD_DEVICE_CAP(DEVICE_LIST_FILESYSTEM_READ, DEVICE_CAP_FILESYSTEM_READ);
  59
  60     ACE_CREATE_DEVICE_CAPS_LIST(DEVICE_LIST_FILESYSTEM_WRITE);
  61     ACE_ADD_DEVICE_CAP(DEVICE_LIST_FILESYSTEM_WRITE,
  62                        DEVICE_CAP_FILESYSTEM_WRITE);
  63
  64     /**
  65      * Api Features
  66      */
  67     ACE_CREATE_FEATURE(FEATURE_READ, FILESYSTEM_FEATURE_API_READ);
  68     ACE_CREATE_FEATURE(FEATURE_WRITE, FILESYSTEM_FEATURE_API_WRITE);
  69
  70     ACE_CREATE_FEATURE_LIST(FILESYSTEM_FEATURES_FILESYSTEM_READ);
  71
  72     ACE_ADD_API_FEATURE(FILESYSTEM_FEATURES_FILESYSTEM_READ,
  73                         FEATURE_READ);
  74
  75     ACE_CREATE_FEATURE_LIST(FILESYSTEM_FEATURES_FILESYSTEM_WRITE);
  76
  77     ACE_ADD_API_FEATURE(FILESYSTEM_FEATURES_FILESYSTEM_WRITE,
  78                         FEATURE_WRITE);
  79
  80     /**
  81      * Functions
  82      */
  83
  84     FunctionMapping FilesystemMapping;
  85
  86     AceFunction mgrResolveFunc = ACE_CREATE_FUNCTION(
  87             FUNCTION_MGR_RESOLVE,
  88             FILESYSTEM_FUNCTION_API_MGR_RESOLVE,
  89             FILESYSTEM_FEATURES_FILESYSTEM_READ,
  90             EMPTY_DEVICE_LIST); // check of device-cap will be done inside resolve()
  91
  92     FilesystemMapping.insert(std::make_pair(
  93                                  FILESYSTEM_FUNCTION_API_MGR_RESOLVE_ID,
  94                                  mgrResolveFunc));
  95
  96     AceFunction getStorageFunc = ACE_CREATE_FUNCTION(
  97             FUNCTION_GET_STORAGE,
  98             FILESYSTEM_FUNCTION_API_GET_STORAGE,
  99             FILESYSTEM_FEATURES_FILESYSTEM_READ,
 100             EMPTY_DEVICE_LIST);
 101
 102     FilesystemMapping.insert(std::make_pair(
 103                                  FILESYSTEM_FUNCTION_API_GET_STORAGE,
 104                                  getStorageFunc));
 105
 106     AceFunction listStorageFunc = ACE_CREATE_FUNCTION(
 107             FUNCTION_LIST_STORAGE,
 108             FILESYSTEM_FUNCTION_API_LIST_STORAGE,
 109             FILESYSTEM_FEATURES_FILESYSTEM_READ,
 110             EMPTY_DEVICE_LIST);
 111
 112     FilesystemMapping.insert(std::make_pair(
 113                                  FILESYSTEM_FUNCTION_API_LIST_STORAGE,
 114                                  listStorageFunc));
 115
 116         AceFunction addStorageListenerFunc = ACE_CREATE_FUNCTION(
 117                                 FUNCTION_ADD_STORAGE_LISTENER,
 118                                 FILESYSTEM_FUNCTION_API_ADD_STORAGE_LISTENER,
 119                                 FILESYSTEM_FEATURES_FILESYSTEM_WRITE,
 120                                 EMPTY_DEVICE_LIST);
 121
 122                 FilesystemMapping.insert(std::make_pair(
 123                                                                          FILESYSTEM_FUNCTION_API_ADD_STORAGE_LISTENER,
 124                                                                          addStorageListenerFunc));
 125
 126                 AceFunction removeStorageListenerFunc = ACE_CREATE_FUNCTION(
 127                                 FUNCTION_REMOVE_STORAGE_LISTENER,
 128                                 FILESYSTEM_FUNCTION_API_REMOVE_STORAGE_LISTENER,
 129                                 FILESYSTEM_FEATURES_FILESYSTEM_WRITE,
 130                                 EMPTY_DEVICE_LIST);
 131
 132                 FilesystemMapping.insert(std::make_pair(
 133                                                                          FILESYSTEM_FUNCTION_API_REMOVE_STORAGE_LISTENER,
 134                                                                          removeStorageListenerFunc));
 135
 136     AceFunction resolveFunc = ACE_CREATE_FUNCTION(
 137             FUNCTION_RESOLVE,
 138             FILESYSTEM_FUNCTION_API_RESOLVE,
 139             FILESYSTEM_FEATURES_FILESYSTEM_READ,
 140             EMPTY_DEVICE_LIST);
 141
 142     FilesystemMapping.insert(std::make_pair(
 143                                  FILESYSTEM_FUNCTION_API_RESOLVE,
 144                                  resolveFunc));
 145
 146     AceFunction toUriFunc = ACE_CREATE_FUNCTION(
 147             FUNCTION_TO_URI,
 148             FILESYSTEM_FUNCTION_API_TO_URI,
 149             FILESYSTEM_FEATURES_FILESYSTEM_READ,
 150             EMPTY_DEVICE_LIST);
 151
 152     FilesystemMapping.insert(std::make_pair(
 153                                  FILESYSTEM_FUNCTION_API_TO_URI,
 154                                  toUriFunc));
 155
 156     AceFunction listFilesFunc = ACE_CREATE_FUNCTION(
 157             FUNCTION_LIST_FILES,
 158             FILESYSTEM_FUNCTION_API_LIST_FILES,
 159             FILESYSTEM_FEATURES_FILESYSTEM_READ,
 160             EMPTY_DEVICE_LIST);
 161
 162     FilesystemMapping.insert(std::make_pair(
 163                                  FILESYSTEM_FUNCTION_API_LIST_FILES,
 164                                  listFilesFunc));
 165
 166     AceFunction openStreamFunc = ACE_CREATE_FUNCTION(
 167             FUNCTION_OPEN_STREAM,
 168             FILESYSTEM_FUNCTION_API_OPEN_STREAM,
 169             FILESYSTEM_FEATURES_FILESYSTEM_READ,
 170             EMPTY_DEVICE_LIST);
 171
 172     FilesystemMapping.insert(std::make_pair(
 173                                  FILESYSTEM_FUNCTION_API_OPEN_STREAM,
 174                                  openStreamFunc));
 175
 176     AceFunction readAsTextFunc = ACE_CREATE_FUNCTION(
 177             FUNCTION_READ_AS_TEXT,
 178             FILESYSTEM_FUNCTION_API_READ_AS_TEXT,
 179             FILESYSTEM_FEATURES_FILESYSTEM_READ,
 180             EMPTY_DEVICE_LIST);
 181
 182     FilesystemMapping.insert(std::make_pair(
 183                                  FILESYSTEM_FUNCTION_API_READ_AS_TEXT,
 184                                  readAsTextFunc));
 185
 186
 187
 188
 189     AceFunction copyToFunc = ACE_CREATE_FUNCTION(
 190             FUNCTION_COPY_TO,
 191             FILESYSTEM_FUNCTION_API_COPY_TO,
 192             FILESYSTEM_FEATURES_FILESYSTEM_WRITE,
 193             EMPTY_DEVICE_LIST);
 194
 195     FilesystemMapping.insert(std::make_pair(
 196                                  FILESYSTEM_FUNCTION_API_COPY_TO,
 197                                  copyToFunc));
 198
 199     AceFunction moveToFunc = ACE_CREATE_FUNCTION(
 200             FUNCTION_MOVE_TO,
 201             FILESYSTEM_FUNCTION_API_MOVE_TO,
 202             FILESYSTEM_FEATURES_FILESYSTEM_WRITE,
 203             EMPTY_DEVICE_LIST);
 204
 205     FilesystemMapping.insert(std::make_pair(
 206                                  FILESYSTEM_FUNCTION_API_MOVE_TO,
 207                                  moveToFunc));
 208
 209     AceFunction createDirFunc = ACE_CREATE_FUNCTION(
 210             FUNCTION_CREATE_DIR,
 211             FILESYSTEM_FUNCTION_API_CREATE_DIR,
 212             FILESYSTEM_FEATURES_FILESYSTEM_WRITE,
 213             EMPTY_DEVICE_LIST);
 214
 215     FilesystemMapping.insert(std::make_pair(
 216                                  FILESYSTEM_FUNCTION_API_CREATE_DIR,
 217                                  createDirFunc));
 218
 219     AceFunction createFileFunc = ACE_CREATE_FUNCTION(
 220             FUNCTION_CREATE_FILE,
 221             FILESYSTEM_FUNCTION_API_CREATE_FILE,
 222             FILESYSTEM_FEATURES_FILESYSTEM_WRITE,
 223             EMPTY_DEVICE_LIST);
 224
 225     FilesystemMapping.insert(std::make_pair(
 226                                  FILESYSTEM_FUNCTION_API_CREATE_FILE,
 227                                  createFileFunc));
 228
 229     AceFunction deleteDirFunc = ACE_CREATE_FUNCTION(
 230             FUNCTION_DELETE_DIR,
 231             FILESYSTEM_FUNCTION_API_DELETE_DIR,
 232             FILESYSTEM_FEATURES_FILESYSTEM_WRITE,
 233             EMPTY_DEVICE_LIST);
 234
 235     FilesystemMapping.insert(std::make_pair(
 236                                  FILESYSTEM_FUNCTION_API_DELETE_DIR,
 237                                  deleteDirFunc));
 238
 239     AceFunction deleteFileFunc = ACE_CREATE_FUNCTION(
 240             FUNCTION_DELETE_FILE,
 241             FILESYSTEM_FUNCTION_API_DELETE_FILE,
 242             FILESYSTEM_FEATURES_FILESYSTEM_WRITE,
 243             EMPTY_DEVICE_LIST);
 244
 245     FilesystemMapping.insert(std::make_pair(
 246                                  FILESYSTEM_FUNCTION_API_DELETE_FILE,
 247                                  deleteFileFunc));
 248
 249     AceFunction closeFunc = ACE_CREATE_FUNCTION(
 250             FUNCTION_CLOSE,
 251             FILESYSTEM_FUNCTION_API_CLOSE,
 252             FILESYSTEM_FEATURES_FILESYSTEM_READ,
 253             EMPTY_DEVICE_LIST);
 254
 255     FilesystemMapping.insert(std::make_pair(
 256                                  FILESYSTEM_FUNCTION_API_CLOSE,
 257                                  closeFunc));
 258
 259     AceFunction readFunc = ACE_CREATE_FUNCTION(
 260             FUNCTION_READ,
 261             FILESYSTEM_FUNCTION_API_READ,
 262             FILESYSTEM_FEATURES_FILESYSTEM_READ,
 263             EMPTY_DEVICE_LIST);
 264
 265     FilesystemMapping.insert(std::make_pair(
 266                                  FILESYSTEM_FUNCTION_API_READ,
 267                                  readFunc));
 268
 269     AceFunction readBytesFunc = ACE_CREATE_FUNCTION(
 270             FUNCTION_READ_BYTES,
 271             FILESYSTEM_FUNCTION_API_READ_BYTES,
 272             FILESYSTEM_FEATURES_FILESYSTEM_READ,
 273             EMPTY_DEVICE_LIST);
 274
 275     FilesystemMapping.insert(std::make_pair(
 276                                  FILESYSTEM_FUNCTION_API_READ_BYTES,
 277                                  readBytesFunc));
 278
 279     AceFunction readBase64Func = ACE_CREATE_FUNCTION(
 280             FUNCTION_READ_BASE64,
 281             FILESYSTEM_FUNCTION_API_READ_BASE64,
 282             FILESYSTEM_FEATURES_FILESYSTEM_READ,
 283             EMPTY_DEVICE_LIST);
 284
 285     FilesystemMapping.insert(std::make_pair(
 286                                  FILESYSTEM_FUNCTION_API_READ_BASE64,
 287                                  readBase64Func));
 288
 289     AceFunction writeFunc = ACE_CREATE_FUNCTION(
 290             FUNCTION_WRITE,
 291             FILESYSTEM_FUNCTION_API_WRITE,
 292             FILESYSTEM_FEATURES_FILESYSTEM_WRITE,
 293             EMPTY_DEVICE_LIST);
 294
 295     FilesystemMapping.insert(std::make_pair(
 296                                  FILESYSTEM_FUNCTION_API_WRITE,
 297                                  writeFunc));
 298
 299     AceFunction writeBytesFunc = ACE_CREATE_FUNCTION(
 300             FUNCTION_WRITE_BYTES,
 301             FILESYSTEM_FUNCTION_API_WRITE_BYTES,
 302             FILESYSTEM_FEATURES_FILESYSTEM_WRITE,
 303             EMPTY_DEVICE_LIST);
 304
 305     FilesystemMapping.insert(std::make_pair(
 306                                  FILESYSTEM_FUNCTION_API_WRITE_BYTES,
 307                                  writeBytesFunc));
 308
 309     AceFunction writeBase64Func = ACE_CREATE_FUNCTION(
 310             FUNCTION_WRITE_BASE64,
 311             FILESYSTEM_FUNCTION_API_WRITE_BASE64,
 312             FILESYSTEM_FEATURES_FILESYSTEM_WRITE,
 313             EMPTY_DEVICE_LIST);
 314
 315     FilesystemMapping.insert(std::make_pair(
 316                                  FILESYSTEM_FUNCTION_API_WRITE_BASE64,
 317                                  writeBase64Func));
 318
 319     return FilesystemMapping;
 320 }
 321
 322 }
 323 }