[NOVATEK] NT96580行车记录仪ET580声控

txz那边给过来的文件有：libactive.a和txz_engine.h以及sample_code.c(网络激活)

ASR.c和ASR.h是我们移植sample_code.c的

一、文件移植

1、将ASR.c+ASR.h+txz_engine.h复制到code\application\source\cardv\SrcCode\UIApp路径下

2、将libactivate.a复制到code\lib\output路径下

3、code\application\source\cardv\Makefile内要包含ASR.c: ./SrcCode/UIApp/ASR.c

4、在code\application\source\cardv\OutputImg.mk里面包含libactivate.a(每次make clean之后这个库就会不见要重新复制进去)

放到这里Z:\SunFan\ET580\final\ET580\code\lib\source\fileout可以解决make clean后库不见的问题

对比565的makefile加会报错

正确方法：LDFLAGS += -lactivate 和-l:libactivate.a一起加

 

二、准备工作

1、txz_engine.h里面需要用到的函数:

需要做一个修改不然编译器会认为不安全

 

 

三、代码

ASR_FUNCTION的宏定义在UIAppNetwork.c、SysInput_Exe.c、UISetup_Exe.c 、SysMain_Exe.c、SoundData.h

为了出货方便最后放在了SrcCode\PrjCfg.h里面

1、UISetup_Exe.c

• 检测SD卡里面有没有WiFi名和密码预设文件

• 在SetupExe_OnWifiStart里面如果ASR_FUNCTION模式打开且SD卡里面有WiFi预设内容则把WiFi模式设置为NET_STATION_MODE

2、UiAppNetwork.c

• WiFi名和密码预设文件路径

• 地址（具体作用不太清楚）

•  读取预先设置在文件中的WiFi名和密码并将记录仪的SSID和gPASSPHRASE设置为相应的

• 在设置Wifi名和密码函数里面去读取预设的内容（在ASR_FUNCTION打开且SD卡内有文件的情况下）

 3、SysInput_Exe.c

• 新增TXZ_MESSAGE_PROCESS和CZS_ASR_INIT（CZS_ASR_INIT里面调用TXZ_MESSAGE_PROCESS）

读取返回值判断后执行相应指令

• 在UI_DetCustom1Key里面1秒循环一次调用

4、SysMain_Exe.c

在开启设备和关闭设备的时候调用ASR.c里面的ASR_Init和ADR_UnInit

 下面这个变量目前没啥作用

5、ASR.c

按照txz给的demo流程进行设备激活生成txz.txt文件以及激活后的将语音数据传输给指令识别引擎

6、SoundData.h

UIWnd\SPORTCAM\Resource\SoundData.h

7、SoundData.c

SrcCode\UIWnd\SPORTCAM\Resource\SoundData.c

拷贝SoundData_Okay_16K.c文件到UIWnd\SPORTCAM\Resource

 

四、过程中遇到的问题 

1、网络连接不上

Linux系统进入STATION模式需要wpa_supplicant

搜索发现SDK里面是自带的：\code\application\external

查看Makefile文件里面发现make命令已经有了但是没有编译出来

 在na51055_linux_ET580\configs搜索hostapd（这个是用于AP模式的，已经成功搜索它）发现都是在xxxxx-info.dtsi文件里面，则找到对应的配置增加wap_supplicant

na51055_linux_ET580\configs\Linux\cfg_580_CARDV_ETHCAM_RX_EVB\nvt-na51055-info.dtsi

进行上述步骤后

• STA（Station）模式

STA模式，也被称为客户端模式，是指设备连接到现有的无线网络，通常是由一个无线接入点（Access Point）提供的网络。在STA模式下，设备可以作为网络中的终端节点，用于访问互联网或与同一网络内的其他设备进行通信。例如，您的手机、笔记本电脑、智能电视等在家中连接Wi-Fi时，它们就是以STA模式工作的。

• AP（Access Point）模式

