#include <errno.h>
#include <fcntl.h>
#include <paths.h>
#include <string.h>
#include <unistd.h>
#include <sys/prctl.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <signal.h>

#include <DeviceIo.h>
#include <Rk_wifi.h>
#include <RkBtBase.h>
#include <RkBle.h>
#include <RkBtSource.h>
#include <RkBtHfp.h>
#include <RkBleClient.h>
#include <RkBtObex.h>
#include <RkBtPan.h>

#include "avrcpctrl.h"
#include "bluez_ctrl.h"
#include "a2dp_source/a2dp_masterctrl.h"
#include "a2dp_source/shell.h"
#include "spp_server/spp_server.h"
#include "bluez_alsa_client/ctl-client.h"
#include "bluez_alsa_client/rfcomm_msg.h"
#include "obex_client.h"
#include "gatt_client.h"
#include "utility.h"
#include "slog.h"

extern volatile bt_control_t bt_control;

#define BT_CONFIG_FAILED 2
#define BT_CONFIG_OK 1

typedef struct {
	int sockfd;
	pthread_t tid;
	RK_BT_SINK_UNDERRUN_CB cb;
} underrun_handler_t;

static underrun_handler_t g_underrun_handler = {
	-1, 0, NULL,
};

static int bt_hal_source_close(bool disconnect);
static int bt_hal_hfp_close(bool disconnect);
static int bt_hal_ble_stop(bool disconnect);
static void bt_hal_ble_client_close(bool disconnect);
static int bt_hal_sink_close(bool disconnect);

#if 0
void rk_printf_system_time(char *tag)
{
	struct timeval tv;
	gettimeofday(&tv, NULL);

	printf("---%s: time: %lld ms\n", tag, tv.tv_sec * 1000 + tv.tv_usec/1000 + tv.tv_usec%1000);
}
#endif

/*****************************************************************
 *            Rockchip bluetooth LE api                      *
 *****************************************************************/
int rk_bt_ble_set_visibility(const int visiable, const int connect)
{
	pr_info("bluez don't support %s\n", __func__);
	return 0;
}

int rk_ble_start(RkBleContent *ble_content)
{
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	if(ble_is_open()) {
		pr_info("%s: ble has been opened\n", __func__);
		return -1;
	}

	pr_info("%s, tid(%lu)\n", __func__, pthread_self());
	if(ble_client_is_open()) {
		pr_info("ble client has been opened, close ble client\n");
		rk_ble_client_close();
	}

	if(rk_bt_control(BT_BLE_OPEN, NULL, 0) < 0)
		return -1;

	ble_state_send(RK_BLE_STATE_IDLE);
	return 0;
}

static int bt_hal_ble_stop(bool disconnect)
{
	if (!ble_is_open()) {
		pr_info("%s: ble has been closed\n", __func__);
		return -1;
	}

	pr_info("%s, tid(%lu)\n", __func__, pthread_self());
	bt_close_ble(disconnect);
	return 0;
}

int rk_ble_stop()
{
	return bt_hal_ble_stop(true);
}

int rk_ble_get_state(RK_BLE_STATE *p_state)
{
	ble_get_state(p_state);
	return 0;
}

int rk_ble_set_address(char *address)
{
	return ble_set_address(address);
}

int rk_ble_write(const char *uuid, char *data, int len)
{
	RkBleConfig ble_cfg;

	if (!ble_is_open()) {
		pr_info("ble isn't open, please open\n");
		return -1;
	}

	ble_cfg.len = len > BT_ATT_MAX_VALUE_LEN ? BT_ATT_MAX_VALUE_LEN : len;
	memcpy(ble_cfg.data, data, ble_cfg.len);
	strcpy(ble_cfg.uuid, uuid);
	rk_bt_control(BT_BLE_WRITE, &ble_cfg, sizeof(RkBleConfig));

	return 0;
}

int rk_ble_register_status_callback(RK_BLE_STATE_CALLBACK cb)
{
	ble_register_state_callback(cb);
	return 0;
}

void rk_ble_register_mtu_callback(RK_BT_MTU_CALLBACK cb)
{
	ble_register_mtu_callback(cb);
}

int rk_ble_register_recv_callback(RK_BLE_RECV_CALLBACK cb)
{
	if (cb) {
		pr_info("BlueZ does not support this interface."
			"Please set the callback function when init BT.\n");
	}

	return 0;
}

void rk_ble_register_request_data_callback(RK_BLE_REQUEST_DATA cb)
{
	if (cb) {
		pr_info("BlueZ does not support this interface."
			"Please set the callback function when init BT.\n");
	}
}

int rk_ble_disconnect()
{
	if (!ble_is_open()) {
		pr_info("%s: ble isn't open, please open\n", __func__);
		return -1;
	}

	pr_info("%s, tid(%lu)\n", __func__, pthread_self());
	return ble_disconnect();
}

void rk_ble_set_local_privacy(bool local_privacy)
{
	pr_info("bluez don't support %s\n", __func__);
}

int rk_ble_set_adv_interval(unsigned short adv_int_min, unsigned short adv_int_max)
{
	return ble_set_adv_interval(adv_int_min, adv_int_max);
}

/*****************************************************************
 *            Rockchip bluetooth LE Client api                      *
 *****************************************************************/
void rk_ble_client_register_state_callback(RK_BLE_CLIENT_STATE_CALLBACK cb)
{
	gatt_client_register_state_callback(cb);
}

void rk_ble_client_register_recv_callback(RK_BLE_CLIENT_RECV_CALLBACK cb)
{
	gatt_client_register_recv_callback(cb);
}

void rk_ble_client_register_mtu_callback(RK_BT_MTU_CALLBACK cb)
{
	ble_register_mtu_callback(cb);
}

int rk_ble_client_open(bool mtu_change)
{
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	if(ble_client_is_open()) {
		pr_info("%s: ble client has been opened\n", __func__);
		return -1;
	}

	if(ble_is_open()) {
		pr_info("%s: ble has been opened, close ble\n", __func__);
		rk_ble_stop();
	}

	gatt_client_open();
	bt_control.is_ble_client_open = true;
	gatt_client_state_send(RK_BLE_CLIENT_STATE_IDLE);
	return 0;
}

static void bt_hal_ble_client_close(bool disconnect)
{
	if(!ble_client_is_open()) {
		pr_info("%s: ble client has been closed\n", __func__);
		return;
	}

	if(disconnect) {
		if(!ble_disconnect())
			sleep(3);
	}

	gatt_client_close();
	bt_control.is_ble_client_open = false;
}

