目录
klink-u-upstream
分支1
标签0
+ 疑修
Web IDE
huheng@kylinos.cn
[需求]: #563105    Klink-U代码整理
[修改说明]: 添加BLE适配层代码
[影响范围]: 不影响其它模块


Change-Id: Ic3eaad2ac747fa72faa206f7d7e02c2464f89193
1天前475次提交
目录README.md

Copyright&LICENSE

Copyright (c) 2023-2024 KylinSoft Co., Ltd.

kylin-dsoftbus-standard is licensed under the Apache License, Version 2.0 (the “License”);

Please check the LICENSE file for more information.

kylin-dsoftbus-standard fork from openharmony dsoftbus;

You can access the source open source software address through this URL：

https://gitee.com/openharmony/communication_dsoftbus

接口文档（linux开发）

sdk名称：互联互通应用sdk

版本：v1.0.0

发布日期：2024.04.30

开发团队：麒麟软件有限公司星光麒麟事业部

联系邮箱：xxx@kylinos.cn

1. 简介

互联互通SDK为应用接入互联互通功能提供了便捷的编程接口，支持C/C++语言。通过集成此SDK，开发者可以快速实现应用接入互联互通体系，简化开发流程，提高开发效率。本文档详细介绍了SDK的核心接口及其参数说明、示例代码以及常见问题处理。

2. 快速开始

（1）编译

cd src-path # 进入源码路径
# 编译依赖
# 查看build-depends文件
# 这里需要使用3.0.0以上版本的openssl库
# 这里在third_party/openssl/下提供已编译的openssl库，仅支持linux使用，其他平台需要自行编译
# 执行
sudo bash ./third_party/openssl/openssl_install.sh ./third_party/openssl [amd|arm]
# 进行动态库植入
# 如果你是其他平台或架构，请自己编译openssl版本，非常抱歉
mkdir build & cd build
cmake ..
make
sudo make install

（2）运行

目前需要自己将klink的服务拉起

#配置网卡
#ifconfig查看当前使用网卡名称
#修改/opt/dsoftbus/config/ifname.conf中的字段为当前使用的网卡名称
# 启动软总线服务
sudo /opt/dsoftbus/bin/connectivity_softbus_server
# 启动认证客户端（可以根据sdk接口自己实现）
sudo /opt/dsoftbus/bin/connectivity_devicemgr_client

（3）cmake链接库说明

find_package(PkgConfig REQUIRED)
pkg_check_modules(SOFTBUS_CLIENT REQUIRED softbus_client)
pkg_check_modules(DEVICEMGR_SDK REQUIRED devicemgrservice)

include_directories(${SOFTBUS_CLIENT_INCLUDE_DIRS})
include_directories(${DEVICEMGR_SDK_INCLUDE_DIRS})

target_link_libraries (
    ${PROJECT_NAME}
    PUBLIC
    ${SOFTBUS_CLIENT_LIBRARIES}
    ${DEVICEMGR_SDK_LIBRARIES}
    )

然后就可以进行klink业务的开发了

3. 核心接口

（1）初始化设备管理业务

功能描述：开发认证管理端时的初始化操作

接口：

// 初始化设备管理器中心
// 初始化devicemanager
int32_t InitDeviceManagerCenter();

请求参数：无

返回值：成功返回0

使用说明：

// 包含头文件
#include <device_manager_center.h>

if (InitDeviceManagerCenter() == 0) 
{
    // 初始化成功
}

（2）销毁设备管理业务

功能描述：开发认证管理端时的销毁操作

接口：

// 销毁设备管理器中心
// 释放操作
int32_t DestoryDeviceManagerCenter();

请求参数：无

返回值：成功返回0

使用说明：

// 包含头文件
#include <device_manager_center.h>

if (DestoryDeviceManagerCenter() == 0) 
{
    // 销毁成功
}

（3）注册|取消注册设备能力发布回调

功能描述：开发认证管理端时用于注册|取消注册设备能力发布回调接口

接口：

typedef struct {
    // 当发布结果产生时调用
    void (*OnPublishResult)(int32_t publishId, int32_t publishResult);
} ISoftbusPublishCallback;

// 注册发布回调
// callback: 发布回调接口指针
// 注册发布回调
int32_t RegisterPublishCallback(const ISoftbusPublishCallback *callback);

// 取消发布回调注册
// 注销之前注册的发布回调
int32_t UnRegisterPublishCallback();

请求参数：

参数名 类型 是否必填 描述
callback const ISoftbusPublishCallback * 是 发布回调接口指针

返回值：成功返回0