AP模式指的是设备自身作为一个无线接入点，能够创建一个无线网络供其他设备连接。在AP模式下，设备会广播一个SSID（Service Set Identifier），其他设备可以搜索并连接到这个SSID来接入网络。AP模式常用于小型网络环境，比如家庭、办公室或临时会议场所，有时也被用于设置热点或实现设备间的直接通信，如Ad-Hoc网络。

2、声音采样率

导致播放出来的声音不正常

定义

UIWnd\SPORTCAM\Resource\SoundData.h

UIWnd\SPORTCAM\Resource\SoundData.c

UIApp\Movie\UIAppMovie_RecSetting.c

3、ImageApp_MovieMulti_AudCapGetFrame报错

ImageApp_MovieMulti_AudCapGetFrame找到这个函数所在文件发现还有两个函数ImageApp_MovieMulti_Open和ImageApp_MovieMulti_AudCapStart，在调用这些函数的地方加打印发现这个报错是函数先后执行的问题，正常顺序是START----OPEN-----GETFRAME,ImageApp_MovieMulti_AudCapGetFrame是在线程里面执行，但是还没执行open和start它就执行了导致报错，报错一段时间后就没了

解决办法：在线程刚开始延时几秒，等待start和open的函数先执行完

通过打印DataAddr和DataSize的值发现， DataSize的值是0导致读取数据长度为0

16K采样率是2048,32K采样率是4096

4、发出关闭录音指令后无法识别接下来的语音

code\application\source\cardv\SrcCode\UIApp\Movie\UIAppMovie_Exe.c：MovieExe_OnOpen

在ImageApp_MovieMulti_Open之前添加才能生效

5、走激活流程STATION模式下红灯也要亮

（1）设备连接上热点后红灯闪烁

UIApp\Network\UIAppNetwork.c

（2）设备启动后红灯常亮

原来是放在下面一点，为了兼容ET580声控现在放到统一函数的上面一点

UIApp\Setup\UISetup_Exe.c

6、激活文件要保存在FLASH里面

修改ASR.c，加一个宏定义

ASR.c

#include "vf_gfx.h"
#include <kwrap/error_no.h>
#include "System/SysCommon.h"
#include "System/SysMain.h"
#include "UIApp/Movie/UIAppMovie.h"
#include "UIWnd/SPORTCAM/UIInfo/UIInfo.h"
#include "PStore.h"
#include "txz_engine.h"
#include "ASR.h"
#include <kwrap/debug.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <dirent.h>


//#include <pthread.h>
//static pthread_t ASRRECEIVE_ID;
//static volatile sig_atomic_t g_bASRreceiveTskOpened = 0;
//static volatile sig_atomic_t g_bASRreceiveTskClosing = 0;

#define _ASR_ENABLE_ 1
#define USB_JIHUO	DISABLE//ENABLE

#if defined(_ASR_ENABLE_)

#include "txz_engine.h"
#include "ASR.h"
#include "sys_mempool.h"
#include <kwrap/semaphore.h>
#include <kwrap/flag.h>
#include "FileSysTsk.h"

#define SAVE_DIR "/mnt/sd/txz.txt"
#define PP_PATH "/mnt/sd/"   // push pop file
#define TXZ_PATH "/mnt/sd/"  // txz file

static void *txzHandle = NULL;
UINT8 * mempool_asr=NULL;
UINT32 audio_T=0;
#define PRI_ASR             20
#define STKSIZE_ASR         (512*8)
static UINT32 is_asr_opened = 0;
char onlydata_send[512]={0};

UINT8 success_flag = 0;
THREAD_HANDLE ASRRECEIVE_ID = 0;
static ID FLG_ID_ASR = 0;
static ID FASR_SEM_ID = 0;
static BOOL     g_bASRreceiveTskOpened = FALSE;
static BOOL     g_bASRreceiveTskClosing = FALSE;
#define ASR_FLAG_ALL		        0xFFFFFFFF
#define FLGASR_IDLE          FLGPTN_BIT(0)

