Android平台上集成大华SDK

在项目中需要接入大华设备，因此我们集成了大华Android版本SDK。与海康SDK类似，它也是分为NetSDK和PlaySDK。

前者用于设备连接、网络通信；后者用于解码、播放。

在APP中，关于大华设备，我们实现了以下功能：添加设备、获取通道、实时预览、远程回放。

接下来，我们一个一个来分析如何实现。

首先，登录设备，用到的方法是INetSDK.LoginEx(String pchDVRIP, int wDVRPort, String pchUserName, String pchPassword, int nSpecCap, Object pCapParam, NET_DEVICEINFO lpDeviceInfo, Integer nError)

具体代码实现如下：

首先，我们需要做一些准备工作：

INetSDK.LoadLibrarys();
DeviceDisConnect disConnect = new DeviceDisConnect();
INetSDK.Init(disConnect);  //初始化SDK,在所有的SDK函数之前调用
/**
 * 设置连接设备超时时间和尝试次数
 * @param nWaitTime 客户端与设备的连接等待时间,毫秒级
 * @param nTryTimes 连接次数
 */
INetSDK.SetConnectTime(4000, 2);
NET_PARAM stNetParam = new NET_PARAM();  //NET_PARAM  该类用于设置登录时的相关参数
stNetParam.nWaittime = 10000;   //等待超时时间(毫秒为单位)
stNetParam.nSearchRecordTime = 10000;  //按时间查询录像文件的超时时间(毫秒为单位)
INetSDK.SetNetworkParam(stNetParam);  //设置登陆网络环境

NET_DEVICEINFO deviceInfo = new NET_DEVICEINFO();  //设备信息
Integer error = new Integer(0);

DeviceReConnect reConnect = new DeviceReConnect();
INetSDK.SetAutoReconnect(reConnect);  //设置断线重连成功回调函数,设置后SDK内部断线自动重连
DeviceSubDisConnect subDisConnect = new DeviceSubDisConnect();
INetSDK.SetSubconnCallBack(subDisConnect);  //设置动态子连接断线回调函数,目前SVR设备的监视和回放是短连接的
INetSDK.SetDVRMessCallBack(new Test_CB_fMessageCallBack());  //设置消息回调函数

/**
 * 设备未连接上
 */
public class DeviceDisConnect implements CB_fDisConnect {
    @Override
    public void invoke(long lLoginID, String pchDVRIP, int nDVRPort) {
        return;
    }
}

/**
 * 设备连接恢复
 */
public class DeviceReConnect implements CB_fHaveReConnect {
    @Override
    public void invoke(long lLoginID, String pchDVRIP, int nDVRPort) {}
}

/**
 * 动态子连接断开
 */
public class DeviceSubDisConnect implements CB_fSubDisConnect {
    @Override
    public void invoke(int emInterfaceType, boolean bOnline,
                       long lOperateHandle, long lLoginID) {}
}

/**
 * 消息回调函数
 */
class Test_CB_fMessageCallBack implements CB_fMessageCallBack {
    @Override
    public boolean invoke(int lCommand, long lLoginID, Object obj, String pchDVRIP, int nDVRPort) {
        if (12295 == lCommand) {
            DEV_PLAY_RESULT stResult = (DEV_PLAY_RESULT) obj;
        }
        return true;
    }
}

接下来，调用登录方法：

long loginHandle = INetSDK.LoginEx(ipAddress, port,
        userName, password, mSpecCap, null, deviceInfo, error);

mSpecCap为设备支持的能力，这里值为20。

如果loginHandle的值不为0，那么登录成功。

获取通道

m_speedCtrl = false;
m_schedule = 0;
SDK_DEV_ENABLE_INFO stEnableInfo = new SDK_DEV_ENABLE_INFO();
if (INetSDK.QuerySystemInfo(loginHandle, SDK_SYS_ABILITY.ABILITY_DEVALL_INFO, stEnableInfo, 3000)) {
    if (stEnableInfo.IsFucEnable[SDK_DEV_FUNC.EN_PLAYBACK_SPEED_CTRL] != 0) {
        m_speedCtrl = true;
    }
    m_schedule = stEnableInfo.IsFucEnable[SDK_DEV_FUNC.EN_SCHEDULE];
}
stCfgCapAlarm = new CFG_CAP_ALARM_INFO();
char szOutBuffer[] = new char[10240];
Integer stError = new Integer(0);
boolean bQN = INetSDK.QueryNewSystemInfo(loginHandle, FinalVar.CFG_CAP_ALARM, 0, szOutBuffer, stError, 5000);
if (bQN) {
    bQN = INetSDK.ParseData(FinalVar.CFG_CAP_ALARM, szOutBuffer, stCfgCapAlarm, null);  //解析查询到的配置信息
    if (!bQN) {
        Log.e("dahua", "INetSDK.ParseData CFG_CAP_ALARM error");
    }
} else {
    Log.e("dahua", "INetSDK.QueryNewSystemInfo CFG_CAP_ALARM error");
}
mCount = deviceInfo.byChanNum;
if (-1 == deviceInfo.byChanNum) {
    SDK_PRODUCTION_DEFNITION stDef = new SDK_PRODUCTION_DEFNITION();
    boolean bRet = INetSDK.QueryProductionDefinition(loginHandle, stDef, 3000);
    if (bRet) {
        mCount = stDef.nVideoInChannel + stDef.nMaxRemoteInputChannels;
    }
}