使用说明：

// 包含头文件
#include <device_manager_center.h>

static void OnPublishResult(int32_t publishId, int32_t publishResult)
{
    // 发布结果处理
}
  
static ISoftbusPublishCallback g_callback = {.OnPublishResult = OnPublishResult};

if (RegisterPublishCallback(&g_callback) == 0) {    
    // 成功注册
}

if (UnRegisterPublishCallback() == 0) {    
    // 成功取消注册
}

（4）注册|取消注册设备发现结果回调接口

功能描述：开发认证管理端时用于注册|取消注册设备发现结果回调接口

接口：

typedef struct {
    // 当发现新设备时调用，isOnline表示设备是否在线
    void (*OnDeviceFound)(const AuthDeviceInfo &info, bool isOnline);
    // 当设备发现成功时调用 
    void (*OnDiscoverySuccess)(int32_t subscribeId);
    // 当设备发现失败时调用
    void (*OnDiscoveryFailed)(int32_t subscribeId, int32_t failedReason);
} ISoftbusDiscoveryCallback;

// 注册发现回调
// callback: 发现回调接口指针
// 注册发现回调
int32_t RegisterDiscoverCallback(const ISoftbusDiscoveryCallback *callback);

// 取消发现回调注册
// 注销之前注册的发现回调
int32_t UnRegisterDiscoverCallback();

请求参数：

参数名 类型 是否必填 描述
callback const ISoftbusDiscoveryCallback* 是 发现回调接口指针

返回值：成功返回0

使用说明：

// 包含头文件
#include <device_manager_center.h>

void OnDeviceFound(const AuthDeviceInfo &info, bool isOnline)
{
    // 设备信息 info
    // 是否在线 isOnline
}

void OnDiscoverySuccess(int32_t subscribeId)
{
    // 成功订阅
}

void OnDiscoveryFailed(int32_t subscribeId, int32_t failedReason)
{
    // 订阅失败
}

ISoftbusDiscoveryCallback g_callback = {.OnDeviceFound = OnDeviceFound,
                                        .OnDiscoverySuccess = OnDiscoverySuccess,
                                        .OnDiscoveryFailed = OnDiscoveryFailed};

if (RegisterDiscoverCallback(&g_callback) == 0) {
    // 注册成功
}

if (UnRegisterDiscoverCallback() == 0) {
    // 取消注册成功
}

（5）注册|取消注册设备状态信息监听回调接口

功能描述：开发认证管理端时用于注册|取消注册设备状态信息监听回调接口

接口：

typedef struct {
    // 当设备状态改变时调用
    void (*OnDeviceChanged)(AuthDeviceState state, const AuthDeviceInfo &info);
} ISoftbusStateCallback;

// 注册设备状态回调
// callback: 设备状态回调接口指针
// 注册设备监听回调
int32_t RegisterDeviceStateCallback(const ISoftbusStateCallback *callback);

// 取消设备状态回调注册
// 注销之前注册的设备状态回调
int32_t UnRegisterDeviceStateCallback();

请求参数：

参数名 类型 是否必填 描述
callback const ISoftbusStateCallback* 是 设备状态回调接口指针

返回值：成功返回0

使用说明：

// 包含头文件
#include <device_manager_center.h>

static void OnDeviceChanged(AuthDeviceState state, const AuthDeviceInfo &info)
{
    switch ((int)state) {
        case (int)AuthDeviceState::DEVICE_STATE_ONLINE: {
            // 设备上线
        } break;
        case (int)AuthDeviceState::DEVICE_STATE_OFFLINE: {
            // 设备下线
        } break;
        case (int)AuthDeviceState::DEVICE_INFO_CHANGED: {
            // 设备信息改变
        } break;
    }
}

static ISoftbusStateCallback g_ callback = {.OnDeviceChanged = OnDeviceChanged};

if (RegisterDeviceStateCallback(&g_callback) == 0) {
    // 注册成功
}

if (UnRegisterDeviceStateCallback() == 0) {
    // 取消注册成功
}

（6）注册|取消注册设备认证UI更新回调接口

功能描述：开发认证管理端时用于注册|取消注册设备认证过程中的用户交互操作回调接口

接口：

typedef struct {
    // 当授权状态改变时调用 
    void (*OnShowAuthState)(int32_t msgType);
    // 当授权信息展示需要更新时调用 
    void (*OnShowAuthInfo)(int32_t code);
    // 当用户进行操作时调用，返回值决定后续操作 
    int32_t (*OnUserOperation)(const char *remoteName);
    // 当需要取消显示时调用 
    void (*OnCancelDisplay)();
    // 当需要输入授权信息时调用，返回值决定是否继续 
    std::string (*OnInputAuthInfo)();
    // 认证凭据错误，需要重新输入时调用 
    std::string (*OnAuthInfoError)(int32_t availableNum);
} IUIStateUpdateCallback;