//解码库为激活APP 准备的授权检验的字符串，包含DVR MAC地址
int txz_sendData(void *data,int len)
{
	memcpy(onlydata_send,data,len);
	vk_pr_warn("txz_sendData ---onlydata_send:%s\r\n", onlydata_send);
	return 0;
}


// APP 激活时  APP 通过wifiCMD9962 -- XML_Get_app_onlysum  call 到这里
char *Send_app_onlysum(void)  
{
	vk_pr_warn(" Send_app_onlysum ---onlydata_send:%s\r\n", onlydata_send);
	return onlydata_send;
}
char onlydata_get[512]={0};
BOOL date_send_true=0;


//激活APP  通过 WiFiCmd_OnExeSetONLYSUM 传下来的，然后解码库call xz_recvData
int txz_recvData(void *data,int len)  
{
	// 激活APP 发过来的 授权码字符串，包含DVR MAC地址、授权ID
	vk_pr_warn(" txz_recvData onlydata_get=%s,strlen(onlydata_get)=%d\r\n", onlydata_get,strlen(onlydata_get));

	if(date_send_true)
	{
		memcpy(data,onlydata_get,len);
		date_send_true=0;
		return 1;
	}
	else
	{
		return 0;
	}
}
char onlysum[512] = {0};

extern char *UINet_GetMAC(void);

void Set_app_onlysum(CHAR onlysum[512])  
{

	ASRCALI_INFO AsrCali_Info;
	PPSTORE_SECTION_HANDLE  pSection;
	UINT32 error = 0;
	
	CHKPNT;

	AsrCali_Info.uiVerifyCode = ASR_VERIFICATION;	
	memcpy(AsrCali_Info.MacAddr , UINet_GetMAC(), NVT_WIFIIPC_MAC_ADDR_LEN);
	memcpy(AsrCali_Info.App_onlysum ,onlysum, 512);
		UINT32 uiPsFreeSpace = 0;
		uiPsFreeSpace=PStore_GetInfo(PS_INFO_FREE_SPACE);

		DBG_DUMP("uiPsFreeSpace = %d   sizeof(ASRCALI_INFO)=%d\r\n",uiPsFreeSpace, sizeof(ASRCALI_INFO));
		
	if ((pSection = PStore_OpenSection(PS_ASR_PARAM, PS_RDWR | PS_CREATE)) != E_PS_SECHDLER) 
	{
	CHKPNT;
		PStore_WriteSection((UINT8 *)&AsrCali_Info, 0, sizeof(ASRCALI_INFO), pSection);
		PStore_CloseSection(pSection);
		//UISound_Play(DEMOSOUND_SOUND_AUTHTRUE_TONE);
	}
	CHKPNT;
	if (PStore_CheckSection(PS_ASR_PARAM, &error) != E_PS_OK) {
			DBG_ERR("PStore_CheckSection\r\n");
		}
	vk_pr_warn(" Set_app_onlysum to Save_MenuInfo...\r\n");
	//Save_MenuInfo();	
	
}

//开机后运行解码库时，解码库首先来获取授权码
char *Get_app_onlysum(void)   
{
	ASRCALI_INFO AsrCali_Info;
	PPSTORE_SECTION_HANDLE  pSection;
    char mac[NVT_WIFIIPC_MAC_ADDR_LEN] = {0, 0, 0, 0x81, 0x89, 0xe5};
	memset((UINT8 *)&AsrCali_Info, 0, sizeof(ASRCALI_INFO));

	if ((pSection = PStore_OpenSection(PS_ASR_PARAM, PS_RDWR)) != E_PS_SECHDLER) {
		PStore_ReadSection((UINT8 *)&AsrCali_Info, 0, sizeof(ASRCALI_INFO), pSection);
		PStore_CloseSection(pSection);
	} else {
		DBG_ERR("^R Pstore of ASR open to read FAIL\r\n");
	}
	if(AsrCali_Info.uiVerifyCode == ASR_VERIFICATION)
	{
		memcpy(mac,AsrCali_Info.MacAddr ,NVT_WIFIIPC_MAC_ADDR_LEN); 
		memcpy(onlysum,AsrCali_Info.App_onlysum ,512); 
       	 vk_pr_warn("\r\n Get_app_onlysum onlysum:%s  strlen(onlysum)=%d\r\n",onlysum,strlen(onlysum));
	}
	return onlysum;
}