void rk_ble_client_close()
{
	bt_hal_ble_client_close(true);
}

RK_BLE_CLIENT_STATE rk_ble_client_get_state()
{
	if(!ble_client_is_open()) {
		pr_info("%s: ble client isn't open, please open\n", __func__);
		return -1;
	}

	return gatt_client_get_state();
}

int rk_ble_client_connect(char *address)
{
	if(!ble_client_is_open()) {
		pr_info("%s: ble client isn't open, please open\n", __func__);
		return -1;
	}

	return connect_by_address(address);
}

int rk_ble_client_disconnect(char *address)
{
	if(!ble_client_is_open()) {
		pr_info("%s: ble client isn't open, please open\n", __func__);
		return -1;
	}

	return ble_disconnect();
}

int rk_ble_client_get_service_info(char *address, RK_BLE_CLIENT_SERVICE_INFO *info)
{
	if(!ble_client_is_open()) {
		pr_info("%s: ble client isn't open, please open\n", __func__);
		return -1;
	}

	return gatt_client_get_service_info(address, info);
}

int rk_ble_client_read(const char *uuid)
{
	if(!ble_client_is_open()) {
		pr_info("%s: ble client isn't open, please open\n", __func__);
		return -1;
	}

	return gatt_client_read(uuid, 0);
}

int rk_ble_client_write(const char *uuid, char *data, int data_len)
{
	if(!ble_client_is_open()) {
		pr_info("%s: ble client isn't open, please open\n", __func__);
		return -1;
	}

	return gatt_client_write(uuid, data, data_len, 0);
}

bool rk_ble_client_is_notifying(const char *uuid)
{
	if(!ble_client_is_open()) {
		pr_info("%s: ble client isn't open, please open\n", __func__);
		return -1;
	}

	return gatt_client_is_notifying(uuid);
}

int rk_ble_client_notify(const char *uuid, bool is_indicate, bool enable)
{
	if(!ble_client_is_open()) {
		pr_info("%s: ble client isn't open, please open\n", __func__);
		return -1;
	}

	return gatt_client_notify(uuid, enable);
}

int rk_ble_client_get_eir_data(char *address, char *eir_data, int len)
{
	if(!ble_client_is_open()) {
		pr_err("ble client isn't open, please open\n");
		return -1;
	}

	return gatt_client_get_eir_data(address, eir_data, len);
}

int rk_ble_client_default_data_length()
{
	pr_info("bluez don't support %s\n", __func__);
	return -1;
}

/*****************************************************************
 *            Rockchip bluetooth master api                      *
 *****************************************************************/
static pthread_t g_btmaster_thread = 0;

static void* _btmaster_autoscan_and_connect(void *data)
{
	BtScanParam scan_param;
	BtDeviceInfo *start;
	int max_rssi = -100;
	int ret = 0;
	char target_address[17] = {0};
	bool target_vaild = false;
	int scan_cnt, i;

	/* Scan bluetooth devices */
	scan_param.mseconds = 10000; /* 10s for default */
	scan_param.item_cnt = 0;
	scan_cnt = 3;

	prctl(PR_SET_NAME,"_btmaster_autoscan_and_connect");

scan_retry:
	pr_info("=== BT_SOURCE_SCAN ===\n");
	ret = rk_bt_source_scan(&scan_param);
	if (ret && (scan_cnt--)) {
		sleep(1);
		goto scan_retry;
	} else if (ret) {
		pr_info("%s: ERROR: Scan error!\n", __func__);
		a2dp_master_event_send(BT_SOURCE_EVENT_CONNECT_FAILED, "", "");
		return NULL;
	}

	/*
	 * Find the audioSink device from the device list,
	 * which has the largest rssi value.
	 */
	max_rssi = -100;
	for (i = 0; i < scan_param.item_cnt; i++) {
		start = &scan_param.devices[i];
		if (start->rssi_valid && (start->rssi > max_rssi) &&
			(!strcmp(start->playrole, "Audio Sink"))) {
			pr_info("#%02d Name:%s\n", i, start->name);
			pr_info("\tAddress:%s\n", start->address);
			pr_info("\tRSSI:%d\n", start->rssi);
			pr_info("\tPlayrole:%s\n", start->playrole);
			max_rssi = start->rssi;

			memcpy(target_address, start->address, 17);
			target_vaild = true;
		}
	}

	if (!target_vaild) {
		pr_info("=== Cannot find audio Sink devices. ===\n");
		a2dp_master_event_send(BT_SOURCE_EVENT_CONNECT_FAILED, "", "");
		return NULL;
	} else if (max_rssi < -80) {
		pr_info("=== BT SOURCE RSSI is is too weak !!! ===\n");
		a2dp_master_event_send(BT_SOURCE_EVENT_CONNECT_FAILED, "", "");
		return NULL;
	}

	/* Connect target device */
	if (!a2dp_master_status(NULL, 0, NULL, 0))
		a2dp_master_connect(target_address);

	pr_info("%s: Exit _btmaster_autoscan_and_connect thread!\n", __func__);
	return NULL;
}

/*
 * Turn on Bluetooth and scan SINK devices.
 * Features:
 *     1. turn on Bluetooth
 *     2. enter the bt source mode
 *     3. Scan surrounding SINK type devices
 *     4. If the SINK device is found, the device with the strongest
 *        signal is automatically connected.
 * Return:
 *     0: The function is executed successfully and needs to listen
 *        for Bluetooth connection events.
 *    -1: Function execution failed.
 */
int rk_bt_source_auto_connect_start(void *userdata, RK_BT_SOURCE_CALLBACK cb)
{
	int ret;

	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	if (g_btmaster_thread) {
		pr_info("%s: The last operation is still in progress, please stop then start\n", __func__);
		return -1;
	}

	/* Register callback and userdata */
	rk_bt_source_register_status_cb(userdata, cb);

	ret = rk_bt_source_open();
	if (ret < 0)
		return ret;

	/* Create thread to do connect task. */
	ret = pthread_create(&g_btmaster_thread, NULL,
						 _btmaster_autoscan_and_connect, NULL);
	if (ret) {
		pr_info("%s: _btmaster_autoscan_and_connect thread create failed!\n", __func__);
		return -1;
	}

	return 0;
}