// 注册UI状态回调
// callback: UI状态更新回调接口指针
// 注册UI更新回调
int32_t RegisterUIStateCallback(const IUIStateUpdateCallback *callback);

// 取消UI状态回调注册
// 注销之前注册的UI状态回调
int32_t UnRegisterUIStateCallback();

请求参数：

参数名 类型 是否必填 描述
callback const IUIStateUpdateCallback* 是 UI状态更新回调接口指针

返回值：成功返回0

使用说明：

// 包含头文件
#include <device_manager_center.h>

void OnShowAuthState(int32_t msgType)
{
    // 认证状态切换
    switch ((UiStateMsg)msgType) {
        case UiStateMsg::MSG_PIN_CODE_ERROR:
            // 认证凭据输入错误
            break;
        case UiStateMsg::MSG_PIN_CODE_SUCCESS:
            // 认证成功
            break;
        case UiStateMsg::MSG_CANCEL_PIN_CODE_SHOW:
            // 取消认证凭据显示
            break;
        case UiStateMsg::MSG_CANCEL_PIN_CODE_INPUT:
            // 取消认证凭据输入
            break;
        case UiStateMsg::MSG_DOING_AUTH:
            // 认证结束
            break;
        default:
            break;
    }
}

void OnShowAuthInfo(int32_t code)
{
    // 认证凭据显示
}

int32_t OnUserOperation(const char *remoteName)
{
    // 认证用户授权
    // remoteName：请求端设备名
    // 同意：返回0，拒绝：返回-1
}

void OnCancelDisplay()
{
    // 取消UI显示
}

std::string OnInputAuthInfo()
{
    // 输入设备认证凭据
    // 将输入结果返回
}

std::string OnAuthInfoError(int32_t num)
{
   // 认证凭据输入错误，重新输入
   // num：输入错误次数，最多3次
   // 将重新输入结果返回
}

static IUIStateUpdateCallback g_callback = {.OnShowAuthState = OnShowAuthState,
                                            .OnShowAuthInfo = OnShowAuthInfo,
                                            .OnUserOperation = OnUserOperation,
                                            .OnCancelDisplay = OnCancelDisplay,
                                            .OnInputAuthInfo = OnInputAuthInfo,
                                            .OnAuthInfoError= OnAuthInfoError};

if (RegisterUIStateCallback(&g_callback) == 0) {
    // 注册成功
}

if (UnRegisterUIStateCallback() == 0) {
    // 取消注册成功
}

（7）注册|取消注册设备认证处理回调接口

功能描述：开发认证管理端时用于注册|取消注册设备认证过程中一些额外处理回调接口

接口：

typedef struct {
    // 当授权结果改变时调用此函数
    // deviceId: 设备ID
    // token: 授权令牌
    // status: 授权状态
    // reason: 授权失败的原因
    void (*OnAuthResult)(const std::string &deviceId, const std::string &token, int32_t status, int32_t reason);

    // 检查设备序列号是否有效
    // 这个函数接受一个字符串类型的设备序列号，并返回一个布尔值
    // 如果设备序列号有效，返回 true；否则返回 false
    bool (*OnCheckDeviceSNVaild)(const std::string &deviceSn);

    // 定义一个函数指针类型，该函数指针指向一个无参数的函数
    // 该函数返回一个对std::string的引用
    // 该函数指针类型的名称是OnGetAuthCredential
    std::string (*OnGetAuthCredential)();
} IAuthResultCallback;

// 注册认证结果回调
// callback: 认证处理回调接口指针
// 注册认证结果回调
int32_t RegisterAuthResultCallback(const IAuthResultCallback *callback);

// 取消认证结果回调注册
// 注销之前注册的认证结果回调
int32_t UnRegisterAuthResultCallback();

请求参数：

参数名 类型 是否必填 描述
callback const IAuthResultCallback* 是 认证处理回调接口指针

返回值：成功返回0

使用说明：

// 包含头文件
#include <device_manager_center.h>

static void OnAuthResult(const std::string &deviceId, const std::string &token, int32_t status, int32_t reason)
{
    // 认证结果处理
    // 暂时不需要进行处理
}

static bool OnCheckDeviceSNVaild(const std::string &deviceSn)
{
    // SN认证检查
    // deviceSn请求设备的SN号，校验是否需要信任
    // 信任：返回true，不信任：返回false
}

