跳到主要内容

局域网设备

更新时间：2025-07-22 18:35:15
信息

前提导读

发现局域网设备，发现了多个设备会有一个设备列表，从设备列表选择一台设备进行连接，监听连接状态，连接成功后则可进行播放或获取网关设备的子设备进行播放

object LanDeviceLinkMgr {
    /**
     * 搜索局域网设备
     *
     * @param onResultListener  如果搜索到多个设备,会多次触发回调
     */
    fun searchLanDevice(onResultListener: OnResultListener<LanDeviceInfo>)
    
    /**
     * 停止搜索局域网设备
     *
     */
    fun stopSearch() 
    
     /**
     * 设备连接设备状态监听
     *
     * @param connectStateListener
     */
    fun setOnDeviceConnectStateListener(connectStateListener: OnResultListener<Boolean>) 
    
     /**
     * 连接设备
     *
     * @param deviceInfo 局域网设备[DeviceInfo]
     */
    fun connectDevice(deviceInfo: DeviceInfo)
    
    /**
     * 断开设备连接
     *
     */
    fun disConnectDevice()
    
    /**
     * 网关设备获取子设备 需要先连接设备
     *
     * @param
     * @return
     */
    fun getSubDeviceList(productKey: String, deviceName: String, onResultListener: OnResultListener<List<LanDeviceInfo>>)
    
     /**
     * 退出局域网连接时请务必调用
     *
     */
    fun exitLanLink() 
}

发现设备​

发现设备可能会有多个设备响应，回调可能多多次触发，UI请使用列表展示

示例

private void getDeviceList() {
    showLoading(true);
    //回调可能会多次触发
    LanDeviceLinkMgr.searchLanDevice(new OnResultListener<>() {
        @Override
        public void onResult(LanDeviceInfo result) {
            mDeviceListAdapter.addItem(result);
            hideLoading();
        }

        @Override
        public void onError(@NonNull IoTSDKError error) {
            showToast(error.toString());
            binding.rvDeviceList.setVisibility(View.GONE);
            binding.tvNoDeviceTip.setVisibility(View.VISIBLE);
            hideLoading();
        }
    });
}

停止发现设备​

示例

LanDeviceLinkMgr.stopSearch()

设置设备连接监听​

示例

mDeviceListAdapter.setOnItemClickListener(new OnItemClickListener<DeviceInfo>() {
            @Override
    public void onClick(DeviceInfo item, int position) {
        LanDeviceLinkMgr.setOnDeviceConnectStateListener(new OnResultListener<Boolean>() {
            @Override
            public void onResult(Boolean result) {
                if (result) { //连接成功
                    if (isVisibility) {
                        DeviceNodeTypeEnum nodeType = DeviceNodeTypeEnum.valueOf(item.getNodeType());
                        if (nodeType == DeviceNodeTypeEnum.GATEWAY) {
                            LanDeviceChildListActivity.callActivity(LanDeviceListActivity.this, item);
                        } else {
                            LanDevicePlayActivity.callActivity(LanDeviceListActivity.this, item);
                        }
                    }
                } else { // 连接断开
                    showToast(R.string.common_cant_connect);
                    Intent intent = new Intent(LanDeviceListActivity.this, LanDeviceListActivity.class);
                    intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
                    startActivity(intent);
                }
            }

            @Override
            public void onError(@NonNull IoTSDKError error) {
                showToast(R.string.common_cant_connect);
            }
        });
        LanDeviceLinkMgr.connectDevice(item);
    }
});

连接设备​

示例