static int32_t load_fun(void *data, int len)
{
#if (USB_JIHUO)//
	if(access(SAVE_DIR, F_OK) == 0)
	{
		FILE* fp = fopen(SAVE_DIR, "r");
		if(fp == NULL)
		{
			printf("open %s file error\n",SAVE_DIR);
			return -1; //失败
		}
		size_t sf_read=fread(data,1,len,fp);
		printf("read from %s:[%ld]\n",SAVE_DIR,sf_read);
		fclose(fp);
		return 0;
	}
	return -1;
//
#else 
	memcpy(data,Get_app_onlysum(),len); 
	//strcpy(data,"dHh6qENFREeOx94VDcNh5FqbotWypRHbrRl18ADJLadBB9AZVyFIEhij0xXfBV20QvB8NZfTwwmFlC3WS7I05oFVBORfDsmof61alFq8X8nTfGaHWXwlWNfynbLM3AhN8gXNv0DBbl/+rOVAMDZE2eEngHwWPfQ301T/rCzlhcgc+FW1Y4rs1f2/p4VppvBfrOSTnTQMJUvkHhYJ3rMO9xPMGYPeVwyQR/H7NlgAAABCTGt5cm5QcXlWZjJPUDZyeUJaY1ZhclgzRGxsT3EyYkFlQkYvNjllYXNNY1JmaXZBTjhhRWVUZGFEYnozV0JYeXpwcTFveFM3MGZCdkc5T1UwNmJIUT09");
	//vk_pr_warn("load_fun	   len=%d \n\r",len);
	return len;
#endif
		return 0;

}

static int32_t save_fun(const void *data, int len)
{
#if (USB_JIHUO)
	FILE* fp = fopen(SAVE_DIR, "wb+");
	if(fp == NULL)
	{
		printf("open %s file error\n",SAVE_DIR);
		return -1; //失败返回-1
	}
	
	int sf_write= fwrite(data,1,len,fp);
	printf("write to %s:[%ld]\n",SAVE_DIR,sf_write);
    fclose(fp);
    return sf_write;
#else
	char buf[512] = {0};
	memcpy(buf,data,len);
	Set_app_onlysum(buf);
#endif
	return 524;  
}

BOOL gb_CHANG_MODE_FLAG=0;
void *Mem = NULL; 


