1 /*
2 * Copyright (c) 2017 Rockchip, Inc. All Rights Reserved.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <string.h>
18 #include <stdio.h>
19 #include <pthread.h>
20 #include <fcntl.h>
21 #include <unistd.h>
22 #include <math.h>
23 #include <sys/un.h>
24 #include <sys/time.h>
25 #include <sys/select.h>
26 #include <sys/socket.h>
27 #include <errno.h>
28
29 #include <RkBtBase.h>
30 #include <RkBtSource.h>
31 #include <RkBtSpp.h>
32 #include <RkBle.h>
33 #include <slog.h>
34
35 #include "rkbtsource_common.h"
36
37 /* Immediate wifi Service UUID */
38 #define BLE_UUID_DEVINFO "0000180A-0000-1000-8000-00805F9B34FB"
39 #define BLE_UUID_BATTERY "00002A19-0000-1000-8000-00805F9B34FB"
40 #define BLE_UUID_STRING "00002A3D-0000-1000-8000-00805F9B34FB"
41
42 #define SCAN_DEVICES_SAVE_COUNT 30
43
44 static bool bleconnect = false;
45
46 enum {
47 RK_BT_IDEL,
48 RK_BT_INITING,
49 RK_BT_INITED,
50 RK_BT_DEINITING,
51 RK_BT_DEINITED,
52 RK_BT_CONNECTING,
53 RK_BT_CONNECTED,
54 RK_BT_DISCONNECTING,
55 RK_BT_DISCONNECTED,
56 };
57
58 typedef struct {
59 int init_state;
60 int deinit_state;
61 int connect_state;
62 int disconnect_state;
63 } bt_state_t;
64
65 static int sockfd = 0;
66
67 static int scan_devices_count = 0;
68 static bool is_recovery_process = false;
69 static bt_state_t bt_state;
70 static int scan_count = 0;
71 static int connect_device_cache_flag = 0;
72 static int user_connect_device_flag = 0;
73
_console_run(char * cmd,char * reply)74 int _console_run(char *cmd , char *reply)
75 {
76 FILE *stream;
77 int len = 0;
78 char buf[4096];
79
80 if(cmd == NULL || strlen(cmd) == 0)
81 {
82 pr_info("cmd invalid\n");
83 return -1;
84 }
85
86 if(cmd[strlen(cmd)-1] == '&') //run cmd in background
87 {
88 system(cmd);
89 if(reply)strcpy(reply , "\0");
90 }
91 else
92 {
93 stream = popen( cmd , "r" );
94 if(stream)
95 {
96 len = fread( buf, sizeof(char), sizeof(buf), stream);
97 if(len > 0)
98 {
99 if(buf[len-1] == '\n')
100 {
101 buf[len-1] = '\0';
102 }
103 }
104 pclose(stream);
105 }
106 buf[len] = '\0';
107 if(reply)strcpy(reply , buf);
108
109 time_t ts = time(NULL);
110 pr_info("[_console_run] %ld cmd %s resp :%s\n" , ts , cmd , buf);
111 }
112
113 return 0;
114 }
115
rk_bt_send_custom_evt(bt_msg_t * evt)116 static int rk_bt_send_custom_evt(bt_msg_t *evt)
117 {
118 struct sockaddr_un addr;
119 struct msghdr msg;
120 struct iovec iov[1];
121
122 addr.sun_family = AF_UNIX;
123 strcpy(addr.sun_path, RKBTSOURCE_CLIENT_SOCKET_PATH);
124
125 iov[0].iov_base = evt;
126 iov[0].iov_len = sizeof(bt_msg_t);
127
128 memset(&msg, 0, sizeof(msg));
129 msg.msg_name = &addr,
130 msg.msg_namelen = sizeof(addr),
131 msg.msg_iov = iov;
132 msg.msg_iovlen = 1;
133
134 if (sendmsg(sockfd, &msg, 0) < 0)
135 pr_info("[BT SPP] send fd fail %s\n", strerror(errno));
136
137 return 0;
138 }
139
rk_bt_send_evt(enum rk_bt_evt val)140 static int rk_bt_send_evt(enum rk_bt_evt val)
141 {
142 struct sockaddr_un addr;
143 bt_msg_t evt;
144 struct msghdr msg;
145 struct iovec iov[1];
146
147 addr.sun_family = AF_UNIX;
148 strcpy(addr.sun_path, RKBTSOURCE_CLIENT_SOCKET_PATH);
149
150 memset(&evt, 0, sizeof(bt_msg_t));
151 evt.type = RK_BT_EVT;
152 evt.id = val;
153
154 iov[0].iov_base = &evt;
155 iov[0].iov_len = sizeof(bt_msg_t);
156
157 memset(&msg, 0, sizeof(msg));
158
159 msg.msg_name = &addr,
160 msg.msg_namelen = sizeof(addr),
161 msg.msg_iov = iov;
162 msg.msg_iovlen = 1;
163
164 if (sendmsg(sockfd, &msg, 0) < 0)
165 pr_info("[BT SPP] send fd fail %s\n", strerror(errno));
166 }
167
rk_bt_send_spp_client_fd(void)168 static void rk_bt_send_spp_client_fd(void)
169 {
170 struct sockaddr_un addr;
171 bt_msg_t evt;
172 struct iovec iov[1];
173 union {
174 char buf[CMSG_SPACE(sizeof(int))];
175 struct cmsghdr _align;
176 } control_un;
177
178 memset(&evt, 0, sizeof(bt_msg_t));
179 evt.type = RK_BT_EVT;
180 evt.id = RK_BT_EVT_SPP_CONNECTED;
181
182 iov[0].iov_base = &evt;
183 iov[0].iov_len = sizeof(bt_msg_t);
184
185 addr.sun_family = AF_UNIX;
186 strcpy(addr.sun_path, RKBTSOURCE_CLIENT_SOCKET_PATH);
187
188 struct msghdr msg = {
189 .msg_name = &addr,
190 .msg_namelen = sizeof(addr),
191 .msg_iov = &iov,
192 .msg_iovlen = 1,
193 .msg_control = control_un.buf,
194 .msg_controllen = sizeof(control_un.buf),
195 };
196
197 struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
198 cmsg->cmsg_level = SOL_SOCKET;
199 cmsg->cmsg_type = SCM_RIGHTS;
200 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
201 int *fdptr = (int *)CMSG_DATA(cmsg);
202 *fdptr = _rk_bt_spp_get_client_fd();
203 pr_info("[BT SPP] send fd %d\n", _rk_bt_spp_get_client_fd());
204
205 if (sendmsg(sockfd, &msg, 0) == -1)
206 pr_info("[BT SPP] send fd fail %s\n", strerror(errno));
207 }
208
rk_bt_state_cb(RK_BT_STATE state)209 static void rk_bt_state_cb(RK_BT_STATE state)
210 {
211 switch(state) {
212 case RK_BT_STATE_TURNING_ON:
213 pr_info("%s: RK_BT_STATE_TURNING_ON\n", PRINT_FLAG_RKBTSOURCE);
214 break;
215 case RK_BT_STATE_ON:
216 pr_info("%s: RK_BT_STATE_ON\n", PRINT_FLAG_RKBTSOURCE);
217 rk_bt_send_evt(RK_BT_EVT_INIT_OK);
218 break;
219 case RK_BT_STATE_TURNING_OFF:
220 pr_info("%s: RK_BT_STATE_TURNING_OFF\n", PRINT_FLAG_RKBTSOURCE);
221 break;
222 case RK_BT_STATE_OFF:
223 pr_info("%s: RK_BT_STATE_OFF\n", PRINT_FLAG_RKBTSOURCE);
224 rk_bt_send_evt(RK_BT_EVT_DEINIT_OK);
225 break;
226 }
227 }
228
rk_bt_bond_state_cb(const char * bd_addr,const char * name,RK_BT_BOND_STATE state)229 static void rk_bt_bond_state_cb(const char *bd_addr, const char *name, RK_BT_BOND_STATE state)
230 {
231 switch(state) {
232 case RK_BT_BOND_STATE_NONE:
233 pr_info("%s: BT BOND NONE: %s, %s\n", PRINT_FLAG_RKBTSOURCE, name, bd_addr);
234 break;
235 case RK_BT_BOND_STATE_BONDING:
236 pr_info("%s: BT BOND BONDING: %s, %s\n", PRINT_FLAG_RKBTSOURCE, name, bd_addr);
237 break;
238 case RK_BT_BOND_STATE_BONDED:
239 pr_info("%s: BT BONDED: %s, %s\n", PRINT_FLAG_RKBTSOURCE, name, bd_addr);
240 break;
241 }
242 }
243
rk_ble_status_cb(const char * bd_addr,const char * name,RK_BLE_STATE state)244 static void rk_ble_status_cb(const char *bd_addr, const char *name, RK_BLE_STATE state)
245 {
246 switch (state) {
247 case RK_BLE_STATE_IDLE:
248 pr_info("+++++ RK_BLE_STATE_IDLE +++++\n");
249 break;
250 case RK_BLE_STATE_CONNECT:
251 pr_info("+++++ RK_BLE_STATE_CONNECT: %s, %s +++++\n", name, bd_addr);
252 bleconnect = true;
253 break;
254 case RK_BLE_STATE_DISCONNECT:
255 pr_info("+++++ RK_BLE_STATE_DISCONNECT: %s, %s +++++\n", name, bd_addr);
256 bleconnect = false;
257 break;
258 }
259 }
260
rk_bt_discovery_status_cb(RK_BT_DISCOVERY_STATE status)261 static void rk_bt_discovery_status_cb(RK_BT_DISCOVERY_STATE status)
262 {
263 switch(status) {
264 case RK_BT_DISC_STARTED:
265 pr_info("%s: RK_BT_DISC_STARTED\n", PRINT_FLAG_RKBTSOURCE);
266 rk_bt_send_evt(RK_BT_EVT_SCAN_ON);
267 break;
268 case RK_BT_DISC_START_FAILED:
269 pr_info("%s: RK_BT_DISC_START_FAILED\n", PRINT_FLAG_RKBTSOURCE);
270 rk_bt_send_evt(RK_BT_EVT_SCAN_OFF);
271 break;
272 case RK_BT_DISC_STOPPED_BY_USER:
273 pr_info("%s: RK_BT_DISC_STOPPED_BY_USER\n", PRINT_FLAG_RKBTSOURCE);
274 rk_bt_send_evt(RK_BT_EVT_SCAN_OFF);
275 break;
276 }
277 }
278
rk_bt_send_devinfo_evt(enum rk_bt_evt val,const char * name,const char * address)279 static void rk_bt_send_devinfo_evt(enum rk_bt_evt val, const char *name, const char *address)
280 {
281 int rc;
282 /* INVALID = 0, SOURCE = 1, SINK = 2 */
283 int i, name_len, scan_msg_len = 0, scan_device_exist = 0;
284 char buff[2048];
285 char *offset;
286 bt_msg_t evt;
287
288 evt.type = RK_BT_EVT;
289 evt.id = val;
290 evt.dev.role = rk_bt_get_playrole_by_addr(address);
291
292 memcpy(evt.dev.addr, address, 17);
293 evt.dev.addr[17] = '\0';
294
295 name_len = strlen(name);
296 memcpy(evt.dev.name, name, name_len);
297 evt.dev.name[name_len] = '\0';
298
299 pr_info("%s: device is %s\n", PRINT_FLAG_RKBTSOURCE,
300 val == RK_BT_EVT_SOURCE_CONNECTED ? "connected" : "disconnected");
301 pr_info(" address: %s\n", address);
302 pr_info(" name: %s\n", name);
303
304 rk_bt_send_custom_evt(&evt);
305 }
306
rk_bt_dev_found_cb(const char * address,const char * name,unsigned int bt_class,int rssi,int change)307 static void rk_bt_dev_found_cb(const char *address, const char *name, unsigned int bt_class, int rssi, int change)
308 {
309 int rc;
310 /* INVALID = 0, SOURCE = 1, SINK = 2 */
311 int i, name_len, scan_msg_len = 0, scan_device_exist = 0;
312 char buff[2048];
313 char *offset;
314 bt_msg_t evt;
315
316 if (change)
317 evt.id = RK_BT_EVT_SCAN_ADD_DEV;
318 else
319 evt.id = RK_BT_EVT_SCAN_REMOVE_DEV;
320
321 if (change == 2)
322 evt.id = RK_BT_EVT_SCAN_CHANGE_DEV;
323
324 evt.dev.role = rk_bt_get_playrole_by_addr(address);
325 evt.dev.change = 1;
326 evt.dev.rssi = rssi;
327
328 memcpy(evt.dev.addr, address, 17);
329 evt.dev.addr[17] = '\0';
330
331 name_len = strlen(name);
332 memcpy(evt.dev.name, name, name_len);
333 evt.dev.name[name_len] = '\0';
334
335 evt.dev.change = change;
336
337 pr_info("%s: device is found\n", PRINT_FLAG_RKBTSOURCE);
338 pr_info(" address: %s\n", address);
339 pr_info(" name: %s\n", name);
340 pr_info(" class: 0x%x\n", bt_class);
341 pr_info(" rssi: %d\n", rssi);
342
343 rk_bt_send_custom_evt(&evt);
344 }
345
bt_test_get_paired_devices(void)346 static void bt_test_get_paired_devices(void)
347 {
348 int i, count;
349 RkBtScanedDevice *dev_tmp = NULL;
350
351 rk_bt_get_paired_devices(&dev_tmp, &count);
352
353 pr_info("%s: current paired devices count: %d\n", __func__, count);
354 for(i = 0; i < count; i++) {
355
356 bt_msg_t evt;
357 int name_len;
358
359 evt.type = RK_BT_EVT;
360 evt.id = RK_BT_EVT_PAIRED_DEV;
361 evt.dev.role = rk_bt_get_playrole_by_addr(dev_tmp->remote_address);
362
363 memcpy(evt.dev.addr, dev_tmp->remote_address, 17);
364 evt.dev.addr[17] = '\0';
365
366 name_len = strlen(dev_tmp->remote_name);
367 memcpy(evt.dev.name, dev_tmp->remote_name, name_len);
368 evt.dev.name[name_len] = '\0';
369 evt.dev.is_connected = dev_tmp->is_connected;
370
371 pr_info("device %d\n", i);
372 pr_info(" remote_address: %s\n", dev_tmp->remote_address);
373 pr_info(" remote_name: %s\n", dev_tmp->remote_name);
374 pr_info(" is_connected: %d\n", dev_tmp->is_connected);
375 dev_tmp = dev_tmp->next;
376 rk_bt_send_custom_evt(&evt);
377 }
378 rk_bt_free_paired_devices(dev_tmp);
379 }
380
rk_bt_source_status_callback(void * userdata,const char * remote_addr,const char * remote_name,const RK_BT_SOURCE_EVENT enEvent)381 void rk_bt_source_status_callback(void *userdata, const char *remote_addr,
382 const char *remote_name, const RK_BT_SOURCE_EVENT enEvent)
383 {
384 char address[18] = {0}, name[100] = {0};
385 char cmd[128];
386
387 switch(enEvent) {
388 case BT_SOURCE_EVENT_CONNECT_FAILED:
389 bt_state.connect_state = RK_BT_IDEL;
390 rk_bt_send_evt(RK_BT_EVT_SOURCE_CONNECT_FAILED);
391 pr_info("%s: BT_SOURCE_EVENT_CONNECT_FAILED, %s, %s\n", PRINT_FLAG_RKBTSOURCE, remote_name, remote_addr);
392 break;
393 case BT_SOURCE_EVENT_CONNECTED:
394 {
395 bt_state.connect_state = RK_BT_CONNECTED;
396 bt_state.disconnect_state = RK_BT_IDEL;
397 pr_info("%s: BT_SOURCE_EVENT_CONNECTED, %s, %s\n", PRINT_FLAG_RKBTSOURCE, remote_name, remote_addr);
398 rk_bt_send_devinfo_evt(RK_BT_EVT_SOURCE_CONNECTED, remote_name, remote_addr);
399 break;
400 }
401 case BT_SOURCE_EVENT_DISCONNECTED:
402 {
403 bt_state.connect_state = RK_BT_IDEL;
404 bt_state.disconnect_state = RK_BT_DISCONNECTED;
405 rk_bt_send_devinfo_evt(RK_BT_EVT_SOURCE_DISCONNECTED, remote_name, remote_addr);
406 pr_info("%s: BT_SOURCE_EVENT_DISCONNECTED, %s, %s\n", PRINT_FLAG_RKBTSOURCE, remote_name, remote_addr);
407 break;
408 }
409 case BT_SOURCE_EVENT_RC_PLAY:
410 pr_info("%s: BT_SOURCE_EVENT_RC_PLAY\n", PRINT_FLAG_RKBTSOURCE);
411 break;
412 case BT_SOURCE_EVENT_RC_STOP:
413 pr_info("%s: BT_SOURCE_EVENT_RC_STOP\n", PRINT_FLAG_RKBTSOURCE);
414 break;
415 case BT_SOURCE_EVENT_RC_PAUSE:
416 pr_info("%s: BT_SOURCE_EVENT_RC_PAUSE\n", PRINT_FLAG_RKBTSOURCE);
417 break;
418 case BT_SOURCE_EVENT_RC_FORWARD:
419 pr_info("%s: BT_SOURCE_EVENT_RC_FORWARD\n", PRINT_FLAG_RKBTSOURCE);
420 break;
421 case BT_SOURCE_EVENT_RC_BACKWARD:
422 pr_info("%s: BT_SOURCE_EVENT_RC_BACKWARD\n", PRINT_FLAG_RKBTSOURCE);
423 break;
424 case BT_SOURCE_EVENT_RC_VOL_UP:
425 pr_info("%s: BT_SOURCE_EVENT_RC_VOL_UP\n", PRINT_FLAG_RKBTSOURCE);
426 break;
427 case BT_SOURCE_EVENT_RC_VOL_DOWN:
428 pr_info("%s: BT_SOURCE_EVENT_RC_VOL_DOWN\n", PRINT_FLAG_RKBTSOURCE);
429 break;
430 case BT_SOURCE_EVENT_REMOVED:
431 bt_state.connect_state = RK_BT_IDEL;
432 bt_state.disconnect_state = RK_BT_IDEL;
433 pr_info("%s: BT_SOURCE_EVENT_REMOVED\n", PRINT_FLAG_RKBTSOURCE);
434 break;
435 default:
436 pr_info("%s: Source event: %d\n", PRINT_FLAG_RKBTSOURCE, enEvent);
437 break;
438 }
439 }
440
rk_bt_spp_status_callback(RK_BT_SPP_STATE type)441 static void rk_bt_spp_status_callback(RK_BT_SPP_STATE type)
442 {
443 switch(type) {
444 case RK_BT_SPP_STATE_IDLE:
445 pr_info("+++++++ RK_BT_SPP_STATE_IDLE +++++\n");
446 break;
447 case RK_BT_SPP_STATE_CONNECT:
448 pr_info("+++++++ RK_BT_SPP_EVENT_CONNECT +++++\n");
449 //rk_bt_send_evt(RK_BT_EVT_SPP_CONNECTED);
450 rk_bt_send_spp_client_fd();
451 break;
452 case RK_BT_SPP_STATE_DISCONNECT:
453 pr_info("+++++++ RK_BT_SPP_EVENT_DISCONNECT +++++\n");
454 rk_bt_send_evt(RK_BT_EVT_SPP_DISCONNECTED);
455 break;
456 case RK_BT_SPP_STATE_CONNECT_FAILED:
457 pr_info("+++++++ RK_BT_SPP_EVENT_CONNECT_FAILED +++++\n");
458 rk_bt_send_evt(RK_BT_EVT_SPP_CONNECT_FAILED);
459 break;
460 default:
461 pr_info("+++++++ BT SPP NOT SUPPORT TYPE! +++++\n");
462 break;
463 }
464 }
465
rk_ble_recv_data_cb(const char * uuid,char * data,int len)466 static void rk_ble_recv_data_cb(const char *uuid, char *data, int len)
467 {
468 pr_info("=== %s uuid: %s===\n", __func__, uuid);
469 for (int i = 0 ; i < len; i++) {
470 pr_info("%02x ", data[i]);
471 }
472 pr_info("\n");
473 }
474
rk_ble_request_data_cb(const char * uuid)475 static void rk_ble_request_data_cb(const char *uuid)
476 {
477 pr_info("=== %s: uuid = %s ===\n", __func__, uuid);
478
479 if (strcmp(uuid, BLE_UUID_BATTERY) == 0) {
480 rk_ble_write(BLE_UUID_BATTERY, "Hello Rockchip", strlen("Hello Rockchip"));
481 }
482 }
483
rk_ble_mtu_cb(const char * bd_addr,unsigned int mtu)484 static void rk_ble_mtu_cb(const char *bd_addr, unsigned int mtu)
485 {
486 pr_info("=== %s: bd_addr: %s, mtu: %d ===\n", __func__, bd_addr, mtu);
487 }
488
489 static char name[128];
490 static RkBtContent bt_content;
491
rk_bt_server_init(char * bt_name)492 static int rk_bt_server_init(char *bt_name)
493 {
494 pr_info("----- rk_bt_server_init(YDPen) -----\n");
495 memset(&bt_content, 0, sizeof(bt_content));
496
497 //sprintf(name, "YDPen:%s", "test");
498
499 bt_content.bt_name = bt_name;
500 bt_content.ble_content.ble_name = bt_name;
501 bt_content.ble_content.server_uuid.uuid = BLE_UUID_DEVINFO;
502 bt_content.ble_content.server_uuid.len = UUID_128;
503 bt_content.ble_content.chr_uuid[0].uuid = BLE_UUID_BATTERY;
504 bt_content.ble_content.chr_uuid[0].len = UUID_128;
505 bt_content.ble_content.chr_uuid[1].uuid = BLE_UUID_STRING;
506 bt_content.ble_content.chr_uuid[1].len = UUID_128;
507 bt_content.ble_content.chr_cnt = 2;
508 bt_content.ble_content.advDataType = BLE_ADVDATA_TYPE_SYSTEM;
509 bt_content.ble_content.cb_ble_recv_fun = NULL;
510 bt_content.ble_content.cb_ble_request_data = rk_ble_request_data_cb;
511
512 rk_bt_register_state_callback(rk_bt_state_cb);
513 rk_bt_register_bond_callback(rk_bt_bond_state_cb);
514 rk_bt_register_discovery_callback(rk_bt_discovery_status_cb);
515 rk_bt_register_dev_found_callback(rk_bt_dev_found_cb);
516
517 return rk_bt_init(&bt_content);
518 }
519
rk_bt_server_init_ble()520 static int rk_bt_server_init_ble()
521 {
522 rk_ble_register_mtu_callback(rk_ble_mtu_cb);
523
524 return rk_ble_start(&bt_content.ble_content);
525 }
526
rk_bt_server_deinit()527 static int rk_bt_server_deinit()
528 {
529 pr_info("%s: BT SERVER DEINIT\n", PRINT_FLAG_RKBTSOURCE);
530 return _rk_bt_deinit(NULL);
531 //return rk_bt_deinit();
532 }
533
main(int argc,char * argv[])534 int main(int argc, char *argv[])
535 {
536 int ret;
537 char buff[256] = {0};
538
539 unlink(RKBTSOURCE_SERVER_SOCKET_PATH);
540
541 pr_info("----- rkbtsource_server -----\n");
542
543 sockfd = socket(AF_UNIX, SOCK_DGRAM, 0);
544 if (sockfd < 0) {
545 pr_info("%s: Create socket failed!\n", PRINT_FLAG_ERR);
546 return -1;
547 }
548
549 struct sockaddr_un addr;
550 addr.sun_family = AF_UNIX;
551 strcpy(addr.sun_path, RKBTSOURCE_SERVER_SOCKET_PATH);
552 ret = bind(sockfd, (struct sockaddr *)&addr, sizeof(addr));
553 if (ret < 0) {
554 pr_info("%s: Bind Local addr failed!\n", PRINT_FLAG_ERR);
555 goto fail;
556 }
557
558 struct timeval t = {4, 0};
559 setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (const char *)&t, sizeof(t));
560
561 memset(&bt_state, 0, sizeof(bt_state_t));
562
563 while (1) {
564 memset(buff, 0, sizeof(buff));
565 ret = recvfrom(sockfd, buff, sizeof(buff), 0, NULL, NULL);
566 if (ret <= 0)
567 continue;
568
569 bt_msg_t *msg = (bt_msg_t *)buff;
570 pr_info("recv cmd: type: %d, id: %d\n", msg->type, msg->id);
571
572 if (msg->type != RK_BT_CMD)
573 continue;
574
575 switch (msg->id) {
576 case RK_BT_INIT:
577 if (bt_state.init_state == RK_BT_IDEL &&
578 bt_state.deinit_state != RK_BT_DEINITING) {
579
580 bt_state.init_state = RK_BT_INITING;
581
582 if (rk_bt_server_init(msg->data) < 0) {
583 pr_info("%s: bt server init failed!\n", PRINT_FLAG_ERR);
584 goto fail;
585 }
586
587 /*
588 if (rk_bt_server_init_ble() < 0) {
589 pr_info("%s: ble init failed!\n", PRINT_FLAG_ERR);
590 goto fail;
591 }
592 */
593
594 bt_state.init_state = RK_BT_INITED;
595 bt_state.deinit_state = RK_BT_IDEL;
596 pr_info("%s: bt server init sucessful!\n", PRINT_FLAG_SUCESS);
597 } else {
598 pr_info("%s: [INIT] init_state = %d, deinit_state = %d\n", PRINT_FLAG_RKBTSOURCE, bt_state.init_state, bt_state.deinit_state);
599 }
600 break;
601
602 case RK_BT_SOURCE_OPEN:
603 exec_command_system("hciconfig hci0 piscan");
604 rk_bt_source_register_status_cb(NULL, rk_bt_source_status_callback);
605 if (rk_bt_source_open() < 0) {
606 pr_info("%s: bt source open failed!\n", PRINT_FLAG_ERR);
607 goto fail;
608 }
609 rk_bt_send_evt(RK_BT_EVT_SOURCE_OPEN);
610 break;
611 case RK_BT_SOURCE_CLOSE:
612 //rk_bt_source_register_status_cb(NULL, rk_bt_source_status_callback);
613 if (rk_bt_source_close() < 0) {
614 pr_info("%s: bt source close failed!\n", PRINT_FLAG_ERR);
615 goto fail;
616 }
617 rk_bt_send_evt(RK_BT_EVT_SOURCE_CLOSE);
618 break;
619 case RK_BT_SOURCE_CONNECT:
620 if (is_recovery_process) {
621 pr_info("%s: [CONNECT] recovering process\n", PRINT_FLAG_RKBTSOURCE);
622 break;
623 }
624
625 if (bt_state.init_state != RK_BT_INITED) {
626 pr_info("%s: [CONNECT] bt don't init, init_state = %d\n", PRINT_FLAG_ERR, bt_state.init_state);
627 break;
628 }
629
630 if (bt_state.connect_state == RK_BT_IDEL &&
631 bt_state.disconnect_state != RK_BT_DISCONNECTING) {
632
633 bt_state.connect_state = RK_BT_CONNECTING;
634 user_connect_device_flag = 1;
635 if (rk_bt_source_connect_by_addr(msg->addr) < 0) {
636 bt_state.connect_state = RK_BT_IDEL;
637 user_connect_device_flag = 0;
638 pr_info("%s: rk_bt_source_connect %s failed!\n", PRINT_FLAG_ERR, msg->addr);
639 }
640 } else {
641 pr_info("%s: [CONNECT] connect_state = %d, disconnect_state = %d\n", PRINT_FLAG_RKBTSOURCE, bt_state.connect_state, bt_state.disconnect_state);
642 }
643 break;
644
645 case RK_BT_SCAN_ON:
646 if (is_recovery_process) {
647 pr_info("%s: [SCAN_ON] recovering process\n", PRINT_FLAG_RKBTSOURCE);
648 rk_bt_send_evt(RK_BT_EVT_SCANNING);
649 break;
650 }
651
652 if (bt_state.init_state != RK_BT_INITED) {
653 pr_info("%s: [SCAN_ON] bt don't init, init_state = %d\n", PRINT_FLAG_ERR, bt_state.init_state);
654 rk_bt_send_evt(RK_BT_EVT_SCAN_OFF);
655 break;
656 }
657
658 /* Scan bluetooth devices, 10s for default */
659 if (rk_bt_start_discovery(10000, SCAN_TYPE_BREDR) < 0)
660 {
661 pr_info("%s: rk_bt_start_discovery failed\n", PRINT_FLAG_ERR);
662 rk_bt_send_evt(RK_BT_EVT_SCAN_OFF);
663 }
664 else
665 {
666 //BT_CMD_SCAN_START
667 }
668 break;
669
670 case RK_BT_SCAN_OFF:
671 if (is_recovery_process) {
672 pr_info("%s: [SCAN_OFF] recovering process\n", PRINT_FLAG_RKBTSOURCE);
673 break;
674 }
675
676 if (bt_state.init_state != RK_BT_INITED) {
677 pr_info("%s: [SCAN_OFF] bt don't init, init_state = %d\n", PRINT_FLAG_ERR, bt_state.init_state);
678 break;
679 }
680
681 rk_bt_cancel_discovery();
682 break;
683
684 case RK_BT_SOURCE_DISCONNECT:
685 if (is_recovery_process) {
686 pr_info("%s: [DISCONNECT] recovering process\n", PRINT_FLAG_RKBTSOURCE);
687 break;
688 }
689
690 if (bt_state.init_state != RK_BT_INITED) {
691 pr_info("%s: [DISCONNECT] bt don't init, init_state = %d\n", PRINT_FLAG_ERR, bt_state.init_state);
692 break;
693 }
694
695 if (bt_state.disconnect_state == RK_BT_IDEL && bt_state.connect_state == RK_BT_CONNECTED) {
696 bt_state.disconnect_state = RK_BT_DISCONNECTING;
697 user_connect_device_flag = 0;
698 if (rk_bt_source_disconnect_by_addr(msg->addr) < 0) {
699 bt_state.disconnect_state = RK_BT_IDEL;
700 user_connect_device_flag = 1;
701 pr_info("%s: rk_bt_source_disconnect failed!\n", PRINT_FLAG_ERR);
702 }
703 } else {
704 pr_info("%s: [DISCONNECT] connect_state = %d, disconnect_state = %d\n", PRINT_FLAG_RKBTSOURCE, bt_state.connect_state, bt_state.disconnect_state);
705 }
706 break;
707
708 case RK_BT_SOURCE_REMOVE:
709 if (is_recovery_process) {
710 pr_info("%s: [REMOVE] recovering process\n", PRINT_FLAG_RKBTSOURCE);
711 break;
712 }
713
714 if (bt_state.init_state != RK_BT_INITED) {
715 pr_info("%s: [REMOVE] bt don't init, init_state = %d\n", PRINT_FLAG_ERR, bt_state.init_state);
716 break;
717 }
718
719 if (rk_bt_source_remove(msg->addr) < 0)
720 pr_info("%s: remove failed!\n", PRINT_FLAG_ERR);
721 else
722 pr_info("%s: remove sucess!\n", PRINT_FLAG_SUCESS);
723 break;
724 case RK_BT_SPP_LISTEN:
725 rk_bt_spp_open(NULL);
726 rk_bt_spp_register_status_cb(rk_bt_spp_status_callback);
727 break;
728 case RK_BT_SPP_CONNECT:
729 rk_bt_spp_connect(msg->addr);
730 rk_bt_spp_register_status_cb(rk_bt_spp_status_callback);
731 break;
732 case RK_BT_SPP_CLOSE:
733 rk_bt_spp_close();
734 rk_bt_spp_register_status_cb(NULL);
735 break;
736 case RK_BT_DEINIT:
737 if(bt_state.init_state == RK_BT_INITED && bt_state.deinit_state == RK_BT_IDEL) {
738 bt_state.deinit_state = RK_BT_DEINITING;
739
740 rk_bt_server_deinit();
741 rk_bt_send_evt(RK_BT_EVT_DEINIT_OK);
742 if(sockfd) {
743 close(sockfd);
744 pr_info("%s: close server socket\n", PRINT_FLAG_RKBTSOURCE);
745 sockfd = 0;
746 }
747
748 bt_state.deinit_state = RK_BT_DEINITED;
749 bt_state.init_state = RK_BT_IDEL;
750 pr_info("%s:deinit bt server sucess!\n", PRINT_FLAG_SUCESS);
751 return 0;
752 } else {
753 pr_info("%s: [DEINIT] init_state = %d, deinit_state = %d\n", PRINT_FLAG_RKBTSOURCE, bt_state.init_state, bt_state.deinit_state);
754 }
755 break;
756 case RK_BT_GET_PAIRED_DEVICES:
757 bt_test_get_paired_devices();
758 break;
759 case RK_BT_PING:
760 rk_bt_send_evt(RK_BT_EVT_PONG);
761 break;
762 default:
763 break;
764 }
765 }
766
767 fail:
768 pr_info("%s: rkbtsource_server failed and exit\n", PRINT_FLAG_ERR);
769 if(sockfd) {
770 close(sockfd);
771 pr_info("%s: close server socket\n", PRINT_FLAG_RKBTSOURCE);
772 sockfd = 0;
773 }
774
775 rk_bt_server_deinit();
776 return -1;
777 }
778