mDeviceListAdapter.setOnItemClickListener(new OnItemClickListener<DeviceInfo>() {
            @Override
    public void onClick(DeviceInfo item, int position) {
        LanDeviceLinkMgr.setOnDeviceConnectStateListener(new OnResultListener<Boolean>() {
            @Override
            public void onResult(Boolean result) {
                if (result) { //连接成功
                    if (isVisibility) {
                        DeviceNodeTypeEnum nodeType = DeviceNodeTypeEnum.valueOf(item.getNodeType());
                        if (nodeType == DeviceNodeTypeEnum.GATEWAY) {
                            LanDeviceChildListActivity.callActivity(LanDeviceListActivity.this, item);
                        } else {
                            LanDevicePlayActivity.callActivity(LanDeviceListActivity.this, item);
                        }
                    }
                } else { // 连接断开
                    showToast(R.string.common_cant_connect);
                    Intent intent = new Intent(LanDeviceListActivity.this, LanDeviceListActivity.class);
                    intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
                    startActivity(intent);
                }
            }

            @Override
            public void onError(@NonNull IoTSDKError error) {
                showToast(R.string.common_cant_connect);
            }
        });
        LanDeviceLinkMgr.connectDevice(item);
    }
});

断开设备连接​

设备连接成功后，断开设备连接。释放资源

示例

LanDeviceLinkMgr.disConnectDevice()

获取网关子设备​

如果发现的是一个NVR设备，并连接成功，则可获取网关设备下挂的子设备

示例

private void getDeviceList() {
    showLoading(true);
    LanDeviceLinkMgr.getSubDeviceList(mDeviceInfo.getProductKey(), mDeviceInfo.getDeviceName(), new OnResultListener<>() {
        @Override
        public void onResult(List<LanDeviceInfo> result) {
            mDeviceListAdapter.setDataList(new ArrayList<>(result));
            hideLoading();
        }

        @Override
        public void onError(@NonNull IoTSDKError error) {
            showToast(error.toString());
            hideLoading();
        }
    });
}

退出局域网连接​

已进入局域网发现、连接等流程。再退出相关界面时需要调用退出接口释放资源

@Override
public void onDestroy() {
    super.onDestroy();
    IoTLogger.d(TAG, "lifeCycle onDestroyView");
    LanDeviceLinkMgr.exitLanLink();
}

局域网设备播放​

LanDeviceInfo对象继承自com.polaris.iot.appsdk.libuserdevicemgr.model.DeviceInfo，可将LanDeviceInfo对象传递到播放界面，播放流程与设备普通设备相同

局域网设备物模型操作​

可调用物模型服务操作设备，如PTZ等，需要设备连接成功后调用

初始化​

PanelDevice panelDevice = new PanelDevice(mDeviceInfo);

panelDevice.init(context, new IPanelCallback() {
    @Override
    public void onComplete(boolean bSuc, Object o) {
    }
});
  //context是应用的上下文，IPanelCallback是初始化回调接口
  // bSuc表示初始化结果，true为成功，false为失败
  // o表示具体的数据，失败时是一个IoTSDKError结构，成功时忽略

调用设备服务​

panelDevice.invokeService(identifier: String, args: Map<String, Any>, new IPanelCallback() {
    @Override
    public void onComplete(boolean bSuc, Object o) {
        IoTLogger.d(TAG,"callService(), request complete,"+bSuc);
        SignallingRsp rsp = (SignallingRsp) o;
    }
});

//参数格式参考如下
/*
"identifier":"Rhythm",
"args": {
    "Saturation":80,
    "LightDuration":50,
    "Hue":325,
    "Value":50
}
*/

//bSuc表示是否获取成功，true为成功，false为失败
//o表示具体的数据，失败时是一个IoTSDKError结构，成功时需要返回忽略，需要返回请解析成SignallingRsp 对象

调用示例如下：

  • PTZ云台控制
Map<String, Object> args = new HashMap<String, Object>();
args.put("ActionType", PTZActionType.PTZ_LEFT.ordinal());
args.put("Speed", PTZSpeedMode.MIDDLE.ordinal());
// 获取物模型services中ptz参数配置
panelDevice.invokeService("StartPTZAction", args);

局域网设备存储卡​

提供存储卡录制不同方式的播放能力，需要设备连接成功后调用