std::string OnGetAuthCredential()
{
    // 生成本地认证凭据
    // 返回生成结果
}

static IAuthResultCallback s_authResultCb = {
                .OnAuthResult = OnAuthResult,
                .OnCheckDeviceSNVaild = OnCheckDeviceSNVaild,
                .OnGetAuthCredential = OnGetAuthCredential};

if (RegisterAuthResultCallback(&g_callback) == 0) {
    // 注册成功
}

if (UnRegisterAuthResultCallback() == 0) {
    // 取消注册成功
}

（8）获取本机信息接口

功能描述：获取本设备的可用信息。

接口：

typedef struct AuthDeviceInfo {
    // 设备ID。
    // 在设备管理中心唯一标识设备。
    char deviceId[DEV_CENTER_MAX_DEVICE_ID_LEN];
    // 设备名称。
    // 用于给设备一个可读的名称。
    char deviceName[DEV_CENTER_MAX_DEVICE_NAME_LEN];
    // 设备类型。
    // DEVICE_TYPE_PC：电脑
    // DEVICE_TYPE_PHONE：手机
    // 标识设备的类型。
    uint16_t deviceTypeId;
    // 网络ID。
    // 标识设备所属的网络。
    char networkId[DEV_CENTER_MAX_DEVICE_ID_LEN];
    // 发现设备的距离。
    // 表示从发现点到设备的物理距离。
    // 暂不可用
    int32_t range;
    // 网络类型。
    // 描述设备连接的网络类型。
    int32_t networkType;
    // 设备认证形式。
    // 描述设备的认证方式。
    AuthForm authForm;
    // 对端IP地址，字符串格式。
    // 可以是点分十进制表示的IPv4地址或冒号分隔的十六进制表示的IPv6地址。
    char peerAddr[IP_STR_MAX_LEN];
    // 设备功能映射。
    // 存储设备支持的功能列表。
    uint32_t capabilityMap[DEV_CAPABILITY_MAX];
} AuthDeviceInfo;

int32_t GetLocalDeviceInfo(AuthDeviceInfo &info);

请求参数：

参数名 类型 是否必填 描述
info AuthDeviceInfo & 是 输出参数，输出设备信息

返回值：成功返回0

使用说明：

// 包含头文件
#include <device_manager_center.h>

AuthDeviceInfo g_local_deviceinfo;

if (GetLocalDeviceInfo(PKG_NAME, &g_local_deviceinfo) == 0) 
{
    // 获取信息成功
}

（9）发布|取消发布设备能力接口

功能描述：开发认证管理端时用于发布|取消发布业务能力信息，设备收到广播后会将业务能力推送。

接口：

typedef struct {
    // 服务ID 
    int publishId;
    // 服务发布的发现模式
    DiscoverMode mode;
    // 服务发布的交换介质，目前仅支持WIFI 
    ExchangeMedium medium;
    // 服务发布的交换频率
    ExchangeFreq freq;
    // 服务发布的能力 
    const char *capability;
    // 服务发布的能力数据，必须为C字符串格式
    unsigned char *capabilityData;
    // 服务发布的能力数据的最大长度（512字节） 
    unsigned int dataLen;
    // 设备是否应被发现者测距
    bool ranging;
} PublishInfo;

// 发布设备发现服务
// publishInfo: 发布信息结构体指针
// 发布设备发现服务
int32_t PublishDeviceDiscovery(const PublishInfo &publishInfo);

// 取消发布设备发现服务
// publishId: 发布服务的ID
// 取消发布设备发现服务
int32_t UnPublishDeviceDiscovery(int32_t publishId);

请求参数：

参数名 类型 是否必填 描述
发布 publishInfo const PublishInfo & 是 发布信息结构体指针
取消发布 publishId int32_t 是 发布服务的ID

返回值：成功返回0

使用说明：

// 包含头文件
#include <device_manager_center.h>

PublishInfo g_info = {
        .publishId = 100,
        .mode = DISCOVER_MODE_ACTIVE,
        .medium = COAP,
        .freq = HIGH,
        .capability = CAPABILITY,
        .capabilityData = nullptr,
        .dataLen = 0,
        .ranging = true};
      
if (PublishDeviceDiscovery(g_Info) == 0) 
{
    // 发布成功
}

if (UnPublishDeviceDiscovery(100) == 0) {
    // 取消发布成功
}

（10）订阅|设备能力接口

功能描述：开发认证管理端时用于订阅发现/停止发现附近设备的能力

