binding/mediaplayer-manager.c

   1 /*
   2  *  Copyright 2017 Konsulko Group
   3  *
   4  *  Based on bluetooth-manager.c
   5  *   Copyright 2016 ALPS ELECTRIC CO., LTD.
   6  *
   7  *   Licensed under the Apache License, Version 2.0 (the "License");
   8  *   you may not use this file except in compliance with the License.
   9  *   You may obtain a copy of the License at
  10  *
  11  *   http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  *   Unless required by applicable law or agreed to in writing, software
  14  *   distributed under the License is distributed on an "AS IS" BASIS,
  15  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  *   See the License for the specific language governing permissions and
  17  *   limitations under the License.
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <unistd.h>
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26
  27 #include <pthread.h>
  28 #include <glib.h>
  29 #include <gio/gio.h>
  30 #include <glib-object.h>
  31 #include <sqlite3.h>
  32
  33 #include "mediaplayer-manager.h"
  34
  35 static Binding_RegisterCallback_t g_RegisterCallback = { 0 };
  36 static stMediaPlayerManage MediaPlayerManage = { 0 };
  37
  38 /* ------ LOCAL  FUNCTIONS --------- */
  39 void ListLock() {
  40     g_mutex_lock(&(MediaPlayerManage.m));
  41 }
  42
  43 void ListUnlock() {
  44     g_mutex_unlock(&(MediaPlayerManage.m));
  45 }
  46
  47 void DebugTraceSendMsg(int level, gchar* message)
  48 {
  49 #ifdef LOCAL_PRINT_DEBUG
  50     switch (level)
  51     {
  52             case DT_LEVEL_ERROR:
  53                 g_print("[E]");
  54                 break;
  55
  56             case DT_LEVEL_WARNING:
  57                 g_print("[W]");
  58                 break;
  59
  60             case DT_LEVEL_NOTICE:
  61                 g_print("[N]");
  62                 break;
  63
  64             case DT_LEVEL_INFO:
  65                 g_print("[I]");
  66                 break;
  67
  68             case DT_LEVEL_DEBUG:
  69                 g_print("[D]");
  70                 break;
  71
  72             default:
  73                 g_print("[-]");
  74                 break;
  75     }
  76
  77     g_print("%s",message);
  78 #endif
  79
  80     if (message) {
  81         g_free(message);
  82     }
  83
  84 }
  85
  86 GList* media_lightmediascanner_scan(void)
  87 {
  88     sqlite3 *conn;
  89     sqlite3_stmt *res;
  90     GList *list = NULL;
  91     const char *tail;
  92     const gchar *db_path;
  93     int ret = 0;
  94
  95     db_path = scanner1_get_data_base_path(MediaPlayerManage.lms_proxy);
  96
  97     ret = sqlite3_open(db_path, &conn);
  98     if (ret) {
  99         LOGE("Cannot open SQLITE database: '%s'\n", db_path);
 100         return NULL;
 101     }
 102
 103     ret = sqlite3_prepare_v2(conn, SQL_QUERY, strlen(SQL_QUERY) + 1, &res, &tail);
 104     if (ret) {
 105         LOGE("Cannot execute query '%s'\n", SQL_QUERY);
 106         return NULL;
 107     }
 108
 109     while (sqlite3_step(res) == SQLITE_ROW) {
 110         struct stat buf;
 111         const char *path = (const char *) sqlite3_column_text(res, 0);
 112
 113         ret = stat(path, &buf);
 114         if (ret)
 115             continue;
 116
 117         list = g_list_append(list, g_strdup_printf("file://%s", path));
 118     }
 119
 120     return list;
 121 }
 122
 123
 124 static void
 125 on_interface_proxy_properties_changed (GDBusProxy *proxy,
 126                                     GVariant *changed_properties,
 127                                     const gchar* const  *invalidated_properties)
 128 {
 129     GVariantIter iter;
 130     const gchar *key;
 131     GVariant *subValue;
 132     const gchar *pInterface;
 133     GList *list;
 134
 135     pInterface = g_dbus_proxy_get_interface_name (proxy);
 136
 137     if (0 != g_strcmp0(pInterface, LIGHTMEDIASCANNER_INTERFACE))
 138         return;
 139
 140     g_variant_iter_init (&iter, changed_properties);
 141     while (g_variant_iter_next (&iter, "{&sv}", &key, &subValue))
 142     {
 143         gboolean val;
 144         if (0 == g_strcmp0(key,"IsScanning")) {
 145             g_variant_get(subValue, "b", &val);
 146             if (val == TRUE)
 147                 return;
 148         } else if (0 == g_strcmp0(key, "WriteLocked")) {
 149             g_variant_get(subValue, "b", &val);
 150             if (val == TRUE)
 151                 return;
 152         }
 153     }
 154
 155     ListLock();
 156
 157     list = media_lightmediascanner_scan();
 158
 159     if (list != NULL && g_RegisterCallback.binding_device_added)
 160         g_RegisterCallback.binding_device_added(list);
 161
 162     ListUnlock();
 163 }
 164
 165 static int MediaPlayerDBusInit(void)
 166 {
 167     GError *error = NULL;
 168
 169     MediaPlayerManage.lms_proxy = scanner1_proxy_new_for_bus_sync(
 170         G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_NONE, LIGHTMEDIASCANNER_SERVICE,
 171         LIGHTMEDIASCANNER_PATH, NULL, &error);
 172
 173     if (MediaPlayerManage.lms_proxy == NULL) {
 174         LOGE("Create LightMediaScanner Proxy failed\n");
 175         return -1;
 176     }
 177
 178     g_signal_connect (MediaPlayerManage.lms_proxy,
 179                       "g-properties-changed",
 180                       G_CALLBACK (on_interface_proxy_properties_changed),
 181                       NULL);
 182
 183     return 0;
 184 }
 185
 186 static void *media_event_loop_thread(void *unused)
 187 {
 188     GMainLoop *loop = g_main_loop_new(NULL, FALSE);
 189     int ret;
 190
 191     ret = MediaPlayerDBusInit();
 192     if (ret == 0) {
 193         LOGD("g_main_loop_run\n");
 194         g_main_loop_run(loop);
 195     }
 196
 197     g_main_loop_unref(loop);
 198
 199     return NULL;
 200 }
 201
 202 void
 203 unmount_cb (GFileMonitor      *mon,
 204             GFile             *file,
 205             GFile             *other_file,
 206             GFileMonitorEvent  event,
 207             gpointer           udata)
 208 {
 209     gchar *path = g_file_get_path(file);
 210     gchar *uri = g_strconcat("file://", path, NULL);
 211     g_free(path);
 212
 213     ListLock();
 214
 215     if (g_RegisterCallback.binding_device_removed &&
 216         event == G_FILE_MONITOR_EVENT_DELETED) {
 217             g_RegisterCallback.binding_device_removed(uri);
 218     }
 219
 220     ListUnlock();
 221     g_free(uri);
 222 }
 223
 224 /*
 225  * Create MediaPlayer Manager Thread
 226  * Note: mediaplayer-api should do MediaPlayerManagerInit() before any other
 227  *       API calls
 228  * Returns: 0 - success or error conditions
 229  */
 230 int MediaPlayerManagerInit() {
 231     pthread_t thread_id;
 232     GFile *file;
 233     GFileMonitor *mon;
 234
 235     g_mutex_init(&(MediaPlayerManage.m));
 236
 237     file = g_file_new_for_path("/media");
 238     g_assert(file != NULL);
 239
 240     mon = g_file_monitor (file, G_FILE_MONITOR_NONE, NULL, NULL);
 241     g_assert(mon != NULL);
 242     g_signal_connect (mon, "changed", G_CALLBACK(unmount_cb), NULL);
 243
 244     pthread_create(&thread_id, NULL, media_event_loop_thread, NULL);
 245
 246     return 0;
 247 }
 248
 249 /*
 250  * Register MediaPlayer Manager Callback functions
 251  */
 252 void BindingAPIRegister(const Binding_RegisterCallback_t* pstRegisterCallback)
 253 {
 254     if (NULL != pstRegisterCallback)
 255     {
 256         if (NULL != pstRegisterCallback->binding_device_added)
 257         {
 258             g_RegisterCallback.binding_device_added =
 259                 pstRegisterCallback->binding_device_added;
 260         }
 261
 262         if (NULL != pstRegisterCallback->binding_device_removed)
 263         {
 264             g_RegisterCallback.binding_device_removed =
 265                 pstRegisterCallback->binding_device_removed;
 266         }
 267     }
 268 }