package com.polaris.iot.appsdk.libplayback

object LanDeviceSDCardService {
    /**
     * 按时间段获取SD卡录制文件
     *
     * @param params 请求参数 [SDCardRecordQueryReq]
     * @param listener  回调 [OnResultListener]<[RecordQueryRsp]>
     */
    @JvmStatic
    fun recordTimeQuery(params: SDCardRecordQueryReq, listener: OnResultListener<RecordQueryRsp>)
    
    /**
     * 按文件获取SD卡录制文件
     *
     * @param params 请求参数 [SDCardRecordQueryReq]
     * @param listener 回调 [OnResultListener]<[RecordFileQueryRsp]>
     */
    @JvmStatic
    fun recordFileQuery(params: SDCardRecordQueryReq, listener: OnResultListener<RecordFileQueryRsp>)
    
    /**
     * 按时间段获取事件文件
     *
     * @param params 请求参数 [SDCardEventQueryReq]
     * @param listener  回调 [OnResultListener]<[EventQueryRsp]>
     */
    @JvmStatic
    fun eventTimeQuery(params: SDCardEventQueryReq, listener: OnResultListener<EventQueryRsp>)
    
    /**
     * 按月查询录制统计
     *
     * @param monthQueryReq
     * @param listener
     */
    @JvmStatic
    fun monthRecordQuery(monthQueryReq: SDCardRecordMonthQueryReq, listener: OnResultListener<MonthQueryRsp>)
}

按时间录制列表​

时间跨度不能超过7天，开始时间不能大于结束时间

返回列表倒序排列

/**
 * SD卡查询条件
 *
 * @property productKey
 * @property deviceName
 * @property beginTime 查询开始时间。
 * @property endTime 查询结束时间。
 * @property pageSize
 * @constructor Create empty S d card record query req
 */
data class SDCardRecordQueryReq(
    var productKey: String,

    var deviceName: String,

    var beginTime: Long,

    var endTime: Long,

    var pageSize: Int
) {
    constructor(productKey: String, deviceName: String, beginTime: Long, endTime: Long) : this(productKey, deviceName, beginTime, endTime, 100)

    /**
     * 录像类型：0 计划录像，1 报警录像，2 主动录像 99:所有类型
     */
    var recordType: Int = 99
}

示例

String iotId = ""
long endTime = System.currentTimeMillis();
long beginTime = endTime - 6 * 3600 * 1000;

final RecordQueryReq recordQueryReq = new SDCardRecordQueryReq(mPlayDeviceInfo.getProductKey(), mPlayDeviceInfo.getDeviceName(), beginTime, endTime);

//mPanelDevice 见物模型初始化 

LanDeviceSDCardService.recordTimeQuery(recordQueryReq, new OnResultListener<RecordQueryRsp>() {
    @Override
    public void onError(@NonNull IoTSDKError error) {

    }

    @Override
    public void onResult(RecordQueryRsp result) {
        final List<TimelineRecordInfo> RecordInfoList = result.getRecordFileList(); 
    }
});

按时间录制列表播放​

IoTPlayerParam param = new IoTPlayerParam();
//从录制数据接口返回
boolean isSDCardPlayback = true;
IoTPlayerSeekParam seekParam = new IoTPlayerSeekParam(beginTime,endTime,isSDCardPlayback )
mPlayerCtrl.prepare(param,seekParam);
mPlayerCtrl.start();

//回看seek
IoTPlayerSeekParam seekParam = new IoTPlayerSeekParam(beginTime,endTime,isSDCardPlayback)
mPlayerCtrl.seekTo(seekParam);

按文件录制列表​

时间跨度不能超过7天，开始时间不能大于结束时间

返回列表倒序排列

String iotId = ""
long endTime = System.currentTimeMillis();
long beginTime = endTime - 6 * 3600 * 1000;