接口：

// 订阅信息
typedef struct {
    // 服务ID
    int subscribeId;
    // 服务订阅的发现模式
    DiscoverMode mode;
    // 服务订阅的传输介质
    ExchangeMedium medium;
    // 服务订阅的频率
    ExchangeFreq freq;
    // 是否仅查找相同账户的设备
    bool isSameAccount;
    // 是否查找休眠设备
    bool isWakeRemote;
    // 服务订阅的能力
    const char *capability;
    // 服务订阅的能力数据，必须为C字符串格式
    unsigned char *capabilityData;
    // 服务订阅的能力数据的最大长度（512字节）
    unsigned int dataLen;
} SubscribeInfo;

// 发现通知回调
typedef struct {
    // 发现设备通知
    void (*OnDeviceFound)(const AuthDeviceInfo &info, bool isOnline);
    // 订阅成功通知
    void (*OnDiscoverySuccess)(int32_t subscribeId);
    // 订阅失败通知
    void (*OnDiscoveryFailed)(int32_t subscribeId, int32_t failedReason);
} ISoftbusDiscoveryCallback;

// 订阅发现
int32_t StartDeviceDiscovery(const SubscribeInfo &subscribeInfo);
// 停止发现
int32_t StopDeviceDiscovery(int32_t subscribeId);

请求参数：

参数名 类型 是否必填 描述
订阅 subscribeInfo const SubscribeInfo & 是 订阅信息
取消订阅 subscribeId int32_t 是 订阅ID

返回值：成功返回0

使用说明：

// 包含头文件
#include <device_manager_center.h>

SubscribeInfo g_Info = {.subscribeId = 101,
                              .mode = DiscoverMode::DISCOVER_MODE_ACTIVE,
                              .medium = ExchangeMedium::COAP,
                              .freq = ExchangeFreq::HIGH,
                              .isSameAccount = false,
                              .isWakeRemote = false,
                              .capability = CAPABILITY,
                              .capabilityData = nullptr,
                              .dataLen = 0};

if (StartDeviceDiscovery(g_Info) == 0) 
{
    // 订阅成功
}

if (StopDeviceDiscovery (101) == 0) {
    // 取消订阅成功
}

（11）认证|取消认证设备接口

功能描述：开发认证管理端时用于对已发现设备进行可信认证|取消认证，使用时需提前注册UI操作接口，见上文。

接口：

// 开始设备认证
// deviceId: 需要认证的设备ID
// authType: 认证类型 远程SN认证|Pincode认证|本地SN号认证
int32_t AuthenticateDevice(const std::string &deviceId, DeviceAuthType authType);

// 删除认证设备
// networkId: 设备的网络ID
int32_t UnAuthenticateDevice(const std::string &networkId);

请求参数：

参数名 类型 是否必填 描述
认证 deviceId const std::string & 是 设备ID，由设备发现的AuthDeviceInfo数据中提供
authType DeviceAuthType 是 认证类型
取消认证 networkId const std::string & 是 已认证后获取的网络ID

返回值：成功返回0

使用说明：

// 包含头文件
#include <device_manager_center.h>

if (AuthenticateDevice(deviceId, authType) == 0)
{     
    // 认证操作成功
}

if (UnAuthenticateDevice(networkId) == 0){     
    // 删除可信设备操作成功
}

（12）获取可信设备列表接口

功能描述：开发认证管理端时用于获取附近所有可信任设备信息列表

接口：

// 获取可信设备列表
// 返回值: 可信设备列表指针和列表数量
// 注意：调用者需要释放返回的列表内存
int32_t GetTrustedDeviceList(AuthDeviceInfo **info, int *infoNum);

请求参数：

参数名 类型 是否必填 描述
deviceInfo AuthDeviceInfo ** 是 输出参数，可信设备列表信息
infoNum int * 是 输出参数，设备数量

返回值：成功返回0

使用说明：

// 包含头文件
#include <device_manager_center.h>

int devNum = 0;
AuthDeviceInfo *deviceInfo = nullptr;
if (GetTrustedDeviceList(PKG_NAME, &deviceInfo, &devNum) == 0)
{     
    // 获取成功
}

// 释放
free(deviceInfo)

（13）创建会话传输接口

功能描述：业务侧创建会话传输

接口：