int rk_bt_source_auto_connect_stop(void)
{
	if (g_btmaster_thread) {
		pthread_join(g_btmaster_thread, NULL);
		g_btmaster_thread = 0;
	}

	return rk_bt_source_close();
}

int rk_bt_source_open()
{
	pr_info("%s, tid(%lu)\n", __func__, pthread_self());
	if (!bt_is_open()) {
		pr_err("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	if (g_btmaster_thread) {
		pr_err("%s: The last operation is still in progress\n", __func__);
		return -1;
	}

	if (bt_source_is_open()) {
		pr_info("%s: bt source has been opened\n", __func__);
		return -1;
	}

	if (bt_sink_is_open()){
		pr_info("%s: bt sink has been opened, close bt sink", __func__);
		rk_bt_sink_close();
	}

	if (bt_interface(BT_SOURCE_OPEN, NULL) < 0) {
		bt_control.is_a2dp_source_open = false;
		return -1;
	}

	reconn_last_devices(BT_DEVICES_A2DP_SINK);
	bt_control.is_a2dp_source_open = true;

	return 0;
}

static int bt_hal_source_close(bool disconnect)
{
	pr_info("%s, tid(%lu)\n", __func__, pthread_self());
	if(rk_bt_is_discovering())
		rk_bt_cancel_discovery();

	if (!bt_source_is_open()) {
		pr_info("%s: bt source has been closed\n", __func__);
		return -1;
	}

	a2dp_master_save_status(NULL);
	source_set_reconnect_tag(false);
	bt_close_source(disconnect);
	a2dp_master_deregister_cb();

	bt_control.is_a2dp_source_open = false;
	return 0;
}

int rk_bt_source_close()
{
	return bt_hal_source_close(true);
}

int rk_bt_source_scan(BtScanParam *data)
{
	if (!bt_source_is_open()) {
		pr_info("%s: bt source isn't open, please open\n", __func__);
		return -1;
	}

	source_set_reconnect_tag(false);
	return a2dp_master_scan(data, sizeof(BtScanParam), SCAN_TYPE_BREDR);
}

int rk_bt_source_connect_by_addr(char *address)
{
	char bd_addr[18];
	memset(bd_addr, 0, 18);

	if (!bt_source_is_open()) {
		pr_info("%s: bt source isn't open, please open\n", __func__);
		return -1;
	}

	pr_info("%s thread tid = %lu\n", __func__, pthread_self());
	return a2dp_master_connect(address);
}

int rk_bt_source_disconnect_by_addr(char *address)
{
	if (!bt_source_is_open()) {
		pr_info("%s: bt source isn't open, please open\n", __func__);
		return -1;
	}

	pr_info("%s thread tid = %lu\n", __func__, pthread_self());
	return disconnect_by_address(address);
}

int rk_bt_source_disconnect()
{
	if (!bt_source_is_open()) {
		pr_info("%s: bt source isn't open, please open\n", __func__);
		return -1;
	}

	return disconnect_current_devices();
}

int rk_bt_source_remove(char *address)
{
	if (!bt_source_is_open()) {
		pr_info("%s: bt source isn't open, please open\n", __func__);
		return -1;
	}

	return remove_by_address(address);
}

int rk_bt_source_register_status_cb(void *userdata, RK_BT_SOURCE_CALLBACK cb)
{
	a2dp_master_register_cb(userdata,  cb);
	return 0;
}

int rk_bt_source_get_device_name(char *name, int len)
{
	return rk_bt_get_device_name(name, len);
}

int rk_bt_source_get_device_addr(char *addr, int len)
{
	return rk_bt_get_device_addr(addr, len);
}

int rk_bt_source_get_status(RK_BT_SOURCE_STATUS *pstatus, char *name, int name_len,
                                    char *address, int addr_len)
{
	if (!pstatus)
		return 0;

	if (a2dp_master_status(address, addr_len, name, name_len))
		*pstatus = BT_SOURCE_STATUS_CONNECTED;
	else
		*pstatus = BT_SOURCE_STATUS_DISCONNECTED;

	return 0;
}

int rk_bt_source_resume()
{
	pr_info("bluez don't support %s\n", __func__);
	return 0;
}

int rk_bt_source_stop()
{
	pr_info("bluez don't support %s\n", __func__);
	return 0;
}

int rk_bt_source_pause()
{
	pr_info("bluez don't support %s\n", __func__);
	return 0;
}

int rk_bt_source_vol_up()
{
	pr_info("bluez don't support %s\n", __func__);
	return 0;
}

int rk_bt_source_vol_down()
{
	pr_info("bluez don't support %s\n", __func__);
	return 0;
}

int rk_bt_source_set_vol(int vol)
{
	pr_info("bluez don't support %s\n", __func__);
	return 0;
}

/*****************************************************************
 *            Rockchip bluetooth sink api                        *
 *****************************************************************/
void *sink_underrun_listen(void *arg)
{
	int ret = 0;
	char buff[100] = {0};
	struct sockaddr_un clientAddr;
	struct sockaddr_un serverAddr;
	socklen_t addr_len;

	g_underrun_handler.sockfd = socket(AF_UNIX, SOCK_DGRAM, 0);
	if (g_underrun_handler.sockfd < 0) {
		pr_err("%s: Create socket failed!\n", __func__);
		return NULL;
	}

	serverAddr.sun_family = AF_UNIX;
	strcpy(serverAddr.sun_path, "/tmp/rk_deviceio_a2dp_underrun");

	system("rm -rf /tmp/rk_deviceio_a2dp_underrun");
	ret = bind(g_underrun_handler.sockfd, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
	if (ret < 0) {
		pr_err("%s: Bind Local addr failed!\n", __func__);
		return NULL;
	}

	pr_info("%s: underrun listen...\n", __func__);
	while(1) {
		memset(buff, 0, sizeof(buff));
		ret = recvfrom(g_underrun_handler.sockfd, buff, sizeof(buff), 0, (struct sockaddr *)&clientAddr, &addr_len);
		if (ret <= 0) {
			if (ret == 0)
				pr_info("%s: socket closed!\n", __func__);
			break;
		}
		pr_info("%s: recv a message(%s)\n", __func__, buff);

		if (!bt_sink_is_open())
			break;

		if (!strstr(buff, "a2dp underrun;")) {
			pr_warning("%s: recv a unsupport msg:%s\n", __func__, buff);
			continue;
		}

		if (g_underrun_handler.cb)
			g_underrun_handler.cb();
		else
			break;
	}

	pr_info("%s: Exit underrun listen thread!\n", __func__);
	return NULL;
}

static int underrun_listen_thread_create(RK_BT_SINK_UNDERRUN_CB cb)
{
	pr_info("%s: underrun_listen_thread_create\n", __func__);

	g_underrun_handler.cb = cb;

	/* Create a thread to listen for bluez-alsa sink underrun. */
	if (!g_underrun_handler.tid) {
		if (pthread_create(&g_underrun_handler.tid, NULL, sink_underrun_listen, NULL)) {
			pr_err("%s: Create underrun listen pthread failed\n", __func__);
			return -1;
		}

		pthread_setname_np(g_underrun_handler.tid, "underrun_listen");
	}

	return 0;
}

static void underrun_listen_thread_delete()
{
	pr_debug("%s enter\n", __func__);
	if (g_underrun_handler.sockfd >= 0) {
		shutdown(g_underrun_handler.sockfd, SHUT_RDWR);
		g_underrun_handler.sockfd = -1;
	}

	if(g_underrun_handler.tid) {
		pthread_join(g_underrun_handler.tid, NULL);
		g_underrun_handler.tid = 0;
	}

	g_underrun_handler.cb = NULL;
	pr_debug("%s exit\n", __func__);
}
int rk_bt_sink_register_callback(RK_BT_SINK_CALLBACK cb)
{
	a2dp_sink_register_cb(cb);
	return 0;
}

void rk_bt_sink_register_underurn_callback(RK_BT_SINK_UNDERRUN_CB cb)
{
	underrun_listen_thread_create(cb);
}

int rk_bt_sink_register_volume_callback(RK_BT_SINK_VOLUME_CALLBACK cb)
{
	a2dp_sink_register_volume_cb(cb);
	return 0;
}

int rk_bt_sink_register_track_callback(RK_BT_AVRCP_TRACK_CHANGE_CB cb)
{
	a2dp_sink_register_track_cb(cb);
	return 0;
}

int rk_bt_sink_register_position_callback(RK_BT_AVRCP_PLAY_POSITION_CB cb)
{
	a2dp_sink_register_position_cb(cb);
	return 0;
}

int rk_bt_sink_get_default_dev_addr(char *addr, int len)
{
	return bt_get_default_dev_addr(addr, len);
}

int rk_bt_sink_open()
{
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	if (bt_sink_is_open()) {
		pr_info("%s: bt sink has been opened\n", __func__);
		return -1;
	}

	if(bt_source_is_open()) {
		pr_info("%s: bt source has been opened, close bt source", __func__);
		rk_bt_source_close();
	}

	if (bt_interface(BT_SINK_OPEN, NULL) < 0) {
		bt_control.is_a2dp_sink_open = false;
		return -1;
	}

	reconn_last_devices(BT_DEVICES_A2DP_SOURCE);

	bt_control.is_a2dp_sink_open = true;

	return 0;
}

static int bt_hal_sink_close(bool disconnect)
{
	if (!bt_sink_is_open()) {
		pr_info("%s: bt sink has been closed\n", __func__);
		return -1;
	}

	bt_close_sink(disconnect);
	underrun_listen_thread_delete();
	a2dp_sink_clear_cb();
	return 0;
}

int rk_bt_sink_close()
{
	return bt_hal_sink_close(true);
}

int rk_bt_sink_get_state(RK_BT_SINK_STATE *pState)
{
	return a2dp_sink_status(pState);
}

int rk_bt_sink_play(void)
{
	if (bt_control_cmd_send(BT_RESUME_PLAY) < 0)
		return -1;

	return 0;
}

int rk_bt_sink_pause(void)
{
	if (bt_control_cmd_send(BT_PAUSE_PLAY) < 0)
		return -1;

	return 0;
}

int rk_bt_sink_prev(void)
{
	if (bt_control_cmd_send(BT_AVRCP_BWD) < 0)
		return -1;

	return 0;
}

int rk_bt_sink_next(void)
{
	if (bt_control_cmd_send(BT_AVRCP_FWD) < 0)
		return -1;

	return 0;
}

int rk_bt_sink_stop(void)
{
	if (bt_control_cmd_send(BT_AVRCP_STOP) < 0)
		return -1;

	return 0;
}

int rk_bt_sink_get_play_status()
{
	if (!bt_sink_is_open()) {
		pr_info("%s: bt sink isn't open, please open\n", __func__);
		return -1;
	}

	return get_play_status_avrcp();
}

bool rk_bt_sink_get_poschange()
{
	if (!bt_sink_is_open()) {
		pr_info("%s: bt sink isn't open, please open\n", __func__);
		return false;
	}

	return get_poschange_avrcp();
}

int rk_bt_sink_disconnect()
{
	if (!bt_sink_is_open()) {
		pr_info("%s: bt sink isn't open, please open\n", __func__);
		return -1;
	}

	return disconnect_current_devices();
}

int rk_bt_sink_connect_by_addr(char *addr)
{
	if (!bt_sink_is_open()) {
		pr_info("%s: bt sink isn't open, please open\n", __func__);
		return -1;
	}

	return connect_by_address(addr);
}

int rk_bt_sink_disconnect_by_addr(char *addr)
{
	if(bt_sink_is_open()) {
		return disconnect_by_address(addr);
	}

	return -1;
}

static int _get_bluealsa_plugin_volume_ctrl_info(char *name, int *value)
{
	char buff[1024] = {0};
	char ctrl_name[128] = {0};
	int ctrl_value = 0;
	char *start = NULL;
	char *end = NULL;

	if (!name && !value)
		return -1;

	if (name) {
		exec_command("amixer -D bluealsa scontents", buff, sizeof(buff));
		start = strstr(buff, "Simple mixer control ");
		end = strstr(buff, "A2DP'");
		if (!start || (!strstr(start, "A2DP")))
			return -1;

		start += strlen("Simple mixer control '");
		end += strlen("A2DP");
		if ((end - start) < strlen(" - A2DP"))
			return -1;

		memcpy(ctrl_name, start, end-start);
		memcpy(name, ctrl_name, strlen(ctrl_name));
	}

	if (value) {
		start = strstr(buff, "Front Left: Capture ");
		if (!start)
			return -1;

		start += strlen("Front Left: Capture ");
		if ((*start < '0') || (*start > '9'))
			return -1;

		/* Max volume value:127, the length of volume value string must be <= 3 */
		ctrl_value += (*start - '0');
		start++;
		if ((*start >= '0') && (*start <= '9'))
			ctrl_value = 10 * ctrl_value + (*start - '0');
		start++;
		if ((*start >= '0') && (*start <= '9'))
			ctrl_value = 10 * ctrl_value + (*start - '0');

		*value = ctrl_value;
	}

	return 0;
}

static int _set_bluealsa_plugin_volume_ctrl_info(char *name, int value)
{
	char buff[1024] = {0};
	char cmd[256] = {0};
	char ctrl_name[128] = {0};
	int new_volume = 0;

	if (!name)
		return -1;

	sprintf(cmd, "amixer -D bluealsa sset \"%s\" %d", name, value);
	exec_command(cmd, buff, sizeof(buff));

	if (_get_bluealsa_plugin_volume_ctrl_info(ctrl_name, &new_volume) == -1)
		return -1;
	if (new_volume != value)
		return -1;

	return 0;
}

int rk_bt_sink_volume_up(void)
{
	char ctrl_name[128] = {0};
	int current_volume = 0;
	int ret = 0;

	if (!bt_sink_is_open()) {
		pr_info("%s: bt sink isn't open, please open\n", __func__);
		return -1;
	}

	ret = _get_bluealsa_plugin_volume_ctrl_info(ctrl_name, &current_volume);
	if (ret)
		return ret;

	ret = _set_bluealsa_plugin_volume_ctrl_info(ctrl_name, current_volume + 8);
	return ret;
}

int rk_bt_sink_volume_down(void)
{
	char ctrl_name[128] = {0};
	int current_volume = 0;
	int ret = 0;

	if (!bt_sink_is_open()) {
		pr_info("%s: bt sink isn't open, please open\n", __func__);
		return -1;
	}

	ret = _get_bluealsa_plugin_volume_ctrl_info(ctrl_name, &current_volume);
	if (ret)
		return ret;

	if (current_volume < 8)
		current_volume = 0;
	else
		current_volume -= 8;

	ret = _set_bluealsa_plugin_volume_ctrl_info(ctrl_name, current_volume);
	return ret;
}

int rk_bt_sink_set_volume(int volume)
{
	char ctrl_name[128] = {0};
	int new_volume = 0;
	int ret = 0;

	if (!bt_sink_is_open()) {
		pr_info("%s: bt sink isn't open, please open\n", __func__);
		return -1;
	}

	if (volume < 0)
		new_volume = 0;
	else if (volume > 127)
		new_volume = 127;
	else
		new_volume = volume;

	ret = _get_bluealsa_plugin_volume_ctrl_info(ctrl_name, NULL);
	if (ret)
		return ret;

	ret = _set_bluealsa_plugin_volume_ctrl_info(ctrl_name, new_volume);
	return ret;
}

void rk_bt_sink_set_alsa_device(char *alsa_dev)
{
	pr_info("bluez don't support %s\n", __func__);
}

/*****************************************************************
 *            Rockchip bluetooth spp api                         *
 *****************************************************************/
int rk_bt_spp_open()
{
	int ret = 0;

	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	ret = bt_spp_server_open();
	return ret;
}

int rk_bt_spp_register_status_cb(RK_BT_SPP_STATUS_CALLBACK cb)
{
	bt_spp_register_status_callback(cb);
	return 0;
}

int rk_bt_spp_register_recv_cb(RK_BT_SPP_RECV_CALLBACK cb)
{
	bt_spp_register_recv_callback(cb);
	return 0;
}

int rk_bt_spp_close(void)
{
	bt_spp_server_close();
	return 0;
}

int rk_bt_spp_get_state(RK_BT_SPP_STATE *pState)
{
	if (pState)
		*pState = bt_spp_get_status();

	return 0;
}

int rk_bt_spp_write(char *data, int len)
{
	pr_info("bluez don't support %s\n", __func__);
	return 0;
}

int rk_bt_spp_listen()
{
	pr_info("bluez don't support %s\n", __func__);

	return 0;
}

int rk_bt_spp_connect(char *address)
{
	pr_info("bluez don't support %s\n", __func__);

	return 0;
}

int rk_bt_spp_disconnect(char *address)
{
	pr_info("bluez don't support %s\n", __func__);

	return 0;
}

//====================================================//
static GMainLoop *bt_main_loop = NULL;
static pthread_t main_loop_thread = 0;
GMainContext *Bluez_Context = NULL;

static void *main_loop_init_thread(void *data)
{
#ifdef DefGContext
	bt_main_loop = g_main_loop_new(NULL, FALSE);
	pr_info("%s: bt mainloop run with default context\n", __func__);
#else
	Bluez_Context = g_main_context_new();
	bt_main_loop = g_main_loop_new(Bluez_Context, FALSE);
	pr_info("%s: bt mainloop run with Bluez_Context\n", __func__);
#endif

	g_main_loop_run(bt_main_loop);

	g_main_loop_unref(bt_main_loop);
	bt_main_loop = NULL;

	pr_info("%s: bt mainloop exit\n", __func__);
	return NULL;
}

static int main_loop_init()
{
	if (main_loop_thread)
		return 0;

	if (pthread_create(&main_loop_thread, NULL, main_loop_init_thread, NULL)) {
		pr_err("%s: Create bt mainloop thread failed\n", __func__);
		return -1;
	}

	pthread_setname_np(main_loop_thread, "main_loop_thread");
	return 0;
}

static int main_loop_deinit()
{
	if(bt_main_loop) {
		pr_info("%s bt mainloop quit\n", __func__);
		g_main_loop_quit(bt_main_loop);
	}

	if(main_loop_thread) {
		if (pthread_join(main_loop_thread, NULL)) {
			pr_err("%s: bt mainloop exit failed!\n", __func__);
			return -1;
		} else {
			pr_info("%s: bt mainloop thread exit ok\n", __func__);
		}
		main_loop_thread = 0;
	}

	return 0;
}

static pthread_t rk_bt_init_thread = 0;
static int _rk_bt_init(void *p)
{
	RkBtContent *p_bt_content = p;

	if (bt_is_open()) {
		pr_info("%s: bluetooth has been opened!\n", __func__);
		return -1;
	}

	pr_info("enter %s, tid(%lu)\n", __func__, pthread_self());
	bt_state_send(RK_BT_STATE_TURNING_ON);

	main_loop_init();

	setenv("DBUS_SESSION_BUS_ADDRESS", "unix:path=/var/run/dbus/system_bus_socket", 1);
	if (rk_bt_control(BT_OPEN, p_bt_content, sizeof(RkBtContent))) {
		bt_state_send(RK_BT_STATE_OFF);
		return -1;
	}

	pr_info("exit %s\n", __func__);
	return 0;
}

int rk_bt_init(RkBtContent *p_bt_content)
{
	if (rk_bt_init_thread)
		return 0;

	if (pthread_create(&rk_bt_init_thread, NULL, _rk_bt_init, (void *)p_bt_content)) {
		pr_err("%s: Create rk_bt_init_thread thread failed\n", __func__);
		return -1;
	}

	pthread_setname_np(rk_bt_init_thread, "rk_bt_init_thread");
	pthread_detach(rk_bt_init_thread);
	return 0;
}

int _rk_bt_deinit(void *p)
{
	rk_bt_init_thread = 0;

	if (!bt_is_open()) {
		pr_info("%s: bluetooth has been closed!\n", __func__);
		return -1;
	}

	pr_info("enter %s, tid(%lu)\n", __func__, pthread_self());
	bt_state_send(RK_BT_STATE_TURNING_OFF);

	bt_hal_hfp_close(false);
	bt_hal_sink_close(false);
	bt_hal_source_close(false);
	rk_bt_spp_close();
	bt_hal_ble_stop(false);
	bt_hal_ble_client_close(false);
	rk_bt_obex_pbap_deinit();
	bt_close();

	kill_task("obexd");
	kill_task("bluealsa");
	kill_task("bluealsa-aplay");
	kill_task("bluetoothctl");
	msleep(600);
	kill_task("bluetoothd");
	exec_command_system("hciconfig hci0 down");
	kill_task("rtk_hciattach");
	kill_task("brcm_patchram_plus1");

	main_loop_deinit();

	bt_deregister_bond_callback();
	bt_deregister_discovery_callback();
	bt_deregister_dev_found_callback();
	bt_deregister_name_change_callback();
	bt_control.is_bt_open = false;

	bt_state_send(RK_BT_STATE_OFF);
	bt_deregister_state_callback();
	pr_info("exit %s\n", __func__);

	return 0;
}

static pthread_t rk_bt_deinit_thread = 0;
int rk_bt_deinit()
{
	if (pthread_create(&rk_bt_deinit_thread, NULL, _rk_bt_deinit, NULL)){
		pr_err("%s: Create rk_bt_init_thread thread failed\n", __func__);
		return -1;
	}

	pthread_setname_np(rk_bt_deinit_thread, "rk_bt_deinit_thread");
	pthread_detach(rk_bt_deinit_thread);
	return 0;
}

void rk_bt_register_state_callback(RK_BT_STATE_CALLBACK cb)
{
	bt_register_state_callback(cb);
}

void rk_bt_register_bond_callback(RK_BT_BOND_CALLBACK cb)
{
	bt_register_bond_callback(cb);
}

void rk_bt_register_discovery_callback(RK_BT_DISCOVERY_CALLBACK cb)
{
	bt_register_discovery_callback(cb);
}

void rk_bt_register_dev_found_callback(RK_BT_DEV_FOUND_CALLBACK cb)
{
	bt_register_dev_found_callback(cb);
}

void rk_bt_register_name_change_callback(RK_BT_NAME_CHANGE_CALLBACK cb)
{
	bt_register_name_change_callback(cb);
}

/*
 * / # 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
 */
int rk_bt_is_connected(void)
{
	return bt_is_connected();
}

int rk_bt_set_class(int value)
{
	char cmd[100] = {0};

	pr_info("#%s value:0x%x\n", __func__, value);
	sprintf(cmd, "hciconfig hci0 class 0x%x", value);
	exec_command_system(cmd);
	msleep(100);

	return 0;
}

int rk_bt_set_sleep_mode()
{
	pr_info("bluez don't support %s\n", __func__);
	return 0;
}

int rk_bt_enable_reconnect(int value)
{
	int ret = 0;
	int fd = 0;

	fd = open("/userdata/cfg/bt_reconnect", O_RDWR | O_CREAT | O_TRUNC, 0666);
	if (fd < 0) {
		pr_err("open /userdata/cfg/bt_reconnect failed!\n");
		return -1;
	}

	if (value)
		ret = write(fd, "bluez-reconnect:enable", strlen("bluez-reconnect:enable"));
	else
		ret = write(fd, "bluez-reconnect:disable", strlen("bluez-reconnect:disable"));

	close(fd);
	return (ret < 0) ? -1 : 0;
}

int rk_bt_start_discovery(unsigned int mseconds, RK_BT_SCAN_TYPE scan_type)
{
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	pr_info("%s, tid(%lu)\n", __func__, pthread_self());
	return bt_start_discovery(mseconds, scan_type);
}

int rk_bt_cancel_discovery()
{
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	pr_info("%s, tid(%lu)\n", __func__, pthread_self());
	return bt_cancel_discovery(RK_BT_DISC_STOPPED_BY_USER);
}

bool rk_bt_is_discovering()
{
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return false;
	}

	return bt_is_scaning();
}

int rk_bt_get_scaned_devices(RkBtScanedDevice **dev_list, int *count)
{
	*count = 0;
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	return bt_get_scaned_devices(dev_list, count, false);
}

int rk_bt_free_scaned_devices(RkBtScanedDevice *dev_list)
{
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	return bt_free_scaned_devices(dev_list);
}

void rk_bt_display_devices()
{
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return;
	}

	bt_display_devices();
}