THREAD_RETTYPE ASRTsk2(void){

	printf("\n-------------ASRTsk2_THREAD--------------\n");
	//unsigned short keyIndex = 0;
	//float confidence = 0.0;
	//char* keyWord = NULL;
	const char *keyWord = NULL;
	uint16_t keyIndex = 0;
	float confidence = 0.0;
	UINT8 *DataAddr;
	UINT32 DataSize;
	DataAddr = (UINT8 *)mempool_asr;
	THREAD_ENTRY();
	vos_flag_clr(FLG_ID_ASR, FLGASR_IDLE);

	while (ASRRECEIVE_ID) {
		if(success_flag ==0){
			#define TXZ_TOKEN "618bbf998f82da9a9e451d53bab27abfa4f03375"
			#define TXZ_APPID "80fd4647513c9015423fc60b593e1439"
			//char filename[268]={0};
			//strcpy(filename,"/mnt/sd/audio.pcm");
			printf("start txzEngineSetStorageFunc\r\n");

			//初始化
			vos_util_delay_ms(2600);
			txzSetLogLevel(OSAL_LOG_INFO);
			txzEngineSetStorageFunc(load_fun, save_fun); //设置存储回调 用于保存激活数据
			txzEngineSetAppid(TXZ_APPID);/*同行者会给出*/
			//txzEngineSetCustomerId("customerId"); //供应商提供的客户id（可能没有，这个跟激活方式有关,需要询问商务或者同行者的工作人员）
			printf("start txzEngineSetStorageFunc\r\n");
			int ret = 0;
			while((ret = txzEngineInit(NULL, TXZ_TOKEN,PP_PATH, TXZ_PATH,&txzHandle)) == -1) //初始化
			{
				printf("sleep 3 s");
				sleep(3);
			}
			printf("\n\n-----Initialization successful  ret=%d-----\n\n",ret);
			if(ret ==0){
				//UISound_Play(DEMOSOUND_SOUND_VOICE_TONE);//语音播报语音助手已开启
				success_flag =1;
			}else{
			//if (ret != 0) //初始化失败(即机器未激活){
				printf("\n\n\n---------NO ACTIVATION----------\n\n\n");
				//激活流程
				int write_file_flag = 1;
				int read_file_flag = 1;
				int write_otp_flag = 1;
				int net_pop_flag = 1;
				int init_flag = 1;
				while(1)
				{
				if (write_file_flag) {
					printf("txz write file start\n");
					write_file_flag = txzEngineWriteFile(); //生成push文件
					printf("txz write file over\n");
				}
				if(net_pop_flag!=0 && !write_file_flag){
					printf("txz Network start\n");
					net_pop_flag = txzEngineNetwork(); //通过网络生成pop数据
					if(net_pop_flag!=0){
						printf("txzEngineNetwork error:%lld",net_pop_flag);
					}
					printf("txz Network over\n");
				}
				if (read_file_flag && net_pop_flag==0) {
					printf("txz read file start\n");
					read_file_flag = txzEngineReadFile(); //读取pop文件
					printf("txz read file over\n");
				}
				if (write_otp_flag && !read_file_flag) {
					printf("txz write otp start\n");
					write_otp_flag = txzEngineWriteOTP(); //保存激活数据
					printf("txz write otp over\n");
				}
				if (init_flag && !write_otp_flag) {
					printf("txzEngineInit start\n");
					init_flag = txzEngineInit(NULL, TXZ_TOKEN,PP_PATH, TXZ_PATH,&txzHandle);
					printf("txzEngineInit over\n");
				}
				if (!init_flag) {
					UISound_Play(DEMOSOUND_SOUND_VOICE_TONE);//语音播报语音助手已开启
					success_flag =1;
					break;
				}
				sleep(3);
				printf("delay 3s txz\r\n");
				}
			}
		}

		ER result;
		if(success_flag ==1){
			DataAddr = (UINT8 *)mempool_asr;
			DataSize=4096;//16k-2048 32k-4096
			result = ImageApp_MovieMulti_AudCapGetFrame(0,DataAddr,&DataSize,200);
			result = txzEngineProcess((void *)txzHandle, (signed short *)DataAddr, DataSize/2, (unsigned short *)&keyIndex, &confidence);
			//printf("\n\n====[result]:%d====\n\n",result);
	        if (result == 0)
			{
				result = txzEngineGetName(keyIndex, &keyWord);
				audio_T=keyIndex;
				printf("======Command ID: %d - %s - %f\n\r", keyIndex, keyWord,confidence);
				txzEngineReset((void *)txzHandle);
			}
		}

		/*测试代码从sd卡里面读取预先保存的.pcm文件*/
		/*FILE *audioFp = fopen("/mnt/sd/audio.pcm", "r"); //此处采取读取文件方式获取录音数据，目前离线引擎只支持16K，位深16，单声道音频
		if(audioFp == NULL){
			printf("\naudio.pcm is empty\n");
			break;
		}
		int size = 0, total_size = 0;
		char audioData[960];
		while(1){
			total_size = fread(audioData, 1, 960, audioFp);
			if(total_size <= 0)
			{
				printf("\ntotal_size <= 0  break!\n");
				break;
			}
			size = 0;
			while(size < total_size){
			if(total_size - size >= 960){
			result = txzEngineProcess((void *)txzHandle, (signed short *)(audioData + size), 480, (unsigned short *)&keyIndex, &confidence);
			}else{
			// 将数据 塞入引擎识别 评估音频质量时 将数据(signed short *)(audioData + size) 数据量(total_size - size) 写入文件看看
			result = txzEngineProcess((void *)txzHandle, (signed short *)(audioData + size), (total_size - size)/2, (unsigned short *)&keyIndex,&confidence);
			}
			printf("\n\n====[result]:%d====\n\n",result);
			if (result == 0) {
				result = txzEngineGetName(keyIndex, &keyWord);
				//ret = txzEngineGetName(keyIndex, (const char**)&keyWord);
				audio_T=keyIndex;
				printf("======Command ID: %d - %s - %f\n\r", keyIndex, keyWord,confidence);
				// 清除当前识别结果记录
				txzEngineReset((void *)txzHandle);
			}
				size += 960;
			}
		}
		fclose(audioFp);*/
	}
	THREAD_RETURN(0);
}