// 会话管理通知回调
typedef struct {    
    // 会话已打开通知    
    int (*OnSessionOpened)(int sessionId, int result);    
    // 会话已关闭通知    
    void (*OnSessionClosed)(int sessionId);    
    // 收到字节数据通知    
    void (*OnBytesReceived)(int sessionId, const void *data, unsigned int dataLen);    
    // 收到消息数据通知    
    void (*OnMessageReceived)(int sessionId, const void *data, unsigned int dataLen);    
    // 收到流数据通知    
    void (*OnStreamReceived)(int sessionId, const StreamData *data, const StreamData *ext, const StreamFrameInfo *param);    
    // 暂未开发    
    void (*OnQosEvent)(int sessionId, int eventId, int tvCount, const QosTv *tvList);
} ISessionListener;

int CreateSessionServer(const char *pkgName, const char *sessionName, const ISessionListener *listener, bool isProxy);

请求参数：

参数名 类型 是否必填 描述
pkgName const char * 是 业务侧应用名
sessionName const char * 是 会话名
listener const ISessionListener * 是 会话管理通知回调函数
isProxy bool 是 填入true

返回值：成功返回0，失败返回-1

使用说明：

使用session传输之前，确保需要传输的设备全部创建session节点，session的名称确保一致。只需一段打开session即可进行通道创建。

// 包含头文件
#include <session.h>

const char *PKG_NAME = "test";
const char *SESSION_TEST_NAME = "test.session";

int32_t OnSessionOpened(int32_t sessionId, int32_t result)
{    
    // 会话已打开
}

void OnSessionClosed(int32_t sessionId)
{    
    // 会话已关闭
}

void OnBytesReceived(int32_t sessionId, const void *data, uint32_t dataLen)
{    
    // 处理字节数据
}

void OnStreamReceived(int32_t sessionId, const StreamData *data, const StreamData *ext, const StreamFrameInfo *frameInfo)
{    
    // 处理流数据
}

void OnMessageReceived(int sessionId, const void *data, unsigned int dataLen)
{    
    // 处理消息数据
}

void OnQosEvent(int sessionId, int eventId, int tvCount, const QosTv *tvList)
{    
    // 暂未开发
}

ISessionListener s_sessionListener = {.OnSessionOpened = OnSessionOpened,
                                      .OnSessionClosed = OnSessionClosed,
                                      .OnBytesReceived = OnBytesReceived,
                                      .OnMessageReceived = OnMessageReceived,
                                      .OnStreamReceived = OnStreamReceived,
                                      .OnQosEvent = OnQosEvent};

if (CreateSessionServer(PKG_NAME, SESSION_TEST_NAME, &s_sessionListener, true) == 0) {     
    // 创建成功
}

（14）删除会话传输接口

功能描述：业务侧删除会话传输

接口：

int RemoveSessionServer(const char *pkgName, const char *sessionName);

请求参数：

参数名 类型 是否必填 描述
pkgName const char * 是 业务侧应用名
sessionName const char * 是 会话名

返回值：成功返回0，失败返回-1

使用说明：

// 包含头文件
#include <session.h>
const char *PKG_NAME = "test";
const char *SESSION_TEST_NAME = "test.session";
if (RemoveSessionServer(DEV_CENTER_PKG_NAME, SESSION_TEST_NAME) == 0){     
    // 删除会话成功
}

（15）开启会话传输接口

功能描述：业务侧打开会话传输

接口：

// 会话属性描述
typedef struct {    
    // 传输数据类型    
    int dataType;    
    // 链路数量    
    int linkTypeNum;    
    // 链路类型    
    LinkType linkType[LINK_TYPE_MAX];    
    union {        
        // 流数据类型        
        struct StreamAttr {            
            int streamType;        
        } streamAttr;    
    } attr;    
    uint8_t *fastTransData;    
    uint16_t fastTransDataSize;
} SessionAttribute;

int OpenSession(const char *mySessionName, const char *peerSessionName, const char *peerNetworkId, const char *groupId,                const SessionAttribute *attr);

请求参数：

参数名 类型 是否必填 描述
mySessionName const char * 是 业务侧应用名
peerSessionName const char * 是 连接对端设备会话名
peerNetworkId const char * 是 连接对端设备networkId
groupId const char * 是 群组ID，没有填”0”
attr const SessionAttribute * 是 会话属性描述信息

返回值：成功返回sessionId，失败返回-1

使用说明：

