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
  93         *file = cloud_file;
  94
  95         return SERVICE_ADAPTOR_ERROR_NONE;
  96 }
  97
  98 API int service_storage_cloud_file_clone(service_storage_cloud_file_h src_file, service_storage_cloud_file_h *dst_file)
  99 {
 100         SAL_FN_CALL;
 101
 102         RETV_IF(NULL == src_file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 103
 104         service_storage_cloud_file_h cloud_file = (service_storage_cloud_file_h) g_malloc0(sizeof(service_storage_cloud_file_s));
 105         cloud_file->plugin = src_file->plugin;
 106         cloud_file->callback = src_file->callback;
 107         cloud_file->is_dir = src_file->is_dir;
 108         cloud_file->dir_path = strdup(src_file->dir_path);
 109         cloud_file->local_path = strdup(src_file->local_path);
 110         cloud_file->cloud_path = strdup(src_file->cloud_path);
 111         cloud_file->size = src_file->size;
 112         cloud_file->operation = strdup(src_file->operation);
 113         // TODO: g_list_copy_deep()
 114         cloud_file->files = g_list_copy(src_file->files);
 115
 116         *dst_file = cloud_file;
 117
 118         return SERVICE_ADAPTOR_ERROR_NONE;
 119 }
 120
 121 API int service_storage_cloud_file_destroy(service_storage_cloud_file_h file)
 122 {
 123         SAL_FN_CALL;
 124
 125         SAL_FREE(file->dir_path);
 126         SAL_FREE(file->local_path);
 127         SAL_FREE(file->cloud_path);
 128         SAL_FREE(file->operation);
 129         SAL_FREE(file);
 130
 131         return SERVICE_ADAPTOR_ERROR_NONE;
 132 }
 133
 134 API int service_storage_cloud_file_set_callback(service_storage_cloud_file_h file, service_storage_cloud_file_cb callback, void *user_data)
 135 {
 136         SAL_FN_CALL;
 137
 138         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 139         RETV_IF(NULL == callback, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 140
 141         file->callback = callback;
 142         file->user_data = user_data;
 143
 144         return SERVICE_ADAPTOR_ERROR_NONE;
 145 }
 146
 147 API int service_storage_cloud_file_unset_callback(service_storage_cloud_file_h file)
 148 {
 149         SAL_FN_CALL;
 150
 151         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 152
 153         file->callback = NULL;
 154         file->user_data = NULL;
 155
 156         return SERVICE_ADAPTOR_ERROR_NONE;
 157 }
 158
 159 API int service_storage_cloud_file_set_cloud_path(service_storage_cloud_file_h file, const char *cloud_path)
 160 {
 161         SAL_FN_CALL;
 162
 163         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 164         RETV_IF(NULL == cloud_path, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 165
 166         file->cloud_path = strdup(cloud_path);
 167
 168         return SERVICE_ADAPTOR_ERROR_NONE;
 169 }
 170
 171 API int service_storage_cloud_file_get_cloud_path(service_storage_cloud_file_h file, char **cloud_path)
 172 {
 173         SAL_FN_CALL;
 174
 175         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 176         RETV_IF(NULL == cloud_path, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 177
 178         *cloud_path = strdup(file->cloud_path);
 179
 180         return SERVICE_ADAPTOR_ERROR_NONE;
 181 }
 182
 183 API int service_storage_cloud_file_set_local_path(service_storage_cloud_file_h file, const char *local_path)
 184 {
 185         SAL_FN_CALL;
 186
 187         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 188         RETV_IF(NULL == local_path, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 189
 190         file->local_path = strdup(local_path);
 191
 192         return SERVICE_ADAPTOR_ERROR_NONE;
 193 }
 194
 195 API int service_storage_cloud_file_get_local_path(service_storage_cloud_file_h file, char **local_path)
 196 {
 197         SAL_FN_CALL;
 198
 199         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 200         RETV_IF(NULL == local_path, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 201
 202         *local_path = strdup(file->local_path);
 203
 204         return SERVICE_ADAPTOR_ERROR_NONE;
 205 }
 206
 207 API int service_storage_cloud_file_set_size(service_storage_cloud_file_h file, unsigned long long size)
 208 {
 209         SAL_FN_CALL;
 210
 211         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 212         RETV_IF(0 > size, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 213
 214         file->size = size;
 215
 216         return SERVICE_ADAPTOR_ERROR_NONE;
 217 }
 218
 219 API int service_storage_cloud_file_get_size(service_storage_cloud_file_h file, unsigned long long *size)
 220 {
 221         SAL_FN_CALL;
 222
 223         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 224         RETV_IF(NULL == size, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 225
 226         *size = file->size;
 227
 228         return SERVICE_ADAPTOR_ERROR_NONE;
 229 }
 230
 231 API int service_storage_cloud_file_set_operation(service_storage_cloud_file_h file, const char *operation)
 232 {
 233         SAL_FN_CALL;
 234
 235         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 236         RETV_IF(NULL == operation, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 237
 238         file->operation = strdup(operation);
 239
 240         return SERVICE_ADAPTOR_ERROR_NONE;
 241 }
 242
 243 API int service_storage_cloud_file_get_operation(service_storage_cloud_file_h file, char **operation)
 244 {
 245         SAL_FN_CALL;
 246
 247         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 248         RETV_IF(NULL == operation, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 249
 250         *operation = strdup(file->operation);
 251
 252         return SERVICE_ADAPTOR_ERROR_NONE;
 253 }
 254
 255 API int service_storage_cloud_file_is_directory(service_storage_cloud_file_h file, bool *is_dir)
 256 {
 257         SAL_FN_CALL;
 258
 259         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 260         RETV_IF(NULL == is_dir, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 261
 262         *is_dir = file->is_dir;
 263
 264         return SERVICE_ADAPTOR_ERROR_NONE;
 265 }
 266
 267 API int service_storage_cloud_file_foreach_file(service_storage_cloud_file_h file, service_storage_cloud_file_cb callback, void *user_data)
 268 {
 269         SAL_FN_CALL;
 270
 271         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 272         RETV_IF(NULL == callback, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 273
 274         RETV_IF(false == file->is_dir, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 275
 276         RETV_IF(0 == g_list_length(file->files), SERVICE_ADAPTOR_ERROR_NO_DATA);
 277
 278         for (GList *list = g_list_first(file->files); list != NULL; list = list->next)
 279         {
 280                 service_storage_cloud_file_h file_data = (service_storage_cloud_file_h) list->data;
 281
 282                 bool ret = callback(SERVICE_ADAPTOR_ERROR_NONE, file_data, user_data);
 283                 RETV_IF(false == ret, SERVICE_ADAPTOR_ERROR_NONE);
 284         }
 285
 286         return SERVICE_ADAPTOR_ERROR_NONE;
 287 }
 288
 289 API int service_storage_cloud_file_create_task(service_storage_cloud_file_h file, service_task_h *task)
 290 {
 291         SAL_FN_CALL;
 292
 293         RETV_IF(NULL == file, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 294         RETV_IF(NULL == task, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 295
 296         service_task_h service_task = (service_task_h) g_malloc0(sizeof(service_task_s));
 297         service_task->cloud_file = file;
 298
 299         *task = service_task;
 300
 301         return SERVICE_ADAPTOR_ERROR_NONE;
 302 }
 303
 304 API int service_storage_cloud_file_destroy_task(service_task_h task)
 305 {
 306         SAL_FN_CALL;
 307
 308         RETV_IF(NULL == task, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 309
 310         SAL_FREE(task);
 311
 312         return SERVICE_ADAPTOR_ERROR_NONE;
 313 }