client/sal_service_adaptor.c

   1 /*
   2  * Service Adaptor
   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 <unistd.h>
  23 #include <glib.h>
  24
  25 #include <app.h>
  26
  27 #include "service_adaptor_errors.h"
  28 #include "service_adaptor_internal.h"
  29 #include "sal_service_adaptor.h"
  30 #include "sal_service_task.h"
  31 #include "sal_service_task_internal.h"
  32 #include "sal_ipc_client.h"
  33 #include "sal_ipc_client_core.h"
  34 #include "sal_ipc_client_auth.h"
  35
  36 //******************************************************************************
  37 //* Global variables and defines
  38 //******************************************************************************
  39
  40 /**
  41  * @brief Describes infromation about Adaptor Handle
  42  */
  43 typedef struct _service_adaptor_s
  44 {
  45         char *uri;
  46
  47         GList *plugins;         /* char **plugins (uri) */
  48         GList *started_plugins; /* service_plugin_h **started_plugins */
  49 } service_adaptor_s;
  50 typedef struct _service_adaptor_s *service_adaptor_h;
  51
  52 /**
  53  * @brief Describes infromation about Plugin Handle
  54  */
  55 typedef struct _service_plugin_s
  56 {
  57         char *uri;
  58 } service_plugin_s;
  59
  60 service_adaptor_h service_adaptor = NULL;
  61
  62 //******************************************************************************
  63 //* Private interface
  64 //******************************************************************************
  65
  66 //******************************************************************************
  67 //* Private interface definition
  68 //******************************************************************************
  69
  70 //******************************************************************************
  71 //* Public interface definition
  72 //******************************************************************************
  73
  74 API int service_adaptor_connect()
  75 {
  76         SAL_FN_CALL;
  77
  78         service_adaptor = (service_adaptor_h) g_malloc0(sizeof(service_adaptor_s));
  79
  80         char *uri = NULL;
  81
  82         app_get_id(&uri);
  83
  84         if (NULL == uri)
  85         {
  86                 char path[1024] = {0,};
  87                 int path_len = 0;
  88
  89                 path_len = readlink("/proc/self/exe", path, 1024);
  90                 RETV_IF(0 == path_len, SERVICE_ADAPTOR_ERROR_SYSTEM);
  91
  92                 uri = strndup(path, path_len);
  93         }
  94
  95         service_adaptor->uri = strdup(uri);
  96
  97         int ret = SERVICE_ADAPTOR_ERROR_NONE;
  98         ret = sal_ipc_client_init();
  99         RETV_IF(SERVICE_ADAPTOR_ERROR_NONE != ret, SERVICE_ADAPTOR_ERROR_INTERNAL);
 100
 101         GList *plugins = NULL;
 102         ret = ipc_service_adaptor_connect(uri, &plugins);
 103         RETV_IF(SERVICE_ADAPTOR_ERROR_NONE != ret, SERVICE_ADAPTOR_ERROR_INTERNAL);
 104
 105         ret = service_task_connect();
 106         RETVM_IF(SERVICE_ADAPTOR_ERROR_NONE != ret, ret, "service_task_connect() Failed");
 107
 108         service_adaptor->plugins = plugins;
 109
 110         SAL_FREE(uri);
 111
 112         return SERVICE_ADAPTOR_ERROR_NONE;
 113 }
 114
 115 API int service_adaptor_disconnect()
 116 {
 117         SAL_FN_CALL;
 118
 119         RETV_IF(NULL == service_adaptor, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 120
 121         int ret = SERVICE_ADAPTOR_ERROR_NONE;
 122         ret = service_task_disconnect();
 123         RETVM_IF(SERVICE_ADAPTOR_ERROR_NONE != ret, ret, "service_task_disconnect() Failed");
 124
 125         ret = ipc_service_adaptor_disconnect(service_adaptor->uri);
 126         RETV_IF(SERVICE_ADAPTOR_ERROR_NONE != ret, SERVICE_ADAPTOR_ERROR_INTERNAL);
 127
 128         ret = sal_ipc_client_deinit();
 129         RETV_IF(SERVICE_ADAPTOR_ERROR_NONE != ret, SERVICE_ADAPTOR_ERROR_INTERNAL);
 130
 131         // TODO: free memory in adaptor
 132         SAL_FREE(service_adaptor);
 133
 134         return SERVICE_ADAPTOR_ERROR_NONE;
 135 }
 136
 137 API int service_adaptor_foreach_plugin(service_adaptor_plugin_cb callback, void *user_data)
 138 {
 139         SAL_FN_CALL;
 140
 141         RETV_IF(NULL == service_adaptor, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 142         RETV_IF(NULL == callback, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 143
 144         RETV_IF(0 == g_list_length(service_adaptor->plugins), SERVICE_ADAPTOR_ERROR_NO_DATA);
 145
 146         for (GList *list = g_list_first(service_adaptor->plugins); list != NULL; list = list->next)
 147         {
 148                 char * uri = (char *) list->data;
 149
 150                 bool ret = callback(uri, 0, user_data);
 151                 RETV_IF(false == ret, SERVICE_ADAPTOR_ERROR_NONE);
 152         }
 153
 154         return SERVICE_ADAPTOR_ERROR_NONE;
 155 }
 156
 157 API int service_adaptor_get_last_result(int *err)
 158 {
 159         SAL_FN_CALL;
 160
 161         RETV_IF(NULL == service_adaptor, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 162         RETV_IF(NULL == err, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 163
 164         return SERVICE_ADAPTOR_ERROR_NONE;
 165 }
 166
 167 API int service_adaptor_get_last_error_message(char **message)
 168 {
 169         SAL_FN_CALL;
 170
 171         RETV_IF(NULL == service_adaptor, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 172         RETV_IF(NULL == message, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 173
 174         return SERVICE_ADAPTOR_ERROR_NONE;
 175 }
 176
 177 API int service_plugin_create(const char *uri, service_plugin_h *plugin)
 178 {
 179         SAL_FN_CALL;
 180
 181         RETV_IF(NULL == service_adaptor, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 182         RETV_IF(NULL == uri, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 183         RETV_IF(NULL == plugin, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 184
 185         int ret = ipc_service_plugin_create(uri);
 186         RETV_IF(SERVICE_ADAPTOR_ERROR_NONE != ret, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 187
 188         service_plugin_h service_plugin = (service_plugin_h) g_malloc0(sizeof(service_plugin_s));
 189
 190         service_plugin->uri = strdup(uri);
 191
 192         *plugin = service_plugin;
 193
 194         return SERVICE_ADAPTOR_ERROR_NONE;
 195 }
 196
 197 API int service_plugin_destroy(service_plugin_h plugin)
 198 {
 199         SAL_FN_CALL;
 200
 201         RETV_IF(NULL == service_adaptor, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 202         RETV_IF(NULL == plugin, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 203
 204         int ret = ipc_service_plugin_destroy(plugin->uri);
 205         RETV_IF(SERVICE_ADAPTOR_ERROR_NONE != ret, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 206
 207         // TODO: free memeory of plugin
 208         SAL_FREE(plugin);
 209
 210         return SERVICE_ADAPTOR_ERROR_NONE;
 211 }
 212
 213 API int service_plugin_add_property(service_plugin_h plugin, const char *key, const char *value)
 214 {
 215         RETV_IF(NULL == service_adaptor, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 216         RETV_IF(NULL == plugin, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 217         RETV_IF(NULL == key, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 218         RETV_IF(NULL == value, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 219
 220         return SERVICE_ADAPTOR_ERROR_NONE;
 221 }
 222
 223 API int service_plugin_remove_property(service_plugin_h plugin, const char *key)
 224 {
 225         RETV_IF(NULL == service_adaptor, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 226         RETV_IF(NULL == plugin, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 227         RETV_IF(NULL == key, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 228
 229         return SERVICE_ADAPTOR_ERROR_NONE;
 230 }
 231
 232 API int service_plugin_get_property(service_plugin_h plugin, const char *key, char **value)
 233 {
 234         RETV_IF(NULL == service_adaptor, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 235         RETV_IF(NULL == plugin, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 236         RETV_IF(NULL == key, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 237         RETV_IF(NULL == value, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 238
 239         return SERVICE_ADAPTOR_ERROR_NONE;
 240 }
 241
 242 API int service_plugin_login(service_plugin_h plugin, service_plugin_login_cb callback, void *user_data)
 243 {
 244         SAL_FN_CALL;
 245
 246         RETV_IF(NULL == service_adaptor, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 247         RETV_IF(NULL == plugin, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 248         RETV_IF(NULL == callback, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 249
 250         // TODO: login this plugin via service adaptor (dbus)
 251
 252         callback(SERVICE_ADAPTOR_ERROR_NONE, user_data);
 253
 254         return SERVICE_ADAPTOR_ERROR_NONE;
 255 }
 256
 257 API int service_plugin_start(service_plugin_h plugin)
 258 {
 259         SAL_FN_CALL;
 260
 261         RETV_IF(NULL == service_adaptor, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 262         RETV_IF(NULL == plugin, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 263
 264         // TODO: check this plugin via service adaptor (dbus), use or not use?, must be logined.
 265
 266         service_adaptor->started_plugins = g_list_append(service_adaptor->started_plugins, plugin);
 267
 268         return SERVICE_ADAPTOR_ERROR_NONE;
 269 }
 270
 271 API int service_plugin_stop(service_plugin_h plugin)
 272 {
 273         SAL_FN_CALL;
 274
 275         RETV_IF(NULL == service_adaptor, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 276         RETV_IF(NULL == plugin, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 277
 278         // TODO: notify to stop this plugin to service adaptor (dbus)
 279
 280         for (GList *list = g_list_first(service_adaptor->started_plugins); list != NULL; list = list->next)
 281         {
 282                 service_plugin_h service_plugin = (service_plugin_h) list->data;
 283
 284                 if (0 == strcmp(service_plugin->uri, plugin->uri))
 285                 {
 286                         service_adaptor->started_plugins = g_list_remove(service_adaptor->started_plugins, list);
 287
 288                         return SERVICE_ADAPTOR_ERROR_NONE;
 289                 }
 290         }
 291
 292         return SERVICE_ADAPTOR_ERROR_NONE;
 293 }
 294
 295 int service_plugin_get_uri(service_plugin_h plugin, char **uri)
 296 {
 297         SAL_FN_CALL;
 298
 299         RETV_IF(NULL == service_adaptor, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 300         RETV_IF(NULL == plugin, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 301         RETV_IF(NULL == uri, SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 302         RETV_IF(NULL == g_list_find(service_adaptor->started_plugins, plugin), SERVICE_ADAPTOR_ERROR_INVALID_PARAMETER);
 303
 304         *uri = strdup(plugin->uri);
 305
 306         return SERVICE_ADAPTOR_ERROR_NONE;
 307 }