// 包含头文件
#include <session.h>
const char *PKG_NAME = "test";
const char *SESSION_TEST_NAME = "test.session";
SessionAttribute attr = {0};
attr.dataType = SessionType::TYPE_BYTES; // 字节数据
if (type == TYPE_STREAM) {    
    // 设置流数据格式    
    attr.attr.streamAttr.streamType = COMMON_VIDEO_STREAM;
}
attr.linkTypeNum = LINK_TYPE_MAX;
LinkType linkTypeList[LINK_TYPE_MAX] = {    
    LINK_TYPE_WIFI_P2P,    
    LINK_TYPE_WIFI_WLAN_5G,    
    LINK_TYPE_WIFI_WLAN_2G,    
    LINK_TYPE_BR,
};
int ret = memcpy(attr.linkType, linkTypeList, sizeof(attr.linkType));
if (ret != 0) {    
    // 错误    
    return ;
}
int sessionId = OpenSession(SESSION_TEST_NAME, SESSION_TEST_NAME, peerNetworkId, "0", &attr);
if (sessionId < 0) {    
    // 错误    
    return;
}
// 保存sessionId

（16）关闭会话传输接口

功能描述：业务侧关闭会话传输

接口：

void CloseSession(int sessionId);

请求参数：

参数名 类型 是否必填 描述
sessionId int 是 打开会话时返回的会话ID

返回值：无

使用说明：无

（17）发送字节数据接口

功能描述：业务侧基于打开会话的sessionId进行字节数据传输

接口：

int SendBytes(int sessionId, const void *data, unsigned int len);

请求参数：

参数名 类型 是否必填 描述
sessionId int 是 会话ID
data const void * 是 待发送的字节数据
len unsigned int 是 数据长度

返回值：成功返回0

使用说明：

// 包含头文件
#include <session.h>
const char *data = "SendBytes Test";
if (SendBytes(sessionId, data, strlen(data)) == 0) {    
    // 数据发送成功
}

（18）发送消息数据接口

功能描述：业务侧基于打开会话的sessionId进行消息数据传输

接口：

int SendMessage(int sessionId, const void *data, unsigned int len);

请求参数：

参数名 类型 是否必填 描述
sessionId int 是 会话ID
data const void * 是 待发送的消息数据
len unsigned int 是 数据长度

返回值：成功返回0

使用说明：无

（19）发送流数据接口

功能描述：业务侧基于打开会话的sessionId进行流数据传输

接口：

// 流数据描述
typedef struct {    
    // 指向用于存储流数据的缓冲区的指针    
    char *buf;    
    // 缓冲区大小    
    int bufLen; 
} StreamData;
// 帧信息
typedef struct {    
    // 帧类型    
    int frameType;    
    // 时间戳    
    int64_t timeStamp;    
    // 序列号    
    int seqNum;    
    // 切片序列号    
    int seqSubNum;    
    // 视频编码级别    
    int level;    
    // 位图    
    int bitMap;    
    int tvCount;    
    TV *tvList;
} StreamFrameInfo;
int SendStream(int sessionId, const StreamData *data, const StreamData *ext, const StreamFrameInfo *param);

请求参数：

参数名 类型 是否必填 描述
sessionId int 是 会话ID
data const StreamData * 是 待发送的流数据的指针
ext const StreamData * 是 扩展流数据指针
param const StreamFrameInfo * 是 流帧信息的指针

返回值：成功返回0

使用说明：

// 包含头文件
#include <session.h>
// 将图片转换为流数据
std::vector<uchar> buffer;
// 设置流数据指针
StreamData data = {reinterpret_cast<char *>(buffer.data()), buffer.size()};
StreamData ext = {0};
StreamFrameInfo frameInfo = {0};
if (SendStream(sessionId, &data, &ext, &frameInfo) == 0) {    
    // 流数据发送成功
}

（20）发送文件接口

功能描述：业务侧发送文件

接口：

// 文件接收管理回调函数
typedef struct {    
    // 接收到文件通知    
    int (*OnReceiveFileStarted)(int sessionId, const char *files, int fileCnt);    
    // 文件接收处理    
    int (*OnReceiveFileProcess)(int sessionId, const char *firstFile, uint64_t bytesUpload, uint64_t bytesTotal);    
    // 文件接收完成    
    void (*OnReceiveFileFinished)(int sessionId, const char *files, int fileCnt);    
    // 文件接收失败    
    void (*OnFileTransError)(int sessionId);
} IFileReceiveListener;
// 设置接收文件管理
int SetFileReceiveListener(const char *pkgName, const char *sessionName, const IFileReceiveListener *recvListener,                           const char *rootDir);
// 发送文件管理回调函数
typedef struct {    
    // 发送文件处理    
    int (*OnSendFileProcess)(int sessionId, uint64_t bytesUpload, uint64_t bytesTotal);    
    // 文件发送完成    
    int (*OnSendFileFinished)(int sessionId, const char *firstFile);    
    // 文件发送失败    
    void (*OnFileTransError)(int sessionId);
} IFileSendListener;
// 设置文件发送管理
int SetFileSendListener(const char *pkgName, const char *sessionName, const IFileSendListener *sendListener);
// 发送文件
// 如果需要使用该接口
// 在创建session之前需要
// 使用上文的SetFileReceiveListener接口设置文件接收处理
// 使用上文的SetFileSendListener接口设置文件发送处理
int SendFile(int sessionId, const char *sFileList[], const char *dFileList[], uint32_t fileCnt);

