Kaotings/AC695N-SoundBox-SDK
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
main
AC695N-SoundBox-SDK/apps/common/third_party_profile/interface/app_protocol_api.c

1203 lines
36 KiB
C
Raw Permalink Normal View History

Import AC695N SoundBox SDK 3.1.0
2026-08-09 00:00:00 +00:00
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "system/timer.h"
#include "system/task.h"
#include "app_protocol_api.h"
#include "btstack/avctp_user.h"
#include "syscfg_id.h"
#include "system/includes.h"
#include "bt_tws.h"
#include "app_protocol_ota.h"
#include "btstack/third_party/app_protocol_libs_api.h"
#include "audio_config.h"
#include "app_task.h"
#if AI_APP_PROTOCOL
static int app_protocol_demo_init(int match_id);
static int app_protocol_ama_init(int match_id);
static int app_protocol_gma_init(int match_id);
static int app_protocol_dma_init(int match_id);
static int app_protocol_tme_init(int match_id);
static int app_protocol_mma_init(int match_id);
#if 1
#define APP_PROTOCOL_LOG printf
#define APP_PROTOCOL_DUMP put_buf
#else
#define APP_PROTOCOL_LOG(...)
#define APP_PROTOCOL_DUMP(...)
#endif
typedef struct {
// linked list - assert: first field
void *offset_item;
// data is contained in same memory
u32 service_record_handle;
u8 *service_record;
} app_protocal_item_t;
#define AI_RECORD_REGISTER(handler) \
const app_protocal_item_t handler sec(.sdp_record_item)
struct app_protocol_info_t {
/*配置类接口*/
void (*set_product_id)(u32 pid);
void (*set_vendor_id)(u32 vid);
void (*set_local_version)(u32 vid);
void (*set_special_info_group)(void *addr);
void (*set_tws_sibling_mac)(void *mac);
};
struct app_ctrl_operation_t {
int(*protocol_init)();
int(*protocol_exit)();
int(*adv_enable)(int enable);
int(*ibeacon_adv)(int sw);
int(*regist_wakeup_send)(void *priv, void *cbk);
int(*regist_recieve_cbk)(void *priv, void *cbk);
int(*latency_enable)(void *priv, u32 enable);
int(*send_data)(void *priv, void *buf, u16 len);
int(*send_voice_data)(void *buf, u16 len);
int(*disconnect)(void *addr);
int(*tws_receive_sync_data)(u8 *data, int len);
int(*get_auth_state)(void);
int(*start_voice_recognition)(int st);
int(*update_tws_state_to_lib)(int sta);
};
struct callback_register_t {
void(*message_handler_regedit)(int (*handler)(int id, int opcode, u8 *data, u32 len));
void(*check_some_status_register)(int (*handler)(int state_flag));
void(*check_tws_role_is_master_register)(bool (*handler)(void));
void(*tx_resume)(void (*handler)(void));
void(*rx_resume)(void (*handler)(void));
void(*get_battery)(bool (*handler)(u8 battery_type, u8 *value));
};
typedef struct app_protocol {
int handler_id;
int (*loop)(void);
int (*tx_loop)(void);
int (*special_message)(int id, int opcode, u8 *data, u32 len);
struct app_protocol_info_t *settings;
struct app_ctrl_operation_t *app_ctrl;
struct callback_register_t *callback;
} app_protocol_interface_t;
#define MAX_NUMBER_RUN 2
struct app_protocol_task {
app_protocol_interface_t app_p[MAX_NUMBER_RUN];
u16 tick_timer;
u8 running_protocol_number: 3;
u8 run_flag: 1;
u8 first_init_flag: 1;
u8 reserve: 3;
};
struct app_protocol_task g_app;
#define __this (&g_app)
static app_protocol_interface_t *current_run_app = NULL;
#define list_for_each_app_protocol(p) \
for (p = __this->app_p; p < __this->app_p + MAX_NUMBER_RUN; p++)
static app_protocol_interface_t *get_interface_for_id(u32 id)
{
app_protocol_interface_t *app;
list_for_each_app_protocol(app) {
if (id == app->handler_id) {
return app;
}
}
return NULL;
}
static int free_interface_for_id(u32 id)
{
app_protocol_interface_t *app;
list_for_each_app_protocol(app) {
if (id == app->handler_id) {
app->handler_id = 0;
app->loop = NULL;
app->tx_loop = NULL;
app->settings = NULL;
app->app_ctrl = NULL;
app->callback = NULL;
return 1;
}
}
return 0;
}
static app_protocol_interface_t *get_empty_interface()
{
app_protocol_interface_t *app;
list_for_each_app_protocol(app) {
if (0 == app->handler_id) {
return app;
}
}
return NULL;
}
/**获取当前协议*/
u32 app_protocol_get_cur_handle_id()
{
if (current_run_app) {
return current_run_app->handler_id;
}
return 0;
}
/*设置产品的PID*/
void app_protocol_set_product_id(u32 handler_id, u32 pid)
{
app_protocol_interface_t *app = get_interface_for_id(handler_id);
if (app && app->settings) {
if (app->settings->set_product_id) {
app->settings->set_product_id(pid);
}
}
}
/*设置产品的VID*/
void app_protocol_set_vendor_id(u32 handler_id, u32 vid)
{
app_protocol_interface_t *app = get_interface_for_id(handler_id);
if (app && app->settings) {
if (app->settings->set_vendor_id) {
app->settings->set_vendor_id(vid);
}
}
}
/*设置产品的version*/
void app_protocol_set_local_version(u32 handler_id, u32 version)
{
app_protocol_interface_t *app = get_interface_for_id(handler_id);
if (app && app->settings) {
if (app->settings->set_local_version) {
app->settings->set_local_version(version);
}
}
}
/*配置协议更多信息，例如GMA的三元组地址*/
void app_protocol_set_info_group(u32 handler_id, void *addr)
{
app_protocol_interface_t *app = get_interface_for_id(handler_id);
if (app && app->settings) {
if (app->settings->set_special_info_group) {
app->settings->set_special_info_group(addr);
}
}
}
/*配置TWS的地址,app协议用于配置广播包或者命令告知app*/
void app_protocol_set_tws_sibling_mac(u8 *mac)
{
app_protocol_interface_t *app;
list_for_each_app_protocol(app) {
if (app->settings) {
if (app->settings->set_tws_sibling_mac) {
app->settings->set_tws_sibling_mac(mac);
}
}
}
}
void app_protocol_ibeacon_switch(int sw)
{
app_protocol_interface_t *app;
list_for_each_app_protocol(app) {
if (app->app_ctrl) {
if (app->app_ctrl->ibeacon_adv) {
app->app_ctrl->ibeacon_adv(sw);
}
}
}
}
void app_protocol_ble_adv_switch(int sw)
{
app_protocol_interface_t *app;
list_for_each_app_protocol(app) {
if (app->app_ctrl) {
if (app->app_ctrl->adv_enable) {
app->app_ctrl->adv_enable(sw);
}
}
}
}
void app_protocol_disconnect(void *addr)
{
app_protocol_interface_t *app;
list_for_each_app_protocol(app) {
if (app->app_ctrl) {
if (app->app_ctrl->disconnect) {
app->app_ctrl->disconnect(addr);
}
}
}
}
void app_protocol_get_tws_data_for_lib(u8 *data, u32 len)
{
app_protocol_interface_t *app;
list_for_each_app_protocol(app) {
if (app->app_ctrl) {
if (app->app_ctrl->tws_receive_sync_data) {
app->app_ctrl->tws_receive_sync_data(data, len);
}
}
}
}
void app_protocal_update_tws_state_to_lib(int state)
{
app_protocol_interface_t *app;
list_for_each_app_protocol(app) {
if (app->app_ctrl) {
if (app->app_ctrl->update_tws_state_to_lib) {
app->app_ctrl->update_tws_state_to_lib(state);
}
}
}
}
__attribute__((weak))
bool is_tws_master_role()
{
#if TCFG_USER_TWS_ENABLE
return (tws_api_get_role() == TWS_ROLE_MASTER);
#endif
return 1;
}
static int app_get_tws_side()
{
// CHECK_STATUS_TWS_SIDE: /*0是单耳，1是左耳，2是右耳*/
#if TCFG_USER_TWS_ENABLE
if (tws_api_get_local_channel() == 'R') {
return 2;
} else if (tws_api_get_local_channel() == 'L') {
return 1;
}
#endif
return 0;
}
int app_protocol_check_status(int status_flag)
{
switch (status_flag) {
case CHECK_STATUS_TWS_MASTER:
return is_tws_master_role();
case CHECK_STATUS_TWS_SLAVE:
return !is_tws_master_role();
case CHECK_STATUS_TWS_PAIR_STA: /*1是tws已经配对了，0是未配对*/
#if TCFG_USER_TWS_ENABLE
if (get_bt_tws_connect_status()) {
return true;
} else {
return false;
}
#endif
return 0;
case CHECK_STATUS_TWS_SIDE: /*0是单耳，1是左耳，2是右耳*/
return app_get_tws_side();
}
return 0;
}
__attribute__((weak))
bool app_protocol_get_battery(u8 type, u8 *value)
{
for (int i = 0; i < APP_PROTOCOL_BAT_T_MAX; i++) {
if (type & BIT(i)) {
value[i] = app_protocal_get_bat_by_type(i);
}
}
return 0;
}
static void set_mic_rec_param(int id)
{
switch (id) {
case TME_HANDLER_ID:
mic_rec_pram_init(AUDIO_CODING_OPUS, 1 << 6, app_protocol_send_voice_data, 4, 1024); //TME每4帧加一个头，每帧长度46
break;
case GMA_HANDLER_ID:
mic_rec_pram_init(AUDIO_CODING_OPUS, 0, app_protocol_send_voice_data, 4, 1024);
break;
case MMA_HANDLER_ID:
mic_rec_pram_init(AUDIO_CODING_SPEEX, 0, app_protocol_send_voice_data, 5, 1024); //小米每5帧加一个头，每帧长度42
break;
default:
mic_rec_pram_init(AUDIO_CODING_OPUS, 0, app_protocol_send_voice_data, 4, 1024);
break;
}
}
static int app_protocol_message_handler(int id, int opcode, u8 *data, u32 len)
{
static app_protocol_interface_t *message_app = NULL;
APP_PROTOCOL_LOG("\napp_protocol_message_handler opcode = %d\n", opcode);
int ret = 0;
switch (opcode) {
case APP_PROTOCOL_CONNECTED_SPP:
case APP_PROTOCOL_CONNECTED_BLE:
//连接上断开消息的
app_protocol_post_bt_event(AI_EVENT_APP_CONNECT, NULL);
/* void bt_check_exit_sniff(); */
/* bt_check_exit_sniff(); */
user_send_cmd_prepare(USER_CTRL_ALL_SNIFF_EXIT, 0, NULL);
current_run_app = get_interface_for_id(id);
#if APP_PROTOCOL_SPEECH_EN
set_mic_rec_param(id);
#endif
printf("APP_PROTOCOL_CONNECT\n");
break;
case APP_PROTOCOL_DISCONNECT:
app_protocol_post_bt_event(AI_EVENT_APP_DISCONNECT, NULL);
app_protocol_ota_interrupt_by_disconnect(id);
current_run_app = NULL;
printf("APP_PROTOCOL_disconnect\n");
if (app_protocol_update_success_flag()) {
cpu_reset();
}
break;
case APP_PROTOCOL_AUTH_PASS:
break;
case APP_PROTOCOL_SPEECH_ENCODER_TYPE:
break;
#if APP_PROTOCOL_SPEECH_EN
case APP_PROTOCOL_SPEECH_START:
APP_PROTOCOL_LOG("app_protocol_speech_start by app\n");
#if TCFG_BLUETOOTH_BACK_MODE
if (app_get_curr_task() != APP_BT_TASK) {
app_task_switch_to(APP_BT_TASK);
}
#endif
ret = app_protocol_start_speech_by_app(1);
break;
case APP_PROTOCOL_SPEECH_STOP:
ret = app_protocol_stop_speech_by_app();
break;
#endif
case APP_PROTOCOL_SET_VOLUME:
app_protocol_set_volume(data[0]);
break;
case APP_PROTOCOL_GET_VOLUME:
data[0] = app_audio_get_volume(APP_AUDIO_STATE_MUSIC);
break;
case APP_PROTOCOL_LIB_TWS_DATA_SYNC:
app_protocol_tws_send_to_sibling(APP_PROTOCOL_TWS_FOR_LIB, data, len);
break;
default:
ret = app_protocol_ota_message_handler(id, opcode, data, len);
break;
}
message_app = get_interface_for_id(id);
if (message_app) {
if (message_app->special_message) {
message_app->special_message(id, opcode, data, len);
}
}
return ret;
}
static void app_protocol_resume(void)
{
if (__this->run_flag == 0) {
return ;
}
os_taskq_post_type(APP_PROTOCOL_TASK_NAME, APP_PROTOCOL_RX_DATA_EVENT, 0, NULL);
}
static void app_protocol_send_resume(void)
{
if (__this->run_flag == 0) {
return ;
}
os_taskq_post_type(APP_PROTOCOL_TASK_NAME, APP_PROTOCOL_TX_DATA_EVENT, 0, NULL);
}
static void app_protocol_tick_resume(void)
{
app_protocol_resume();///500ms resume for send retry
}
static void app_protocol_loop_process(void *parm)
{
int msg[8];
int ret;
app_protocol_interface_t *app = NULL;
__this->tick_timer = sys_timer_add(NULL, app_protocol_tick_resume, 1000);
__this->run_flag = 1;
APP_PROTOCOL_LOG("app_protocol_loop_process\n");
while (1) {
ret = os_taskq_pend("taskq", msg, ARRAY_SIZE(msg));
if (ret != OS_TASKQ) {
continue;
}
switch (msg[0]) {
case APP_PROTOCOL_RX_DATA_EVENT:
list_for_each_app_protocol(app) {
if (app->handler_id) {
if (app->loop) {
app->loop();
}
}
}
break;
case APP_PROTOCOL_TX_DATA_EVENT:
list_for_each_app_protocol(app) {
if (app->handler_id) {
if (app->tx_loop) {
app->tx_loop();
}
}
}
break;
case APP_PROTOCOL_TASK_EXIT:
os_sem_post((OS_SEM *)msg[1]);
os_time_dly(10000);
break;
default:
APP_PROTOCOL_LOG("err app protocal msg\n");
break;
}
}
}
//可以动态加载选择某个APP协议
void app_protocol_init(int handler_id)
{
APP_PROTOCOL_LOG("app_protocol_init\n");
//如果是第二次调用这个函数，就只起注册协议的作用，不需要重新建立任务
if (__this->running_protocol_number < MAX_NUMBER_RUN) {
#if APP_PROTOCOL_DEMO_CODE
if (app_protocol_demo_init(handler_id)) {
__this->running_protocol_number++;
}
#endif
#if APP_PROTOCOL_AMA_CODE
if (app_protocol_ama_init(handler_id)) {
__this->running_protocol_number++;
}
#endif
#if APP_PROTOCOL_GMA_CODE
if (app_protocol_gma_init(handler_id)) {
__this->running_protocol_number++;
}
#endif
#if APP_PROTOCOL_DMA_CODE
if (app_protocol_dma_init(handler_id)) {
__this->running_protocol_number++;
}
#endif
#if APP_PROTOCOL_MMA_CODE
if (app_protocol_mma_init(handler_id)) {
__this->running_protocol_number++;
}
#endif
#if APP_PROTOCOL_TME_CODE
if (app_protocol_tme_init(handler_id)) {
__this->running_protocol_number++;
}
#endif
}
if ((__this->running_protocol_number > 0) && __this->first_init_flag == 0) {
APP_PROTOCOL_LOG("app_protocol_task create\n");
__this->first_init_flag = 1;
task_create(app_protocol_loop_process, NULL, APP_PROTOCOL_TASK_NAME);
}
}
void app_protocol_all_init()
{
app_protocol_init(DEMO_HANDLER_ID);
app_protocol_init(DMA_HANDLER_ID);
app_protocol_init(MMA_HANDLER_ID);
app_protocol_init(GMA_HANDLER_ID);
app_protocol_init(TME_HANDLER_ID);
}
/*为了适应以前的参数格式，自定义了一个函数发消息*/
int app_protocol_post_msg(const char *name, int argc, ...)
{
int ret = 0;
int argv[8];
APP_PROTOCOL_LOG("mm_task_post_msg\n");
va_list argptr;
ASSERT(argc < 8);
va_start(argptr, argc);
for (int i = 0; i < argc; i++) {
argv[i] = va_arg(argptr, int);
}
va_end(argptr);
if (argc == 1) {
ret = os_taskq_post_type(name, argv[0], 0, NULL);
} else {
ret = os_taskq_post_type(name, argv[0], argc - 1, &argv[1]);
}
return ret;
}
void app_protocol_exit(int handler_id)
{
//handler_id为0时退出所有，有具体handler值是退出一个
OS_SEM sem;
app_protocol_interface_t *app;
if (handler_id == 0) {
list_for_each_app_protocol(app) {
if (app->handler_id) {
if (app->app_ctrl) {
if (app->app_ctrl->protocol_exit) {
app->app_ctrl->protocol_exit();
}
}
if (free_interface_for_id(app->handler_id)) {
__this->running_protocol_number--;
}
}
}
} else {
app = get_interface_for_id(handler_id);
if (app) {
if (app->app_ctrl) {
if (app->app_ctrl->protocol_exit) {
app->app_ctrl->protocol_exit();
}
}
if (free_interface_for_id(handler_id)) {
__this->running_protocol_number--;
}
}
}
APP_PROTOCOL_LOG("app_protocol_exit\n");
if (__this->run_flag && (!__this->running_protocol_number)) {
__this->run_flag = 0;
if (__this->tick_timer) {
sys_timer_del(__this->tick_timer);
__this->tick_timer = 0;
}
os_sem_create(&sem, 0);
os_taskq_post_type(APP_PROTOCOL_TASK_NAME, APP_PROTOCOL_TASK_EXIT, 1, (int *)&sem);
os_sem_pend(&sem, 0);
task_kill(APP_PROTOCOL_TASK_NAME);
__this->first_init_flag = 0;
APP_PROTOCOL_LOG("app_protocol_delete task\n");
}
}
int app_protocol_send_voice_data(uint8_t *voice_buf, uint16_t voice_len)
{
int error = 0;
app_protocol_interface_t *app = current_run_app;
if (app) {
if (app->app_ctrl) {
if (app->app_ctrl->send_voice_data) {
error = app->app_ctrl->send_voice_data(voice_buf, voice_len);
}
}
return error;
}
return -1;
}
int app_protocol_check_connect_success()
{
int flag = 0;
app_protocol_interface_t *app = current_run_app;
if (app) {
if (app->app_ctrl) {
//一般认为只有真正加密完才能说连接完成
if (app->app_ctrl->get_auth_state) {
flag = app->app_ctrl->get_auth_state();
}
}
}
return flag;
}
static int app_protocol_start_voice_recognition(int state)
{
int flag = 0;
app_protocol_interface_t *app = current_run_app;
if (!app) {
//做案子的时候百度有时候没连接也有状态更新到蓝牙库
app = get_interface_for_id(DMA_HANDLER_ID);
}
if (app) {
if (app->app_ctrl) {
//一般认为只有真正加密完才能说连接完成
if (app->app_ctrl->start_voice_recognition) {
flag = app->app_ctrl->start_voice_recognition(state);
}
}
}
return flag;
}
int app_protocol_start_speech_cmd()
{
return app_protocol_start_voice_recognition(1);
}
int app_protocol_stop_speech_cmd()
{
return app_protocol_start_voice_recognition(0);
}
int app_protocol_left_start_speech_cmd()
{
printf("left click");
return app_protocol_start_voice_recognition(2);
}
int app_protocol_right_start_speech_cmd()
{
printf("right click");
return app_protocol_start_voice_recognition(3);
}
void app_protocol_common_init(app_protocol_interface_t *app)
{
#if USER_SUPPORT_PROFILE_SPP
extern void user_spp_data_handler(u8 packet_type, u16 ch, u8 * packet, u16 size);
spp_data_deal_handle_register(user_spp_data_handler);
#endif
#if TCFG_USER_TWS_ENABLE
tws_api_auto_role_switch_disable();
#endif
if (app->callback) {
if (app->callback->message_handler_regedit) {
app->callback->message_handler_regedit(app_protocol_message_handler);
}
if (app->callback->check_tws_role_is_master_register) {
app->callback->check_tws_role_is_master_register(is_tws_master_role);
}
if (app->callback->check_some_status_register) {
app->callback->check_some_status_register(app_protocol_check_status);
}
if (app->callback->tx_resume) {
app->callback->tx_resume(app_protocol_send_resume);
}
if (app->callback->rx_resume) {
app->callback->rx_resume(app_protocol_resume);
}
if (app->callback->get_battery) {
app->callback->get_battery(app_protocol_get_battery);
}
}
if (app->app_ctrl) {
if (app->app_ctrl->protocol_init) {
app->app_ctrl->protocol_init();
}
}
}
//**对接具体协议的接口**//
#if APP_PROTOCOL_DEMO_CODE
extern int demo_process();
extern int demo_all_init(void);
extern int demo_all_exit(void);
static const struct app_ctrl_operation_t demo_ctrl = {
.protocol_init = demo_all_init,
.protocol_exit = demo_all_exit,
};
static int app_protocol_demo_init(int match_id)
{
if (DEMO_HANDLER_ID != match_id) {
return 0;
}
APP_PROTOCOL_LOG("app_protocol_demo_init\n");
app_protocol_interface_t *app = get_interface_for_id(DEMO_HANDLER_ID);
if (app) {
APP_PROTOCOL_LOG("DEMO_HANDLER_ID init again\n");
} else {
app = get_empty_interface();
if (app) {
app->handler_id = DEMO_HANDLER_ID;
app->loop = demo_process;
app->settings = NULL;
app->app_ctrl = &demo_ctrl;
app->callback = NULL;
app_protocol_common_init(app);
APP_PROTOCOL_LOG("DEMO_HANDLER_ID init OK\n");
return 1;
} else {
APP_PROTOCOL_LOG("not support more app protocal\n");
}
}
return 0;
}
#endif
#if APP_PROTOCOL_AMA_CODE
static int ama_run_loop(void)
{
APP_PROTOCOL_LOG("ama_run_loop\n");
return 0;
}
static int app_protocol_ama_init(int match_id)
{
if (AMA_HANDLER_ID != match_id) {
return 0;
}
APP_PROTOCOL_LOG("app_protocol_ama_init\n");
app_protocol_interface_t *app = get_interface_for_id(AMA_HANDLER_ID);
if (app) {
APP_PROTOCOL_LOG("AMA_HANDLER_ID init again\n");
} else {
app = get_empty_interface();
if (app) {
app->handler_id = AMA_HANDLER_ID;
app->loop = ama_run_loop;
app->settings = NULL;
app->app_ctrl = NULL;
app->callback = NULL;
APP_PROTOCOL_LOG("AMA_HANDLER_ID init OK\n");
return 1;
} else {
APP_PROTOCOL_LOG("not support more app protocal\n");
}
}
return 0;
}
#endif
#if APP_PROTOCOL_GMA_CODE
#if TCFG_USER_TWS_ENABLE//GMA_TWS_SUPPORTED
u8 gma_tws_support = 1;
#endif
extern const char *gma_tone_tab[];
extern struct app_protocol_private_handle_t gma_private_handle;
extern const u8 sdp_gma_spp_service_data[];
AI_RECORD_REGISTER(gma_record_item) = {
.service_record = (u8 *)sdp_gma_spp_service_data,
.service_record_handle = 0x00010035,
};
static const struct callback_register_t gma_callback = {
.message_handler_regedit = gma_message_callback_register,
.check_tws_role_is_master_register = gma_is_tws_master_callback_register,
.tx_resume = gma_tx_resume_register,
.rx_resume = gma_rx_resume_register,
.get_battery = gma_get_battery_callback_register,
};
static const struct app_ctrl_operation_t gma_ctrl = {
.protocol_init = gma_all_init,
.protocol_exit = gma_all_exit,
.send_voice_data = gma_opus_voice_mic_send,
.get_auth_state = gma_connect_success,
.start_voice_recognition = gma_start_voice_recognition,
.adv_enable = gma_ble_adv_enable,
.ibeacon_adv = gma_ble_ibeacon_adv,
.disconnect = gma_disconnect,
};
static const struct app_protocol_info_t gma_settings = {
.set_special_info_group = gma_set_active_ali_para,
.set_tws_sibling_mac = gma_set_sibling_mac_para,
};
#define GMA_MAIN_NUMBER 0X00
#define GMA_SECONDARY_NUMBER 0X00
#define GMA_REVISION_NUMBER 0X01
int app_protocol_gma_get_version(void)
{
return (GMA_MAIN_NUMBER << 16 | GMA_SECONDARY_NUMBER << 8 | GMA_REVISION_NUMBER);
}
/*
*code crc16
* */
static unsigned short wCRCin = 0xFFFF;
static unsigned short wCPoly = 0x1021;
static unsigned short CRC16_CCITT_FALSE(u16 init_crc, unsigned char *data, unsigned int datalen)
{
while (datalen--) {
wCRCin ^= *(data++) << 8;
for (int i = 0; i < 8; i++) {
if (wCRCin & 0x8000) {
wCRCin = (wCRCin << 1) ^ wCPoly;
} else {
wCRCin = wCRCin << 1;
}
}
}
return (wCRCin);
}
static void CRC16_CCITT_FALSE_INIT(void)
{
wCRCin = 0xFFFF;
wCPoly = 0x1021;
}
static int CRC16_CODE_RESULT(int calc_crc)
{
return 0;
}
static int app_protocol_gma_init(int match_id)
{
if (GMA_HANDLER_ID != match_id) {
return 0;
}
APP_PROTOCOL_LOG("app_protocol_gma_init\n");
app_protocol_interface_t *app = get_interface_for_id(GMA_HANDLER_ID);
if (app) {
APP_PROTOCOL_LOG("GMA_HANDLER_ID init again\n");
} else {
app = get_empty_interface();
if (app) {
app->handler_id = GMA_HANDLER_ID;
app->loop = gma_rx_loop;
app->tx_loop = tm_data_send_process_thread;
app->settings = &gma_settings;
app->app_ctrl = &gma_ctrl;
app->callback = &gma_callback;
gma_prev_init();
app_protocol_tone_register(gma_tone_tab);
app_protocol_handle_register(&gma_private_handle);
app_protocol_common_init(app);
app_protocol_ota_api api = {
.ota_request_data = gma_ota_requset_next_packet,
.ota_report_result = gma_replay_ota_result,
.ota_crc_init_hdl = CRC16_CCITT_FALSE_INIT,
.ota_crc_calc_hdl = CRC16_CCITT_FALSE,
};
app_protocol_ota_init(&api, 0);
/* app_protocol_data_api_register(gma_ota_requset_next_packet, gma_replay_ota_result); */
/* app_protocol_ota_crc_handler_register( CRC16_CCITT_FALSE_INIT, CRC16_CCITT_FALSE); */
APP_PROTOCOL_LOG("GMA_HANDLER_ID init OK\n");
return 1;
} else {
APP_PROTOCOL_LOG("not support more app protocal\n");
}
}
return 0;
}
#endif
#if APP_PROTOCOL_DMA_CODE
//u8 dma_tws_support = 1;
extern const char *dma_notice_tab[];
extern const u8 sdp_dueros_spp_service_data[];
extern const u8 sdp_dueros_ota_service_data[];
AI_RECORD_REGISTER(dma_record_item) = {
.service_record = (u8 *)sdp_dueros_spp_service_data,
.service_record_handle = 0x00010036,
};
AI_RECORD_REGISTER(dma_ota_record_item) = {
.service_record = (u8 *)sdp_dueros_ota_service_data,
.service_record_handle = 0x00010037,
};
static const struct callback_register_t dma_callback = {
.message_handler_regedit = dma_message_callback_register,
.check_some_status_register = dma_check_status_callback_register,
.tx_resume = dma_tx_resume_register,
.rx_resume = dma_rx_resume_register,
.get_battery = dma_get_battery_callback_register,
};
static const struct app_ctrl_operation_t dma_ctrl = {
.protocol_init = dma_all_init,
.protocol_exit = dma_all_exit,
.adv_enable = dma_ble_adv_enable,
.send_voice_data = dma_speech_data_send,
.get_auth_state = dma_pair_state,
.start_voice_recognition = dma_start_voice_recognition,
.disconnect = dma_disconnect,
.update_tws_state_to_lib = dma_update_tws_state_to_lib,
.tws_receive_sync_data = dma_tws_data_deal,
/*.send_voice_data = dma_opus_voice_mic_send,
.adv_enable = dma_ble_adv_enable,*/
};
static const struct app_protocol_info_t dma_settings = {
.set_product_id = dma_set_pid,
.set_special_info_group = dma_set_product_id_key,
};
static int dueros_special_message(int id, int opcode, u8 *data, u32 len)
{
int ret = 0;
switch (opcode) {
case APP_PROTOCOL_DMA_SAVE_RAND:
APP_PROTOCOL_LOG("APP_PROTOCOL_DMA_SAVE_RAND");
//APP_PROTOCOL_DUMP(data, len);
ret = syscfg_write(VM_DMA_RAND, data, len);
//app_protocol_tws_send_to_sibling(DMA_TWS_ALL_INFO_SYNC, data, len);
break;
case APP_PROTOCOL_DMA_READ_RAND:
APP_PROTOCOL_LOG("APP_PROTOCOL_DMA_READ_RAND");
ret = syscfg_read(VM_DMA_RAND, data, len);
//APP_PROTOCOL_DUMP(data, len);
break;
case APP_PROTOCOL_DMA_SAVE_OTA_INFO:
APP_PROTOCOL_LOG("APP_PROTOCOL_DMA_SAVE_OTA_INFO");
APP_PROTOCOL_DUMP(data, len);
//不支持断点续传
//ret = syscfg_write(VM_TME_AUTH_COOKIE, data, len);
//app_protocol_tws_send_to_sibling(DMA_TWS_OTA_INFO_SYNC, data, len);
break;
case APP_PROTOCOL_DMA_READ_OTA_INFO:
APP_PROTOCOL_LOG("APP_PROTOCOL_DMA_READ_OTA_INFO");
//ret = syscfg_read(VM_TME_AUTH_COOKIE, data, len);
//不支持断点续传
memset(data, 0, len);
APP_PROTOCOL_DUMP(data, len);
break;
case APP_PROTOCOL_DMA_TTS_TYPE:
printf("app_protocol_dma_tone_play %d\n", data[0]);
//app_protocol_dma_tone_play(data[0], 1);
break;
}
return ret;
}
static int app_protocol_dma_init(int match_id)
{
if (DMA_HANDLER_ID != match_id) {
return 0;
}
APP_PROTOCOL_LOG("app_protocol_dma_init\n");
app_protocol_interface_t *app = get_interface_for_id(DMA_HANDLER_ID);
if (app) {
APP_PROTOCOL_LOG("DMA_HANDLER_ID init again\n");
} else {
app = get_empty_interface();
if (app) {
app->handler_id = DMA_HANDLER_ID;
app->loop = dueros_process;
app->tx_loop = dueros_send_process;
app->special_message = dueros_special_message;
app->settings = &dma_settings;
app->app_ctrl = &dma_ctrl;
app->callback = &dma_callback;
app_protocol_tone_register(dma_notice_tab);
dueros_dma_manufacturer_info_init();
app_protocol_common_init(app);
APP_PROTOCOL_LOG("DMA_HANDLER_ID init OK\n");
return 1;
} else {
APP_PROTOCOL_LOG("not support more app protocal\n");
}
}
return 0;
}
#endif
#if APP_PROTOCOL_TME_CODE
extern const char *tme_notice_tab[APP_RROTOCOL_TONE_MAX];
extern const u8 sdp_tme_service_data[];
extern struct app_protocol_private_handle_t tme_private_handle;
AI_RECORD_REGISTER(tme_record_item) = {
.service_record = (u8 *)sdp_tme_service_data,
.service_record_handle = 0x00010037,
};
static const struct callback_register_t tme_callback = {
.message_handler_regedit = tme_message_callback_register,
.check_tws_role_is_master_register = tme_is_tws_master_callback_register,
.tx_resume = tme_tx_resume_register,
.rx_resume = tme_rx_resume_register,
.get_battery = tme_get_battery_callback_register,
};
static const struct app_ctrl_operation_t tme_ctrl = {
.protocol_init = tme_all_init,
.protocol_exit = tme_all_exit,
.adv_enable = tme_ble_adv_enable,
.send_voice_data = tme_send_voice_data,
.get_auth_state = tme_connect_success,
.start_voice_recognition = tme_start_voice_recognition,
.disconnect = tme_protocol_disconnect,
// .ibeacon_adv = gma_ble_ibeacon_adv,
// int(*regist_wakeup_send)(void *priv, void *cbk);
// int(*regist_recieve_cbk)(void *priv, void *cbk);
// int(*latency_enable)(void *priv, u32 enable);
// int(*send_data)(void *priv, void *buf, u16 len);
};
static const struct app_protocol_info_t tme_settings = {
.set_special_info_group = tme_set_configuration_info,
.set_product_id = tme_set_pid,
.set_vendor_id = tme_set_bid,
//.set_tws_sibling_mac = gma_set_sibling_mac_para,
//void (*set_left_battery)(u8 bat);
};
#define TME_VERSION {0x00,0x10}//版本号
static const char version[] = TME_VERSION;
int app_protocol_tme_get_version(void)
{
return (version[0] << 8) | version[1];
}
static int app_protocol_tme_init(int match_id)
{
if (TME_HANDLER_ID != match_id) {
return 0;
}
APP_PROTOCOL_LOG("app_protocol_tme_init\n");
app_protocol_interface_t *app = get_interface_for_id(TME_HANDLER_ID);
if (app) {
APP_PROTOCOL_LOG("TME_HANDLER_ID init again\n");
} else {
app = get_empty_interface();
if (app) {
app->handler_id = TME_HANDLER_ID;
app->loop = TME_protocol_process;
app->tx_loop = TME_send_packet_process;
app->settings = &tme_settings;
app->app_ctrl = &tme_ctrl;
app->callback = &tme_callback;
app_protocol_tone_register(tme_notice_tab);
app_protocol_handle_register(&tme_private_handle);
app_protocol_ota_api api = {
.ota_request_data = TME_request_ota_data,
.ota_report_result = NULL,
.ota_crc_init_hdl = NULL,
.ota_crc_calc_hdl = NULL,
.ota_notify_file_size = TME_notify_file_size,
};
app_protocol_ota_init(&api, 0);
app_protocol_common_init(app);
APP_PROTOCOL_LOG("TME_HANDLER_ID init OK\n");
return 1;
} else {
APP_PROTOCOL_LOG("not support more app protocal\n");
}
}
return 0;
}
#endif
#if APP_PROTOCOL_MMA_CODE
extern void mma_prev_init();
extern const char *mma_notice_tab[APP_RROTOCOL_TONE_MAX];
extern struct app_protocol_private_handle_t mma_private_handle;
static const struct callback_register_t mma_callback = {
.message_handler_regedit = mma_message_callback_register,
.check_tws_role_is_master_register = mma_is_tws_master_callback_register,
.tx_resume = mma_tx_resume_register,
.rx_resume = mma_rx_resume_register,
.get_battery = mma_get_battery_callback_register,
};
static const struct app_ctrl_operation_t mma_ctrl = {
.protocol_init = mma_all_init,
.protocol_exit = mma_all_exit,
.adv_enable = mma_ble_adv_enable,
.send_voice_data = XM_speech_data_send,
.get_auth_state = XM_protocal_auth_pass,
.start_voice_recognition = mma_start_voice_recognition,
.disconnect = mma_disconnect,
.tws_receive_sync_data = mma_tws_data_deal,
};
static const struct app_protocol_info_t mma_settings = {
.set_product_id = mma_set_product_id,
.set_vendor_id = mma_set_verdor_id,
.set_local_version = mma_set_local_version,
};
int mma_special_message(int id, int opcode, u8 *data, u32 len)
{
int ret = 0;
switch (opcode) {
case APP_PROTOCOL_MMA_SAVE_INFO:
APP_PROTOCOL_LOG("APP_PROTOCOL_MMA_SAVE_");
APP_PROTOCOL_DUMP(data, len);
ret = syscfg_write(VM_DMA_RAND, data, len);
break;
case APP_PROTOCOL_MMA_READ_INFO:
APP_PROTOCOL_LOG("APP_PROTOCOL_mMA_READ_");
ret = syscfg_read(VM_DMA_RAND, data, len);
APP_PROTOCOL_DUMP(data, len);
break;
case APP_PROTOCOL_MMA_SAVE_ADV_COUNTER:
syscfg_write(VM_TME_AUTH_COOKIE, data, len);
break;
case APP_PROTOCOL_MMA_READ_ADV_COUNTER:
syscfg_read(VM_TME_AUTH_COOKIE, data, len);
break;
}
return ret;
}
static int app_protocol_mma_init(int match_id)
{
if (MMA_HANDLER_ID != match_id) {
return 0;
}
APP_PROTOCOL_LOG("app_protocol_mma_init\n");
app_protocol_interface_t *app = get_interface_for_id(MMA_HANDLER_ID);
if (app) {
APP_PROTOCOL_LOG("MMA_HANDLER_ID init again\n");
} else {
app = get_empty_interface();
if (app) {
app->handler_id = MMA_HANDLER_ID;
app->loop = mma_protocol_loop_process;
/*app->tx_loop = ;*/
app->special_message = mma_special_message;
app->settings = &mma_settings;
app->app_ctrl = &mma_ctrl;
app->callback = &mma_callback;
app_protocol_tone_register(mma_notice_tab);
app_protocol_ota_api api = {
.ota_request_data = mma_request_ota_data,
.ota_report_result = mma_report_ota_status,
.ota_crc_init_hdl = NULL,
.ota_crc_calc_hdl = NULL,
.ota_notify_file_size = mma_notify_file_size,
};
app_protocol_ota_init(&api, 1); //mma需要等待APP来进行复位
mma_prev_init();
app_protocol_handle_register(&mma_private_handle);
app_protocol_common_init(app);
APP_PROTOCOL_LOG("mMA_HANDLER_ID init OK\n");
return 1;
} else {
APP_PROTOCOL_LOG("not support more app protocal\n");
}
}
return 0;
}
#endif
int app_protocol_get_version_by_id(int id)
{
#if APP_PROTOCOL_GMA_CODE
if (id == GMA_HANDLER_ID) {
return app_protocol_gma_get_version();
}
#endif
#if APP_PROTOCOL_TME_CODE
if (id == TME_HANDLER_ID) {
return app_protocol_tme_get_version();
}
#endif
return 0;
}
/* int app_protocol_reply_frame_check_result(int result){ */
/* if( app_protocol_get_cur_handle_id() == GMA_HANDLER_ID){ */
/* gma_replay_ota_result(result); */
/* } */
/* return 0; */
/* } */
//编译问题加几个空的
_WEAK_ void bt_ble_init(void)
{
}
_WEAK_ void bt_ble_exit(void)
{
APP_PROTOCOL_LOG("bt_ble_exit");
app_protocol_disconnect(0);
}
_WEAK_ void bt_ble_adv_enable(void)
{
}
#else
void app_protocol_init(int handler_id)
{
}
void app_protocol_exit(int handler_id)
{
}
#endif
Reference in New Issue Copy Permalink