智汇云-企业数智化核心引擎

首页> 开发者中心>SDK管理>Net SDK>Android>开发文档

## Android Net SDK开发文档

### 简介

智汇云以SDK形式提供视频本地缓存服务，可以帮助开发者快速实现预缓存的功能。SDK包含jar包、demo及开发文档。

### 功能说明

系统属性
 - Android 4.0及以上
 - CPU armeabi-v7a架构（同时兼容armeabi、arm64-v8a、x86、x86_64）

功能列表
 - 视频预缓存
 - 视频下载

### 业务流程
![image](http://p9.qhimg.com/d/inn/fd2fd1e4/t01dc6b5e3f31bd2cbf.png)

### SDK集成

#### 下载SDK

sdk下载链接：[https://zyun.360.cn/developer](https://zyun.360.cn/developer)

- jar
    - qhvc_net_sdk.jar
 - so
    - armeabi-v7a/liblocalserver.so

demo下载链接：[https://github.com/360livecloud/android_demo.git](https://github.com/360livecloud/android_demo.git)

#### 配置说明

将qhvc_net_sdk.jar放到工程libs目录下，在build.gradle中配置：
```
dependencies {
    compile fileTree(include: ['*.jar'], dir: 'libs')
}
```

将libQHVCNet.so放到工程src/main/jniLibs/armeabi-v7a/目录下，在build.gradle中配置：
```
android {
    defaultConfig {
        ndk {
            // 设置支持的CPU架构，目前只支持armeabi-v7a、arm64-v8a
            abiFilters 'armeabi-v7a'
        }

}
}
```

注：

1. 若需减小APK体积，请参考#插件化支持#

#### 权限配置

```
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
```

#### 混淆规则

```
-keep class com.qihoo.livecloud.** {
    <fields>;
    <methods>;
}

-keep class com.qihoo.videocloud.** {
    <fields>;
    <methods>;
}

-keep class net.qihoo.videocloud.** {
    <fields>;
    <methods>;
}
```

#### 调试

为便于接入时定位问题，可以在开发版本中打开logcat日志，本地缓存相关的日志TAG为QHVCNet。

```
/**
 * 设置日志级别, 日志会直接打印到logcat, Tag为 QHVCNet。该接口可以在SDK初始化前调用
 *
 * @param logLevel 日志级别, 取值{@link #LOG_NONE}, {@link #LOG_FATAL}, {@link #LOG_WARN}, {@link #LOG_INFO}, {@link #LOG_DEBUG}
 */
QHVCNet.setLogLevel(int logLevel);
```

#### SDK初始化

需要调用`QHVCSdk.getInstance().init()`，接口说明如下：

appId(也叫businessId)是为业务分配的业务ID（appId获取地址：登录[视频云官网](https://zyun.360.cn/)-控制台-SDK-应用管理-新建应用）【见下图】；version为业务端APP的版本号；machineId为设备唯一标识；uid为业务方用户标识，只要保证唯一即可。

![创建AppId截图](http://p5.qhimg.com/t011da35ea7b6063845.png)

[点此查看应用ID](https://zyun.360.cn/console/sdk/application)

> 对appId和channelID这两个参数的引入，在设计之初目的是为了每个业务有独立的ID，通过appId来获取云端的一些参数控制，特别是视频缓冲策略、P2P行为、硬解码黑白名单以及解码库类型；channelID更多的为数据统计打点的唯一标注，可以通过云点播和云直播的服务标识来获取，以此获取播放数据反馈。UserID的设计是为了业务方和视频云唯一的沟通桥梁，只要保持唯一即可，一般为用户ID的加密字符串，通过UserID可以排查到一个用户的级别的失败日志；

```
QHVCSdkConfig.Builder builder = new QHVCSdkConfig.Builder(this)
        .setAppId("businessId")
        .setAppVersion("version")
        .setMachineId("machineId")
        .setUserId("uid");

QHVCSdk.getInstance().init(builder.build());

```

#### APPID合法性验证

需要调用 `public int validityCheck(String appId, String authorization, long authTime, int randomNum, final QHVCAppAuth.ResultCallback<String> callback)`，接口说明如下：

合法性验证需要用到appId, Access Key(简称AK)和Secret Key(简称SK)。AK、SK获取地址： 登录[视频云官网](https://zyun.360.cn/)-用户中心-秘钥管理【见下图】。
只有appId、Access Key以及Secret Key相匹配，才能通过鉴权，否则将无法正常使用SDK。
![秘钥获取](http://p2.qhimg.com/t0146c3d44e71ae7a62.png)

[点此查看秘钥](https://zyun.360.cn/console/usercenter/accesskey)

==注意：此接口必须在启动APP后120秒内调用，否则将无法正常使用SDK。==

appId使用和SDK初始化时同样的内容，callback可以用来监听合法性验证结果。 计算authorization时需要使用AK、SK以及当前系统的时间戳和随机数。
**为了保证AK、SK的安全，请业务接入时，务必把AK和SK存储在服务端，并且把authorization的计算也放在服务端来做。**

计算authorization的示例代码如下：

```
    private void videocloudValidCheck() {
        int randomNum = new Random(100000000).nextInt(); //随机数
        long authTime = System.currentTimeMillis() / 1000; //时间戳 (unix时间戳（10位）)

//TODO 为了保证ak、sk的安全，请业务接入时，务必把AK和SK存储在服务端，并且把authorization的计算也放在服务端来做。
        String authorization = getServerAuthorization(appId, AK, SK, randomNum, authTime);

QHVCSdk.getInstance().validityCheck(appId, authorization, authTime, randomNum, new QHVCAppAuth.ResultCallback<String>() {

@Override
            public void onSuccess(String data) {
                Logger.i(TAG, "validityCheck onSuccess, data: " + data);
            }

@Override
            public void onFailed(int errCode, String errMsg) {
                Logger.e(TAG, "validityCheck onFailed, errCode: " + errCode + ", errMsg: " + errMsg);
            }
        });
    }

private String getServerAuthorization(String appID, String ak, String sk, int randNum, long authTime) {
        HashMap<String, String> mapParams = new HashMap<>();
        mapParams.put("appid", appID);

String strParams = getParams(mapParams);
        String paramSign = makeParamSign(strParams, randNum);
        String authString = ak + "\n" + authTime + "\n" + randNum + "\n" + paramSign;
        String encryptString = null;
        try {
            encryptString = encryptHMAC(authString, sk);
        } catch (Exception e) {
            e.printStackTrace();
        }
        Logger.i(TAG, "apiAuth(), encryptString: " + encryptString);
        return ak + ":" + encryptString;
    }

private String getParams(Map<String, String> mapParams) {
        String strParams;
        if (mapParams == null || mapParams.isEmpty()) {
            strParams = "";
        } else {
            StringBuilder sbParams = new StringBuilder();
            Object[] key_arr = mapParams.keySet().toArray();
            Arrays.sort(key_arr);/*key升序排列*/
            for (Object key : key_arr) {
                String value = mapParams.get(key);
                if (!TextUtils.isEmpty(value)) {
                    sbParams.append("&").append(key).append("=").append(value);
                }
            }
            strParams = sbParams.substring(1);
        }
        return strParams;
    }

private String makeParamSign(String param, int randNum) {
        return MD5.encryptMD5(MD5.encryptMD5(param) + randNum);
    }

public String encryptHMAC(String data, String key) throws Exception {
        final String KEY_MAC = "HmacSHA1";
        SecretKey secretKey = new SecretKeySpec(key.getBytes(), KEY_MAC);
        Mac mac = Mac.getInstance(KEY_MAC);
        mac.init(secretKey);
        byte[] rawHmac = mac.doFinal(data.getBytes());
        return Base64.encodeToString(rawHmac, Base64.DEFAULT);
    }
```

相关错误码：

```
int AUTH_OK = 1;                  //鉴权成功
int AUTH_FAILED = -11001;         //鉴权未通过（鉴权失败）
int AUTH_NOT_INVOKED = -11002;    //未调用鉴权接口
```
#### Net 初始化/销毁
```
/**
 * 初始化QHVCNet，全局只用调用一次，需要和{@link #stopLocalServer}配对使用
 *
 * @param context    context
 * @param cacheDir   缓存目录，要保证是一个当前存在且有读写权限的文件夹
 * @param deviceId   设备Id，统计上报会带上，追查问题用
 * @param businessId 业务ID
 * @param params     可选参数，可传空。参数列表：<br>
 *                   {@link #QHVC_NET_PARAM_CACHE_SIZE} 缓存占用空间大小，单位MB
 *                   {@link #QHVC_NET_PARAM_FORCE_P2P}  是否强制p2p  数据类型: Boolean
 *                   {@link #QHVC_NET_PARAM_CHANNEL_ID} channelId  数据类型: String    [当开启p2p时，必须设置]
 * @return true 初始化成功；false 初始化失败
 */
public static boolean startLocalServer(Context context, String cacheDir, String deviceId, String businessId, Map<String, Object> params);
```

其中，可选参数列表如下：

参数 | 说明 | 备注
---|---|--
QHVCNet.QHVC_NET_PARAM_CACHE_SIZE | 缓存占用空间大小，单位MB | 如果调用`QHVCNet.setCacheSize(int)`修改默认缓存占用空间大小，必须在初始化时也设置一次
QHVCNet.QHVC_NET_PARAM_FORCE_P2P  | 是否强制p2p  数据类型: Boolean |
QHVCNet.QHVC_NET_PARAM_CHANNEL_ID | channelId  数据类型: String | 当开启p2p时，必须设置

调用`QHVCNet.startLocalServer()`必须配对调用`QHVCNet.stopLocalServer()`：

```
/**
 * 销毁QHVCNet，需要和{@link #startLocalServer}配对使用
 */
QHVCNet.stopLocalServer();
```

### 接口说明

### 1. QHVCNet设置

#### 缓存占用空间

默认50M，超过设置的大小后将删除最早加入的缓存文件（如果单个视频文件大小超过设置的缓存占用空间大小，则播放结束后将自动删除该视频文件的缓存）。为避免过度占用用户手机内存卡空间，请合理设置缓存占用空间大小。

```
/**
 * 设置和调整缓存占用空间大小。这个接口可以中途调用，可以调用多次。
 *
 * @param cacheSize 缓存空间的大小，单位MB，默认50M
 * @return true 设置成功；false 设置失败
 */
QHVCNet.setCacheSize(int cacheSize);
```

业务方可随时调用`QHVCNet.clearCache()`接口清除当前占用的空间（该接口不会影响当前正在播放的任务）。

```
/**
 * 清除缓存空间（当前播放的任务不会清除）
 */
QHVCNet.clearCache();
```

#### 非WIFI网络预缓存

默认关闭，防止偷跑用户3G/4G网络流量，请谨慎开启。该接口不影响`QHVCNet.getPlayUrl()`播放的视频，仅影响`QHVCNet.doPrecache()`添加的预缓存任务。

```
/**
 * 非WIFI网络下是否允许预缓存，默认关闭，防止偷跑流量
 *
 * @param enable true 允许非WIFI网络下预缓存；false 不允许
 */
QHVCNet.enablePrecacheInMobileNetwork(boolean enable);
```

#### 禁止所有网络请求

禁止后，所有网络请求都将被禁止，主要用于非WIFI网暂停络播放时禁止预缓存的场景（LocalServer会预加载当前播放点后约4M的文件）。具体使用方法请参考DEMO中的示例。

```
/**
 * 允许或禁止LocalServer所有访问网络主动拉取数据的行为
 *
 * @param enableCache true 允许，false 禁止
 */
QHVCNet.enableCache(boolean enableCache);
```

### 2. 视频播放与预缓存

#### 视频播放

通过`QHVCNet.getPlayUrl()`接口将原始视频URL转换为QHVCNet播放的URL，如不支持，则返回原始视频URL。目前限制如下：
 - 只支持 Content-Type 为 video/* 的视频
 - 暂不支持m3u8格式的视频

**关于rid参数的说明：**
 - 原始视频URL在加防盗链机制时是可变的，无法作为唯一的视频资源标识使用
 - rid应该作为物理文件的唯一标识，而不是URL的唯一标识
 - 转码前后的视频物理文件已发生变化，rid应该不同
 - 内容相同但分辨率不同的视频物理文件不同，rid应该不同

```
/**
 * 获取走QHVCNet播放的链接
 *
 * 根据云控配置，可能返回本地缓存地址、p2p地址、本地缓存与p2p组合地址
 * 如果开启p2p, 需要在a项目中包含qhvc_p2pserver_sdk.jar
 *
 * @param rid       资源的唯一标识，由于url在加防盗链时是可变的，所以需要一个唯一标识来匹配缓存文件
 * @param originUrl 资源的链接
 * @return 返回变换后的播放链接
 */
QHVCNet.getPlayUrl(String rid, String url);
```

播放过程中，`IQHVCPlayer.setOnBufferingUpdateListener()`回调中的缓存进度是指播放器本身缓存的进度（约30s时长的数据），而非LocalServer实际缓存的进度。

```
IQHVCPlayer.setOnBufferingUpdateListener(new IQHVCPlayer.OnBufferingUpdateListener() {
    
    @Override
    public void onBufferingUpdate(int handle, int percent) {
        //此处得到的percent为播放器缓存的进度，非QHVCNet实际缓存的进度
    }
});
```

为获得QHVCNet实际缓存的进度，需要调用`QHVCNet.getFileAvailedSize()`接口获取当前播放时间点后连续可用的播放时长。假设返回结果为bufferSize，则当前QHVCNet缓存进度为：percent = (bufferSize + currentPosition) / total * 100。

```
/**
 * 查询指定的缓存在给定播放时间点后连续可用的播放时长
 *
 * @param rid 资源的唯一标识，由于url在加防盗链时是可变的，所以需要一个唯一标识来匹配缓存文件
 * @param url 资源的链接
 * @param currentPosition 播放器当前播放时间点
 * @param total 播放器播放总时长
 * @return 播放器当前播放时间点后连续可用的播放时长，失败时返回负值
 */
QHVCNet.getFileAvailedSize(String rid, String url, int currentPosition, int total);
```

#### 预缓存

为加快视频播放首屏速度，QHVCNet提供预缓存功能，业务方可以指定每个视频预缓存的大小。预缓存任务优先级低于当前播放任务，即预缓存不会影响当前视频的播放。预缓存任务并发执行，由业务方自行调度任务优先级。

```
/**
 * 添加预缓存任务
 *
 * @param rid 资源的唯一标识，由于url在加防盗链时是可变的，所以需要一个唯一标识来匹配缓存文件
 * @param url 资源的链接
 * @param preCacheSize 预缓存多少的数据量，单位KB
 * @return true 添加任务成功；false 添加任务失败
 */
QHVCNet.doPrecache(String rid, String url, int preCacheSize);
```

```
/**
 * 取消预缓存任务
 *
 * @param rid 资源的唯一标识，由于url在加防盗链时是可变的，所以需要一个唯一标识来匹配缓存文件
 * @return true 取消任务成功；false 取消任务失败
 */
QHVCNet.cancelPrecache(String rid);
```

#### 缓存进度查询

为便于业务方自行调度预缓存任务优先级，QHVCNet提供以下接口用于查询缓存任务（当前播放的视频也会被视为缓存任务）完成进度。缓存任务可能会被分段缓存，该接口返回的已完成数据量是指所有分段缓存的总和。

```
/**
 * 查询指定的缓存是否完成
 *
 * @param rid 资源的唯一标识，由于url在加防盗链时是可变的，所以需要一个唯一标识来匹配缓存文件
 * @param url 资源的链接
 * @return true 缓存完成，false 未缓存完成
 */
QHVCNet.isCacheFinished(String rid, String url);
```

```
/**
 * 查询指定的缓存已完成的数据量以及总数据量
 *
 * @param rid 资源的唯一标识，由于url在加防盗链时是可变的，所以需要一个唯一标识来匹配缓存文件
 * @param url 资源的链接
 * @param cachedSize 缓存的文件大小
 * @return true 表示成功，false 表示失败
 */
QHVCNet.getFileCachedSize(String rid, String url, CachedSize cachedSize);
```

### 3. 视频下载

QHVCNet支持视频下载功能，提供下载、暂停、恢复、取消等操作，不提供下载任务队列、优先级管理等操作。

下载任务队列需要业务方自行管理，如使用数据库持久化保存任务队列。每次APP启动后，从数据库读取任务队列，并调用`QHVCNet.rebuildPersistence()`接口重建QHVCNet下载任务队列。

```
/**
 * 重建某个缓存的持久化任务
 *
 * @param rid 资源的唯一标识，由于url在加防盗链时是可变的，所以需要一个唯一标识来匹配缓存文件
 * @param url 资源的链接
 * @param path 持久化磁盘路径
 * @return true 表示成功，否则表示失败
 */
QHVCNet.rebuildPersistence(String rid, String url, String path);
```

下载优先级需要业务方自行管理。加入QHVCNet下载列表的任务会并发下载，业务方可以通过下载相关接口实现优先级管理。如：

接口 | 场景
---|---
`QHVCNet.rebuildPersistence()` | 加入下载任务队列但不立即开始下载
`QHVCNet.cachePersistence()` | 加入下载任务队列且立即开始下载
`QHVCNet.pauseCachePersistence()` | 暂停下载
`QHVCNet.resumeCachePersistence()` | 恢复下载
`QHVCNet.cancelCachePersistence()` | 取消下载

#### 设置

使用下载功能前，需要设置下载回调接口，便于业务方接收下载状态变化、进度变化等事件，所有回调均在主线程。

```
/**
 * 设置持久化回调函数
 *
 * @param callback 缓存持久化完成的回调函数
 */
QHVCNet.setQHVCNetCachePersistenceCallback(QHVCNetCachePersistenceCallback callback);
```

```
/**
 * 持久化任务回调
 */
public interface QHVCNetCachePersistenceCallback {

/**
     * 开始下载
     *
     * @param rid 资源的唯一标识
     */
    void onStart(String rid);

/**
     * 下载进度回调
     *
     * @param rid 资源的唯一标识
     * @param position 当前已下载文件大小，单位字节
     * @param total 文件总大小，单位字节
     * @param speed 下载速度，单位字节/秒
     */
    void onProgress(String rid, long position, long total, double speed);

/**
     * 下载完成
     *
     * @param rid 资源的唯一标识
     */
    void onSuccess(String rid);

/**
     * 下载失败
     *
     * @param rid 资源的唯一标识
     * @param errCode 错误码，参见{@link #E_NOT_VIDEO}、{@link #E_FILE_IO_FAILED}等及各类HTTP错误（如400等）
     * @param errMsg 错误描述
     */
    void onFailed(String rid, int errCode, String errMsg);
}
```

#### 下载

```
/**
 * 对某个缓存开始持久化任务
 *
 * @param rid 资源的唯一标识，由于url在加防盗链时是可变的，所以需要一个唯一标识来匹配缓存文件
 * @param url 资源的链接
 * @param path 持久化磁盘路径
 * @return true 表示成功，否则表示失败
 */
QHVCNet.cachePersistence(String rid, String url, String path);
```

可以调用`QHVCNet.getCachePersistenceSize()`接口获取指定下载任务的进度。

```
/**
 * 查询某个持久化任务已完成的数据量以及总数据量
 *
 * @param rid 资源的唯一标识，由于url在加防盗链时是可变的，所以需要一个唯一标识来匹配缓存文件
 * @param cachedSize 缓存的文件大小
 * @return true 表示成功，false 表示失败
 */
QHVCNet.getCachePersistenceSize(String rid, CachedSize cachedSize);
```

#### 暂停、恢复

```
/**
 * 暂停对某个缓存的持久化任务
 * 
 * @param rid 资源的唯一标识，由于url在加防盗链时是可变的，所以需要一个唯一标识来匹配缓存文件
 * @return true 表示成功，否则表示失败
 */
QHVCNet.pauseCachePersistence(String rid);
```

```
/**
 * 恢复对某个缓存的持久化任务
 *
 * @param rid 资源的唯一标识，由于url在加防盗链时是可变的，所以需要一个唯一标识来匹配缓存文件
 * @return true 表示成功，否则表示失败
 */
QHVCNet.resumeCachePersistence(String rid);
```

#### 取消

```
/**
 * 取消对某个缓存的持久化任务
 * 
 * @param rid 资源的唯一标识，由于url在加防盗链时是可变的，所以需要一个唯一标识来匹配缓存文件
 * @param deleteFile 是否同时删除已持久化的文件
 * @return true 表示成功，否则表示失败
 */
QHVCNet.cancelCachePersistence(String rid, boolean deleteFile);
```
### 4. p2p支持

概要说明：
1. P2P功能可以通过云控来确定是否开启，以及开启的比例
2. 使用P2P需要添加qhvc_p2pserver_sdk.jar包
3. 云控的开关关闭，P2P无效，即使是本地包含jar包且调用了enableP2P
4. P2P开启的比例是用户的比例，不是播放次数的比例
5. P2P需要的so会动态下载，so没有下载完成前，P2P无效

```
/**
 * 清空P2P的缓冲
 */
QHVCNet.clearP2PCache();
```

```
/**
 * 设置P2P缓冲路径
 * @param cacheDir 缓冲路径
 */
QHVCNet.setP2PCacheDir(String cacheDir);
```

```
/**
 * 设置P2P缓冲的大小
 * @param cacheSize 缓冲大小, 单位MB
 */
QHVCNet.setP2PCacheSize(int cacheSize);
```

```
/*
 * 是否开启P2P功能，只有带了P2P的jar包，开启才有效
 * @param enable P2P是否有效
 */
void enableP2P(boolean enable);

### 5. 插件化支持

为减小APK体积，本地缓存SDK支持插件化方式接入，业务方仅需接入JAR包即可，不需要捆包带SO文件，最终APK体积预计增加25KB。

为支持插件化，业务方需要在调用`QHVCNet`任意接口前动态下载并加载插件，基本流程为：

![image](http://p2.qhimg.com/d/inn/9d7006fa/plugin_flow_chart.jpg)

```
/**
 * 设置是否自带插件，如果使用插件化方式接入，该接口必须第一个被调用
 *
 * @param defaultPluginInstalled true自带，false不自带
 */
LocalServerPlugin.getInstance().setDefaultPluginInstalled(boolean defaultPluginInstalled);
```

```
/**
 * 安装或升级插件
 *
 * @param context  context
 * @param listener 下载监听接口，若业务方需要自行实现插件下载功能，需要实现该接口
 * @param callback 回调接口
 * @return 错误码，{@link #ERROR_INSTALL_RUNNING}表示插件正在后台安装或升级，
 * {@link #ERROR_SUCCESS}表示插件开始安装或升级
 */
LocalServerPlugin.getInstance().checkInstallOrUpdatePlugin(Context context, final PluginDownloadListener listener, final PluginCallback callback);
```

```
/**
 * 加载已安装的插件
 *
 * @return 错误码，参见{@link #ERROR_UNKNOWN}等
 */
LocalServerPlugin.getInstance().loadPlugin();
```

```
/**
 * 移除插件，该接口必须在加载插件前调用方可生效
 *
 * @return 错误码，参见{@link LocalServerPlugin#ERROR_UNKNOWN}等
 */
LocalServerPlugin.getInstance().removePlugin();
```

示例：

```
public void initQHVCNetProxy(Context context) {
    final LocalServerPlugin liveCloudPlugin = LocalServerPlugin.getInstance();

//设置接入时不带插件，使用插件化方案时必须第一个调用该接口
    liveCloudPlugin.setDefaultPluginInstalled(false);

if (liveCloudPlugin.isDefaultPluginInstalled()) {
        initQHVCNet(context);
    } else if (liveCloudPlugin.isPluginInstalled()) {
        //插件已下载，必须加载后才能使用
        int result = liveCloudPlugin.loadPlugin();
        if (result == LocalServerPlugin.ERROR_SUCCESS) {
            initQHVCNet(context);
        }
    } else {
        liveCloudPlugin.checkInstallOrUpdatePlugin(context, new LocalServerPlugin.PluginCallback() {
            @Override
            public void onStart(Context context) {

}

@Override
            public void onProgress(Context context, int progress) {

}

@Override
            public void onComplete(Context context, boolean background, int result) {
                if (result == LocalServerPlugin.ERROR_SUCCESS) {
                    //插件下载完成，必须加载后才能使用
                    int loadResult = liveCloudPlugin.loadPlugin();
                    if (loadResult == LocalServerPlugin.ERROR_SUCCESS) {
                        initQHVCNet(context);
                    }
                }
            }

@Override
            public void onCancel(Context context) {

}
        });
    }
}

private void initQHVCNet(Context context) {
    Map<String, Object> params = new HashMap<>();
    params.put(QHVCNet.QHVC_NET_PARAM_CACHE_SIZE, LocalServerSettingConfig.CACHE_SIZE);
    params.put(QHVCNet.QHVC_NET_PARAM_CHANNEL_ID, SettingConfig.CHANNEL_ID);

boolean ret = QHVCNet.startLocalServer(context, "cacheDir", "deviceId", "businessId", params);
    if (ret) {
        QHVCNet.setCacheSize(LocalServerSettingConfig.CACHE_SIZE);
    }
}
```

### 注意事项

1. 如无特殊说明，所有接口均在主线程调用
2. 加防盗链或可变的URL无法作为视频的唯一标识，必须正确设置rid参数

AI大模型

AI平台

AI应用

视频

物联网

数据上云

IoT设备

账号体系

智慧城市

电商视频解决方案

教育

全屋智能

医疗

智能制造

游戏

SDK管理

电话咨询：

服务咨询

建议反馈

产品与服务

文档与社区

关于我们

关注我们

请您联系我们

小安提醒您

1对1免费 咨询智汇云专属顾问

为您量身定制产品解决方案

1对1免费咨询智汇云专属顾问