client/sal_service_storage.c

   1 /*
   2  * Service Storage
   3  *
   4  * Copyright (c) 2014 - 2015 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <glib.h>
  23
  24 #include <app.h>
  25
  26 #include "service_adaptor_errors.h"
  27 #include "service_adaptor_internal.h"
  28 #include "sal_service_adaptor.h"
  29 #include "sal_service_adaptor_internal.h"
  30 #include "sal_service_task.h"
  31 #include "sal_service_task_internal.h"
  32 #include "sal_service_storage.h"
  33 #include "sal_service_storage_internal.h"
  34 #include "sal_ipc_client_storage.h"
  35
  36 //******************************************************************************
  37 //* Global variables and defines
  38 //******************************************************************************
  39
  40 //******************************************************************************
  41 //* Private interface
  42 //******************************************************************************
  43
  44 //******************************************************************************
  45 //* Private interface definition
  46 //******************************************************************************
  47
  48 int service_storage_cloud_start(service_storage_cloud_file_h file)
  49 {
  50         SAL_FN_CALL;
  51
  52         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
  53         RETV_IF(NULL == file->plugin, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
  54
  55         int ret = SERVICE_ADAPTOR_ERROR_NONE;
  56         char *uri = NULL;
  57
  58         ret = service_plugin_get_uri(file->plugin, &uri);
  59         RETVM_IF(SERVICE_ADAPTOR_ERROR_NONE != ret, ret, "service_plugin_get_uri() Failed(%d)", ret);
  60
  61         service_storage_cloud_file_h cloud_file = NULL;
  62         ret = ipc_service_storage_cloud_file(uri, file, &cloud_file);
  63         RETVM_IF(SERVICE_ADAPTOR_ERROR_NONE != ret, ret, "ipc_service_storage_cloud_file() Failed(%d)", ret);
  64
  65         RETV_IF(NULL == file->callback, SERVICE_ADAPTOR_ERROR_NONE);
  66
  67         file->callback(SERVICE_ADAPTOR_ERROR_NONE, cloud_file,  file->user_data);
  68
  69         return SERVICE_ADAPTOR_ERROR_NONE;
  70 }
  71
  72 int service_storage_cloud_stop(service_storage_cloud_file_h file)
  73 {
  74         SAL_FN_CALL;
  75
  76         return SERVICE_ADAPTOR_ERROR_NONE;
  77 }
  78
  79 //******************************************************************************
  80 //* Public interface definition
  81 //******************************************************************************
  82
  83 API int service_storage_cloud_file_create(service_plugin_h plugin, service_storage_cloud_file_h *file)
  84 {
  85         SAL_FN_CALL;
  86
  87         RETV_IF(NULL == plugin, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
  88         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
  89
  90         service_storage_cloud_file_h cloud_file = (service_storage_cloud_file_h) g_malloc0(sizeof(service_storage_cloud_file_s));
  91         cloud_file->plugin = plugin;
  92         cloud_file->callback = NULL;
  93         cloud_file->is_dir = false;
  94         cloud_file->size = 0;
  95         cloud_file->dir_path = NULL;
  96         cloud_file->local_path = NULL;
  97         cloud_file->cloud_path = NULL;
  98         cloud_file->operation = NULL;
  99         cloud_file->files = NULL;
 100
 101         *file = cloud_file;
 102
 103         return SERVICE_ADAPTOR_ERROR_NONE;
 104 }
 105
 106 API int service_storage_cloud_file_clone(service_storage_cloud_file_h src_file, service_storage_cloud_file_h *dst_file)
 107 {
 108         SAL_FN_CALL;
 109
 110         RETV_IF(NULL == src_file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 111         RETV_IF(NULL == dst_file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 112
 113         service_storage_cloud_file_h cloud_file = (service_storage_cloud_file_h) g_malloc0(sizeof(service_storage_cloud_file_s));
 114         cloud_file->plugin = src_file->plugin;
 115         cloud_file->callback = src_file->callback;
 116         cloud_file->is_dir = src_file->is_dir;
 117         cloud_file->size = src_file->size;
 118         cloud_file->dir_path = g_strdup(src_file->dir_path);
 119         cloud_file->local_path = g_strdup(src_file->local_path);
 120         cloud_file->cloud_path = g_strdup(src_file->cloud_path);
 121         cloud_file->operation = g_strdup(src_file->operation);
 122         // TODO: g_list_copy_deep()
 123         if (NULL != src_file->files)
 124         {
 125                 cloud_file->files = g_list_copy(src_file->files);
 126         }
 127         else
 128         {
 129                 cloud_file->files = NULL;
 130         }
 131
 132         *dst_file = cloud_file;
 133
 134         return SERVICE_ADAPTOR_ERROR_NONE;
 135 }
 136
 137 API int service_storage_cloud_file_destroy(service_storage_cloud_file_h file)
 138 {
 139         SAL_FN_CALL;
 140
 141         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 142
 143         SAL_FREE(file->dir_path);
 144         SAL_FREE(file->local_path);
 145         SAL_FREE(file->cloud_path);
 146         SAL_FREE(file->operation);
 147         SAL_FREE(file);
 148
 149         return SERVICE_ADAPTOR_ERROR_NONE;
 150 }
 151
 152 API int service_storage_cloud_file_set_callback(service_storage_cloud_file_h file, service_storage_cloud_file_cb callback, void *user_data)
 153 {
 154         SAL_FN_CALL;
 155
 156         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 157         RETV_IF(NULL == callback, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 158
 159         file->callback = callback;
 160         file->user_data = user_data;
 161
 162         return SERVICE_ADAPTOR_ERROR_NONE;
 163 }
 164
 165 API int service_storage_cloud_file_unset_callback(service_storage_cloud_file_h file)
 166 {
 167         SAL_FN_CALL;
 168
 169         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 170
 171         file->callback = NULL;
 172         file->user_data = NULL;
 173
 174         return SERVICE_ADAPTOR_ERROR_NONE;
 175 }
 176
 177 API int service_storage_cloud_file_set_cloud_path(service_storage_cloud_file_h file, const char *cloud_path)
 178 {
 179         SAL_FN_CALL;
 180
 181         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 182         RETV_IF(NULL == cloud_path, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 183
 184         file->cloud_path = strdup(cloud_path);
 185
 186         return SERVICE_ADAPTOR_ERROR_NONE;
 187 }
 188
 189 API int service_storage_cloud_file_get_cloud_path(service_storage_cloud_file_h file, char **cloud_path)
 190 {
 191         SAL_FN_CALL;
 192
 193         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 194         RETV_IF(NULL == cloud_path, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 195
 196         *cloud_path = g_strdup(file->cloud_path);
 197
 198         return SERVICE_ADAPTOR_ERROR_NONE;
 199 }
 200
 201 API int service_storage_cloud_file_set_local_path(service_storage_cloud_file_h file, const char *local_path)
 202 {
 203         SAL_FN_CALL;
 204
 205         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 206         RETV_IF(NULL == local_path, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 207
 208         file->local_path = strdup(local_path);
 209
 210         return SERVICE_ADAPTOR_ERROR_NONE;
 211 }
 212
 213 API int service_storage_cloud_file_get_local_path(service_storage_cloud_file_h file, char **local_path)
 214 {
 215         SAL_FN_CALL;
 216
 217         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 218         RETV_IF(NULL == local_path, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 219
 220         *local_path = g_strdup(file->local_path);
 221
 222         return SERVICE_ADAPTOR_ERROR_NONE;
 223 }
 224
 225 API int service_storage_cloud_file_set_size(service_storage_cloud_file_h file, unsigned long long size)
 226 {
 227         SAL_FN_CALL;
 228
 229         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 230
 231         file->size = size;
 232
 233         return SERVICE_ADAPTOR_ERROR_NONE;
 234 }
 235
 236 API int service_storage_cloud_file_get_size(service_storage_cloud_file_h file, unsigned long long *size)
 237 {
 238         SAL_FN_CALL;
 239
 240         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 241         RETV_IF(NULL == size, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 242
 243         *size = file->size;
 244
 245         return SERVICE_ADAPTOR_ERROR_NONE;
 246 }
 247
 248 API int service_storage_cloud_file_set_operation(service_storage_cloud_file_h file, const char *operation)
 249 {
 250         SAL_FN_CALL;
 251
 252         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 253         RETV_IF(NULL == operation, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 254
 255         file->operation = strdup(operation);
 256
 257         return SERVICE_ADAPTOR_ERROR_NONE;
 258 }
 259
 260 API int service_storage_cloud_file_get_operation(service_storage_cloud_file_h file, char **operation)
 261 {
 262         SAL_FN_CALL;
 263
 264         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 265         RETV_IF(NULL == operation, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 266
 267         *operation = g_strdup(file->operation);
 268
 269         return SERVICE_ADAPTOR_ERROR_NONE;
 270 }
 271
 272 API int service_storage_cloud_file_is_directory(service_storage_cloud_file_h file, bool *is_dir)
 273 {
 274         SAL_FN_CALL;
 275
 276         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 277         RETV_IF(NULL == is_dir, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 278
 279         *is_dir = file->is_dir;
 280
 281         return SERVICE_ADAPTOR_ERROR_NONE;
 282 }
 283
 284 API int service_storage_cloud_file_foreach_file(service_storage_cloud_file_h file, service_storage_cloud_file_cb callback, void *user_data)
 285 {
 286         SAL_FN_CALL;
 287
 288         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 289         RETV_IF(NULL == callback, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 290
 291         RETV_IF(false == file->is_dir, SERVICE_ADAPTOR_ERROR_NO_DATA);
 292
 293         RETV_IF(0 == g_list_length(file->files), SERVICE_ADAPTOR_ERROR_NO_DATA);
 294
 295         for (GList *list = g_list_first(file->files); list != NULL; list = list->next)
 296         {
 297                 service_storage_cloud_file_h file_data = (service_storage_cloud_file_h) list->data;
 298
 299                 bool ret = callback(SERVICE_ADAPTOR_ERROR_NONE, file_data, user_data);
 300                 RETV_IF(false == ret, SERVICE_ADAPTOR_ERROR_NONE);
 301         }
 302
 303         return SERVICE_ADAPTOR_ERROR_NONE;
 304 }
 305
 306 API int service_storage_cloud_file_create_task(service_storage_cloud_file_h file, service_task_h *task)
 307 {
 308         SAL_FN_CALL;
 309
 310         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 311         RETV_IF(NULL == task, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 312
 313         service_task_h service_task = (service_task_h) g_malloc0(sizeof(service_task_s));
 314         service_task->cloud_file = file;
 315
 316         *task = service_task;
 317
 318         return SERVICE_ADAPTOR_ERROR_NONE;
 319 }
 320
 321 API int service_storage_cloud_file_destroy_task(service_task_h task)
 322 {
 323         SAL_FN_CALL;
 324
 325         RETV_IF(NULL == task, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 326
 327         SAL_FREE(task);
 328
 329         return SERVICE_ADAPTOR_ERROR_NONE;
 330 }
 331
 332 //******************************************************************************
 333 //* 2.4 Public interface definition
 334 //******************************************************************************
 335
 336 API int service_storage_get_file_list(service_plugin_h plugin,
 337                                                 const char *dir_path,
 338                                                 service_storage_file_list_cb callback,
 339                                                 void *user_data)
 340 {
 341         RETV_IF(NULL == plugin, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 342         RETV_IF(NULL == dir_path, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 343         RETV_IF(NULL == callback, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 344
 345         return SERVICE_ADAPTOR_ERROR_NONE;
 346 }
 347
 348 API int service_storage_remove(service_plugin_h plugin,
 349                                                 const char *remove_path,
 350                                                 service_storage_result_cb callback,
 351                                                 void *user_data)
 352 {
 353         RETV_IF(NULL == plugin, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 354         RETV_IF(NULL == remove_path, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 355         RETV_IF(NULL == callback, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 356
 357         return SERVICE_ADAPTOR_ERROR_NONE;
 358 }
 359
 360 API int service_storage_create_upload_task(service_plugin_h plugin,
 361                                                 const char *file_path,
 362                                                 const char *upload_path,
 363                                                 service_storage_task_h *task)
 364 {
 365         RETV_IF(NULL == plugin, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 366         RETV_IF(NULL == file_path, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 367         RETV_IF(NULL == upload_path, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 368         RETV_IF(NULL == task, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 369
 370         return SERVICE_ADAPTOR_ERROR_NONE;
 371 }
 372
 373 API int service_storage_create_download_task(service_plugin_h plugin,
 374                                                 const char *storage_path,
 375                                                 const char *download_path,
 376                                                 service_storage_task_h *task)
 377 {
 378         RETV_IF(NULL == plugin, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 379         RETV_IF(NULL == storage_path, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 380         RETV_IF(NULL == download_path, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 381         RETV_IF(NULL == task, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 382
 383         return SERVICE_ADAPTOR_ERROR_NONE;
 384 }
 385
 386 API int service_storage_create_download_thumbnail_task (service_plugin_h plugin,
 387                                                 const char *storage_path,
 388                                                 const char *download_path,
 389                                                 int thumbnail_size,
 390                                                 service_storage_task_h *task)
 391 {
 392         RETV_IF(NULL == plugin, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 393         RETV_IF(NULL == storage_path, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 394         RETV_IF(NULL == download_path, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 395         RETV_IF(0 < thumbnail_size, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 396         RETV_IF(NULL == task, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 397
 398         return SERVICE_ADAPTOR_ERROR_NONE;
 399 }
 400
 401 API int service_storage_destroy_task(service_storage_task_h task)
 402 {
 403         RETV_IF(NULL == task, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 404
 405         return SERVICE_ADAPTOR_ERROR_NONE;
 406 }
 407
 408 API int service_storage_start_task(service_storage_task_h task)
 409 {
 410         RETV_IF(NULL == task, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 411
 412         return SERVICE_ADAPTOR_ERROR_NONE;
 413 }
 414
 415 API int service_storage_cancel_task(service_storage_task_h task)
 416 {
 417         RETV_IF(NULL == task, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 418
 419         return SERVICE_ADAPTOR_ERROR_NONE;
 420 }
 421
 422 API int service_storage_set_task_progress_cb(service_storage_task_h task,
 423                                                 service_storage_task_progress_cb callback,
 424                                                 void *user_data)
 425 {
 426         RETV_IF(NULL == task, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 427         RETV_IF(NULL == callback, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 428
 429         return SERVICE_ADAPTOR_ERROR_NONE;
 430 }
 431
 432 API int service_storage_unset_task_progress_cb(service_storage_task_h task)
 433 {
 434         RETV_IF(NULL == task, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 435
 436         return SERVICE_ADAPTOR_ERROR_NONE;
 437 }
 438
 439 API int service_storage_set_task_state_changed_cb(service_storage_task_h task,
 440                                                 service_storage_task_state_cb callback,
 441                                                 void *user_data)
 442 {
 443         RETV_IF(NULL == task, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 444         RETV_IF(NULL == callback, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 445
 446         return SERVICE_ADAPTOR_ERROR_NONE;
 447 }
 448
 449 API int service_storage_unset_task_state_changed_cb(service_storage_task_h task)
 450 {
 451         RETV_IF(NULL == task, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 452
 453         return SERVICE_ADAPTOR_ERROR_NONE;
 454 }
 455
 456 API int service_storage_file_list_clone(service_storage_file_list_h src_list,
 457                                                 service_storage_file_list_h *dst_list)
 458 {
 459         RETV_IF(NULL == src_list, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 460         RETV_IF(NULL == dst_list, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 461
 462         return SERVICE_ADAPTOR_ERROR_NONE;
 463 }
 464
 465 API int service_storage_file_list_destroy(service_storage_file_list_h list)
 466 {
 467         RETV_IF(NULL == list, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 468
 469         return SERVICE_ADAPTOR_ERROR_NONE;
 470 }
 471
 472 API int service_storage_file_list_get_length(service_storage_file_list_h list,
 473                                                 int *length)
 474 {
 475         RETV_IF(NULL == list, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 476         RETV_IF(NULL == length, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 477
 478         return SERVICE_ADAPTOR_ERROR_NONE;
 479 }
 480
 481 API int service_storage_file_list_foreach_file(service_storage_file_list_h list,
 482                                                 service_storage_file_cb callback,
 483                                                 void *user_data)
 484 {
 485         RETV_IF(NULL == list, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 486         RETV_IF(NULL == callback, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 487
 488         return SERVICE_ADAPTOR_ERROR_NONE;
 489 }
 490
 491 API int service_storage_file_clone(service_storage_file_h src_file,
 492                                                 service_storage_file_h *dst_file)
 493 {
 494         RETV_IF(NULL == src_file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 495         RETV_IF(NULL == dst_file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 496
 497         return SERVICE_ADAPTOR_ERROR_NONE;
 498 }
 499
 500 API int service_storage_file_destroy(service_storage_file_h file)
 501 {
 502         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 503
 504         return SERVICE_ADAPTOR_ERROR_NONE;
 505 }
 506
 507 API int service_storage_file_is_dir(service_storage_file_h file,
 508                                                 bool *is_dir)
 509 {
 510         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 511         RETV_IF(NULL == is_dir, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 512
 513         return SERVICE_ADAPTOR_ERROR_NONE;
 514 }
 515
 516 API int service_storage_file_get_size(service_storage_file_h file,
 517                                                 unsigned long long *size)
 518 {
 519         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 520         RETV_IF(NULL == size, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 521
 522         return SERVICE_ADAPTOR_ERROR_NONE;
 523 }
 524
 525 API int service_storage_file_get_logical_path(service_storage_file_h file,
 526                                                 char **path)
 527 {
 528         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 529         RETV_IF(NULL == path, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 530
 531         return SERVICE_ADAPTOR_ERROR_NONE;
 532 }
 533
 534 API int service_storage_file_get_physical_path(service_storage_file_h file,
 535                                                 char **path)
 536 {
 537         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 538         RETV_IF(NULL == path, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 539
 540         return SERVICE_ADAPTOR_ERROR_NONE;
 541 }