void rk_bt_display_paired_devices()
{
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return;
	}

	bt_display_paired_devices();
}

int rk_bt_get_eir_data(char *address, char *eir_data, int len)
{
	if (!bt_is_open()) {
		pr_err("bt isn't open, please open\n");
		return -1;
	}

	return bt_get_eir_data(address, eir_data, len);
}

int rk_bt_pair_by_addr(char *addr)
{
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	return pair_by_addr(addr);
}

int rk_bt_unpair_by_addr(char *addr)
{
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	return unpair_by_addr(addr);
}

int rk_bt_set_device_name(char *name)
{
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	return bt_set_device_name(name);
}

int rk_bt_get_device_name(char *name, int len)
{
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	return bt_get_device_name(name, len);
}

int rk_bt_get_device_addr(char *addr, int len)
{
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	return bt_get_device_addr(addr, len);
}

int rk_bt_get_paired_devices(RkBtScanedDevice **dev_list, int *count)
{
	*count = 0;
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	return bt_get_scaned_devices(dev_list, count, true);
}

int rk_bt_free_paired_devices(RkBtScanedDevice *dev_list)
{
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	return bt_free_scaned_devices(dev_list);
}

RK_BT_PLAYROLE_TYPE rk_bt_get_playrole_by_addr(char *addr)
{
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	return bt_get_playrole_by_addr(addr);
}