void ASR_InstallID(void)
{
   //OS_CONFIG_TASK(ASR_TSK_ID2, PRI_ASR, STKSIZE_ASR, ASRTsk2);
   T_CFLG cflg ;
  
   vos_flag_create(&FLG_ID_ASR, &cflg, "ASR receive FLG");
   vos_sem_create(&FASR_SEM_ID, 1, "ASR receive SEM");

}
void ASR_UnInstallID(void)
{
	//OS_CONFIG_TASK(MOVIESTAMPTSK_ID, PRI_MOVIESTAMP, STKSIZE_MOVIESTAMP, MovieStampTsk);
	vos_flag_destroy(FLG_ID_ASR);
	vos_sem_destroy(FASR_SEM_ID);
}

ER ASRreceiveTsk_Open(void)
{

	if (g_bASRreceiveTskOpened) {
		return E_SYS;
	}
	vk_pr_warn("######################ASRreceiveTsk_Open######################\n\r");

	ASR_InstallID();
	vos_flag_clr(FLG_ID_ASR, ASR_FLAG_ALL);
	g_bASRreceiveTskOpened = TRUE;
	g_bASRreceiveTskClosing = FALSE;
	//sta_tsk(MOVIESTAMPTSK_ID, 0);	
	mempool_asr=(UINT8*)malloc(10*1024);
	ASRRECEIVE_ID=vos_task_create(ASRTsk2,  0, "ASRreceiveTsk",   PRI_ASR,	STKSIZE_ASR);
	vos_task_resume(ASRRECEIVE_ID);
	CHKPNT;
	return E_OK;
}


ER ASRreceiveTsk_Close(void)
{

	FLGPTN  FlgPtn;

	if (!g_bASRreceiveTskOpened) {
		return E_SYS;
	}

	g_bASRreceiveTskClosing = TRUE;
	vos_flag_set(FLG_ID_ASR, FLGASR_IDLE);//add to close tsk
	CHKPNT;
	vos_flag_wait(&FlgPtn, FLG_ID_ASR, FLGASR_IDLE, TWF_ORW);
	CHKPNT;
	vos_task_destroy(ASRRECEIVE_ID);
	ASR_UnInstallID();
	g_bASRreceiveTskOpened = FALSE;

	return E_OK;
}


INT32 ASR_Init(void)
{

	if (is_asr_opened == 1) {
		DBG_ERR("ASR is already opened!\n");
		return -1;
	}
	ASRreceiveTsk_Open();
	is_asr_opened = 1;

	return 0;
}

INT32 ASR_UnInit(void)
{
	if (txzHandle) {
		//txzEngineDesrtoy((void *)&txzHandle);
		// txzHandle = NULL;
	}

	if (is_asr_opened == 0) {
		DBG_ERR("ASR is already closed!\n");
		return -1;
	}

	//ter_tsk(ASR_TSK_ID2);
	ASRreceiveTsk_Close();
	is_asr_opened = 0;

	return 0;
}


#endif

ASR.h

#ifndef _ASR_H
#define _ASR_H
#include "PrjCfg.h"

#define _ASR_ENABLE_ 1
#include "./txz_engine.h"

