C# NLogEx.LoggerEx.Info方法代码示例

        /// <summary>
        /// 停止服务
        /// </summary>
        public override void StopService()
        {
            if (serviceHost != null)
            {
                NLog.Logger log = NLog.LogManager.GetCurrentClassLogger();
                NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);

                CgwService.Instance().StopAllStream();//stop all stream.
                SmcErr err = CgwService.Instance().DisconnectMonitor();
                logEx.Info("CGW service.StopService DisconnectMonitor.ErrNo ={0}!", err.ErrNo);

                serviceHost.Close();
                logEx.Info("CGW service.StopService Close Success.");
            }
        }

        /// <summary>
        /// 释放所有实况通道,释放NETSOURCE资源
        /// </summary>
        public IVS_NETSOURCE_RESULT IVS_NETSOURCE_UnInit()
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: SipStackAdapter.IVS_NETSOURCE_UnInit.");
            //IVS_NETSOURCE_RESULT iRet = IVS_NETSOURCE_RESULT.FAILURE;
            IVS_NETSOURCE_RESULT iRet = IVS_NETSOURCE_RESULT.SUCCESS;
            try
            {
                foreach (KeyValuePair<UInt32, int> kvp in channelResponseIDDic)
                {
                    UInt32 channel = kvp.Key;
                    iRet = NetSourcedInterface.IVS_NETSOURCE_CloseNetStream(channel);
                    if (iRet != IVS_NETSOURCE_RESULT.SUCCESS)
                    {
                        logEx.Error("SipStackAdapter.IVS_NETSOURCE_CloseNetStream channelResponseIDDic = {0}.", channel);
                        //注销return，避免返回，不实现IVS_NETSOURCE_UnInit
                        //return iRet;
                    }
                    iRet = NetSourcedInterface.IVS_NETSOURCE_FreeChannel(channel);
                    if (iRet != IVS_NETSOURCE_RESULT.SUCCESS)
                    {
                        logEx.Error("SipStackAdapter.IVS_NETSOURCE_FreeChannel channelResponseIDDic = {0}.", channel);
                        //注销return，避免返回，不实现IVS_NETSOURCE_UnInit
                        //return iRet;
                    }
                }
                //iRet = NetSourcedInterface.IVS_NETSOURCE_UnInit();
                //if (iRet != IVS_NETSOURCE_RESULT.SUCCESS)
                //{
                //    logEx.Error("SipStackAdapter.IVS_NETSOURCE_UnInit failed.");
                //}

                NetSourcedInterface.IVS_NETSOURCE_UnInit();
                logEx.Info("Leave: SipStackAdapter.IVS_NETSOURCE_UnInit.");

            }
            catch (System.Exception ex)
            {
                logEx.Error("SipStackAdapter.IVS_NETSOURCE_UnInit Error = {0}.", ex.ToString());
                iRet = IVS_NETSOURCE_RESULT.FAILURE;
            }
            return iRet;
        }

        /// <summary>
        /// 停止预览
        /// </summary>
        /// <param name="cameraNo">摄像头编号</param>
        /// <returns>成功返回0，失败返回错误码</returns>
        public SmcErr StopReceiveVideo(string cameraNo)
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: TiandyVideoMonitor.StopReceiveVideo({0}).", cameraNo);
            SmcErr err = new CgwError();

            //需要停止的预览句柄
            int needToStopHandel = CgwConst.START_RECEIVE_VIDEO_DATA_FAILED;
            if (this.handelOperateLock.TryEnterWriteLock(CgwConst.ENTER_LOCK_WAIT_TIME))
            {
                try
                {
                    if (this.cameraVideoHandeDic.ContainsKey(cameraNo))
                    {
                        needToStopHandel = this.cameraVideoHandeDic[cameraNo];
                        this.videoHandleCameraDic.Remove(needToStopHandel);
                        this.cameraVideoHandeDic.Remove(cameraNo);
                    }
                    else
                    {
                        //不存在，表示已经删除，不返回错误
                        //err.SetErrorNo(CgwError.STOP_RECEIVE_VIDEO_FAILED);
                        logEx.Warn("Stop Receive camera video data failed. Don't need to end the preview.Camera No:{0}.", cameraNo);
                    }
                }
                finally
                {
                    this.handelOperateLock.ExitWriteLock();
                }
            }

            //调用sdk的停止方法，放在handelOperateLock外面，防止长时间占用锁
            if (needToStopHandel != CgwConst.START_RECEIVE_VIDEO_DATA_FAILED)
            {
                this.sdkClient.StopReceiveVideo(needToStopHandel);
            }

            logEx.Info("Stop Receive camera video data success.Camera No:{0},Handle:{1}.", cameraNo, needToStopHandel);
            return err;
        }

        /// <summary>
        /// 启动摄像头预览
        /// </summary>
        /// <param name="cameraNo">摄像头编号</param>
        /// <returns></returns>
        public SmcErr StartReceiveVideo(string cameraNo)
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: TiandyVideoMonitor.StartReceiveVideo({0}).", cameraNo);
            SmcErr err = new CgwError();

            TiandyCamera camera = null;
            Host host = null;

            //摄像头所连接的流媒体服务器
            MediaServer cameraMediaServer = null;
            if (this.cameraOperateLock.TryEnterReadLock(CgwConst.ENTER_LOCK_WAIT_TIME))
            {
                try
                {
                    if (!this.tiandyCameraDictionary.ContainsKey(cameraNo))
                    {
                        err.SetErrorNo(CgwError.CAMERA_NOT_FOUND);
                        logEx.Error("Start Receive camera video data failed.Camera No is not found.Camera No:{0}", cameraNo);
                        return err;
                    }
                    camera = this.tiandyCameraDictionary[cameraNo];
                    host = this.hostDictionary[camera.HostNo];
                    cameraMediaServer = this.mediaServerDictionary[host.MediaServerNo];
                }
                catch (Exception e)
                {
                    err.SetErrorNo(CgwError.START_RECEIVE_VIDEO_FAILED);
                    logEx.Error("Start Receive camera video data failed.Camera No:{0},Execption message:{1}", cameraNo, e.Message);
                    return err;
                }
                finally
                {
                    this.cameraOperateLock.ExitReadLock();
                }
            }

            if (camera == null)
            {
                err.SetErrorNo(CgwError.START_RECEIVE_VIDEO_FAILED);
                logEx.Error("Start Receive camera video data failed.Camera No is not found.Camera No:{0}", cameraNo);
                return err;
            }

            RealPlayInfo real = new RealPlayInfo();
            real.ch = camera.Channel;
            real.data_type = (int)TiandyDateType.PRIMARY;
            real.hPlayWnd = null;

            int result = this.sdkClient.StartReceiveVideo(host.No, cameraMediaServer, ref real);

            //如果为负数，表示预览失败
            if (result < 0)
            {
                err.SetErrorNo(CgwError.START_RECEIVE_VIDEO_FAILED);
                logEx.Error("Start Receive camera video data failed.Camera No:{0}.", cameraNo);
                return err;
            }
            else
            {
                //需要停止的预览句柄
                int needToStopHandel = CgwConst.START_RECEIVE_VIDEO_DATA_FAILED;
                if (this.handelOperateLock.TryEnterWriteLock(CgwConst.ENTER_LOCK_WAIT_TIME))
                {
                    try
                    {
                        //如果预览句柄已经存在，删除掉原来的句柄,用新的句柄替换
                        if (this.cameraVideoHandeDic.ContainsKey(cameraNo))
                        {
                            needToStopHandel = this.cameraVideoHandeDic[cameraNo];
                            this.videoHandleCameraDic.Remove(needToStopHandel);
                            this.cameraVideoHandeDic.Remove(cameraNo);
                        }
                        this.cameraVideoHandeDic.Add(cameraNo, result);
                        this.videoHandleCameraDic.Add(result, cameraNo);
                    }
                    finally
                    {
                        this.handelOperateLock.ExitWriteLock();
                    }
                }
                logEx.Info("Start Receive camera video data success.Camera No:{0},Handle:{1}.", cameraNo, result);
                //重新预览后，更新了预览句柄，需要将原来的预览停止，放在handelOperateLock外面，防止长时间占用锁
                if (needToStopHandel != CgwConst.START_RECEIVE_VIDEO_DATA_FAILED)
                {
                    this.sdkClient.StopReceiveVideo(needToStopHandel);
                }
            }

            return err;
        }

        /// <summary>
        /// 刷新监控摄像头列表
        /// </summary>
        /// <returns></returns>
        public SmcErr RefreshMonitorCamera()
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: TiandyVideoMonitor.RefreshMonitorCamera");
            SmcErr err = new CgwError();

            if (refreshMonitorCameraOperateLock.TryEnterWriteLock(CgwConst.EFRESH_MONITOR_CAMERA_WAIT_TIME))
            {
                try
                {
                    GetAllCamerasMethod();
                    //重新开始计时
                    updateCameraTimer.Stop();
                    updateCameraTimer.Start();
                }
                finally
                {
                    refreshMonitorCameraOperateLock.ExitWriteLock();
                }
            }
            logEx.Info("RefreshMonitorCamera success.");
            return err;
        }

        /// <summary>
        /// 获取监控摄像头列表刷新状态，返回结果为0是表示刷新完毕，为1是刷新操作中。当查询刷新状态为0时，可调用获取监控摄像头列表接口，获取刷新后监控摄像头列表
        /// </summary>
        /// <param name="refreshStatus">刷新状态</param>
        /// <returns></returns>
        public SmcErr GetRefreshStatus(out SmcErr refreshStatus)
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: TiandyVideoMonitor.GetRefreshStatus");
            SmcErr err = new CgwError();
            refreshStatus = new SmcErr();
            refreshStatus.ErrNo = CgwError.ERR_DEVICE_LIST_REFRESH_STATUS_END;

            if (refreshMonitorCameraOperateLock.TryEnterWriteLock(CgwConst.EFRESH_MONITOR_CAMERA_WAIT_TIME))
            {
                try
                {
                    refreshStatus.ErrNo = isRefreshSucess ? CgwError.ERR_DEVICE_LIST_REFRESH_STATUS_END : CgwError.ERR_DEVICE_LIST_REFRESH_STATUS_FAILED;
                }
                finally
                {
                    refreshMonitorCameraOperateLock.ExitWriteLock();
                }
            }
            else
            {
                refreshStatus.ErrNo = CgwError.ERR_DEVICE_LIST_REFRESH_STATUS_EXECUTING;
            }
            logEx.Info("GetRefreshStatus success.");
            return err;
        }

        /// <summary>
        /// 获取摄像头列表及分组信息
        /// </summary>
        private void GetAllCamerasMethod()
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: IvsVideoMonitor.GetAllCamerasMethod().");
            try
            {
                //1、获取系统中所有的域
                List<IvsDomainRoute> ivsDomainRouteList;

                logEx.Trace("Call ivsSdkClient.GetDomainRoute().");
                int result = this.ivsSdkClient.GetDomainRoute(out ivsDomainRouteList);

                if (result == CgwConst.IVS_SDK_SUCCESS_TAG)
                {
                    logEx.Info("GetDomainRoute success.List count:{0}", ivsDomainRouteList.Count);
                }
                else
                {
                    logEx.Error("GetDomainRoute failed.Ivs sdk error code:{0}", result);
                    ClearCamera();
                    isRefreshSucess = false;
                    return;
                }

                List<Camera> cameraListTemp = new List<Camera>();
                List<CameraGroup> groupListTemp = new List<CameraGroup>();
                List<NodeRelation> nodeRelationListTemp = new List<NodeRelation>();
                Dictionary<string, NodeRelation> nodeRelationDicTemp = new Dictionary<string, NodeRelation>();

                foreach (IvsDomainRoute route in ivsDomainRouteList)
                {
                    //加上此判断条件的话，子域将不会作查目录处理，不合理，故注释掉
                    //if (route.ParentDomain != "")
                    //{
                    //    continue;
                    //}
                    Dictionary<string, IvsCameraGroup> ivsCameraGroupDic;

                    logEx.Trace("Call ivsSdkClient.GetDeviceGroupList({0},{1}，out groupCount, out ivsCameraGroupDic).",
                                route.DomainCode,
                                CgwConst.IVS_SDK_ROOTGROUP_TAG);

                    result = this.ivsSdkClient.GetDeviceGroupList(route.DomainCode,
                                                             CgwConst.IVS_SDK_ROOTGROUP_TAG,
                                                             out ivsCameraGroupDic);

                    if (result == CgwConst.IVS_SDK_SUCCESS_TAG)
                    {
                        logEx.Info("GetDeviceGroupList success.Current group count:{0}", ivsCameraGroupDic.Count);
                    }
                    else
                    {
                        logEx.Error("GetDeviceGroupList failed.Ivs sdk error code:{0}", result);
                        ClearCamera();
                        isRefreshSucess = false;
                        return;
                    }

                    //域也当做分组使用
                    string encodeDomainNo = CgwConst.IVS_SDK_ROOTGROUP_TAG + CgwConst.IVS_SDK_DOMAINCODE_SEPARATOR_TAG + route.DomainCode;
                    CameraGroup domainGroup = new CameraGroup(encodeDomainNo, route.DomainName);
                    groupListTemp.Add(domainGroup);

                    List<string> pathDomainList = new List<string>();
                    RecursionGroupPath(route.DomainCode, ivsDomainRouteList,ref pathDomainList);
                    NodeRelation nodeDomainRelation = new NodeRelation(encodeDomainNo, pathDomainList, CgwMonitorManage.Common.NodeType.GROUP);
                    nodeRelationDicTemp.Add(encodeDomainNo, nodeDomainRelation);

                    foreach (KeyValuePair<string, IvsCameraGroup> ivsCameraGroupKeyValue in ivsCameraGroupDic)
                    {
                        IvsCameraGroup group = ivsCameraGroupKeyValue.Value;
                        string encodeGroupNo = group.GroupNo + CgwConst.IVS_SDK_DOMAINCODE_SEPARATOR_TAG + group.DomainCode;
                        //添加组信息
                        CameraGroup cameraGroup = new CameraGroup(encodeGroupNo, group.GroupName);
                        groupListTemp.Add(cameraGroup);

                        List<string> pathList = new List<string>();
                        RecursionPath(group.GroupNo, ivsCameraGroupDic, ref pathList);

                        NodeRelation nodeRelation = new NodeRelation(encodeGroupNo, pathList, CgwMonitorManage.Common.NodeType.GROUP);
                        nodeRelationDicTemp.Add(encodeGroupNo, nodeRelation);
                    }
                }
                //添加所有组节点
                nodeRelationListTemp.AddRange(nodeRelationDicTemp.Values);

                List<IvsCamera> ivsCameraPageList = new List<IvsCamera>();
                int cameraCount = 0;
                logEx.Trace("Call ivsSdkClient.GetDeviceList");

                //查询第一页记录，同时获取摄像头个数
                result = this.ivsSdkClient.GetDeviceList(CgwConst.PAGE_FIRST_INDEX, CgwConst.PAGE_LAST_INDEX, out cameraCount, out ivsCameraPageList);

                List<IvsCamera> ivsCameraLeaveList = new List<IvsCamera>();
                //如果总记录大于一页的总记录数
                if (cameraCount > CgwConst.PAGE_LAST_INDEX)
                {
//.........这里部分代码省略.........

        /// <summary>
        /// 停止预览
        /// </summary>
        /// <param name="cameraNo">摄像头编号</param>
        /// <returns>成功返回0，失败返回错误码</returns>
        public SmcErr StopReceiveVideo(string cameraNo)
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: IvsVideoMonitor.StopReceiveVideo({0}).", cameraNo);
            SmcErr err = new CgwError();
            //需要停止的预览句柄
            int needToStopHandel = CgwConst.START_RECEIVE_VIDEO_DATA_FAILED;
            if (this.handelOperateLock.TryEnterWriteLock(CgwConst.ENTER_LOCK_WAIT_TIME))
            {
                try
                {
                    if (this.cameraVideoHandeDic.ContainsKey(cameraNo))
                    {
                        needToStopHandel = this.cameraVideoHandeDic[cameraNo];
                        this.videoHandleCameraDic.Remove(needToStopHandel);
                        this.cameraVideoHandeDic.Remove(cameraNo);
                    }
                    else
                    {
                        logEx.Warn("Stop Receive camera video data failed. Don't need to end the preview.Camera No:{0}.", cameraNo);
                        //如果预览句柄不存在，不需要处理，直接返回
                        return err;
                    }
                }
                catch (Exception ex)
                {
                    err.SetErrorNo(CgwError.STOP_RECEIVE_VIDEO_FAILED);
                    logEx.Error("Stop Receive camera video data failed.Execption message:{0}", ex.Message);
                    return err;
                }
                finally
                {
                    this.handelOperateLock.ExitWriteLock();
                }
            }

            //调用sdk的停止方法，放在handelOperateLock外面，防止长时间占用锁
            if (needToStopHandel != CgwConst.START_RECEIVE_VIDEO_DATA_FAILED)
            {
                int result = this.ivsSdkClient.StopRealPlay(needToStopHandel);
                //如果不为0，表示预览失败
                if (result != CgwConst.IVS_SDK_SUCCESS_TAG)
                {
                    err.SetErrorNo(CgwError.STOP_RECEIVE_VIDEO_FAILED);
                    logEx.Error("Stop Receive camera video data failed.Ivs sdk error code:{0}", result);
                    return err;
                }
                logEx.Info("Stop Receive camera video data success.Camera No:{0},Handle:{1}.", cameraNo, needToStopHandel);
            }

            return err;
        }

 /// <summary>
 /// 开启服务函数
 /// </summary>
 static void StartService()
 {
     MonitorManageService inist = MonitorManageService.Instance();
     ServiceHost host = new ServiceHost(inist);
     inist.SetHost(host);
     host.Opened += delegate
     {
         NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
         Thread dbConnectionThread = new Thread(new ThreadStart(LoadMonitorTimer_Elapsed));
         dbConnectionThread.Start();
         logEx.Info("Enter: Start CgwMonitorManage.Service");
     };
     host.Open();
     ServiceBase.Run(inist);
 }

        /// <summary>
        /// 获取本机ip
        /// </summary>
        /// <returns></returns>
        private string GetLocalIP(string serverIP, int serverPort, int localPort)
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: SipStackAdapter.GetLocalIP().");

            try
            {
                IPAddress serverAddress = IPAddress.Parse(serverIP);
                IPAddress[] arrIPAddresses = Dns.GetHostAddresses(System.Environment.MachineName);
                foreach (IPAddress ip in arrIPAddresses)
                {
                    //如果serverIP为IPv4
                    if (serverAddress.AddressFamily.Equals(AddressFamily.InterNetwork) && ip.AddressFamily.Equals(serverAddress.AddressFamily))
                    {
                        #region IPv4
                        IPEndPoint serverEndpoint = new IPEndPoint(serverAddress, serverPort);
                        Socket socketClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                        IPEndPoint clientEndpoint = new IPEndPoint(ip, localPort);
                        socketClient.Bind(clientEndpoint);
                        try
                        {
                            socketClient.Connect(serverEndpoint);
                            if (socketClient.Connected)
                            {
                                logEx.Trace("SipStackAdapter.try GetLocalIP ={0}.", ip.ToString());
                                return ip.ToString();
                            }
                        }
                        catch (SocketException e)
                        {
                            //logEx.Warn("SipStackAdapter.GetLocalIP failed,e.ErrorCode:{0}", e.ErrorCode);

                            if (e.ErrorCode == 10061 || e.ErrorCode == 10048)   //Even No connection could be made because the target machine actively refused it ,but IP is valid.
                            {
                                logEx.Trace("SipStackAdapter.catch GetLocalIP ={0}.", ip.ToString());
                                return ip.ToString();
                            }

                            logEx.Error("SipStackAdapter.GetLocalIP failed.catch Execption message:{0}", e.Message);
                        }
                        finally
                        {
                            socketClient.Close();
                            logEx.Info("SipStackAdapter.GetLocalIP finally,Close the socketClient success");
                        }
                        #endregion
                    }
                    //如果serverIP为IPv6
                    else if (serverAddress.AddressFamily.Equals(AddressFamily.InterNetworkV6) && ip.AddressFamily.Equals(serverAddress.AddressFamily))
                    {
                        #region IPV6
                        IPEndPoint serverEndpoint = new IPEndPoint(serverAddress, serverPort);
                        Socket socketClient = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp);
                        IPEndPoint clientEndpoint = new IPEndPoint(ip, localPort);
                        socketClient.Bind(clientEndpoint);
                        try
                        {
                            socketClient.Connect(serverEndpoint);
                            if (socketClient.Connected)
                            {
                                logEx.Trace("SipStackAdapter.try GetLocalIP ={0}.", ip.ToString());
                                return ip.ToString();
                            }
                        }
                        catch (SocketException e)
                        {
                            //logEx.Warn("SipStackAdapter.GetLocalIP failed,e.ErrorCode:{0}", e.ErrorCode);

                            if (e.ErrorCode == 10061 || e.ErrorCode == 10048)   //Even No connection could be made because the target machine actively refused it ,but IP is valid.
                            {
                                logEx.Trace("SipStackAdapter.catch GetLocalIP ={0}.", ip.ToString());
                                return ip.ToString();
                            }

                            logEx.Error("SipStackAdapter.GetLocalIP failed.catch Execption message:{0}", e.Message);
                        }
                        finally
                        {
                            socketClient.Close();
                            logEx.Info("SipStackAdapter.GetLocalIP finally,Close the socketClient success");
                        }
                        #endregion
                    }
                }
                return null;
            }
            catch (System.Exception ex)
            {
                logEx.Error("SipStackAdapter.GetLocalIP failed.Execption message:{0}", ex.Message);
                return null;
            }
        }