int rk_bt_set_visibility(const int visiable, const int connectable)
{
	if (visiable && connectable) {
		exec_command_system("hciconfig hci0 piscan");
		return 0;
	}

	exec_command_system("hciconfig hci0 noscan");
	usleep(20000);//20ms
	if (visiable)
		exec_command_system("hciconfig hci0 iscan");
	if (connectable)
		exec_command_system("hciconfig hci0 pscan");

	return 0;
}

void rk_bt_set_bsa_server_path(char *path)
{
	pr_info("bluez don't support %s\n", __func__);
}

bool rk_bt_get_connected_properties(char *addr)
{
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return false;
	}

	return get_device_connected_properties(addr);
}

int rk_bt_read_remote_device_name(char *addr, int transport)
{
	pr_info("bluez don't support %s\n", __func__);
	return -1;
}

RK_BT_DEV_PLATFORM_TYPE rk_bt_get_dev_platform(char *addr)
{
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	return (RK_BT_DEV_PLATFORM_TYPE)get_dev_platform(addr);
}

/*****************************************************************
 *            Rockchip bluetooth hfp-hf api                      *
 *****************************************************************/
static int g_ba_hfp_client = -1;

void rk_bt_hfp_register_callback(RK_BT_HFP_CALLBACK cb)
{
	rfcomm_hfp_hf_regist_cb(cb);
}