请求参数：

参数名 类型 是否必填 描述
pkgName const char * 是 业务侧应用名
sessionName const char * 是 会话名
recvListener const IFileReceiveListener * 是 接收文件管理指针
sendListener const IFileSendListener * 是 发送文件管理指针
sessionId int 是 会话ID
sFileList const char ** 是 指向要发送的源文件的指针
dFileList const char ** 是 指向目标文件的指针
fileCnt uint32_t 是 发送的文件数

返回值：成功返回0

使用说明：

// 包含头文件
#include <session.h>
const char *PKG_NAME = "test";
const char *SESSION_TEST_NAME = "test.session";
int OnSendFileProcess(int sessionId, uint64_t bytesUpload, uint64_t bytesTotal)
{    
    // bytesUpload 发送的文件大小    
    // bytesTotal 文件总大小    
    return 0;
}
int OnSendFileFinished(int sessionId, const char *firstFile)
{    
    // firstFile 发送的第一个文件指针    
    return 0;
}
void OnFileTransError(int sessionId)
{    
    // 错误处理
}
int OnReceiveFileStarted(int sessionId, const char *files, int fileCnt){    
    // files 要接受的文件的指针    
    // fileCnt 文件数量    
    return 0;
}
int OnReceiveFileProcess(int sessionId, const char *firstFile, uint64_t bytesUpload, uint64_t bytesTotal)
{    
    // 要接收的第一个文件的指针    
    // bytesUpload 接收的文件大小    
    // bytesTotal 接收文件总大小    
    return 0;
}
void OnReceiveFileFinished(int sessionId, const char *files, int fileCnt)
{    
    // files 指向接收到的文件指针    
    // fileCnt 文件数量
}
IFileSendListener g_fileSendListener = {.OnSendFileProcess = OnSendFileProcess,
                                        .OnSendFileFinished = OnSendFileFinished,
                                        .OnFileTransError = OnFileTransError};
IFileReceiveListener g_fileRecvListener = {.OnReceiveFileStarted = OnReceiveFileStarted,
                                           .OnReceiveFileProcess = OnReceiveFileProcess,
                                           .OnReceiveFileFinished = OnReceiveFileFinished,
                                           .OnFileTransError = OnFileTransError};
if (SetFileSendListener(PKG_NAME, SESSION_TEST_NAME, &g_fileSendListener) == 0) {    
    // 设置成功
}
if (SetFileReceiveListener(PKG_NAME, SESSION_TEST_NAME, &g_fileRecvListener, "/tmp/") == 0) {    
    // 设置成功
}
const char *sfileList[] = {        
    "/tmp/sessiontest/test.jpg",        
    "/tmp/sessiontest/app.png",
    "/tmp/sessiontest/pc.svg",};
if (SendFile(g_testSessionId, sfileList, NULL, 3) == 0) {    
    // 发送成功
}

（21）获取对端设备网络ID

功能描述：业务侧基于打开会话的sessionId获取对端设备网络ID

接口：

// 获取对等设备的设备ID
// sessionId 会话ID，用于标识与对等设备的会话
// networkId 网络ID字符串，用于存储获取的对等设备的设备ID
// len 网络ID字符串的最大长度
int GetPeerDeviceId(int sessionId, char *networkId, unsigned int len);

请求参数：

参数名 类型 是否必填 描述
sessionId int 是 会话ID
networkId char * 是 输出参数，获取到的对端设备网络ID
len unsigned int 是 字符长度

返回值：成功返回0

使用说明：

// 包含头文件
#include <session.h>

char networkID[65];

if (GetPeerDeviceId(sessionId, networkID, 65) == 0) {
    // 获取成功
}
关于
cc++cmake
README.md
44.4 MB
邀请码
    Gitlink（确实开源）
  • 加入我们
  • 官网邮箱：gitlink@ccf.org.cn
    • QQ群
  • QQ群
    • 公众号
  • 公众号

©Copyright 2023 CCF 开源发展委员会
Powered by Trustie& IntelliDE 京ICP备13000930号