//.........这里部分代码省略.........

                if (string.IsNullOrEmpty(localIP))
                {
                    localIP = GetLocalIP(domain, Convert.ToInt32(iSipPort), Convert.ToInt32(localPort));
                }
                string strLocal = localIP;

                //获取可用通道
                NetSourcedInterface.IVS_NETSOURCE_GetChannel(ref uiChannel);

                //用户参数,4字节整数
                IntPtr pUser = Marshal.AllocHGlobal(4);
                Marshal.Copy(new int[1] { Convert.ToInt32(uiChannel) }, 0, pUser, 1);

                //设置媒体流回调函数
                NetSourcedInterface.IVS_NETSOURCE_SetDataCallBack(uiChannel, cbDataCallBack, pUser);
                //异常回调函数
                IVS_NETSOURCE_RESULT iRet = NetSourcedInterface.IVS_NETSOURCE_SetExceptionCallBack(cbNetExceptionCallBack, pUser);

                //协议类型 UDP
                iRet = NetSourcedInterface.IVS_NETSOURCE_SetProtocolType(uiChannel, 1);
                if (iRet != IVS_NETSOURCE_RESULT.SUCCESS)
                {
                    logEx.Error("SipStackAdapter.StartRecvStream.IVS_NETSOURCE_SetProtocolType failed. cameraCode :{0},domain = {1},iSipPort ={2}", cameraCode, domain, iSipPort);
                    return CgwConst.T28181_ERROR_HANDLE;
                }

                iRet = NetSourcedInterface.IVS_NETSOURCE_SetLocalRecvStreamIP(uiChannel, localIP);
                if (iRet != IVS_NETSOURCE_RESULT.SUCCESS)
                {
                    logEx.Error("SipStackAdapter.StartRecvStream.IVS_NETSOURCE_SetLocalRecvStreamIP failed. cameraCode :{0},domain = {1},iSipPort ={2}", cameraCode, domain, iSipPort);
                    return CgwConst.T28181_ERROR_HANDLE;
                }

                iRet = NetSourcedInterface.IVS_NETSOURCE_GetLocalRecvStreamPort(uiChannel, ref  uiLocalRecvStreamVideoRtpPort, ref  uiLocalRecvStreamAudioRtpPort);
                if (iRet != IVS_NETSOURCE_RESULT.SUCCESS)
                {
                    logEx.Error("SipStackAdapter.StartRecvStream.IVS_NETSOURCE_GetLocalRecvStreamPort failed. cameraCode :{0},domain = {1},iSipPort ={2}", cameraCode, domain, iSipPort);
                    return CgwConst.T28181_ERROR_HANDLE;
                }

                //Invite消息体
                string strRealPlay = "v=0\r\n"
                                  + "o=" + cameraCode + @" 0 0 IN IP4 " + strLocal + "\r\n"
                                  + "s=Play\r\n"
                                  + "c=IN IP4 " + strLocal + "\r\n"
                                  + "t=0 0\r\n"
                                  + "m=video " + uiLocalRecvStreamVideoRtpPort + " RTP/AVP 96 98 97\r\n"
                                  + "a=recvonly\r\n"
                                  + "a=rtpmap:96 PS/90000\r\n"
                                  + "a=rtpmap:98 H264/90000\r\n"
                                  + "a=rtpmap:97 MPEG4/90000\r\n";

                //发送SIP Invite消息
                int iResponseID = 0;
                //制定字符串长度为1024
                StringBuilder strRemoteBody = new StringBuilder(1024);
                //发送SIP Invite消息
                EM_SIP_RESULT iSip = SIP_SDK_INVITE(cameraCode, strRealPlay, ref iResponseID, strRemoteBody);
                if (iSip != EM_SIP_RESULT.RET_SUCCESS)
                {
                    logEx.Error("SipStackAdapter.SIP_SDK_INVITE failed. cameraCode :{0},domain = {1},iSipPort ={2}", cameraCode, domain, iSipPort);
                    return CgwConst.T28181_ERROR_HANDLE;
                }

                //源端发送码流IP;
                string pRemoteSendStreamIp = "";
                //源端发送视频码流RTP端口号
                uint uiRemoteSendStreamVideoPort = 0;
                GetInviteRemoteIPPort(strRemoteBody.ToString(), ref pRemoteSendStreamIp, ref uiRemoteSendStreamVideoPort);

                iRet = NetSourcedInterface.IVS_NETSOURCE_OpenNetStream(uiChannel, pRemoteSendStreamIp, uiRemoteSendStreamVideoPort, 0);//无音频，传入0
                if (iRet != IVS_NETSOURCE_RESULT.SUCCESS)
                {
                    logEx.Error("SipStackAdapter.StartRecvStream failed. cameraCode :{0},domain = {1},iSipPort ={2}", cameraCode, domain, iSipPort);
                    return CgwConst.T28181_ERROR_HANDLE;
                }

                iRet = NetSourcedInterface.IVS_NETSOURCE_StartRecvStream(uiChannel);
                if (iRet == IVS_NETSOURCE_RESULT.SUCCESS)
                {
                    channelResponseIDDic.Add(uiChannel, iResponseID);
                    channelInPtrDic.Add(uiChannel, pUser);
                    logEx.Info("SipStackAdapter.StartRecvStream pChannel: {0}, cameraCode :{1},domain = {2},iSipPort ={3} ", uiChannel, cameraCode, domain, iSipPort);
                    return uiChannel;
                }
                else
                {
                    logEx.Error("SipStackAdapter.StartRecvStream failed. cameraCode :{0},domain = {1},iSipPort ={2}", cameraCode, domain, iSipPort);
                    StopRecvStream(uiChannel);
                    Marshal.FreeHGlobal(pUser);
                    return CgwConst.T28181_ERROR_HANDLE;
                }
            }
            catch (System.Exception ex)
            {
                logEx.Error("StartRecvStream failed.Exception message:{0},cameraCode :{0},domain = {1},iSipPort ={2}", ex.Message, cameraCode, domain, iSipPort);
                return CgwConst.T28181_ERROR_HANDLE;
            }
        }

        /// <summary>
        /// 该函数用于发送SIP Register消息
        /// </summary>
        public EM_SIP_RESULT SIP_SDK_REGISTER()
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: SipStackAdapter.SIP_SDK_REGISTER().");
            EM_SIP_RESULT iRet = EM_SIP_RESULT.RET_FAILURE;
            try
            {
                iRet = SipSDKInterface.SIP_SDK_REGISTER();

                if (iRet != EM_SIP_RESULT.RET_SUCCESS)
                {
                    logEx.Error("SipStackAdapter.SIP_SDK_REGISTER Error = {0}.", Enum.GetName(typeof(EM_SIP_RESULT), iRet));
                }
                else
                {
                    logEx.Info("SipStackAdapter.SIP_SDK_REGISTER Success");
                }
            }
            catch (System.Exception ex)
            {
                logEx.Error("SipStackAdapter.SIP_SDK_REGISTER ,Exception:{0}", ex.ToString());
                iRet = EM_SIP_RESULT.RET_FAILURE;
            }
            return iRet;
        }

        /// <summary>
        /// 该函数用于发送SIP Invite消息
        /// </summary>
        /// <param name="pAccount">对方账号</param>
        /// <param name="pSdpBody">SDP描述字符串</param>
        public EM_SIP_RESULT SIP_SDK_INVITE(string pAccount, string pSdpBody, ref int iResponseID, StringBuilder strRemoteBody)
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: SipStackAdapter.SIP_SDK_INVITE().");
            iResponseID = 0;
            EM_SIP_RESULT iRet = EM_SIP_RESULT.RET_FAILURE;
            try
            {
                iRet = SipSDKInterface.SIP_SDK_INVITE(pAccount, pSdpBody, ref iResponseID, strRemoteBody);
                SIP_SDK_ACK(iResponseID);
                if (iRet != EM_SIP_RESULT.RET_SUCCESS)
                {
                    logEx.Error("SipStackAdapter.SIP_SDK_INVITE ,pSdpBody:{0}", pSdpBody);
                }
                else
                {
                    logEx.Info("SipStackAdapter.SIP_SDK_INVITE ,iResponseID={0}", iResponseID);

                }
            }
            catch (System.Exception ex)
            {
                logEx.Error("SipStackAdapter.SIP_SDK_INVITE ,Exception:{0}", ex.ToString());
                iRet = EM_SIP_RESULT.RET_FAILURE;
            }
            return iRet;
        }

        /// <summary>
        /// 该函数用于发送SIP ACK消息
        /// </summary>
        /// <param name="iResponseID">iResponseID</param>
        public EM_SIP_RESULT SIP_SDK_ACK(int iResponseID)
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: SipStackAdapter.SIP_SDK_ACK().");
            EM_SIP_RESULT iRet = EM_SIP_RESULT.RET_FAILURE;
            try
            {
                iRet = SipSDKInterface.SIP_SDK_ACK(iResponseID);

                if (iRet != EM_SIP_RESULT.RET_SUCCESS)
                {
                    logEx.Error("SipStackAdapter.SIP_SDK_ACK ,iResponseID:{0}", iResponseID);
                }
                else
                {
                    logEx.Info("SipStackAdapter.SIP_SDK_ACK ,iResponseID={0}", iResponseID);
                }
            }
            catch (System.Exception ex)
            {
                logEx.Error("SipStackAdapter.SIP_SDK_ACK ,Exception:{0}", ex.ToString());
                iRet = EM_SIP_RESULT.RET_FAILURE;
            }
            return iRet;
        }

 /// <summary>
 /// 设置实况rtp数据包回调 
 /// </summary>
 /// <param name="dataCallBack"></param>
 public void SetNetDataCallBack(NET_DATA_CALLBACK dataCallBack, NET_EXCEPTION_CALLBACK netExceptionCallBack)
 {
     NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
     logEx.Trace("Enter: SipStackAdapter.SetNetDataCallBack().");
     cbDataCallBack = dataCallBack;
     cbNetExceptionCallBack = netExceptionCallBack;
     logEx.Info("Set SetNetDataCallBack success");
 }