778 lines
21 KiB
C
778 lines
21 KiB
C
/*
|
|
* Copyright (c) 2017 Rockchip, Inc. All Rights Reserved.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <pthread.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <math.h>
|
|
#include <sys/un.h>
|
|
#include <sys/time.h>
|
|
#include <sys/select.h>
|
|
#include <sys/socket.h>
|
|
#include <errno.h>
|
|
|
|
#include <RkBtBase.h>
|
|
#include <RkBtSource.h>
|
|
#include <RkBtSpp.h>
|
|
#include <RkBle.h>
|
|
#include <slog.h>
|
|
|
|
#include "rkbtsource_common.h"
|
|
|
|
/* Immediate wifi Service UUID */
|
|
#define BLE_UUID_DEVINFO "0000180A-0000-1000-8000-00805F9B34FB"
|
|
#define BLE_UUID_BATTERY "00002A19-0000-1000-8000-00805F9B34FB"
|
|
#define BLE_UUID_STRING "00002A3D-0000-1000-8000-00805F9B34FB"
|
|
|
|
#define SCAN_DEVICES_SAVE_COUNT 30
|
|
|
|
static bool bleconnect = false;
|
|
|
|
enum {
|
|
RK_BT_IDEL,
|
|
RK_BT_INITING,
|
|
RK_BT_INITED,
|
|
RK_BT_DEINITING,
|
|
RK_BT_DEINITED,
|
|
RK_BT_CONNECTING,
|
|
RK_BT_CONNECTED,
|
|
RK_BT_DISCONNECTING,
|
|
RK_BT_DISCONNECTED,
|
|
};
|
|
|
|
typedef struct {
|
|
int init_state;
|
|
int deinit_state;
|
|
int connect_state;
|
|
int disconnect_state;
|
|
} bt_state_t;
|
|
|
|
static int sockfd = 0;
|
|
|
|
static int scan_devices_count = 0;
|
|
static bool is_recovery_process = false;
|
|
static bt_state_t bt_state;
|
|
static int scan_count = 0;
|
|
static int connect_device_cache_flag = 0;
|
|
static int user_connect_device_flag = 0;
|
|
|
|
int _console_run(char *cmd , char *reply)
|
|
{
|
|
FILE *stream;
|
|
int len = 0;
|
|
char buf[4096];
|
|
|
|
if(cmd == NULL || strlen(cmd) == 0)
|
|
{
|
|
pr_info("cmd invalid\n");
|
|
return -1;
|
|
}
|
|
|
|
if(cmd[strlen(cmd)-1] == '&') //run cmd in background
|
|
{
|
|
system(cmd);
|
|
if(reply)strcpy(reply , "\0");
|
|
}
|
|
else
|
|
{
|
|
stream = popen( cmd , "r" );
|
|
if(stream)
|
|
{
|
|
len = fread( buf, sizeof(char), sizeof(buf), stream);
|
|
if(len > 0)
|
|
{
|
|
if(buf[len-1] == '\n')
|
|
{
|
|
buf[len-1] = '\0';
|
|
}
|
|
}
|
|
pclose(stream);
|
|
}
|
|
buf[len] = '\0';
|
|
if(reply)strcpy(reply , buf);
|
|
|
|
time_t ts = time(NULL);
|
|
pr_info("[_console_run] %ld cmd %s resp :%s\n" , ts , cmd , buf);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int rk_bt_send_custom_evt(bt_msg_t *evt)
|
|
{
|
|
struct sockaddr_un addr;
|
|
struct msghdr msg;
|
|
struct iovec iov[1];
|
|
|
|
addr.sun_family = AF_UNIX;
|
|
strcpy(addr.sun_path, RKBTSOURCE_CLIENT_SOCKET_PATH);
|
|
|
|
iov[0].iov_base = evt;
|
|
iov[0].iov_len = sizeof(bt_msg_t);
|
|
|
|
memset(&msg, 0, sizeof(msg));
|
|
msg.msg_name = &addr,
|
|
msg.msg_namelen = sizeof(addr),
|
|
msg.msg_iov = iov;
|
|
msg.msg_iovlen = 1;
|
|
|
|
if (sendmsg(sockfd, &msg, 0) < 0)
|
|
pr_info("[BT SPP] send fd fail %s\n", strerror(errno));
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int rk_bt_send_evt(enum rk_bt_evt val)
|
|
{
|
|
struct sockaddr_un addr;
|
|
bt_msg_t evt;
|
|
struct msghdr msg;
|
|
struct iovec iov[1];
|
|
|
|
addr.sun_family = AF_UNIX;
|
|
strcpy(addr.sun_path, RKBTSOURCE_CLIENT_SOCKET_PATH);
|
|
|
|
memset(&evt, 0, sizeof(bt_msg_t));
|
|
evt.type = RK_BT_EVT;
|
|
evt.id = val;
|
|
|
|
iov[0].iov_base = &evt;
|
|
iov[0].iov_len = sizeof(bt_msg_t);
|
|
|
|
memset(&msg, 0, sizeof(msg));
|
|
|
|
msg.msg_name = &addr,
|
|
msg.msg_namelen = sizeof(addr),
|
|
msg.msg_iov = iov;
|
|
msg.msg_iovlen = 1;
|
|
|
|
if (sendmsg(sockfd, &msg, 0) < 0)
|
|
pr_info("[BT SPP] send fd fail %s\n", strerror(errno));
|
|
}
|
|
|
|
static void rk_bt_send_spp_client_fd(void)
|
|
{
|
|
struct sockaddr_un addr;
|
|
bt_msg_t evt;
|
|
struct iovec iov[1];
|
|
union {
|
|
char buf[CMSG_SPACE(sizeof(int))];
|
|
struct cmsghdr _align;
|
|
} control_un;
|
|
|
|
memset(&evt, 0, sizeof(bt_msg_t));
|
|
evt.type = RK_BT_EVT;
|
|
evt.id = RK_BT_EVT_SPP_CONNECTED;
|
|
|
|
iov[0].iov_base = &evt;
|
|
iov[0].iov_len = sizeof(bt_msg_t);
|
|
|
|
addr.sun_family = AF_UNIX;
|
|
strcpy(addr.sun_path, RKBTSOURCE_CLIENT_SOCKET_PATH);
|
|
|
|
struct msghdr msg = {
|
|
.msg_name = &addr,
|
|
.msg_namelen = sizeof(addr),
|
|
.msg_iov = &iov,
|
|
.msg_iovlen = 1,
|
|
.msg_control = control_un.buf,
|
|
.msg_controllen = sizeof(control_un.buf),
|
|
};
|
|
|
|
struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
|
|
cmsg->cmsg_level = SOL_SOCKET;
|
|
cmsg->cmsg_type = SCM_RIGHTS;
|
|
cmsg->cmsg_len = CMSG_LEN(sizeof(int));
|
|
int *fdptr = (int *)CMSG_DATA(cmsg);
|
|
*fdptr = _rk_bt_spp_get_client_fd();
|
|
pr_info("[BT SPP] send fd %d\n", _rk_bt_spp_get_client_fd());
|
|
|
|
if (sendmsg(sockfd, &msg, 0) == -1)
|
|
pr_info("[BT SPP] send fd fail %s\n", strerror(errno));
|
|
}
|
|
|
|
static void rk_bt_state_cb(RK_BT_STATE state)
|
|
{
|
|
switch(state) {
|
|
case RK_BT_STATE_TURNING_ON:
|
|
pr_info("%s: RK_BT_STATE_TURNING_ON\n", PRINT_FLAG_RKBTSOURCE);
|
|
break;
|
|
case RK_BT_STATE_ON:
|
|
pr_info("%s: RK_BT_STATE_ON\n", PRINT_FLAG_RKBTSOURCE);
|
|
rk_bt_send_evt(RK_BT_EVT_INIT_OK);
|
|
break;
|
|
case RK_BT_STATE_TURNING_OFF:
|
|
pr_info("%s: RK_BT_STATE_TURNING_OFF\n", PRINT_FLAG_RKBTSOURCE);
|
|
break;
|
|
case RK_BT_STATE_OFF:
|
|
pr_info("%s: RK_BT_STATE_OFF\n", PRINT_FLAG_RKBTSOURCE);
|
|
rk_bt_send_evt(RK_BT_EVT_DEINIT_OK);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void rk_bt_bond_state_cb(const char *bd_addr, const char *name, RK_BT_BOND_STATE state)
|
|
{
|
|
switch(state) {
|
|
case RK_BT_BOND_STATE_NONE:
|
|
pr_info("%s: BT BOND NONE: %s, %s\n", PRINT_FLAG_RKBTSOURCE, name, bd_addr);
|
|
break;
|
|
case RK_BT_BOND_STATE_BONDING:
|
|
pr_info("%s: BT BOND BONDING: %s, %s\n", PRINT_FLAG_RKBTSOURCE, name, bd_addr);
|
|
break;
|
|
case RK_BT_BOND_STATE_BONDED:
|
|
pr_info("%s: BT BONDED: %s, %s\n", PRINT_FLAG_RKBTSOURCE, name, bd_addr);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void rk_ble_status_cb(const char *bd_addr, const char *name, RK_BLE_STATE state)
|
|
{
|
|
switch (state) {
|
|
case RK_BLE_STATE_IDLE:
|
|
pr_info("+++++ RK_BLE_STATE_IDLE +++++\n");
|
|
break;
|
|
case RK_BLE_STATE_CONNECT:
|
|
pr_info("+++++ RK_BLE_STATE_CONNECT: %s, %s +++++\n", name, bd_addr);
|
|
bleconnect = true;
|
|
break;
|
|
case RK_BLE_STATE_DISCONNECT:
|
|
pr_info("+++++ RK_BLE_STATE_DISCONNECT: %s, %s +++++\n", name, bd_addr);
|
|
bleconnect = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void rk_bt_discovery_status_cb(RK_BT_DISCOVERY_STATE status)
|
|
{
|
|
switch(status) {
|
|
case RK_BT_DISC_STARTED:
|
|
pr_info("%s: RK_BT_DISC_STARTED\n", PRINT_FLAG_RKBTSOURCE);
|
|
rk_bt_send_evt(RK_BT_EVT_SCAN_ON);
|
|
break;
|
|
case RK_BT_DISC_START_FAILED:
|
|
pr_info("%s: RK_BT_DISC_START_FAILED\n", PRINT_FLAG_RKBTSOURCE);
|
|
rk_bt_send_evt(RK_BT_EVT_SCAN_OFF);
|
|
break;
|
|
case RK_BT_DISC_STOPPED_BY_USER:
|
|
pr_info("%s: RK_BT_DISC_STOPPED_BY_USER\n", PRINT_FLAG_RKBTSOURCE);
|
|
rk_bt_send_evt(RK_BT_EVT_SCAN_OFF);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void rk_bt_send_devinfo_evt(enum rk_bt_evt val, const char *name, const char *address)
|
|
{
|
|
int rc;
|
|
/* INVALID = 0, SOURCE = 1, SINK = 2 */
|
|
int i, name_len, scan_msg_len = 0, scan_device_exist = 0;
|
|
char buff[2048];
|
|
char *offset;
|
|
bt_msg_t evt;
|
|
|
|
evt.type = RK_BT_EVT;
|
|
evt.id = val;
|
|
evt.dev.role = rk_bt_get_playrole_by_addr(address);
|
|
|
|
memcpy(evt.dev.addr, address, 17);
|
|
evt.dev.addr[17] = '\0';
|
|
|
|
name_len = strlen(name);
|
|
memcpy(evt.dev.name, name, name_len);
|
|
evt.dev.name[name_len] = '\0';
|
|
|
|
pr_info("%s: device is %s\n", PRINT_FLAG_RKBTSOURCE,
|
|
val == RK_BT_EVT_SOURCE_CONNECTED ? "connected" : "disconnected");
|
|
pr_info(" address: %s\n", address);
|
|
pr_info(" name: %s\n", name);
|
|
|
|
rk_bt_send_custom_evt(&evt);
|
|
}
|
|
|
|
static void rk_bt_dev_found_cb(const char *address, const char *name, unsigned int bt_class, int rssi, int change)
|
|
{
|
|
int rc;
|
|
/* INVALID = 0, SOURCE = 1, SINK = 2 */
|
|
int i, name_len, scan_msg_len = 0, scan_device_exist = 0;
|
|
char buff[2048];
|
|
char *offset;
|
|
bt_msg_t evt;
|
|
|
|
if (change)
|
|
evt.id = RK_BT_EVT_SCAN_ADD_DEV;
|
|
else
|
|
evt.id = RK_BT_EVT_SCAN_REMOVE_DEV;
|
|
|
|
if (change == 2)
|
|
evt.id = RK_BT_EVT_SCAN_CHANGE_DEV;
|
|
|
|
evt.dev.role = rk_bt_get_playrole_by_addr(address);
|
|
evt.dev.change = 1;
|
|
evt.dev.rssi = rssi;
|
|
|
|
memcpy(evt.dev.addr, address, 17);
|
|
evt.dev.addr[17] = '\0';
|
|
|
|
name_len = strlen(name);
|
|
memcpy(evt.dev.name, name, name_len);
|
|
evt.dev.name[name_len] = '\0';
|
|
|
|
evt.dev.change = change;
|
|
|
|
pr_info("%s: device is found\n", PRINT_FLAG_RKBTSOURCE);
|
|
pr_info(" address: %s\n", address);
|
|
pr_info(" name: %s\n", name);
|
|
pr_info(" class: 0x%x\n", bt_class);
|
|
pr_info(" rssi: %d\n", rssi);
|
|
|
|
rk_bt_send_custom_evt(&evt);
|
|
}
|
|
|
|
static void bt_test_get_paired_devices(void)
|
|
{
|
|
int i, count;
|
|
RkBtScanedDevice *dev_tmp = NULL;
|
|
|
|
rk_bt_get_paired_devices(&dev_tmp, &count);
|
|
|
|
pr_info("%s: current paired devices count: %d\n", __func__, count);
|
|
for(i = 0; i < count; i++) {
|
|
|
|
bt_msg_t evt;
|
|
int name_len;
|
|
|
|
evt.type = RK_BT_EVT;
|
|
evt.id = RK_BT_EVT_PAIRED_DEV;
|
|
evt.dev.role = rk_bt_get_playrole_by_addr(dev_tmp->remote_address);
|
|
|
|
memcpy(evt.dev.addr, dev_tmp->remote_address, 17);
|
|
evt.dev.addr[17] = '\0';
|
|
|
|
name_len = strlen(dev_tmp->remote_name);
|
|
memcpy(evt.dev.name, dev_tmp->remote_name, name_len);
|
|
evt.dev.name[name_len] = '\0';
|
|
evt.dev.is_connected = dev_tmp->is_connected;
|
|
|
|
pr_info("device %d\n", i);
|
|
pr_info(" remote_address: %s\n", dev_tmp->remote_address);
|
|
pr_info(" remote_name: %s\n", dev_tmp->remote_name);
|
|
pr_info(" is_connected: %d\n", dev_tmp->is_connected);
|
|
dev_tmp = dev_tmp->next;
|
|
rk_bt_send_custom_evt(&evt);
|
|
}
|
|
rk_bt_free_paired_devices(dev_tmp);
|
|
}
|
|
|
|
void rk_bt_source_status_callback(void *userdata, const char *remote_addr,
|
|
const char *remote_name, const RK_BT_SOURCE_EVENT enEvent)
|
|
{
|
|
char address[18] = {0}, name[100] = {0};
|
|
char cmd[128];
|
|
|
|
switch(enEvent) {
|
|
case BT_SOURCE_EVENT_CONNECT_FAILED:
|
|
bt_state.connect_state = RK_BT_IDEL;
|
|
rk_bt_send_evt(RK_BT_EVT_SOURCE_CONNECT_FAILED);
|
|
pr_info("%s: BT_SOURCE_EVENT_CONNECT_FAILED, %s, %s\n", PRINT_FLAG_RKBTSOURCE, remote_name, remote_addr);
|
|
break;
|
|
case BT_SOURCE_EVENT_CONNECTED:
|
|
{
|
|
bt_state.connect_state = RK_BT_CONNECTED;
|
|
bt_state.disconnect_state = RK_BT_IDEL;
|
|
pr_info("%s: BT_SOURCE_EVENT_CONNECTED, %s, %s\n", PRINT_FLAG_RKBTSOURCE, remote_name, remote_addr);
|
|
rk_bt_send_devinfo_evt(RK_BT_EVT_SOURCE_CONNECTED, remote_name, remote_addr);
|
|
break;
|
|
}
|
|
case BT_SOURCE_EVENT_DISCONNECTED:
|
|
{
|
|
bt_state.connect_state = RK_BT_IDEL;
|
|
bt_state.disconnect_state = RK_BT_DISCONNECTED;
|
|
rk_bt_send_devinfo_evt(RK_BT_EVT_SOURCE_DISCONNECTED, remote_name, remote_addr);
|
|
pr_info("%s: BT_SOURCE_EVENT_DISCONNECTED, %s, %s\n", PRINT_FLAG_RKBTSOURCE, remote_name, remote_addr);
|
|
break;
|
|
}
|
|
case BT_SOURCE_EVENT_RC_PLAY:
|
|
pr_info("%s: BT_SOURCE_EVENT_RC_PLAY\n", PRINT_FLAG_RKBTSOURCE);
|
|
break;
|
|
case BT_SOURCE_EVENT_RC_STOP:
|
|
pr_info("%s: BT_SOURCE_EVENT_RC_STOP\n", PRINT_FLAG_RKBTSOURCE);
|
|
break;
|
|
case BT_SOURCE_EVENT_RC_PAUSE:
|
|
pr_info("%s: BT_SOURCE_EVENT_RC_PAUSE\n", PRINT_FLAG_RKBTSOURCE);
|
|
break;
|
|
case BT_SOURCE_EVENT_RC_FORWARD:
|
|
pr_info("%s: BT_SOURCE_EVENT_RC_FORWARD\n", PRINT_FLAG_RKBTSOURCE);
|
|
break;
|
|
case BT_SOURCE_EVENT_RC_BACKWARD:
|
|
pr_info("%s: BT_SOURCE_EVENT_RC_BACKWARD\n", PRINT_FLAG_RKBTSOURCE);
|
|
break;
|
|
case BT_SOURCE_EVENT_RC_VOL_UP:
|
|
pr_info("%s: BT_SOURCE_EVENT_RC_VOL_UP\n", PRINT_FLAG_RKBTSOURCE);
|
|
break;
|
|
case BT_SOURCE_EVENT_RC_VOL_DOWN:
|
|
pr_info("%s: BT_SOURCE_EVENT_RC_VOL_DOWN\n", PRINT_FLAG_RKBTSOURCE);
|
|
break;
|
|
case BT_SOURCE_EVENT_REMOVED:
|
|
bt_state.connect_state = RK_BT_IDEL;
|
|
bt_state.disconnect_state = RK_BT_IDEL;
|
|
pr_info("%s: BT_SOURCE_EVENT_REMOVED\n", PRINT_FLAG_RKBTSOURCE);
|
|
break;
|
|
default:
|
|
pr_info("%s: Source event: %d\n", PRINT_FLAG_RKBTSOURCE, enEvent);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void rk_bt_spp_status_callback(RK_BT_SPP_STATE type)
|
|
{
|
|
switch(type) {
|
|
case RK_BT_SPP_STATE_IDLE:
|
|
pr_info("+++++++ RK_BT_SPP_STATE_IDLE +++++\n");
|
|
break;
|
|
case RK_BT_SPP_STATE_CONNECT:
|
|
pr_info("+++++++ RK_BT_SPP_EVENT_CONNECT +++++\n");
|
|
//rk_bt_send_evt(RK_BT_EVT_SPP_CONNECTED);
|
|
rk_bt_send_spp_client_fd();
|
|
break;
|
|
case RK_BT_SPP_STATE_DISCONNECT:
|
|
pr_info("+++++++ RK_BT_SPP_EVENT_DISCONNECT +++++\n");
|
|
rk_bt_send_evt(RK_BT_EVT_SPP_DISCONNECTED);
|
|
break;
|
|
case RK_BT_SPP_STATE_CONNECT_FAILED:
|
|
pr_info("+++++++ RK_BT_SPP_EVENT_CONNECT_FAILED +++++\n");
|
|
rk_bt_send_evt(RK_BT_EVT_SPP_CONNECT_FAILED);
|
|
break;
|
|
default:
|
|
pr_info("+++++++ BT SPP NOT SUPPORT TYPE! +++++\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void rk_ble_recv_data_cb(const char *uuid, char *data, int len)
|
|
{
|
|
pr_info("=== %s uuid: %s===\n", __func__, uuid);
|
|
for (int i = 0 ; i < len; i++) {
|
|
pr_info("%02x ", data[i]);
|
|
}
|
|
pr_info("\n");
|
|
}
|
|
|
|
static void rk_ble_request_data_cb(const char *uuid)
|
|
{
|
|
pr_info("=== %s: uuid = %s ===\n", __func__, uuid);
|
|
|
|
if (strcmp(uuid, BLE_UUID_BATTERY) == 0) {
|
|
rk_ble_write(BLE_UUID_BATTERY, "Hello Rockchip", strlen("Hello Rockchip"));
|
|
}
|
|
}
|
|
|
|
static void rk_ble_mtu_cb(const char *bd_addr, unsigned int mtu)
|
|
{
|
|
pr_info("=== %s: bd_addr: %s, mtu: %d ===\n", __func__, bd_addr, mtu);
|
|
}
|
|
|
|
static char name[128];
|
|
static RkBtContent bt_content;
|
|
|
|
static int rk_bt_server_init(char *bt_name)
|
|
{
|
|
pr_info("----- rk_bt_server_init(YDPen) -----\n");
|
|
memset(&bt_content, 0, sizeof(bt_content));
|
|
|
|
//sprintf(name, "YDPen:%s", "test");
|
|
|
|
bt_content.bt_name = bt_name;
|
|
bt_content.ble_content.ble_name = bt_name;
|
|
bt_content.ble_content.server_uuid.uuid = BLE_UUID_DEVINFO;
|
|
bt_content.ble_content.server_uuid.len = UUID_128;
|
|
bt_content.ble_content.chr_uuid[0].uuid = BLE_UUID_BATTERY;
|
|
bt_content.ble_content.chr_uuid[0].len = UUID_128;
|
|
bt_content.ble_content.chr_uuid[1].uuid = BLE_UUID_STRING;
|
|
bt_content.ble_content.chr_uuid[1].len = UUID_128;
|
|
bt_content.ble_content.chr_cnt = 2;
|
|
bt_content.ble_content.advDataType = BLE_ADVDATA_TYPE_SYSTEM;
|
|
bt_content.ble_content.cb_ble_recv_fun = NULL;
|
|
bt_content.ble_content.cb_ble_request_data = rk_ble_request_data_cb;
|
|
|
|
rk_bt_register_state_callback(rk_bt_state_cb);
|
|
rk_bt_register_bond_callback(rk_bt_bond_state_cb);
|
|
rk_bt_register_discovery_callback(rk_bt_discovery_status_cb);
|
|
rk_bt_register_dev_found_callback(rk_bt_dev_found_cb);
|
|
|
|
return rk_bt_init(&bt_content);
|
|
}
|
|
|
|
static int rk_bt_server_init_ble()
|
|
{
|
|
rk_ble_register_mtu_callback(rk_ble_mtu_cb);
|
|
|
|
return rk_ble_start(&bt_content.ble_content);
|
|
}
|
|
|
|
static int rk_bt_server_deinit()
|
|
{
|
|
pr_info("%s: BT SERVER DEINIT\n", PRINT_FLAG_RKBTSOURCE);
|
|
return _rk_bt_deinit(NULL);
|
|
//return rk_bt_deinit();
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
int ret;
|
|
char buff[256] = {0};
|
|
|
|
unlink(RKBTSOURCE_SERVER_SOCKET_PATH);
|
|
|
|
pr_info("----- rkbtsource_server -----\n");
|
|
|
|
sockfd = socket(AF_UNIX, SOCK_DGRAM, 0);
|
|
if (sockfd < 0) {
|
|
pr_info("%s: Create socket failed!\n", PRINT_FLAG_ERR);
|
|
return -1;
|
|
}
|
|
|
|
struct sockaddr_un addr;
|
|
addr.sun_family = AF_UNIX;
|
|
strcpy(addr.sun_path, RKBTSOURCE_SERVER_SOCKET_PATH);
|
|
ret = bind(sockfd, (struct sockaddr *)&addr, sizeof(addr));
|
|
if (ret < 0) {
|
|
pr_info("%s: Bind Local addr failed!\n", PRINT_FLAG_ERR);
|
|
goto fail;
|
|
}
|
|
|
|
struct timeval t = {4, 0};
|
|
setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (const char *)&t, sizeof(t));
|
|
|
|
memset(&bt_state, 0, sizeof(bt_state_t));
|
|
|
|
while (1) {
|
|
memset(buff, 0, sizeof(buff));
|
|
ret = recvfrom(sockfd, buff, sizeof(buff), 0, NULL, NULL);
|
|
if (ret <= 0)
|
|
continue;
|
|
|
|
bt_msg_t *msg = (bt_msg_t *)buff;
|
|
pr_info("recv cmd: type: %d, id: %d\n", msg->type, msg->id);
|
|
|
|
if (msg->type != RK_BT_CMD)
|
|
continue;
|
|
|
|
switch (msg->id) {
|
|
case RK_BT_INIT:
|
|
if (bt_state.init_state == RK_BT_IDEL &&
|
|
bt_state.deinit_state != RK_BT_DEINITING) {
|
|
|
|
bt_state.init_state = RK_BT_INITING;
|
|
|
|
if (rk_bt_server_init(msg->data) < 0) {
|
|
pr_info("%s: bt server init failed!\n", PRINT_FLAG_ERR);
|
|
goto fail;
|
|
}
|
|
|
|
/*
|
|
if (rk_bt_server_init_ble() < 0) {
|
|
pr_info("%s: ble init failed!\n", PRINT_FLAG_ERR);
|
|
goto fail;
|
|
}
|
|
*/
|
|
|
|
bt_state.init_state = RK_BT_INITED;
|
|
bt_state.deinit_state = RK_BT_IDEL;
|
|
pr_info("%s: bt server init sucessful!\n", PRINT_FLAG_SUCESS);
|
|
} else {
|
|
pr_info("%s: [INIT] init_state = %d, deinit_state = %d\n", PRINT_FLAG_RKBTSOURCE, bt_state.init_state, bt_state.deinit_state);
|
|
}
|
|
break;
|
|
|
|
case RK_BT_SOURCE_OPEN:
|
|
exec_command_system("hciconfig hci0 piscan");
|
|
rk_bt_source_register_status_cb(NULL, rk_bt_source_status_callback);
|
|
if (rk_bt_source_open() < 0) {
|
|
pr_info("%s: bt source open failed!\n", PRINT_FLAG_ERR);
|
|
goto fail;
|
|
}
|
|
rk_bt_send_evt(RK_BT_EVT_SOURCE_OPEN);
|
|
break;
|
|
case RK_BT_SOURCE_CLOSE:
|
|
//rk_bt_source_register_status_cb(NULL, rk_bt_source_status_callback);
|
|
if (rk_bt_source_close() < 0) {
|
|
pr_info("%s: bt source close failed!\n", PRINT_FLAG_ERR);
|
|
goto fail;
|
|
}
|
|
rk_bt_send_evt(RK_BT_EVT_SOURCE_CLOSE);
|
|
break;
|
|
case RK_BT_SOURCE_CONNECT:
|
|
if (is_recovery_process) {
|
|
pr_info("%s: [CONNECT] recovering process\n", PRINT_FLAG_RKBTSOURCE);
|
|
break;
|
|
}
|
|
|
|
if (bt_state.init_state != RK_BT_INITED) {
|
|
pr_info("%s: [CONNECT] bt don't init, init_state = %d\n", PRINT_FLAG_ERR, bt_state.init_state);
|
|
break;
|
|
}
|
|
|
|
if (bt_state.connect_state == RK_BT_IDEL &&
|
|
bt_state.disconnect_state != RK_BT_DISCONNECTING) {
|
|
|
|
bt_state.connect_state = RK_BT_CONNECTING;
|
|
user_connect_device_flag = 1;
|
|
if (rk_bt_source_connect_by_addr(msg->addr) < 0) {
|
|
bt_state.connect_state = RK_BT_IDEL;
|
|
user_connect_device_flag = 0;
|
|
pr_info("%s: rk_bt_source_connect %s failed!\n", PRINT_FLAG_ERR, msg->addr);
|
|
}
|
|
} else {
|
|
pr_info("%s: [CONNECT] connect_state = %d, disconnect_state = %d\n", PRINT_FLAG_RKBTSOURCE, bt_state.connect_state, bt_state.disconnect_state);
|
|
}
|
|
break;
|
|
|
|
case RK_BT_SCAN_ON:
|
|
if (is_recovery_process) {
|
|
pr_info("%s: [SCAN_ON] recovering process\n", PRINT_FLAG_RKBTSOURCE);
|
|
rk_bt_send_evt(RK_BT_EVT_SCANNING);
|
|
break;
|
|
}
|
|
|
|
if (bt_state.init_state != RK_BT_INITED) {
|
|
pr_info("%s: [SCAN_ON] bt don't init, init_state = %d\n", PRINT_FLAG_ERR, bt_state.init_state);
|
|
rk_bt_send_evt(RK_BT_EVT_SCAN_OFF);
|
|
break;
|
|
}
|
|
|
|
/* Scan bluetooth devices, 10s for default */
|
|
if (rk_bt_start_discovery(10000, SCAN_TYPE_BREDR) < 0)
|
|
{
|
|
pr_info("%s: rk_bt_start_discovery failed\n", PRINT_FLAG_ERR);
|
|
rk_bt_send_evt(RK_BT_EVT_SCAN_OFF);
|
|
}
|
|
else
|
|
{
|
|
//BT_CMD_SCAN_START
|
|
}
|
|
break;
|
|
|
|
case RK_BT_SCAN_OFF:
|
|
if (is_recovery_process) {
|
|
pr_info("%s: [SCAN_OFF] recovering process\n", PRINT_FLAG_RKBTSOURCE);
|
|
break;
|
|
}
|
|
|
|
if (bt_state.init_state != RK_BT_INITED) {
|
|
pr_info("%s: [SCAN_OFF] bt don't init, init_state = %d\n", PRINT_FLAG_ERR, bt_state.init_state);
|
|
break;
|
|
}
|
|
|
|
rk_bt_cancel_discovery();
|
|
break;
|
|
|
|
case RK_BT_SOURCE_DISCONNECT:
|
|
if (is_recovery_process) {
|
|
pr_info("%s: [DISCONNECT] recovering process\n", PRINT_FLAG_RKBTSOURCE);
|
|
break;
|
|
}
|
|
|
|
if (bt_state.init_state != RK_BT_INITED) {
|
|
pr_info("%s: [DISCONNECT] bt don't init, init_state = %d\n", PRINT_FLAG_ERR, bt_state.init_state);
|
|
break;
|
|
}
|
|
|
|
if (bt_state.disconnect_state == RK_BT_IDEL && bt_state.connect_state == RK_BT_CONNECTED) {
|
|
bt_state.disconnect_state = RK_BT_DISCONNECTING;
|
|
user_connect_device_flag = 0;
|
|
if (rk_bt_source_disconnect_by_addr(msg->addr) < 0) {
|
|
bt_state.disconnect_state = RK_BT_IDEL;
|
|
user_connect_device_flag = 1;
|
|
pr_info("%s: rk_bt_source_disconnect failed!\n", PRINT_FLAG_ERR);
|
|
}
|
|
} else {
|
|
pr_info("%s: [DISCONNECT] connect_state = %d, disconnect_state = %d\n", PRINT_FLAG_RKBTSOURCE, bt_state.connect_state, bt_state.disconnect_state);
|
|
}
|
|
break;
|
|
|
|
case RK_BT_SOURCE_REMOVE:
|
|
if (is_recovery_process) {
|
|
pr_info("%s: [REMOVE] recovering process\n", PRINT_FLAG_RKBTSOURCE);
|
|
break;
|
|
}
|
|
|
|
if (bt_state.init_state != RK_BT_INITED) {
|
|
pr_info("%s: [REMOVE] bt don't init, init_state = %d\n", PRINT_FLAG_ERR, bt_state.init_state);
|
|
break;
|
|
}
|
|
|
|
if (rk_bt_source_remove(msg->addr) < 0)
|
|
pr_info("%s: remove failed!\n", PRINT_FLAG_ERR);
|
|
else
|
|
pr_info("%s: remove sucess!\n", PRINT_FLAG_SUCESS);
|
|
break;
|
|
case RK_BT_SPP_LISTEN:
|
|
rk_bt_spp_open(NULL);
|
|
rk_bt_spp_register_status_cb(rk_bt_spp_status_callback);
|
|
break;
|
|
case RK_BT_SPP_CONNECT:
|
|
rk_bt_spp_connect(msg->addr);
|
|
rk_bt_spp_register_status_cb(rk_bt_spp_status_callback);
|
|
break;
|
|
case RK_BT_SPP_CLOSE:
|
|
rk_bt_spp_close();
|
|
rk_bt_spp_register_status_cb(NULL);
|
|
break;
|
|
case RK_BT_DEINIT:
|
|
if(bt_state.init_state == RK_BT_INITED && bt_state.deinit_state == RK_BT_IDEL) {
|
|
bt_state.deinit_state = RK_BT_DEINITING;
|
|
|
|
rk_bt_server_deinit();
|
|
rk_bt_send_evt(RK_BT_EVT_DEINIT_OK);
|
|
if(sockfd) {
|
|
close(sockfd);
|
|
pr_info("%s: close server socket\n", PRINT_FLAG_RKBTSOURCE);
|
|
sockfd = 0;
|
|
}
|
|
|
|
bt_state.deinit_state = RK_BT_DEINITED;
|
|
bt_state.init_state = RK_BT_IDEL;
|
|
pr_info("%s:deinit bt server sucess!\n", PRINT_FLAG_SUCESS);
|
|
return 0;
|
|
} else {
|
|
pr_info("%s: [DEINIT] init_state = %d, deinit_state = %d\n", PRINT_FLAG_RKBTSOURCE, bt_state.init_state, bt_state.deinit_state);
|
|
}
|
|
break;
|
|
case RK_BT_GET_PAIRED_DEVICES:
|
|
bt_test_get_paired_devices();
|
|
break;
|
|
case RK_BT_PING:
|
|
rk_bt_send_evt(RK_BT_EVT_PONG);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
fail:
|
|
pr_info("%s: rkbtsource_server failed and exit\n", PRINT_FLAG_ERR);
|
|
if(sockfd) {
|
|
close(sockfd);
|
|
pr_info("%s: close server socket\n", PRINT_FLAG_RKBTSOURCE);
|
|
sockfd = 0;
|
|
}
|
|
|
|
rk_bt_server_deinit();
|
|
return -1;
|
|
}
|