int rk_bt_hfp_open()
{
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	if (bt_hfp_is_open()) {
		pr_err("%s: bt hfp has already been opened!!!\n", __func__);
		return -1;
	}

	if(bt_source_is_open()) {
		pr_info("%s: bt source has been opened, close bt source", __func__);
		rk_bt_source_close();
	}

	if (bt_interface(BT_HFP_OPEN, NULL) < 0) {
		bt_control.is_hfp_open = false;
		return -1;
	}

	g_ba_hfp_client = bluealsa_open("hci0");
	if (g_ba_hfp_client < 0) {
		pr_err("%s: bt hfp connect to bluealsa server failed!", __func__);
		return -1;
	}

	rfcomm_listen_ba_msg_start();
	bt_control.is_hfp_open = true;

	reconn_last_devices(BT_DEVICES_HFP);

	return 0;
}

int rk_bt_hfp_sink_open(void)
{
	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	/* Already in sink mode or hfp mode? */
	if (bt_sink_is_open() || bt_hfp_is_open()) {
		pr_err("\"rk_bt_sink_open\" or \"rk_bt_hfp_open\" is called before calling this interface."
			"This situation is not allowed.");
		return -1;
	}

	if(bt_source_is_open()) {
		pr_info("%s: bt source has been opened, close bt source", __func__);
		rk_bt_source_close();
	}

	if (bt_interface(BT_HFP_SINK_OPEN, NULL) < 0) {
		bt_control.is_a2dp_sink_open = false;
		bt_control.is_hfp_open = false;
		return -1;
	}

	g_ba_hfp_client = bluealsa_open("hci0");
	if (g_ba_hfp_client < 0) {
		pr_err("%s: bt hfp connect to bluealsa server failed!", __func__);
		return -1;
	}

	rfcomm_listen_ba_msg_start();

	bt_control.is_a2dp_sink_open = true;
	bt_control.is_hfp_open = true;

	return 0;
}

