bt-service/bt-service-headset-connection.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *              http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <glib.h>
  19 #include <string.h>
  20 #include <dlog.h>
  21 #include <vconf.h>
  22 #include <vconf-internal-bt-keys.h>
  23
  24 #include "bluetooth-api.h"
  25 #include "bt-internal-types.h"
  26
  27 #include "bt-service-common.h"
  28 #include "bt-service-event.h"
  29 #include "bt-service-main.h"
  30 #include "bt-service-adapter.h"
  31 #include "bt-service-device.h"
  32 #include "bt-service-audio.h"
  33 #include "bt-service-headset-connection.h"
  34
  35 #include "bt-service-opp-client.h"
  36
  37
  38
  39 static GList *p_connection_list = NULL;
  40 typedef enum {
  41         BLUETOOTH_NONE_CONNECTED = 0x00,
  42         BLUETOOTH_HFP_CONNECTED ,
  43         BLUETOOTH_A2DP_CONNECTED,
  44         BLUETOOTH_ALL_CONNECTED,
  45 } bluetooth_state_type_t;
  46
  47 typedef struct {
  48         bluetooth_state_type_t state;
  49         bluetooth_device_info_t dev_info;
  50         int connection_type;
  51 } bt_connection_node_info_t;
  52
  53 gboolean connection_local = FALSE;
  54
  55
  56 void _bt_headset_set_local_connection(gboolean value)
  57 {
  58         BT_INFO("setting connection_local to %d", value);
  59         connection_local = value;
  60 }
  61
  62 gboolean _bt_headset_get_local_connection()
  63 {
  64         return connection_local;
  65 }
  66
  67 //gint compare_state(GList *data, bluetooth_state_type_t state)
  68 gint compare_state(gconstpointer list_data, gconstpointer conn_state)
  69 {
  70         GList *data = (GList *) list_data;
  71         bluetooth_state_type_t *state = (bluetooth_state_type_t *)conn_state;
  72         bt_connection_node_info_t *p_data = (bt_connection_node_info_t *) data;
  73         if (p_data->state == *state) {
  74                 BT_INFO("State Already Added");
  75                 return 0;
  76         }
  77         return 1;
  78 }
  79
  80 gboolean connect_remote_media_audio(gpointer user_data)
  81 {
  82         bt_connection_node_info_t *conn_info =
  83                         (bt_connection_node_info_t *) user_data;
  84         GList *list = NULL;
  85         bluetooth_state_type_t state;
  86
  87         char remote_address[BT_ADDRESS_STRING_SIZE] = { 0 };
  88         _bt_convert_addr_type_to_string(remote_address, conn_info->dev_info.device_address.addr);
  89         if (p_connection_list == NULL) {
  90                 BT_INFO("None of device connected and this hasbeen triggered");
  91                 return FALSE;
  92         }
  93         if (conn_info->connection_type == BT_AUDIO_A2DP) {
  94                 state = BLUETOOTH_A2DP_CONNECTED;
  95                 list = g_list_find_custom(p_connection_list,
  96                                 &state, compare_state);
  97                 if (list == NULL) {
  98                         BT_INFO("Head Set didn't initiated a2dp connection");
  99                         BT_INFO("local device initiating A2DP connection");
 100                         _bt_audio_connect(0, BT_AUDIO_A2DP,
 101                                         &conn_info->dev_info.device_address, NULL);
 102                 } else {
 103                         BT_INFO("A2DP Connection Already exists");
 104                 }
 105                 g_free(conn_info);
 106         } else {
 107                 state = BLUETOOTH_HFP_CONNECTED;
 108                 list = g_list_find_custom(p_connection_list,
 109                                 &state, compare_state);
 110                 if (list == NULL) {
 111                         BT_INFO("Headset didn't initiated HFP connection");
 112                         BT_INFO("local device intiating HFP Connection");
 113                         _bt_audio_connect(0, BT_AUDIO_HSP,
 114                                         &conn_info->dev_info.device_address, NULL);
 115                 } else {
 116                         BT_INFO("HFP Connection Already exists");
 117                 }
 118                 g_free(conn_info);
 119         }
 120         return FALSE;
 121 }
 122
 123 void _bt_get_bluetooth_device_info(char *remote_address, bluetooth_device_info_t *device)
 124 {
 125         GArray *dev_list = NULL;
 126         int size,i=0;
 127         bluetooth_device_info_t info;
 128         char bond_address[BT_ADDRESS_STRING_SIZE] = { 0 };
 129         dev_list = g_array_new (FALSE, FALSE, sizeof(gchar));
 130         if (device == NULL)
 131                 return;
 132         _bt_get_bonded_devices(&dev_list);
 133         size = (dev_list->len) / sizeof(bluetooth_device_info_t);
 134         for (i=0; i < size; i++) {
 135                 info = g_array_index(dev_list, bluetooth_device_info_t, i);
 136                 _bt_convert_addr_type_to_string(bond_address, info.device_address.addr);
 137                 if (strcmp(bond_address, remote_address) == 0) {
 138                         BT_INFO("Match found");
 139                         memcpy(device, &info, sizeof(bluetooth_device_info_t));
 140                         g_array_free(dev_list, TRUE);
 141                         return;
 142                 }
 143         }
 144         g_array_free(dev_list, TRUE);
 145         return;
 146 }
 147
 148 void _bt_headset_add_timer_function(int connection_type, bluetooth_device_info_t *info)
 149 {
 150         bt_connection_node_info_t *pass_conn_info = NULL;
 151
 152         if (info == NULL)
 153                 return;
 154
 155         pass_conn_info = g_new0(bt_connection_node_info_t, 1);
 156         pass_conn_info->connection_type = connection_type;
 157         memcpy(&pass_conn_info->dev_info, info, sizeof(bluetooth_device_info_t));
 158         /* This need to be freed in timer function */
 159         g_timeout_add(CONNECT_TIMEOUT, connect_remote_media_audio,
 160                 pass_conn_info);
 161         return;
 162 }
 163
 164 void _bt_start_timer_for_connection(char *remote_address, int connection_type)
 165 {
 166         GArray *dev_list = NULL;
 167         int size,i=0,j;
 168         bluetooth_device_info_t info;
 169         char bond_address[BT_ADDRESS_STRING_SIZE] = { 0 };
 170         dev_list = g_array_new (FALSE, FALSE, sizeof(gchar));
 171         _bt_get_bonded_devices(&dev_list);
 172         size = (dev_list->len) / sizeof(bluetooth_device_info_t);
 173
 174         for (i=0; i < size; i++) {
 175                 info = g_array_index(dev_list, bluetooth_device_info_t, i);
 176                 j = 0;
 177                 _bt_convert_addr_type_to_string(bond_address,
 178                                 info.device_address.addr);
 179                 if (strcmp(bond_address, remote_address) != 0)
 180                         continue;
 181                 BT_INFO("Device address Matched");
 182
 183                 while (j != info.service_index) {
 184                         BT_INFO("UUID %s", info.uuids[j]);
 185                         if (connection_type == BT_AUDIO_A2DP) {
 186                                 if (strcmp(info.uuids[j], A2DP_SINK_UUID) == 0) {
 187                                         BT_INFO("Remote Device has A2DP Sink Support start timer");
 188                                         _bt_headset_add_timer_function(BT_AUDIO_A2DP, &info);
 189                                         goto end;
 190                                 }
 191                         } else {
 192                                 if (strcmp(info.uuids[j], HFP_HS_UUID) == 0) {
 193                                         BT_INFO("Remote Device has HFP Sink Support start timer");
 194                                         _bt_headset_add_timer_function(BT_AUDIO_HSP, &info);
 195                                         goto end;
 196                                 }
 197                         }
 198                         j++;
 199                 }
 200         }
 201 end:
 202         g_array_free(dev_list, TRUE);
 203 }
 204
 205 void __bt_connection_manager_set_state(char *remote_address, int event)
 206 {
 207         bt_connection_node_info_t *info = g_new0(bt_connection_node_info_t, 1);
 208
 209         char bond_address[BT_ADDRESS_STRING_SIZE] = { 0 };
 210         if (event == BLUETOOTH_EVENT_AG_CONNECTED) {
 211                 info->state = BLUETOOTH_HFP_CONNECTED;
 212                 _bt_get_bluetooth_device_info(remote_address, &info->dev_info);
 213                 _bt_convert_addr_type_to_string(bond_address,
 214                                 info->dev_info.device_address.addr);
 215                 BT_INFO("Adding HFP Connected device to list");
 216                 p_connection_list = g_list_append(p_connection_list, info);
 217         }
 218         else if (event == BLUETOOTH_EVENT_AG_DISCONNECTED) {
 219                 /* Delete coresponding node */
 220                 BT_INFO("Deleting HFP Connected device from list");
 221                 GList *list = NULL;
 222                 bluetooth_state_type_t state;
 223                 bt_connection_node_info_t *h_conn;
 224                 state = BLUETOOTH_HFP_CONNECTED;
 225                 list = g_list_find_custom(p_connection_list,
 226                                 &state, compare_state);
 227                 if (list == NULL) {
 228                         BT_INFO("Didn't found any device with HFP State");
 229                         return;
 230                 }
 231                 h_conn = list->data;
 232                 p_connection_list = g_list_remove(p_connection_list, h_conn);
 233                 g_free(h_conn);
 234         } else if (event == BLUETOOTH_EVENT_AV_CONNECTED) {
 235                 info->state = BLUETOOTH_A2DP_CONNECTED;
 236                 _bt_get_bluetooth_device_info(remote_address, &info->dev_info);
 237                 _bt_convert_addr_type_to_string(bond_address,
 238                                 info->dev_info.device_address.addr);
 239                 BT_INFO("Adding A2DP Connected device to list");
 240                 p_connection_list = g_list_append(p_connection_list, info);
 241         } else if (event == BLUETOOTH_EVENT_AV_DISCONNECTED) {
 242                 BT_INFO("Deleting A2DP Connected device from list");
 243                 bt_connection_node_info_t *a_conn;
 244                 GList *list = NULL;
 245                 bluetooth_state_type_t state;
 246                 state = BLUETOOTH_A2DP_CONNECTED;
 247                 list = g_list_find_custom(p_connection_list,
 248                                 &state, compare_state);
 249                 if (list == NULL) {
 250                         BT_INFO("Didn't found any device with A2DP State");
 251                         return;
 252                 }
 253                 a_conn = list->data;
 254                 p_connection_list = g_list_remove(p_connection_list, a_conn);
 255                 g_free(a_conn);
 256         }
 257 }
 258