binding: bluetooth: make system wide service

Allow Bluetooth binding to be build separately and installed
as a system wide service

Bug-AGL: SPEC-661 SPEC-715
Change-Id: I12feefa2908243aa3bdcb0341f9bc9654c23741e
Signed-off-by: Matt Ranostay <matt.ranostay@konsulko.com>

1 files changed, 1811 insertions, 0 deletions

diff --git a/binding-bluetooth/bluetooth-manager.c b/binding-bluetooth/bluetooth-manager.c
new file mode 100644
index 0000000..5ce90ce
--- /dev/null
+++ b/binding-bluetooth/bluetooth-manager.c
@@ -0,0 +1,1811 @@
+/*  Copyright 2016 ALPS ELECTRIC CO., LTD.
+*
+*   Licensed under the Apache License, Version 2.0 (the "License");
+*   you may not use this file except in compliance with the License.
+*   You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+*   Unless required by applicable law or agreed to in writing, software
+*   distributed under the License is distributed on an "AS IS" BASIS,
+*   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*   See the License for the specific language governing permissions and
+*   limitations under the License.
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <glib.h>
+#include <gio/gio.h>
+#include <glib-object.h>
+#include <syslog.h>
+#include <sys/time.h>
+
+#include "bluetooth-manager.h"
+#include "bluez-client.h"
+#include "ofono-client.h"
+#include "bluetooth-agent.h"
+
+static Client cli = { 0 };
+static Binding_RegisterCallback_t g_RegisterCallback = { 0 };
+static stBluetoothManage BluetoothManage = { 0 };
+static FILE *logfp= NULL;
+
+/* ------ LOCAL  FUNCTIONS --------- */
+void BluetoothManage_InitFlag_Set(gboolean value)
+{
+    BluetoothManage.inited = value;
+}
+
+gboolean BluetoothManage_InitFlag_Get(void)
+{
+    return BluetoothManage.inited;
+}
+
+void devices_list_lock(void)
+{
+    g_mutex_lock(&(BluetoothManage.m));
+}
+
+void devices_list_unlock(void)
+{
+    g_mutex_unlock(&(BluetoothManage.m));
+}
+
+static int device_path_cmp(struct btd_device * device, const gchar* pPath )
+{
+    return !g_str_has_prefix (pPath, device->path);
+}
+
+/*
+ * search device by path
+ * Returns the first found btd_device or NULL if it is not found
+ */
+struct btd_device *devices_list_find_device_by_path(const gchar* pPath)
+{
+    GSList * temp;
+
+    temp = g_slist_find_custom (BluetoothManage.device, pPath,
+                                (GCompareFunc)device_path_cmp);
+
+    if (temp) {
+        return temp->data;
+    }
+
+    return NULL;
+
+}
+
+
+static int device_bdaddr_cmp(struct btd_device * device, const gchar* pBDaddr )
+{
+    return g_strcmp0 (device->bdaddr, pBDaddr);
+}
+
+/*
+ * search device by path
+ * Returns the first found btd_device or NULL if it is not found
+ */
+struct btd_device *devices_list_find_device_by_bdaddr(const gchar* pBDaddr)
+{
+    GSList * temp;
+
+    temp = g_slist_find_custom (BluetoothManage.device, pBDaddr,
+                                (GCompareFunc)device_bdaddr_cmp);
+
+    if (temp) {
+        return temp->data;
+    }
+
+    return NULL;
+
+}
+
+
+/*
+ * make a copy of each element
+ * And, to entirely free the new btd_device, you could do: device_free
+ */
+struct btd_device *device_copy(struct btd_device* device)
+{
+    struct btd_device * temp;
+
+    if (NULL == device) {
+        return NULL;
+    }
+
+    temp = g_malloc0(sizeof(struct btd_device));
+    temp->path = g_strdup(device->path);
+    temp->bdaddr = g_strdup(device->bdaddr);
+    temp->name = g_strdup(device->name);
+    temp->paired = device->paired;
+    temp->trusted = device->trusted;
+    temp->connected = device->connected;
+    temp->avconnected = device->avconnected;
+    temp->hfpconnected = device->hfpconnected;
+    temp->uuids = g_list_copy_deep(device->uuids, g_strdup, NULL);
+
+    return temp;
+}
+
+/*
+ * Frees all of the memory
+ */
+void device_free(struct btd_device* device)
+{
+
+    if (NULL == device) {
+        return ;
+    }
+    D_PRINTF("device %p\n",device);
+    if (device->path) {
+        D_PRINTF("path:%s\n",device->path);
+        g_free(device->path);
+        device->path = NULL;
+    }
+    if (device->bdaddr) {
+        D_PRINTF("bdaddr:%s\n",device->bdaddr);
+        g_free(device->bdaddr);
+        device->bdaddr = NULL;
+    }
+    if (device->name) {
+        D_PRINTF("name:%s\n",device->name);
+        g_free(device->name);
+        device->name = NULL;
+    }
+
+    if (device->avrcp_title) {
+        D_PRINTF("avrcp_title:%s\n",device->avrcp_title);
+        g_free(device->avrcp_title);
+        device->avrcp_title = NULL;
+    }
+
+    if (device->avrcp_artist) {
+        D_PRINTF("avrcp_artist:%s\n",device->avrcp_artist);
+        g_free(device->avrcp_artist);
+        device->avrcp_artist = NULL;
+    }
+
+    if (device->avrcp_status) {
+        D_PRINTF("avrcp_status:%s\n",device->avrcp_status);
+        g_free(device->avrcp_status);
+        device->avrcp_status = NULL;
+    }
+
+    if (device->transport_state) {
+        D_PRINTF("transport_state:%s\n",device->transport_state);
+        g_free(device->transport_state);
+        device->transport_state = NULL;
+    }
+
+    if (device->uuids) {
+        D_PRINTF("uuids: xxx\n");
+        g_list_free_full(device->uuids, g_free);
+        device->uuids = NULL;
+    }
+
+    g_free(device);
+}
+
+void device_print(struct btd_device *BDdevice)
+{
+    g_print("device %p\n",BDdevice);
+    g_print("bdaddr\t\t:%s\n",BDdevice->bdaddr);
+    g_print("name\t\t:%s\n",BDdevice->name);
+    g_print("trusted\t\t:%d\n",BDdevice->trusted);
+    g_print("paired\t\t:%d\n",BDdevice->paired);
+
+    g_print("connected\t:%d\n",BDdevice->connected);
+    g_print("AVPconnected\t:%d\n",BDdevice->avconnected);
+    g_print("HFPconnected\t:%d\n",BDdevice->hfpconnected);
+}
+
+/*
+ * remove all the devices
+ */
+void devices_list_cleanup()
+{
+    LOGD("\n");
+    GSList * temp = BluetoothManage.device;
+    while (temp) {
+        struct btd_device *BDdevice = temp->data;
+        temp = temp->next;
+
+        BluetoothManage.device = g_slist_remove_all(BluetoothManage.device,
+                BDdevice);
+
+        device_free(BDdevice);
+    }
+}
+
+/*
+ * Print all the devices
+ */
+void devices_list_print()
+{
+    LOGD("\n");
+    GSList * temp = BluetoothManage.device;
+    while (temp) {
+        struct btd_device *BDdevice = temp->data;
+        temp = temp->next;
+        g_print("----------------------------------------\n");
+        device_print(BDdevice);
+    }
+    g_print("----------------------------------------\n");
+}
+
+/*
+ * update device from Interfcace org.bluez.MediaControl1 properties
+ */
+static int device_update_from_MediaControl1(struct btd_device *device,
+                                                     GVariant *value)
+{
+    GVariantIter iter;
+    const gchar *key;
+    GVariant *subValue;
+
+    if ((NULL==device) || (NULL==value))
+    {
+        return -1;
+    }
+
+    g_variant_iter_init (&iter, value);
+    while (g_variant_iter_next (&iter, "{&sv}", &key, &subValue))
+    {
+        //gchar *s = g_variant_print (subValue, TRUE);
+        //g_print ("  %s -> %s\n", key, s);
+        //g_free (s);
+
+        gboolean value_b  =  FALSE;//b gboolean
+        //gchar value_c = 0;
+        //guchar value_y  =  0;//y guchar
+        //gint16 value_n  =  0;//n gint16
+        //guint16 value_q  =  0;//q guint16
+        //gint32 value_i  =  0;//i gint32
+        //guint32 value_u  =  0;//u guint32
+        //gint64 value_x  =  0;//x gint64
+        //guint64 value_t  =  0;//t guint64
+        //gint32 value_h  = 0;//h gint32
+        //gdouble value_d = 0.0;//d gdouble
+        gchar *str;//d gdouble
+
+        if (0==g_strcmp0(key,"Connected")) {
+            g_variant_get(subValue, "b", &value_b );
+            D_PRINTF("Connected %d\n",value_b);
+            device->avconnected = value_b;
+        }else if (0==g_strcmp0(key,"Player")) {
+            g_variant_get(subValue, "o", &str );
+            D_PRINTF("Player Object %s\n",str);
+        }
+    }
+
+    return 0;
+}
+
+/*
+ * update device from Interface org.bluez.MediaTransport1 properties
+ */
+static int device_update_from_MediaTransport1(struct btd_device *device,
+                                                     GVariant *value)
+{
+    GVariantIter iter;
+    const gchar *key;
+    GVariant *subValue;
+
+    if ((NULL==device) || (NULL==value))
+    {
+        return -1;
+    }
+
+    g_variant_iter_init (&iter, value);
+    while (g_variant_iter_next (&iter, "{&sv}", &key, &subValue))
+    {
+        //gchar *s = g_variant_print (subValue, TRUE);
+        //g_print ("  %s -> %s\n", key, s);
+        //g_free (s);
+
+        //gboolean value_b  =  FALSE;//b gboolean
+        //gchar value_c = 0;
+        //guchar value_y  =  0;//y guchar
+        //gint16 value_n  =  0;//n gint16
+        guint16 value_q  =  0;//q guint16
+        //gint32 value_i  =  0;//i gint32
+        //guint32 value_u  =  0;//u guint32
+        //gint64 value_x  =  0;//x gint64
+        //guint64 value_t  =  0;//t guint64
+        //gint32 value_h  = 0;//h gint32
+        //gdouble value_d = 0.0;//d gdouble
+        gchar *str;//d gdouble
+
+        if (0==g_strcmp0(key,"State")) {
+            g_variant_get(subValue, "s", &str);
+            D_PRINTF("State %s\n", str);
+            if (device->transport_state)
+                free(device->transport_state);
+            device->transport_state = g_strdup(str);
+        } else if (0==g_strcmp0(key,"Volume")) {
+            g_variant_get(subValue, "q", &value_q);
+            D_PRINTF("Volume %d\n", value_q);
+            device->transport_volume = value_q;
+        }
+    }
+
+    return 0;
+}
+
+
+static int device_update_from_Track(struct btd_device *device,
+                                                     GVariant *value)
+{
+    GVariantIter iter;
+    const gchar *key;
+    GVariant *subValue;
+
+    if ((NULL==device) || (NULL==value))
+    {
+        return -1;
+    }
+
+    g_variant_iter_init (&iter, value);
+    while (g_variant_iter_next (&iter, "{&sv}", &key, &subValue))
+    {
+        //gchar *s = g_variant_print (subValue, TRUE);
+        //g_print ("  %s -> %s\n", key, s);
+        //g_free (s);
+
+        gboolean value_b  =  FALSE;//b gboolean
+        //gchar value_c = 0;
+        //guchar value_y  =  0;//y guchar
+        //gint16 value_n  =  0;//n gint16
+        //guint16 value_q  =  0;//q guint16
+        //gint32 value_i  =  0;//i gint32
+        guint32 value_u  =  0;//u guint32
+        //gint64 value_x  =  0;//x gint64
+        //guint64 value_t  =  0;//t guint64
+        //gint32 value_h  = 0;//h gint32
+        //gdouble value_d = 0.0;//d gdouble
+        gchar *str;//d gdouble
+
+        if (0==g_strcmp0(key,"Title")) {
+            g_variant_get(subValue, "s", &str);
+            D_PRINTF("Title %s\n", str);
+            if (device->avrcp_title)
+                free(device->avrcp_title);
+            device->avrcp_title = g_strdup(str);
+        } else if (0==g_strcmp0(key,"Artist")) {
+            g_variant_get(subValue, "s", &str);
+            D_PRINTF("Artist %s\n", str);
+            if (device->avrcp_artist)
+                free(device->avrcp_artist);
+            device->avrcp_artist = g_strdup(str);
+        } else if (0==g_strcmp0(key,"Duration")) {
+            g_variant_get(subValue, "u", &value_u);
+            D_PRINTF("Duration %u\n", value_u);
+            device->avrcp_duration = value_u;
+        }
+    }
+
+    return 0;
+}
+
+/*
+ * update device from Interface org.bluez.MediaPlayer1 properties
+ */
+static int device_update_from_MediaPlayer1(struct btd_device *device,
+                                                     GVariant *value)
+{
+    GVariantIter iter;
+    const gchar *key;
+    GVariant *subValue;
+
+    if ((NULL==device) || (NULL==value))
+    {
+        return -1;
+    }
+
+    g_variant_iter_init (&iter, value);
+    while (g_variant_iter_next (&iter, "{&sv}", &key, &subValue))
+    {
+        //gchar *s = g_variant_print (subValue, TRUE);
+        //g_print ("  %s -> %s\n", key, s);
+        //g_free (s);
+
+        gboolean value_b  =  FALSE;//b gboolean
+        //gchar value_c = 0;
+        //guchar value_y  =  0;//y guchar
+        //gint16 value_n  =  0;//n gint16
+        //guint16 value_q  =  0;//q guint16
+        //gint32 value_i  =  0;//i gint32
+        guint32 value_u  =  0;//u guint32
+        //gint64 value_x  =  0;//x gint64
+        //guint64 value_t  =  0;//t guint64
+        //gint32 value_h  = 0;//h gint32
+        //gdouble value_d = 0.0;//d gdouble
+        gchar *str;//d gdouble
+
+        if (0==g_strcmp0(key,"Status")) {
+            g_variant_get(subValue, "s", &str);
+            D_PRINTF("Status %s\n", str);
+            if (device->avrcp_status)
+                free(device->avrcp_status);
+            device->avrcp_status = g_strdup(str);
+        } else if (0==g_strcmp0(key,"Position")) {
+            g_variant_get(subValue, "u", &value_u);
+            D_PRINTF("Position %d\n", value_u);
+            device->avrcp_position = value_u;
+        } else if (0==g_strcmp0(key,"Track")) {
+            device_update_from_Track(device, subValue);
+        }
+    }
+
+    return 0;
+}
+
+/*
+ * update device from Interfcace org.bluez.Device1 properties
+ */
+static int device_update_from_Device1(struct btd_device *device,
+                                               GVariant *value)
+{
+    if ((NULL==device) || (NULL==value))
+    {
+        return -1;
+    }
+
+    GVariantIter iter;
+    const gchar *key;
+    GVariant *subValue;
+
+    g_variant_iter_init (&iter, value);
+    while (g_variant_iter_next (&iter, "{&sv}", &key, &subValue))
+    {
+        //gchar *s = g_variant_print (subValue, TRUE);
+        //g_print ("  %s -> %s\n", key, s);
+        //g_free (s);
+
+        gboolean value_b  =  FALSE;//b gboolean
+        //gchar value_c = 0;
+        //guchar value_y  =  0;//y guchar
+        //gint16 value_n  =  0;//n gint16
+        //guint16 value_q  =  0;//q guint16
+        //gint32 value_i  =  0;//i gint32
+        //guint32 value_u  =  0;//u guint32
+        //gint64 value_x  =  0;//x gint64
+        //guint64 value_t  =  0;//t guint64
+        //gint32 value_h  = 0;//h gint32
+        //gdouble value_d = 0.0;//d gdouble
+        gchar *str;//d gdouble
+
+        if (0==g_strcmp0(key,"Address")) {
+            g_variant_get(subValue, "s", &str );
+            D_PRINTF("Address %s\n",str);
+
+            if (device->bdaddr)
+                g_free (device->bdaddr);
+
+            device->bdaddr = g_strdup(str);
+
+            g_free (str);
+            str = NULL;
+
+        }else if (0==g_strcmp0(key,"Name")) {
+            g_variant_get(subValue, "s", &str );
+            D_PRINTF("Name %s\n",str);
+
+            if (device->name)
+                g_free (device->name);
+
+            device->name = g_strdup(str);
+
+            g_free (str);
+            str = NULL;
+
+        }else if (0==g_strcmp0(key,"Paired")) {
+            g_variant_get(subValue, "b", &value_b );
+            D_PRINTF("Paired %d\n",value_b);
+            device->paired = value_b;
+        }else if (0==g_strcmp0(key,"Trusted")) {
+            g_variant_get(subValue, "b", &value_b );
+            D_PRINTF("Trusted %d\n",value_b);
+            device->trusted = value_b;
+         }else if (0==g_strcmp0(key,"Connected")) {
+            g_variant_get(subValue, "b", &value_b );
+            D_PRINTF("Connected %d\n",value_b);
+            device->connected = value_b;
+        }
+    }
+
+    return 0;
+
+}
+#if 0
+/*
+ * update device from Interfcace org.bluez.MediaControl1 properties
+ */
+static int bluez_mediacontrol1_properties_update(struct bt_device *device,
+                                                         GVariant *value)
+{
+    GVariantIter iter;
+    const gchar *key;
+    GVariant *subValue;
+
+    if ((NULL==device) || (NULL==value))
+    {
+        return -1;
+    }
+
+    g_variant_iter_init (&iter, value);
+    while (g_variant_iter_next (&iter, "{&sv}", &key, &subValue))
+    {
+        //gchar *s = g_variant_print (subValue, TRUE);
+        //g_print ("  %s -> %s\n", key, s);
+        //g_free (s);
+
+        gboolean value_b  =  FALSE;//b gboolean
+        //gchar value_c = 0;
+        //guchar value_y  =  0;//y guchar
+        gint16 value_n  =  0;//n gint16
+        //guint16 value_q  =  0;//q guint16
+        //gint32 value_i  =  0;//i gint32
+        //guint32 value_u  =  0;//u guint32
+        //gint64 value_x  =  0;//x gint64
+        //guint64 value_t  =  0;//t guint64
+        //gint32 value_h  = 0;//h gint32
+        //gdouble value_d = 0.0;//d gdouble
+        gchar *str;//d gdouble
+
+        if (0==g_strcmp0(key,"Connected")) {
+            g_variant_get(subValue, "b", &value_b );
+            D_PRINTF("Connected %d\n",value_b);
+            device->avconnected = value_b;
+
+        }else if (0==g_strcmp0(key,"Player")) {
+            g_variant_get(subValue, "o", &str );
+            D_PRINTF("Player Object %s\n",str);
+
+        }
+    }
+
+    return 0;
+
+}
+#endif
+
+/*
+ * make a copy of each element
+ */
+struct btd_device *device_copy_from_bluez(struct bt_device* device)
+{
+    struct btd_device * temp;
+
+    if (NULL == device) {
+        return NULL;
+    }
+
+    temp = g_malloc0(sizeof(struct btd_device));
+    temp->path = g_strdup(device->path);
+    temp->bdaddr = g_strdup(device->bdaddr);
+    temp->name = g_strdup(device->name);
+    temp->paired = device->paired;
+    temp->trusted = device->trusted;
+    temp->connected = device->connected;
+    temp->avconnected = device->avconnected;
+    temp->uuids = g_list_copy_deep(device->uuids, g_strdup, NULL);
+
+    return temp;
+}
+
+/*
+ * Force Update the device list
+ * Call <method>GetManagedObjects
+ * Returns: 0 - success or other errors
+ */
+int devices_list_update(void)
+{
+    LOGD("\n");
+
+    GSList* list;
+    GSList* tmp;
+    list = GetBluezDevicesList();
+
+    if (NULL == list)
+    {
+        return -1;
+    }
+
+    tmp = list;
+
+    devices_list_lock();
+
+    devices_list_cleanup();
+
+    while(tmp)
+    {
+        struct bt_device *BDdevice = tmp->data;
+        tmp = tmp->next;
+
+        struct btd_device * new_device = device_copy_from_bluez(BDdevice);
+
+        if (new_device)
+        {
+            gchar * ofono_path = g_strconcat("/hfp", new_device->path, NULL);
+            if (ofono_path)
+                new_device->hfpconnected =
+                                    getOfonoModemPoweredByPath(ofono_path);
+
+            //BluetoothManage.device = g_slist_prepend(BluetoothManage.device, new_device);
+            BluetoothManage.device =
+                            g_slist_append(BluetoothManage.device, new_device);
+        }
+
+    }
+
+    FreeBluezDevicesList(list);
+
+    devices_list_unlock();
+
+
+    return 0;
+}
+
+
+/*
+ * notify::name-owner callback function
+ */
+static void bluez_device_added_cb(struct bt_device *device)
+{
+    LOGD("\n");
+
+    struct btd_device * new_device;
+
+    if (NULL == device)
+    {
+        return;
+    }
+
+    new_device = device_copy_from_bluez(device);
+
+    devices_list_lock();
+
+    //BluetoothManage.device = g_slist_prepend(BluetoothManage.device, new_device);
+    BluetoothManage.device = g_slist_append(BluetoothManage.device,new_device);
+    if (NULL != g_RegisterCallback.binding_device_added)
+    {
+        g_RegisterCallback.binding_device_added(new_device);
+    }
+
+    devices_list_unlock();
+
+}
+
+/*
+ * object-removed callback function
+ */
+static void bluez_device_removed_cb (const gchar *path)
+{
+    struct btd_device *device;
+
+    LOGD("%s\n",path);
+
+    devices_list_lock();
+
+    device = devices_list_find_device_by_path(path);
+
+    if (device) {
+        BluetoothManage.device = g_slist_remove_all(BluetoothManage.device,
+                                    device);
+
+        if (NULL != g_RegisterCallback.binding_device_removed)
+        {
+            g_RegisterCallback.binding_device_removed(device);
+        }
+
+        device_free(device);
+    }
+
+    devices_list_unlock();
+
+}
+
+/*
+ * BLUEZ interface-proxy-properties-changed callback function
+ */
+static void
+bluez_device_properties_changed_cb (const gchar *pObjecPath,
+                                    const gchar *pInterface,
+                                    GVariant *properties)
+{
+
+    struct btd_device *device;
+
+#if  0
+    gchar *s;
+    g_print ("Path:%s, Interface:%s\n",pObjecPath, pInterface);
+    g_print ("type '%s'\n", g_variant_get_type_string (properties));
+    s = g_variant_print (properties, TRUE);
+    g_print (" %s\n", s);
+    g_free (s);
+#endif
+
+    LOGD("%s\n",pObjecPath);
+
+    devices_list_lock();
+
+    device = devices_list_find_device_by_path(pObjecPath);
+
+    if (0 == g_strcmp0(pInterface, DEVICE_INTERFACE)) {
+
+        device_update_from_Device1(device, properties);
+
+    } else if (0 == g_strcmp0(pInterface, MEDIA_CONTROL1_INTERFACE)) {
+
+        device_update_from_MediaControl1(device, properties);
+
+    } else if (0 == g_strcmp0(pInterface, MEDIA_PLAYER1_INTERFACE)) {
+
+        device_update_from_MediaPlayer1(device, properties);
+
+    } else if (0 == g_strcmp0(pInterface, MEDIA_TRANSPORT1_INTERFACE)) {
+
+	device_update_from_MediaTransport1(device, properties);
+
+    }
+
+    if (g_RegisterCallback.binding_device_properties_changed)
+        g_RegisterCallback.binding_device_properties_changed(device);
+
+    devices_list_unlock();
+
+}
+
+void ofono_modem_added_cb(struct ofono_modem *modem)
+{
+    struct btd_device * device;
+    gchar *path;
+
+    path = modem->path;
+
+    LOGD("%s\n",path);
+
+    if (NULL == path)
+        return;
+
+    devices_list_lock();
+    device = devices_list_find_device_by_path(path+4);
+
+    if (device)
+    {
+        gboolean old_value = device->hfpconnected;
+
+        device->hfpconnected = modem->powered;
+
+        if ((NULL != g_RegisterCallback.binding_device_properties_changed)
+            && (old_value != device->hfpconnected))
+        {
+            g_RegisterCallback.binding_device_properties_changed(device);
+        }
+    }
+    devices_list_unlock();
+
+}
+
+void ofono_modem_removed_cb(struct ofono_modem *modem)
+{
+    struct btd_device * device;
+    gchar *path = modem->path;
+
+    LOGD("%s\n",path);
+
+    if (NULL == path)
+        return;
+
+    devices_list_lock();
+    device = devices_list_find_device_by_path(path+4);
+
+    if (device)
+    {
+        gboolean old_value = device->hfpconnected;
+
+        device->hfpconnected = FALSE;
+
+        if ((NULL != g_RegisterCallback.binding_device_properties_changed)
+            && (old_value != device->hfpconnected))
+        {
+            g_RegisterCallback.binding_device_properties_changed(device);
+        }
+    }
+    devices_list_unlock();
+}
+
+void ofono_modem_properties_change_cb(struct ofono_modem *modem)
+{
+    struct btd_device * device;
+    gchar *path = modem->path;
+
+    LOGD("%s\n",path);
+
+    if (NULL == path)
+        return;
+
+    devices_list_lock();
+    device = devices_list_find_device_by_path(path+4);
+
+    if (device)
+    {
+        gboolean old_value = device->hfpconnected;
+
+        device->hfpconnected = modem->powered;
+
+        if ((NULL != g_RegisterCallback.binding_device_properties_changed)
+            && (old_value != device->hfpconnected))
+        {
+            g_RegisterCallback.binding_device_properties_changed(device);
+        }
+    }
+    devices_list_unlock();
+}
+
+gboolean agent_requset_confirm( const gchar *device_path,
+                                guint passkey,
+                                const gchar **error)
+{
+    gboolean ret = FALSE;
+
+    const gchar *myerror = ERROR_BLUEZ_REJECT;
+
+    LOGD("-%s,%d\n",device_path,passkey);
+
+    if (NULL != g_RegisterCallback.binding_request_confirmation)
+    {
+
+        devices_list_lock();
+        struct btd_device *device = devices_list_find_device_by_path(device_path);
+        gchar *device_bdaddr = NULL;
+
+        if (device)
+        {
+            device_bdaddr = g_strdup(device->bdaddr);
+        }
+        devices_list_unlock();
+
+        if (device_bdaddr)
+            ret = g_RegisterCallback.binding_request_confirmation(device_bdaddr, passkey);
+    }
+
+    if (TRUE == ret)
+    {
+        LOGD("return TRUE\n");
+        return TRUE;
+    }else{
+        *error = myerror;
+        LOGD("return FALSE\n");
+        return FALSE;
+    }
+}
+
+
+/*
+ * register callback function
+ * Returns: 0 - success or other errors
+ */
+static int bt_manager_app_init(void)
+{
+    GError *error = NULL;
+    int ret;
+
+    cli.system_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
+    if (error) {
+        LOGE("Create System GDBusconnection fail\n");
+        LOGE("Error:%s\n", error->message);
+        g_error_free(error);
+        return -1;
+    }
+
+    cli.session_conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error);
+    if (error) {
+        LOGE("Create Session GDBusconnection fail\n");
+        LOGE("Error:%s\n", error->message);
+        g_error_free(error);
+        g_object_unref(cli.system_conn);
+        return -1;
+    }
+
+    Bluez_RegisterCallback_t Bluez_API_Callback;
+    Bluez_API_Callback.device_added = bluez_device_added_cb;
+    Bluez_API_Callback.device_removed = bluez_device_removed_cb;
+    Bluez_API_Callback.device_properties_changed = bluez_device_properties_changed_cb;
+    BluezDeviceAPIRegister(&Bluez_API_Callback);
+
+    Ofono_RegisterCallback_t Ofono_API_Callback;
+    Ofono_API_Callback.modem_added = ofono_modem_added_cb;
+    Ofono_API_Callback.modem_removed = ofono_modem_removed_cb;
+    Ofono_API_Callback.modem_properties_changed = ofono_modem_properties_change_cb;
+    OfonoModemAPIRegister(&Ofono_API_Callback);
+
+
+    Agent_RegisterCallback_t AgentRegCallback;
+    AgentRegCallback.agent_RequestConfirmation = agent_requset_confirm;
+    agent_API_register(&AgentRegCallback);
+
+    ret = BluezManagerInit();
+    if (0 != ret )
+    {
+        LOGE("BluezManagerInit fail\n");
+        return -1;
+    }
+
+    ret = OfonoManagerInit();
+    if (0 != ret )
+    {
+        LOGE("OfonoManagerInit fail\n");
+
+        BluezManagerQuit();
+        return -1;
+    }
+
+    ret = agent_register("");
+    if (0 != ret )
+    {
+        LOGE("agent_register fail\n");
+
+        BluezManagerQuit();
+        OfonoManagerQuit();
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * Bluetooth Manager Thread
+ * register callback function and create a new GMainLoop structure
+ */
+static void *bt_event_loop_thread()
+{
+    int ret = 0;
+
+    cli.clientloop = g_main_loop_new(NULL, FALSE);
+
+    ret = bt_manager_app_init();
+
+    if (0 == ret){
+
+        devices_list_update();
+
+        BluetoothManage.inited = TRUE;
+        LOGD("g_main_loop_run\n");
+        g_main_loop_run(cli.clientloop);
+
+    }
+
+    g_main_loop_unref(cli.clientloop);
+
+    LOGD("Exit\n");
+}
+
+/*
+ * print log message
+ */
+void DebugTraceSendMsg(int level, gchar* message)
+{
+
+    if (logfp)
+    {
+        struct timeval  tv;
+        struct tm       tm;
+        char            s[32]       = {0};
+
+        gettimeofday(&tv, NULL);
+        localtime_r(&tv.tv_sec, &tm);
+        strftime(s, sizeof(s), "%Y-%m-%d %H:%M:%S", &tm);
+        fprintf(logfp, "[%s.%6.6d] ", s, (int)(tv.tv_usec));
+
+        switch (level)
+        {
+                case DT_LEVEL_ERROR:
+                    fprintf(logfp,"[E]");
+                    break;
+
+                case DT_LEVEL_WARNING:
+                    fprintf(logfp,"[W]");
+                    break;
+
+                case DT_LEVEL_NOTICE:
+                    fprintf(logfp,"[N]");
+                    break;
+
+                case DT_LEVEL_INFO:
+                    fprintf(logfp,"[I]");
+                    break;
+
+                case DT_LEVEL_DEBUG:
+                    fprintf(logfp,"[D]");
+                    break;
+
+                default:
+                    fprintf(logfp,"[-]");
+                    break;
+        }
+
+        fprintf(logfp,"%s\n",message);
+        fflush(logfp);
+    }
+#ifdef LOCAL_PRINT_DEBUG
+    switch (level)
+    {
+            case DT_LEVEL_ERROR:
+                g_print("[E]");
+                break;
+
+            case DT_LEVEL_WARNING:
+                g_print("[W]");
+                break;
+
+            case DT_LEVEL_NOTICE:
+                g_print("[N]");
+                break;
+
+            case DT_LEVEL_INFO:
+                g_print("[I]");
+                break;
+
+            case DT_LEVEL_DEBUG:
+                g_print("[D]");
+                break;
+
+            default:
+                g_print("[-]");
+                break;
+    }
+
+    g_print("%s",message);
+#endif
+
+    if (message) {
+        g_free(message);
+    }
+
+}
+
+
+
+/* ------ PUBLIC PLUGIN FUNCTIONS --------- */
+
+/*
+ * Set the Bluez Adapter Property "Powered" value
+ * If success return 0, else return -1;
+ */
+int adapter_set_powered(gboolean powervalue)
+{
+    LOGD("value:%d\n",powervalue);
+
+    GError *error = NULL;
+    GVariant *value;
+
+    if (FALSE == BluetoothManage_InitFlag_Get()) {
+        LOGD("BluetoothManage Not Init\n");
+        return -1;
+    }
+
+    value = g_dbus_connection_call_sync(cli.system_conn, BLUEZ_SERVICE,
+                    ADAPTER_PATH,    FREEDESKTOP_PROPERTIES,
+                    "Set",    g_variant_new("(ssv)", ADAPTER_INTERFACE,
+                        "Powered",  g_variant_new("b", powervalue)),
+                    NULL,  G_DBUS_CALL_FLAGS_NONE, DBUS_REPLY_TIMEOUT,
+                    NULL, &error);
+
+    if (NULL == value) {
+        LOGW ("Error getting object manager client: %s", error->message);
+        g_error_free(error);
+        return -1;
+    }
+
+    g_variant_unref(value);
+    return 0;
+}
+
+/*
+ * Get the Bluez Adapter Property "Powered" value
+ * If success return 0, else return -1;
+ */
+int adapter_get_powered(gboolean *powervalue) {
+    LOGD("\n");
+
+    GError *error = NULL;
+    GVariant *value = NULL;
+    GVariant *subValue = NULL;
+
+    if (FALSE == BluetoothManage_InitFlag_Get()) {
+        LOGD("BluetoothManage Not Init\n");
+        return -1;
+    }
+
+    if (NULL == powervalue) {
+        LOGD("powervalue is NULL\n");
+        return -1;
+    }
+
+    value = g_dbus_connection_call_sync(cli.system_conn, BLUEZ_SERVICE,
+                ADAPTER_PATH,   FREEDESKTOP_PROPERTIES, "Get",
+                g_variant_new("(ss)", ADAPTER_INTERFACE, "Powered"),
+                NULL, G_DBUS_CALL_FLAGS_NONE, DBUS_REPLY_TIMEOUT,
+                NULL, &error);
+
+    if (NULL == value) {
+        LOGW ("Error getting object manager client: %s\n", error->message);
+        g_error_free(error);
+        return -1;
+    }
+
+    g_variant_get(value, "(v)", &subValue);
+    g_variant_get(subValue, "b", powervalue);
+    g_variant_unref(subValue);
+
+    g_variant_unref(value);
+
+    LOGD("get ret :%d\n",*powervalue);
+    return 0;
+}
+
+/*
+ * Set the Bluez Adapter Property value
+ * Only support boolean property now.(Discoverable, Pairable, Powered)
+ * If success return 0, else return -1;
+ */
+int adapter_set_property(const gchar* property, gboolean setvalue)
+{
+    LOGD("property:%s,value:%d\n",property, setvalue);
+
+    GError *error = NULL;
+    GVariant *value;
+
+    if (FALSE == BluetoothManage_InitFlag_Get()) {
+        LOGW("BluetoothManage Not Init\n");
+        return -1;
+    }
+
+    if ((0!=g_strcmp0 (property, "Discoverable"))&&
+        (0!=g_strcmp0 (property, "Pairable"))&&
+        (0!=g_strcmp0 (property, "Powered")))
+    {
+        LOGD("Invalid value\n");
+        return -1;
+    }
+    value = g_dbus_connection_call_sync(cli.system_conn, BLUEZ_SERVICE,
+                    ADAPTER_PATH,    FREEDESKTOP_PROPERTIES,
+                    "Set",    g_variant_new("(ssv)", ADAPTER_INTERFACE,
+                        property,  g_variant_new("b", setvalue)),
+                    NULL,  G_DBUS_CALL_FLAGS_NONE, DBUS_REPLY_TIMEOUT,
+                    NULL, &error);
+
+    if (NULL == value) {
+        LOGW ("Error : %s", error->message);
+        g_error_free(error);
+        return -1;
+    }
+
+    g_variant_unref(value);
+
+    return 0;
+}
+
+
+/*
+ * Call the Bluez Adapter Method "StartDiscovery"
+ * If success return 0, else return -1;
+ */
+int adapter_start_discovery()
+{
+    LOGD("\n");
+
+    GError *error = NULL;
+    GVariant *value = NULL;
+
+    if (FALSE == BluetoothManage_InitFlag_Get()) {
+        LOGW("BluetoothManage Not Init\n");
+        return -1;
+    }
+
+    value = g_dbus_connection_call_sync(cli.system_conn, BLUEZ_SERVICE,
+                ADAPTER_PATH,  ADAPTER_INTERFACE, "StartDiscovery",
+                NULL, NULL, G_DBUS_CALL_FLAGS_NONE,
+                DBUS_REPLY_TIMEOUT, NULL, &error);
+
+    if (NULL == value) {
+        LOGW ("Error getting object manager client: %s\n", error->message);
+        g_error_free(error);
+        return -1;
+    }
+
+    g_variant_unref(value);
+    return 0;
+}
+
+/*
+ * Call the Bluez Adapter Method "StopDiscovery"
+ * If success return 0, else return -1;
+ */
+int adapter_stop_discovery()
+{
+    LOGD("\n");
+
+    GError *error = NULL;
+    GVariant *value = NULL;
+
+    if (FALSE == BluetoothManage_InitFlag_Get()) {
+        LOGW("BluetoothManage Not Init\n");
+        return -1;
+    }
+
+    value = g_dbus_connection_call_sync(cli.system_conn, BLUEZ_SERVICE,
+                ADAPTER_PATH, ADAPTER_INTERFACE, "StopDiscovery",
+                NULL, NULL, G_DBUS_CALL_FLAGS_NONE,
+                DBUS_REPLY_TIMEOUT, NULL, &error);
+
+    if (NULL == value) {
+        LOGW ("Error getting object manager client: %s\n", error->message);
+        g_error_free(error);
+        return -1;
+    }
+
+    g_variant_unref(value);
+
+    return 0;
+}
+
+/*
+ * Call the Bluez Adapter Method "RemoveDevice"
+ * If success return 0, else return -1;
+ */
+int adapter_remove_device(const gchar* bdaddr)
+{
+    LOGD("\n%s\n",bdaddr);
+
+    struct btd_device * device;
+    gchar *path;
+    GError *error = NULL;
+    GVariant *value;
+
+
+    if (FALSE == BluetoothManage_InitFlag_Get()) {
+        LOGW("BluetoothManage Not Init\n");
+        return -1;
+    }
+
+    devices_list_lock();
+    device = devices_list_find_device_by_bdaddr(bdaddr);
+
+    if (NULL == device) {
+        devices_list_unlock();
+        LOGD("not find device\n");
+        return -1;
+    }
+    path = g_strdup(device->path);
+    devices_list_unlock();
+
+    value = g_dbus_connection_call_sync(cli.system_conn, BLUEZ_SERVICE,
+                ADAPTER_PATH, ADAPTER_INTERFACE, "RemoveDevice",
+                g_variant_new("(o)", path), NULL,
+                G_DBUS_CALL_FLAGS_NONE, DBUS_REPLY_TIMEOUT, NULL, &error);
+
+    g_free(path);
+
+    if (NULL == value) {
+        LOGW ("Error getting object manager client: %s", error->message);
+        g_error_free(error);
+        return -1;
+    }
+
+    g_variant_unref(value);
+    return 0;
+
+}
+
+
+/*
+ * Get the copy of device list.
+ */
+GSList* adapter_get_devices_list()
+{
+    GSList* tmp;
+    devices_list_lock();
+    tmp = g_slist_copy_deep (BluetoothManage.device,
+                                        (GCopyFunc)device_copy, NULL);
+    devices_list_unlock();
+    return tmp;
+}
+
+/*
+ * free device list.
+ */
+void adapter_devices_list_free(GSList* list)
+{
+    if (NULL != list)
+        g_slist_free_full(list,(GDestroyNotify)device_free);
+
+}
+
+/*
+ * device_pair callback
+ */
+void device_pair_done_cb(GDBusConnection *source_object,
+                        GAsyncResult *res,
+                        gpointer user_data)
+{
+    LOGD("\n");
+    g_dbus_connection_call_finish (source_object, res, NULL);
+
+}
+
+/*
+ * send pairing command
+ * If success return 0, else return -1;
+ */
+int device_pair(const gchar * bdaddr)
+{
+    LOGD("\n%s\n",bdaddr);
+
+    struct btd_device * device;
+    gchar *path;
+    GError *error = NULL;
+    GVariant *value;
+
+
+    if (FALSE == BluetoothManage_InitFlag_Get()) {
+        LOGD("BluetoothManage Not Init\n");
+        return -1;
+    }
+
+    devices_list_lock();
+    device = devices_list_find_device_by_bdaddr(bdaddr);
+
+    if (NULL == device) {
+        devices_list_unlock();
+        LOGD("not find device\n");
+        return -1;
+    }
+    path = g_strdup(device->path);
+    devices_list_unlock();
+
+#if 0
+    value = g_dbus_connection_call_sync(cli.system_conn, BLUEZ_SERVICE,
+                path, DEVICE_INTERFACE, "Pair",
+                NULL, NULL, G_DBUS_CALL_FLAGS_NONE,
+                DBUS_REPLY_TIMEOUT, NULL, &error);
+
+    g_free(path);
+
+    if (NULL == value) {
+        LOGW ("Error getting object manager client: %s", error->message);
+        g_error_free(error);
+        return -1;
+    }
+
+    g_variant_unref(value);
+#else
+
+    g_dbus_connection_call(cli.system_conn, BLUEZ_SERVICE,
+                path, DEVICE_INTERFACE, "Pair",
+                NULL, NULL, G_DBUS_CALL_FLAGS_NONE,
+                DBUS_REPLY_TIMEOUT, NULL,
+                (GAsyncReadyCallback)device_pair_done_cb, NULL);
+
+    g_free(path);
+#endif
+    return 0;
+
+}
+
+/*
+ * send cancel pairing command
+ * If success return 0, else return -1;
+ */
+int device_cancelPairing(const gchar * bdaddr)
+{
+    LOGD("\n%s\n",bdaddr);
+
+    struct btd_device * device;
+    gchar *path;
+    GError *error = NULL;
+    GVariant *value;
+
+
+    if (FALSE == BluetoothManage_InitFlag_Get()) {
+        LOGD("BluetoothManage Not Init\n");
+        return -1;
+    }
+
+    devices_list_lock();
+    device = devices_list_find_device_by_bdaddr(bdaddr);
+
+    if (NULL == device) {
+        devices_list_unlock();
+        LOGD("not find device\n");
+        return -1;
+    }
+    path = g_strdup(device->path);
+    devices_list_unlock();
+
+    value = g_dbus_connection_call_sync(cli.system_conn, BLUEZ_SERVICE,
+                path, DEVICE_INTERFACE, "CancelPairing",
+                NULL, NULL, G_DBUS_CALL_FLAGS_NONE,
+                DBUS_REPLY_TIMEOUT, NULL, &error);
+
+    g_free(path);
+
+    if (NULL == value) {
+        LOGW ("Error getting object manager client: %s", error->message);
+        g_error_free(error);
+        return -1;
+    }
+
+    g_variant_unref(value);
+    return 0;
+
+}
+/*
+ * send connect command
+ * If success return 0, else return -1;
+ */
+int device_connect(const gchar * bdaddr, const gchar * uuid)
+{
+    LOGD("\n%s\n",bdaddr);
+
+    struct btd_device * device;
+    gchar *path;
+    GError *error = NULL;
+    GVariant *value;
+
+
+    if (FALSE == BluetoothManage_InitFlag_Get()) {
+        LOGD("BluetoothManage Not Init\n");
+        return -1;
+    }
+
+    devices_list_lock();
+    device = devices_list_find_device_by_bdaddr(bdaddr);
+
+    if (NULL == device) {
+        devices_list_unlock();
+        LOGD("not find device\n");
+        return -1;
+    }
+    path = g_strdup(device->path);
+    devices_list_unlock();
+
+    value = g_dbus_connection_call_sync(cli.system_conn, BLUEZ_SERVICE,
+                path, DEVICE_INTERFACE, uuid ? "ConnectProfile" : "Connect",
+                uuid ? g_variant_new("(s)", uuid) : NULL,
+                NULL, G_DBUS_CALL_FLAGS_NONE,
+                DBUS_REPLY_TIMEOUT, NULL, &error);
+
+    g_free(path);
+
+    if (NULL == value) {
+        LOGW ("Error getting object manager client: %s", error->message);
+        g_error_free(error);
+        return -1;
+    }
+
+    g_variant_unref(value);
+    return 0;
+
+}
+
+/*
+ * send disconnect command
+ * If success return 0, else return -1;
+ */
+int device_disconnect(const gchar* bdaddr, const gchar *uuid)
+{
+    LOGD("\n%s\n",bdaddr);
+
+    struct btd_device * device;
+    gchar *path;
+    GError *error = NULL;
+    GVariant *value;
+
+
+    if (FALSE == BluetoothManage_InitFlag_Get()) {
+        LOGD("BluetoothManage Not Init\n");
+        return -1;
+    }
+
+    devices_list_lock();
+    device = devices_list_find_device_by_bdaddr(bdaddr);
+
+    if (NULL == device) {
+        devices_list_unlock();
+        LOGD("not find device\n");
+        return -1;
+    }
+    path = g_strdup(device->path);
+    devices_list_unlock();
+
+    value = g_dbus_connection_call_sync(cli.system_conn, BLUEZ_SERVICE,
+                path, DEVICE_INTERFACE, uuid ? "DisconnectProfile" : "Disconnect",
+                uuid ? g_variant_new("(s)", uuid) : NULL,
+                NULL, G_DBUS_CALL_FLAGS_NONE,
+                DBUS_REPLY_TIMEOUT, NULL, &error);
+
+    g_free(path);
+
+    if (NULL == value) {
+        LOGW ("Error getting object manager client: %s", error->message);
+        g_error_free(error);
+        return -1;
+    }
+
+    g_variant_unref(value);
+    return 0;
+}
+
+/*
+ * set remote device property
+ * If success return 0, else return -1;
+ */
+int device_set_property(const char * bdaddr, const char *property_name,
+                        const char *property_value)
+{
+    LOGD("\n%s-%s-%s\n",bdaddr,property_name,property_value);
+
+    GError *error = NULL;
+    GVariant *ret;
+    struct btd_device * device;
+    gchar *path;
+    gboolean value;
+
+    if (FALSE == BluetoothManage_InitFlag_Get()) {
+        LOGD("BluetoothManage Not Init\n");
+        return -1;
+    }
+
+    //Only support set "Trusted"
+    if (strcmp(property_name, "Trusted")) {
+        LOGD("Not support property name\n");
+        return -1;
+    }
+
+    if (atoi(property_value) == 1 || !strcasecmp(property_value, "true")) {
+        value = TRUE;
+    } else if (atoi(property_value) == 0
+            || !strcasecmp(property_value, "false")) {
+        value = FALSE;
+    } else {
+        LOGD("Not support property value\n");
+        return -1;
+    }
+
+    devices_list_lock();
+    device = devices_list_find_device_by_bdaddr(bdaddr);
+
+    if (NULL == device) {
+        devices_list_unlock();
+        LOGD("not find device\n");
+        return -1;
+    }
+    path = g_strdup(device->path);
+    devices_list_unlock();
+
+    ret = g_dbus_connection_call_sync(cli.system_conn, BLUEZ_SERVICE,
+                path,   FREEDESKTOP_PROPERTIES, "Set",
+                g_variant_new("(ssv)", DEVICE_INTERFACE, property_name,
+                    g_variant_new("b", value)), NULL, G_DBUS_CALL_FLAGS_NONE,
+                DBUS_REPLY_TIMEOUT, NULL, &error);
+
+    g_free(path);
+
+    if (NULL == ret) {
+        LOGW ("Error getting object manager client: %s", error->message);
+        g_error_free(error);
+        return -1;
+    }
+
+    g_variant_unref(ret);
+    return 0;
+}
+
+/*
+ * call remote device avrcp method
+ * Only support controls (Play, Pause, Stop, Previous, Next)
+ * If success return 0, else return -1;
+ */
+int device_call_avrcp_method(const gchar* bdaddr, const gchar* method)
+{
+    LOGD("device:%s,value:%d\n", bdaddr, method);
+
+    struct btd_device * device;
+    GError *error = NULL;
+    GVariant *value;
+    gchar *path;
+
+    if (FALSE == BluetoothManage_InitFlag_Get()) {
+        LOGW("BluetoothManage Not Init\n");
+        return -1;
+    }
+
+    if ((0!=g_strcmp0 (method, "Play"))&&
+        (0!=g_strcmp0 (method, "Pause"))&&
+        (0!=g_strcmp0 (method, "Stop"))&&
+        (0!=g_strcmp0 (method, "Previous"))&&
+        (0!=g_strcmp0 (method, "Next")))
+    {
+        LOGD("Invalid method\n");
+        return -1;
+    }
+
+    devices_list_lock();
+    device = devices_list_find_device_by_bdaddr(bdaddr);
+
+    if (NULL == device) {
+        devices_list_unlock();
+        LOGD("not find device\n");
+        return -1;
+    }
+    path = g_strdup(device->path);
+    devices_list_unlock();
+
+    value = g_dbus_connection_call_sync(cli.system_conn, BLUEZ_SERVICE,
+                    path,    MEDIA_CONTROL1_INTERFACE,
+                    method,   NULL,  NULL,
+                    G_DBUS_CALL_FLAGS_NONE, DBUS_REPLY_TIMEOUT,
+                    NULL, &error);
+
+    g_free(path);
+
+    if (NULL == value) {
+        LOGW ("Error : %s", error->message);
+        g_error_free(error);
+        return -1;
+    }
+
+    g_variant_unref(value);
+
+    return 0;
+}
+
+
+/*
+ * Stops the GMainLoop
+ */
+int BluetoothManagerQuit()
+{
+    LOGD("\n");
+
+    if (FALSE == BluetoothManage.inited )
+    {
+        LOGD("BluetoothManage Not init\n");
+        return -1;
+    }
+
+    if(cli.clientloop){
+        g_main_loop_quit(cli.clientloop);
+    }
+
+    OfonoManagerQuit();
+    BluezManagerQuit();
+    stop_agent();
+
+    devices_list_lock();
+    devices_list_cleanup();
+    devices_list_unlock();
+
+
+    g_mutex_clear (&(BluetoothManage.m));
+
+    g_object_unref(cli.system_conn);
+    g_object_unref(cli.session_conn);
+
+    if (logfp)
+        fclose(logfp);
+    logfp = NULL;
+
+    BluetoothManage.inited = FALSE;
+
+    return 0;
+}
+
+/*
+ * Create Bluetooth Manager Thread
+ * Note: bluetooth-api shall do BluetoothManageInit() first before call other APIs.
+ *          bluetooth-api shall register callback function
+ * Returns: 0 - success or other errors
+ */
+int BluetoothManagerInit() {
+    pthread_t thread_id;
+
+    LOGD("\n");
+
+    if (TRUE == BluetoothManage.inited )
+    {
+        LOGW("BluetoothManage already init\n");
+        return -1;
+    }
+
+    logfp = fopen("/var/log/BluetoothManager.log", "a+");
+
+    if (NULL == logfp)
+    {
+        openlog("BluetoothManager", LOG_CONS | LOG_PID, LOG_USER);
+        syslog(LOG_WARNING, "BluetoothManager create log file fail\n");
+        closelog();
+    }
+
+    g_mutex_init(&(BluetoothManage.m));
+
+    pthread_create(&thread_id, NULL, bt_event_loop_thread, NULL);
+    //pthread_setname_np(thread_id, "BT_Manager");
+    sleep(1);
+
+    return 0;
+}
+
+/*
+ * Register Bluetooth Manager Callback function
+ */
+void BindingAPIRegister(const Binding_RegisterCallback_t* pstRegisterCallback)
+{
+    if (NULL != pstRegisterCallback)
+    {
+        if (NULL != pstRegisterCallback->binding_device_added)
+        {
+            g_RegisterCallback.binding_device_added =
+                pstRegisterCallback->binding_device_added;
+        }
+
+        if (NULL != pstRegisterCallback->binding_device_removed)
+        {
+            g_RegisterCallback.binding_device_removed =
+                pstRegisterCallback->binding_device_removed;
+        }
+
+        if (NULL != pstRegisterCallback->binding_device_properties_changed)
+        {
+            g_RegisterCallback.binding_device_properties_changed =
+                pstRegisterCallback->binding_device_properties_changed;
+        }
+
+        if (NULL != pstRegisterCallback->binding_request_confirmation)
+        {
+            g_RegisterCallback.binding_request_confirmation =
+                pstRegisterCallback->binding_request_confirmation;
+        }
+    }
+}
+
+GError* setHMIStatus(enum btStates state) {
+
+    gchar *iconString = NULL;
+    GDBusConnection *connection;
+    GVariant *params = NULL;
+    GVariant *message = NULL;
+    GError *error = NULL;
+
+    if (state==INACTIVE) iconString = "qrc:/images/Status/HMI_Status_Bluetooth_Inactive-01.png";
+    else if (state==ACTIVE) iconString = "qrc:/images/Status/HMI_Status_Bluetooth_On-01.png";
+    else iconString = "qrc:/images/Status/HMI_Status_Bluetooth_Inactive-01.png";
+
+    connection = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error);
+
+    params = g_variant_new("(is)", HOMESCREEN_BT_ICON_POSITION, iconString);
+
+    message = g_dbus_connection_call_sync(connection, HOMESCREEN_SERVICE,
+    HOMESCREEN_ICON_PATH, HOMESCREEN_ICON_INTERFACE, "setStatusIcon", params,
+            NULL, G_DBUS_CALL_FLAGS_NONE,
+            DBUS_REPLY_TIMEOUT, NULL, &error);
+
+    if (error) {
+        printf("error: %s\n", error->message);
+
+        return error;
+    } else {
+        return NULL;
+    }
+
+}
+
+