static int bt_hal_hfp_close(bool disconnect)
{
	rfcomm_listen_ba_msg_stop();
	if (g_ba_hfp_client >= 0) {
		shutdown(g_ba_hfp_client, SHUT_RDWR);
		g_ba_hfp_client = -1;
	}

	if (!bt_hfp_is_open())
		return -1;

	rfcomm_hfp_send_event(RK_BT_HFP_DISCONNECT_EVT, NULL);
	rfcomm_hfp_hf_regist_cb(NULL);
	bt_control.is_hfp_open = false;

	if (bt_sink_is_open())
		return 0;

	if(disconnect) {
		if(!disconnect_current_devices())
			sleep(3);
	}

	exec_command_system("hciconfig hci0 noscan");
	kill_task("bluealsa-aplay");
	kill_task("bluealsa");

	return 0;
}

int rk_bt_hfp_close(void)
{
	return bt_hal_hfp_close(true);
}

static char *build_rfcomm_command(const char *cmd)
{

	static char command[512];
	bool at;

	command[0] = '\0';
	if (!(at = strncmp(cmd, "AT", 2) == 0))
		strcpy(command, "\r\n");

	strcat(command, cmd);
	strcat(command, "\r");
	if (!at)
		strcat(command, "\n");

	return command;
}

static int rk_bt_hfp_hp_send_cmd(char *cmd)
{
	char dev_addr[18] = {0};
	char result_buf[256] = {0};
	int ret = 0;
	bdaddr_t ba_addr;
	char *start = NULL;

	if (g_ba_hfp_client <= 0) {
		pr_err("%s ba hfp client is not valid!", __func__);
		return -1;
	}

	exec_command("hcitool con", result_buf, sizeof(result_buf));
	if ((start = strstr(result_buf, "ACL ")) != NULL) {
		start += 4; /* skip space */
		memcpy(dev_addr, start, 17);
	}

	pr_err("%s send cmd:%s to addr:%s", __func__, cmd, dev_addr);
	ret = str2ba(dev_addr, &ba_addr);
	if (ret) {
		pr_err("%s no valid hfp connection!", __func__);
		return -1;
	}

	ret = bluealsa_send_rfcomm_command(g_ba_hfp_client, ba_addr, build_rfcomm_command(cmd));
	if (ret)
		pr_err("%s ba hfp client cmd:/'%s/' failed!", __func__, cmd);

	return ret;
}

int rk_bt_hfp_pickup(void)
{
	if(rk_bt_hfp_hp_send_cmd("ATA")) {
		pr_info("%s: send ATA cmd error\n", __func__);
		return -1;
	}

	return 0;
}

int rk_bt_hfp_hangup(void)
{
	if(rk_bt_hfp_hp_send_cmd("AT+CHUP")) {
		pr_info("%s: send AT+CHUP cmd error\n", __func__);
		return -1;
	}

	return 0;
}