#if defined(_ASR_ENABLE_)
//#include "NvtIpcAPI.h"
#include <kflow_common/isf_flow_def.h>
#include <kflow_common/isf_flow_core.h>

#define PS_ASR_PARAM            "ASR"
#define ASR_VERIFICATION        0x415352 //"ASR"
typedef struct {
	UINT32  uiVerifyCode;
    char    MacAddr[6];
	CHAR    App_onlysum[512];
} ASRCALI_INFO;
typedef struct {
	unsigned long count;
	unsigned long addr;
	unsigned long size;
} ASR_DATA;

typedef struct {
	unsigned long count;
	unsigned long result;
} ASR_RESULT;


typedef enum {
	USERPROC_TRIG_PROC_NONE = 0,
	USERPROC_TRIG_PROC_EN   = 1,
	ENUM_DUMMY4WORD(USERPROC_TRIG_PROC_VAL)
} USERPROC_TRIG_PROC_VAL;

extern void ASR_InstallID(void);
extern INT32 ASR_Init(void);
extern INT32 ASR_UnInit(void);
extern USERPROC_TRIG_PROC_VAL ASR_UserProc_PushCB(ISF_PORT *pPort, ISF_DATA *pData);
extern ER ASRreceiveTsk_Open(void);
extern ER ASRreceiveTsk_Close(void);
int txzEngineSetAppid(const char *appid);
int txzEngineSetCustomerId(const char *customerId);

#endif
#endif // #ifndef _ASR_H

txz_engine.h

#ifndef __TXZ_SINGLE_ENGINE_UNBLOCK_H__
#define __TXZ_SINGLE_ENGINE_UNBLOCK_H__

#include <stdint.h>
#include <stddef.h>