最终得到的mCount就是通道数。

对大华摄像头进行实时预览，用到的方法是INetSDK.RealPlayEx(int lLoginID, int nChannelID, int rType)

用之前获取的loginHandle，

long lRealHandle = INetSDK.RealPlayEx(loginHandle, channelNo, streamType);

如果lRealHandle不为0，则成功，接下来：

mPort = IPlaySDK.PLAYGetFreePort();

boolean bOpenRet = IPlaySDK.PLAYOpenStream(mPort, null, 0, 1024 * 1024 * 2) == 0 ? false : true;
if (bOpenRet) {
    boolean bPlayRet = IPlaySDK.PLAYPlay(mPort, surfaceView) == 0 ? false : true;
    if (bPlayRet) {
        boolean bSuccess = IPlaySDK.PLAYPlaySoundShare(mPort) == 0 ? false : true;
        /*if (!bSuccess) {
            IPlaySDK.PLAYStop(mPort);
            IPlaySDK.PLAYCloseStream(mPort);
            return false;
        }
        if (-1 == nCurVolume) {
            nCurVolume = IPlaySDK.PLAYGetVolume(mPort);
        } else {
            IPlaySDK.PLAYSetVolume(mPort, nCurVolume);
        }*/
    } else {
        IPlaySDK.PLAYCloseStream(mPort);
        return false;
    }
} else {
    //IPlaySDK.PLAYCloseStream(mPort);
    return false;
}
return true;

如果最终return true，接下来，我们继续：

public class TestRealDataCallBackEx implements CB_fRealDataCallBackEx {

    public int port;
    public TestRealDataCallBackEx(int port) {
        this.port = port;
    }

    /**
     * 网络断线回调函数
     * @param lRealHandle 实时监视ID
     * @param dwDataType  回调出来的数据类型
     * @param pBuffer     回调数据，根据数据类型的不同每次回调不同的长度的数据，除类型0，其他数据类型都是按帧，每次回调一帧数据
     * @param dwBufSize   回调数据参数结构体，根据不同的类型，参数结构也不一致
     * @param param       回调数据的长度，根据不同的类型，长度也不同(单位字节)
     */
    @Override
    public void invoke(long lRealHandle, int dwDataType, byte[] pBuffer, int dwBufSize, int param) {
        if (dwDataType == 0) {
            IPlaySDK.PLAYInputData(port, pBuffer, pBuffer.length);
        }
    }
}

public class TestVideoDataCallBack implements IPlaySDKCallBack.fDemuxCBFun {

    public FileOutputStream outputStream;

    public TestVideoDataCallBack(FileOutputStream outputStream) {
        this.outputStream = outputStream;
    }

