diff options
Diffstat (limited to 'bluetooth-manager.c')
| -rw-r--r-- | bluetooth-manager.c | 1853 |
1 files changed, 1314 insertions, 539 deletions
diff --git a/bluetooth-manager.c b/bluetooth-manager.c index 893760d..91dfa1c 100644 --- a/bluetooth-manager.c +++ b/bluetooth-manager.c @@ -18,729 +18,1505 @@ #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-api.h" #include "bluetooth-manager.h" +#include "bluez-client.h" +#include "ofono-client.h" +#include "bluetooth-agent.h" -Client cli = { 0 }; - -stBluetoothManage BluetoothManage = { 0 }; +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_strcmp0 (device->path, pPath); +} /* - register the agent, and register signal watch + * search device by path + * Returns the first found btd_device or NULL if it is not found */ -void bt_manage_dbus_init(void) { - D_PRINTF("\n"); +struct btd_device *devices_list_find_device_by_path(const gchar* pPath) +{ + GSList * temp; - //InitDBusCommunication(); + temp = g_slist_find_custom (BluetoothManage.device, pPath, + (GCompareFunc)device_path_cmp); + + if (temp) { + return temp->data; + } + + return NULL; } -/* ------ PUBLIC PLUGIN FUNCTIONS --------- */ + + +static int device_bdaddr_cmp(struct btd_device * device, const gchar* pBDaddr ) +{ + return g_strcmp0 (device->bdaddr, pBDaddr); +} /* - * Init the Bluetooth Manager - * Note: bluetooth-api shall do BluetoothManageInit() first before call other APIs. + * search device by path + * Returns the first found btd_device or NULL if it is not found */ -int BluetoothManageInit() { - D_PRINTF("\n"); +struct btd_device *devices_list_find_device_by_bdaddr(const gchar* pBDaddr) +{ + GSList * temp; - BluetoothManage.device = NULL; - g_mutex_init(&(BluetoothManage.m)); + temp = g_slist_find_custom (BluetoothManage.device, pBDaddr, + (GCompareFunc)device_bdaddr_cmp); - bt_manage_dbus_init(); + if (temp) { + return temp->data; + } + + return NULL; - return 0; } + /* - * Set the Bluez Adapter Property "Powered" value - * If success return 0, else return -1; + * make a copy of each element + * And, to entirely free the new btd_device, you could do: device_free */ -int adapter_set_powered(gboolean powervalue) { - D_PRINTF("value:%d\n",powervalue); - GDBusConnection *connection; - GError *error = NULL; +struct btd_device *device_copy(struct btd_device* device) +{ + struct btd_device * temp; - GVariant *value; - gboolean result; + if (NULL == device) { + return NULL; + } - connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error); - if (NULL == connection) { - D_PRINTF("GDBusconnection is NULL\n"); - return -1; - } + 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; + + return temp; +} - value = g_dbus_connection_call_sync(connection, 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); +/* + * Frees all of the memory + */ +void device_free(struct btd_device* device) +{ - if (NULL == value) { - D_PRINTF ("Error getting object manager client: %s", error->message); - g_error_free(error); - return -1; - } + 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; + } - g_variant_unref(value); - return 0; + 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); } /* - * Get the Bluez Adapter Property "Powered" value - * If success return 0, else return -1; + * remove all the devices */ -int adapter_get_powered(gboolean *powervalue) { - D_PRINTF("\n"); - GDBusConnection *connection; - GError *error = NULL; - GVariant *value = NULL; - GVariant *subValue = NULL; +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); + } +} - connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error); - if (NULL == connection) { - D_PRINTF("GDBusconnection is NULL\n"); - return -1; - } - value = g_dbus_connection_call_sync(connection, 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); +/* + * 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"); +} - if (NULL == value) { - D_PRINTF ("Error getting object manager client: %s\n", error->message); - g_error_free(error); - return -1; - } +/* + * 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; - g_variant_get(value, "(v)", &subValue); - g_variant_get(subValue, "b", powervalue); - g_variant_unref(value); + 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); + } + } - D_PRINTF("get ret :%d\n",*powervalue); - return 0; + return 0; } + + /* - * Call the Bluez Adapter Method "StartDiscovery" - * If success return 0, else return -1; + * update device from Interfcace org.bluez.Device1 properties */ -int adapter_start_discovery() { - D_PRINTF("\n"); - GDBusConnection *connection = NULL; - GError *error = NULL; - GVariant *value = NULL; - GVariant *subValue = NULL; +static int device_update_from_Device1(struct btd_device *device, + GVariant *value) +{ + if ((NULL==device) || (NULL==value)) + { + return -1; + } - connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error); - if (NULL == connection) { - D_PRINTF("GDBusconnection is NULL\n"); - return -1; - } - value = g_dbus_connection_call_sync(connection, BLUEZ_SERVICE, ADAPTER_PATH, - ADAPTER_INTERFACE, "StartDiscovery", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, - DBUS_REPLY_TIMEOUT, NULL, &error); + 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; + } + } - if (NULL == value) { - D_PRINTF ("Error getting object manager client: %s\n", error->message); - g_error_free(error); - return -1; - } + return 0; - g_variant_unref(value); - 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 /* - * Call the Bluez Adapter Method "StopDiscovery" - * If success return 0, else return -1; + * make a copy of each element */ -int adapter_stop_discovery() { - D_PRINTF("\n"); - GDBusConnection *connection = NULL; - GError *error = NULL; - GVariant *value = NULL; - GVariant *subValue = NULL; +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; + + 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(); - connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error); - if (NULL == connection) { - D_PRINTF("GDBusconnection is NULL\n"); - return -1; - } - value = g_dbus_connection_call_sync(connection, BLUEZ_SERVICE, ADAPTER_PATH, - ADAPTER_INTERFACE, "StopDiscovery", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, - DBUS_REPLY_TIMEOUT, NULL, &error); + devices_list_cleanup(); - if (NULL == value) { - D_PRINTF ("Error getting object manager client: %s\n", error->message); - g_error_free(error); - return -1; - } + while(tmp) + { + struct bt_device *BDdevice = tmp->data; + tmp = tmp->next; - g_variant_unref(value); + struct btd_device * new_device = device_copy_from_bluez(BDdevice); - return 0; + 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; } + /* - * Call the Bluez Adapter Method "RemoveDevice" - * If success return 0, else return -1; + * notify::name-owner callback function */ -int adapter_remove_device(struct btd_device * addr) { - D_PRINTF("\n%s\t%s\t%s\n",addr->bdaddr,addr->name,addr->path); +static void bluez_device_added_cb(struct bt_device *device) +{ + LOGD("\n"); + + struct btd_device * new_device; - GDBusConnection *connection; - GError *error = NULL; - GVariant *value; + if (NULL == device) + { + return; + } - connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error); - if (NULL == connection) { - D_PRINTF("GDBusconnection is NULL\n"); - return -1; - } + new_device = device_copy_from_bluez(device); - value = g_dbus_connection_call_sync(connection, BLUEZ_SERVICE, ADAPTER_PATH, - ADAPTER_INTERFACE, "RemoveDevice", g_variant_new("(o)", addr->path), NULL, - G_DBUS_CALL_FLAGS_NONE, DBUS_REPLY_TIMEOUT, NULL, &error); + devices_list_lock(); - if (NULL == value) { - D_PRINTF ("Error getting object manager client: %s", error->message); - g_error_free(error); - return -1; - } + //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); + } - g_variant_unref(value); - return 0; + devices_list_unlock(); } /* - * Get the store device list. + * object-removed callback function */ -//FIXME: gdevices should be added the lock/unlock -GSList* adapter_get_devices_list() { - return BluetoothManage.device; +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(); + } -void lock_devices_list(void) { - g_mutex_lock(&(BluetoothManage.m)); +/* + * 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); + + } + + if (g_RegisterCallback.binding_device_propertyies_changed) + g_RegisterCallback.binding_device_propertyies_changed(device); + + devices_list_unlock(); + } -void unlock_devices_list(void) { - g_mutex_unlock(&(BluetoothManage.m)); +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_propertyies_changed) + && (old_value != device->hfpconnected)) + { + g_RegisterCallback.binding_device_propertyies_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_propertyies_changed) + && (old_value != device->hfpconnected)) + { + g_RegisterCallback.binding_device_propertyies_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_propertyies_changed) + && (old_value != device->hfpconnected)) + { + g_RegisterCallback.binding_device_propertyies_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; + } } + /* - * Update the device list - * Call <method>GetManagedObjects - * reply type is "Dict of {Object Path, Dict of {String, Dict of {String, Variant}}}" + * register callback function + * Returns: 0 - success or other errors */ -#if 0 -// Test Function -/* recursively iterate a container */ -void iterate_container_recursive (GVariant *container) +static int bt_manager_app_init(void) { - GVariantIter iter; - GVariant *child; + GError *error = NULL; + int ret; - g_variant_iter_init (&iter, container); - while ((child = g_variant_iter_next_value (&iter))) - { - g_print ("type '%s'\n", g_variant_get_type_string (child)); + 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_propertyies_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_propertyies_changed = ofono_modem_properties_change_cb; + OfonoModemAPIRegister(&Ofono_API_Callback); - if (g_variant_is_container (child)) - iterate_container_recursive (child); - g_variant_unref (child); - } + 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; } -#endif -int adapter_update_devices() { - D_PRINTF("\n"); - GDBusConnection *connection = NULL; - GError *error = NULL; - GVariant *value = NULL; - GSList *newDeviceList = NULL; - - connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error); - if (NULL == connection) { - D_PRINTF("GDBusconnection is NULL\n"); - return -1; - } - value = g_dbus_connection_call_sync(connection, BLUEZ_SERVICE, "/", - "org.freedesktop.DBus.ObjectManager", "GetManagedObjects", NULL, - NULL, G_DBUS_CALL_FLAGS_NONE, DBUS_REPLY_TIMEOUT, NULL, &error); - - if (NULL == value) { - D_PRINTF ("Error getting object manager client: %s\n", error->message); - g_error_free(error); - return -1; - } - - GVariant *subValue = NULL; - GVariant *subValue_1 = NULL; - GVariantIter *subValueIter; - - g_variant_get(value, "(*)", &subValue); - - g_variant_get(subValue, "a*", &subValueIter); - while (g_variant_iter_loop(subValueIter, "*", &subValue_1)) { +/* + * Bluetooth Manager Thread + * register callback function and create a new GMainLoop structure + */ +static void *bt_event_loop_thread() +{ + int ret = 0; -#if 0 - iterate_container_recursive(subValue_1); -#else + 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); -//FIXME:Bad solution to get the BT address and name - GVariantIter dbus_object_iter; - GVariant *dbusObjecValue; - GVariant *dbusObjecSubValue; - gchar *dbusObjecPath; - struct btd_device *device; - - g_variant_iter_init(&dbus_object_iter, subValue_1); - - //DBus Object - dbusObjecValue = g_variant_iter_next_value(&dbus_object_iter); - - g_variant_get(dbusObjecValue, "o", &dbusObjecPath); - - //ObjectPath is /org/bluez/hci0/dev_xx_xx_xx_xx_xx_xx - if ((37 != strlen(dbusObjecPath)) - || (NULL - == g_strrstr_len(dbusObjecPath, 19, - "/org/bluez/hci0/dev"))) { - g_variant_unref(dbusObjecValue); - continue; - } - device = g_try_malloc0(sizeof(struct btd_device)); - device->path = g_strdup(dbusObjecPath); - g_variant_unref(dbusObjecValue); - D_PRINTF("Found new device%s\n",device->path ); - - //DBus Interfaces and Method/Properties under Interface - dbusObjecSubValue = g_variant_iter_next_value(&dbus_object_iter); - - GVariantIter *interfaces_iter; - GVariant *interfaces_subValue; - g_variant_get(dbusObjecSubValue, "a*", &interfaces_iter); - - while (g_variant_iter_loop(interfaces_iter, "*", &interfaces_subValue)) { - // D_PRINTF("\t%s\n",g_variant_get_type_string(interfaces_subValue)); - - GVariantIter MethodsSignalProperties_iter; - GVariant *MethodsSignalProperties_name; - GVariant *MethodsSignalProperties_value; - gchar *properties_name; - - g_variant_iter_init(&MethodsSignalProperties_iter, - interfaces_subValue); - - //DBus Interfaces - MethodsSignalProperties_name = g_variant_iter_next_value( - &MethodsSignalProperties_iter); - - g_variant_get(MethodsSignalProperties_name, "s", &properties_name); - //D_PRINTF("\t%s\n",properties_name); - g_variant_unref(MethodsSignalProperties_name); - - if (NULL - == g_strrstr_len(properties_name, 20, - "org.bluez.Device1")) { - continue; - } - - D_PRINTF("\t%s\n",properties_name); - - //DBus XXX - MethodsSignalProperties_value = g_variant_iter_next_value( - &MethodsSignalProperties_iter); - - GVariantIter *subValue_iter; - GVariant *subValueVariant; - g_variant_get(MethodsSignalProperties_value, "a*", &subValue_iter); - - while (g_variant_iter_loop(subValue_iter, "*", &subValueVariant)) { - GVariantIter sub_subValue_iter; - GVariant *sub_subValue_name; - GVariant *sub_subValue_value; - gchar *key_1 = NULL; - gchar *key_2 = NULL; - - g_variant_iter_init(&sub_subValue_iter, subValueVariant); - - //DBus Interfaces - sub_subValue_name = g_variant_iter_next_value( - &sub_subValue_iter); - - g_variant_get(sub_subValue_name, "s", &key_1); - D_PRINTF("\t\t%s\n",key_1); - - //DBus XXX - sub_subValue_value = g_variant_iter_next_value( - &sub_subValue_iter); - - GVariant *dbus_value; - dbus_value = g_variant_get_variant(sub_subValue_value); - - if (g_variant_is_of_type(dbus_value, G_VARIANT_TYPE_STRING)) { - g_variant_get(dbus_value, "s", &key_2); - //D_PRINTF("\t\t\t%s\ts%s\n",key_1,key_2); - - if (g_strrstr_len(key_1, 10, "Address")) { - device->bdaddr = g_strdup(key_2); - } else if (g_strrstr_len(key_1, 10, "Name")) { - device->name = g_strdup(key_2); - } - g_free(key_2); - - } else if (g_variant_is_of_type(dbus_value, - G_VARIANT_TYPE_BOOLEAN)) { - gboolean properties_value; - g_variant_get(dbus_value, "b", &properties_value); - - if (g_strrstr_len(key_1, 10, "Paired")) { - device->paired = properties_value; - } else if (g_strrstr_len(key_1, 10, "Blocked")) { - device->blocked = properties_value; - } else if (g_strrstr_len(key_1, 10, "Connected")) { - device->connected = properties_value; - } else if (g_strrstr_len(key_1, 10, "Trusted")) { - device->trusted = properties_value; - } - - } - g_variant_unref(sub_subValue_name); - g_variant_unref(sub_subValue_value); + } - } - g_variant_iter_free(subValue_iter); + g_main_loop_unref(cli.clientloop); - g_variant_unref(MethodsSignalProperties_value); + LOGD("Exit\n"); +} - } - g_variant_iter_free(interfaces_iter); +/* + * print log message + */ +void DebugTraceSendMsg(int level, gchar* message) +{ - g_variant_unref(dbusObjecSubValue); + 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 - newDeviceList = g_slist_append(newDeviceList, device); + if (message) { + g_free(message); + } - } +} - g_variant_iter_free(subValueIter); - g_variant_unref(value); - //clean first - GSList * temp = BluetoothManage.device; - while (temp) { - struct btd_device *BDdevice = temp->data; - temp = temp->next; +/* ------ PUBLIC PLUGIN FUNCTIONS --------- */ - BluetoothManage.device = g_slist_remove_all(BluetoothManage.device, - BDdevice); - //D_PRINTF("\n%s\n%s\n",BDdevice->bdaddr,BDdevice->name); - if (BDdevice->bdaddr) { - g_free(BDdevice->bdaddr); - } - if (BDdevice->name) { - g_free(BDdevice->name); - } - if (BDdevice->path) { - g_free(BDdevice->path); - } - g_free(BDdevice); +/* + * 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; - BluetoothManage.device = newDeviceList; + 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; } /* - * send pairing command + * Get the Bluez Adapter Property "Powered" value * If success return 0, else return -1; */ -int device_pair(struct btd_device * addr) { - D_PRINTF("\n%s\n%s\t%s\n",addr->bdaddr,addr->name,addr->path); +int adapter_get_powered(gboolean *powervalue) { + LOGD("\n"); - GDBusConnection *connection; - GError *error = NULL; - GVariant *value; + GError *error = NULL; + GVariant *value = NULL; + GVariant *subValue = NULL; - connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error); - if (NULL == connection) { - D_PRINTF("GDBusconnection is NULL\n"); - return -1; - } + if (FALSE == BluetoothManage_InitFlag_Get()) { + LOGD("BluetoothManage Not Init\n"); + return -1; + } - value = g_dbus_connection_call_sync(connection, BLUEZ_SERVICE, addr->path, - "org.bluez.Device1", "Pair", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, - DBUS_REPLY_TIMEOUT, NULL, &error); + if (NULL == powervalue) { + LOGD("powervalue is NULL\n"); + return -1; + } - if (NULL == value) { - D_PRINTF ("Error getting object manager client: %s", error->message); - g_error_free(error); - 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); - g_variant_unref(value); - return 0; + 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; } /* - * send cancel pairing command + * Set the Bluez Adapter Property value + * Only support boolean property now.(Discoverable, Pairable, Powered) * If success return 0, else return -1; */ -int device_cancelPairing(struct btd_device * addr) { - D_PRINTF("\n%s\n%s\t%s\n",addr->bdaddr,addr->name,addr->path); +int adapter_set_property(const gchar* property, gboolean setvalue) +{ + LOGD("property:%s,value:%d\n",property, setvalue); + + GError *error = NULL; + GVariant *value; - GDBusConnection *connection; - GError *error = NULL; - GVariant *value; + if (FALSE == BluetoothManage_InitFlag_Get()) { + LOGW("BluetoothManage Not Init\n"); + return -1; + } - connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error); - if (NULL == connection) { - D_PRINTF("GDBusconnection is NULL\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; + } - value = g_dbus_connection_call_sync(connection, BLUEZ_SERVICE, addr->path, - "org.bluez.Device1", "CancelPairing", NULL, NULL, - G_DBUS_CALL_FLAGS_NONE, DBUS_REPLY_TIMEOUT, NULL, &error); + g_variant_unref(value); - if (NULL == value) { - D_PRINTF ("Error getting object manager client: %s", error->message); - g_error_free(error); - return -1; - } + return 0; +} - 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; } + /* - * send connect command + * Call the Bluez Adapter Method "StopDiscovery" * If success return 0, else return -1; */ -int device_connect(struct btd_device * addr) { - D_PRINTF("\n%s\n%s\t%s\n",addr->bdaddr,addr->name,addr->path); +int adapter_stop_discovery() +{ + LOGD("\n"); - GDBusConnection *connection; - GError *error = NULL; - GVariant *value; + GError *error = NULL; + GVariant *value = NULL; - connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error); - if (NULL == connection) { - D_PRINTF("GDBusconnection is NULL\n"); - return -1; - } + if (FALSE == BluetoothManage_InitFlag_Get()) { + LOGW("BluetoothManage Not Init\n"); + return -1; + } - value = g_dbus_connection_call_sync(connection, BLUEZ_SERVICE, addr->path, - "org.bluez.Device1", "Connect", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, - DBUS_REPLY_TIMEOUT, NULL, &error); + 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) { - D_PRINTF ("Error getting object manager client: %s", error->message); - g_error_free(error); - return -1; - } + 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; + g_variant_unref(value); + return 0; } /* - * send disconnect command + * Call the Bluez Adapter Method "RemoveDevice" * If success return 0, else return -1; */ -int device_disconnect(struct btd_device * addr) { - D_PRINTF("\n%s\n%s\t%s\n",addr->bdaddr,addr->name,addr->path); +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); - GDBusConnection *connection; - GError *error = NULL; - GVariant *value; + if (NULL == device) { + devices_list_unlock(); + LOGD("not find device\n"); + return -1; + } + path = g_strdup(device->path); + devices_list_unlock(); - connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error); - if (NULL == connection) { - D_PRINTF("GDBusconnection is NULL\n"); - return -1; - } + 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); - value = g_dbus_connection_call_sync(connection, BLUEZ_SERVICE, addr->path, - "org.bluez.Device1", "Disconnect", NULL, NULL, - G_DBUS_CALL_FLAGS_NONE, DBUS_REPLY_TIMEOUT, NULL, &error); + g_free(path); - if (NULL == value) { - D_PRINTF ("Error getting object manager client: %s", error->message); - g_error_free(error); - return -1; - } + if (NULL == value) { + LOGW ("Error getting object manager client: %s", error->message); + g_error_free(error); + return -1; + } - g_variant_unref(value); - return 0; + g_variant_unref(value); + return 0; } + /* - * set remote device property + * 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_set_property(struct btd_device * addr, const char *property_name, - const char *property_value) { - D_PRINTF("\n%s\n%s\t%s\n",addr->bdaddr,addr->name,addr->path); +int device_cancelPairing(const gchar * bdaddr) +{ + LOGD("\n%s\n",bdaddr); + + struct btd_device * device; + gchar *path; + GError *error = NULL; + GVariant *value; - GDBusConnection *connection; - GError *error = NULL; - GVariant *ret; - connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error); - if (NULL == connection) { - D_PRINTF("GDBusconnection is NULL\n"); - return -1; - } + if (FALSE == BluetoothManage_InitFlag_Get()) { + LOGD("BluetoothManage Not Init\n"); + return -1; + } - //Only support set "Trusted" - if (strcmp(property_name, "Trusted")) { - D_PRINTF("Not support property name\n"); - return -1; - } + devices_list_lock(); + device = devices_list_find_device_by_bdaddr(bdaddr); - gboolean value; - if (atoi(property_value) == 1 || !strcasecmp(property_value, "true")) { - value = TRUE; - } else if (atoi(property_value) == 0 - || !strcasecmp(property_value, "false")) { - value = FALSE; - } else { - D_PRINTF("Not support property value\n"); - return -1; - } + 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(connection, BLUEZ_SERVICE, addr->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); + 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; + } - if (NULL == ret) { - D_PRINTF ("Error getting object manager client: %s", error->message); - g_error_free(error); - return -1; - } + g_variant_unref(value); + return 0; - g_variant_unref(ret); - return 0; } +/* + * send connect command + * If success return 0, else return -1; + */ +int device_connect(const gchar * bdaddr) +{ + LOGD("\n%s\n",bdaddr); -int isAVPConnected(struct btd_device *addr) { + struct btd_device * device; + gchar *path; + GError *error = NULL; + GVariant *value; - GDBusConnection *connection; - GError *error = NULL; - GVariant *value; - GVariant *variantValue; - gboolean status; + 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(); - connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error); - if (NULL == connection) { - D_PRINTF("GDBusconnection is NULL\n"); - return -1; - } + value = g_dbus_connection_call_sync(cli.system_conn, BLUEZ_SERVICE, + path, DEVICE_INTERFACE, "Connect", + NULL, NULL, G_DBUS_CALL_FLAGS_NONE, + DBUS_REPLY_TIMEOUT, NULL, &error); -// value = g_dbus_connection_call_sync(connection, BLUEZ_SERVICE, BDdevice->path, FREEDESKTOP_PROPERTIES, -// "Get", g_variant_new("(ss)",MEDIA_CONTROL1_INTERFACE,"Connected"), -// NULL, G_DBUS_CALL_FLAGS_NONE, DBUS_REPLY_TIMEOUT, NULL, &error); + g_free(path); - value = g_dbus_connection_call_sync(connection, BLUEZ_SERVICE, addr->path, - FREEDESKTOP_PROPERTIES, "Get", - g_variant_new("(ss)", MEDIA_CONTROL1_INTERFACE, "Connected"), 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; + } - if (NULL == value) { - D_PRINTF ("Error getting object manager client: %s\n", error->message); + g_variant_unref(value); + return 0; - g_error_free(error); - return -1; - } +} - else { - g_variant_get(value, "(v)", &variantValue); - g_variant_get(variantValue, "b", &status); - printf("Address: %s:%i",addr->bdaddr, status); - return status; - } +/* + * send disconnect command + * If success return 0, else return -1; + */ +int device_disconnect(const gchar* bdaddr) +{ + LOGD("\n%s\n",bdaddr); - return 0; + 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, "Disconnect", + 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; } -int isHFPConnected(struct btd_device *addr) { - GDBusConnection *connection; +/* + * Stops the GMainLoop + */ +int BluetoothManagerQuit() +{ + LOGD("\n"); - GError *error = NULL; - GVariant *value; - gchar *ofono_path; - gboolean status; + if (FALSE == BluetoothManage.inited ) + { + LOGD("BluetoothManage Not init\n"); + return -1; + } - GVariantIter *array; - GVariant *var = NULL; - const gchar *key = NULL; + if(cli.clientloop){ + g_main_loop_quit(cli.clientloop); + } - connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error); - if (NULL == connection) { - D_PRINTF("GDBusconnection is NULL\n"); - return -1; - } + OfonoManagerQuit(); + BluezManagerQuit(); + stop_agent(); + devices_list_lock(); + devices_list_cleanup(); + devices_list_unlock(); -//path=/hfp/org/bluez/hci0/dev_E0_98_61_7D_D3_1E; interface=org.ofono.Modem; member=GetProperties - ofono_path = g_strconcat("/hfp", addr->path, NULL); + g_mutex_clear (&(BluetoothManage.m)); + g_object_unref(cli.system_conn); + g_object_unref(cli.session_conn); - value = g_dbus_connection_call_sync(connection, OFONO_SERVICE, ofono_path, - OFONO_MODEM_INTERFACE, "GetProperties", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, - DBUS_REPLY_TIMEOUT, NULL, &error); + if (logfp) + fclose(logfp); + logfp = NULL; - if (NULL == value) { - D_PRINTF ("Error getting object manager client: %s\n", error->message); + BluetoothManage.inited = FALSE; - g_error_free(error); - return -1; - } + 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; - else { + LOGD("\n"); - g_variant_get(value, "(a{sv})", &array); - while (g_variant_iter_loop(array, "{sv}", &key, &var)) { - if (g_strcmp0(key, "Powered") == 0) { + if (TRUE == BluetoothManage.inited ) + { + LOGW("BluetoothManage already init\n"); + return -1; + } - g_variant_get(var, "b", &status); + logfp = fopen("/var/log/BluetoothManager.log", "a+"); - return status; + if (NULL == logfp) + { + openlog("BluetoothManager", LOG_CONS | LOG_PID, LOG_USER); + syslog(LOG_WARNING, "BluetoothManager create log file fail\n"); + closelog(); + } - } - } - g_variant_iter_free(array); - g_variant_unref(value); - g_free(ofono_path); + g_mutex_init(&(BluetoothManage.m)); - return status; - } + pthread_create(&thread_id, NULL, bt_event_loop_thread, NULL); + //pthread_setname_np(thread_id, "BT_Manager"); + sleep(1); - return 0; + 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_propertyies_changed) + { + g_RegisterCallback.binding_device_propertyies_changed = + pstRegisterCallback->binding_device_propertyies_changed; + } + + if (NULL != pstRegisterCallback->binding_request_confirmation) + { + g_RegisterCallback.binding_request_confirmation = + pstRegisterCallback->binding_request_confirmation; + } + } } GError* setHMIStatus(enum btStates state) { @@ -774,5 +1550,4 @@ GError* setHMIStatus(enum btStates state) { } -/************************************** The End Of File **************************************/ |