#include <stdio.h>
|
#include <string.h>
|
#include <unistd.h>
|
#include <errno.h>
|
|
#include <DeviceIo.h>
|
#include <RkBtBase.h>
|
#include <RkBtSink.h>
|
#include <RkBtHfp.h>
|
#include "utility.h"
|
#include "slog.h"
|
|
#include <bt_manager_1s2.h>
|
|
static btmg_callback_t *g_btmg_cb = NULL;
|
static bool g_btmg_enable = false;
|
static btmg_state_t g_bt_state = BTMG_STATE_OFF;
|
|
int bt_manager_set_loglevel(btmg_log_level_t log_level)
|
{
|
return 0;
|
}
|
|
/* get the bt_manager printing level*/
|
btmg_log_level_t bt_manager_get_loglevel(void)
|
{
|
return BTMG_LOG_LEVEL_NONE;
|
}
|
|
void bt_manager_debug_open_syslog(void)
|
{
|
}
|
|
void bt_manager_debug_close_syslog(void)
|
{
|
}
|
|
int bt_manager_debug_open_file(const char *path)
|
{
|
return 0;
|
}
|
|
void bt_manager_debug_close_file(void)
|
{
|
|
}
|
|
static void btmg_gap_status_cb(RK_BT_STATE state)
|
{
|
switch(state) {
|
case RK_BT_STATE_OFF:
|
g_bt_state = BTMG_STATE_OFF;
|
break;
|
case RK_BT_STATE_ON:
|
g_bt_state = BTMG_STATE_ON;
|
break;
|
case RK_BT_STATE_TURNING_ON:
|
g_bt_state = BTMG_STATE_TURNING_ON;
|
break;
|
case RK_BT_STATE_TURNING_OFF:
|
g_bt_state = BTMG_STATE_TURNING_OFF;
|
break;
|
default:
|
pr_info("unknown bt state: %d\n", state);
|
return;
|
}
|
|
if(g_btmg_cb && g_btmg_cb->btmg_gap_cb.gap_status_cb)
|
g_btmg_cb->btmg_gap_cb.gap_status_cb(g_bt_state);
|
}
|
|
static void btmg_gap_bond_state_cb(const char *bd_addr, const char *name, RK_BT_BOND_STATE state)
|
{
|
btmg_bond_state_t bond_state;
|
|
switch(state) {
|
case RK_BT_BOND_STATE_NONE:
|
bond_state = BTMG_BOND_STATE_NONE;
|
break;
|
case RK_BT_BOND_STATE_BONDING:
|
bond_state = BTMG_BOND_STATE_BONDING;
|
break;
|
case RK_BT_BOND_STATE_BONDED:
|
bond_state = BTMG_BOND_STATE_BONDED;
|
break;
|
default:
|
pr_info("unknown bt bond state: %d\n", state);
|
return;
|
}
|
|
if(g_btmg_cb && g_btmg_cb->btmg_gap_cb.gap_bond_state_cb)
|
g_btmg_cb->btmg_gap_cb.gap_bond_state_cb(bond_state, bd_addr, name);
|
}
|
|
static void btmg_gap_discovery_status_cb(RK_BT_DISCOVERY_STATE state)
|
{
|
btmg_discovery_state_t disc_state;
|
|
switch(state) {
|
case RK_BT_DISC_STARTED:
|
disc_state = BTMG_DISC_STARTED;
|
break;
|
case RK_BT_DISC_STOPPED_AUTO:
|
disc_state = BTMG_DISC_STOPPED_AUTO;
|
break;
|
case RK_BT_DISC_START_FAILED:
|
disc_state = BTMG_DISC_START_FAILED;
|
break;
|
case RK_BT_DISC_STOPPED_BY_USER:
|
disc_state = BTMG_DISC_STOPPED_BY_USER;
|
break;
|
default:
|
pr_info("unknown bt discovery state: %d\n", state);
|
return;
|
}
|
|
if(g_btmg_cb && g_btmg_cb->btmg_gap_cb.gap_disc_status_cb)
|
g_btmg_cb->btmg_gap_cb.gap_disc_status_cb(disc_state);
|
}
|
|
static void btmg_dev_found_cb(const char *address,const char *name, unsigned int bt_class, int rssi)
|
{
|
if(g_btmg_cb && g_btmg_cb->btmg_gap_cb.gap_dev_found_cb)
|
g_btmg_cb->btmg_gap_cb.gap_dev_found_cb(address, name, bt_class, rssi);
|
}
|
|
static void _btmg_sink_conn_state_cb(const char *bd_addr, btmg_a2dp_sink_connection_state_t state)
|
{
|
if(g_btmg_cb && g_btmg_cb->btmg_a2dp_sink_cb.a2dp_sink_connection_state_cb)
|
g_btmg_cb->btmg_a2dp_sink_cb.a2dp_sink_connection_state_cb(bd_addr, state);
|
}
|
|
static void _btmg_avrcp_play_state_cb(const char *bd_addr, btmg_avrcp_play_state_t state)
|
{
|
if(g_btmg_cb && g_btmg_cb->btmg_avrcp_cb.avrcp_play_state_cb)
|
g_btmg_cb->btmg_avrcp_cb.avrcp_play_state_cb(bd_addr, state);
|
}
|
|
static void _btmg_sink_audio_state_cb(const char *bd_addr, btmg_a2dp_sink_audio_state_t state)
|
{
|
if(g_btmg_cb && g_btmg_cb->btmg_a2dp_sink_cb.a2dp_sink_audio_state_cb)
|
g_btmg_cb->btmg_a2dp_sink_cb.a2dp_sink_audio_state_cb(bd_addr, state);
|
}
|
|
static void btmg_sink_audio_underrun_cb(void)
|
{
|
if(g_btmg_cb && g_btmg_cb->btmg_a2dp_sink_cb.a2dp_sink_audio_underrun_cb)
|
g_btmg_cb->btmg_a2dp_sink_cb.a2dp_sink_audio_underrun_cb();
|
}
|
|
static int btmg_sink_callback(RK_BT_SINK_STATE state)
|
{
|
char bd_addr[18];
|
memset(bd_addr, 0, 18);
|
rk_bt_sink_get_default_dev_addr(bd_addr, 18);
|
|
switch(state) {
|
case RK_BT_SINK_STATE_IDLE:
|
break;
|
case RK_BT_SINK_STATE_CONNECT:
|
_btmg_sink_conn_state_cb(bd_addr, BTMG_A2DP_SINK_CONNECTED);
|
break;
|
case RK_BT_SINK_STATE_DISCONNECT:
|
_btmg_sink_conn_state_cb(bd_addr, BTMG_A2DP_SINK_DISCONNECTED);
|
break;
|
//avrcp
|
case RK_BT_SINK_STATE_PLAY:
|
_btmg_avrcp_play_state_cb(bd_addr, BTMG_AVRCP_PLAYSTATE_PLAYING);
|
break;
|
case RK_BT_SINK_STATE_PAUSE:
|
_btmg_avrcp_play_state_cb(bd_addr, BTMG_AVRCP_PLAYSTATE_PAUSED);
|
break;
|
case RK_BT_SINK_STATE_STOP:
|
_btmg_avrcp_play_state_cb(bd_addr, BTMG_AVRCP_PLAYSTATE_STOPPED);
|
break;
|
//avdtp(a2dp)
|
case RK_BT_A2DP_SINK_STARTED:
|
_btmg_sink_audio_state_cb(bd_addr, BTMG_A2DP_SINK_AUDIO_STARTED);
|
break;
|
case RK_BT_A2DP_SINK_SUSPENDED:
|
_btmg_sink_audio_state_cb(bd_addr, BTMG_A2DP_SINK_AUDIO_SUSPENDED);
|
break;
|
case RK_BT_A2DP_SINK_STOPPED:
|
_btmg_sink_audio_state_cb(bd_addr, BTMG_A2DP_SINK_AUDIO_STOPPED);
|
break;
|
}
|
|
return 0;
|
}
|
|
static void btmg_sink_track_change_callback(const char *bd_addr, BtTrackInfo track_info)
|
{
|
if(g_btmg_cb && g_btmg_cb->btmg_avrcp_cb.avrcp_track_changed_cb)
|
g_btmg_cb->btmg_avrcp_cb.avrcp_track_changed_cb(bd_addr, track_info);
|
}
|
|
static void btmg_sink_position_change_callback(const char *bd_addr, int song_len, int song_pos)
|
{
|
if(g_btmg_cb && g_btmg_cb->btmg_avrcp_cb.avrcp_play_position_cb)
|
g_btmg_cb->btmg_avrcp_cb.avrcp_play_position_cb(bd_addr, song_len, song_pos);
|
}
|
|
/*preinit function, to allocate room for callback struct, which will be free by bt_manager_deinit*/
|
int bt_manager_preinit(btmg_callback_t **btmg_cb)
|
{
|
*btmg_cb = (btmg_callback_t *)malloc(sizeof(btmg_callback_t));
|
if(*btmg_cb == NULL) {
|
pr_info("malloc bt manager callback failed\n");
|
return -1;
|
}
|
|
memset(*btmg_cb, 0, sizeof(btmg_callback_t));
|
return 0;
|
}
|
|
/*init function, the callback functions will be registered*/
|
int bt_manager_init(btmg_callback_t *btmg_cb)
|
{
|
g_btmg_cb = btmg_cb;
|
return 0;
|
}
|
|
/*deinit function, must be called before exit*/
|
int bt_manager_deinit(btmg_callback_t *btmg_cb)
|
{
|
if(bt_manager_is_enabled())
|
bt_manager_enable(false);
|
|
if(btmg_cb)
|
free(btmg_cb);
|
|
g_btmg_cb = NULL;
|
return 0;
|
}
|
|
/*enable BT*/
|
int bt_manager_enable(bool enable)
|
{
|
int ret;
|
if(enable) {
|
rk_bt_register_state_callback(btmg_gap_status_cb);
|
rk_bt_register_bond_callback(btmg_gap_bond_state_cb);
|
rk_bt_register_discovery_callback(btmg_gap_discovery_status_cb);
|
rk_bt_register_dev_found_callback(btmg_dev_found_cb);
|
if(rk_bt_init(NULL) < 0) {
|
pr_info("%s: rk_bt_init error\n", __func__);
|
return -1;
|
}
|
|
rk_bt_sink_register_track_callback(btmg_sink_track_change_callback);
|
rk_bt_sink_register_position_callback(btmg_sink_position_change_callback);
|
rk_bt_sink_register_callback(btmg_sink_callback);
|
rk_bt_sink_register_underurn_callback(btmg_sink_audio_underrun_cb);
|
ret = rk_bt_sink_open();
|
} else {
|
rk_bt_deinit();
|
ret = 0;
|
}
|
|
g_btmg_enable = enable;
|
return ret;
|
}
|
|
/*return BT state, is enabled or not*/
|
bool bt_manager_is_enabled(void)
|
{
|
return g_btmg_enable;
|
}
|
|
/*GAP APIs*/
|
/*start discovery, will return immediately*/
|
int bt_manager_start_discovery(unsigned int mseconds)
|
{
|
return rk_bt_start_discovery(mseconds, SCAN_TYPE_AUTO);
|
}
|
|
/*cancel discovery, will return immediately*/
|
int bt_manager_cancel_discovery(void)
|
{
|
return rk_bt_cancel_discovery();
|
}
|
|
/*judge the discovery is in process or not*/
|
bool bt_manager_is_discovering()
|
{
|
return rk_bt_is_discovering();
|
}
|
|
/*set BT discovery mode*/
|
int bt_manager_set_discovery_mode(btmg_discovery_mode_t mode)
|
{
|
int ret = -1;
|
switch (mode) {
|
case BTMG_SCAN_MODE_NONE:
|
ret = rk_bt_set_visibility(0, 0);
|
break;
|
case BTMG_SCAN_MODE_CONNECTABLE:
|
ret = rk_bt_set_visibility(0, 1);
|
break;
|
case BTMG_SCAN_MODE_CONNECTABLE_DISCOVERABLE:
|
ret = rk_bt_set_visibility(1, 1);
|
break;
|
}
|
|
return ret;
|
}
|
|
/*pair*/
|
int bt_manager_pair(char *addr)
|
{
|
return rk_bt_pair_by_addr(addr);
|
}
|
|
/*unpair*/
|
int bt_manager_unpair(char *addr)
|
{
|
return rk_bt_unpair_by_addr(addr);
|
}
|
|
/*get bt state*/
|
btmg_state_t bt_manager_get_state()
|
{
|
return g_bt_state;
|
}
|
|
/*get BT name*/
|
int bt_manager_get_name(char *name, int size)
|
{
|
return rk_bt_get_device_name(name, size);
|
}
|
|
/*set BT name*/
|
int bt_manager_set_name(const char *name)
|
{
|
return rk_bt_set_device_name((char *)name);
|
}
|
|
/*get local device address*/
|
int bt_manager_get_address(char *addr, int size)
|
{
|
return rk_bt_get_device_addr(addr, size);
|
}
|
|
/*a2dp sink APIs*/
|
/*request a2dp_sink connection*/
|
int bt_manager_a2dp_sink_connect(char *addr)
|
{
|
return rk_bt_sink_connect_by_addr(addr);
|
}
|
|
/*request a2dp_sink disconnection*/
|
int bt_manager_a2dp_sink_disconnect(char *addr)
|
{
|
return rk_bt_sink_disconnect_by_addr(addr);
|
}
|
|
/*used to send avrcp command, refer to the struct btmg_avrcp_command_t for the supported commands*/
|
int bt_manager_avrcp_command(char *addr, btmg_avrcp_command_t command)
|
{
|
int ret = -1;
|
char bd_addr[18];
|
|
memset(bd_addr, 0, 18);
|
rk_bt_sink_get_default_dev_addr(bd_addr, 18);
|
if(strncmp(bd_addr, addr, 17)) {
|
pr_info("%s: Invalid address(%s)\n", __func__, addr);
|
return -1;
|
}
|
|
switch(command) {
|
case BTMG_AVRCP_PLAY:
|
ret = rk_bt_sink_play();
|
break;
|
case BTMG_AVRCP_STOP:
|
ret = rk_bt_sink_stop();
|
break;
|
case BTMG_AVRCP_PAUSE:
|
ret = rk_bt_sink_pause();
|
break;
|
case BTMG_AVRCP_FORWARD:
|
ret = rk_bt_sink_next();
|
break;
|
case BTMG_AVRCP_BACKWARD:
|
ret = rk_bt_sink_prev();
|
break;
|
}
|
|
return ret;
|
}
|
|
bt_paried_device *bt_create_one_paired_dev(RkBtScanedDevice *scan_dev)
|
{
|
bt_paried_device *new_device = (bt_paried_device*)malloc(sizeof(bt_paried_device));
|
if(!new_device) {
|
printf("%s: malloc one paierded device failed\n", __func__);
|
return NULL;
|
}
|
|
new_device->remote_address = (char *)malloc(strlen(scan_dev->remote_address) + 1);
|
strncpy(new_device->remote_address, scan_dev->remote_address, strlen(scan_dev->remote_address));
|
new_device->remote_address[strlen(scan_dev->remote_address)] = '\0';
|
|
new_device->remote_name = (char *)malloc(strlen(scan_dev->remote_name) + 1);
|
strncpy(new_device->remote_name, scan_dev->remote_name, strlen(scan_dev->remote_name));
|
new_device->remote_name[strlen(scan_dev->remote_name)] = '\0';
|
|
new_device->is_connected = scan_dev->is_connected;
|
new_device->next = NULL;
|
|
return new_device;
|
}
|
|
/* Get the paired device,need to call <bt_manager_free_paired_devices> to free data*/
|
int bt_manager_get_paired_devices(bt_paried_device **dev_list,int *count)
|
{
|
int i;
|
RkBtScanedDevice *dev_tmp = NULL;
|
RkBtScanedDevice *scan_dev_list;
|
|
if(dev_list == NULL) {
|
pr_info("%s: invalid dev_list\n", __func__);
|
return -1;
|
}
|
|
if(rk_bt_get_paired_devices(&scan_dev_list, count) < 0)
|
return -1;
|
|
//printf("%s: current paired devices count: %d\n", __func__, *count);
|
dev_tmp = scan_dev_list;
|
for(i = 0; i < *count; i++) {
|
//printf("device %d\n", i);
|
//printf(" remote_address: %s\n", dev_tmp->remote_address);
|
//printf(" remote_name: %s\n", dev_tmp->remote_name);
|
//printf(" is_connected: %d\n", dev_tmp->is_connected);
|
//printf(" cod: %d\n", dev_tmp->cod);
|
|
if(*dev_list == NULL) {
|
*dev_list = bt_create_one_paired_dev(dev_tmp);
|
if(*dev_list == NULL)
|
return -1;
|
} else {
|
bt_paried_device *cur_dev = *dev_list;
|
while(cur_dev->next != NULL)
|
cur_dev = cur_dev->next;
|
|
bt_paried_device *new_dev = bt_create_one_paired_dev(dev_tmp);
|
if(!new_dev)
|
return -1;
|
|
cur_dev->next = new_dev;
|
}
|
|
dev_tmp = dev_tmp->next;
|
}
|
|
rk_bt_free_paired_devices(scan_dev_list);
|
return 0;
|
}
|
|
/* free paird device data resource*/
|
int bt_manager_free_paired_devices(bt_paried_device *dev_list)
|
{
|
bt_paried_device *dev_tmp = NULL;
|
|
if(dev_list == NULL) {
|
printf("%s: dev_list is nill, don't need to clear\n", __func__);
|
return -1;
|
}
|
|
while(dev_list->next != NULL) {
|
printf("%s: free dev: %s\n", __func__, dev_list->remote_address);
|
dev_tmp = dev_list->next;
|
free(dev_list->remote_address);
|
free(dev_list->remote_name);
|
free(dev_list);
|
dev_list = dev_tmp;
|
}
|
|
if(dev_list != NULL) {
|
printf("%s: last free dev: %s\n", __func__, dev_list->remote_address);
|
free(dev_list->remote_address);
|
free(dev_list->remote_name);
|
free(dev_list);
|
dev_list = NULL;
|
}
|
|
return 0;
|
}
|
|
int bt_manager_disconnect(char *addr)
|
{
|
return 0;
|
}
|
|
/*send GetPlayStatus cmd*/
|
int bt_manager_send_get_play_status()
|
{
|
return rk_bt_sink_get_play_status();
|
}
|
|
/*if support avrcp EVENT_PLAYBACK_POS_CHANGED,*/
|
bool bt_manager_is_support_pos_changed()
|
{
|
return rk_bt_sink_get_poschange();
|
}
|
|
int bt_manager_switch_throughput(bool sw_to_wlan)
|
{
|
if (sw_to_wlan)
|
return exec_command_system("hcitool cmd 0x3f 0xa7 0x01");
|
else
|
return exec_command_system("hcitool cmd 0x3f 0xa7 0x00");
|
}
|
