src/mtp_gdbus_manager.c

   1 /*
   2  * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdio.h>
  18 #include <unistd.h>
  19 #include <glib.h>
  20 #include <gio/gio.h>
  21 #include <stdlib.h>
  22
  23 #include "mtp_gdbus_manager.h"
  24 #include "mtp_gdbus_objectinfo.h"
  25 #include "mtp_gdbus_deviceinfo.h"
  26 #include "mtp_gdbus_storageinfo.h"
  27
  28 typedef struct _event_cb_s {
  29         mtp_event_cb cb;
  30         void *user_data;
  31 } event_cb_s;
  32
  33 mtpgdbuslibManager *manager_proxy = NULL;
  34 static __thread GSList *event_cb_list = NULL;
  35
  36 /* LCOV_EXCL_START */
  37 static void __mtp_event_cb(mtpgdbuslibManager *object,
  38         gint event, gint arg1, gpointer user_data)
  39 {
  40         GSList *l;
  41         event_cb_s *event_s;
  42
  43         for (l = event_cb_list; l != NULL; l = l->next) {
  44                 event_s = (event_cb_s *)l->data;
  45                 event_s->cb(event, arg1, event_s->user_data);
  46         }
  47 }
  48 /* LCOV_EXCL_STOP */
  49
  50 static void __manager_proxy_init(void)
  51 {
  52         GError *error = NULL;
  53
  54         manager_proxy = mtp_gdbuslib_manager_proxy_new_for_bus_sync(
  55                 G_BUS_TYPE_SYSTEM,
  56                 G_DBUS_PROXY_FLAGS_NONE,
  57                 MTP_DBUS_SERVICE,
  58                 MTP_DBUS_MANAGER_PATH,
  59                 NULL,
  60                 &error);
  61
  62         g_signal_connect(manager_proxy, "mtp-event", G_CALLBACK(__mtp_event_cb), NULL);
  63 }
  64
  65 static void __manager_proxy_deinit(void)
  66 {
  67         manager_proxy = NULL;
  68 }
  69
  70 mtp_error_e mtp_gdbus_manager_add_event_cb(mtp_event_cb callback, void *user_data)
  71 {
  72         event_cb_s *event_s;
  73
  74         event_s = g_try_new0(event_cb_s, 1);
  75         if (event_s == NULL)
  76                 return MTP_ERROR_OUT_OF_MEMORY;
  77
  78         event_s->cb = callback;
  79         event_s->user_data = user_data;
  80
  81         event_cb_list = g_slist_prepend(event_cb_list, event_s);
  82
  83         return MTP_ERROR_NONE;
  84 }
  85
  86 mtp_error_e mtp_gdbus_manager_remove_event_cb(mtp_event_cb callback)
  87 {
  88         GSList *l;
  89         event_cb_s *event_s;
  90
  91         for (l = event_cb_list; l != NULL; l = l->next) {
  92                 /* LCOV_EXCL_START */
  93                 event_s = (event_cb_s *)l->data;
  94                 if (callback == event_s->cb)
  95                         event_cb_list = g_slist_delete_link(event_cb_list, l);
  96                 /* LCOV_EXCL_STOP */
  97         }
  98
  99         return MTP_ERROR_NONE;
 100 }
 101
 102 mtp_error_e mtp_gdbus_manager_remove_all_event_cb(void)
 103 {
 104         g_slist_free_full(event_cb_list, g_free);
 105         event_cb_list = NULL;
 106
 107         return MTP_ERROR_NONE;
 108 }
 109
 110 mtp_error_e mtp_gdbus_manager_initialize(void)
 111 {
 112         mtp_error_e result = MTP_ERROR_NONE;
 113
 114         __manager_proxy_init();
 115         mtp_gdbus_deviceinfo_proxy_init();
 116         mtp_gdbus_storageinfo_proxy_init();
 117         mtp_gdbus_objectinfo_proxy_init();
 118
 119         if (manager_proxy == NULL)
 120                 result = MTP_ERROR_NOT_COMM_INITIALIZED; /* LCOV_EXCL_LINE */
 121
 122         return result;
 123 }
 124
 125 /* LCOV_EXCL_START */
 126 mtp_error_e mtp_gdbus_manager_get_devices(int **mtp_devices, int *device_num)
 127 {
 128         GVariant *va = NULL;
 129         mtp_error_e result = MTP_ERROR_NONE;
 130         GError *error = NULL;
 131
 132         if (manager_proxy == NULL)
 133                         return MTP_ERROR_NOT_COMM_INITIALIZED;
 134
 135         if (mtp_gdbuslib_manager_call_get_devices_sync(
 136                         manager_proxy,
 137                         device_num,
 138                         &va,
 139                         &result,
 140                         NULL,
 141                         &error) == FALSE) {
 142                 result = MTP_ERROR_COMM_ERROR;
 143
 144                 g_error_free(error);
 145                 return result;
 146         }
 147
 148         if (*device_num != 0 && (g_variant_n_children(va) == *device_num)) {
 149                 GVariantIter *iter = NULL, *iter_row = NULL;
 150                 GVariant *key_value;
 151                 const gchar *key;
 152                 guint i = 0;
 153
 154                 *mtp_devices = g_new(int, *device_num);
 155
 156                 g_variant_get(va, "aa{sv}", &iter);
 157                 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 158                         while (g_variant_iter_loop(iter_row, "{sv}", &key, &key_value)) {
 159                                 if (g_strcmp0(key, "mtp_device") == 0)
 160                                         (*mtp_devices)[i] = g_variant_get_int32(key_value);
 161                         }
 162                         i++;
 163
 164                         if (iter_row != NULL) {
 165                                 g_variant_iter_free(iter_row);
 166                                 iter_row = NULL;
 167                         }
 168                 }
 169
 170                 if (iter != NULL) {
 171                         g_variant_iter_free(iter);
 172                         iter = NULL;
 173                 }
 174         }
 175
 176         g_variant_unref(va);
 177
 178         return result;
 179 }
 180
 181 mtp_error_e mtp_gdbus_manager_get_storages(int mtp_device,
 182         int **mtp_storages, int *storage_num)
 183 {
 184         GVariant *va = NULL;
 185         mtp_error_e result = MTP_ERROR_NONE;
 186         GError *error = NULL;
 187
 188         if (manager_proxy == NULL)
 189                 return MTP_ERROR_NOT_COMM_INITIALIZED;
 190
 191         if (mtp_gdbuslib_manager_call_get_storages_sync(
 192                         manager_proxy,
 193                         mtp_device,
 194                         storage_num,
 195                         &va,
 196                         &result,
 197                         NULL,
 198                         &error) == FALSE) {
 199                 result = MTP_ERROR_COMM_ERROR;
 200
 201                 g_error_free(error);
 202                 return result;
 203         }
 204
 205         if (*storage_num != 0 && (g_variant_n_children(va) == *storage_num)) {
 206                 GVariantIter *iter = NULL, *iter_row = NULL;
 207                 GVariant *key_value;
 208                 const gchar *key;
 209                 guint i = 0;
 210
 211                 *mtp_storages = g_new(int, *storage_num);
 212
 213                 g_variant_get(va, "aa{sv}", &iter);
 214                 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 215                         while (g_variant_iter_loop(iter_row, "{sv}", &key, &key_value)) {
 216                                 if (g_strcmp0(key, "mtp_storage") == 0)
 217                                         (*mtp_storages)[i] = g_variant_get_int32(key_value);
 218                         }
 219                         i++;
 220
 221                         if (iter_row != NULL) {
 222                                 g_variant_iter_free(iter_row);
 223                                 iter_row = NULL;
 224                         }
 225                 }
 226
 227                 if (iter != NULL) {
 228                         g_variant_iter_free(iter);
 229                         iter = NULL;
 230                 }
 231         }
 232
 233         g_variant_unref(va);
 234
 235         return result;
 236 }
 237
 238 mtp_error_e mtp_gdbus_manager_get_object_handles(int mtp_device,
 239         int mtp_storage, int file_type, int parent_object_handle, int **object_handles, int *object_num)
 240 {
 241         GVariant *va = NULL;
 242         mtp_error_e result = MTP_ERROR_NONE;
 243         GError *error = NULL;
 244
 245         if (manager_proxy == NULL)
 246                 return MTP_ERROR_NOT_COMM_INITIALIZED;
 247
 248         if (mtp_gdbuslib_manager_call_get_object_handles_sync(
 249                         manager_proxy,
 250                         mtp_device,
 251                         mtp_storage,
 252                         file_type,
 253                         parent_object_handle,
 254                         object_num,
 255                         &va,
 256                         &result,
 257                         NULL,
 258                         &error) == FALSE) {
 259                 result = MTP_ERROR_COMM_ERROR;
 260
 261                 g_error_free(error);
 262                 return result;
 263         }
 264
 265         if (*object_num != 0 && (g_variant_n_children(va) == *object_num)) {
 266                 GVariantIter *iter = NULL, *iter_row = NULL;
 267                 GVariant *key_value;
 268                 const gchar *key;
 269                 guint i = 0;
 270
 271                 *object_handles = g_new(int, *object_num);
 272
 273                 g_variant_get(va, "aa{sv}", &iter);
 274                 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 275                         while (g_variant_iter_loop(iter_row, "{sv}", &key, &key_value)) {
 276                                 if (g_strcmp0(key, "object_handle") == 0)
 277                                         (*object_handles)[i] = g_variant_get_int32(key_value);
 278                         }
 279                         i++;
 280
 281                         if (iter_row != NULL) {
 282                                 g_variant_iter_free(iter_row);
 283                                 iter_row = NULL;
 284                         }
 285                 }
 286
 287                 if (iter != NULL) {
 288                         g_variant_iter_free(iter);
 289                         iter = NULL;
 290                 }
 291         }
 292
 293         g_variant_unref(va);
 294
 295         return result;
 296 }
 297
 298 mtp_error_e mtp_gdbus_manager_delete_object(int mtp_device,
 299         int object_handle)
 300 {
 301         mtp_error_e result = MTP_ERROR_NONE;
 302         GError *error = NULL;
 303
 304         if (manager_proxy == NULL)
 305                         return MTP_ERROR_NOT_COMM_INITIALIZED;
 306
 307         if (mtp_gdbuslib_manager_call_delete_object_sync(
 308                         manager_proxy,
 309                         mtp_device,
 310                         object_handle,
 311                         &result,
 312                         NULL,
 313                         &error) == FALSE) {
 314                 result = MTP_ERROR_COMM_ERROR;
 315
 316                 g_error_free(error);
 317         }
 318
 319         return result;
 320 }
 321
 322 mtp_error_e mtp_gdbus_manager_get_object(int mtp_device,
 323         int object_handle, char *dest_path)
 324 {
 325         mtp_error_e result = MTP_ERROR_NONE;
 326         GError *error = NULL;
 327
 328         if (manager_proxy == NULL)
 329                         return MTP_ERROR_NOT_COMM_INITIALIZED;
 330
 331         if (mtp_gdbuslib_manager_call_get_object_sync(
 332                         manager_proxy,
 333                         mtp_device,
 334                         object_handle,
 335                         dest_path,
 336                         &result,
 337                         NULL,
 338                         &error) == FALSE) {
 339                 result = MTP_ERROR_COMM_ERROR;
 340
 341                 g_error_free(error);
 342         }
 343
 344         return result;
 345 }
 346
 347 mtp_error_e mtp_gdbus_manager_get_partial_object(int mtp_device,
 348         int object_handle, char *dest_path, int offset, int max_bytes, int *actual_written)
 349 {
 350         mtp_error_e result = MTP_ERROR_NONE;
 351         GError *error = NULL;
 352
 353         if (manager_proxy == NULL)
 354                         return MTP_ERROR_NOT_COMM_INITIALIZED;
 355
 356         if (mtp_gdbuslib_manager_call_get_partial_object_sync(
 357                         manager_proxy,
 358                         mtp_device,
 359                         object_handle,
 360                         dest_path,
 361                         offset,
 362                         max_bytes,
 363                         actual_written,
 364                         &result,
 365                         NULL,
 366                         &error) == FALSE) {
 367                 result = MTP_ERROR_COMM_ERROR;
 368
 369                 g_error_free(error);
 370         }
 371
 372         return result;
 373 }
 374
 375 mtp_error_e mtp_gdbus_manager_get_thumbnail(int mtp_device,
 376         int object_handle, char *dest_path)
 377 {
 378         mtp_error_e result = MTP_ERROR_NONE;
 379         GError *error = NULL;
 380
 381         if (manager_proxy == NULL)
 382                 return MTP_ERROR_NOT_COMM_INITIALIZED;
 383
 384         if (mtp_gdbuslib_manager_call_get_thumbnail_sync(
 385                         manager_proxy,
 386                         mtp_device,
 387                         object_handle,
 388                         dest_path,
 389                         &result,
 390                         NULL,
 391                         &error) == FALSE) {
 392                 result = MTP_ERROR_COMM_ERROR;
 393
 394                 g_error_free(error);
 395         }
 396
 397         return result;
 398 }
 399 /* LCOV_EXCL_STOP */
 400
 401 mtp_error_e mtp_gdbus_manager_deinitialize(void)
 402 {
 403         mtp_error_e result = MTP_ERROR_NONE;
 404
 405         __manager_proxy_deinit();
 406         mtp_gdbus_deviceinfo_proxy_deinit();
 407         mtp_gdbus_storageinfo_proxy_deinit();
 408         mtp_gdbus_objectinfo_proxy_deinit();
 409
 410         return result;
 411 }