int rk_bt_hfp_dial_number(char *number)
{
	char buf[256];

	if(number == NULL || (strlen(number) == 0)) {
		pr_err("%s: empty number string\n", __func__);
		return -1;
	}

	if(strlen(number) > 250) {
		pr_err("%s: Invalid phone number(%s)\n", __func__, number);
		return -1;
	}

	memset(buf, 0, 256);
	sprintf(buf, "%s%s%s", "ATD", number, ";");

	return rk_bt_hfp_hp_send_cmd(buf);
}

int rk_bt_hfp_redial(void)
{
	return rk_bt_hfp_hp_send_cmd("AT+BLDN");
}

int rk_bt_hfp_report_battery(int value)
{
	int ret = 0;
	char at_cmd[100] = {0};
	static int done = 0;

	if ((value < 0) || (value > 9)) {
		pr_info("%s: ERROR: Invalid value, should within [0, 9]\n", __func__);
		return -1;
	}

	if (done == 0) {
		ret = rk_bt_hfp_hp_send_cmd("AT+XAPL=ABCD-1234-0100,2");
		done = 1;
	}

	if (ret == 0) {
		sprintf(at_cmd, "AT+IPHONEACCEV=1,1,%d", value);
		ret =  rk_bt_hfp_hp_send_cmd(at_cmd);
	}

	return ret;
}

int rk_bt_hfp_set_volume(int volume)
{
	int ret = 0;
	char at_cmd[100] = {0};

	if (volume > 15)
		volume = 15;
	else if (volume < 0)
		volume = 0;

	sprintf(at_cmd, "AT+VGS=%d", volume);
	ret =  rk_bt_hfp_hp_send_cmd(at_cmd);

	return ret;
}

void rk_bt_hfp_enable_cvsd(void)
{
	//for compile
	pr_info("bluez don't support %s\n", __func__);
}

void rk_bt_hfp_disable_cvsd(void)
{
	//for compile
	pr_info("bluez don't support %s\n", __func__);
}

int rk_bt_hfp_disconnect()
{
	return disconnect_current_devices();
}

/*****************************************************************
 *            Rockchip bluetooth obex api                        *
 *****************************************************************/
static pthread_t g_obex_thread = 0;
int rk_bt_obex_init(char *path)
{
	char buf[100];

	if (!bt_is_open()) {
		pr_info("%s: Please open bt!!!\n", __func__);
		return -1;
	}

	if (get_ps_pid("obexd")) {
		pr_info("%s: obexd has been opened\n", __func__);
		return 0;
	}

	if(!path) {
		pr_info("%s: error, path == NULL\n", __func__);
		return -1;
	}

	/* run obexd */
	memset(buf, 0, 100);
	sprintf(buf, "%s%s%s", "/usr/libexec/bluetooth/obexd -d -n -l -a -r /", path, "/ &");
	pr_info("%s: run obexd(%s)\n", __func__, buf);

	setenv("DBUS_SESSION_BUS_ADDRESS", "unix:path=/var/run/dbus/system_bus_socket", 1);
	usleep(6000);
	if (run_task("obexd", buf)) {
		pr_err("%s: run obexd failed!\n", __func__);
		return -1;
	}

	return 0;
}

int rk_bt_obex_pbap_init()
{
	if (!get_ps_pid("obexd")) {
		pr_info("%s: Please open obex!!!\n", __func__);
		return -1;
	}

	if(g_obex_thread) {
		pr_info("%s: g_obex_thread has been initialized\n", __func__);
		return -1;
	}

	/* Create thread to do connect task. */
	if (pthread_create(&g_obex_thread, NULL, obex_main_thread, NULL)) {
		pr_info("%s: obex_main_thread thread create failed!\n", __func__);
		return -1;
	}

	pthread_setname_np(g_obex_thread, "obex_main_thread");
	return 0;
}

void rk_bt_obex_register_status_cb(RK_BT_OBEX_STATE_CALLBACK cb)
{
	obex_pbap_register_status_cb(cb);
}

int rk_bt_obex_pbap_connect(char *btaddr)
{
	if(!g_obex_thread) {
		pr_err("%s: obex don't inited, please init\n", __func__);
		return -1;
	}

	if (!btaddr || (strlen(btaddr) < 17)) {
		pr_err("%s: Invalid address\n", __func__);
		return -1;
	}

	pr_info("[enter %s]\n", __func__);
	return obex_connect_pbap(btaddr);
}

int rk_bt_obex_pbap_get_vcf(char *dir_name, char *dir_file)
{
	if(!g_obex_thread) {
		pr_err("%s: obex don't inited, please init\n", __func__);
		return -1;
	}

	if (!dir_name || !dir_file) {
		pr_err("%s: Invalid dir_name or dir_file\n", __func__);
		return -1;
	}

	pr_info("[enter %s]\n", __func__);
	return obex_get_pbap_pb(dir_name, dir_file);
}

int rk_bt_obex_pbap_disconnect(char *btaddr)
{
	if(!g_obex_thread) {
		pr_err("%s: obex don't inited, please init\n", __func__);
		return -1;
	}

	pr_info("[enter %s]\n", __func__);
	return obex_disconnect(1, NULL);
}

int rk_bt_obex_pbap_deinit()
{
	if(!g_obex_thread) {
		pr_info("%s: obex has been closed\n", __func__);
		return -1;
	}

	pr_info("[enter %s]\n", __func__);

	obex_quit();

	pthread_join(g_obex_thread, NULL);
	g_obex_thread = 0;

	pr_info("[exit %s]\n", __func__);
	return 0;
}

int rk_bt_obex_deinit()
{
	return kill_task("obexd");
}

/*****************************************************************
 *            Rockchip bluetooth pan api                         *
 *****************************************************************/
void rk_bt_pan_register_event_cb(RK_BT_PAN_EVENT_CALLBACK cb)
{
	pr_info("bluez don't support %s\n", __func__);
}

int rk_bt_pan_open()
{
	pr_info("bluez don't support %s\n", __func__);
	return -1;
}

int rk_bt_pan_close()
{
	pr_info("bluez don't support %s\n", __func__);
	return -1;
}

int rk_bt_pan_connect(char *address)
{
	pr_info("bluez don't support %s\n", __func__);
	return -1;
}

int rk_bt_pan_disconnect(char *address)
{
	pr_info("bluez don't support %s\n", __func__);
	return -1;
}