saberbud/ros_senior
1
0
Fork 0
mirror of https://github.com/Jieshoudaxue/ros_senior.git synced 2026-08-29 08:34:43 +08:00
Code Issues Packages Projects Releases Wiki Activity

[feat] add ifly spark

Browse Source
This commit is contained in:
jieshoudaxue
2023-09-21 19:53:22 +08:00
parent a4b9bae356
commit aa0daa890e
18 changed files with 1863 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ifly_spark/AIKit-Spark_Linux_v2.4.md
+423
View File
@@ -0,0 +1,423 @@
# AIKit-Spark Linux 接入文档
# 1. 功能特性描述
- 高效接入：SDK统一封装鉴权模块，接口简单最快三步完成SDK集成接入
- 稳定可靠： 统一连接池保障连接时效性，httpDNS保障请求入口高可用性
- 配套完善：支持多路并发用户回调上下文绑定，交互历史管理及排障日志回传收集
- 多平台兼容：覆盖Windows，Linux，Android，iOS以及其他交叉编译平台
# 2. SDK集成指南
## 2.1 SDK包目录结构说明
```c++
── SDK // SDK 头文件及动态库
│ ├── include // SDK所需头文件列表
│ │ ├── aikit_biz_api.h
│ │ ├── aikit_biz_builder.h
│ │ ├── aikit_biz_obsolete_builder.h
│ │ ├── aikit_biz_type.h
│ │ ├── aikit_common.h
│ │ ├── aikit_spark_api.h // Spark核心头文件
│ │ └── aikit_type.h
│ └── libs // SDK动态库目录
│ └── x64
│ └── libaikit.so
── demo // demo目录
│ ├── build.sh // demo编译脚本
│ ├── run.sh // demo运行脚本
│ ├── README.md // demo运行说明
│ ├── sparkDemo.cpp // demo源码
│ └── sparkDemo.h
── docs // SDK相关文档
```
## 2.2 demo运行步骤
1. 进入sdk包内,填写sparkDemo.cpp中appID、apiKey、apiSecret字段，demo目录运行build.sh 完成demo编译，生成sparkDemo可执行文件
2. 运行run.sh， 即可进行demo交互体验
3. demo编译环境建议如下：
| 编译环境信息 | 版本 |
| -------------- | ------------------- |
| **编译系统** | Ubuntu 18.04 x86_64 |
| **编译器版本** | gcc 7.5.0 |
| **链接器版本** | ld 2.30 |
## 2.3 项目集成步骤
1. 导入SDK目录内include头文件和libs下对应libaikit.so动态库
2. 集成SDK相关接口，接口调用流程及详细说明如下：
## 3. 详细API介绍
**Demo说明**（C++语言）：
```c++
static void onChatToken(AIChat_Handle* handle, const int& completionTokens, const int& promptTokens, const int& totalTokens) {
cout<<" promptTokens:"<<promptTokens<<" totalTokens:"<<totalTokens<<endl;
}
static void onChatOutput(AIChat_Handle* handle, const char* role, const char* content, const int& index) {
cout<<"role: "<<role<<" :content: "<<content<<endl;
}
static void onChatError(AIChat_Handle* handle,const int& err, const char* errDesc) {
cout<<"chatOnError: err:"<<err<<" ,desc:"<<errDesc<<endl;
}
int main() {
// SDK全局初始化参数配置
AIKIT_InitParam initParam{};
initParam.appID = "yourAppid";
initParam.apiKey = "yourKey";
initParam.apiSecret = "yourSecret";
// SDK全局初始化
int ret = AIKIT_Init(&initParam);
if(ret != 0) {
printf("AIKIT_Init failed:%d\n",ret);
return 0;
}
// 异步回调函数注册
AIKIT_ChatCallback({ onChatOutput, onChatToken, onChatError });
// 配置请求参数
ChatParam* params = ChatParam::builder();
params->uid("xxxid")
->domain("generalv2")
->maxToken(2048)
->url("ws://spark-api.xf-yun.com/v2.1/chat");
// 设置输入文本
string inputText="你好";
// 发起交互请求
ret = AIKIT_AsyncChat(params, inputText.c_str() , nullptr);
if(ret != 0){
printf("AIKIT_AsyncChat failed:%d\n",ret);
return ret;
}
// 等待异步回调
// ........
// 应用退出，逆初始化SDK
AIKIT_UnInit();
return 0;
}
```
Demo中常见设置参照下方接口文档进行开发。
### 3.1 SDK初始化接口
```c++
AIKITAPI int32_t AIKIT_Init(AIKIT_InitParam* param);
```
**说明**：返回 0表示成功，其他表示错误。
该函数用以初始化整个SDK，初始化相关配置参数如下：
#### 3.1.1 SDK初始化参数配置
```c++
typedef struct {
const char* appID; // 应用id
const char* apiKey; // 应用key
const char* apiSecret; // 应用secret
} AIKIT_InitParam;
```
**说明**：这个接口用于设置SDK初始化相关的参数，相关参数配置参考下表：
| 字段 | 含义 | 类型 | 说明 | 是否必传 |
| :-------: | :--------------------------------------- | :----- | -------------- | -------- |
| appID | 应用的app_id，需要在飞云交互平台申请 | string | "maxLength":16 | 是 |
| apiKey | 应用的app_key，需要在飞云交互平台申请 | string | | 是 |
| apiSecret | 应用的app_secret，需要在飞云交互平台申请 | string | | 是 |
#### 3.1.2 回调函数注册
```c++
AIKITAPI int32_t AIKIT_ChatCallback(const AIKIT_ChatCBS& cbs);
```
**说明**：注册回调函数用于接收处理异步结果。其中，AIKIT_ChatCBS是一个包含回调函数的结构体，定义如下：
```c++
typedef struct {
onChatOutput outputCB; // 输出回调
onChatToken tokenCB; // token计算信息回调
onChatError errorCB; // 错误回调
} AIKIT_ChatCBS;
```
其中三个回调函数定义如下：
#### 1. onChatOutput，用于异步请求回调结果输出
```c++
typedef void (*onChatOutput)(AIChat_Handle* handle, const char* role, const char* content, const int& index);
```
参数：
| 字段 | 含义 | 类型 |
| ------- | ---------------------------------------------- | -------------- |
| handle | 用户句柄 | AIChat_Handle* |
| role | user：表示用户的提问， assistant：表示AI的回复 | const char* |
| content | 文本内容，该角色的对话内容 | const char* |
| index | 结果序号，在多候选中使用 | int |
#### 2. onChatToken，用于统计Token相关的数据
```c++
typedef void (*onChatToken)(AIChat_Handle* handle, const int& completionTokens, const int& promptTokens, const int& totalTokens);
```
参数：
| 字段 | 含义 | 类型 |
| ---------------- | ---------------------- | -------------- |
| handle | 用户句柄 | AIChat_Handle* |
| completionTokens | 历史总回答tokens大小 | int |
| promptTokens | 历史问题总tokens大小 | int |
| totalTokens | 问题和回答的tokens大小 | int |
#### 3. onChatError，用于返回错误信息
```c++
typedef void (*onChatError)(AIChat_Handle* handle, const int& err, const char* errDesc);
```
详细错误码描述见文档最后错误码列表。
参数：
| 字段 | 含义 | 类型 |
| ------- | -------- | -------------- |
| handle | 用户句柄 | AIChat_Handle* |
| err | 错误码 | int |
| errDesc | 错误信息 | const char* |
#### 4. 用户句柄handle说明
**说明**：handle是一个结构体，定义如下：
```c++
typedef struct AICHAT_HANDLE {
void* usrContext; // 用户上下文指针
} AIChat_Handle;
```
参数如下：
| 字段 | 含义 | 类型 |
| ---------- | -------------- | ----- |
| usrContext | 用户上下文指针 | void* |
### 3.2 交互请求接口<异步>
```c++
AIKITAPI int32_t AIKIT_AsyncChat(const ChatParam* params, const char* inputText, void* usrContext);
```
**说明**：这个接口用于用户异步发送请求，ret为结果错误码，0=成功，错误码见最后错误码列表。相关参数配置参考下表：
| 字段 | 含义 | 是否必填 | 备注 |
| ------------- | -------- | ---- | ---- |
| params | 请求参数配置信息 | 是 | 见 3.2.1请求参数配置 |
| inputText | 请求文本内容 | 是 | 具体支持文本格式，见3.2.2请求文本内容格式 |
| usrContext | 用户上下文指针 | 否 | 此指针会在回调函数中带出，用于应用进行对应上下文操作 |
#### 3.2.1 请求参数配置
```c++
ChatParam* ChatParam::builder();
```
**说明**：这个接口用于配置请求参数，相关参数配置参考下表：
| 字段 | 含义 | 类型 | 限制 | 是否必传 |
| :---------- | -------------------------------------- | ------ | ------------------------------------------------------------ | -------- |
| domain | 需要使用的领域，当前仅支持通用大模型。 | char* | domian值与星火服务版本对应。<br/>默认请求星火v1.x 版本，domian默认值为 "general"<br/>星火v2.0 版本(url: ws://spark-api.xf-yun.com/v2.1/chat)，domian 值为"generalv2" | 是 |
| uid | 授权的用户id，用于关联用户交互的上下文 | char* | "maxLength":32 | 否 |
| maxToken | 回答的tokens的最大长度 | int | 取值范围1-2048，默认2048 | 否 |
| temperature | 配置核采样阈值，改变结果的随机程度 | float | 最小是0, 最大是1，默认0.5;<br />数字越大，随机性越小，改变此值会影响效果。 | 否 |
| auditing | 内容审核的场景策略 | char* | strict表示严格审核策略；moderate表示中等审核策略；loose表示宽松审核策略；default表示默认的审核程度；（调整策略需线下联系产品经理授权） | 否 |
| topK | 配置从k个候选中随机选择⼀个（⾮等概率) | int | 取值范围1-6，默认值4 | 否 |
| url | 星火服务器地址 | string | 默认为 v1.x版本。<br>星火V2.0 版本服务地址： ws://spark-api.xf-yun.com/v2.1/chat 。domain值对应为 "generalv2" | 否 |
请求参数配置示例：
```c++
ChatParam* params = ChatParam::builder();
params->uid("xxxid")
->domain("generalv2")
->maxToken(1024)
->url("ws://spark-api.xf-yun.com/v2.1/chat");
```
#### 3.2.2 请求文本内容格式
**说明**：不同对话交互场景，输入文本格式不同，具体不同如下：
#### 1. 单轮交互
输入文本是纯字符串，代码示例：
```c++
ChatParam* params = ChatParam::builder();
params->uid("xxxid")
->domain("generalv2")
->maxToken(2048)
->url("ws://spark-api.xf-yun.com/v2.1/chat");
// 设置输入文本
string inputText="你好";
// 发起交互请求
ret = AIKIT_AsyncChat(params, inputText.c_str() , nullptr);
```
#### 2. 多轮持续交互，包含交互上下文
##### 1、用户自行管理交互上下文，输入文本是json数组格式包含完整交互历史，具体SDK调用流程如下：
1.1、配置请求相关参数
```c++
ChatParam* params = ChatParam::builder();
params->uid("xxxid")
->domain("generalv2")
->maxToken(2048)
->url("ws://spark-api.xf-yun.com/v2.1/chat");
```
1.2、第一轮交互：
```c++
// 设置输入文本
string inputText="你好";
// 发起交互请求
ret = AIKIT_AsyncChat(params, inputText.c_str() , nullptr);
```
或
```c++
// 设置输入文本
string inputText = R"(
[
{"role": "user", "content": "你好"}, // ⽤户第⼀个问题 role是user,表示是⽤户的提问
]
)";
// 发起交互请求
ret = AIKIT_AsyncChat(params, inputText.c_str() , nullptr);
```
1.3、第二轮交互
```c++
// 每次输入的请求文本和对应请求的响应文本都需要按照交互顺序完整的记录下来，最终形成的文本数据格式如下：
string inputText = R"(
[
{"role": "user", "content": "你好"}, // ⽤户第⼀个问题 role是user,表示是⽤户的提问
{"role": "assistant", "content": "你好！"}, // AI的第⼀个回复 role是assistant，表示是AI的回复
{"role": "user", "content": "你是谁？"}, // ⽤户第⼆个问题
]
)";
ret = AIKIT_AsyncChat(params, inputText.c_str() , nullptr);
```
### 3.3 逆初始化接口
**说明**：应用退出时可调用此函数回收SDK占用相关资源。
```c++
AIKITAPI int32_t AIKIT_UnInit() ;
```
## 内容审核说明
当返回10013或者10014错误码时，代码内容审核判断当前问题或回复的信息涉及敏感信息。返回错误的同时，message中携带当前的敏感提示语，如果：
* 用户的请求文本敏感，则给出对应提示
* 生成的内容敏感，需要删除已经显示的内容信息，替换成对应提示
如果需要调整内容审核的严格程度、敏感词等信息，请联系我们。
## 6、错误码列表
服务错误码：
| 错误码 | 错误信息 |
| ------ | ------------------------------------------------------------ |
| 0 | 成功 |
| 10000 | 升级为ws出现错误 |
| 10001 | 通过ws读取用户的消息 出错 |
| 10002 | 通过ws向用户发送消息 出错 |
| 10003 | 用户的消息格式有错误 |
| 10004 | 用户数据的schema错误 |
| 10005 | 用户参数值有错误 |
| 10006 | 用户并发错误：当前用户已连接，同一用户不能多处同时连接。 |
| 10007 | 用户流量受限：服务正在处理用户当前的问题，需等待处理完成后再发送新的请求。<br />（必须要等大模型完全回复之后，才能发送下一个问题） |
| 10008 | 服务容量不足，联系服务商 |
| 10009 | 和引擎建立连接失败 |
| 10010 | 接收引擎数据的错误 |
| 10011 | 向引擎发送数据的错误 |
| 10012 | 引擎内部错误 |
| 10013 | 用户问题涉及敏感信息，审核不通过，拒绝处理此次请求。 |
| 10014 | 回复结果涉及到敏感信息，审核不通过，后续结果无法展示给用户。 |
| 10015 | appid在黑名单中 |
| 10016 | appid授权类的错误。比如：未开通此功能，未开通对应版本，token不足，并发超过授权 等等。 （联系我们开通授权或提高限制） |
| 10017 | 清除历史失败 |
| 10018 | 用户在5分钟内持续发送ping消息，但并没有实际请求数据，会返回该错误码并断开ws连接。短链接使用无需关注 |
| 10019 | 该错误码表示返回结果疑似敏感，建议拒绝用户继续交互 |
| 10110 | 服务忙，请稍后再试。 |
| 10163 | 请求引擎的参数异常 引擎的schema 检查不通过 |
| 10222 | 引擎网络异常 |
| 10223 | LB找不到引擎节点 |
| 10907 | token数量超过上限。对话历史+问题的字数太多，需要精简输入。 |
| 11200 | 授权错误：该appId没有相关功能的授权 或者 业务量超过限制（联系我们开通授权或提高限制） |
| 11201 | 授权错误：日流控超限。超过当日最大访问量的限制。（联系我们提高限制） |
| 11202 | 授权错误：秒级流控超限。秒级并发超过授权路数限制。（联系我们提高限制） |
| 11203 | 授权错误：并发流控超限。并发路数超过授权路数限制。（联系我们提高限制） |
SDK错误码：
| 错误码 | 错误信息 |
| ------ | ------------------------------- |
| 18300 | sdk不可用 |
| 18301 | sdk没有初始化 |
| 18302 | sdk初始化失败 |
| 18303 | sdk已经初始化 |
| 18304 | sdk不合法参数 |
| 18305 | sdk会话handle为空 |
| 18306 | sdk会话未找到 |
| 18307 | sdk会话重复终止 |
| 18308 | 超时错误 |
| 18309 | sdk正在初始化中 |
| 18310 | sdk会话重复开启 |
| 18400 | 工作目录无写权限 |
| 18402 | 文件打开失败 |
| 18403 | 内存分配失败 |
| 18500 | 未找到该参数key |
| 18501 | 参数范围溢出，不满足约束条件 |
| 18502 | sdk初始化参数为空 |
| 18503 | sdk初始化参数中appid为空 |
| 18504 | sdk初始化参数中apiKey为空 |
| 18505 | sdk初始化参数中apiSecret为空 |
| 18507 | input参数为空 |
| 18509 | 必填参数缺失 |
| 18700 | 通用网络错误 |
| 18701 | 网路不通 |
| 18702 | 网关检查不过 |
| 18712 | http 404错误 |
| 18801 | 连接建立出错 |
| 18802 | 结果等待超时 |
| 18311 | sdk同一能力并发路数超出最大限制 |
ifly_spark/SDK/include/aikit_biz_api.h
+337
View File
@@ -0,0 +1,337 @@
//
// Created by xkzhang9 on 2020/10/16.
//
#ifndef AIKIT_BIZ_API_H
#define AIKIT_BIZ_API_H
#include "aikit_biz_type.h"
#include "aikit_biz_builder.h"
namespace AIKIT {
/**
* SDK初始化函数用以初始化整个SDK
* 初始化相关配置参数通过AIKIT_Congigurator配置
* @return 结果错误码，0=成功
*/
AIKITAPI int32_t AIKIT_Init();
/**[deprecated]
* SDK初始化函数用以初始化整个SDK
* @param param SDK配置参数
* @return 结果错误码，0=成功
*/
AIKITAPI int32_t AIKIT_Init(AIKIT_InitParam* param);
/**
* SDK逆初始化函数用以释放SDK所占资源
* @return 结果错误码，0=成功
*/
AIKITAPI int32_t AIKIT_UnInit();
/**
* 注册回调函数用以返回执行结果
* @param onOutput 能力实际输出回调
* @param onEvent 能力执行事件回调
* @param onError 能力执行错误回调
* @return 结果错误码，0=成功
*/
AIKITAPI int32_t AIKIT_RegisterCallback(AIKIT_Callbacks cbs);
/**
* 注册回调函数用以返回执行结果
* @param ability [in] 能力唯一标识
* @param onOutput 能力实际输出回调
* @param onEvent 能力执行事件回调
* @param onError 能力执行错误回调
* @return 结果错误码，0=成功
*/
AIKITAPI int32_t AIKIT_RegisterAbilityCallback(const char* ability, AIKIT_Callbacks cbs);
/**
* 初始化能力引擎
* @param ability [in] 能力唯一标识
* @param param [in] 初始化参数
* @return 错误码 0=成功，其他表示失败
*/
AIKITAPI int32_t AIKIT_EngineInit(const char* ability, AIKIT_BizParam* param);
/**
* 能力引擎逆初始化,释放能力及对应引擎占用所有资源
* @param ability [in] 能力唯一标识
* @return 错误码 0=成功，其他表示失败
*/
AIKITAPI int32_t AIKIT_EngineUnInit(const char* ability);
/**
* 个性化数据预处理
* @param ability [in] 能力唯一标识
* @param srcData [in] 原始数据输入
* @param data [out] 结果数据输出
* @return 错误码 0=成功，其他表示失败
*/
AIKITAPI int32_t AIKIT_PreProcess(const char* ability, AIKIT_CustomData* srcData, AIKIT_CustomData** data);
/**
* 离线个性化数据加载
* @param ability 能力唯一标识
* @param data 个性化数据
* @return 错误码 0=成功，其他表示失败
*/
AIKITAPI int32_t AIKIT_LoadData(const char* ability, AIKIT_CustomData* data);
/**
* 在线个性化数据上传
* @param ability 能力唯一标识
* @param params 个性化参数
* @param data 个性化数据
* @return 错误码 0=成功，其他表示失败
*/
AIKITAPI int32_t AIKIT_LoadDataAsync(const char* ability, AIKIT_BizParam* params, AIKIT_InputData* data, void* usrContext, AIKIT_HANDLE** outHandle);
/**
* 个性化数据查询
* @param ability 能力唯一标识
* @param data 个性化数据
* @return 错误码 0=成功，其他表示失败
*/
AIKITAPI int32_t AIKIT_QueryData(const char* ability, AIKIT_CustomData* data);
/**
* @brief 可见即可说（AIUI定制接口）
* @param ability 能力唯一标识
* @param params 个性化参数
* @param data 个性化数据
* @return 错误码 0=成功，其他表示失败
*/
AIKITAPI int32_t AIKIT_LoadDataSpeakableAsync(const char* ability, AIKIT_BizParam* params, AIKIT_InputData* data, void* usrContext, AIKIT_HANDLE** outHandle);
/**
* 个性化数据卸载
* @param ability 能力唯一标识
* @param key 个性化数据唯一标识
* @param index 个性化数据索引
* @return 错误码 0=成功，其他表示失败
*/
AIKITAPI int32_t AIKIT_UnLoadData(const char* ability, const char* key, int index);
/**
* 指定要使用的个性化数据集合，未调用，则默认使用所有AIKIT_LoadData加载的数据
* 可调用多次以使用不同key集合
* @param abilityId 能力唯一标识
* @param key 个性化数据唯一标识数组
* @param index 个性化数据索引数组
* @param count 个性化数据索引数组成员个数
* @return 错误码 0=成功，其他表示失败
*/
AIKITAPI int32_t AIKIT_SpecifyDataSet(const char* ability, const char* key, int index[], int count);
/**
* 启动one-shot模式能力同步模式调用
* @param ability 能力唯一标识
* @param param 能力参数
* @param inputData 能力数据输入
* @param outputData 能力数据输出
* @return 错误码 0=成功，其他表示失败
*/
AIKITAPI int32_t AIKIT_OneShot(const char* ability, AIKIT_BizParam* params, AIKIT_InputData* inputData, AIKIT_OutputData** outputData);
/**
* 启动one-shot模式能力异步模式调用
* @param ability 能力唯一标识d
* @param param 能力参数
* @param data 能力数据输入
* @param usrContext 上下文指针
* @param outHandle 生成的引擎会话句柄
* @return 错误码 0=成功，其他表示失败
*/
AIKITAPI int32_t AIKIT_OneShotAsync(const char* ability, AIKIT_BizParam* params, AIKIT_InputData* data, void* usrContext, AIKIT_HANDLE** outHandle);
/**
* 启动会话模式能力调用实例，若引擎未初始化，则内部首先完成引擎初始化
* @param ability 能力唯一标识
* @param len ability长度
* @param param 初始化参数
* @param usrContext上下文指针
* @param outHandle 生成的引擎会话句柄
* @return 错误码 0=成功，其他表示失败
*/
AIKITAPI int32_t AIKIT_Start(const char* ability, AIKIT_BizParam* param, void* usrContext, AIKIT_HANDLE** outHandle);
/**
* 会话模式输入数据
* @param handle 会话实例句柄
* @param input 输入数据
* @return 结果错误码，0=成功
*/
AIKITAPI int32_t AIKIT_Write(AIKIT_HANDLE* handle, AIKIT_InputData* input);
/**
* 会话模式同步读取数据
* @param handle 会话实例句柄
* @param output 输入数据
* @return 结果错误码，0=成功
* @note output内存由SDK自行维护,无需主动释放
*/
AIKITAPI int32_t AIKIT_Read(AIKIT_HANDLE* handle, AIKIT_OutputData** output);
/**
* 结束会话实例
* @param handle 会话实例句柄
* @return 结果错误码，0=成功
*/
AIKITAPI int32_t AIKIT_End(AIKIT_HANDLE* handle);
/**
* 释放能力占用资源,注意不会释放引擎实例
* 若要释放能力及能力所有资源，需调用AIKIT_EngineUnInit()
* @param ability 能力唯一标识
* @return 错误码 0=成功，其他表示失败
*/
AIKITAPI int32_t AIKIT_FreeAbility(const char* ability);
/**
* 设置日志级别
* @param level 日志级别
* @return 错误码 0=成功，其他表示失败
*/
AIKITAPI int32_t AIKIT_SetLogLevel(int32_t level);
/**
* 设置日志输出模式
* @param mode 日志输出模式
* @return 错误码 0=成功，其他表示失败
*/
AIKITAPI int32_t AIKIT_SetLogMode(int32_t mode);
/**
* 输出模式为文件时，设置日志文件名称
* @param path 日志名称
* @return 错误码 0=成功，其他表示失败
*/
AIKITAPI int32_t AIKIT_SetLogPath(const char* path);
/**
* 获取设备ID
* @param deviceID 设备指纹输出字符串
* @return 结果错误码，0=成功
*/
AIKITAPI int32_t AIKIT_GetDeviceID(const char** deviceID);
/**
* 设置授权更新间隔，单位为秒，默认为300秒
* AIKIT_Init前设置
* @param interval 间隔秒数
* @return 结果错误码，0=成功
*/
AIKITAPI int32_t AIKIT_SetAuthCheckInterval(uint32_t interval);
/**
* 强制更新授权
* 注意：注意需在AIKIT_Init调用成功后，方可调用
* @param timeout 超时时间 单位为秒
* @return 结果错误码，0=成功
*/
AIKITAPI int32_t AIKIT_UpdateAuth(uint32_t timeout);
/**
* 获取能力授权剩余秒数
* 能力输入参数为空时，默认返回最接近授权过期的能力剩余秒数
* 注意：注意需在AIKIT_Init调用成功后，方可调用
* @param leftTime 返回的能力授权剩余秒数，0 表示永久授权， 负值表示已过期的秒数
* @param ability 能力id标识
* @return 返回调用结果，0 = 成功， 其他值表示调用失败
*/
AIKITAPI int AIKIT_GetAuthLeftTime(int64_t& leftTime,int64_t& authEndTime, const char* ability = nullptr);
/**
* 获取SDK版本号
* @return SDK版本号
*/
AIKITAPI const char* AIKIT_GetVersion();
/**
* @brief 获取能力对应的引擎版本
*
* @param ability 能力唯一标识
* @return const* 引擎版本号
*/
AIKITAPI const char* AIKIT_GetEngineVersion(const char* ability);
/**
* 本地日志是否开启
* @param open
* @return
*/
AIKITAPI int32_t AIKIT_SetILogOpen(bool open);
/**
* 本地日志最大存储个数（【1，300】）
* @param count
* @return
*/
AIKITAPI int32_t AIKIT_SetILogMaxCount(uint32_t count);
/**
* 设置单日志文件大小（(0，10M】）
* @param bytes
* @return
*/
AIKITAPI int32_t AIKIT_SetILogMaxSize(long long bytes);
/**
* 设置SDK相关配置
* @param key 参数名字
* @param value 参数值
* @return 结果错误码，0=成功
*/
AIKITAPI int32_t AIKIT_SetConfig(const char* key, const void* value);
/**
* 设置SDK内存模式
* @param ability 能力id
* @param mode 模式，取值参见 AIKIT_MEMORY_MODE
* @return AIKITAPI
*/
AIKITAPI int32_t AIKIT_SetMemoryMode(const char* ability,int32_t mode);
/**自2.1.6版本开始已废弃接口，当前仅保留空实现接口声明
* 自2.1.6版本开始AIKIT_OneShot响应数据由SDK内部自己维护，无需用户维护
* 同步接口响应数据缓存释放接口
* @param outputData 由同步接口AIKIT_OneShot获取的响应结果数据
*/
AIKITAPI int32_t AIKIT_Free(AIKIT_OutputData** outputData);
/**自2.1.6版本开始已废弃接口，由AIKIT_FreeAbility替代
* 释放能力占用资源
* @param ability 能力唯一标识
* @return 错误码 0=成功，其他表示失败
*/
AIKITAPI int32_t AIKIT_GC(const char* ability);
/**
* 设置日志级别，模式，以及保存路径,旧版日志接口，不推荐使用
* @param level 日志级别
* @param mode 日志输出模式
* @param level 输出模式为文件时的文件名称
* @return 错误码 0=成功，其他表示失败
*/
AIKITAPI int32_t AIKIT_SetLogInfo(int32_t level, int32_t mode, const char* path);
/**
* 获取能力授权剩余秒数
* 能力输入参数为空时，默认返回最接近授权过期的能力剩余秒数
* 注意：注意需在AEE_Init调用成功后，方可调用
* @param leftTime 返回的能力授权剩余秒数，0 表示永久授权， 负值表示已过期的秒数
* @param ability 能力id标识
* @return 返回调用结果，0 = 成功， 其他值表示调用失败
*/
AIKITAPI int AIKIT_GetAuthLeftTime(int64_t& leftTime, const char* ability = nullptr);
} // namespace AIKIT
#endif //AIKIT_BIZ_API_H
ifly_spark/SDK/include/aikit_biz_builder.h
+299
View File
@@ -0,0 +1,299 @@
#ifndef AIKIT_BIZ_BUILDER_H
#define AIKIT_BIZ_BUILDER_H
#include "aikit_biz_type.h"
#include "aikit_biz_obsolete_builder.h"
namespace AIKIT {
/**
* 参数构造类
*/
class AIKITAPI AIKIT_ParamBuilder {
public:
static AIKIT_ParamBuilder* create();
static void destroy(AIKIT_ParamBuilder* builder);
virtual ~AIKIT_ParamBuilder();
//当需要为能力会话设置header字段时，需调用此接口
//后续调用param设置的kv对，将全部追加到header字段
virtual AIKIT_ParamBuilder* header() = 0;
virtual AIKIT_ParamBuilder* header(const char* key, const char* data, uint32_t dataLen) = 0;
virtual AIKIT_ParamBuilder* header(const char* key, int value) = 0;
virtual AIKIT_ParamBuilder* header(const char* key, double value) = 0;
virtual AIKIT_ParamBuilder* header(const char* key, bool value) = 0;
//当需要设置能力会话功能参数时，需调用此接口
//后续调用param设置的kv对，将全部追加到能力功能参数字段
virtual AIKIT_ParamBuilder* service(const char* serviceID) = 0;
virtual AIKIT_ParamBuilder* service(const char* serviceID, AIKIT_ParamBuilder* value) = 0;
virtual AIKIT_ParamBuilder* param(const char* key, const char* data, uint32_t dataLen) = 0;
virtual AIKIT_ParamBuilder* param(const char* key, int value) = 0;
virtual AIKIT_ParamBuilder* param(const char* key, double value) = 0;
virtual AIKIT_ParamBuilder* param(const char* key, bool value) = 0;
//输出控制参数对设置
virtual AIKIT_ParamBuilder* param(const char* key, AIKIT_ParamBuilder* value) = 0;
virtual AIKIT_BizParam* build() = 0;
virtual void clear() = 0;
};
/**
* @brief 数据构造类基类
*
*/
class AIKITAPI AiData {
public:
template <class T, class O>
class AIKITAPI AiDataHolder {
public:
virtual T* status(int status) = 0;
virtual T* begin() = 0;
virtual T* cont() = 0;
virtual T* end() = 0;
virtual T* once() = 0;
virtual T* data(const char* value,int dataLen) = 0;
virtual T* path(const char* path) = 0;
virtual T* file(const FILE* file) = 0;
virtual O* valid() = 0;
};
virtual ~AiData() = 0;
};
/**
* 文本数据构造类
* encoding 文本编码格式设置 默认值:"utf8" 常见取值:"utf8" "gbk" "gb2312"
* compress 文本压缩格式设置 默认值:"raw" 常见取职:"raw" "gzip"
* format 文本内容格式设置 默认值:"plain" 常见取值:"plain" "json" "xml"
*/
class AIKITAPI AiText : public AiData {
public:
class AiTextHolder : public AiDataHolder<AiTextHolder,AiText> {
public:
virtual AiTextHolder* encoding(const char* encoding) = 0;
virtual AiTextHolder* compress(const char* compress) = 0;
virtual AiTextHolder* format(const char* format) = 0;
};
static AiTextHolder* get(const char* key);
virtual ~AiText() = 0;
public:
static constexpr char* const ENCODING_UTF8 = (char*)"utf8";
static constexpr char* const ENCODING_GBK = (char*)"gbk";
static constexpr char* const ENCODING_GB2312 = (char*)"gb2312";
static constexpr char* const ENCODING_DEF = ENCODING_UTF8;
static constexpr char* const COMPRESS_RAW = (char*)"raw";
static constexpr char* const COMPRESS_GZIP = (char*)"gzip";
static constexpr char* const COMPRESS_DEF = COMPRESS_RAW;
static constexpr char* const FORMAT_PLAIN = (char*)"plain";
static constexpr char* const FORMAT_JSON = (char*)"json";
static constexpr char* const FORMAT_XML = (char*)"xml";
static constexpr char* const FORMAT_DEF = FORMAT_PLAIN;
};
/**
* 音频数据构造类
* encoding 音频编码格式设置 默认值:"speex-wb" 常见取值:"lame" "speex" "speex-wb" "opus" "opus-wb" "mp3" "wav" "amr"
* sampleRate 音频采样率设置 默认值:16000 常见取值:16000 8000
* channels 音频声道数设置 默认值:1 常见取值:1 2
* bitDepth 音频数据位深设置 默认值:16 常见取值:[16,8]
*/
class AIKITAPI AiAudio : public AiData {
public :
class AiAudioHolder : public AiDataHolder<AiAudioHolder,AiAudio> {
public:
virtual AiAudioHolder* encoding(const char* encoding) = 0;
virtual AiAudioHolder* sampleRate(int sampleRate) = 0;
virtual AiAudioHolder* channels(int channels) = 0;
virtual AiAudioHolder* bitDepth(int bitDepth) = 0;
};
static AiAudioHolder* get(const char* key);
virtual ~AiAudio() = 0;
public:
static constexpr char* const ENCODING_PCM = (char*)"pcm";
static constexpr char* const ENCODING_RAW = (char*)"raw";
static constexpr char* const ENCODING_ICO = (char*)"ico";
static constexpr char* const ENCODING_SPEEX = (char*)"speex";
static constexpr char* const ENCODING_SPEEX_WB = (char*)"speex-wb";
static constexpr char* const ENCODING_LAME = (char*)"lame";
static constexpr char* const ENCODING_OPUS = (char*)"opus";
static constexpr char* const ENCODING_OPUS_WB = (char*)"opus-wb";
static constexpr char* const ENCODING_WAV = (char*)"wav";
static constexpr char* const ENCODING_AMR = (char*)"amr";
static constexpr char* const ENCODING_AMR_WB = (char*)"amr-wb";
static constexpr char* const ENCODING_MP3 = (char*)"mp3";
static constexpr char* const ENCODING_CDA = (char*)"cda";
static constexpr char* const ENCODING_WAVE = (char*)"wave";
static constexpr char* const ENCODING_AIFF = (char*)"aiff";
static constexpr char* const ENCODING_MPEG = (char*)"mpeg";
static constexpr char* const ENCODING_MID = (char*)"mid";
static constexpr char* const ENCODING_WMA = (char*)"wma";
static constexpr char* const ENCODING_RA = (char*)"ra";
static constexpr char* const ENCODING_RM = (char*)"rm";
static constexpr char* const ENCODING_RMX = (char*)"rmx";
static constexpr char* const ENCODING_VQF = (char*)"vqf";
static constexpr char* const ENCODING_OGG = (char*)"ogg";
static constexpr char* const ENCODING_DEF = ENCODING_SPEEX_WB;
static const int SAMPLE_RATE_8K = 8000;
static const int SAMPLE_RATE_16K = 16000;
static const int SAMPLE_RATE_DEF = SAMPLE_RATE_16K;
static const int CHANNELS_1 = 1;
static const int CHANNELS_2 = 2;
static const int CHANNELS_DEF = CHANNELS_1;
static const int BIT_DEPTH_8 = 8;
static const int BIT_DEPTH_16 = 16;
static const int BIT_DEPTH_DEF = BIT_DEPTH_16;
};
/**
* 图片数据构造类
* encoding 图片编码格式设置 默认值:"jpg" 常见取值:"raw" "rgb" "bgr" "yuv" "jpg" "jpeg" "png" "bmp"
* width 图片宽度设置 默认值:null 常见取值:根据具体图片文件各不相同
* height 图片高度设置 默认值:null 常见取值:根据具体图片文件各不相同
* dims 图片深度设置 默认值:null 常见取值:根据具体图片文件各不相同
*/
class AIKITAPI AiImage : public AiData {
public:
class AiImageHolder : public AiDataHolder<AiImageHolder,AiImage> {
public:
virtual AiImageHolder* encoding(const char* encoding) = 0;
virtual AiImageHolder* width(int width) = 0;
virtual AiImageHolder* height(int height) = 0;
virtual AiImageHolder* dims(int dims) = 0;
};
static AiImageHolder* get(const char* key);
virtual ~AiImage() = 0;
public:
static constexpr char* const ENCODING_RAW = (char*)"raw";
static constexpr char* const ENCODING_JPG = (char*)"jpg";
static constexpr char* const ENCODING_JPEG = (char*)"jpeg";
static constexpr char* const ENCODING_PNG = (char*)"png";
static constexpr char* const ENCODING_APNG = (char*)"apng";
static constexpr char* const ENCODING_BMP = (char*)"bmp";
static constexpr char* const ENCODING_WEBP = (char*)"webp";
static constexpr char* const ENCODING_TIFF = (char*)"tiff";
static constexpr char* const ENCODING_RGB565 = (char*)"rgb565";
static constexpr char* const ENCODING_RGB888 = (char*)"rgb888";
static constexpr char* const ENCODING_BGR565 = (char*)"bgr565";
static constexpr char* const ENCODING_BGR888 = (char*)"bgr888";
static constexpr char* const ENCODING_YUV12 = (char*)"yuv12";
static constexpr char* const ENCODING_YUV21 = (char*)"yuv21";
static constexpr char* const ENCODING_YUV420 = (char*)"yuv420";
static constexpr char* const ENCODING_YUV422 = (char*)"yuv422";
static constexpr char* const ENCODING_PSD = (char*)"psd";
static constexpr char* const ENCODING_PCD = (char*)"pcd";
static constexpr char* const ENCODING_DEF = ENCODING_JPG;
};
/**
* 视频数据构造类
* encoding 视频编码设置 默认值:"h264" 常见取值:"avi" "rmvb" "flv" "h26x" "mpeg"
* width 视频宽度设置 默认值:null 常见取值:根据具体视频文件各不相同
* height 视频高度设置 默认值:null 常见取值:根据具体视频文件各不相同
* frameRate 视频帧率设置 默认值:null 常见取值:根据具体视频文件各不相同
*/
class AIKITAPI AiVideo : public AiData {
public:
class AiVideoHolder : public AiDataHolder<AiVideoHolder,AiVideo> {
public:
virtual AiVideoHolder* encoding(const char* key) = 0;
virtual AiVideoHolder* width(int width) = 0;
virtual AiVideoHolder* height(int height) = 0;
virtual AiVideoHolder* frameRate(int frameRate) = 0;
};
static AiVideoHolder* get(const char* key);
virtual ~AiVideo() = 0;
public:
static constexpr char* const ENCODING_H264 = (char*)"h264";
static constexpr char* const ENCODING_H265 = (char*)"h265";
static constexpr char* const ENCODING_AVI = (char*)"avi";
static constexpr char* const ENCODING_NAVI = (char*)"navi";
static constexpr char* const ENCODING_MP4 = (char*)"mp4";
static constexpr char* const ENCODING_RM = (char*)"rm";
static constexpr char* const ENCODING_RMVB = (char*)"rmvb";
static constexpr char* const ENCODING_MKV = (char*)"mkv";
static constexpr char* const ENCODING_FLV = (char*)"flv";
static constexpr char* const ENCODING_F4V = (char*)"f4v";
static constexpr char* const ENCODING_MPG = (char*)"mpg";
static constexpr char* const ENCODING_MLV = (char*)"mlv";
static constexpr char* const ENCODING_MPE = (char*)"mpe";
static constexpr char* const ENCODING_MPEG = (char*)"mpeg";
static constexpr char* const ENCODING_DAT = (char*)"dat";
static constexpr char* const ENCODING_m2v = (char*)"m2v";
static constexpr char* const ENCODING_VOB = (char*)"vob";
static constexpr char* const ENCODING_ASF = (char*)"asf";
static constexpr char* const ENCODING_MOV = (char*)"mov";
static constexpr char* const ENCODING_WMV = (char*)"wmv";
static constexpr char* const ENCODING_3GP = (char*)"3gp";
static constexpr char* const ENCODING_DEF = ENCODING_H264;
};
/**
* 输入构造类
*/
class AIKITAPI AIKIT_DataBuilder : public AIKIT_DataBuilderObsolete {
public:
static AIKIT_DataBuilder* create();
static void destroy(AIKIT_DataBuilder* builder);
virtual ~AIKIT_DataBuilder();
virtual AIKIT_DataBuilder* payload(AiData* data) = 0;
virtual AIKIT_InputData* build() = 0;
virtual void clear() = 0;
};
/**
* 自定义数据构造器
*/
class AIKITAPI AIKIT_CustomBuilder {
public:
static AIKIT_CustomBuilder* create();
static void destroy(AIKIT_CustomBuilder* builder);
virtual ~AIKIT_CustomBuilder();
virtual AIKIT_CustomBuilder* text(const char* key, const char* data, uint32_t dataLen, int32_t index) = 0;
virtual AIKIT_CustomBuilder* textPath(const char* key, const char* path, int32_t index) = 0;
virtual AIKIT_CustomBuilder* textFile(const char* key, const FILE* file, int32_t index) = 0;
virtual AIKIT_CustomBuilder* audio(const char* key, const char* data, uint32_t dataLen, int32_t index) = 0;
virtual AIKIT_CustomBuilder* audioPath(const char* key, const char* path, int32_t index) = 0;
virtual AIKIT_CustomBuilder* audioFile(const char* key, const FILE* file, int32_t index) = 0;
virtual AIKIT_CustomBuilder* image(const char* key, const char* data, uint32_t dataLen, int32_t index) = 0;
virtual AIKIT_CustomBuilder* imagePath(const char* key, const char* path, int32_t index) = 0;
virtual AIKIT_CustomBuilder* imageFile(const char* key, const FILE* file, int32_t index) = 0;
virtual AIKIT_CustomBuilder* video(const char* key, const char* data, uint32_t dataLen, int32_t index) = 0;
virtual AIKIT_CustomBuilder* videoPath(const char* key, const char* path, int32_t index) = 0;
virtual AIKIT_CustomBuilder* videoFile(const char* key, const FILE* file, int32_t index) = 0;
virtual AIKIT_CustomData* build() = 0;
virtual void clear() = 0;
};
/**
* 参数和输入统一构造类
*/
class AIKITAPI AIKIT_Builder {
public:
static AIKIT_BizParam* build(AIKIT_ParamBuilder* param);
static AIKIT_InputData* build(AIKIT_DataBuilder* data);
static AIKIT_CustomData* build(AIKIT_CustomBuilder* custom);
};
} // namespace AIKIT
#endif
ifly_spark/SDK/include/aikit_biz_config.h
+158
View File
@@ -0,0 +1,158 @@
#ifndef AIKIT_BIZ_CONFIG_H
#define AIKIT_BIZ_CONFIG_H
#include <iostream>
#include "aikit_biz_type.h"
namespace AIKIT {
class ConfigBuilder;
class AppBuilder;
class AuthBuilder;
class LogBuilder;
class CodecBuilder;
class AIKITAPI AIKIT_Configurator {
public:
static ConfigBuilder& builder();
};
class AIKITAPI ConfigBuilder {
public:
/**
* @brief 用户app信息配置
*/
AppBuilder& app();
/**
* @brief 授权相关配置
*/
AuthBuilder& auth();
/**
* @brief 日志相关配置
*/
LogBuilder& log();
/**
* @brief 音视频编解码相关配置
*/
CodecBuilder& codec();
};
class AIKITAPI AppBuilder : public ConfigBuilder {
public:
/**
* @brief 配置应用id
*/
AppBuilder& appID(const char* appID);
/**
* @brief 配置应用key
*/
AppBuilder& apiKey(const char* apiKey);
/**
* @brief 配置应用secret
*/
AppBuilder& apiSecret(const char* apiSecret);
/**
* @brief 配置sdk工作目录，需可读可写权限
*/
AppBuilder& workDir(const char* workDir);
/**
* @brief 配置只读资源存放目录, 需可读权限
*/
AppBuilder& resDir(const char* resDir);
/**
* @brief 配置文件路径，包括文件名
*/
AppBuilder& cfgFile(const char* cfgFile);
};
class AIKITAPI AuthBuilder : public ConfigBuilder {
public:
/**
* @brief 配置授权方式 0=设备级授权，1=应用级授权
*/
AuthBuilder& authType(int authType);
/**
* @brief 配置离线激活方式的授权文件路径，为空时需联网进行首次在线激活
*/
AuthBuilder& licenseFile(const char* licenseFile);
/**
* @brief 配置授权渠道Id
*/
AuthBuilder& channelID(const char* channelID);
/**
* @brief 配置用户自定义设备标识
*/
AuthBuilder& UDID(const char* UDID);
/**
* @brief 配置授权离线能力，如需配置多个能力，可用";"分隔开, 如"xxx;xxx"
*/
AuthBuilder& ability(const char* ability);
/**
* @brief 配置单个在线能力id及对应请求地址，如需配置多个能力，可多次调用
* url格式参考：https://cn-huadong-1.xf-yun.com/v1/private/xxx:443
*/
AuthBuilder& abilityURL(const char* ability, const char* url);
};
/**
* @brief 配置SDK日志信息
*/
class AIKITAPI LogBuilder : public ConfigBuilder {
public:
/**
* @brief 配置日志等级
*/
LogBuilder& logLevel(int32_t level);
/**
* @brief 配置日志输出模式
*/
LogBuilder& logMode(int32_t mode);
/**
* @brief 配置日志文件保存文件
*/
LogBuilder& logPath(const char* path);
};
/**
* @brief 配置SDK音视频编解码方式
*/
class AIKITAPI CodecBuilder : public ConfigBuilder {
public:
/**
* @brief 配置全局音频编码选项
*/
CodecBuilder& audioEncoding(const char* encodingType);
/**
* @brief 配置能力级音频编码选项
*/
CodecBuilder& audioEncoding(const char* abilityID, const char* encodingType);
/**
* @brief 配置全局音频解码选项
*/
CodecBuilder& audioDecoding(const char* encodingType);
/**
* @brief 配置能力级音频解码选项
*/
CodecBuilder& audioDecoding(const char* abilityID, const char* encodingType);
};
} // end of namespace AIKIT
#endif
ifly_spark/SDK/include/aikit_biz_obsolete_builder.h
+35
View File
@@ -0,0 +1,35 @@
#ifndef AIKIT_BIZ_OBSOLETE_BUILDER_H
#define AIKIT_BIZ_OBSOLETE_BUILDER_H
#include "aikit_biz_type.h"
namespace AIKIT {
class AIKIT_ParamBuilder;
class AIKITAPI AIKIT_DataBuilderObsolete {
public:
//设置SDK输入数据格式描述参数
attribute_deprecated virtual AIKIT_DataBuilderObsolete* desc(const char* key, AIKIT_ParamBuilder* builder) = 0;
attribute_deprecated virtual AIKIT_DataBuilderObsolete* text(const char* key, const char* data, uint32_t dataLen, uint32_t dataStatus) = 0;
attribute_deprecated virtual AIKIT_DataBuilderObsolete* textPath(const char* key, const char* path) = 0;
attribute_deprecated virtual AIKIT_DataBuilderObsolete* textFile(const char* key, const FILE* file) = 0;
attribute_deprecated virtual AIKIT_DataBuilderObsolete* audio(const char* key, const char* data, uint32_t dataLen, uint32_t dataStatus) = 0;
attribute_deprecated virtual AIKIT_DataBuilderObsolete* audioPath(const char* key, const char* path) = 0;
attribute_deprecated virtual AIKIT_DataBuilderObsolete* audioFile(const char* key, const FILE* file) = 0;
attribute_deprecated virtual AIKIT_DataBuilderObsolete* image(const char* key, const char* data, uint32_t dataLen, uint32_t dataStatus) = 0;
attribute_deprecated virtual AIKIT_DataBuilderObsolete* imagePath(const char* key, const char* path) = 0;
attribute_deprecated virtual AIKIT_DataBuilderObsolete* imageFile(const char* key, const FILE* file) = 0;
attribute_deprecated virtual AIKIT_DataBuilderObsolete* video(const char* key, const char* data, uint32_t dataLen, uint32_t dataStatus) = 0;
attribute_deprecated virtual AIKIT_DataBuilderObsolete* videoPath(const char* key, const char* path) = 0;
attribute_deprecated virtual AIKIT_DataBuilderObsolete* videoFile(const char* key, const FILE* file) = 0;
};
} // namespace AIKIT
#endif
ifly_spark/SDK/include/aikit_biz_type.h
+105
View File
@@ -0,0 +1,105 @@
#ifndef __AIKIT_BIZ_TYPE_H__
#define __AIKIT_BIZ_TYPE_H__
#include <stdio.h>
#include "aikit_type.h"
/**
* AIKIT API type
*/
#if defined(_MSC_VER) /* Microsoft Visual C++ */
# if !defined(AIKITAPI)
# if defined(AIKIT_EXPORT)
# define AIKITAPI __declspec(dllexport)
# else
# define AIKITAPI __declspec(dllimport)
# endif
# endif
#elif defined(__BORLANDC__) /* Borland C++ */
# if !defined(AIKITAPI)
# define AIKITAPI __stdcall
# endif
#elif defined(__WATCOMC__) /* Watcom C++ */
# if !defined(AIKITAPI)
# define AIKITAPI __stdcall
# endif
#else /* Any other including Unix */
# if !defined(AIKITAPI)
# if defined(AIKIT_EXPORT)
# define AIKITAPI __attribute__ ((visibility("default")))
# else
# define AIKITAPI
# endif
# endif
#endif
#if defined(_MSC_VER)
# if !defined(attribute_deprecated)
# define attribute_deprecated __declspec(deprecated)
# endif
#else
# if !defined(attribute_deprecated)
# define attribute_deprecated __attribute__((deprecated))
# endif
#endif
#ifndef int32_t
typedef int int32_t;
#endif
#ifndef uint32_t
typedef unsigned int uint32_t;
#endif
typedef AIKIT_BaseParam AIKIT_BizParam;
typedef AIKIT_BaseParamPtr AIKIT_BizParamPtr;
typedef AIKIT_BaseData AIKIT_BizData;
typedef AIKIT_BaseDataPtr AIKIT_BizDataPtr;
typedef AIKIT_BizData AIKIT_InputData;
typedef struct _AIKIT_BaseDataList {
AIKIT_BaseData *node; // 链表节点
int32_t count; // 链表节点个数
int32_t totalLen; // 链表节点所占内存空间：count*(sizeof(AIKIT_BaseData)+strlen(node->key)+node->len)
} AIKIT_BaseDataList, *AIKIT_BaseDataListPtr; // 配置对复用该结构定义
typedef struct _AIKIT_BaseParamList {
AIKIT_BaseParam *node; // 链表节点
int32_t count; // 链表节点个数
int32_t totalLen; // 链表节点所占内存空间：count*(sizeof(AIKIT_BaseParam)+strlen(node->key)+node->len)
} AIKIT_BaseParamList, *AIKIT_BaseParamListPtr; // 配置对复用该结构定义
typedef AIKIT_BaseDataList AIKIT_OutputData;
typedef AIKIT_BaseParamList AIKIT_OutputEvent;
typedef struct {
void* usrContext;
const char* abilityID;
size_t handleID;
} AIKIT_HANDLE;
typedef void (*AIKIT_OnOutput)(AIKIT_HANDLE* handle, const AIKIT_OutputData* output);
typedef void (*AIKIT_OnEvent)(AIKIT_HANDLE* handle, AIKIT_EVENT eventType, const AIKIT_OutputEvent* eventValue);
typedef void (*AIKIT_OnError)(AIKIT_HANDLE* handle, int32_t err, const char* desc);
typedef struct {
AIKIT_OnOutput outputCB; //輸出回调
AIKIT_OnEvent eventCB; //事件回调
AIKIT_OnError errorCB; //错误回调
} AIKIT_Callbacks;
typedef struct {
int authType; // 授权方式，0=设备级授权，1=应用级授权
const char* appID; // 应用id
const char* apiKey; // 应用key
const char* apiSecret; // 应用secret
const char* workDir; // sdk工作目录，需可读可写权限
const char* resDir; // 只读资源存放目录，需可读权限
const char* licenseFile; // 离线激活方式的授权文件存放路径，为空时需联网进行首次在线激活
const char* batchID; // 授权批次
const char* UDID; // 用户自定义设备标识
const char* cfgFile; // 配置文件路径，包括文件名
} AIKIT_InitParam;
#endif // __AIKIT_BIZ_TYPE_H__
ifly_spark/SDK/include/aikit_common.h
+12
View File
@@ -0,0 +1,12 @@
#ifndef AIKIT_COMMON_H
#define AIKIT_COMMON_H
typedef enum AIKIT_DATA_PTR_TYPE_E {
AIKIT_DATA_PTR_MEM = 0, // 数据内存指针
AIKIT_DATA_PTR_FILE = 1, // 数据文件指针（FILE指针）
AIKIT_DATA_PTR_PATH = 2 // 数据文件路径指针
} AIKIT_DATA_PTR_TYPE;
#endif //AIKIT_COMMON_H
ifly_spark/SDK/include/aikit_err.h
+160
View File
@@ -0,0 +1,160 @@
/*
* @Description:
* @version:
* @Author: rfge
* @Date: 2020-11-01 17:56:53
* @LastEditors: rfge
* @LastEditTime: 2020-12-14 14:26:44
*/
//
// Created by xkzhang9 on 2020/6/10.
//
#ifndef AIKIT_ERR_H
#define AIKIT_ERR_H
typedef enum {
AIKIT_ERR_AUTH = 18000, // 授权部分
AIKIT_ERR_RES = AIKIT_ERR_AUTH + 100, // 资源部分
AIKIT_ERR_ENG = AIKIT_ERR_AUTH + 200, // 引擎部分
AIKIT_ERR_SDK = AIKIT_ERR_AUTH + 300, // SDK部分
AIKIT_ERR_SYS = AIKIT_ERR_AUTH + 400, // 系统部分
AIKIT_ERR_PARAM = AIKIT_ERR_AUTH + 500, // 参数部分
AIKIT_ERR_PROTOCOL = AIKIT_ERR_AUTH + 600, // 协议部分
AIKIT_ERR_CLOUD = AIKIT_ERR_AUTH + 700, // 云端错误
AIKIT_ERR_LOCAL_NET= AIKIT_ERR_AUTH + 800, //本地网络网络
AIKIT_ERR_VMS = AIKIT_ERR_AUTH + 900, // 虚拟人错误
AIKIT_ERR_SPARK = AIKIT_ERR_AUTH + 950, // spark大模型错误
AIKIT_ERR_OTHER = 0xFF00 // 其他
} AIKIT_ERR_SECTION;
typedef enum {
AIKIT_ERR_SUCCESS = 0, // 操作成功
AIKIT_ERR_GENERAL_FAILED = 1, // 一般错误
AIKIT_ERR_AUTH_LICENSE_NOT_FOUND = AIKIT_ERR_AUTH + 0, // 18000 本地license文件不存在
AIKIT_ERR_AUTH_LICENSE_FILE_INVALID = AIKIT_ERR_AUTH + 1, // 18001 授权文件内容非法
AIKIT_ERR_AUTH_LICENSE_PARSE_FAILED = AIKIT_ERR_AUTH + 2, // 18002 授权文件解析失败
AIKIT_ERR_AUTH_PAYLOAD_DEFECT = AIKIT_ERR_AUTH + 3, // 18003 payload内容缺失
AIKIT_ERR_AUTH_SIGN_DEFECT = AIKIT_ERR_AUTH + 4, // 18004 signature内容缺失
AIKIT_ERR_AUTH_EXPIRED = AIKIT_ERR_AUTH + 5, // 18005 授权已过期
AIKIT_ERR_AUTH_TIME_ERROR = AIKIT_ERR_AUTH + 6, // 18006 授权时间错误，比正常时间慢30分钟以上
AIKIT_ERR_AUTH_APP_NOT_MATCH = AIKIT_ERR_AUTH + 7, // 18007 授权应用不匹配（apiKey、apiSecret）
AIKIT_ERR_AUTH_LICENSE_EXPIRED = AIKIT_ERR_AUTH + 8, // 18008 授权文件激活过期
AIKIT_ERR_AUTH_NULL_APP_PTR = AIKIT_ERR_AUTH + 9, // 18009 授权app信息指针为空
AIKIT_ERR_AUTH_PLATFORM_NOT_MATCH = AIKIT_ERR_AUTH + 10, // 18010 离线授权激活文件指定平台与设备平台不匹配
AIKIT_ERR_AUTH_ARCH_NOT_MATCH = AIKIT_ERR_AUTH + 11, // 18011 离线授权激活文件指定架构与设备cpu架构不匹配
AIKIT_ERR_AUTH_WRONG_LICENSE_NUM = AIKIT_ERR_AUTH + 12, // 18012 离线授权激活文件中包含License个数异常
AIKIT_ERR_AUTH_DEVICE_NOT_FOUND = AIKIT_ERR_AUTH + 13, // 18013 离线授权激活文件中未找到当前设备
AIKIT_ERR_AUTH_LEVEL_NOT_VALID = AIKIT_ERR_AUTH + 14, // 18014 离线授权激活文件中设备指纹安全等级非法
AIKIT_ERR_AUTH_HARDWARE_FAILED = AIKIT_ERR_AUTH + 15, // 18015 硬件授权验证失败
AIKIT_ERR_AUTH_OFFLINE_PROT_INVALID = AIKIT_ERR_AUTH + 16, // 18016 离线授权激活文件内容非法
AIKIT_ERR_AUTH_HEADER_INVALID = AIKIT_ERR_AUTH + 17, // 18017 离线授权激活文件中协议头非法
AIKIT_ERR_AUTH_PART_COUNT_INVALID = AIKIT_ERR_AUTH + 18, // 18018 离线授权激活文件中指纹组成项个数为0
AIKIT_ERR_AUTH_RESOURCE_EXPIREd = AIKIT_ERR_AUTH + 19, // 18019 资源已过期
AIKIT_ERR_RES_VERIFY_FAILED = AIKIT_ERR_RES + 0, // 18100 资源鉴权失败
AIKIT_ERR_RES_INVALID_HEADER= AIKIT_ERR_RES + 1, // 18101 资源格式解析失败
AIKIT_ERR_RES_NOT_MATCH = AIKIT_ERR_RES + 2, // 18102 资源(与引擎)不匹配
AIKIT_ERR_RES_NULL_PTR = AIKIT_ERR_RES + 3, // 18103 资源参数不存在（指针为NULL）
AIKIT_ERR_RES_OPEN_FAILED = AIKIT_ERR_RES + 4, // 18104 资源路径打开失败
AIKIT_ERR_RES_LOAD_FAILED = AIKIT_ERR_RES + 5, // 18105 资源加载失败，workDir内未找到对应资源
AIKIT_ERR_RES_UNLOAD_FAILED = AIKIT_ERR_RES + 6, // 18106 资源卸载失败, 卸载的资源未加载过
AIKIT_ERR_ENG_VERIFY_FAILED = AIKIT_ERR_ENG + 0, // 18200 引擎鉴权失败
AIKIT_ERR_ENG_LOAD_FAILED = AIKIT_ERR_ENG + 1, // 18201 引擎动态加载失败
AIKIT_ERR_ENG_NOT_INITED = AIKIT_ERR_ENG + 2, // 18202 引擎未初始化
AIKIT_ERR_ENG_API_NOT_SUPPORT = AIKIT_ERR_ENG + 3, // 18203 引擎不支持该接口调用
AIKIT_ERR_ENG_NULL_CREATE_PTR = AIKIT_ERR_ENG + 4, // 18204 引擎craete函数指针为空
AIKIT_ERR_SDK_INVALID = AIKIT_ERR_SDK + 0, // 18300 sdk不可用
AIKIT_ERR_SDK_NOT_INITED = AIKIT_ERR_SDK + 1, // 18301 sdk没有初始化
AIKIT_ERR_SDK_INIT_FAILED = AIKIT_ERR_SDK + 2, // 18302 sdk初始化失败
AIKIT_ERR_SDK_ALREADY_INIT = AIKIT_ERR_SDK + 3, // 18303 sdk已经初始化
AIKIT_ERR_SDK_INVALID_PARAM = AIKIT_ERR_SDK + 4, // 18304 sdk不合法参数
AIKIT_ERR_SDK_NULL_SESSION_HANDLE = AIKIT_ERR_SDK + 5, // 18305 sdk会话handle为空
AIKIT_ERR_SDK_SESSION_NOT_FOUND = AIKIT_ERR_SDK + 6, // 18306 sdk会话未找到
AIKIT_ERR_SDK_SESSION_ALREADY_END = AIKIT_ERR_SDK + 7, // 18307 sdk会话重复终止
AIKIT_ERR_SDK_TIMEOUT = AIKIT_ERR_SDK + 8, // 18308 超时错误
AIKIT_ERR_SDK_INITING = AIKIT_ERR_SDK + 9, // 18309 sdk正在初始化中
AIKIT_ERR_SDK_SESSEION_ALREAY_START = AIKIT_ERR_SDK + 10, // 18310 sdk会话重复开启
AIKIT_ERR_SDK_CONCURRENT_OVERFLOW = AIKIT_ERR_SDK + 11, // 18311 sdk同一能力并发路数超出最大限制
AIKIT_ERR_SYS_WORK_DIR_ILLEGAL = AIKIT_ERR_SYS + 0, // 18400 工作目录无写权限
AIKIT_ERR_SYS_DEVICE_UNKNOWN = AIKIT_ERR_SYS + 1, // 18401 设备指纹获取失败，设备未知
AIKIT_ERR_SYS_FILE_OPEN_FAILED = AIKIT_ERR_SYS + 2, // 18402 文件打开失败
AIKIT_ERR_SYS_MEM_ALLOC_FAILED = AIKIT_ERR_SYS + 3, // 18403 内存分配失败
AIKIT_ERR_SYS_DEVICE_COMPARE_FAILED = AIKIT_ERR_SYS + 4, // 18404 设备指纹比较失败
AIKIT_ERR_PARAM_NOT_FOUND = AIKIT_ERR_PARAM + 0, // 18500 未找到该参数key
AIKIT_ERR_PARAM_OVERFLOW = AIKIT_ERR_PARAM + 1, // 18501 参数范围溢出，不满足约束条件
AIKIT_ERR_PARAM_NULL_INIT_PARAM_PTR = AIKIT_ERR_PARAM + 2, // 18502 sdk初始化参数为空
AIKIT_ERR_PARAM_NULL_APPID_PTR = AIKIT_ERR_PARAM + 3, // 18503 sdk初始化参数中appid为空
AIKIT_ERR_PARAM_NULL_APIKEY_PTR = AIKIT_ERR_PARAM + 4, // 18504 sdk初始化参数中apiKey为空
AIKIT_ERR_PARAM_NULL_APISECRET_PTR = AIKIT_ERR_PARAM + 5, // 18505 sdk初始化参数中apiSecret为空
AIKIT_ERR_PARAM_NULL_ABILITY_PTR = AIKIT_ERR_PARAM + 6, // 18506 ability参数为空
AIKIT_ERR_PARAM_NULL_INPUT_PTR = AIKIT_ERR_PARAM + 7, // 18507 input参数为空
AIKIT_ERR_PARAM_DATA_KEY_NOT_EXIST = AIKIT_ERR_PARAM + 8, // 18508 输入数据参数Key不存在
AIKIT_ERR_PARAM_REQUIRED_MISSED = AIKIT_ERR_PARAM + 9, // 18509 必填参数缺失
AIKIT_ERR_PARAM_NULL_OUTPUT_PTR = AIKIT_ERR_PARAM + 10, // 18510 output参数缺失
AIKIT_ERR_CODEC_NOT_SUPPORT = AIKIT_ERR_PARAM + 20, // 18520 不支持的编解码类型
AIKIT_ERR_CODEC_NULL_PTR = AIKIT_ERR_PARAM + 21, // 18521 编解码handle指针为空
AIKIT_ERR_CODEC_MODULE_MISSED = AIKIT_ERR_PARAM + 22, // 18522 编解码模块条件编译未打开
AIKIT_ERR_CODEC_ENCODE_FAIL = AIKIT_ERR_PARAM + 23, // 18523 编码错误
AIKIT_ERR_CODEC_DECODE_FAIL = AIKIT_ERR_PARAM + 24, // 18524 解码错误
AIKIT_ERR_VAD_RESPONSE_TIMEOUT = AIKIT_ERR_PARAM + 30, // VAD静音超时
AIKIT_ERR_PROTOCOL_TIMESTAMP_MISSING = AIKIT_ERR_PROTOCOL + 0, // 18600 协议中时间戳字段缺失
AIKIT_ERR_PROTOCOL_ABILITY_NOT_FOUND = AIKIT_ERR_PROTOCOL + 1, // 18601 协议中未找到该能力ID
AIKIT_ERR_PROTOCOL_RESOURCE_NOT_FOUND = AIKIT_ERR_PROTOCOL + 2, // 18602 协议中未找到该资源ID
AIKIT_ERR_PROTOCOL_ENGINE_NOT_FOUND = AIKIT_ERR_PROTOCOL + 3, // 18603 协议中未找到该引擎ID
AIKIT_ERR_PROTOCOL_ZERO_ENGINE_NUM = AIKIT_ERR_PROTOCOL + 4, // 18604 协议中引擎个数为0
AIKIT_ERR_PROTOCOL_NOT_LOADED = AIKIT_ERR_PROTOCOL + 5, // 18605 协议未被初始化解析
AIKIT_ERR_PROTOCOL_INTERFACE_TYPE_NOT_MATCH = AIKIT_ERR_PROTOCOL + 6, // 18606 协议能力接口类型不匹配
AIKIT_ERR_PROTOCOL_TEMP_VERIFY_FAILED = AIKIT_ERR_PROTOCOL + 7, // 18607 预置协议解析失败
AIKIT_ERR_CLOUD_GENERAL_FAILED = AIKIT_ERR_CLOUD + 0, // 18700 通用网络错误
AIKIT_ERR_CLOUD_CONNECT_FAILED = AIKIT_ERR_CLOUD + 1, // 18701 网路不通
AIKIT_ERR_CLOUD_403 = AIKIT_ERR_CLOUD + 2, // 18702 网关检查不过
AIKIT_ERR_CLOUD_WRONG_RSP_FORMAT = AIKIT_ERR_CLOUD + 3, // 18703 云端响应格式不对
AIKIT_ERR_CLOUD_APP_NOT_FOUND = AIKIT_ERR_CLOUD + 4, // 18704 应用未注册
AIKIT_ERR_CLOUD_APP_CHECK_FAILED = AIKIT_ERR_CLOUD + 5, // 18705 应用apiKey&&apiSecret校验失败
AIKIT_ERR_CLOUD_WRONG_ARCHITECT = AIKIT_ERR_CLOUD + 6, // 18706 引擎不支持的平台架构
AIKIT_ERR_CLOUD_AUTH_EXPIRED = AIKIT_ERR_CLOUD + 7, // 18707 授权已过期
AIKIT_ERR_CLOUD_AUTH_FULL = AIKIT_ERR_CLOUD + 8, // 18708 授权数量已满
AIKIT_ERR_CLOUD_ABILITY_NOT_FOUND = AIKIT_ERR_CLOUD + 9, // 18709 未找到该app绑定的能力
AIKIT_ERR_CLOUD_RESOURCE_NOT_FOUND = AIKIT_ERR_CLOUD + 10, // 18710 未找到该app绑定的能力资源
AIKIT_ERR_CLOUD_JSON_PARSE_FAILED = AIKIT_ERR_CLOUD + 11, // 18711 JSON操作失败
AIKIT_ERR_CLOUD_404 = AIKIT_ERR_CLOUD + 12, // 18712 http 404错误
AIKIT_ERR_CLOUD_LEVEL_NOT_MATCH = AIKIT_ERR_CLOUD + 13, // 18713 设备指纹安全等级不匹配
AIKIT_ERR_CLOUD_401 = AIKIT_ERR_CLOUD + 14, // 18714 用户没有访问权限，需要进行身份认证
AIKIT_ERR_CLOUD_SDK_NOT_FOUND = AIKIT_ERR_CLOUD + 15, // 18715 未找到该SDK ID
AIKIT_ERR_CLOUD_ABILITYS_NOT_FOUND = AIKIT_ERR_CLOUD + 16, // 18716 未找到该组合能力集合
AIKIT_ERR_CLOUD_ABILITY_NOT_ENOUGH = AIKIT_ERR_CLOUD + 17, // 18717 SDK组合能力授权不足
AIKIT_ERR_CLOUD_APP_SIG_INVALID = AIKIT_ERR_CLOUD + 18, // 18718 无效授权应用签名
AIKIT_ERR_CLOUD_APP_SIG_NOT_UNIQUE = AIKIT_ERR_CLOUD + 19, // 18719 应用签名不唯一
AIKIT_ERR_CLOUD_SCHEMA_INVALID = AIKIT_ERR_CLOUD + 20, // 18720 能力schema不可用
AIKIT_ERR_CLOUD_TEMPLATE_NOT_FOUND = AIKIT_ERR_CLOUD + 21, // 18721 竞争授权: 未找到能力集模板
AIKIT_ERR_CLOUD_ABILITY_NOT_IN_TEMPLATE = AIKIT_ERR_CLOUD + 22, // 18722 竞争授权: 能力不在模板能力集模板中
AIKIT_ERR_LOCAL_NET_CONNECT_FAILED = AIKIT_ERR_LOCAL_NET + 1, // 18801 连接建立出错
AIKIT_ERR_LOCAL_NET_RES_WAIT_TIMEOUT = AIKIT_ERR_LOCAL_NET + 2, // 18802 结果等待超时
AIKIT_ERR_LOCAL_NET_CONNECT_ERROR = AIKIT_ERR_LOCAL_NET + 3, // 18803 连接状态异常
AIKIT_ERR_VMS_START_ERROR = AIKIT_ERR_VMS + 1, // 18901虚拟人启动错误
AIKIT_ERR_VMS_STOP_ERROR = AIKIT_ERR_VMS + 2, // 18902虚拟人结束错误
AIKIT_ERR_VMS_DRIVE_ERROR = AIKIT_ERR_VMS + 3, // 18903虚拟人驱动错误
AIKIT_ERR_VMS_HEARTBEAT_ERROR = AIKIT_ERR_VMS + 4, // 18904虚拟人心跳报错
AIKIT_ERR_VMS_TIMEOUT = AIKIT_ERR_VMS + 5, // 18905虚拟人服务超时
AIKIT_ERR_VMS_OTHER_ERROR = AIKIT_ERR_VMS + 6, // 18906虚拟人通用报错
AIKIT_ERR_SPARK_REQUEST_UNORDERED = AIKIT_ERR_SPARK + 1, // 18951 同一流式大模型会话，禁止并发交互请求
AIKIT_ERR_SPARK_TEXT_INVALID = AIKIT_ERR_SPARK + 2 // 18952 输入文本格式或内容非法
} AIKIT_ERR;
typedef enum { AIKIT_ERR_TYPE_AUTH = 0, AIKIT_ERR_TYPE_HTTP = 1 } AIKIT_ERR_TYPE;
#endif //AIKIT_ERR_H
ifly_spark/SDK/include/aikit_spark_api.h
+90
View File
@@ -0,0 +1,90 @@
#ifndef AIKIT_SPARK_H
#define AIKIT_SPARK_H
#include "aikit_biz_api.h"
namespace AIKIT {
class AIKITAPI ChatParam {
public:
static ChatParam* builder();
virtual ~ChatParam();
/**
* @brief 配置授权的用户id，用于关联用户交互的上下文
*/
virtual ChatParam* uid(const char* uid) = 0;
/**
* @brief 配置chat领域信息
*/
virtual ChatParam* domain(const char* domain) = 0;
/**
* @brief 配置内容审核策略
*/
virtual ChatParam* auditing(const char* auditing) = 0;
/**
* @brief 配置关联会话chat id标识，需要保障⽤户下唯⼀
*/
virtual ChatParam* chatID(const char* chatID) = 0;
/**
* @brief 配置核采样阈值，默认值0.5，向上调整可以增加结果的随机程度
*/
virtual ChatParam* temperature(const float& temperature) = 0;
/**
* @brief 配置从k个候选中随机选择⼀个（⾮等概率），默认值4，取值范围1-99
*/
virtual ChatParam* topK(const int& topK) = 0;
/**
* @brief 配置回答的tokens的最大长度，默认值2048
*/
virtual ChatParam* maxToken(const int& maxToken) = 0;
/**
* @brief 配置chat服务域名地址
*/
virtual ChatParam* url(const char* url) = 0;
/**
* @brief 配置chat扩展功能参数
*/
virtual ChatParam* param(const char* key, const char* value) = 0;
virtual ChatParam* param(const char* key, int value) = 0;
virtual ChatParam* param(const char* key, double value) = 0;
virtual ChatParam* param(const char* key, bool value) = 0;
};
using AIChat_Handle = AIKIT_HANDLE;
typedef void (*onChatOutput)(AIChat_Handle* handle, const char* role, const char* content, const int& index);
typedef void (*onChatToken)(AIChat_Handle* handle, const int& completionTokens, const int& promptTokens, const int& totalTokens);
typedef void (*onChatError)(AIChat_Handle* handle, const int& err, const char* errDesc);
typedef struct {
onChatOutput outputCB; //输出回调
onChatToken tokenCB; //token计算信息回调
onChatError errorCB; //错误回调
} AIKIT_ChatCBS;
AIKITAPI int32_t AIKIT_ChatCallback(const AIKIT_ChatCBS& cbs);
//异步chat
AIKITAPI int32_t AIKIT_AsyncChat(const ChatParam* params, const char* inputText, void* usrContext);
AIKITAPI int32_t AIKIT_Start(const ChatParam* params, void* usrContext, AIChat_Handle** outHandle);
AIKITAPI int32_t AIKIT_Write(AIChat_Handle* handle, const char* inputText);
//
//AIKITAPI int32_t AIKIT_End(AIChat_Handle* handle);
} // end of namespace AIKIT
#endif
ifly_spark/SDK/include/aikit_type.h
+107
View File
@@ -0,0 +1,107 @@
#ifndef __AIKIT_TYPE_H__
#define __AIKIT_TYPE_H__
#include <stddef.h>
#include <stdint.h>
#include "aikit_common.h"
#if defined(_MSC_VER) /* Microsoft Visual C++ */
#pragma pack(push, 8)
#elif defined(__BORLANDC__) /* Borland C++ */
#pragma option -a8
#elif defined(__WATCOMC__) /* Watcom C++ */
#pragma pack(push, 8)
#else /* Any other including Unix */
#endif
typedef enum _AIKIT_VarType {
AIKIT_VarTypeString = 0, // 字符串型
AIKIT_VarTypeInt = 1, // 整型
AIKIT_VarTypeDouble = 2, // 实型
AIKIT_VarTypeBool = 3, // 布尔类型
AIKIT_VarTypeParamPtr = 4, // 子参数类型
AIKIT_VarTypeUnknown = -1 //
} AIKIT_VarType;
typedef enum _AIKIT_DataStatus {
AIKIT_DataBegin = 0, // 首数据
AIKIT_DataContinue = 1, // 中间数据
AIKIT_DataEnd = 2, // 尾数据
AIKIT_DataOnce = 3, // 非会话单次输入输出
} AIKIT_DataStatus;
typedef enum _AIKIT_DataType {
AIKIT_DataText = 0, // 文本数据
AIKIT_DataAudio = 1, // 音频数据
AIKIT_DataImage = 2, // 图像数据
AIKIT_DataVideo = 3, // 视频数据
// AIKIT_DataPer = 4, // 个性化数据
} AIKIT_DataType;
typedef enum {
AIKIT_Event_UnKnown = 0,
AIKIT_Event_Start = 1, // 引擎计算开始事件
AIKIT_Event_End = 2, // 引擎计算结束事件
AIKIT_Event_Timeout = 3, // 引擎计算超时事件
AIKIT_Event_Progress = 4, // 引擎计算进度事件
// 在线能力连接状态事件
AIKIT_Event_Null = 10, // 空连接状态
AIKIT_Event_Init, // 初始状态
AIKIT_Event_Connecting, // 正在连接
AIKIT_Event_ConnTimeout, // 连接超时
AIKIT_Event_Failed, // 连接失败
AIKIT_Event_Connected, // 已经连接
AIKIT_Event_Error, // 收发出错，意味着断开连接
AIKIT_Event_Disconnected, // 断开连接，一般指心跳超时，连接无错误
AIKIT_Event_Closing, // 正在关闭连接
AIKIT_Event_Closed, // 已经关闭连接
AIKIT_Event_Responding, // 网络连接正在响应
AIKIT_Event_ResponseTimeout, // 网络连接响应超时
// VAD事件
AIKIT_Event_VadBegin = 30, // VAD开始
AIKIT_Event_VadEnd // VAD结束
} AIKIT_EVENT;
typedef struct _AIKIT_BaseParam {
struct _AIKIT_BaseParam *next; // 链表指针
const char *key; // 数据标识
void *value; // 数据实体
void* reserved; // 预留字段
int32_t len; // 数据长度
int32_t type; // 变量类型，取值参见AIKIT_VarType
} AIKIT_BaseParam, *AIKIT_BaseParamPtr; // 配置对复用该结构定义
typedef struct _AIKIT_BaseData {
struct _AIKIT_BaseData *next; // 链表指针
AIKIT_BaseParam *desc; // 数据描述，包含每个数据(audio/video/text/image)的所有特征参数数据(sample_rate,channels,data等)
const char *key; // 数据标识
void *value; // 数据实体
void* reserved; // 预留字段
int32_t len; // 数据长度
int32_t type; // 数据类型，取值参见AIKIT_DataType
int32_t status; // 数据状态，取值参见AIKIT_DataStatus
int32_t from; // 数据来源，取值参见AIKIT_DATA_PTR_TYPE
} AIKIT_BaseData, *AIKIT_BaseDataPtr;
typedef struct _AIKIT_CustomData {
struct _AIKIT_CustomData* next; // 链表指针
const char* key; // 数据标识
void* value; // 数据内容
void* reserved; // 预留字段
int32_t index; // 数据索引,用户可自定义设置
int32_t len; // 数据长度，type非DATA_PTR_FILE时本字段有效
int32_t from; // 数据内容的类型，取值参见枚举AIKIT_DATA_PTR_TYPE
} AIKIT_CustomData, *AIKIT_CustomDataPtr;
/* Reset the structure packing alignments for different compilers. */
#if defined(_MSC_VER) /* Microsoft Visual C++ */
#pragma pack(pop)
#elif defined(__BORLANDC__) /* Borland C++ */
#pragma option -a.
#elif defined(__WATCOMC__) /* Watcom C++ */
#pragma pack(pop)
#endif
#endif
ifly_spark/SDK/libs/x64/libaikit.so
BIN
View File
Binary file not shown.
ifly_spark/demo/README.md
+28
View File
@@ -0,0 +1,28 @@
# AIKit-Spark
在sparkDemo.cpp中填入 appId,apiKey,apiSecret,uid
1.编译：
sh build.sh
2.运行：
sh run.sh
.
├── SDK // SDK头文件及动态库
│ ├── include // SDK所需头文件列表
│ │ ├── aikit_biz_api.h
│ │ ├── aikit_biz_builder.h
│ │ ├── aikit_biz_obsolete_builder.h
│ │ ├── aikit_biz_type.h
│ │ ├── aikit_common.h
│ │ ├── aikit_spark_api.h // spark核心头文件
│ │ └── aikit_type.h
│ └── libs // SDK动态库目录
│ └── x64
│ └── libaikit.so
├── demo // demo目录
│ ├── build.sh // demo编译脚本
│ ├── README.md // demo运行说明
│ ├── run.sh // demo运行脚本
│ ├── sparkDemo.cpp // demo源码
│ └── sparkDemo.h
└── docs //SDK相关文档
ifly_spark/demo/build.sh
Executable
+1
View File
@@ -0,0 +1 @@
g++ -std=c++11 -g -o sparkDemo sparkDemo.cpp -I../include -I./ -L../SDK/libs/x64 -laikit -Wl,-rpath=libs
ifly_spark/demo/files/ilog_v1/records.log
View File
ifly_spark/demo/files/logan_cache/logan.mmap2
BIN
View File
Binary file not shown.
ifly_spark/demo/run.sh
Executable
+2
View File
@@ -0,0 +1,2 @@
export LD_LIBRARY_PATH=../SDK/libs/x64
./sparkDemo
ifly_spark/demo/sparkDemo.cpp
+96
View File
@@ -0,0 +1,96 @@
#include "sparkDemo.h"
using namespace std;
using namespace AIKIT;
struct UsrCtx {
string chatID;
};
string getUsrInput() {
cout<<"请输入用户问题："<<endl;
string text;
cin>>text;
return text;
}
int sendRequest () {
//请求参数配置
ChatParam* config = ChatParam::builder();
config->uid("xxxid")
->domain("generalv2")
->auditing("default")
->url("ws://spark-api.xf-yun.com/v2.1/chat");
// 设置chatID,使用static变量,防止回调时被销毁。
// 用于用户动态控制会话轮次
static UsrCtx usr = {"FistRound"};
int ret = AIKIT_AsyncChat(config, getUsrInput().c_str(), &usr);
if(ret != 0) {
printf("AIKIT_AsyncChat failed:%d\n",ret);
return ret;
}
return ret;
}
void chatOnToken(AIChat_Handle* handle, const int& completionTokens, const int& promptTokens, const int& totalTokens) {
if(handle!=nullptr){
cout<<"chatID:"<<((UsrCtx*)handle->usrContext)->chatID<<", ";
}
cout<<"completionTokens:"<<completionTokens<<" promptTokens:"<<promptTokens<<" totalTokens:"<<totalTokens<<endl;
sendRequest();
}
static void chatOnOutput(AIChat_Handle* handle, const char* role, const char* content, const int& index) {
if(handle!=nullptr){
cout<<"chatID:"<<((UsrCtx*)handle->usrContext)->chatID<<", ";
}
cout<<"role:"<<role<<", content: "<<content<<endl;
}
static void chatOnError(AIChat_Handle* handle, const int& err, const char* errDesc) {
if(handle!=nullptr){
cout<<"chatID:"<<((UsrCtx*)handle->usrContext)->chatID<<", ";
}
printf("chatOnError: err:%d,desc:%s\n",err,errDesc);
sendRequest();
}
void initSDK() {
AIKIT_InitParam initParam{};
AIKIT_SetLogInfo(100,0,nullptr);
initParam.appID = "bb839ccf";
initParam.apiKey = "ab95d52b4ea9f2a5dc15e77ae3f778fa";
initParam.apiSecret = "MTAxZDllZDY1OTVjYmIwYzg2NDBlZWQ0";
int ret = AIKIT_Init(&initParam);
if(ret != 0) {
printf("AIKIT_Init failed:%d\n",ret);
return ;
}
//异步回调注册
AIKIT_ChatCallback({ chatOnOutput, chatOnToken, chatOnError });
return;
}
void unInit() {
//等待异步回调，这里sleep仅是demo最简便运行需要
//真实场景，应用侧自行决定合适进行SDK逆初始化
sleep(500);
//逆初始化SDK
AIKIT_UnInit();
return;
}
int main() {
//初始化SDK
initSDK();
//发送用户请求
sendRequest();
//逆初始化
unInit();
return 0;
}
ifly_spark/demo/sparkDemo.h
+10
View File
@@ -0,0 +1,10 @@
#include <iostream>
#include <fstream>
#include <assert.h>
#include <cstring>
#include <atomic>
#include <unistd.h>
#include "../SDK/include/aikit_spark_api.h"