生活物联网平台提供Android版本的设备端Link Visual SDK,您可以基于该SDK开发Link Visual视频设备的直播、点播、语音对讲、抓图等功能。

Android设备端Link Visual SDK依赖如下。

依赖SDK 概述
Link Kit Android SDK 提供设备与云端的双向数据通道能力。

获取SDK

请您根据引入依赖的方法来获取Android版本的设备端Link Visual SDK,并在proguard-rules.pro文件中排除不需要被混淆的类和方法。

  • 引入依赖
    // 1. 根build.gradle添加对aliyun maven仓库的引用
    allprojects {
        repositories {
            maven {
                url "http://maven.aliyun.com/nexus/content/repositories/releases"
            }
        }
    }
    
    // 2. app build.gradle中添加依赖
    implementation 'com.aliyun.iotx:linkvisual-ipc:1.4.0'
  • 混淆配置
    # keep linkvisual
    
    -keep class com.aliyun.iotx.linkvisualipc.** { *; }

初始化SDK

请在Link SDK初始化完毕后再初始化Link Visual SDK,初始化时需要传入设备证书信息。

LinkKit.getInstance().init(this, params, new ILinkKitConnectListener() {
            @Override
            public void onError(AError error) {
                Log.d(TAG,
                    "onError() called with: error = [" + (error == null ? "null" : (error.getCode() + error.getMsg()))
                        + "]");

            }

            @Override
            public void onInitDone(Object data) {
                Log.d(TAG, "onInitDone() called with: data = [" + JSON.toJSONString(data) + "]");
                // 初始化SDK
                IPCDev.getInstance().init(context, your_productKey, your_deviceName, your_deviceSecret);
            }

其中your_productnameyour_devicenameyour_devicesecret需要替换为您自己的设备证书信息。

Link Visual SDK需借助Link kit的能力来完成消息监听和处理。注册监听的流程如下。

  1. 设备服务中注册异步服务调用监听器。
    //注册异步服务调用监听器
    LinkKit.getInstance().getDeviceThing().setServiceHandler(service.getIdentifier(),
                    itResRequestHandler);
    //异步服务调用监听器
    private ITResRequestHandler itResRequestHandler = new ITResRequestHandler() {
            @Override
            public void onProcess(String identify, Object result, ITResResponseCallback
                itResResponseCallback) {
                Log.d(TAG,
                    "ITResRequestHandler  onProcess() called with: identify = [" + identify + "], result = ["
                        + JSON.toJSONString(result) + "], itResResponseCallback = ["
                        + itResResponseCallback + "]");
                /**
                 * 添加SDK对异步服务调用的监听
                 */
                IPCDev.getInstance().notifyAsyncTopicReceived(identify, result, itResResponseCallback);
            }
    
            @Override
            public void onSuccess(Object o, OutputParams outputParams) {
                Log.d(TAG,
                    "onSuccess() called with: o = [" + JSON.toJSONString(o) + "], outputParams = [" + JSON
                        .toJSONString(outputParams) + "]");
            }
    
            @Override
            public void onFail(Object o, ErrorInfo errorInfo) {
                Log.d(TAG, "onFail() called with: o = [" + JSON.toJSONString(o) + "], errorInfo = [" + JSON
                    .toJSONString(errorInfo) + "]");
            }
        };
  2. 注册同步服务调用的监听器。
    /**
     * 注册同步服务调用的监听器
     */
    LinkKit.getInstance().registerOnPushListener(connectNotifyListener);
    //同步服务调用监听器
    private IConnectNotifyListener connectNotifyListener = new IConnectNotifyListener() {
            @Override
            public void onNotify(String connectId, String topic, AMessage aMessage) {
                /**
                 * 添加SDK对同步服务调用的监听
                 */
                IPCDev.getInstance().notifySyncTopicReceived(connectId, topic, aMessage);
    
                if (CONNECT_ID.equals(connectId) && !TextUtils.isEmpty(topic) &&
                    topic.startsWith("/sys/" + productKey + "/" + deviceName + "/rrpc/request")) {
                    Log.d(TAG, "IConnectNotifyListener   onNotify() called with: connectId = [" + connectId + "], topic = ["
                        + topic + "], aMessage = ["
                        + new String((byte[])aMessage.data) + "]");
                }
            }
    
            @Override
            public boolean shouldHandle(String connectId, String topic) {
                return true;
            }
    
            @Override
            public void onConnectStateChange(String connectId, ConnectState connectState) {
    
            }
        };

开发直播功能

直播通过RTMP推流,视频支持H264、H265,音频支持G711a以及AAC_LC格式。您可以按以下步骤开发直播功能的推流。

  1. 注册直播事件监听器和流错误监听器。
    Link Visual SDK收到服务端下发的开始推流指令后,会通过事先注册的直播流事件监听器(OnLiveStreamListener)来通知何时开始或结束推流、强制I帧等。 该流程开发如下所示。
    1. 设置直播流事件监听。
      // 设置直播流事件监听
      IPCDev.getInstance().getIpcStreamManager().setOnLiveStreamListener(MainActivity.this);
      // 设置流错误监听
      IPCDev.getInstance().getIpcStreamManager().setOnStreamErrorListener(MainActivity.this);
    2. 接收服务端发送的开始推直播流请求。
      public interface OnLiveStreamListener {
          /**
           * 收到开始推直播流请求
           *
           * @param streamId   流ID
           * @param streamType 码流类型: 0为主码流, 1为辅码流
           * @param preTimeInS 预先录制时间,单位S
           */
          void onStartPushLiveStreaming(final int streamId, final int streamType, final int preTimeInS);
      
          /**
           * 收到停止推流请求
           *
           * @param streamId 流ID
           */
          void onStopPushStreaming(final int streamId);
      
          /**
           * 收到强制I帧请求
           * 需立即构造一个I帧并发送
           * @param streamId 流ID
           */
          void onForceIFrame(int streamId);
      }

    推流中发生的错误也将通过流错误监听器来通知。请不要在回调接口中执行阻塞任务。

    public interface OnStreamErrorListener {
        /**
         * 流异常时回调
         * @param streamId
         * @param error 参考StreamError定义
         */
        void onError(int streamId, StreamError error);
    }

    流错误码如下所示。

    错误码 标志符 错误描述
    1 StreamError.ERROR_STREAM_CREATE_FAILED 创建流实例失败。
    2 StreamError.ERROR_STREAM_START_FAILED 开流失败。
    3 StreamError.ERROR_STREAM_STOP_FAILED 停止流失败。
    4 StreamError.ERROR_STREAM_SEND_VIDEO_FAILED 发送视频数据失败。
    5 StreamError.ERROR_STREAM_SEND_AUDIO_FAILED 发送音频数据失败。
    6 StreamError.ERROR_STREAM_INVALID_PARAMS 无效的流参数。

    RTMP错误码如下所示。

    错误码 标志符 描述
    -1 RTMP_ILLEGAL_INPUT 输入不合法,请检查输入参数。
    -2 RTMP_MALLOC_FAILED 内存分配失败。
    -3 RTMP_CONNECT_FAILED RTMP建连失败。
    -4 RTMP_IS_DISCONNECTED RTMP连接未建立。
    -5 RTMP_UNSUPPORT_FORMAT 不支持的音视频格式。
    -6 RTMP_SEND_FAILED RTMP数据包发送失败。
    -7 RTMP_READ_MESSAGE_FAILED RTMP消息读取失败。
    -8 RTMP_READ_TIMESTAMP_ERROR 输入时间戳错误。
  2. 处理开始直播推流请求。
    1. 当服务端下发推流请求时,回调OnLiveStreamListener.onStartPushLiveStreaming(int streamId, int streamType, int preTimeInS)方法来通知设备端需要开始采流并推流。

      一般需要开启摄像头和录音机进行采流,对摄像头采集的数据调用MediaCodec进行H264编码,对录音机采集的数据进行G711a编码,提前设置对应格式的音视频参数,分别调用发送音视频的接口来持续发送采集到编码后的数据。

      @Override
          public void onStartPushLiveStreaming(int streamId, int streamType, int preTimeInS) {
              this.streamId = streamId;
              try {
      
                  // 构造视频参数
                  VideoStreamParams videoStreamParams = new VideoStreamParams();
                  // 直播流该参数始终为0
                  videoStreamParams.setDurationInS(0); 
                  videoStreamParams.setVideoFormat(VideoStreamParams.VIDEO_FORMAT_H264);
      
                  // 构造音频参数
                  AudioStreamParams audioStreamParams = new AudioStreamParams();
                  audioStreamParams.setAudioChannel(AudioStreamParams.AUDIO_CHANNEL_MONO);
                  audioStreamParams.setAudioFormat(AudioStreamParams.AUDIO_FORMAT_G711A);
                  audioStreamParams.setAudioEncoding(AudioStreamParams.AUDIO_ENCODING_16BIT);
                  audioStreamParams.setAudioSampleRate(AudioStreamParams.AUDIO_SAMPLE_RATE_8000);
      
                  // 设置推流参数
                  IPCDev.getInstance().getIpcStreamManager().setStreamParams(streamId, videoStreamParams, audioStreamParams);
      
                  // TODO 开始采流、编码并发送音视频数据            
              } catch (NoSuchStreamException e) {
                  e.printStackTrace();
              }
          }
    2. 发送音视频数据接口(IPCStreamManager)。
           /**
           * 发送音频帧数据
           *
           * @param streamId         流ID
           * @param directByteBuffer 源数据
           * @param length           数据长度
           * @param timeStampInMs    音频帧时间戳,单位ms
           */
           void sendAudioData(int streamId, ByteBuffer directByteBuffer, int length, long timeStampInMs) throws NoSuchStreamException
          /**
           * 发送视频帧数据
           *
           * @param streamId         流ID
           * @param directByteBuffer 源数据
           * @param length           数据长度
           * @param isIFrame         是否为I帧
           * @param timeStampInMs    视频帧时间戳,单位ms
           */
          void sendVideoData(int streamId, ByteBuffer directByteBuffer, int length, boolean isIFrame, long timeStampInMs) throws NoSuchStreamException
      
           /**
           * 发送音频帧数据
           *
           * @param streamId      流ID
           * @param data          源数据
           * @param offset        偏移量
           * @param length        数据长度
           * @param timeStampInMs 音频帧时间戳,单位ms
           * @deprecated 使用 {@link #sendAudioData(int, ByteBuffer, int, long)}来替换
           */
          @Deprecated
          void sendAudioData(int streamId, byte[] data, int offset, int length, long timeStampInMs) throws NoSuchStreamException
      
          /**
           * 发送视频帧数据
           *
           * @param streamId      流ID
           * @param data          源数据
           * @param offset        偏移量
           * @param length        数据长度
           * @param isIFrame      是否为I帧
           * @param timeStampInMs 视频帧时间戳,单位ms
           * @deprecated 使用 {@link #sendVideoData(int, ByteBuffer, int, boolean, long)}来替换
           */
          @Deprecated
          public void sendVideoData(int streamId, byte[] data, int offset, int length, boolean isIFrame, long timeStampInMs) throws NoSuchStreamException
      								
    3. 打印I帧的前256个字节,并查看结果。
      H264、H265的帧结构会有一定的要求,可以打印I帧的前256个字节查看,打印代码如下。
      for (int i = 0; i < ((buffer_size > 256)?256:buffer_size); i++) {
          printf("%02x ", buffer[i]);
          if ((i + 1) % 30 == 0) {
              printf("\n");
          }
      }
      printf("\n");

      H264、H265的帧结构的说明如下。

      • H264

        H264要求I帧为:帧分隔符+SPS+帧分隔符+PPS+帧分隔符+IDR,其中,0x000001或者0x00000001是帧分隔符,0x67是SPS的开始,0x68是PPS的开始,0x65是IDR的开始。如下图所示。

        I帧
      • H265

        H265要求I帧为:帧分隔符+VPS+帧分隔符+SPS+帧分隔符+PPS+帧分隔符+IDR,其中,0x000001或者0x00000001是帧分隔符,0x40是VPS的开始,0x42是SPS的开始,0x44是PPS的开始,0x26是IDR的开始。如下图所示。

        I帧
  3. 处理结束推流请求。
    当服务端下发停止推流请求时,回调OnLiveStreamListener.onStopPushLiveStreaming()方法来通知设备端停止推流。

    一般需要停止摄像头数据和录音机数据的采集,并调用IPCStreamManager的stopStreaming(int streamId)方法。

    /**
         * 收到停止推流请求
         *
         * @param streamId 流ID
         */
        @Override
        public void onStopPushStreaming(int streamId) {
            // TODO 停止音视频数据的发送
            try {
                // 调用停止推流接口
                IPCDev.getInstance().getIpcStreamManager().stopStreaming(streamId);
            } catch (NoSuchStreamException e) {
                e.printStackTrace();
            }
        }
  4. 处理流错误。
    推流过程中需要处理流错误,通过OnStreamErrorListener.onError(int streamId, StreamError error)来接收和处理。

开发点播功能

点播通过RTMP推流,视频支持H264/H265,音频支持G711a以及AAC_LC格式。请根据以下步骤来开发点播功能的推流。

  1. 注册点播事件监听器和流错误监听器。
    SDK收到服务端下发的开始推流指令后,会通过事先注册的点播流事件监听器(OnVodStreamListener)来通知何时开始或结束推流/暂停/恢复/seek等。

    推流中发生的错误也将通过流错误监听器来通知。请不要在回调接口中执行阻塞任务。

  2. 处理查询设备端录像列表请求。
    App端发起查询设备端录像列表的请求,设备端会收到同步服务调用(rrpc/request),收到查询设备录像列表请求,响应该请求将当查询范围内的文件列表返回给App端。
    @Override
            public void onNotify(String connectId, String topic, AMessage aMessage) {
                Log.d(TAG, "onNotify() called with: connectId = [" + connectId + "], topic = [" + topic + "], aMessage = ["
                        + new String((byte[]) aMessage.data) + "]");
                /**
                 * 添加SDK的监听。
                 */
                IPCDev.getInstance().notifySyncTopicReceived(connectId, topic, aMessage);
    
                // 处理同步服务调用
                if (CONNECT_ID.equals(connectId) && !TextUtils.isEmpty(topic) &&
                        topic.contains("rrpc")) {
                    Log.d(TAG, "IConnectNotifyListener   onNotify() called with: connectId = [" + connectId + "], topic = ["
                            + topic + "], aMessage = ["
                            + new String((byte[]) aMessage.data) + "]");
    
                    int code = 200;
                    String data = "{}";
    
                    JSONObject json = JSON.parseObject(new String((byte[]) aMessage.data));
                    if (json != null) {
                        String method = json.getString("method");
                        JSONObject params = json.getJSONObject("params");
                        switch (method) {
                            // 查询设备录像列表请求
                            case "thing.service.QueryRecordList":
                                int beginTime = params.getIntValue("BeginTime");
                                int endTime = params.getIntValue("EndTime");
                                int querySize = params.getIntValue("QuerySize");
                                int type = params.getIntValue("Type");
                                appendLog("收到查询设备录像列表的请求: beginTime=" + beginTime +
                                        "\tendTime=" + endTime + "\tquerySize=" + querySize + "\ttype=" + type);
    
                                JSONArray resultArray = new JSONArray();
                                JSONObject item1 = new JSONObject();
                                item1.put("FileName", Base64.encode("file1".getBytes(), Base64.DEFAULT));
                                item1.put("BeginTime", System.currentTimeMillis() / 1000 - 200);
                                item1.put("EndTime", System.currentTimeMillis() / 1000 - 100);
                                item1.put("Size", 1024000);
                                item1.put("Type", 0);
                                resultArray.add(item1);
    
                                JSONObject item2 = new JSONObject();
                                item2.put("FileName", Base64.encode("file2".getBytes(), Base64.DEFAULT));
                                item2.put("BeginTime", System.currentTimeMillis() / 1000 - 100);
                                item2.put("EndTime", System.currentTimeMillis() / 1000);
                                item2.put("Size", 1024000);
                                item2.put("Type", 0);
                                resultArray.add(item2);
    
                                JSONObject result = new JSONObject();
                                result.put("RecordList", resultArray);
    
                                code = 200;
                                data = result.toJSONString();
                                break;
                            default:
                                break;
                        }
                    }
    
                    MqttPublishRequest request = new MqttPublishRequest();
                    request.isRPC = false;
                    request.topic = topic.replace("request", "response");
                    String resId = topic.substring(topic.indexOf("rrpc/request/") + 13);
                    request.msgId = resId;
                    request.payloadObj = "{\"id\":\"" + resId + "\", \"code\":" + code + ",\"data\":" + data + "}";
                    LinkKit.getInstance().publish(request, new IConnectSendListener() {
                        @Override
                        public void onResponse(ARequest aRequest, AResponse aResponse) {
                            appendLog("上报成功");
                        }
    
                        @Override
                        public void onFailure(ARequest aRequest, AError aError) {
                            appendLog("上报失败:" + aError.toString());
                        }
                    });
                }
            }
    注意 文件名需使用Base64进行编码。
  3. 处理开始开始推流指令。
    App端请求上一步返回的列表中某个设备录像文件后,服务端会下发推流指令,回调OnVodStreamListener.onStartPushVodStreaming(int streamId, String fileName)OnVodStreamListener.onStartPushVodStreaming(int streamId, int beginTimeUtc, int endTimeUtc)方法来通知设备端需要将音视频数据推流。
    • 按文件方式播放设备端录像的响应
          @Override
          public void onStartPushVodStreaming(int streamId, String fileName) {
              appendLog("开始推点播流 " + streamId + " 文件名:" + new String(Base64.decode(fileName, Base64.NO_WRAP)));
      
              try {
                  // 构造视频参数
                  VideoStreamParams videoStreamParams = new VideoStreamParams();
                  // 该视频文件的时长,单位S
                  videoStreamParams.setDurationInS(H264_DURATION_IN_S);
                  videoStreamParams.setVideoFormat(VideoStreamParams.VIDEO_FORMAT_H264);
      
                  // 构造音频参数
                  AudioStreamParams audioStreamParams = new AudioStreamParams();
                  audioStreamParams.setAudioChannel(AudioStreamParams.AUDIO_CHANNEL_MONO);
                  audioStreamParams.setAudioFormat(AudioStreamParams.AUDIO_FORMAT_G711A);
                  audioStreamParams.setAudioEncoding(AudioStreamParams.AUDIO_ENCODING_16BIT);
                  audioStreamParams.setAudioSampleRate(AudioStreamParams.AUDIO_SAMPLE_RATE_8000);
      
                  // 设置推流参数
                  IPCDev.getInstance().getIpcStreamManager().setStreamParams(streamId, videoStreamParams, audioStreamParams);
      
                  // TODO 读取fileName文件,调用发送音视频数据接口进行推流
                  // 文件推流完毕后应调用 IPCDev.getInstance().getIpcStreamManager().notifyVodComplete(streamId) 通知推流完成
      
              } catch (NoSuchStreamException e) {
                  e.printStackTrace();
              }
          }
    • 按时间方式播放设备端录像的响应
          @Override
          public void onStartPushVodStreaming(int streamId, int beginTimeUtc, int endTimeUtc) {
              appendLog("开始推点播流 " + streamId + " beginTimeUtc: "+beginTimeUtc + " endTimeUtc:"+endTimeUtc);
      
              //TODO 推流逻辑需要添加:
              // 1. beginTimeUtc和endTimeUtc一般是一天的开始和结束时间
              // 2. 当收到onStartPushVodStreaming回调后,应从beginTimeUtc开始向后最近的I帧开始推流,时间戳应使用对应帧的UTC时间
              // 3. 若beginTimeUtc到endTimeUtc范围内没有录像或范围内推流已经完成了,则应调用 IPCDev.getInstance().getIpcStreamManager().notifyVodComplete(streamId) 通知推流完成
              // 4. 只要是beginTimeUtc到endTimeUtc范围内有数据, 即使跨文件,推流应该持续不断
          }
  4. 处理暂停或恢复指令。
    需响应暂停或恢复推流指令(OnVodStreamListener),相应的暂停或恢复发送音视频数据。
    /**
         * 收到暂停推流请求
         *
         * @param streamId 流ID
         */
        void onPausePushVodStreaming(int streamId);
    
        /**
         * 收到恢复推流的请求
         *
         * @param streamId 流ID
         */
        void onResumePushVodStreaming(int streamId);
  5. 处理Seek指令。
    当您需响应Seek指令(OnVodStreamListener)时,例如App端播放器进度条Seek到80秒时,对应会回调onSeekTo方法,请从该timeStampInS时间点最近的I帧开始继续推流。
    /**
         * 收到重新定位请求
         *
         * @param streamId     流ID
         * @param timeStampInS 时间偏移量,相对于视频开始时间,单位为S
         */
        void onSeekTo(int streamId, long timeStampInS);
  6. 处理停止推流指令。
    当服务端下发停止推流请求时,通过回调OnVodStreamListener.onStopPushLiveStreaming()方法来通知设备端停止推流。

    一般要停止调用发送音视频接口、关闭视频文件,并调用IPCStreamManager的stopStreaming(int streamId)方法。

    /**
         * 收到停止推流请求
         *
         * @param streamId 流ID
         */
        @Override
        public void onStopPushStreaming(int streamId) {
            // TODO 停止音视频数据的发送
            try {
                // 调用停止推流接口
                IPCDev.getInstance().getIpcStreamManager().stopStreaming(streamId);
             catch (NoSuchStreamException e) {
                e.printStackTrace();
            }
        }
  7. 处理流错误。
    推流过程中需要处理流错误,通过OnStreamErrorListener.onError(int streamId, StreamError error)来接收和处理。

开发语音对讲功能

语音对讲支持单讲、双讲模式。
  • 单讲:App端采集并发送音频数据到设备端进行播放。
  • 双讲:App端和设备端都需要同时做采音和放音,设备端必须支持AEC,否则不建议使用该方案。

语音对讲支持的音频格式如下。

格式 采样率 编码 解码
G711A 8Khz/16Khz
G711U 8Khz/16Khz
说明 对讲提供V1、V2两套接口,除特殊说明外,请使用V2版本。
  • V1版本:需要自行实现录音采集、播放以及回声消除。
  • V2版本:支持单/双讲模式,内部已经实现录音采集、播放以及回声消除,支持设置采集音频增益大小。
  1. 注册语音对讲事件监听器和错误监听器。
    SDK收到服务端下发的开始推流指令后,会通过事先注册的语音对讲事件监听器(OnLiveIntercomListener)来通知开始或结束语音对讲、接收对端的音频参数和语音数据。

    推流中发生的错误也将通过流错误监听器来通知App。请不要在回调接口中执行阻塞任务。

    1. 选择使用的语音对讲版本。
      // 设置使用对讲第二版本, 默认为此版本
      IPCDev.getInstance().setLiveIntercomVersionBeforeInit(IPCDev.LiveIntercomVersion.VERSION_2);
    2. 选择对讲模式。
      // 设置双向对讲模式,只对V2版本接口有效
      IPCDev.getInstance().setLiveIntercomModeBeforeInit(IPCLiveIntercomV2.LiveIntercomMode.DoubleTalk);
    3. 设置监听。
      // 设置语音对讲事件监听
      IPCDev.getInstance().getIpcLiveIntercom().setOnLiveIntercomListener(MainActivity.this);
      // 设置语音对讲错误回调
      IPCDev.getInstance().getIpcLiveIntercom().setOnLiveIntercomErrorListener(MainActivity.this);

    注册语音对讲事件监听器和错误监听器的完整代码如下。

    public interface OnLiveIntercomListener {
    
        /**
         * 收到App端发起的开始语音对讲请求
         *
         * @return 返回当前设备端上行音频参数格式,如采样率、通道数、采样位宽、音频格式, 请确保对App端能支持该音频参数配置
         */
        AudioParams onStartVoiceIntercom();
    
        /**
         * 收到结束语音对讲请求
         */
        void onStopVoiceIntercom();
    
        /**
         * 收到App端音频参数,表示与App端的通道已建立,可以开始对讲
         * @param audioParams  App端的音频参数
         */
        void onAudioParamsChange(AudioParams audioParams);
    
        /**
         * 收到App端发送的PCM数据,一般用来做UI展示,比如绘制音量大小
         * @param buffer
         * @param size
         */
        void onAudioBufferReceive(byte[] buffer, int size);
    }
    public interface OnLiveIntercomErrorListener {
    
        /**
         * 语音对讲发生错误
         * @param error 见{@link LiveIntercomError}
         */
        void onError(LiveIntercomError error);
    }
  2. 响应开始语音对讲请求(仅V1版本接口需要处理)。
    1. 启动录音机开始音频采集并将音频数据发送给对端 。
      @Override
          public AudioParams onStartVoiceIntercom() {
              appendLog("收到开始语音对讲指令");
      
              // 收到开始语音对讲请求, 启动录音机
              simpleAudioRecord.setAudioRecordListener(new AudioRecordListener() {
                  @Override
                  public void onRecordStart() {
                      // 录音开始
                      appendLog("录音开始");
                  }
      
                  @Override
                  public void onRecordEnd() {
                      // 录音结束
                      appendLog("录音结束");
                  }
      
                  @Override
                  public void onBufferReceived(byte[] buffer, int offset, int size) {
                      // 收到录音机抛出的PCM数据, 调用发送接口发送给对端
                      IPCDev.getInstance().getIpcLiveIntercom().sendAudioBuffer(buffer, offset, size);
                  }
      
                  @Override
                  public void onError(int error, String message) {
                      appendLog("录音机错误:" + error + " " + message);
                  }
              });
      
              simpleAudioRecord.start();
      
              // 通知使用G711A作为音频发送格式,内部会对PCM数据重新做编码
              return AudioParams.AUDIOPARAM_MONO_8K_G711A;
          }
    2. 发送音频数据接口(IPCLiveIntercom,仅V1版本接口需要处理)。
      /**
           * 发送音频数据<br>
           * 等价{@link #sendAudioBuffer(byte[] data, int offset, int length, boolean enableEncode)} enableEncode=true
           */
          void sendAudioBuffer(byte[] data, int offset, int length);
      
          /**
           * 发送音频数据<br>
           *
           * @param data         数据buffer
           * @param offset       偏移量
           * @param length       长度
           * @param enableEncode true: 内部会依据{@link OnLiveIntercomListener#onStartVoiceIntercom()}返回的音频格式对送入的数据(必须为PCM)重新编码并发送
           *                     false: 内部会直接发送音频数据
           */
          void sendAudioBuffer(byte[] data, int offset, int length, boolean enableEncode);
  3. 处理声音播放(仅V1版本接口需要处理)。
    当App端和设备端语音对讲通道建立后,设备端通过onAudioParamsChange(AudioParams audioParams)收到App端发过来的音频参数。依据该音频参数新建音频播放器,供后续接受的音频数据播放。
    @Override
        public void onAudioParamsChange(AudioParams audioParams) {
            // 收到对端发送的音频参数
            appendLog("收到客户端的音频参数: " + audioParams.toString());
    
            // 初始化播放器
            if (simpleStreamAudioTrack != null) {
                simpleStreamAudioTrack.release();
                audioTrackQueue.clear();
            }
            if (acousticEchoCanceler != null) {
                acousticEchoCanceler.release();
            }
            if (noiseSuppressor != null) {
                noiseSuppressor.release();
            }
            noiseSuppressor = NoiseSuppressor.create(simpleAudioRecord.getAudioSessionId());
            if (noiseSuppressor != null) {
                noiseSuppressor.setEnabled(true);
            }
            simpleStreamAudioTrack = new SimpleStreamAudioTrack(audioParams, AudioManager.STREAM_MUSIC, audioTrackQueue,
                    simpleAudioRecord.getAudioSessionId());
            if (AcousticEchoCanceler.isAvailable()) {
                acousticEchoCanceler = AcousticEchoCanceler.create(simpleAudioRecord.getAudioSessionId());
                if (acousticEchoCanceler != null) {
                    appendLog("已开启回声消除");
                    acousticEchoCanceler.setEnabled(true);
                }
            }
    
            simpleStreamAudioTrack.start();
        }
    
    
        @Override
        public void onAudioBufferReceive(byte[] buffer, int size) {
            // 收到对端发送的PCM数据
            audioTrackQueue.add(buffer);
        }
  4. 处理结束语音对讲指令(仅V1版本接口需要处理)。
    @Override
    public void onStopVoiceIntercom() {
     appendLog("收到停止语音对讲指令");
     // 收到停止语音对讲请求,停止录音
     simpleAudioRecord.stop();
    }
  5. 语音对讲错误处理。
    @Override
    public void onError(LiveIntercomError error) {
     // 语音对讲发生错误
     appendLog("语音对讲错误:" + error.getCode() + " msg:" + error.getMessage());
    
     // 停止录音(仅V1版本接口需要处理)
     simpleAudioRecord.stop();
    
     // 停止播放(仅V1版本接口需要处理)
     simpleStreamAudioTrack.stop();
    }

语音对讲错误列表如下。

错误码 错误描述
LiveIntercomError.INVALID_AUDIO_PARAMS 无效的设备端音频参数
LiveIntercomError.START_LIVE_INTERCOM_REQUEST_FAILED 无效的语音对讲请求
LiveIntercomError.CONNECTION_STREAM_FAILED 建立语音对讲流通道失败
LiveIntercomError.SEND_STREAM_DATA_FAILED 发送音频数据失败
LiveIntercomError.RECEIVE_STREAM_DATA_FAILED 接收音频数据失败
LiveIntercomError.INIT_RECORD_FAILED 录音机初始化错误
LiveIntercomError.START_RECORD_FAILED 录音机启动错误
LiveIntercomError.READ_RECORD_BUFFER_FAILED 录音机数据读取错误
LiveIntercomError.INIT_AUDIO_PLAYER_FAILED 音频播放器创建失败

开发抓图功能

抓图功能通过回调IUploadPicListener来上传图片。回调信息包括上传地址、此次上传的图片ID、上传类型等。图片上传完成后,设备端通过IUploadPicProcessCallback回调通知SDK上传任务完成。抓图功能主要分以下两种场景。

  • App端发起抓图请求,设备抓图后上传至云端。
  • 侦测事件触发,设备端自动抓图并上传图片至云端。
说明 您还需要确认拍照的物模型TriggerPicCapture里的UploadUrl字符串长度,如果小于512字符,则需要修改到大于512字符,否则图片上传会受到影响。
  1. 抓图上传。
    拍照上传任务的流程通常为:SDK通知设备拍照、设备拍照、设备上传图片、通知SDK上传结果。 详细流程如下。
    1. 设备端注册上传图片监听。
      /**
       * 上传图片监听
       */
      public interface IUploadPicListener {
          /**
           * 触发上传
           * @param uploadInfo  上传信息
           * @param callback    上传结果回调
           */
          void onUpload(UploadInfo uploadInfo, IUploadPicProcessCallback callback);
      }
    2. 当App触发拍照,设备端通过IUploadPicListeneronUpload获取到当前需要抓图并上传通知。

      其中图片上传的URL从onUpload回调的uploadInfo参数中获取。

      /**
       * 上传图片
       */
      public class UploadInfo {
          /**
           * 上传url
           */
          private String uploadUrl;
          /**
           * 上传图片ID(用户生成的,只有事件上报时才有)
           */
          private String picId;
          /**
           * 上传类型,0为拍照,1为事件图片上传。
           */
          private int type;
      }
    3. 设备端通过IUploadPicProcessCallback回调通知SDK上传结果。
      /**
       * 上传图片结果回调
       */
      public interface IUploadPicProcessCallback {
          /**
           * 上传任务成功
           */
          void onSucceed();
      
          /**
           * 上传任务失败
           *
           * @param errorMsg 错误信息
           */
          void onFailed(String errorMsg);
      
      }
    4. 监听注册结果。

      LinkKit SDK初始化成功后,设备端通过如下代码监听注册。

      //注册上传图片监听,当App端触发拍照或者设备上报了事件以后,会在注册的回调中收到上传的回调。
      IPCDev.getInstance().registerUploadPicListener(uploadPicListener);
      
      /**
       * 上传图片回调,回调中只有是事件照片上传的时候picId不为空且为上报事件时用户上传的ID。
       * type为上传类型,0为App触发设备拍照,1为设备上传事件照片。
       */
      private IUploadPicListener uploadPicListener = new IUploadPicListener() {
              @Override
              public void onUpload(final UploadInfo uploadInfo, final IUploadPicProcessCallback callback) {
                  final String url = uploadInfo.getUploadUrl();
                  final String picId = uploadInfo.getPicId();
                  final int type = uploadInfo.getType();
                  switch (type) {
                      //拍照上报
                      case 0:
                          //拍照并且上传
                          upLoadFile(url, pic, new CallBack(){
                                   @Override
                                   public void onSucceed() {
                                          Log.d(TAG, "uploadImage onSucceed");
                                          if (callback != null) {
                                                  callback.onSucceed();
                                          }
                                   }
      
                                    @Override
                                    public void onFailed(String error) {
                                           Log.e(TAG, "uploadImage onFailed:" + error);
                                           if (callback != null) {
                                                  callback.onFailed(error);
                                          }
                                   }                    
                          });            
                          break;
                      //事件图片上报
                      case 1:
                          //上传图片
                          upLoadFile(url, pic, new CallBack(){
                                   @Override
                                   public void onSucceed() {
                                          Log.d(TAG, "uploadImage onSucceed");
                                          if (callback != null) {
                                                  callback.onSucceed();
                                          }
                                   }
      
                                    @Override
                                    public void onFailed(String error) {
                                           Log.e(TAG, "uploadImage onFailed:" + error);
                                           if (callback != null) {
                                                  callback.onFailed(error);
                                          }
                                   }                    
                          });
                          break;
                      default:
                          break;
                  }
              }};
  2. 事件上报触发图片上传。
    事件上报流程依次为:设备触发事件、事件上报、SDK通知设备上传图片、设备上传图片、通知SDK上传结果。 具体的流程如下。
    1. 设备端注册上传图片的监听。
    2. 当设备端触发事件,设备通过SDK提供的接口上报事件(需要上传图片ID)。
    3. SDK会通过IUploadPicListeneronUpload通知设备上传图片。
    4. 设备端通过onUpload中的UploadInfo获取此次上传的URL、图片ID。
    5. 设备端自行通过URL上传图片。
    6. 设备端通过IUploadPicProcessCallback回调通知SDK上传结果。

    上报事件接口实例如下。

    //上报报警事件分成两步:1.上传报警,2.上传图片
    //上报报警事件需要设备生成一个报警图片ID,这个报警图片ID要求是设备唯一的图片ID,建议用Unix时间戳。
    // 不过这边需要确认一下拍照的物模型"TriggerPicCapture"里的"UploadUrl"的字符串长度,如果小于512请增加长度到512以上。
    // 上报事件以后会收到IUploadPicListener(需要注册监听)内的onUpload回调,然后请将对应的图片上传到回调中url指定地址。
    final String alarmPicId = String.valueOf(System.currentTimeMillis() / 1000);
    IPCDev.getInstance().reportAlarmEvent(alarmPicId, 1, new ReportAlarmEventListener() {
        @Override
        public void onSucceed() {
            Log.d(TAG, " report onSucceed  alarmPicId:" + alarmPicId);
            appendLog("上报事件成功");
        }
    
        @Override
        public void onFailed(String msg) {
            Log.e(TAG, " report onFailed  e:" + msg);
            appendLog("上报事件失败  e:" + msg);
        }
    });