    @Override
    public void invoke(int nPort, byte[] pOrgBuffer, int nOrgLen, byte[] pBuffer, int nLen,
                       IPlaySDKCallBack.DEMUX_INFO stInfo, long dwUser) {
        try {
            if (null != outputStream) {
                outputStream.write(pBuffer);
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

TestRealDataCallBackEx m_callbac = new TestRealDataCallBackEx(mPort);
TestVideoDataCallBack m_VideoCallback = new TestVideoDataCallBack(m_Fout);
if (lRealHandle != 0) {
    INetSDK.SetRealDataCallBackEx(lRealHandle, m_callbac, 1);
}

停止实时预览：

/**
 * 停止实时预览
 * @param port
 * @param lRealHandle
 */
public void stopLive(int port, long lRealHandle) {
    IPlaySDK.PLAYStop(port);
    IPlaySDK.PLAYStopSoundShare(port);
    IPlaySDK.PLAYCloseStream(port);
    INetSDK.StopRealPlayEx(lRealHandle);
}

对大华摄像头进行录像回放，我们这里是采用按照时间进行回放，用到的方法是INetSDK.PlayBackTimeEx(long lLoginID, int nChannelID, NET_TIME startTime, NET_TIME stopTime, CB_fDowmLoadPosCallBack posUser, CB_fDataCallBack dataUser)

具体实现代码如下：

先做一些准备工作：

NET_TIME stTimeStart = new NET_TIME();
NET_TIME stTimeEnd = new NET_TIME();
getPlaybackTime(stTimeStart, stTimeEnd, bgYear, bgMonth, bgDay, bgHour, bgMinute, bgSecond,
        endYear, endMonth, endDay, endHour, endMinute, endSecond);

public void getPlaybackTime(NET_TIME stTimeStart, NET_TIME stTimeEnd,int bgYear,int bgMonth,int bgDay,int bgHour,int bgMinute,int bgSecond,
                            int endYear,int endMonth,int endDay,int endHour,int endMinute,int endSecond) {
    stTimeStart.dwYear = bgYear;
    stTimeStart.dwMonth = bgMonth;
    stTimeStart.dwDay = bgDay;
    stTimeStart.dwHour = bgHour;
    stTimeStart.dwMinute = bgMinute;
    stTimeStart.dwSecond = bgSecond;

    stTimeEnd.dwYear = endYear;
    stTimeEnd.dwMonth = endMonth;
    stTimeEnd.dwDay = endDay;
    stTimeEnd.dwHour = endHour;
    stTimeEnd.dwMinute = endMinute;
    stTimeEnd.dwSecond = endSecond;
}

public class TestfDataCallBack implements CB_fDataCallBack {
    @Override
    public int invoke(long lPlaybackHandle, int dwDataType, byte buffer[], int dwBufferSize) {
        if (0 == dwDataType) {
            return IPlaySDK.PLAYInputData(nPort, buffer, buffer.length);
        } else if ( dwDataType == 2 ) {
            //m_PlayView.drawColor(pBuffer);
        } else if ( dwDataType == 3 ) {
            //m_PlayView.drawColor(pBuffer);
        }
        return 0;
    }
}

public class TestDownLoadPosCallBack implements CB_fDownLoadPosCallBack {
    @Override
    public void invoke(long lPlayHandle, int dwTotalSize, int dwDownLoadSize) {
        Log.i("playback",dwTotalSize+"");
        if (-1 == dwDownLoadSize) {
            //m_sbPbByTime.setProgress(dwTotalSize);
            new Thread(new Runnable() {
                @Override
                public void run() {
                    if (0 != lPlaybackHandle) {
                        stopPlayBackDahua();
                    }
                }
            }).start();
        } else {
            //m_sbPbByTime.setProgress(dwDownLoadSize);
        }
    }
}

TestfDataCallBack m_callback = new TestfDataCallBack();
TestDownLoadPosCallBack posUser = new TestDownLoadPosCallBack();

long lPlaybackHandle = INetSDK.PlayBackByTimeEx(loginHandle, channelNo, stTimeStart, 

          stTimeEnd, posUser, m_callback);

如果lPlaybackHandle不为0，则继续：

IPlaySDK.PLAYSetPlayedTimeEx(nPort, 0);
IPlaySDK.PLAYResetBuffer(nPort, 1);  //清码流分析库
IPlaySDK.PLAYResetBuffer(nPort, 3);  //清播放队列

boolean bOpenRet = IPlaySDK.PLAYOpenStream(nPort, null, 0, 1024*1024*2) == 0 ? false : true;
IPlaySDK.PLAYSetStreamOpenMode(nPort, Constants.STREAME_FILE);
if (bOpenRet) {
    boolean bPlayRet = IPlaySDK.PLAYPlay(nPort, surfaceView) == 0 ? false : true;
    if (bPlayRet) {
        boolean bSuccess = IPlaySDK.PLAYPlaySoundShare(nPort) == 0 ? false : true;
        /*if(!bSuccess)
        {
            IPlaySDK.PLAYStop(nPort);
            IPlaySDK.PLAYCloseStream(nPort);
            Message msg = Message.obtain();
            msg.what = 1;
            msg.obj = "Failed to start playback";
            handler.sendMessage(msg);
            return;
        } else {

        }*/
        loadFinish = true;
        Message msg = Message.obtain();
        msg.what = 2;
        handler.sendMessage(msg);
    } else {
        IPlaySDK.PLAYCloseStream(nPort);
        return;
    }
} else {
    return;
}

停止回放：

public void stopPlayBackDahua() {
    if (lPlaybackHandle != 0) {
        IPlaySDK.PLAYStop(nPort);
        IPlaySDK.PLAYCloseStream(nPort);  //在PLAYStop之后调用
        INetSDK.StopPlayBack(lPlaybackHandle);
        lPlaybackHandle = 0;
    }
}