SDCardRecordQueryReq recordQueryReq = new SDCardRecordQueryReq(mDeviceInfo.getProductKey(), mDeviceInfo.getDeviceName(), beginTime, endTime);

//mPanelDevice 见物模型初始化 

LanDeviceSDCardService.recordFileQuery(recordQueryReq, new OnResultListener<RecordFileQueryRsp>() {
    @Override
    public void onError(@NonNull IoTSDKError error) {

    }

    @Override
    public void onResult(RecordFileQueryRsp result) {
        List<SDCardRecordFileInfo> recordInfoList = result.getRecordFileList();
    }
});

按文件录制播放​

IoTPlayerParam param = new IoTPlayerParam();
//录制文件名
String filename = ""
//播放绝对时间
long beginTime;
//录制文件结束时间（绝对时间）
long endTme;
//播放绝对时间相对于文件起始时间（绝对时间）的偏移时间
int seekPos;
IoTPlayerSeekParam seekParam = new IoTPlayerSeekParam(beginTime,endTime,filename, seekPos)
mPlayerCtrl.prepare(param,seekParam);
mPlayerCtrl.start();

//回看seek
IoTPlayerSeekParam seekParam = new IoTPlayerSeekParam(beginTime,endTime,filename, seekPos)
mPlayerCtrl.seekTo(seekParam);

录制事件列表​

时间跨度不能超过7天，开始时间不能大于结束时间

返回列表倒序排列

事件播放同按时间录制列表播放

data class SDCardEventQueryReq(
    var productKey: String,

    var deviceName: String,

    /**
     * 查询开始时间。单位秒。
     */
    var beginTime: Long,

    /**
     * 查询结束时间。单位秒。
     */
    var endTime: Long,


    var pageSize: Int
) {
    constructor(productKey: String, deviceName: String, beginTime: Long, endTime: Long) : this(productKey, deviceName, beginTime, endTime, 100)

    /**
     * 报警类型 不传默认全部
     */
    var eventType: Int? = null

}

示例

String iotId = ""
long endTime = System.currentTimeMillis();
long beginTime = endTime - 6 * 3600 * 1000;


final SDCardEventQueryReq queryReq = new SDCardEventQueryReq(mDeviceInfo.getProductKey(), mDeviceInfo.getDeviceName(), beginTime, endTime);


LanDeviceSDCardService.eventTimeQuery(queryReq, new OnResultListener<EventQueryRsp>() {
    @Override
    public void onError(@NonNull IoTSDKError error) {

    }

    @Override
    public void onResult(EventQueryRsp result) {
        final List<TimelineEventInfo> eventInfoList = result.getEventList();
    }
});

按月统计录制​

按月查询每天是否有录制，使用场景：在日历上加小红点

示例

private void startRecordMonthQuery() throws ParseException {
    Date queryDate = getQueryBeginTime();
    Calendar calendar = Calendar.getInstance();
    calendar.setTime(queryDate);
    SDCardRecordMonthQueryReq params = new SDCardRecordMonthQueryReq(
        mDeviceInfo.getProductKey(), 
        mDeviceInfo.getDeviceName(), 
        calendar.get(Calendar.YEAR), 
        calendar.get(Calendar.MONTH) + 1
    );
    LanDeviceSDCardService.monthRecordQuery(params, new OnResultListener<>() {
        @Override
        public void onError(@NonNull IoTSDKError error) {
            hideLoading();
            showToast("月录制查询失败，" + error.getMessage());
        }

        @Override
        public void onResult(MonthQueryRsp result) {
            runOnUiThread(() -> {
                hideLoading();
                List<CommonListItem> list = new ArrayList<>();
                for (MonthQueryItem item : Objects.requireNonNull(result.getDayCntList())) {
                    list.add(new CommonListItem(item.getDateStr(), String.valueOf(item.getCount())));
                }
                mCommonListAdapter.setDataList(list);
                showToast("月录制查询成功");
            });
        }
    });
}