#ifdef  __cplusplus
extern "C"
{
#endif

/** 初始化 接口
 * @param:
 *  channel[in]:渠道号,公司简称
 *  token[in]:同行者提供的token
 *  dir_activate[in]:保存激活数据的位置  一般为sd卡的目录
 *  dir_license[in]:激活成功后 license保存路径（可以通过txzEngineSetStorageFunc来保存， 当调用txzEngineSetStorageFunc之后， 该参数无效）
 *  handler[out]:初始化成功的句柄
 * @return 0 为成功，-1 为获取uuid失败(返回-1 需要继续调用Init)  -2 为激活校验失败(返回-2 进入激活流程)
 */
int txzEngineInit(
    void *channel,
    const char *token,
    const char *dir_activate,
    const char *dir_license,
    void **handler);

/** 生成 txz_push_uuid.txt 文件
 *@return  0 表示成功
 */
int txzEngineWriteFile(void);

/** 读取 txz_pop_uuid.txt  文件
 *@return  0 表示成功
 */
int txzEngineReadFile(void);

/** 保存 激活成功后 license数据
 *@return  0 表示成功
 */
int txzEngineWriteOTP(void);

/** 释放 销毁引擎
 * @param
 *  handler[in]:句柄
 */
void txzEngineDestroy(void **handler);

/**
 * 重置 识别句柄
 * @param
 *  handler[in]:句柄
 * @return 0 表示成功
 */
int txzEngineReset(void *handler);

/**
 * 塞入音频数据
 * @param
 *  handler[in]:句柄
 *  audio[in]:音频数据
 *  samples[in]:音频长度,单位是帧（2字节）
 *  keyIndex[out]:识别index
 *  confidence[out]:识别置信度
 * @return 0 代表识别成功
 */
int32_t txzEngineProcess(void *handler, const int16_t *audio, uint16_t samples, uint16_t *keyIndex, float *confidence);

/**
 * 获取识别结果
 * @param
 *  cmdId[in]:识别index
 *  keyword[out]:识别到的关键词
 * @return 0 表示成功
 */
int32_t txzEngineGetName(uint16_t cmdId, const char **keyword);

/** 保存/读取license数据
 * @param
 *  buf[in]:保存/读取license数据
 *  len[in]:保存/读取license数据大小
 * @return 非零为保存/读取license数据的大小， 小于零为错误
 * */
typedef int32_t (*TXZ_LOAD_FUN)(void *buf, int bufLen);
typedef int32_t (*TXZ_SAVE_FUN)(const void *buf, int len);

/**
 * 设置存储回调接口，供同行者使用
 * @param
 *	FuncLoad[in]：读接口
 *  FuncSave[in]：写接口
 */
void txzEngineSetStorageFunc(TXZ_LOAD_FUN FuncLoad, TXZ_SAVE_FUN FuncSave);

/**
 * @brief 写push函数
 *
 * @param data push数据
 * @param len  push长度
 *
 * @return 返回大于等于0为成功
 */
typedef int32_t (*FUNC_SAVE_PUSH)(
        void *data,
        size_t len);

/**
 * @brief 读pop函数
 *
 * @param data 写回pop数据到data
 * @param len  写回pop长度到len
 *
 * @return 返回0 为成功
 */
typedef int32_t (*FUNC_LOAD_POP)(
        void *data,
        size_t* len);

/**
 * @brief 设置push,pop储存回调，同行者使用
 *
 * @param funcSavePush push函数指针
 * @param funcLoadPop pop函数指针
 */
void txzEngineSetPushAndPopFunc(
    FUNC_SAVE_PUSH funcSavePush,
    FUNC_LOAD_POP funcLoadPop);


/**
 * @brief 调节灵敏度
 *
 * @param handler
 * @param index 词条序号
 * @param value 灵敏度 0~1.0 越小越灵敏
 * @return int
 **/
int txzEngineSetConfig(void *handler,int index,float value);

enum E_OSAL_LOG
{
    OSAL_LOG_NONE = 0,
    OSAL_LOG_DEBUG = 3,
    OSAL_LOG_INFO = 4,      // 建议为OSAL_LOG_INFO
    OSAL_LOG_WARN = 5,
    OSAL_LOG_ERROR = 6,
    OSAL_LOG_FATAL = 7,
    OSAL_LOG_MAX
};
/**
 * 设置日志等级
 * @param
 *  level:最低日志等级
 */
void txzSetLogLevel(int level);

typedef size_t (*TXZ_UART_SEND_DATA_FUNC)(void* context,void* data,size_t len);


typedef size_t (*TXZ_UART_RECV_DATA_FUNC)(void* context,void* data,size_t len);

/**
 * @brief 串口回调获取数据
 * context[in]:同于回调的上下文
 * sendFunc[in]:发送数据回调
 * recvFunc[in]:接收数据回调
 */
int txzUartReqAction (
/*		const char* uuid,
		size_t nUuidLen,
 		const char* data,
		size_t nDataLen,
		void* licenseData,
		size_t licenseDataMax, */
		void* context,
		TXZ_UART_SEND_DATA_FUNC sendFunc,
		TXZ_UART_RECV_DATA_FUNC recvFunc);

int txzSetUuidFunc(const char *uuid);

/**
 * @brief 设置appid，仅在网络激活版本下有用
 *
 * @param appid
 */
int txzEngineSetAppid(const char *appid);

/**
 * @brief 设置用户id
 *
 * @param customerId 用户id，仅在网络激活版本下有用
 * @return int 0成功
 */
int txzEngineSetCustomerId(const char *customerId);

/**
 * @brief 网络获取pop数据
 *
 * @return 0 表示成功
 */
int64_t txzEngineNetwork(void);

/**
 * @brief 设置push储存回调，同行者使用
 *
 * @param push函数指针
 */
void txzEngineSetPushFunc(
        FUNC_SAVE_PUSH funcSavePush);

/**
 * @brief 设置pop储存回调，同行者使用
 *
 * @param pop函数指针
 */
void txzEngineSetPopFunc(
        FUNC_LOAD_POP funcLoadPop);

#ifdef  __cplusplus
}
#endif

#endif /*__TXZ_SINGLE_ENGINE_UNBLOCK_H__*/