#include <stdio.h>
|
#include <errno.h>
|
#include <glib.h>
|
#include <unistd.h>
|
#include <stdlib.h>
|
#include <signal.h>
|
#include <stdbool.h>
|
#include <wordexp.h>
|
#include <sys/un.h>
|
#include <sys/signalfd.h>
|
#include <sys/socket.h>
|
#include <readline/readline.h>
|
#include <readline/history.h>
|
#include <linux/input.h>
|
#include <dirent.h>
|
#include <fcntl.h>
|
#include <pthread.h>
|
|
#include "DeviceIo.h"
|
//#include "Rk_shell.h"
|
|
#include "a2dp_masterctrl.h"
|
#include "shell.h"
|
#include "util.h"
|
#include "agent.h"
|
#include "gatt.h"
|
#include "advertising.h"
|
#include "../bluez_ctrl.h"
|
#include "../gatt_config.h"
|
#include "../gatt_client.h"
|
#include "../bluez_ctrl.h"
|
#include "utility.h"
|
#include "slog.h"
|
|
/* operands in passthrough commands */
|
#define AVC_VOLUME_UP 0x41
|
#define AVC_VOLUME_DOWN 0x42
|
#define AVC_PLAY 0x44
|
#define AVC_STOP 0x45
|
#define AVC_PAUSE 0x46
|
#define AVC_FORWARD 0x4b
|
#define AVC_BACKWARD 0x4c
|
|
/* String display constants */
|
#define COLORED_NEW COLOR_GREEN "NEW" COLOR_OFF
|
#define COLORED_CHG COLOR_YELLOW "CHG" COLOR_OFF
|
#define COLORED_DEL COLOR_RED "DEL" COLOR_OFF
|
|
#define PROMPT_ON COLOR_BLUE "[bluetooth]" COLOR_OFF "# "
|
#define PROMPT_OFF "Waiting to connect to bluetoothd..."
|
|
#define DISTANCE_VAL_INVALID 0x7FFF
|
|
DBusConnection *dbus_conn = NULL;
|
static GDBusProxy *agent_manager;
|
static char *auto_register_agent = NULL;
|
static RkBtContent *g_bt_content = NULL;
|
|
struct remote_sink_device {
|
int state;
|
char addr[64];
|
char name[64];
|
};
|
struct remote_sink_device rsd;
|
|
struct adapter {
|
GDBusProxy *proxy;
|
GDBusProxy *ad_proxy;
|
GList *devices;
|
};
|
|
typedef struct {
|
RK_BT_STATE_CALLBACK bt_state_cb;
|
RK_BT_BOND_CALLBACK bt_bond_state_cb;
|
RK_BT_DISCOVERY_CALLBACK bt_decovery_cb;
|
RK_BT_DEV_FOUND_CALLBACK bt_dev_found_cb;
|
RK_BT_SOURCE_CALLBACK bt_source_event_cb;
|
RK_BLE_STATE_CALLBACK ble_state_cb;
|
RK_BT_NAME_CHANGE_CALLBACK bt_name_change_cb;
|
RK_BT_MTU_CALLBACK ble_mtu_cb;
|
} bt_callback_t;
|
|
typedef struct {
|
bool is_scaning;
|
bool scan_off_failed;
|
pthread_t scan_thread;
|
unsigned int scan_time;
|
RK_BT_SCAN_TYPE scan_type;
|
} bt_scan_info_t;
|
|
typedef struct {
|
bool is_connecting;
|
bool is_reconnected;
|
char connect_address[18];
|
char reconnect_address[18];
|
} bt_source_info_t;
|
|
//workround unknow err for con/discon remote proxy
|
struct ConnectContext_t {
|
GDBusProxy *proxy;
|
char *address;
|
};
|
|
struct adapter *default_ctrl = NULL;
|
GDBusProxy *default_dev = NULL;
|
GDBusProxy *ble_dev = NULL;
|
GDBusProxy *default_attr = NULL;
|
GList *ctrl_list;
|
|
GDBusClient *btsrc_client = NULL;
|
|
/* For connect cmd */
|
#define BTSRC_CONNECT_IDLE 0
|
#define BTSRC_CONNECT_DOING 1
|
#define BTSRC_CONNECT_SUCESS 2
|
#define BTSRC_CONNECT_FAILED 3
|
|
static bool BT_OPENED = 0;
|
static bool BT_CLOSED = 0;
|
|
static void *g_btmaster_userdata = NULL;
|
static RK_BLE_STATE g_ble_state;
|
static RK_BT_SOURCE_EVENT g_device_state = BT_SOURCE_EVENT_DISCONNECTED;
|
|
static bt_source_info_t g_bt_source_info = {
|
false, false,
|
};
|
|
static bt_callback_t g_bt_callback = {
|
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
|
};
|
|
static bt_scan_info_t g_bt_scan_info = {
|
false, false, 0, 0, SCAN_TYPE_AUTO,
|
};
|
|
#ifdef __cplusplus
|
extern "C" {
|
#endif
|
|
extern void register_app(GDBusProxy *proxy);
|
extern void unregister_app(GDBusProxy *proxy);
|
int gatt_set_on_adv(void);
|
static void filter_clear_transport();
|
static int remove_device(GDBusProxy *proxy);
|
|
#ifdef __cplusplus
|
}
|
#endif
|
|
extern void a2dp_sink_proxy_removed(GDBusProxy *proxy, void *user_data);
|
extern void a2dp_sink_proxy_added(GDBusProxy *proxy, void *user_data);
|
extern void a2dp_sink_property_changed(GDBusProxy *proxy, const char *name, DBusMessageIter *iter, void *user_data);
|
extern void adapter_changed(GDBusProxy *proxy, DBusMessageIter *iter, void *user_data);
|
extern void device_changed(GDBusProxy *proxy, DBusMessageIter *iter, void *user_data);
|
extern int init_avrcp_ctrl(void);
|
|
static volatile int ble_service_cnt = 0;
|
|
extern void report_avrcp_event(enum BtEvent event, void *data, int len);
|
|
static const char *agent_arguments[] = {
|
"on",
|
"off",
|
"DisplayOnly",
|
"DisplayYesNo",
|
"KeyboardDisplay",
|
"KeyboardOnly",
|
"NoInputNoOutput",
|
NULL
|
};
|
|
static const char *ad_arguments[] = {
|
"on",
|
"off",
|
"peripheral",
|
"broadcast",
|
NULL
|
};
|
|
#define BT_RECONNECT_CFG "/data/cfg/lib/bluetooth/reconnect_cfg"
|
|
int a2dp_master_save_status(char *address);
|
static int load_last_device(char *address);
|
static void save_last_device(GDBusProxy *proxy);
|
|
static void bt_bond_state_send(const char *bd_addr, const char *name, RK_BT_BOND_STATE state)
|
{
|
if(g_bt_callback.bt_bond_state_cb)
|
g_bt_callback.bt_bond_state_cb(bd_addr, name, state);
|
}
|
|
void bt_register_bond_callback(RK_BT_BOND_CALLBACK cb)
|
{
|
g_bt_callback.bt_bond_state_cb = cb;
|
}
|
|
void bt_deregister_bond_callback()
|
{
|
g_bt_callback.bt_bond_state_cb = NULL;
|
}
|
|
void bt_state_send(RK_BT_STATE state)
|
{
|
if(g_bt_callback.bt_state_cb)
|
g_bt_callback.bt_state_cb(state);
|
}
|
|
void bt_register_state_callback(RK_BT_STATE_CALLBACK cb)
|
{
|
g_bt_callback.bt_state_cb = cb;
|
}
|
|
void bt_deregister_state_callback()
|
{
|
g_bt_callback.bt_state_cb = NULL;
|
}
|
|
void ble_state_send(RK_BLE_STATE status)
|
{
|
char addr[18], name[256];
|
|
g_ble_state = status;
|
|
if(!g_bt_callback.ble_state_cb) {
|
pr_info("%s: ble_state_cb are not registered\n", __func__);
|
return;
|
}
|
|
if(!ble_is_open()) {
|
pr_info("%s: ble is close\n", __func__);
|
return;
|
}
|
|
memset(addr, 0, 18);
|
memset(name, 0, 256);
|
bt_get_device_addr_by_proxy(ble_dev, addr, 18);
|
bt_get_device_name_by_proxy(ble_dev, name, 256);
|
g_bt_callback.ble_state_cb(addr, name, status);
|
}
|
|
void ble_get_state(RK_BLE_STATE *p_state)
|
{
|
if (!p_state)
|
return;
|
|
*p_state = g_ble_state;
|
}
|
|
void ble_register_state_callback(RK_BLE_STATE_CALLBACK cb)
|
{
|
g_bt_callback.ble_state_cb = cb;
|
}
|
|
void ble_deregister_state_callback()
|
{
|
g_bt_callback.ble_state_cb = NULL;
|
}
|
|
static void bt_discovery_state_send(RK_BT_DISCOVERY_STATE state)
|
{
|
if(g_bt_callback.bt_decovery_cb) {
|
pr_info("%s: state = %d\n", __func__, state);
|
g_bt_callback.bt_decovery_cb(state);
|
}
|
}
|
|
void bt_register_discovery_callback(RK_BT_DISCOVERY_CALLBACK cb)
|
{
|
g_bt_callback.bt_decovery_cb = cb;
|
}
|
|
void bt_deregister_discovery_callback()
|
{
|
g_bt_callback.bt_decovery_cb = NULL;
|
}
|
|
void dev_found_send(GDBusProxy *proxy, RK_BT_DEV_FOUND_CALLBACK cb)
|
{
|
DBusMessageIter iter;
|
dbus_uint32_t bt_class = 0;
|
const char *address, *name;
|
short rssi = DISTANCE_VAL_INVALID;
|
|
if(!cb) {
|
pr_info("%s: cb == NULL\n", __func__);
|
return;
|
}
|
|
if (g_dbus_proxy_get_property(proxy, "Address", &iter) == FALSE) {
|
pr_info("%s: get Address failed\n", __func__);
|
return;
|
}
|
|
dbus_message_iter_get_basic(&iter, &address);
|
|
if (g_dbus_proxy_get_property(proxy, "Alias", &iter))
|
dbus_message_iter_get_basic(&iter, &name);
|
else
|
name = "unknown";
|
|
if(g_dbus_proxy_get_property(proxy, "Class", &iter))
|
dbus_message_iter_get_basic(&iter, &bt_class);
|
|
if (g_dbus_proxy_get_property(proxy, "RSSI", &iter))
|
dbus_message_iter_get_basic(&iter, &rssi);
|
|
cb(address, name, bt_class, rssi);
|
}
|
|
static void bt_dev_found_send(GDBusProxy *proxy)
|
{
|
if(!bt_is_scaning() || !g_bt_callback.bt_dev_found_cb)
|
return;
|
|
dev_found_send(proxy, g_bt_callback.bt_dev_found_cb);
|
}
|
|
void bt_register_dev_found_callback(RK_BT_DEV_FOUND_CALLBACK cb)
|
{
|
g_bt_callback.bt_dev_found_cb = cb;
|
}
|
|
void bt_deregister_dev_found_callback()
|
{
|
g_bt_callback.bt_dev_found_cb = NULL;
|
}
|
|
static void bt_name_change_send(GDBusProxy *proxy)
|
{
|
const char *address, *name;
|
DBusMessageIter iter;
|
|
if(!g_bt_callback.bt_name_change_cb)
|
return;
|
|
if (g_dbus_proxy_get_property(proxy, "Address", &iter) == FALSE) {
|
pr_info("%s: get Address failed\n", __func__);
|
return;
|
}
|
|
dbus_message_iter_get_basic(&iter, &address);
|
|
if (g_dbus_proxy_get_property(proxy, "Alias", &iter))
|
dbus_message_iter_get_basic(&iter, &name);
|
else
|
name = address;
|
|
g_bt_callback.bt_name_change_cb(address, name);
|
}
|
|
static void ble_mtu_exchange_send(GDBusProxy *proxy)
|
{
|
const char *address;
|
dbus_uint16_t mtu;
|
DBusMessageIter iter;
|
|
if(!ble_is_open() && !ble_client_is_open())
|
return;
|
|
if(!g_bt_callback.ble_mtu_cb)
|
return;
|
|
if (!g_dbus_proxy_get_property(proxy, "Address", &iter)) {
|
pr_info("%s: get Address failed\n", __func__);
|
return;
|
}
|
dbus_message_iter_get_basic(&iter, &address);
|
|
if (!g_dbus_proxy_get_property(proxy, "MTU", &iter)) {
|
pr_info("%s: get MTU failed\n", __func__);
|
return;
|
}
|
dbus_message_iter_get_basic(&iter, &mtu);
|
|
if(mtu > BT_ATT_MAX_LE_MTU || mtu < BT_ATT_DEFAULT_LE_MTU)
|
pr_err("%s: MTU exchange error(%d)\n", __func__, mtu);
|
|
g_bt_callback.ble_mtu_cb(address, mtu);
|
}
|
|
void bt_register_name_change_callback(RK_BT_NAME_CHANGE_CALLBACK cb)
|
{
|
g_bt_callback.bt_name_change_cb = cb;
|
}
|
|
void bt_deregister_name_change_callback()
|
{
|
g_bt_callback.bt_name_change_cb = NULL;
|
}
|
|
void ble_register_mtu_callback(RK_BT_MTU_CALLBACK cb)
|
{
|
g_bt_callback.ble_mtu_cb = cb;
|
}
|
|
void ble_deregister_mtu_callback()
|
{
|
g_bt_callback.ble_mtu_cb = NULL;
|
}
|
|
static void proxy_leak(gpointer data)
|
{
|
pr_info("Leaking proxy %p\n", data);
|
}
|
|
static void connect_handler(DBusConnection *connection, void *user_data)
|
{
|
bt_shell_set_prompt(PROMPT_ON);
|
}
|
|
static void disconnect_handler(DBusConnection *connection, void *user_data)
|
{
|
//bt_shell_detach();
|
|
//bt_shell_set_prompt(PROMPT_OFF);
|
|
g_list_free_full(ctrl_list, proxy_leak);
|
ctrl_list = NULL;
|
|
default_ctrl = NULL;
|
}
|
|
static void print_adapter(GDBusProxy *proxy, const char *description)
|
{
|
DBusMessageIter iter;
|
const char *address, *name;
|
|
if (g_dbus_proxy_get_property(proxy, "Address", &iter) == FALSE)
|
return;
|
|
dbus_message_iter_get_basic(&iter, &address);
|
|
if (g_dbus_proxy_get_property(proxy, "Alias", &iter) == TRUE)
|
dbus_message_iter_get_basic(&iter, &name);
|
else
|
name = "<unknown>";
|
|
pr_info("%s%s%sController %s %s %s\n",
|
description ? "[" : "",
|
description ? : "",
|
description ? "] " : "",
|
address, name,
|
default_ctrl &&
|
default_ctrl->proxy == proxy ?
|
"[default]" : "");
|
|
}
|
|
static void btsrc_scan_save_device(GDBusProxy *proxy, BtScanParam *param)
|
{
|
DBusMessageIter iter;
|
const char *address, *name;
|
BtDeviceInfo *device_info = NULL;
|
size_t cplen = 0;
|
|
if (g_dbus_proxy_get_property(proxy, "Address", &iter) == FALSE)
|
return;
|
|
dbus_message_iter_get_basic(&iter, &address);
|
|
if (g_dbus_proxy_get_property(proxy, "Alias", &iter) == TRUE)
|
dbus_message_iter_get_basic(&iter, &name);
|
else
|
name = "<unknown>";
|
|
if (param && (param->item_cnt < BT_SOURCE_SCAN_DEVICES_CNT)) {
|
device_info = &(param->devices[param->item_cnt]);
|
memset(device_info, 0, sizeof(BtDeviceInfo));
|
cplen = sizeof(device_info->name);
|
cplen = (strlen(name) > cplen) ? cplen : strlen(name);
|
memcpy(device_info->name, name, cplen);
|
memcpy(device_info->address, address, sizeof(device_info->address));
|
param->item_cnt++;
|
}
|
}
|
|
static void print_device(GDBusProxy *proxy, const char *description)
|
{
|
DBusMessageIter iter;
|
const char *address, *name;
|
|
if (g_dbus_proxy_get_property(proxy, "Address", &iter) == FALSE) {
|
pr_info("%s: can't get Address\n", __func__);
|
return;
|
}
|
|
dbus_message_iter_get_basic(&iter, &address);
|
|
if (g_dbus_proxy_get_property(proxy, "Alias", &iter) == TRUE)
|
dbus_message_iter_get_basic(&iter, &name);
|
else
|
name = "<unknown>";
|
|
printf("%s%s%sDevice %s %s\n",
|
description ? "[" : "",
|
description ? : "",
|
description ? "] " : "",
|
address, name);
|
}
|
|
void print_fixed_iter(const char *label, const char *name,
|
DBusMessageIter *iter)
|
{
|
dbus_bool_t *valbool;
|
dbus_uint32_t *valu32;
|
dbus_uint16_t *valu16;
|
dbus_int16_t *vals16;
|
unsigned char *byte;
|
int len;
|
|
switch (dbus_message_iter_get_arg_type(iter)) {
|
case DBUS_TYPE_BOOLEAN:
|
dbus_message_iter_get_fixed_array(iter, &valbool, &len);
|
|
if (len <= 0)
|
return;
|
|
pr_info("%s%s:\n", label, name);
|
bt_shell_hexdump((void *)valbool, len * sizeof(*valbool));
|
|
break;
|
case DBUS_TYPE_UINT32:
|
dbus_message_iter_get_fixed_array(iter, &valu32, &len);
|
|
if (len <= 0)
|
return;
|
|
pr_info("%s%s:\n", label, name);
|
bt_shell_hexdump((void *)valu32, len * sizeof(*valu32));
|
|
break;
|
case DBUS_TYPE_UINT16:
|
dbus_message_iter_get_fixed_array(iter, &valu16, &len);
|
|
if (len <= 0)
|
return;
|
|
pr_info("%s%s:\n", label, name);
|
bt_shell_hexdump((void *)valu16, len * sizeof(*valu16));
|
|
break;
|
case DBUS_TYPE_INT16:
|
dbus_message_iter_get_fixed_array(iter, &vals16, &len);
|
|
if (len <= 0)
|
return;
|
|
pr_info("%s%s:\n", label, name);
|
bt_shell_hexdump((void *)vals16, len * sizeof(*vals16));
|
|
break;
|
case DBUS_TYPE_BYTE:
|
dbus_message_iter_get_fixed_array(iter, &byte, &len);
|
|
if (len <= 0)
|
return;
|
|
pr_info("%s%s:\n", label, name);
|
bt_shell_hexdump((void *)byte, len * sizeof(*byte));
|
|
break;
|
default:
|
return;
|
};
|
}
|
|
void print_iter(const char *label, const char *name,
|
DBusMessageIter *iter)
|
{
|
dbus_bool_t valbool;
|
dbus_uint32_t valu32;
|
dbus_uint16_t valu16;
|
dbus_int16_t vals16;
|
unsigned char byte;
|
const char *valstr;
|
DBusMessageIter subiter;
|
char *entry;
|
|
if (iter == NULL) {
|
pr_info("%s%s is nil\n", label, name);
|
return;
|
}
|
|
switch (dbus_message_iter_get_arg_type(iter)) {
|
case DBUS_TYPE_INVALID:
|
pr_info("%s%s is invalid\n", label, name);
|
break;
|
case DBUS_TYPE_STRING:
|
case DBUS_TYPE_OBJECT_PATH:
|
dbus_message_iter_get_basic(iter, &valstr);
|
pr_info("%s%s: %s\n", label, name, valstr);
|
if (!strncmp(name, "Status", 6)) {
|
if (strstr(valstr, "playing"))
|
report_avrcp_event(BT_EVENT_START_PLAY, NULL, 0);
|
else if (strstr(valstr, "paused"))
|
report_avrcp_event(BT_EVENT_PAUSE_PLAY, NULL, 0);
|
else if (strstr(valstr, "stopped"))
|
report_avrcp_event(BT_EVENT_STOP_PLAY, NULL, 0);
|
}
|
break;
|
case DBUS_TYPE_BOOLEAN:
|
dbus_message_iter_get_basic(iter, &valbool);
|
pr_info("%s%s: %s\n", label, name,
|
valbool == TRUE ? "yes" : "no");
|
break;
|
case DBUS_TYPE_UINT32:
|
dbus_message_iter_get_basic(iter, &valu32);
|
pr_info("%s%s: 0x%08x\n", label, name, valu32);
|
break;
|
case DBUS_TYPE_UINT16:
|
dbus_message_iter_get_basic(iter, &valu16);
|
pr_info("%s%s: 0x%04x\n", label, name, valu16);
|
break;
|
case DBUS_TYPE_INT16:
|
dbus_message_iter_get_basic(iter, &vals16);
|
pr_info("%s%s: %d\n", label, name, vals16);
|
break;
|
case DBUS_TYPE_BYTE:
|
dbus_message_iter_get_basic(iter, &byte);
|
pr_info("%s%s: 0x%02x\n", label, name, byte);
|
break;
|
case DBUS_TYPE_VARIANT:
|
dbus_message_iter_recurse(iter, &subiter);
|
print_iter(label, name, &subiter);
|
break;
|
case DBUS_TYPE_ARRAY:
|
dbus_message_iter_recurse(iter, &subiter);
|
|
if (dbus_type_is_fixed(
|
dbus_message_iter_get_arg_type(&subiter))) {
|
print_fixed_iter(label, name, &subiter);
|
break;
|
}
|
|
while (dbus_message_iter_get_arg_type(&subiter) !=
|
DBUS_TYPE_INVALID) {
|
print_iter(label, name, &subiter);
|
dbus_message_iter_next(&subiter);
|
}
|
break;
|
case DBUS_TYPE_DICT_ENTRY:
|
dbus_message_iter_recurse(iter, &subiter);
|
entry = g_strconcat(name, " Key", NULL);
|
print_iter(label, entry, &subiter);
|
g_free(entry);
|
|
entry = g_strconcat(name, " Value", NULL);
|
dbus_message_iter_next(&subiter);
|
print_iter(label, entry, &subiter);
|
g_free(entry);
|
break;
|
default:
|
pr_info("%s%s has unsupported type\n", label, name);
|
break;
|
}
|
}
|
|
void print_property(GDBusProxy *proxy, const char *name)
|
{
|
DBusMessageIter iter;
|
|
if (g_dbus_proxy_get_property(proxy, name, &iter) == FALSE)
|
return;
|
|
print_iter("\t", name, &iter);
|
}
|
|
static void print_uuid(const char *uuid)
|
{
|
const char *text;
|
|
text = bt_uuidstr_to_str(uuid);
|
if (text) {
|
char str[26];
|
unsigned int n;
|
|
str[sizeof(str) - 1] = '\0';
|
|
n = snprintf(str, sizeof(str), "%s", text);
|
if (n > sizeof(str) - 1) {
|
str[sizeof(str) - 2] = '.';
|
str[sizeof(str) - 3] = '.';
|
if (str[sizeof(str) - 4] == ' ')
|
str[sizeof(str) - 4] = '.';
|
|
n = sizeof(str) - 1;
|
}
|
|
pr_info("\tUUID: %s%*c(%s)\n", str, 26 - n, ' ', uuid);
|
} else
|
pr_info("\tUUID: %*c(%s)\n", 26, ' ', uuid);
|
}
|
|
static void print_uuids(GDBusProxy *proxy)
|
{
|
DBusMessageIter iter, value;
|
|
if (g_dbus_proxy_get_property(proxy, "UUIDs", &iter) == FALSE)
|
return;
|
|
dbus_message_iter_recurse(&iter, &value);
|
|
while (dbus_message_iter_get_arg_type(&value) == DBUS_TYPE_STRING) {
|
const char *uuid;
|
|
dbus_message_iter_get_basic(&value, &uuid);
|
|
print_uuid(uuid);
|
|
dbus_message_iter_next(&value);
|
}
|
}
|
|
static gboolean device_is_child(GDBusProxy *device, GDBusProxy *master)
|
{
|
DBusMessageIter iter;
|
const char *adapter, *path;
|
|
if (!master)
|
return FALSE;
|
|
if (g_dbus_proxy_get_property(device, "Adapter", &iter) == FALSE)
|
return FALSE;
|
|
dbus_message_iter_get_basic(&iter, &adapter);
|
path = g_dbus_proxy_get_path(master);
|
|
if (!strcmp(path, adapter))
|
return TRUE;
|
|
return FALSE;
|
}
|
|
static GDBusProxy * service_is_child(GDBusProxy *service)
|
{
|
DBusMessageIter iter;
|
const char *device;
|
|
if (g_dbus_proxy_get_property(service, "Device", &iter) == FALSE)
|
return NULL;
|
|
dbus_message_iter_get_basic(&iter, &device);
|
|
if (!default_ctrl)
|
return NULL;
|
|
return g_dbus_proxy_lookup(default_ctrl->devices, NULL, device,
|
"org.bluez.Device1");
|
}
|
|
static struct adapter *find_parent(GDBusProxy *device)
|
{
|
GList *list;
|
|
for (list = g_list_first(ctrl_list); list; list = g_list_next(list)) {
|
struct adapter *adapter = (struct adapter *)list->data;
|
|
if (device_is_child(device, adapter->proxy) == TRUE)
|
return adapter;
|
}
|
return NULL;
|
}
|
|
#define SERVER_CLASS_TELEPHONY (1U << (22))
|
#define SERVER_CLASS_AUDIO (1U << (21))
|
#define DEVICE_CLASS_SHIFT 8
|
#define DEVICE_CLASS_MASK 0x3f
|
#define DEVICE_CLASS_PHONE 2
|
#define DEVICE_CLASS_AUDIO 4
|
|
enum BT_Device_Class dist_dev_class(GDBusProxy *proxy)
|
{
|
DBusMessageIter iter;
|
const char *address_type = NULL;
|
const char *address = NULL;
|
const char *alias = NULL;
|
dbus_uint32_t cod;
|
|
if (g_dbus_proxy_get_property(proxy, "AddressType", &iter)) {
|
dbus_message_iter_get_basic(&iter, &address_type);
|
pr_info("%s addressType:%s\n", __func__, address_type);
|
|
if (g_dbus_proxy_get_property(proxy, "Alias", &iter)) {
|
dbus_message_iter_get_basic(&iter, &alias);
|
pr_info("%s Alias: %s\n", __func__, alias);
|
}
|
|
if (g_dbus_proxy_get_property(proxy, "Address", &iter)) {
|
dbus_message_iter_get_basic(&iter, &address);
|
pr_info("%s address: %s\n", __func__, address);
|
}
|
|
if (!strcmp(address_type, "random")) {
|
pr_info("%s The device is ble(random)\n", __func__);
|
return BT_BLE_DEVICE;
|
}
|
|
if (!strcmp(address_type, "public")) {
|
if (g_dbus_proxy_get_property(proxy, "Class", &iter) == FALSE) {
|
pr_info("%s The device is ble(public)\n", __func__);
|
return BT_BLE_DEVICE;
|
} else {
|
bool is_phone, is_audio;
|
|
dbus_message_iter_get_basic(&iter, &cod);
|
pr_info("%s class: 0x%x\n", __func__, cod);
|
|
is_phone = ((cod >> DEVICE_CLASS_SHIFT) & DEVICE_CLASS_MASK) == DEVICE_CLASS_PHONE ? true : false;
|
is_audio = ((cod >> DEVICE_CLASS_SHIFT) & DEVICE_CLASS_MASK) == DEVICE_CLASS_AUDIO ? true : false;
|
|
if ((cod & SERVER_CLASS_TELEPHONY) && is_phone) {
|
pr_info("%s The device is source\n", __func__);
|
return BT_SOURCE_DEVICE;
|
}
|
|
if ((cod & SERVER_CLASS_AUDIO) && is_audio) {
|
pr_info("%s The device is sink\n", __func__);
|
return BT_SINK_DEVICE;
|
}
|
|
if (is_phone || is_audio) {
|
DBusMessageIter value;
|
const char *text;
|
char str[26];
|
unsigned int n;
|
const char *uuid;
|
enum BT_Device_Class ret = BT_IDLE;
|
|
if (g_dbus_proxy_get_property(proxy, "UUIDs", &iter) == FALSE)
|
return BT_IDLE;
|
|
dbus_message_iter_recurse(&iter, &value);
|
|
while (dbus_message_iter_get_arg_type(&value) == DBUS_TYPE_STRING) {
|
dbus_message_iter_get_basic(&value, &uuid);
|
|
text = bt_uuidstr_to_str(uuid);
|
if (text) {
|
str[sizeof(str) - 1] = '\0';
|
|
n = snprintf(str, sizeof(str), "%s", text);
|
if (n > sizeof(str) - 1) {
|
str[sizeof(str) - 2] = '.';
|
str[sizeof(str) - 3] = '.';
|
if (str[sizeof(str) - 4] == ' ')
|
str[sizeof(str) - 4] = '.';
|
|
n = sizeof(str) - 1;
|
}
|
|
if (strstr(str, "Audio Sink")) {
|
ret = BT_SINK_DEVICE;
|
pr_info("%s The device is sink\n", __func__);
|
break;
|
} else if (strstr(str, "Audio Source")) {
|
ret = BT_SOURCE_DEVICE;
|
pr_info("%s The device is source\n", __func__);
|
break;
|
}
|
}
|
|
dbus_message_iter_next(&value);
|
}
|
|
return ret;
|
}
|
}
|
}
|
}
|
|
pr_info("%s The device is unknow\n", __func__);
|
return BT_IDLE;
|
}
|
|
static void set_default_device(GDBusProxy *proxy, const char *attribute)
|
{
|
char *desc = NULL;
|
DBusMessageIter iter;
|
const char *path;
|
|
pr_info("%s: proxy is %s\n", __func__, proxy ? "non-null" : "null");
|
pr_info("%s: default_dev %p, proxy: %p\n", __func__, default_dev, proxy);
|
|
if ((proxy != NULL) && (default_dev != NULL) && (default_dev != proxy)) {
|
pr_info("check proxy: ref: %d:%d\n", *((unsigned int *)proxy), *((unsigned int *)default_dev));
|
return;
|
}
|
|
default_dev = proxy;
|
|
if (proxy == NULL) {
|
default_attr = NULL;
|
goto done;
|
}
|
|
save_last_device(proxy);
|
|
if (!g_dbus_proxy_get_property(proxy, "Alias", &iter)) {
|
if (!g_dbus_proxy_get_property(proxy, "Address", &iter))
|
goto done;
|
}
|
|
path = g_dbus_proxy_get_path(proxy);
|
|
dbus_message_iter_get_basic(&iter, &desc);
|
desc = g_strdup_printf(COLOR_BLUE "[%s%s%s]" COLOR_OFF "# ", desc,
|
attribute ? ":" : "",
|
attribute ? attribute + strlen(path) : "");
|
done:
|
bt_shell_set_prompt(desc ? desc : PROMPT_ON);
|
g_free(desc);
|
}
|
|
static void ble_connected_handler(GDBusProxy *proxy)
|
{
|
if(!ble_is_open()) {
|
pr_info("%s: ble is close\n", __func__);
|
return;
|
}
|
|
if(ble_dev) {
|
pr_info("%s: ble connection already exists\n", __func__);
|
return;
|
}
|
|
ble_dev = proxy;
|
pr_info("%s: ble_dev = %p\n", __func__, ble_dev);
|
ble_state_send(RK_BLE_STATE_CONNECT);
|
}
|
|
static void ble_disconnect_handler()
|
{
|
if(!ble_is_open()) {
|
pr_info("%s: ble is close\n", __func__);
|
return;
|
}
|
|
if(!ble_dev) {
|
pr_info("%s: ble_dev is NULL\n", __func__);
|
return;
|
}
|
|
ble_state_send(RK_BLE_STATE_DISCONNECT);
|
|
ble_dev = NULL;
|
ble_service_cnt = 0;
|
pr_info("%s: ble disconneced\n", __func__);
|
gatt_set_on_adv();
|
}
|
|
static void device_added(GDBusProxy *proxy)
|
{
|
DBusMessageIter iter;
|
struct adapter *adapter = find_parent(proxy);
|
char dev_addr[18], dev_name[256];
|
dbus_bool_t paired = FALSE;
|
dbus_bool_t connected = FALSE;
|
enum BT_Device_Class bdc;
|
|
if (!adapter) {
|
/* TODO: Error */
|
return;
|
}
|
|
adapter->devices = g_list_append(adapter->devices, proxy);
|
//print_device(proxy, COLORED_NEW);
|
bt_shell_set_env(g_dbus_proxy_get_path(proxy), proxy);
|
pr_info("%s: path: %s\n", __func__, g_dbus_proxy_get_path(proxy));
|
|
bt_dev_found_send(proxy);
|
|
if (g_dbus_proxy_get_property(proxy, "Connected", &iter))
|
dbus_message_iter_get_basic(&iter, &connected);
|
|
bdc = dist_dev_class(proxy);
|
if(bdc == BT_SINK_DEVICE || bdc == BT_SOURCE_DEVICE) {
|
if (g_dbus_proxy_get_property(proxy, "Paired", &iter) == TRUE) {
|
dbus_message_iter_get_basic(&iter, &paired);
|
if (!paired && connected) {
|
bt_get_device_addr_by_proxy(proxy, dev_addr, 18);
|
bt_get_device_name_by_proxy(proxy, dev_name, 256);
|
bt_bond_state_send(dev_addr, dev_name, RK_BT_BOND_STATE_BONDING);
|
}
|
}
|
|
if (default_dev)
|
return;
|
|
if (connected)
|
set_default_device(proxy, NULL);
|
} else {
|
if(connected)
|
ble_connected_handler(proxy);
|
}
|
}
|
|
static struct adapter *find_ctrl(GList *source, const char *path);
|
|
static struct adapter *adapter_new(GDBusProxy *proxy)
|
{
|
struct adapter *adapter = (struct adapter *)g_malloc0(sizeof(struct adapter));
|
pr_info("=== %s ===\n", __func__);
|
|
ctrl_list = g_list_append(ctrl_list, adapter);
|
|
if (!default_ctrl)
|
default_ctrl = adapter;
|
|
return adapter;
|
}
|
|
static void adapter_added(GDBusProxy *proxy)
|
{
|
struct adapter *adapter;
|
char hostname_buf[HOSTNAME_MAX_LEN];
|
|
pr_info("=== %s ===\n", __func__);
|
|
adapter = find_ctrl(ctrl_list, g_dbus_proxy_get_path(proxy));
|
if (!adapter)
|
adapter = adapter_new(proxy);
|
|
adapter->proxy = proxy;
|
print_adapter(proxy, COLORED_NEW);
|
|
check_open:
|
if(!bt_is_open()) {
|
usleep(20 * 1000);
|
goto check_open;
|
}
|
|
if (g_bt_content && g_bt_content->bt_name) {
|
pr_info("%s: bt_name: %s\n", __func__, g_bt_content->bt_name);
|
rk_bt_set_device_name(g_bt_content->bt_name);
|
} else {
|
bt_gethostname(hostname_buf, sizeof(hostname_buf));
|
pr_info("%s: bt_name: %s\n", __func__, hostname_buf);
|
rk_bt_set_device_name(hostname_buf);
|
}
|
|
msleep(50);
|
exec_command_system("hciconfig hci0 piscan");
|
|
//bt_state_send(RK_BT_STATE_ON);
|
|
pr_info("%s: bt check open ok\n", __func__);
|
}
|
|
static void ad_manager_added(GDBusProxy *proxy)
|
{
|
struct adapter *adapter;
|
adapter = find_ctrl(ctrl_list, g_dbus_proxy_get_path(proxy));
|
if (!adapter)
|
adapter = adapter_new(proxy);
|
|
adapter->ad_proxy = proxy;
|
}
|
|
static void le_proxy_added(GDBusProxy *proxy)
|
{
|
enum BT_Device_Class bdc;
|
|
if(!ble_is_open())
|
return;
|
|
bdc = dist_dev_class(proxy);
|
//if(bdc == BT_SINK_DEVICE || bdc == BT_SOURCE_DEVICE) {
|
// pr_info("%s: bdc(%d) != ble\n", __func__, bdc);
|
// return;
|
//}
|
|
pr_info("%s: ble_service_cnt = %d\n", __func__, ble_service_cnt);
|
if (ble_service_cnt == 0) {
|
if(!ble_dev) {
|
ble_dev = proxy;
|
ble_state_send(RK_BLE_STATE_CONNECT);
|
pr_info("%s: ble conneced, ble_dev = %p\n", __func__, ble_dev);
|
}
|
}
|
|
ble_service_cnt++;
|
}
|
|
static void proxy_added(GDBusProxy *proxy, void *user_data)
|
{
|
const char *interface;
|
|
interface = g_dbus_proxy_get_interface(proxy);
|
pr_info("BT Enter: proxy_added: %s\n", interface);
|
|
if (!strcmp(interface, "org.bluez.Device1")) {
|
device_added(proxy);
|
} else if (!strcmp(interface, "org.bluez.Adapter1")) {
|
adapter_added(proxy);
|
} else if (!strcmp(interface, "org.bluez.AgentManager1")) {
|
if (!agent_manager) {
|
agent_manager = proxy;
|
|
if (auto_register_agent &&
|
!bt_shell_get_env("NON_INTERACTIVE")) {
|
agent_register(dbus_conn, agent_manager,
|
auto_register_agent);
|
}
|
}
|
} else if (!strcmp(interface, "org.bluez.GattService1")) {
|
GDBusProxy *le_proxy = service_is_child(proxy);
|
if (le_proxy != NULL) {
|
gatt_add_service(proxy);
|
le_proxy_added(le_proxy);
|
}
|
} else if (!strcmp(interface, "org.bluez.GattCharacteristic1")) {
|
gatt_add_characteristic(proxy);
|
} else if (!strcmp(interface, "org.bluez.GattDescriptor1")) {
|
gatt_add_descriptor(proxy);
|
} else if (!strcmp(interface, "org.bluez.GattManager1")) {
|
//gatt_add_manager(proxy);
|
register_app(proxy);
|
} else if (!strcmp(interface, "org.bluez.LEAdvertisingManager1")) {
|
ad_manager_added(proxy);
|
} else if (!strcmp(interface, "org.bluez.MediaTransport1")) {
|
a2dp_master_event_send(BT_SOURCE_EVENT_CONNECTED, rsd.addr, rsd.name);
|
a2dp_master_save_status(rsd.addr);
|
}
|
|
if (bt_sink_is_open()) {
|
if ((!strcmp(interface, "org.bluez.MediaPlayer1")) ||
|
(!strcmp(interface, "org.bluez.MediaFolder1")) ||
|
(!strcmp(interface, "org.bluez.MediaItem1")))
|
a2dp_sink_proxy_added(proxy, user_data);
|
|
if (!strcmp(interface, "org.bluez.Device1")) {
|
if ((dist_dev_class(proxy) == BT_SOURCE_DEVICE))
|
a2dp_sink_proxy_added(proxy, user_data);
|
}
|
|
if (!strcmp(interface, "org.bluez.Adapter1")) {
|
a2dp_sink_proxy_added(proxy, user_data);
|
}
|
}
|
|
pr_info("BT Exit: proxy_added: %s\n", interface);
|
}
|
|
void set_default_attribute(GDBusProxy *proxy)
|
{
|
//const char *path;
|
|
default_attr = proxy;
|
|
//path = g_dbus_proxy_get_path(proxy);
|
|
//set_default_device(default_dev, path);
|
}
|
|
static void device_removed(GDBusProxy *proxy)
|
{
|
char dev_addr[18], dev_name[256];
|
dbus_bool_t paired;
|
DBusMessageIter iter;
|
|
pr_info("%s: path: %s\n", __func__, g_dbus_proxy_get_path(proxy));
|
struct adapter *adapter = (struct adapter *)find_parent(proxy);
|
if (!adapter) {
|
pr_info("%s: adapter is NULL\n", __func__);
|
/* TODO: Error */
|
return;
|
}
|
|
if (g_dbus_proxy_get_property(proxy, "Paired", &iter) == TRUE) {
|
dbus_message_iter_get_basic(&iter, &paired);
|
if (paired) {
|
bt_get_device_addr_by_proxy(proxy, dev_addr, 18);
|
bt_get_device_name_by_proxy(proxy, dev_name, 256);
|
pr_info("%s: addr: %s, name: %s [%d]\n", __func__, dev_addr, dev_name, paired);
|
bt_bond_state_send(dev_addr, dev_name, RK_BT_BOND_STATE_NONE);
|
}
|
}
|
|
adapter->devices = g_list_remove(adapter->devices, proxy);
|
|
//print_device(proxy, COLORED_DEL);
|
bt_shell_set_env(g_dbus_proxy_get_path(proxy), NULL);
|
|
if (default_dev == proxy)
|
set_default_device(NULL, NULL);
|
else if(ble_dev == proxy)
|
ble_disconnect_handler();
|
}
|
|
static void adapter_removed(GDBusProxy *proxy)
|
{
|
GList *ll;
|
|
for (ll = g_list_first(ctrl_list); ll; ll = g_list_next(ll)) {
|
struct adapter *adapter = (struct adapter *)ll->data;
|
|
if (adapter->proxy == proxy) {
|
print_adapter(proxy, COLORED_DEL);
|
bt_shell_set_env(g_dbus_proxy_get_path(proxy), NULL);
|
|
if (default_ctrl && default_ctrl->proxy == proxy) {
|
default_ctrl = NULL;
|
set_default_device(NULL, NULL);
|
}
|
|
ctrl_list = g_list_remove_link(ctrl_list, ll);
|
g_list_free(adapter->devices);
|
g_free(adapter);
|
g_list_free(ll);
|
return;
|
}
|
}
|
}
|
|
static void le_proxy_removed(GDBusProxy *proxy)
|
{
|
char *proxy_path, *ble_dev_path;
|
|
if(!ble_is_open())
|
return;
|
|
if(!ble_dev) {
|
pr_info("%s: ble_dev == NULL\n", __func__);
|
return;
|
}
|
|
proxy_path = g_dbus_proxy_get_path(proxy);
|
ble_dev_path = g_dbus_proxy_get_path(ble_dev);
|
if(!g_str_has_prefix(proxy_path, ble_dev_path)) {
|
pr_info("%s: proxy_path = %s, ble_dev_path = %s\n", __func__, proxy_path, ble_dev_path);
|
return;
|
}
|
|
ble_service_cnt--;
|
pr_info("%s: ble_service_cnt = %d\n", __func__, ble_service_cnt);
|
if (ble_service_cnt == 0) {
|
ble_disconnect_handler();
|
ble_dev = NULL;
|
}
|
}
|
|
static void proxy_removed(GDBusProxy *proxy, void *user_data)
|
{
|
const char *interface;
|
|
interface = g_dbus_proxy_get_interface(proxy);
|
pr_info("BT Enter: proxy_removed: %s\n", interface);
|
pr_info("%s: path: %s\n", __func__, g_dbus_proxy_get_path(proxy));
|
|
if (!strcmp(interface, "org.bluez.Device1")) {
|
device_removed(proxy);
|
} else if (!strcmp(interface, "org.bluez.Adapter1")) {
|
adapter_removed(proxy);
|
} else if (!strcmp(interface, "org.bluez.AgentManager1")) {
|
if (agent_manager == proxy) {
|
agent_manager = NULL;
|
if (auto_register_agent) {
|
agent_unregister(dbus_conn, NULL);
|
}
|
}
|
} else if (!strcmp(interface, "org.bluez.GattService1")) {
|
gatt_remove_service(proxy);
|
|
if (default_attr == proxy)
|
set_default_attribute(NULL);
|
|
le_proxy_removed(proxy);
|
} else if (!strcmp(interface, "org.bluez.GattCharacteristic1")) {
|
gatt_remove_characteristic(proxy);
|
|
if (default_attr == proxy)
|
set_default_attribute(NULL);
|
} else if (!strcmp(interface, "org.bluez.GattDescriptor1")) {
|
gatt_remove_descriptor(proxy);
|
|
if (default_attr == proxy)
|
set_default_attribute(NULL);
|
} else if (!strcmp(interface, "org.bluez.GattManager1")) {
|
//gatt_remove_manager(proxy);
|
unregister_app(proxy);
|
} else if (!strcmp(interface, "org.bluez.LEAdvertisingManager1")) {
|
ad_unregister(dbus_conn, NULL);
|
} else if (!strcmp(interface, "org.bluez.MediaTransport1")) {
|
//a2dp_master_save_status(NULL);
|
//a2dp_master_event_send(BT_SOURCE_EVENT_DISCONNECTED, NULL, NULL);
|
}
|
|
if (bt_sink_is_open())
|
a2dp_sink_proxy_removed(proxy, user_data);
|
pr_info("BT Exit: proxy_removed: %s\n", interface);
|
}
|
|
static struct adapter *find_ctrl(GList *source, const char *path)
|
{
|
GList *list;
|
|
for (list = g_list_first(source); list; list = g_list_next(list)) {
|
struct adapter *adapter = (struct adapter *)list->data;
|
|
if (!strcasecmp(g_dbus_proxy_get_path(adapter->proxy), path))
|
return adapter;
|
}
|
|
return NULL;
|
}
|
|
static void device_paired_process(GDBusProxy *proxy,
|
DBusMessageIter *iter, char *dev_addr)
|
{
|
dbus_bool_t valbool = FALSE;
|
char dev_name[256];
|
|
bt_get_device_name_by_proxy(proxy, dev_name, 256);
|
|
dbus_message_iter_get_basic(iter, &valbool);
|
if(valbool)
|
bt_bond_state_send(dev_addr, dev_name, RK_BT_BOND_STATE_BONDED);
|
else
|
bt_bond_state_send(dev_addr, dev_name, RK_BT_BOND_STATE_NONE);
|
}
|
|
static void source_connected_handler(GDBusProxy *proxy, enum BT_Device_Class bdc, dbus_bool_t connected)
|
{
|
DBusMessageIter iter;
|
DBusMessageIter addr_iter;
|
const char *address = NULL;
|
const char *name = NULL;
|
|
if (!bt_source_is_open() || bdc != BT_SINK_DEVICE)
|
return;
|
|
if (g_dbus_proxy_get_property(proxy, "Alias", &iter) == TRUE)
|
dbus_message_iter_get_basic(&iter, &name);
|
else
|
pr_info("%s: can't get remote device name\n", __func__);
|
|
if (g_dbus_proxy_get_property(proxy, "Address", &addr_iter) == TRUE)
|
dbus_message_iter_get_basic(&addr_iter, &address);
|
else
|
pr_info("%s: can't get remote device address\n", __func__);
|
|
pr_info("%s thread tid = %lu\n", __func__, pthread_self());
|
memset(&rsd, 0, sizeof(struct remote_sink_device));
|
strcpy(rsd.addr, address);
|
strcpy(rsd.name, name);
|
|
pr_info("%s: connected: %d, rsd addr: %s, name: %s.\n", __func__, connected, rsd.addr, rsd.name);
|
|
if ((connected == FALSE) && (g_device_state == BT_SOURCE_EVENT_CONNECTED)) {
|
a2dp_master_save_status(NULL);
|
a2dp_master_event_send(BT_SOURCE_EVENT_DISCONNECTED, address, name);
|
}
|
}
|
|
static void ble_client_connected_handler(GDBusProxy *proxy, dbus_bool_t connected)
|
{
|
if(!ble_client_is_open())
|
return;
|
|
if(connected) {
|
if(ble_dev) {
|
pr_info("%s: ble connection already exists\n", __func__);
|
return;
|
}
|
|
ble_dev = proxy;
|
gatt_client_state_send(RK_BLE_CLIENT_STATE_CONNECT);
|
pr_info("%s: ble client conneced, ble_dev = %p\n", __func__, ble_dev);
|
} else {
|
if(!ble_dev) {
|
pr_info("%s: ble_dev is NULL\n", __func__);
|
return;
|
}
|
|
if(ble_dev != proxy) {
|
pr_info("%s: ble_dev(%p) != proxy(%p)\n", __func__, ble_dev, proxy);
|
return;
|
}
|
|
gatt_client_state_send(RK_BLE_CLIENT_STATE_DISCONNECT);
|
ble_dev = NULL;
|
pr_info("%s: ble client disconneced\n", __func__);
|
}
|
}
|
|
static void device_connected_handler(GDBusProxy *proxy,
|
DBusMessageIter *iter, void *user_data)
|
{
|
dbus_bool_t connected = false;
|
enum BT_Device_Class bdc;
|
|
dbus_message_iter_get_basic(iter, &connected);
|
|
bdc = dist_dev_class(proxy);
|
if(bdc == BT_SOURCE_DEVICE || bdc == BT_SINK_DEVICE) {
|
if (connected && default_dev == NULL)
|
set_default_device(proxy, NULL);
|
else if (!connected && default_dev == proxy)
|
set_default_device(NULL, NULL);
|
|
source_connected_handler(proxy, bdc, connected);
|
|
//bt_sink
|
if (bt_sink_is_open() && bdc == BT_SOURCE_DEVICE)
|
device_changed(proxy, iter, user_data);
|
} else if(bdc == BT_BLE_DEVICE) {
|
if(ble_is_open()) {
|
if(connected) {
|
ble_connected_handler(proxy);
|
return;
|
}
|
|
if(ble_dev != proxy)
|
pr_info("%s: ble_dev(%p) != proxy(%p)\n", __func__, ble_dev, proxy);
|
|
if(!connected && ble_dev == proxy) {
|
const char *type = NULL;
|
|
if (g_dbus_proxy_get_property(proxy, "AddressType", iter)) {
|
dbus_message_iter_get_basic(iter, &type);
|
pr_info("%s: AddressType = %s\n", __func__, type);
|
if(!strcmp(type, "public"))
|
remove_device(proxy);
|
}
|
}
|
} else {
|
ble_client_connected_handler(proxy, connected);
|
}
|
}
|
}
|
|
static void source_reconnect_handler(GDBusProxy *proxy, char *dev_addr)
|
{
|
pthread_t tid;
|
enum BT_Device_Class cod;
|
|
if(!g_bt_source_info.is_reconnected)
|
return;
|
|
if(!strcmp(g_bt_source_info.reconnect_address, dev_addr)) {
|
cod = dist_dev_class(proxy);
|
if(cod != BT_SINK_DEVICE) {
|
pr_info("%s: find reconnect device(%s), but cod(%d) != sink\n", __func__, dev_addr, cod);
|
return;
|
}
|
|
source_set_reconnect_tag(false);
|
pr_info("%s: reconnect device = %s\n", __func__, dev_addr);
|
a2dp_master_event_send(BT_SOURCE_EVENT_AUTO_RECONNECTING, dev_addr, dev_addr);
|
a2dp_master_connect(dev_addr);
|
}
|
}
|
|
static void source_avrcp_keycode_handler(GDBusProxy *proxy, DBusMessageIter *iter)
|
{
|
dbus_uint32_t keycode;
|
|
dbus_message_iter_get_basic(iter, &keycode);
|
switch(keycode) {
|
case AVC_PLAY:
|
a2dp_master_event_send(BT_SOURCE_EVENT_RC_PLAY, NULL, NULL);
|
break;
|
case AVC_PAUSE:
|
a2dp_master_event_send(BT_SOURCE_EVENT_RC_PAUSE, NULL, NULL);
|
break;
|
case AVC_STOP:
|
a2dp_master_event_send(BT_SOURCE_EVENT_RC_STOP, NULL, NULL);
|
break;
|
case AVC_VOLUME_UP:
|
a2dp_master_event_send(BT_SOURCE_EVENT_RC_VOL_UP, NULL, NULL);
|
break;
|
case AVC_VOLUME_DOWN:
|
a2dp_master_event_send(BT_SOURCE_EVENT_RC_VOL_DOWN, NULL, NULL);
|
break;
|
case AVC_FORWARD:
|
a2dp_master_event_send(BT_SOURCE_EVENT_RC_FORWARD, NULL, NULL);
|
break;
|
case AVC_BACKWARD:
|
a2dp_master_event_send(BT_SOURCE_EVENT_RC_BACKWARD, NULL, NULL);
|
break;
|
default:
|
break;
|
}
|
}
|
|
static void property_changed(GDBusProxy *proxy, const char *name,
|
DBusMessageIter *iter, void *user_data)
|
{
|
const char *interface;
|
struct adapter *ctrl;
|
|
interface = g_dbus_proxy_get_interface(proxy);
|
pr_info("BT Enter: property_changed: %s\n", interface);
|
|
if (!strcmp(interface, "org.bluez.Device1")) {
|
if (default_ctrl && device_is_child(proxy,
|
default_ctrl->proxy) == TRUE) {
|
DBusMessageIter addr_iter;
|
char *str;
|
char dev_addr[18];
|
|
bt_get_device_addr_by_proxy(proxy, dev_addr, 18);
|
|
if (strcmp(name, "Paired") == 0)
|
device_paired_process(proxy, iter, dev_addr);
|
|
if (strcmp(name, "Connected") == 0)
|
device_connected_handler(proxy, iter, user_data);
|
|
if(strcmp(name, "RSSI") == 0)
|
source_reconnect_handler(proxy, dev_addr);
|
|
if(strcmp(name, "Alias") == 0)
|
bt_name_change_send(proxy);
|
|
if(strcmp(name, "MTU") == 0)
|
ble_mtu_exchange_send(proxy);
|
}
|
} else if (!strcmp(interface, "org.bluez.Adapter1")) {
|
DBusMessageIter addr_iter;
|
char *str;
|
|
if (g_dbus_proxy_get_property(proxy, "Address",
|
&addr_iter) == TRUE) {
|
const char *address;
|
|
dbus_message_iter_get_basic(&addr_iter, &address);
|
str = g_strdup_printf("[" COLORED_CHG
|
"] Controller %s ", address);
|
} else
|
str = g_strdup("");
|
|
if (!strcmp(name, "Powered"))
|
adapter_changed(proxy, iter, user_data);
|
|
if (!strcmp(name, "Discovering")) {
|
dbus_bool_t val;
|
dbus_message_iter_get_basic(iter, &val);
|
pr_info("Adapter Discovering changed to %s", val ? "TRUE" : "FALSE");
|
if (!val) {
|
g_bt_scan_info.is_scaning = false;
|
filter_clear_transport();
|
bt_discovery_state_send(RK_BT_DISC_STOPPED_BY_USER);
|
}
|
}
|
|
print_iter(str, name, iter);
|
g_free(str);
|
} else if (!strcmp(interface, "org.bluez.LEAdvertisingManager1")) {
|
DBusMessageIter addr_iter;
|
char *str;
|
|
ctrl = find_ctrl(ctrl_list, g_dbus_proxy_get_path(proxy));
|
if (!ctrl)
|
return;
|
|
if (g_dbus_proxy_get_property(ctrl->proxy, "Address",
|
&addr_iter) == TRUE) {
|
const char *address;
|
|
dbus_message_iter_get_basic(&addr_iter, &address);
|
str = g_strdup_printf("[" COLORED_CHG
|
"] Controller %s ",
|
address);
|
} else
|
str = g_strdup("");
|
|
print_iter(str, name, iter);
|
g_free(str);
|
}else if (!strcmp(interface, "org.bluez.GattCharacteristic1")
|
|| !strcmp(interface, "org.bluez.GattDescriptor1")) {
|
char *str;
|
|
str = g_strdup_printf("[" COLORED_CHG "] Attribute %s ",
|
g_dbus_proxy_get_path(proxy));
|
|
print_iter(str, name, iter);
|
g_free(str);
|
|
if(!strcmp(name, "Value"))
|
gatt_client_recv_data_send(proxy, iter);
|
} else if (!strcmp(interface, "org.bluez.MediaPlayer1")) {
|
if (!strcmp(name, "KeyCode"))
|
source_avrcp_keycode_handler(proxy, iter);
|
}
|
|
if (bt_sink_is_open())
|
a2dp_sink_property_changed(proxy, name, iter, user_data);
|
|
pr_info("BT Exit: property_changed: %s\n", interface);
|
}
|
|
static void message_handler(DBusConnection *connection,
|
DBusMessage *message, void *user_data)
|
{
|
pr_info("[SIGNAL] %s.%s\n", dbus_message_get_interface(message),
|
dbus_message_get_member(message));
|
}
|
|
static struct adapter *find_ctrl_by_address(GList *source, const char *address)
|
{
|
GList *list;
|
|
for (list = g_list_first(source); list; list = g_list_next(list)) {
|
struct adapter *adapter = (struct adapter *)list->data;
|
DBusMessageIter iter;
|
const char *str;
|
|
if (g_dbus_proxy_get_property(adapter->proxy,
|
"Address", &iter) == FALSE)
|
continue;
|
|
dbus_message_iter_get_basic(&iter, &str);
|
|
if (!strcasecmp(str, address))
|
return adapter;
|
}
|
|
return NULL;
|
}
|
|
static GDBusProxy *find_proxy_by_address(GList *source, const char *address)
|
{
|
GList *list;
|
|
for (list = g_list_first(source); list; list = g_list_next(list)) {
|
GDBusProxy *proxy = (GDBusProxy *)list->data;
|
DBusMessageIter iter;
|
const char *str;
|
|
if (g_dbus_proxy_get_property(proxy, "Address", &iter) == FALSE)
|
continue;
|
|
dbus_message_iter_get_basic(&iter, &str);
|
if (!strcasecmp(str, address))
|
return proxy;
|
}
|
|
return NULL;
|
}
|
|
static gboolean check_default_ctrl(void)
|
{
|
if (!default_ctrl) {
|
pr_info("%s: No default controller available\n", __func__);
|
return FALSE;
|
}
|
|
return TRUE;
|
}
|
|
static gboolean parse_argument(int argc, char *argv[], const char **arg_table,
|
const char *msg, dbus_bool_t *value,
|
const char **option)
|
{
|
const char **opt;
|
|
if (!strcmp(argv[1], "on") || !strcmp(argv[1], "yes")) {
|
*value = TRUE;
|
if (option)
|
*option = "";
|
return TRUE;
|
}
|
|
if (!strcmp(argv[1], "off") || !strcmp(argv[1], "no")) {
|
*value = FALSE;
|
return TRUE;
|
}
|
|
for (opt = arg_table; opt && *opt; opt++) {
|
if (strcmp(argv[1], *opt) == 0) {
|
*value = TRUE;
|
*option = *opt;
|
return TRUE;
|
}
|
}
|
|
pr_info("Invalid argument %s\n", argv[1]);
|
return FALSE;
|
}
|
|
static void cmd_list(int argc, char *argv[])
|
{
|
GList *list;
|
|
for (list = g_list_first(ctrl_list); list; list = g_list_next(list)) {
|
struct adapter *adapter = (struct adapter *)list->data;
|
print_adapter(adapter->proxy, NULL);
|
}
|
}
|
|
static void cmd_show(int argc, char *argv[])
|
{
|
struct adapter *adapter;
|
GDBusProxy *proxy;
|
DBusMessageIter iter;
|
const char *address;
|
|
if (argc < 2 || !strlen(argv[1])) {
|
if (check_default_ctrl() == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
proxy = default_ctrl->proxy;
|
} else {
|
adapter = find_ctrl_by_address(ctrl_list, argv[1]);
|
if (!adapter) {
|
pr_info("Controller %s not available\n",
|
argv[1]);
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
proxy = adapter->proxy;
|
}
|
|
if (g_dbus_proxy_get_property(proxy, "Address", &iter) == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
dbus_message_iter_get_basic(&iter, &address);
|
|
if (g_dbus_proxy_get_property(proxy, "AddressType", &iter) == TRUE) {
|
const char *type;
|
|
dbus_message_iter_get_basic(&iter, &type);
|
|
pr_info("Controller %s (%s)\n", address, type);
|
} else {
|
pr_info("Controller %s\n", address);
|
}
|
|
print_property(proxy, "Name");
|
print_property(proxy, "Alias");
|
print_property(proxy, "Class");
|
print_property(proxy, "Powered");
|
print_property(proxy, "Discoverable");
|
print_property(proxy, "Pairable");
|
print_uuids(proxy);
|
print_property(proxy, "Modalias");
|
print_property(proxy, "Discovering");
|
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
}
|
|
static void cmd_select(int argc, char *argv[])
|
{
|
struct adapter *adapter;
|
|
adapter = find_ctrl_by_address(ctrl_list, argv[1]);
|
if (!adapter) {
|
pr_info("Controller %s not available\n", argv[1]);
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
if (default_ctrl && default_ctrl->proxy == adapter->proxy)
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
|
default_ctrl = adapter;
|
print_adapter(adapter->proxy, NULL);
|
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
}
|
|
static void cmd_devices(BtScanParam *param)
|
{
|
GList *ll;
|
|
if (check_default_ctrl() == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
|
for (ll = g_list_first(default_ctrl->devices); ll; ll = g_list_next(ll)) {
|
GDBusProxy *proxy = (GDBusProxy *)ll->data;
|
|
if(param)
|
btsrc_scan_save_device(proxy, param);
|
else
|
print_device(proxy, NULL);
|
}
|
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
}
|
|
static void cmd_paired_devices()
|
{
|
GList *ll;
|
|
if (check_default_ctrl() == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
|
for (ll = g_list_first(default_ctrl->devices);
|
ll; ll = g_list_next(ll)) {
|
GDBusProxy *proxy = (GDBusProxy *)ll->data;
|
DBusMessageIter iter;
|
dbus_bool_t paired;
|
|
if (g_dbus_proxy_get_property(proxy, "Paired", &iter) == FALSE)
|
continue;
|
|
dbus_message_iter_get_basic(&iter, &paired);
|
if (!paired)
|
continue;
|
|
print_device(proxy, NULL);
|
}
|
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
}
|
|
static void generic_callback(const DBusError *error, void *user_data)
|
{
|
if (dbus_error_is_set(error)) {
|
pr_info("Set failed: %s\n", error->name);
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
} else {
|
pr_info("Changing succeeded\n");
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
}
|
}
|
|
static void cmd_system_alias(int argc, char *argv[])
|
{
|
char *name;
|
|
if (check_default_ctrl() == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
name = g_strdup(argv[1]);
|
|
if (g_dbus_proxy_set_property_basic(default_ctrl->proxy, "Alias",
|
DBUS_TYPE_STRING, &name,
|
generic_callback, name, g_free) == TRUE)
|
return;
|
|
g_free(name);
|
}
|
|
static void cmd_reset_alias(int argc, char *argv[])
|
{
|
char *name;
|
|
if (check_default_ctrl() == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
name = g_strdup("");
|
|
if (g_dbus_proxy_set_property_basic(default_ctrl->proxy, "Alias",
|
DBUS_TYPE_STRING, &name,
|
generic_callback, name, g_free) == TRUE)
|
return;
|
|
g_free(name);
|
}
|
|
static void cmd_power(int argc, char *argv[])
|
{
|
dbus_bool_t powered;
|
char *str;
|
|
if (!parse_argument(argc, argv, NULL, NULL, &powered, NULL))
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
if (check_default_ctrl() == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
str = g_strdup_printf("power %s", powered == TRUE ? "on" : "off");
|
|
if (g_dbus_proxy_set_property_basic(default_ctrl->proxy, "Powered",
|
DBUS_TYPE_BOOLEAN, &powered,
|
generic_callback, str, g_free) == TRUE)
|
return;
|
|
g_free(str);
|
}
|
|
static void cmd_pairable(int argc, char *argv[])
|
{
|
dbus_bool_t pairable;
|
char *str;
|
|
if (!parse_argument(argc, argv, NULL, NULL, &pairable, NULL))
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
if (check_default_ctrl() == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
str = g_strdup_printf("pairable %s", pairable == TRUE ? "on" : "off");
|
|
if (g_dbus_proxy_set_property_basic(default_ctrl->proxy, "Pairable",
|
DBUS_TYPE_BOOLEAN, &pairable,
|
generic_callback, str, g_free) == TRUE)
|
return;
|
|
g_free(str);
|
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
static void cmd_discoverable(int argc, char *argv[])
|
{
|
dbus_bool_t discoverable;
|
char *str;
|
|
if (!parse_argument(argc, argv, NULL, NULL, &discoverable, NULL))
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
if (check_default_ctrl() == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
str = g_strdup_printf("discoverable %s",
|
discoverable == TRUE ? "on" : "off");
|
|
if (g_dbus_proxy_set_property_basic(default_ctrl->proxy, "Discoverable",
|
DBUS_TYPE_BOOLEAN, &discoverable,
|
generic_callback, str, g_free) == TRUE)
|
return;
|
|
g_free(str);
|
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
static void cmd_agent(int argc, char *argv[])
|
{
|
dbus_bool_t enable;
|
const char *capability;
|
|
if (!parse_argument(argc, argv, agent_arguments, "capability",
|
&enable, &capability))
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
if (enable == TRUE) {
|
g_free(auto_register_agent);
|
auto_register_agent = g_strdup(capability);
|
|
if (agent_manager)
|
agent_register(dbus_conn, agent_manager,
|
auto_register_agent);
|
else
|
pr_info("Agent registration enabled\n");
|
} else {
|
g_free(auto_register_agent);
|
auto_register_agent = NULL;
|
|
if (agent_manager)
|
agent_unregister(dbus_conn, agent_manager);
|
else
|
pr_info("Agent registration disabled\n");
|
}
|
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
}
|
|
static void cmd_default_agent(int argc, char *argv[])
|
{
|
agent_default(dbus_conn, agent_manager);
|
}
|
|
static void discovery_reply(DBusMessage *message, void *user_data)
|
{
|
dbus_bool_t enable = GPOINTER_TO_UINT(user_data);
|
DBusError error;
|
|
dbus_error_init(&error);
|
|
if (dbus_set_error_from_message(&error, message) == TRUE) {
|
pr_info("%s: Failed to %s(%lu) discovery: %s\n", __func__,
|
enable == TRUE ? "start" : "stop", pthread_self(), error.name);
|
if(enable)
|
bt_discovery_state_send(RK_BT_DISC_START_FAILED);
|
else
|
g_bt_scan_info.scan_off_failed = true;
|
|
dbus_error_free(&error);
|
return;
|
}
|
|
if(enable)
|
bt_discovery_state_send(RK_BT_DISC_STARTED);
|
|
pr_info("%s: Discovery %s(%lu)\n", __func__, enable ? "started" : "stopped", pthread_self());
|
/* Leave the discovery running even on noninteractive mode */
|
}
|
|
static struct set_discovery_filter_args {
|
char *transport;
|
dbus_uint16_t rssi;
|
dbus_int16_t pathloss;
|
char **uuids;
|
size_t uuids_len;
|
dbus_bool_t duplicate;
|
bool set;
|
} filter = {
|
NULL,
|
DISTANCE_VAL_INVALID,
|
DISTANCE_VAL_INVALID,
|
NULL,
|
0,
|
false,
|
true,
|
};
|
|
static void scan_filter_transport()
|
{
|
const char *type = NULL;
|
|
switch(g_bt_scan_info.scan_type) {
|
case SCAN_TYPE_AUTO:
|
type = "auto";
|
break;
|
|
case SCAN_TYPE_BREDR:
|
type = "bredr";
|
break;
|
|
case SCAN_TYPE_LE:
|
type = "le";
|
break;
|
}
|
|
if(type) {
|
filter_clear_transport();
|
filter.transport = g_strdup(type);
|
filter.set = false;
|
}
|
}
|
|
static void set_discovery_filter_setup(DBusMessageIter *iter, void *user_data)
|
{
|
struct set_discovery_filter_args *args = (struct set_discovery_filter_args *)user_data;
|
DBusMessageIter dict;
|
|
dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
|
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
|
DBUS_TYPE_STRING_AS_STRING
|
DBUS_TYPE_VARIANT_AS_STRING
|
DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
|
|
if(args->uuids_len > 0)
|
g_dbus_dict_append_array(&dict, "UUIDs", DBUS_TYPE_STRING,
|
&args->uuids,
|
args->uuids_len);
|
|
if (args->pathloss != DISTANCE_VAL_INVALID)
|
g_dbus_dict_append_entry(&dict, "Pathloss", DBUS_TYPE_UINT16,
|
&args->pathloss);
|
|
if (args->rssi != DISTANCE_VAL_INVALID)
|
g_dbus_dict_append_entry(&dict, "RSSI", DBUS_TYPE_INT16,
|
&args->rssi);
|
|
if (args->transport != NULL) {
|
pr_info("%s: scan transport: %s\n", __func__, args->transport);
|
g_dbus_dict_append_entry(&dict, "Transport", DBUS_TYPE_STRING,
|
&args->transport);
|
}
|
|
if (args->duplicate)
|
g_dbus_dict_append_entry(&dict, "DuplicateData",
|
DBUS_TYPE_BOOLEAN,
|
&args->duplicate);
|
|
dbus_message_iter_close_container(iter, &dict);
|
}
|
|
|
static void set_discovery_filter_reply(DBusMessage *message, void *user_data)
|
{
|
DBusError error;
|
|
dbus_error_init(&error);
|
if (dbus_set_error_from_message(&error, message) == TRUE) {
|
pr_info("SetDiscoveryFilter failed: %s\n", error.name);
|
dbus_error_free(&error);
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
filter.set = true;
|
|
pr_info("SetDiscoveryFilter success\n");
|
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
}
|
|
static void set_discovery_filter(void)
|
{
|
if (check_default_ctrl() == FALSE || filter.set)
|
return;
|
|
if (g_dbus_proxy_method_call(default_ctrl->proxy, "SetDiscoveryFilter",
|
set_discovery_filter_setup, set_discovery_filter_reply,
|
&filter, NULL) == FALSE) {
|
pr_info("Failed to set discovery filter\n");
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
filter.set = true;
|
}
|
|
static int cmd_scan(const char *cmd)
|
{
|
dbus_bool_t enable;
|
const char *method;
|
|
if (strcmp(cmd, "on") == 0) {
|
enable = TRUE;
|
} else if (strcmp(cmd, "off") == 0){
|
enable = FALSE;
|
} else {
|
pr_info("ERROR: %s cmd(%s) is invalid!\n", __func__, cmd);
|
return -1;
|
}
|
|
if (check_default_ctrl() == FALSE)
|
return -1;
|
|
if (enable == TRUE) {
|
scan_filter_transport();
|
set_discovery_filter();
|
method = "StartDiscovery";
|
} else
|
method = "StopDiscovery";
|
|
pr_info("%s method = %s\n", __func__, method);
|
|
if (g_dbus_proxy_method_call(default_ctrl->proxy, method,
|
NULL, discovery_reply,
|
GUINT_TO_POINTER(enable), NULL) == FALSE) {
|
pr_info("Failed to %s discovery\n",
|
enable == TRUE ? "start" : "stop");
|
return -1;
|
}
|
|
return 0;
|
}
|
|
static void cmd_scan_filter_uuids(int argc, char *argv[])
|
{
|
if (argc < 2 || !strlen(argv[1])) {
|
char **uuid;
|
|
for (uuid = filter.uuids; uuid && *uuid; uuid++)
|
print_uuid(*uuid);
|
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
}
|
|
g_strfreev(filter.uuids);
|
filter.uuids = NULL;
|
filter.uuids_len = 0;
|
|
if (!strcmp(argv[1], "all"))
|
goto commit;
|
|
filter.uuids = g_strdupv(&argv[1]);
|
if (!filter.uuids) {
|
pr_info("Failed to parse input\n");
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
filter.uuids_len = g_strv_length(filter.uuids);
|
|
commit:
|
filter.set = false;
|
}
|
|
static void cmd_scan_filter_rssi(int argc, char *argv[])
|
{
|
if (argc < 2 || !strlen(argv[1])) {
|
if (filter.rssi != DISTANCE_VAL_INVALID)
|
pr_info("RSSI: %d\n", filter.rssi);
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
}
|
|
filter.pathloss = DISTANCE_VAL_INVALID;
|
filter.rssi = atoi(argv[1]);
|
|
filter.set = false;
|
}
|
|
static void cmd_scan_filter_pathloss(int argc, char *argv[])
|
{
|
if (argc < 2 || !strlen(argv[1])) {
|
if (filter.pathloss != DISTANCE_VAL_INVALID)
|
pr_info("Pathloss: %d\n",
|
filter.pathloss);
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
}
|
|
filter.rssi = DISTANCE_VAL_INVALID;
|
filter.pathloss = atoi(argv[1]);
|
|
filter.set = false;
|
}
|
|
static void cmd_scan_filter_duplicate_data(int argc, char *argv[])
|
{
|
if (argc < 2 || !strlen(argv[1])) {
|
pr_info("DuplicateData: %s\n",
|
filter.duplicate ? "on" : "off");
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
}
|
|
if (!strcmp(argv[1], "on"))
|
filter.duplicate = true;
|
else if (!strcmp(argv[1], "off"))
|
filter.duplicate = false;
|
else {
|
pr_info("Invalid option: %s\n", argv[1]);
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
filter.set = false;
|
}
|
|
static void filter_clear_uuids(void)
|
{
|
g_strfreev(filter.uuids);
|
filter.uuids = NULL;
|
filter.uuids_len = 0;
|
}
|
|
static void filter_clear_rssi(void)
|
{
|
filter.rssi = DISTANCE_VAL_INVALID;
|
}
|
|
static void filter_clear_pathloss(void)
|
{
|
filter.pathloss = DISTANCE_VAL_INVALID;
|
}
|
|
static void filter_clear_transport()
|
{
|
if(filter.transport) {
|
pr_info("%s\n", __func__);
|
g_free(filter.transport);
|
filter.transport = NULL;
|
}
|
}
|
|
static void filter_clear_duplicate(void)
|
{
|
filter.duplicate = false;
|
}
|
|
struct clear_entry {
|
const char *name;
|
void (*clear) (void);
|
};
|
|
static const struct clear_entry filter_clear[] = {
|
{ "uuids", filter_clear_uuids },
|
{ "rssi", filter_clear_rssi },
|
{ "pathloss", filter_clear_pathloss },
|
{ "transport", filter_clear_transport },
|
{ "duplicate-data", filter_clear_duplicate },
|
{}
|
};
|
|
static char *filter_clear_generator(const char *text, int state)
|
{
|
static int index, len;
|
const char *arg;
|
|
if (!state) {
|
index = 0;
|
len = strlen(text);
|
}
|
|
while ((arg = filter_clear[index].name)) {
|
index++;
|
|
if (!strncmp(arg, text, len))
|
return strdup(arg);
|
}
|
|
return NULL;
|
}
|
|
static gboolean data_clear(const struct clear_entry *entry_table,
|
const char *name)
|
{
|
const struct clear_entry *entry;
|
bool all = false;
|
|
if (!name || !strlen(name) || !strcmp("all", name))
|
all = true;
|
|
for (entry = entry_table; entry && entry->name; entry++) {
|
if (all || !strcmp(entry->name, name)) {
|
entry->clear();
|
if (!all)
|
goto done;
|
}
|
}
|
|
if (!all) {
|
pr_info("Invalid argument %s\n", name);
|
return FALSE;
|
}
|
|
done:
|
return TRUE;
|
}
|
|
static void cmd_scan_filter_clear(int argc, char *argv[])
|
{
|
bool all = false;
|
|
if (argc < 2 || !strlen(argv[1]))
|
all = true;
|
|
if (!data_clear(filter_clear, all ? "all" : argv[1]))
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
filter.set = false;
|
|
if (check_default_ctrl() == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
set_discovery_filter();
|
}
|
|
static struct GDBusProxy *find_device(int argc, char *argv[])
|
{
|
GDBusProxy *proxy;
|
|
if (argc < 2 || !strlen(argv[1])) {
|
if (default_dev)
|
return default_dev;
|
pr_info("Missing device address argument\n");
|
return NULL;
|
}
|
|
if (check_default_ctrl() == FALSE)
|
return NULL;
|
|
proxy = find_proxy_by_address(default_ctrl->devices, argv[1]);
|
if (!proxy) {
|
pr_info("Device %s not available\n", argv[1]);
|
return NULL;
|
}
|
|
return proxy;
|
}
|
|
struct GDBusProxy *find_device_by_address(char *address)
|
{
|
GDBusProxy *proxy;
|
|
if (!address || strlen(address) < 17) {
|
if (default_dev)
|
return default_dev;
|
pr_info("Missing device address argument\n");
|
return NULL;
|
}
|
|
if (check_default_ctrl() == FALSE)
|
return NULL;
|
|
proxy = find_proxy_by_address(default_ctrl->devices, address);
|
if (!proxy) {
|
pr_info("%s: Device %s not available\n", __func__, address);
|
return NULL;
|
}
|
|
return proxy;
|
}
|
|
static void cmd_info(int argc, char *argv[])
|
{
|
GDBusProxy *proxy;
|
DBusMessageIter iter;
|
const char *address;
|
|
proxy = find_device(argc, argv);
|
if (!proxy)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
if (g_dbus_proxy_get_property(proxy, "Address", &iter) == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
dbus_message_iter_get_basic(&iter, &address);
|
|
if (g_dbus_proxy_get_property(proxy, "AddressType", &iter) == TRUE) {
|
const char *type;
|
|
dbus_message_iter_get_basic(&iter, &type);
|
|
pr_info("Device %s (%s)\n", address, type);
|
} else {
|
pr_info("Device %s\n", address);
|
}
|
|
print_property(proxy, "Name");
|
print_property(proxy, "Alias");
|
print_property(proxy, "Class");
|
print_property(proxy, "Appearance");
|
print_property(proxy, "Icon");
|
print_property(proxy, "Paired");
|
print_property(proxy, "Trusted");
|
print_property(proxy, "Blocked");
|
print_property(proxy, "Connected");
|
print_property(proxy, "LegacyPairing");
|
print_property(proxy, "Modalias");
|
print_property(proxy, "ManufacturerData");
|
print_property(proxy, "ServiceData");
|
print_property(proxy, "RSSI");
|
print_property(proxy, "TxPower");
|
print_property(proxy, "AdvertisingFlags");
|
print_property(proxy, "AdvertisingData");
|
print_uuids(proxy);
|
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
}
|
|
static void pair_reply(DBusMessage *message, void *user_data)
|
{
|
DBusError error;
|
|
dbus_error_init(&error);
|
|
if (dbus_set_error_from_message(&error, message) == TRUE) {
|
pr_info("Failed to pair: %s\n", error.name);
|
dbus_error_free(&error);
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
pr_info("Pairing successful\n");
|
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
}
|
|
static const char *proxy_address(GDBusProxy *proxy)
|
{
|
DBusMessageIter iter;
|
const char *addr;
|
|
if (!g_dbus_proxy_get_property(proxy, "Address", &iter))
|
return NULL;
|
|
dbus_message_iter_get_basic(&iter, &addr);
|
|
return addr;
|
}
|
|
static int cmd_pair(GDBusProxy *proxy)
|
{
|
if (!proxy)
|
return -1;
|
|
if (g_dbus_proxy_method_call(proxy, "Pair", NULL, pair_reply,
|
NULL, NULL) == FALSE) {
|
pr_info("%s: Failed to pair\n", __func__);
|
return -1;
|
}
|
|
pr_info("%s: Attempting to pair with %s\n", __func__, proxy_address(proxy));
|
return 0;
|
}
|
|
static void cmd_trust(int argc, char *argv[])
|
{
|
GDBusProxy *proxy;
|
dbus_bool_t trusted;
|
char *str;
|
|
proxy = find_device(argc, argv);
|
if (!proxy)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
trusted = TRUE;
|
|
str = g_strdup_printf("%s trust", proxy_address(proxy));
|
|
if (g_dbus_proxy_set_property_basic(proxy, "Trusted",
|
DBUS_TYPE_BOOLEAN, &trusted,
|
generic_callback, str, g_free) == TRUE)
|
return;
|
|
g_free(str);
|
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
static void cmd_untrust(int argc, char *argv[])
|
{
|
GDBusProxy *proxy;
|
dbus_bool_t trusted;
|
char *str;
|
|
proxy = find_device(argc, argv);
|
if (!proxy)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
trusted = FALSE;
|
|
str = g_strdup_printf("%s untrust", proxy_address(proxy));
|
|
if (g_dbus_proxy_set_property_basic(proxy, "Trusted",
|
DBUS_TYPE_BOOLEAN, &trusted,
|
generic_callback, str, g_free) == TRUE)
|
return;
|
|
g_free(str);
|
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
static void cmd_block(int argc, char *argv[])
|
{
|
GDBusProxy *proxy;
|
dbus_bool_t blocked;
|
char *str;
|
|
proxy = find_device(argc, argv);
|
if (!proxy)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
blocked = TRUE;
|
|
str = g_strdup_printf("%s block", proxy_address(proxy));
|
|
if (g_dbus_proxy_set_property_basic(proxy, "Blocked",
|
DBUS_TYPE_BOOLEAN, &blocked,
|
generic_callback, str, g_free) == TRUE)
|
return;
|
|
g_free(str);
|
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
static void cmd_unblock(int argc, char *argv[])
|
{
|
GDBusProxy *proxy;
|
dbus_bool_t blocked;
|
char *str;
|
|
proxy = find_device(argc, argv);
|
if (!proxy)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
blocked = FALSE;
|
|
str = g_strdup_printf("%s unblock", proxy_address(proxy));
|
|
if (g_dbus_proxy_set_property_basic(proxy, "Blocked",
|
DBUS_TYPE_BOOLEAN, &blocked,
|
generic_callback, str, g_free) == TRUE)
|
return;
|
|
g_free(str);
|
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
static void remove_device_reply(DBusMessage *message, void *user_data)
|
{
|
DBusError error;
|
|
dbus_error_init(&error);
|
|
if (dbus_set_error_from_message(&error, message) == TRUE) {
|
pr_info("Failed to remove device: %s\n", error.name);
|
//a2dp_master_event_send(BT_SOURCE_EVENT_REMOVE_FAILED, "", "");
|
dbus_error_free(&error);
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
pr_info("%s: Device has been removed\n", __func__);
|
//a2dp_master_event_send(BT_SOURCE_EVENT_REMOVED, "", "");
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
}
|
|
static void remove_device_setup(DBusMessageIter *iter, void *user_data)
|
{
|
char *path = (char *)user_data;
|
|
dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);
|
}
|
|
static int remove_device(GDBusProxy *proxy)
|
{
|
char *path;
|
|
path = g_strdup(g_dbus_proxy_get_path(proxy));
|
|
if (check_default_ctrl() == FALSE)
|
return -1;
|
|
pr_info("%s: Attempting to remove device with %s\n", __func__, proxy_address(proxy));
|
if (g_dbus_proxy_method_call(default_ctrl->proxy, "RemoveDevice",
|
remove_device_setup,
|
remove_device_reply,
|
path, g_free) == FALSE) {
|
pr_info("%s: Failed to remove device\n", __func__);
|
g_free(path);
|
return -1;
|
}
|
|
return 0;
|
}
|
|
static void cmd_remove(int argc, char *argv[])
|
{
|
GDBusProxy *proxy;
|
|
if (check_default_ctrl() == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
pr_info("%s\n", __func__);
|
if (strcmp(argv[1], "*") == 0) {
|
GList *list;
|
|
for (list = default_ctrl->devices; list;
|
list = g_list_next(list)) {
|
GDBusProxy *proxy = (GDBusProxy *)list->data;
|
|
remove_device(proxy);
|
}
|
return;
|
}
|
|
proxy = find_proxy_by_address(default_ctrl->devices, argv[1]);
|
if (!proxy) {
|
pr_info("Device %s not available\n", argv[1]);
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
remove_device(proxy);
|
}
|
|
static void cmd_list_attributes(int argc, char *argv[])
|
{
|
GDBusProxy *proxy;
|
|
proxy = find_device(argc, argv);
|
if (!proxy)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
gatt_list_attributes(g_dbus_proxy_get_path(proxy));
|
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
}
|
|
static void cmd_set_alias(int argc, char *argv[])
|
{
|
char *name;
|
|
if (!default_dev) {
|
pr_info("No device connected\n");
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
name = g_strdup(argv[1]);
|
|
if (g_dbus_proxy_set_property_basic(default_dev, "Alias",
|
DBUS_TYPE_STRING, &name,
|
generic_callback, name, g_free) == TRUE)
|
return;
|
|
g_free(name);
|
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
static struct GDBusProxy *find_attribute(int argc, char *argv[])
|
{
|
GDBusProxy *proxy;
|
|
if (argc < 2 || !strlen(argv[1])) {
|
if (default_attr)
|
return default_attr;
|
pr_info("Missing attribute argument\n");
|
return NULL;
|
}
|
|
proxy = gatt_select_attribute(default_attr, argv[1]);
|
if (!proxy) {
|
pr_info("Attribute %s not available\n", argv[1]);
|
return NULL;
|
}
|
|
return proxy;
|
}
|
|
static void cmd_attribute_info(int argc, char *argv[])
|
{
|
GDBusProxy *proxy;
|
DBusMessageIter iter;
|
const char *iface, *uuid, *text;
|
|
proxy = find_attribute(argc, argv);
|
if (!proxy)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
if (g_dbus_proxy_get_property(proxy, "UUID", &iter) == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
dbus_message_iter_get_basic(&iter, &uuid);
|
|
text = bt_uuidstr_to_str(uuid);
|
if (!text)
|
text = g_dbus_proxy_get_path(proxy);
|
|
iface = g_dbus_proxy_get_interface(proxy);
|
if (!strcmp(iface, "org.bluez.GattService1")) {
|
pr_info("Service - %s\n", text);
|
|
print_property(proxy, "UUID");
|
print_property(proxy, "Primary");
|
print_property(proxy, "Characteristics");
|
print_property(proxy, "Includes");
|
} else if (!strcmp(iface, "org.bluez.GattCharacteristic1")) {
|
pr_info("Characteristic - %s\n", text);
|
|
print_property(proxy, "UUID");
|
print_property(proxy, "Service");
|
print_property(proxy, "Value");
|
print_property(proxy, "Notifying");
|
print_property(proxy, "Flags");
|
print_property(proxy, "Descriptors");
|
} else if (!strcmp(iface, "org.bluez.GattDescriptor1")) {
|
pr_info("Descriptor - %s\n", text);
|
|
print_property(proxy, "UUID");
|
print_property(proxy, "Characteristic");
|
print_property(proxy, "Value");
|
}
|
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
}
|
|
static void cmd_acquire_write(int argc, char *argv[])
|
{
|
if (!default_attr) {
|
pr_info("No attribute selected\n");
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
gatt_acquire_write(default_attr, argv[1]);
|
}
|
|
static void cmd_release_write(int argc, char *argv[])
|
{
|
if (!default_attr) {
|
pr_info("No attribute selected\n");
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
gatt_release_write(default_attr, argv[1]);
|
}
|
|
static void cmd_acquire_notify(int argc, char *argv[])
|
{
|
if (!default_attr) {
|
pr_info("No attribute selected\n");
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
gatt_acquire_notify(default_attr, argv[1]);
|
}
|
|
static void cmd_release_notify(int argc, char *argv[])
|
{
|
if (!default_attr) {
|
pr_info("No attribute selected\n");
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
gatt_release_notify(default_attr, argv[1]);
|
}
|
|
static void cmd_notify(int argc, char *argv[])
|
{
|
dbus_bool_t enable;
|
|
if (!parse_argument(argc, argv, NULL, NULL, &enable, NULL))
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
if (!default_attr) {
|
pr_info("No attribute selected\n");
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
gatt_notify_attribute(default_attr, enable ? true : false);
|
}
|
|
static void cmd_register_app(int argc, char *argv[])
|
{
|
if (check_default_ctrl() == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
gatt_register_app(dbus_conn, default_ctrl->proxy, argc, argv);
|
}
|
|
static void cmd_unregister_app(int argc, char *argv[])
|
{
|
if (check_default_ctrl() == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
gatt_unregister_app(dbus_conn, default_ctrl->proxy);
|
}
|
|
static void cmd_register_service(int argc, char *argv[])
|
{
|
if (check_default_ctrl() == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
gatt_register_service(dbus_conn, default_ctrl->proxy, argc, argv);
|
}
|
|
static void cmd_register_includes(int argc, char *argv[])
|
{
|
if (check_default_ctrl() == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
gatt_register_include(dbus_conn, default_ctrl->proxy, argc, argv);
|
}
|
|
static void cmd_unregister_includes(int argc, char *argv[])
|
{
|
if (check_default_ctrl() == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
gatt_unregister_include(dbus_conn, default_ctrl->proxy, argc, argv);
|
}
|
|
static void cmd_unregister_service(int argc, char *argv[])
|
{
|
if (check_default_ctrl() == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
gatt_unregister_service(dbus_conn, default_ctrl->proxy, argc, argv);
|
}
|
|
static void cmd_register_characteristic(int argc, char *argv[])
|
{
|
if (check_default_ctrl() == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
gatt_register_chrc(dbus_conn, default_ctrl->proxy, argc, argv);
|
}
|
|
static void cmd_unregister_characteristic(int argc, char *argv[])
|
{
|
if (check_default_ctrl() == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
gatt_unregister_chrc(dbus_conn, default_ctrl->proxy, argc, argv);
|
}
|
|
static void cmd_register_descriptor(int argc, char *argv[])
|
{
|
if (check_default_ctrl() == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
gatt_register_desc(dbus_conn, default_ctrl->proxy, argc, argv);
|
}
|
|
static void cmd_unregister_descriptor(int argc, char *argv[])
|
{
|
if (check_default_ctrl() == FALSE)
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
gatt_unregister_desc(dbus_conn, default_ctrl->proxy, argc, argv);
|
}
|
|
static char *generic_generator(const char *text, int state,
|
GList *source, const char *property)
|
{
|
static int index, len;
|
GList *list;
|
|
if (!state) {
|
index = 0;
|
len = strlen(text);
|
}
|
|
for (list = g_list_nth(source, index); list;
|
list = g_list_next(list)) {
|
GDBusProxy *proxy = (GDBusProxy *)list->data;
|
DBusMessageIter iter;
|
const char *str;
|
|
index++;
|
|
if (g_dbus_proxy_get_property(proxy, property, &iter) == FALSE)
|
continue;
|
|
dbus_message_iter_get_basic(&iter, &str);
|
|
if (!strncasecmp(str, text, len))
|
return strdup(str);
|
}
|
|
return NULL;
|
}
|
|
static char *ctrl_generator(const char *text, int state)
|
{
|
static int index = 0;
|
static int len = 0;
|
GList *list;
|
|
if (!state) {
|
index = 0;
|
len = strlen(text);
|
}
|
|
for (list = g_list_nth(ctrl_list, index); list;
|
list = g_list_next(list)) {
|
struct adapter *adapter = (struct adapter *)list->data;
|
DBusMessageIter iter;
|
const char *str;
|
|
index++;
|
|
if (g_dbus_proxy_get_property(adapter->proxy,
|
"Address", &iter) == FALSE)
|
continue;
|
|
dbus_message_iter_get_basic(&iter, &str);
|
|
if (!strncasecmp(str, text, len))
|
return strdup(str);
|
}
|
|
return NULL;
|
}
|
|
static char *dev_generator(const char *text, int state)
|
{
|
return generic_generator(text, state,
|
default_ctrl ? default_ctrl->devices : NULL, "Address");
|
}
|
|
static char *attribute_generator(const char *text, int state)
|
{
|
return gatt_attribute_generator(text, state);
|
}
|
|
static char *argument_generator(const char *text, int state,
|
const char *args_list[])
|
{
|
static int index, len;
|
const char *arg;
|
|
if (!state) {
|
index = 0;
|
len = strlen(text);
|
}
|
|
while ((arg = args_list[index])) {
|
index++;
|
|
if (!strncmp(arg, text, len))
|
return strdup(arg);
|
}
|
|
return NULL;
|
}
|
|
static char *capability_generator(const char *text, int state)
|
{
|
return argument_generator(text, state, agent_arguments);
|
}
|
|
static void cmd_advertise(int argc, char *argv[])
|
{
|
dbus_bool_t enable;
|
const char *type;
|
|
if (!parse_argument(argc, argv, ad_arguments, "type",
|
&enable, &type))
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
if (!default_ctrl || !default_ctrl->ad_proxy) {
|
pr_info("LEAdvertisingManager not found\n");
|
bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
if (enable == TRUE)
|
ad_register(dbus_conn, default_ctrl->ad_proxy, type);
|
else
|
ad_unregister(dbus_conn, default_ctrl->ad_proxy);
|
}
|
|
static char *ad_generator(const char *text, int state)
|
{
|
return argument_generator(text, state, ad_arguments);
|
}
|
|
static void cmd_advertise_uuids(int argc, char *argv[])
|
{
|
ad_advertise_uuids(dbus_conn, argc, argv);
|
}
|
|
static void cmd_advertise_service(int argc, char *argv[])
|
{
|
ad_advertise_service(dbus_conn, argc, argv);
|
}
|
|
static void cmd_advertise_manufacturer(int argc, char *argv[])
|
{
|
ad_advertise_manufacturer(dbus_conn, argc, argv);
|
}
|
|
static void cmd_advertise_data(int argc, char *argv[])
|
{
|
ad_advertise_data(dbus_conn, argc, argv);
|
}
|
|
static void cmd_advertise_discoverable(int argc, char *argv[])
|
{
|
dbus_bool_t discoverable;
|
|
if (argc < 2) {
|
ad_advertise_discoverable(dbus_conn, NULL);
|
return;
|
}
|
|
if (!parse_argument(argc, argv, NULL, NULL, &discoverable, NULL))
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
ad_advertise_discoverable(dbus_conn, &discoverable);
|
}
|
|
static void cmd_advertise_discoverable_timeout(int argc, char *argv[])
|
{
|
long int value;
|
char *endptr = NULL;
|
|
if (argc < 2) {
|
ad_advertise_discoverable_timeout(dbus_conn, NULL);
|
return;
|
}
|
|
value = strtol(argv[1], &endptr, 0);
|
if (!endptr || *endptr != '\0' || value > UINT16_MAX) {
|
pr_info("Invalid argument\n");
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
ad_advertise_discoverable_timeout(dbus_conn, &value);
|
}
|
|
static void cmd_advertise_tx_power(int argc, char *argv[])
|
{
|
dbus_bool_t powered;
|
|
if (argc < 2) {
|
ad_advertise_tx_power(dbus_conn, NULL);
|
return;
|
}
|
|
if (!parse_argument(argc, argv, NULL, NULL, &powered, NULL))
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
|
ad_advertise_tx_power(dbus_conn, &powered);
|
}
|
|
static void cmd_advertise_name(int argc, char *argv[])
|
{
|
if (argc < 2) {
|
ad_advertise_local_name(dbus_conn, NULL);
|
return;
|
}
|
|
if (strcmp(argv[1], "on") == 0 || strcmp(argv[1], "yes") == 0) {
|
ad_advertise_name(dbus_conn, true);
|
return;
|
}
|
|
if (strcmp(argv[1], "off") == 0 || strcmp(argv[1], "no") == 0) {
|
ad_advertise_name(dbus_conn, false);
|
return;
|
}
|
|
ad_advertise_local_name(dbus_conn, argv[1]);
|
}
|
|
static void cmd_advertise_appearance(int argc, char *argv[])
|
{
|
long int value;
|
char *endptr = NULL;
|
|
if (argc < 2) {
|
ad_advertise_local_appearance(dbus_conn, NULL);
|
return;
|
}
|
|
if (strcmp(argv[1], "on") == 0 || strcmp(argv[1], "yes") == 0) {
|
ad_advertise_appearance(dbus_conn, true);
|
return;
|
}
|
|
if (strcmp(argv[1], "off") == 0 || strcmp(argv[1], "no") == 0) {
|
ad_advertise_appearance(dbus_conn, false);
|
return;
|
}
|
|
value = strtol(argv[1], &endptr, 0);
|
if (!endptr || *endptr != '\0' || value > UINT16_MAX) {
|
pr_info("Invalid argument\n");
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
ad_advertise_local_appearance(dbus_conn, &value);
|
}
|
|
static void cmd_advertise_duration(int argc, char *argv[])
|
{
|
long int value;
|
char *endptr = NULL;
|
|
if (argc < 2) {
|
ad_advertise_duration(dbus_conn, NULL);
|
return;
|
}
|
|
value = strtol(argv[1], &endptr, 0);
|
if (!endptr || *endptr != '\0' || value > UINT16_MAX) {
|
pr_info("Invalid argument\n");
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
ad_advertise_duration(dbus_conn, &value);
|
}
|
|
static void cmd_advertise_timeout(int argc, char *argv[])
|
{
|
long int value;
|
char *endptr = NULL;
|
|
if (argc < 2) {
|
ad_advertise_timeout(dbus_conn, NULL);
|
return;
|
}
|
|
value = strtol(argv[1], &endptr, 0);
|
if (!endptr || *endptr != '\0' || value > UINT16_MAX) {
|
pr_info("Invalid argument\n");
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
ad_advertise_timeout(dbus_conn, &value);
|
}
|
|
static void ad_clear_uuids(void)
|
{
|
ad_disable_uuids(dbus_conn);
|
}
|
|
static void ad_clear_service(void)
|
{
|
ad_disable_service(dbus_conn);
|
}
|
|
static void ad_clear_manufacturer(void)
|
{
|
ad_disable_manufacturer(dbus_conn);
|
}
|
|
static void ad_clear_data(void)
|
{
|
ad_disable_data(dbus_conn);
|
}
|
|
static void ad_clear_tx_power(void)
|
{
|
dbus_bool_t powered = false;
|
|
ad_advertise_tx_power(dbus_conn, &powered);
|
}
|
|
static void ad_clear_name(void)
|
{
|
ad_advertise_name(dbus_conn, false);
|
}
|
|
static void ad_clear_appearance(void)
|
{
|
ad_advertise_appearance(dbus_conn, false);
|
}
|
|
static void ad_clear_duration(void)
|
{
|
long int value = 0;
|
|
ad_advertise_duration(dbus_conn, &value);
|
}
|
|
static void ad_clear_timeout(void)
|
{
|
long int value = 0;
|
|
ad_advertise_timeout(dbus_conn, &value);
|
}
|
|
static const struct clear_entry ad_clear[] = {
|
{ "uuids", ad_clear_uuids },
|
{ "service", ad_clear_service },
|
{ "manufacturer", ad_clear_manufacturer },
|
{ "data", ad_clear_data },
|
{ "tx-power", ad_clear_tx_power },
|
{ "name", ad_clear_name },
|
{ "appearance", ad_clear_appearance },
|
{ "duration", ad_clear_duration },
|
{ "timeout", ad_clear_timeout },
|
{}
|
};
|
|
static void cmd_ad_clear(int argc, char *argv[])
|
{
|
bool all = false;
|
|
if (argc < 2 || !strlen(argv[1]))
|
all = true;
|
|
if(!data_clear(ad_clear, all ? "all" : argv[1]))
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
static const struct option options[] = {
|
{ "agent", required_argument, 0, 'a' },
|
{ 0, 0, 0, 0 }
|
};
|
|
static const char *agent_option;
|
|
static const char **optargs[] = {
|
&agent_option
|
};
|
|
static const char *help[] = {
|
"Register agent handler: <capability>"
|
};
|
|
static const struct bt_shell_opt opt = {
|
.options = options,
|
.optno = sizeof(options) / sizeof(struct option),
|
.optstr = "a:",
|
.optarg = optargs,
|
.help = help,
|
};
|
|
static void client_ready(GDBusClient *client, void *user_data)
|
{
|
return;
|
}
|
|
static guint reconnect_timer;
|
static void connect_reply(DBusMessage *message, void *user_data)
|
{
|
struct ConnectContext_t *ctx_ptr = (struct ConnectContext_t *)user_data;
|
if (!ctx_ptr) {
|
pr_err("%s: invaild connect context!\n", __func__);
|
return;
|
}
|
GDBusProxy *proxy = ctx_ptr->proxy;
|
DBusError error;
|
static int conn_count = 0;
|
DBusMessageIter iter;
|
const char *address = ctx_ptr->address;
|
char addr[18], name[256];
|
|
dbus_error_init(&error);
|
|
g_bt_source_info.is_connecting = false;
|
if (dbus_set_error_from_message(&error, message) == TRUE) {
|
pr_info("%s: Failed to connect: %s\n", __func__, error.name);
|
dbus_error_free(&error);
|
|
conn_count--;
|
if (conn_count > 0) {
|
if(g_dbus_proxy_get_property(proxy, "Address", &iter) == FALSE) {
|
pr_err("%s: can't get address!\n", __func__);
|
return;
|
}
|
|
dbus_message_iter_get_basic(&iter, &address);
|
if (reconnect_timer) {
|
g_source_remove(reconnect_timer);
|
reconnect_timer = 0;
|
}
|
reconnect_timer = g_timeout_add_seconds(3,
|
a2dp_master_connect, address);
|
return;
|
}
|
|
if(bt_source_is_open()) {
|
pr_err("%s: ---------------------- at here\n", __func__);
|
memset(addr, 0, 18);
|
memset(name, 0, 256);
|
//bt_get_device_addr_by_proxy(proxy, addr, 18);
|
//bt_get_device_name_by_proxy(proxy, name, 256);//fail maybe no name
|
a2dp_master_event_send(BT_SOURCE_EVENT_CONNECT_FAILED, address, address);
|
}
|
pr_err("%s: ------------------ ending\n", __func__);
|
conn_count = 0;
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
pr_info("%s: Connection successful\n", __func__);
|
//set_default_device(proxy, NULL);
|
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
}
|
|
static void disconn_reply(DBusMessage *message, void *user_data)
|
{
|
GDBusProxy *proxy = (GDBusProxy *)user_data;
|
DBusError error;
|
|
dbus_error_init(&error);
|
|
if (dbus_set_error_from_message(&error, message) == TRUE) {
|
char addr[18], name[256];
|
|
pr_info("Failed to disconnect: %s\n", error.name);
|
dbus_error_free(&error);
|
|
if(bt_source_is_open()) {
|
memset(addr, 0, 18);
|
memset(name, 0, 256);
|
bt_get_device_addr_by_proxy(proxy, addr, 18);
|
bt_get_device_name_by_proxy(proxy, name, 256);
|
a2dp_master_event_send(BT_SOURCE_EVENT_DISCONNECT_FAILED, addr, name);
|
}
|
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
pr_info("%s: Successful disconnected\n", __func__);
|
|
//check disconnect
|
if(bt_is_connected())
|
pr_info("\n\n%s: The ACL link still exists!\n\n\n", __func__);
|
|
if (proxy == default_dev)
|
set_default_device(NULL, NULL);
|
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
}
|
|
static void a2dp_source_clean(void)
|
{
|
dbus_conn = NULL;
|
agent_manager = NULL;
|
auto_register_agent = NULL;
|
|
default_ctrl = NULL;
|
ctrl_list = NULL;
|
default_dev = NULL;
|
default_attr = NULL;
|
|
btsrc_client = NULL;
|
}
|
|
static void bluetooth_open(RkBtContent *bt_content)
|
{
|
pr_info("%s thread tid = %lu\n", __func__, pthread_self());
|
a2dp_source_clean();
|
|
if (agent_option)
|
auto_register_agent = g_strdup(agent_option);
|
else
|
auto_register_agent = g_strdup("");
|
|
dbus_conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, NULL);
|
g_dbus_attach_object_manager(dbus_conn);
|
|
btsrc_client = g_dbus_client_new(dbus_conn, "org.bluez", "/org/bluez");
|
if (NULL == btsrc_client) {
|
pr_info("%s: btsrc_client init fail\n", __func__);
|
g_free(auto_register_agent);
|
dbus_connection_unref(dbus_conn);
|
return;
|
}
|
|
init_avrcp_ctrl();
|
|
if(bt_content) {
|
g_bt_content = bt_content;
|
gatt_init(bt_content);
|
} else {
|
g_bt_content = NULL;
|
}
|
|
g_dbus_client_set_connect_watch(btsrc_client, connect_handler, NULL);
|
g_dbus_client_set_disconnect_watch(btsrc_client, disconnect_handler, NULL);
|
g_dbus_client_set_signal_watch(btsrc_client, message_handler, NULL);
|
g_dbus_client_set_proxy_handlers(btsrc_client, proxy_added, proxy_removed,
|
property_changed, NULL);
|
|
BT_OPENED = 1;
|
pr_info("%s: server start...\n", __func__);
|
return;
|
}
|
|
static gboolean _bluetooth_open(void *user_data)
|
{
|
RkBtContent *bt_content = user_data;
|
|
bluetooth_open(bt_content);
|
return FALSE;
|
}
|
|
extern GMainContext *Bluez_Context;
|
int bt_open(RkBtContent *bt_content)
|
{
|
int confirm_cnt = 100;
|
|
BT_OPENED = 0;
|
#ifdef DefGContext
|
//_bluetooth_open(bt_content);
|
g_idle_add(_bluetooth_open, bt_content);
|
#else
|
GSource *source;
|
source = g_idle_source_new();
|
g_source_set_priority (source, G_PRIORITY_DEFAULT_IDLE);
|
g_source_set_callback (source, _bluetooth_open, bt_content, NULL);
|
g_source_attach (source, Bluez_Context);
|
g_source_unref (source);
|
#endif
|
|
while (confirm_cnt--) {
|
if (BT_OPENED)
|
return 0;
|
|
usleep(50 * 1000);
|
}
|
|
return -1;
|
}
|
|
static gboolean _bluetooth_close(void *user_data)
|
{
|
memset(&g_bt_scan_info, 0, sizeof(bt_scan_info_t));
|
|
g_dbus_client_unref(btsrc_client);
|
btsrc_client = NULL;
|
|
gatt_cleanup();
|
|
dbus_connection_unref(dbus_conn);
|
dbus_conn = NULL;
|
|
g_list_free_full(ctrl_list, proxy_leak);
|
g_free(auto_register_agent);
|
auto_register_agent = NULL;
|
//a2dp_source_clean();
|
|
BT_CLOSED = 1;
|
pr_info("%s: server exit!\n", __func__);
|
return FALSE;
|
}
|
|
void bt_close()
|
{
|
int confirm_cnt = 100;
|
|
BT_CLOSED = 0;
|
#ifdef DefGContext
|
//_bluetooth_close(NULL);
|
g_idle_add(_bluetooth_close, NULL);
|
#else
|
GSource *source;
|
|
source = g_idle_source_new();
|
g_source_set_priority (source, G_PRIORITY_DEFAULT_IDLE);
|
g_source_set_callback (source, _bluetooth_close, NULL, NULL);
|
g_source_attach (source, Bluez_Context);
|
g_source_unref (source);
|
#endif
|
}
|
|
static int a2dp_master_get_rssi(GDBusProxy *proxy)
|
{
|
int retry_cnt = 5;
|
DBusMessageIter iter;
|
short rssi = DISTANCE_VAL_INVALID;
|
|
while (retry_cnt--) {
|
if (g_dbus_proxy_get_property(proxy, "RSSI", &iter) == FALSE) {
|
usleep(10000); //10ms
|
continue;
|
}
|
break;
|
}
|
|
if (retry_cnt >= 0)
|
dbus_message_iter_get_basic(&iter, &rssi);
|
|
return rssi;
|
}
|
|
static RK_BT_PLAYROLE_TYPE a2dp_master_get_playrole(GDBusProxy *proxy)
|
{
|
int ret = PLAYROLE_TYPE_UNKNOWN;
|
enum BT_Device_Class device_class;
|
|
device_class = dist_dev_class(proxy);
|
if (device_class == BT_SINK_DEVICE)
|
ret = PLAYROLE_TYPE_SINK;
|
else if (device_class == BT_SOURCE_DEVICE)
|
ret = PLAYROLE_TYPE_SOURCE;
|
|
return ret;
|
}
|
|
int a2dp_master_scan(void *arg, int len, RK_BT_SCAN_TYPE scan_type)
|
{
|
BtScanParam *param = NULL;
|
BtDeviceInfo *start = NULL;
|
GDBusProxy *proxy;
|
int ret = 0;
|
int i;
|
|
if (check_default_ctrl() == FALSE)
|
return -1;
|
|
param = (BtScanParam *)arg;
|
if (len < sizeof(BtScanParam)) {
|
pr_info("%s parameter error. BtScanParam setting is incorrect\n", __func__);
|
return -1;
|
}
|
|
if(g_bt_scan_info.is_scaning) {
|
pr_info("%s: devices discovering\n", __func__);
|
return -1;
|
}
|
g_bt_scan_info.is_scaning = true;
|
g_bt_scan_info.scan_type = scan_type;
|
|
pr_info("=== scan on ===\n");
|
cmd_scan("on");
|
if (param->mseconds > 100) {
|
pr_info("Waiting for Scan(%d ms)...\n", param->mseconds);
|
usleep(param->mseconds * 1000);
|
} else {
|
pr_info("warning:%dms is too short, scan time is changed to 2s.\n",
|
param->mseconds);
|
usleep(2000 * 1000);
|
}
|
|
pr_info("=== scan off ===\n");
|
cmd_scan("off");
|
|
cmd_devices(param);
|
pr_info("=== parse scan device (cnt:%d) ===\n", param->item_cnt);
|
for (i = 0; i < param->item_cnt; i++) {
|
start = ¶m->devices[i];
|
proxy = find_device_by_address(start->address);
|
if (!proxy) {
|
pr_info("%s find_device_by_address failed!\n", __func__);
|
continue;
|
}
|
/* Get bluetooth rssi */
|
ret = a2dp_master_get_rssi(proxy);
|
if (ret != DISTANCE_VAL_INVALID) {
|
start->rssi = ret;
|
start->rssi_valid = TRUE;
|
}
|
/* Get bluetooth AudioProfile */
|
ret = a2dp_master_get_playrole(proxy);
|
if (ret == PLAYROLE_TYPE_SINK)
|
memcpy(start->playrole, "Audio Sink", strlen("Audio Sink"));
|
else if (ret == PLAYROLE_TYPE_SOURCE)
|
memcpy(start->playrole, "Audio Source", strlen("Audio Source"));
|
else
|
memcpy(start->playrole, "Unknow", strlen("Unknow"));
|
}
|
|
g_bt_scan_info.scan_type = SCAN_TYPE_AUTO;
|
filter_clear_transport();
|
g_bt_scan_info.is_scaning = false;
|
return 0;
|
}
|
|
static void *a2dp_master_connect_thread(void *arg)
|
{
|
GDBusProxy *proxy;
|
char *address = (char *)arg;
|
static struct ConnectContext_t ctx;
|
ctx.proxy = NULL;
|
ctx.address = NULL;
|
pr_info("%s thread tid = %lu\n", __func__, pthread_self());
|
|
if(bt_is_scaning())
|
bt_cancel_discovery(RK_BT_DISC_STOPPED_BY_USER);
|
|
if(!bt_source_is_open()) {
|
pr_err("%s: bt source is not open\n", __func__);
|
a2dp_master_event_send(BT_SOURCE_EVENT_CONNECT_FAILED, address, address);
|
return NULL;
|
}
|
|
proxy = find_proxy_by_address(default_ctrl->devices, address);
|
if (!proxy) {
|
pr_info("%s: Device %s not available\n", __func__, address);
|
a2dp_master_event_send(BT_SOURCE_EVENT_CONNECT_FAILED, address, address);
|
return NULL;
|
}
|
|
g_device_state = BT_SOURCE_EVENT_DISCONNECTED;
|
a2dp_master_event_send(BT_SOURCE_EVENT_CONNECTTING, address, NULL);
|
ctx.proxy = proxy;
|
ctx.address = address;
|
if (g_dbus_proxy_method_call(proxy, "Connect", NULL, connect_reply,
|
&ctx, NULL) == FALSE) {
|
//char name[256];
|
//memset(name, 0, 256);
|
//bt_get_device_name_by_proxy(proxy, name, 256);
|
|
pr_info("%s: Failed to connect\n", __func__);
|
a2dp_master_event_send(BT_SOURCE_EVENT_CONNECT_FAILED, address, address);
|
return NULL;
|
}
|
|
g_bt_source_info.is_connecting = true;
|
pr_info("%s: Attempting to connect to %s [proxy: %p]\n", __func__, address, proxy);
|
return NULL;
|
}
|
|
int a2dp_master_connect(char *t_address)
|
{
|
pthread_t tid;
|
int addr_len;
|
|
if (!t_address || (strlen(t_address) < 17)) {
|
pr_err("%s: Invalid address\n", __func__);
|
a2dp_master_event_send(BT_SOURCE_EVENT_CONNECT_FAILED, t_address, t_address);
|
return -1;
|
}
|
|
if (check_default_ctrl() == FALSE) {
|
a2dp_master_event_send(BT_SOURCE_EVENT_CONNECT_FAILED, t_address, t_address);
|
return -1;
|
}
|
|
memset(g_bt_source_info.connect_address, 0, sizeof(g_bt_source_info.connect_address));
|
addr_len = sizeof(g_bt_source_info.connect_address) > strlen(t_address) ?
|
strlen(t_address) : sizeof(g_bt_source_info.connect_address);
|
memcpy(g_bt_source_info.connect_address, t_address, addr_len);
|
|
if (pthread_create(&tid, NULL, a2dp_master_connect_thread, (void *)g_bt_source_info.connect_address)) {
|
pr_err("%s: source connect thread create failed!\n", __func__);
|
a2dp_master_event_send(BT_SOURCE_EVENT_CONNECT_FAILED, t_address, t_address);
|
return -1;
|
}
|
|
pthread_detach(tid);
|
return 0;
|
}
|
|
void ble_disconn_reply(DBusMessage *message, void *user_data)
|
{
|
GDBusProxy *proxy = (GDBusProxy *)user_data;
|
DBusError error;
|
|
dbus_error_init(&error);
|
|
if (dbus_set_error_from_message(&error, message) == TRUE) {
|
pr_info("Failed to disconnect: %s\n", error.name);
|
dbus_error_free(&error);
|
return;
|
}
|
|
if (proxy == ble_dev) {
|
pr_info("%s: Successful disconnected ble\n", __func__);
|
} else {
|
pr_info("%s: Failed disconnected ble\n", __func__);
|
}
|
}
|
|
int ble_disconnect()
|
{
|
if (!ble_dev) {
|
pr_info("%s: ble no connect\n", __func__);
|
return -1;
|
}
|
|
if(ble_is_open()) {
|
if(!remove_ble_device())
|
return;
|
}
|
|
if (g_dbus_proxy_method_call(ble_dev, "Disconnect", NULL, ble_disconn_reply,
|
ble_dev, NULL) == FALSE) {
|
pr_info("%s: Failed to disconnect\n", __func__);
|
return -1;
|
}
|
|
pr_info("%s: Attempting to disconnect ble from %s\n", __func__, proxy_address(ble_dev));
|
return 0;
|
}
|
|
int remove_ble_device()
|
{
|
DBusMessageIter iter;
|
const char *type = NULL;
|
|
if (!ble_dev) {
|
pr_info("%s: ble no connect\n", __func__);
|
return -1;
|
}
|
|
if (g_dbus_proxy_get_property(ble_dev, "AddressType", &iter)) {
|
dbus_message_iter_get_basic(&iter, &type);
|
pr_info("%s: AddressType = %s\n", __func__, type);
|
if (!strcmp(type, "public")) {
|
return remove_device(ble_dev);
|
}
|
}
|
|
return -1;
|
}
|
|
void ble_clean()
|
{
|
ble_service_cnt = 0;
|
ble_dev = NULL;
|
}
|
|
static int disconnect_by_proxy(GDBusProxy *proxy)
|
{
|
if (!proxy) {
|
pr_info("%s: Invalid proxy\n", __func__);
|
return -1;
|
}
|
|
if (g_dbus_proxy_method_call(proxy, "Disconnect", NULL, disconn_reply,
|
proxy, NULL) == FALSE) {
|
pr_info("Failed to disconnect\n");
|
return -1;
|
}
|
|
pr_info("%s: Attempting to disconnect from %s\n", __func__, proxy_address(proxy));
|
return 0;
|
}
|
|
/*
|
* Get the Bluetooth connection status.
|
* Input parameters:
|
* Addr_buff -> if not empty, the interface will resolve the address
|
* of the current connection and store it in addr_buf.
|
* return value:
|
* 0-> not connected;
|
* 1-> is connected;
|
*/
|
int a2dp_master_status(char *addr_buf, int addr_len, char *name_buf, int name_len)
|
{
|
DBusMessageIter iter;
|
const char *address;
|
const char *name;
|
|
if (!default_dev) {
|
pr_info("no source connect\n");
|
return 0;
|
}
|
|
if (addr_buf) {
|
if (g_dbus_proxy_get_property(default_dev, "Address", &iter) == FALSE) {
|
pr_info("WARING: Bluetooth connected, but can't get address!\n");
|
return 0;
|
}
|
dbus_message_iter_get_basic(&iter, &address);
|
memset(addr_buf, 0, addr_len);
|
memcpy(addr_buf, address, (strlen(address) > addr_len) ? addr_len : strlen(address));
|
}
|
|
if (name_buf) {
|
if (g_dbus_proxy_get_property(default_dev, "Alias", &iter) == FALSE) {
|
pr_info("WARING: Bluetooth connected, but can't get device name!\n");
|
return 0;
|
}
|
|
dbus_message_iter_get_basic(&iter, &name);
|
memset(name_buf, 0, name_len);
|
memcpy(name_buf, name, (strlen(name) > name_len) ? name_len : strlen(name));
|
}
|
|
return 1;
|
}
|
|
int remove_by_address(char *t_address)
|
{
|
GDBusProxy *proxy;
|
|
if(t_address == NULL) {
|
pr_err("%s: Invalid address\n", __func__);
|
return -1;
|
}
|
|
if (check_default_ctrl() == FALSE)
|
return -1;
|
|
if (strcmp(t_address, "*") == 0) {
|
GList *list;
|
|
for (list = default_ctrl->devices; list; list = g_list_next(list)) {
|
proxy = (GDBusProxy *)list->data;
|
remove_device(proxy);
|
}
|
return 0;
|
} else if ((strlen(t_address) < 17)) {
|
pr_err("%s: %s address error!\n", __func__, t_address);
|
return -1;
|
}
|
|
proxy = find_proxy_by_address(default_ctrl->devices, t_address);
|
if (!proxy) {
|
pr_info("Device %s not available\n", t_address);
|
return -1;
|
}
|
|
return remove_device(proxy);
|
}
|
|
int a2dp_master_save_status(char *address)
|
{
|
char buff[100] = {0};
|
struct sockaddr_un serverAddr;
|
int snd_cnt = 3;
|
int sockfd;
|
int send_len = 0;
|
|
sockfd = socket(AF_UNIX, SOCK_DGRAM, 0);
|
if (sockfd < 0) {
|
pr_info("FUNC:%s create sockfd failed!\n", __func__);
|
return 0;
|
}
|
|
serverAddr.sun_family = AF_UNIX;
|
strcpy(serverAddr.sun_path, "/tmp/a2dp_master_status");
|
|
memset(buff, 0, sizeof(buff));
|
if (address)
|
sprintf(buff, "status:connect;address:%s;", address);
|
else
|
sprintf(buff, "status:disconnect;");
|
|
while(snd_cnt--) {
|
send_len = sendto(sockfd, buff, strlen(buff), MSG_DONTWAIT, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
|
if(send_len == strlen(buff)) {
|
pr_info("%s: send: %s(%d)\n", __func__, buff, send_len);
|
break;
|
}
|
|
usleep(1000);
|
}
|
|
close(sockfd);
|
return 0;
|
}
|
|
void a2dp_master_event_send(RK_BT_SOURCE_EVENT event, char *dev_addr, char *dev_name)
|
{
|
if(!g_bt_callback.bt_source_event_cb || !bt_source_is_open())
|
return;
|
|
if ((event == BT_SOURCE_EVENT_CONNECTED) || (event == BT_SOURCE_EVENT_DISCONNECTED))
|
g_device_state = event;
|
|
pr_info("%s: state: %d, addr: %s, name: %s.\n", __func__, event, dev_addr, dev_name);
|
|
if(!dev_addr && !dev_name) {
|
char addr[18], name[256];
|
|
memset(addr, 0, 18);
|
memset(name, 0, 256);
|
bt_get_device_addr_by_proxy(default_dev, addr, 18);
|
bt_get_device_name_by_proxy(default_dev, name, 256);
|
|
g_bt_callback.bt_source_event_cb(g_btmaster_userdata, addr, name, event);
|
} else {
|
g_bt_callback.bt_source_event_cb(g_btmaster_userdata, dev_addr, dev_name, event);
|
}
|
}
|
|
void a2dp_master_register_cb(void *userdata, RK_BT_SOURCE_CALLBACK cb)
|
{
|
g_bt_callback.bt_source_event_cb = cb;
|
g_btmaster_userdata = userdata;
|
return;
|
}
|
|
void a2dp_master_deregister_cb()
|
{
|
g_bt_callback.bt_source_event_cb = NULL;
|
g_btmaster_userdata = NULL;
|
return;
|
}
|
|
/**********************************************
|
* bt source avrcp
|
**********************************************/
|
static void save_last_device(GDBusProxy *proxy)
|
{
|
int fd;
|
const char *object_path, *address;
|
DBusMessageIter iter, class_iter;
|
dbus_uint32_t valu32;
|
char buff[512] = {0};
|
|
pr_info("%s\n", __func__);
|
|
if (g_dbus_proxy_get_property(proxy, "Address", &iter) == FALSE) {
|
pr_info("Get adapter address error");
|
return;
|
}
|
|
dbus_message_iter_get_basic(&iter, &address);
|
pr_info("Connected device address: %s\n", address);
|
|
if (g_dbus_proxy_get_property(proxy, "Class", &class_iter) == FALSE) {
|
pr_info("Get adapter Class error\n");
|
return;
|
}
|
|
dbus_message_iter_get_basic(&class_iter, &valu32);
|
pr_info("Connected device class: 0x%x\n", valu32);
|
|
object_path = g_dbus_proxy_get_path(proxy);
|
pr_info("Connected device object path: %s\n", object_path);
|
|
fd = open(BT_RECONNECT_CFG, O_RDWR | O_CREAT | O_TRUNC, 0644);
|
if (fd == -1) {
|
pr_info("Open %s error: %s\n", BT_RECONNECT_CFG, strerror(errno));
|
return;
|
}
|
|
sprintf(buff, "ADDRESS:%s;CLASS:%x;PATH:%s;", address, valu32, object_path);
|
write(fd, buff, strlen(buff));
|
fsync(fd);
|
close(fd);
|
}
|
|
static int load_last_device(char *address)
|
{
|
int fd, ret, i;
|
char buff[512] = {0};
|
char *start = NULL, *end = NULL;
|
|
pr_info("Load path %s\n", BT_RECONNECT_CFG);
|
|
ret = access(BT_RECONNECT_CFG, F_OK);
|
if (ret == -1) {
|
pr_info("%s does not exist\n", BT_RECONNECT_CFG);
|
return -1;
|
}
|
|
fd = open(BT_RECONNECT_CFG, O_RDONLY);
|
if (fd == -1) {
|
pr_info("Open %s error: %s\n", BT_RECONNECT_CFG, strerror(errno));
|
return -1;
|
}
|
|
ret = read(fd, buff, sizeof(buff));
|
if (ret < 0) {
|
pr_info("read %s error: %s\n", BT_RECONNECT_CFG, strerror(errno));
|
close(fd);
|
return -1;
|
}
|
|
start = strstr(buff, "ADDRESS:");
|
end = strstr(buff, ";");
|
if (!start || !end || (end < start)) {
|
pr_info("file %s content invalid(address): %s\n", BT_RECONNECT_CFG, buff);
|
close(fd);
|
return -1;
|
}
|
start += strlen("ADDRESS:");
|
if (address)
|
memcpy(address, start, end - start);
|
|
close(fd);
|
return 0;
|
}
|
|
static void reconn_last_device_reply(DBusMessage * message, void *user_data)
|
{
|
DBusError err;
|
|
dbus_error_init(&err);
|
if (dbus_set_error_from_message(&err, message) == TRUE) {
|
pr_info("Reconnect failed!\n");
|
dbus_error_free(&err);
|
}
|
}
|
|
int reconn_last_devices(BtDeviceType type)
|
{
|
GDBusProxy *proxy;
|
DBusMessageIter addr_iter, addrType_iter;
|
int fd, ret, reconnect = 1;
|
char buff[100] = {0};
|
char address[48] = {0};
|
enum BT_Device_Class device_class;
|
|
fd = open("/userdata/cfg/bt_reconnect", O_RDONLY);
|
if (fd > 0) {
|
ret = read(fd, buff, sizeof(buff));
|
if (ret > 0) {
|
if (strstr(buff, "bluez-reconnect:disable"))
|
reconnect = 0;
|
}
|
close(fd);
|
}
|
|
if (reconnect == 0) {
|
pr_info("%s: automatic reconnection is disabled!\n", __func__);
|
return 0;
|
}
|
|
if (bt_is_connected()) {
|
pr_info("%s: The device is connected and does not need to be reconnected!\n", __func__);
|
return 0;
|
}
|
|
ret = load_last_device(address);
|
if (ret < 0)
|
return ret;
|
|
proxy = find_device_by_address(address);
|
if (!proxy) {
|
pr_info("Invalid proxy, stop reconnecting\n");
|
return -1;
|
}
|
|
device_class = dist_dev_class(proxy);
|
if (device_class == BT_IDLE) {
|
pr_info("Invalid device_class, stop reconnecting\n");
|
return -1;
|
}
|
|
if(type == BT_DEVICES_A2DP_SINK) {
|
pr_info("%s: source reconnected(%s)\n", __func__, address);
|
memset(g_bt_source_info.reconnect_address, 0, sizeof(g_bt_source_info.reconnect_address));
|
memcpy(g_bt_source_info.reconnect_address, address, sizeof(g_bt_source_info.reconnect_address));
|
source_set_reconnect_tag(true);
|
return 0;
|
}
|
|
switch(type) {
|
case BT_DEVICES_A2DP_SINK:
|
if (device_class != BT_SINK_DEVICE)
|
reconnect = 0;
|
break;
|
case BT_DEVICES_A2DP_SOURCE:
|
if (device_class != BT_SOURCE_DEVICE)
|
reconnect = 0;
|
break;
|
case BT_DEVICES_BLE:
|
if (device_class != BT_BLE_DEVICE)
|
reconnect = 0;
|
break;
|
case BT_DEVICES_HFP:
|
if (device_class != BT_SOURCE_DEVICE)
|
reconnect = 0;
|
break;
|
case BT_DEVICES_SPP:
|
break;
|
default:
|
reconnect = 0;
|
}
|
|
if (reconnect == 0) {
|
pr_info("Unable to find a suitable reconnect device!\n");
|
return -1;
|
}
|
|
if(type == BT_DEVICES_A2DP_SINK) {
|
a2dp_master_connect(address);
|
} else {
|
if(bt_is_scaning())
|
bt_cancel_discovery(RK_BT_DISC_STOPPED_BY_USER);
|
|
if (g_dbus_proxy_method_call(proxy, "Connect", NULL,
|
reconn_last_device_reply, NULL, NULL) == FALSE) {
|
pr_info("Failed to call org.bluez.Device1.Connect\n");
|
return -1;
|
}
|
}
|
|
return 0;
|
}
|
|
int disconnect_current_devices()
|
{
|
if (!default_dev) {
|
pr_info("%s: No connected device\n", __func__);
|
return -1;
|
}
|
|
return disconnect_by_proxy(default_dev);
|
}
|
|
int get_dev_platform(char *address)
|
{
|
int vendor = -1, platform = DEV_PLATFORM_UNKNOWN;
|
char *str;
|
const char *valstr;
|
GDBusProxy *proxy;
|
DBusMessageIter iter;
|
|
if(!address) {
|
pr_info("%s: Invalid address\n", __func__);
|
return DEV_PLATFORM_UNKNOWN;
|
}
|
|
proxy = find_device_by_address(address);
|
if (!proxy) {
|
pr_info("%s: Invalid proxy\n", __func__);
|
return DEV_PLATFORM_UNKNOWN;
|
}
|
|
if (g_dbus_proxy_get_property(proxy, "Modalias", &iter) == FALSE) {
|
pr_info("%s: WARING: can't get Modalias!\n", __func__);
|
return DEV_PLATFORM_UNKNOWN;
|
}
|
|
dbus_message_iter_get_basic(&iter, &valstr);
|
pr_info("%s: Modalias valstr = %s\n", __func__, valstr);
|
|
str = strstr(valstr, "v");
|
if(str) {
|
if(!strncasecmp(str + 1, "004c", 4))
|
vendor = IOS_VENDOR_SOURCE_BT;
|
else if(!strncasecmp(str + 1, "05ac", 4))
|
vendor = IOS_VENDOR_SOURCE_USB;
|
}
|
|
if(vendor == IOS_VENDOR_SOURCE_BT || vendor == IOS_VENDOR_SOURCE_USB)
|
platform = DEV_PLATFORM_IOS;
|
|
pr_info("%s: %s is %s\n", __func__, address,
|
platform == DEV_PLATFORM_UNKNOWN ? "Unknown Platform" : "Apple IOS");
|
|
return platform;
|
}
|
|
int get_current_dev_platform()
|
{
|
if (!default_dev) {
|
pr_info("%s: No connected device\n", __func__);
|
return DEV_PLATFORM_UNKNOWN;
|
}
|
|
return get_dev_platform(proxy_address(default_dev));
|
}
|
|
static void connect_by_address_reply(DBusMessage *message, void *user_data)
|
{
|
GDBusProxy *proxy = (GDBusProxy*)user_data;
|
DBusError error;
|
|
dbus_error_init(&error);
|
|
if (dbus_set_error_from_message(&error, message) == TRUE) {
|
pr_info("%s: Failed to connect: %s\n", __func__, error.name);
|
dbus_error_free(&error);
|
//set_default_device(NULL, NULL);
|
return bt_shell_noninteractive_quit(EXIT_FAILURE);
|
}
|
|
pr_info("%s: Connection successful\n", __func__);
|
//set_default_device(proxy, NULL);
|
|
return bt_shell_noninteractive_quit(EXIT_SUCCESS);
|
}
|
|
int connect_by_address(char *addr)
|
{
|
GDBusProxy *proxy;
|
|
if (!addr || (strlen(addr) < 17)) {
|
pr_err("%s: Invalid address\n", __func__);
|
return -1;
|
}
|
|
proxy = find_device_by_address(addr);
|
if (!proxy) {
|
pr_info("%s: Invalid proxy\n", __func__);
|
return -1;
|
}
|
|
if(bt_is_scaning())
|
bt_cancel_discovery(RK_BT_DISC_STOPPED_BY_USER);
|
|
if (g_dbus_proxy_method_call(proxy, "Connect", NULL,
|
connect_by_address_reply, proxy, NULL) == FALSE) {
|
pr_info("%s: Failed to call org.bluez.Device1.Connect\n", __func__);
|
return -1;
|
}
|
|
pr_info("%s: Attempting to connect to %s\n", __func__, addr);
|
return 0;
|
}
|
|
int disconnect_by_address(char *addr)
|
{
|
GDBusProxy *proxy;
|
|
if (!addr || (strlen(addr) < 17)) {
|
pr_err("%s: Invalid address\n", __func__);
|
return -1;
|
}
|
|
proxy = find_device_by_address(addr);
|
if (!proxy) {
|
pr_info("%s: Invalid proxy\n", __func__);
|
return -1;
|
}
|
|
return disconnect_by_proxy(proxy);
|
}
|
|
void bt_display_devices()
|
{
|
cmd_devices(NULL);
|
}
|
|
void bt_display_paired_devices()
|
{
|
cmd_paired_devices();
|
}
|
|
RkBtScanedDevice *bt_create_one_scaned_dev(GDBusProxy *proxy)
|
{
|
DBusMessageIter iter;
|
const char *address, *name;
|
dbus_int16_t rssi = -100;
|
dbus_bool_t is_connected = FALSE;
|
dbus_uint32_t cod = 0;
|
|
RkBtScanedDevice *new_device = (RkBtScanedDevice*)malloc(sizeof(RkBtScanedDevice));
|
if(!new_device) {
|
pr_err("%s: malloc one scaned device failed\n", __func__);
|
return NULL;
|
}
|
|
if (g_dbus_proxy_get_property(proxy, "Address", &iter))
|
dbus_message_iter_get_basic(&iter, &address);
|
else
|
address = "<unknown>";
|
pr_info(" addr: %s\n", address);
|
|
if (g_dbus_proxy_get_property(proxy, "Alias", &iter))
|
dbus_message_iter_get_basic(&iter, &name);
|
else
|
name = "<unknown>";
|
pr_info(" name: %s\n", name);
|
|
if (g_dbus_proxy_get_property(proxy, "Connected", &iter))
|
dbus_message_iter_get_basic(&iter, &is_connected);
|
else
|
pr_info("%s: Can't get connected status\n", __func__);
|
pr_info(" Connected: %d\n", is_connected);
|
|
if(g_dbus_proxy_get_property(proxy, "Class", &iter))
|
dbus_message_iter_get_basic(&iter, &cod);
|
else
|
pr_info("%s: Can't get class of device\n", __func__);
|
pr_info(" Class: 0x%x\n", cod);
|
|
new_device->remote_address = (char *)malloc(strlen(address) + 1);
|
if(!new_device->remote_address) {
|
pr_err("%s: malloc remote_address failed\n", __func__);
|
return NULL;
|
}
|
strncpy(new_device->remote_address, address, strlen(address));
|
new_device->remote_address[strlen(address)] = '\0';
|
|
new_device->remote_name = (char *)malloc(strlen(name) + 1);
|
if(!new_device->remote_name) {
|
pr_err("%s: malloc remote_name failed\n", __func__);
|
return NULL;
|
}
|
strncpy(new_device->remote_name, name, strlen(name));
|
new_device->remote_name[strlen(name)] = '\0';
|
|
new_device->is_connected = is_connected;
|
new_device->cod = cod;
|
new_device->next = NULL;
|
|
return new_device;
|
}
|
|
static int list_scaned_dev_push_back(RkBtScanedDevice **dev_list, GDBusProxy *proxy)
|
{
|
if(dev_list == NULL) {
|
pr_info("%s: invalid dev_list\n", __func__);
|
return -1;
|
}
|
|
if(*dev_list == NULL) {
|
*dev_list = bt_create_one_scaned_dev(proxy);
|
if(*dev_list == NULL)
|
return -1;
|
} else {
|
RkBtScanedDevice *cur_dev = *dev_list;
|
while(cur_dev->next != NULL)
|
cur_dev = cur_dev->next;
|
|
RkBtScanedDevice *new_dev = bt_create_one_scaned_dev(proxy);
|
if(!new_dev)
|
return -1;
|
|
cur_dev->next = new_dev;
|
}
|
|
return 0;
|
}
|
|
int bt_get_scaned_devices(RkBtScanedDevice **dev_list, int *count, bool paired)
|
{
|
GList *ll;
|
|
*count = 0;
|
if (check_default_ctrl() == FALSE)
|
return -1;
|
|
for (ll = g_list_first(default_ctrl->devices);
|
ll; ll = g_list_next(ll)) {
|
GDBusProxy *proxy = (GDBusProxy *)ll->data;
|
|
if(paired) {
|
DBusMessageIter iter;
|
dbus_bool_t paired;
|
|
if (g_dbus_proxy_get_property(proxy, "Paired", &iter) == FALSE)
|
continue;
|
|
dbus_message_iter_get_basic(&iter, &paired);
|
if (!paired)
|
continue;
|
}
|
if(!list_scaned_dev_push_back(dev_list, proxy))
|
(*count)++;
|
}
|
|
pr_info("%s: paired = %d, count = %d\n", __func__, paired, *count);
|
return 0;
|
}
|
|
int bt_free_scaned_devices(RkBtScanedDevice *dev_list)
|
{
|
RkBtScanedDevice *dev_tmp = NULL;
|
|
if(dev_list == NULL) {
|
pr_info("%s: dev_list is null, don't need to clear\n", __func__);
|
return -1;
|
}
|
|
while(dev_list->next != NULL) {
|
pr_info("%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) {
|
pr_info("%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 pair_by_addr(char *addr)
|
{
|
GDBusProxy *proxy;
|
char dev_name[256];
|
|
if (!addr || (strlen(addr) < 17)) {
|
pr_err("%s: Invalid address\n", __func__);
|
return -1;
|
}
|
|
proxy = find_device_by_address(addr);
|
if (!proxy) {
|
pr_info("%s: Invalid proxy\n", __func__);
|
return -1;
|
}
|
|
bt_get_device_name_by_proxy(proxy, dev_name, 256);
|
bt_bond_state_send(addr, dev_name, RK_BT_BOND_STATE_BONDING);
|
|
return cmd_pair(proxy);
|
}
|
|
int unpair_by_addr(char *addr)
|
{
|
GDBusProxy *proxy;
|
|
if (!addr || (strlen(addr) < 17)) {
|
pr_err("%s: Invalid address\n", __func__);
|
return -1;
|
}
|
|
pr_info("%s\n", __func__);
|
proxy = find_device_by_address(addr);
|
if (!proxy) {
|
pr_info("%s: Invalid proxy\n", __func__);
|
return -1;
|
}
|
|
/* There is no direct unpair method, removing device will clear pairing information */
|
return remove_device(proxy);
|
}
|
|
int bt_set_device_name(char *name)
|
{
|
if (!name) {
|
pr_info("%s: Invalid bt name: %s\n", __func__, name);
|
return -1;
|
}
|
|
if (check_default_ctrl() == FALSE)
|
return -1;
|
|
if (!default_ctrl->proxy) {
|
pr_info("%s: Invalid proxy\n", __func__);
|
return -1;
|
}
|
|
if (g_dbus_proxy_set_property_basic(default_ctrl->proxy, "Alias",
|
DBUS_TYPE_STRING, &name,
|
generic_callback, name, NULL) == FALSE) {
|
pr_info("%s: set Alias property error\n", __func__);
|
return -1;
|
}
|
|
pr_info("%s: Attempting to set device name %s\n", __func__, name);
|
return 0;
|
}
|
|
int bt_get_device_name_by_proxy(GDBusProxy *proxy,
|
char *name_buf, int name_len)
|
{
|
DBusMessageIter iter;
|
const char *name;
|
|
if (!proxy) {
|
pr_info("%s: Invalid proxy\n", __func__);
|
return -1;
|
}
|
|
if (!name_buf || name_len <= 0) {
|
pr_info("%s: Invalid name buffer, name_len: %d\n", __func__, name_len);
|
return -1;
|
}
|
|
memset(name_buf, 0, name_len);
|
if (g_dbus_proxy_get_property(proxy, "Alias", &iter) == FALSE) {
|
pr_info("WARING: Bluetooth connected, but can't get device name!\n");
|
return -1;
|
}
|
|
dbus_message_iter_get_basic(&iter, &name);
|
memcpy(name_buf, name, (strlen(name) > name_len) ? name_len : strlen(name));
|
|
return 0;
|
}
|
|
int bt_get_device_name(char *name_buf, int name_len)
|
{
|
if (check_default_ctrl() == FALSE)
|
return -1;
|
|
if (!default_ctrl->proxy) {
|
pr_info("%s: Invalid proxy\n", __func__);
|
return -1;
|
}
|
|
return bt_get_device_name_by_proxy(default_ctrl->proxy, name_buf, name_len);
|
}
|
|
int bt_get_device_addr_by_proxy(GDBusProxy *proxy,
|
char *addr_buf, int addr_len)
|
{
|
DBusMessageIter iter;
|
const char *address;
|
|
if (!proxy) {
|
pr_info("%s: Invalid proxy\n", __func__);
|
return -1;
|
}
|
|
if (!addr_buf || addr_len < 17) {
|
pr_info("%s: Invalid address buffer, addr_len: %d\n", __func__, addr_len);
|
return -1;
|
}
|
|
memset(addr_buf, 0, addr_len);
|
if (g_dbus_proxy_get_property(proxy, "Address", &iter) == FALSE) {
|
pr_info("WARING: Bluetooth connected, but can't get address!\n");
|
return -1;
|
}
|
|
dbus_message_iter_get_basic(&iter, &address);
|
memcpy(addr_buf, address, (strlen(address) > addr_len) ? addr_len : strlen(address));
|
|
return 0;
|
}
|
|
int bt_get_device_addr(char *addr_buf, int addr_len)
|
{
|
if (check_default_ctrl() == FALSE)
|
return -1;
|
|
if (!default_ctrl->proxy) {
|
pr_info("%s: Invalid proxy\n", __func__);
|
return -1;
|
}
|
|
return bt_get_device_addr_by_proxy(default_ctrl->proxy, addr_buf, addr_len);
|
}
|
|
|
int bt_get_default_dev_addr(char *addr_buf, int addr_len)
|
{
|
if (!default_dev) {
|
pr_info("%s: no connected device\n", __func__);
|
return -1;
|
}
|
|
return bt_get_device_addr_by_proxy(default_dev, addr_buf, addr_len);
|
}
|
|
static void reomve_unpaired_device ()
|
{
|
GDBusProxy *proxy;
|
DBusMessageIter iter;
|
GList *list;
|
|
if (check_default_ctrl() == FALSE)
|
return;
|
|
for (list = default_ctrl->devices; list;
|
list = g_list_next(list)) {
|
dbus_bool_t paired = FALSE;
|
dbus_bool_t connected = FALSE;
|
|
GDBusProxy *proxy = (GDBusProxy *)list->data;
|
|
if (g_dbus_proxy_get_property(proxy, "Paired", &iter))
|
dbus_message_iter_get_basic(&iter, &paired);
|
|
if (g_dbus_proxy_get_property(proxy, "Connected", &iter))
|
dbus_message_iter_get_basic(&iter, &connected);
|
|
if (paired || connected) {
|
const char *address;
|
if (g_dbus_proxy_get_property(proxy, "Address", &iter)) {
|
dbus_message_iter_get_basic(&iter, &address);
|
pr_info("%s: address(%s) is paired(%d) or connected(%d)\n", __func__, address, paired, connected);
|
}
|
continue;
|
}
|
|
remove_device(proxy);
|
}
|
|
return;
|
}
|
|
int bt_get_eir_data(char *address, char *eir_data, int eir_len)
|
{
|
DBusMessageIter iter;
|
DBusMessageIter array;
|
unsigned char *data;
|
int len, data_len = 0;
|
struct GDBusProxy *proxy;
|
|
if (!address || (strlen(address) < 17)) {
|
pr_err("%s: invalid address\n", __func__);
|
return -1;
|
}
|
|
if (!eir_data) {
|
pr_err("%s: invalid eir_data buf\n", __func__);
|
return -1;
|
}
|
|
proxy = find_device_by_address(address);
|
if (proxy == NULL)
|
return -1;
|
|
if (g_dbus_proxy_get_property(proxy, "EirData", &iter) == FALSE) {
|
pr_err("%s: get EirData data failed\n", __func__);
|
return- 1;
|
}
|
|
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) {
|
pr_err("%s: iter type != DBUS_TYPE_ARRAY\n", __func__);
|
return -1;
|
}
|
|
dbus_message_iter_recurse(&iter, &array);
|
|
if (!dbus_type_is_fixed(dbus_message_iter_get_arg_type(&array))) {
|
pr_err("%s: dbus type isn't fixed\n", __func__);
|
return -1;
|
}
|
|
if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_BYTE) {
|
pr_err("%s: iter type != DBUS_TYPE_BYTE\n", __func__);
|
return -1;
|
}
|
|
dbus_message_iter_get_fixed_array(&array, &data, &data_len);
|
if (data_len <= 0) {
|
pr_err("%s: get EirData data failed, len = %d\n", __func__, data_len);
|
return -1;
|
}
|
|
pr_err("%s: get EirData data, data_len = %d\n", __func__, data_len);
|
|
bt_shell_hexdump((void *)data, data_len * sizeof(*data));
|
|
len = data_len > eir_len ? eir_len : data_len;
|
memset(eir_data, 0, eir_len);
|
memcpy(eir_data, data, len);
|
|
return len;
|
}
|
|
int bt_start_discovery(unsigned int mseconds, RK_BT_SCAN_TYPE scan_type)
|
{
|
int ret;
|
|
if (bt_is_scaning()) {
|
pr_info("%s: devices discovering\n", __func__);
|
return -1;
|
}
|
|
g_bt_scan_info.is_scaning = true;
|
g_bt_scan_info.scan_type = scan_type;
|
|
reomve_unpaired_device();
|
|
pr_info("=== scan on ===\n");
|
//exec_command_system("hciconfig hci0 noscan");
|
if(cmd_scan("on") < 0) {
|
bt_discovery_state_send(RK_BT_DISC_START_FAILED);
|
}
|
|
return 0;
|
}
|
|
int bt_cancel_discovery(RK_BT_DISCOVERY_STATE state)
|
{
|
int wait_cnt = 100;
|
|
if (!g_bt_scan_info.is_scaning) {
|
pr_info("%s: discovery canceling or canceled\n", __func__);
|
return 0;
|
}
|
|
pr_info("%s thread tid = %lu\n", __func__, pthread_self());
|
|
if (bt_is_discovering()) {
|
pr_info("=== %s scan off again===\n", __func__);
|
cmd_scan("off");
|
}
|
|
return 0;
|
}
|
|
bool bt_is_scaning()
|
{
|
return bt_is_discovering() || g_bt_scan_info.is_scaning;
|
}
|
|
bool bt_is_discovering()
|
{
|
DBusMessageIter iter;
|
dbus_bool_t valbool;
|
|
if (check_default_ctrl() == FALSE)
|
return false;
|
|
if (!default_ctrl->proxy) {
|
pr_info("%s: Invalid proxy\n", __func__);
|
return false;
|
}
|
|
if (g_dbus_proxy_get_property(default_ctrl->proxy, "Discovering", &iter) == FALSE) {
|
pr_info("WARING: Bluetooth connected, but can't get Discovering!\n");
|
return false;
|
}
|
|
dbus_message_iter_get_basic(&iter, &valbool);
|
|
return valbool;
|
}
|
|
/*
|
* / # hcitool con
|
* Connections:
|
* > ACL 64:A2:F9:68:1E:7E handle 1 state 1 lm SLAVE AUTH ENCRYPT
|
* > LE 60:9C:59:31:7F:B9 handle 16 state 1 lm SLAVE
|
*/
|
bool bt_is_connected()
|
{
|
bool ret = false;
|
char buf[1024];
|
|
memset(buf, 0, 1024);
|
exec_command("hcitool con", buf, 1024);
|
usleep(300000);
|
|
if (strstr(buf, "ACL") || strstr(buf, "LE"))
|
ret = true;
|
|
return ret;
|
}
|
|
RK_BT_PLAYROLE_TYPE bt_get_playrole_by_addr(char *addr)
|
{
|
GDBusProxy *proxy;
|
|
if (!addr || (strlen(addr) < 17)) {
|
pr_err("%s: Invalid address\n", __func__);
|
return -1;
|
}
|
|
proxy = find_device_by_address(addr);
|
if (!proxy) {
|
pr_err("%s: Invalid proxy\n", __func__);
|
return -1;
|
}
|
|
return a2dp_master_get_playrole(proxy);
|
}
|
|
void source_set_reconnect_tag(bool reconnect)
|
{
|
g_bt_source_info.is_reconnected = reconnect;
|
}
|
|
void source_stop_connecting()
|
{
|
if(g_bt_source_info.is_connecting) {
|
pr_info("%s\n", __func__);
|
if(!disconnect_by_address(g_bt_source_info.connect_address))
|
sleep(3);
|
}
|
}
|
|
bool get_device_connected_properties(char *addr)
|
{
|
GDBusProxy *proxy;
|
DBusMessageIter iter;
|
dbus_bool_t is_connected = FALSE;
|
|
if (!addr || (strlen(addr) < 17)) {
|
pr_err("%s: Invalid address\n", __func__);
|
return false;
|
}
|
|
proxy = find_device_by_address(addr);
|
if (!proxy) {
|
pr_info("%s: Invalid proxy\n", __func__);
|
return false;
|
}
|
|
if (g_dbus_proxy_get_property(proxy, "Connected", &iter))
|
dbus_message_iter_get_basic(&iter, &is_connected);
|
else
|
pr_info("%s: Can't get connected status\n", __func__);
|
|
return is_connected;
|
}
|
