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

 /// <summary>
 /// sip保活
 /// </summary>
 /// <param name="localSignalGateway">网关对接T28181监控平台时，网关视为监控平台外域，该编码是标识网关的域编码，即是监控平台配置界面添加网关时的外域编码。</param>
 public void StartKeepalive(string serverID, string localID)
 {
     NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
     logEx.Trace("Enter: T28181VideoMonitor.StartConnectRegisterSip().");
     EM_SIP_RESULT iRet = EM_SIP_RESULT.RET_FAILURE;
     //初始话定时器
     this.keepLiveTimer.AutoReset = true;
     this.keepLiveTimer.Elapsed += new System.Timers.ElapsedEventHandler((x, y)
         =>
         {
             //sip保活,deviceID为用户名
             string strBody = @"<?xml version='1.0'?><Notify><CmdType>Keepalive</CmdType><SN>" + KeepaliveSN + "</SN><DeviceID>" + localID + "</DeviceID><Status>OK</Status></Notify>";
             KeepaliveSN++;
             iRet = SipSDKInterface.SIP_SDK_MESSAGE(serverID, strBody);
             if (iRet != EM_SIP_RESULT.RET_SUCCESS)
             {
                 logEx.Warn("SipStackAdapter.Keepalive Failed");
                 //保活失败，重新注册. zWX231378 .2015/6/24
                 SIP_SDK_REGISTER();
             }
             else
             {
                 logEx.Trace("SipStackAdapter.Keepalive Success");
             }
         });
     //保活时间为10秒
     this.keepLiveTimer.Interval = CgwConst.Thread_Sleep_Time * 10;
     keepLiveTimer.Start();
 }

        /// <summary>
        /// 根据消息体解析设备
        /// </summary>
        /// <param name="strBody">查询返回的消息</param>
        private static void GetDeviceItem(string strBody)
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: SipStackAdapter.GetDeviceItem().");

            //解析返回的XML数据返回数据对象
            XmlNode node = XmlUtil.ProcessResponseMsg(strBody, "DeviceList");
            List<DeviceItem> list = XmlUtil.DeserializeToList<DeviceItem>(node);

            if (list == null)
            {
                return;
            }

            try
            {
                foreach (DeviceItem item in list)
                {
                    if (!deviceList.Contains(item, new DeviceItemCompare()))
                    {
                        deviceList.Add(item);
                    }
                    else
                    {
                        logEx.Warn("SipStackAdapter.GetDeviceItem DeviceItem.DeviceID = {0} duplicate", item.DeviceID);
                        return;
                    }
                }

                //获取数据完成
                if (deviceNum == deviceList.Count)
                {
                    if (ReceivedAllDevice != null)
                    {
                        logEx.Trace("SipStackAdapter.GetDeviceItem Start ReceivedAllDevice");
                        // 接收完所有设备，通知上层处理单元
                        ReceivedAllDevice(null, null);

                        //回收系统内存
                        GC.Collect();
                        GC.WaitForFullGCComplete(CgwConst.Thread_Sleep_Time);
                    }
                }
            }
            catch (System.Exception ex)
            {
                logEx.Error("SipStackAdapter Get all cameras failed.Execption message:{0}", ex.Message);
            }
        }

        /// <summary>
        /// 断开监控管理连接
        /// </summary>
        /// <returns></returns>
        public SmcErr Disconnect()
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            SmcErr err = new CgwError();
            if (OperationContext.Current != null)
            {
                //string strSessionId = OperationContext.Current.SessionId;
                string strSessionId = currentSessionID;
                if (!string.IsNullOrEmpty(strSessionId))
                {
                    err = SessionManage.Instance().RemoveSessionBySessionId(strSessionId);
                    logEx.Info("Client DisConnect MonitorManageService Successful,Current.Cgw IP is : {0}", CgwConst.ClientIp);
                }
                else
                {
                    err.SetErrorNo(CgwError.ERR_CGW_BUSINESS_CURRENTSESSION_NULL);
                    logEx.Warn("Current SessionId is null ! ");
                }
            }
            else
            {
                err.SetErrorNo(CgwError.ERR_CGW_BUSINESS_CURRENTSESSION_NULL);
                logEx.Warn("Current SessionId is null ! ");
            }

            return err;

        }

        /// <summary>
        /// 连接融合网关
        /// </summary>
        /// <param name="password">连接字符串</param>
        /// <returns></returns>
        public SmcErr Connect(out string sessionID)
        {
            SmcErr err = new CgwError();
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            sessionID = "";
            if (isLoadSuccess == false)
            {
                err.SetErrorNo(CgwError.ERR_CGW_IS_LOADING);
                return err;
            }

            //获取SessionManage中Session个数
            if (SessionManage.Instance().GetSessionsCount() == 0)
            {
                Guid sessionGuid = Guid.NewGuid();

                sessionID = OperationContext.Current.SessionId;
                currentSessionID = sessionID;
                //保存至CGW的session管理中
                CgwSession CgwSession = new CgwSession(sessionGuid, OperationContext.Current.SessionId);

                MessageProperties properties = OperationContext.Current.IncomingMessageProperties;   //获取传进的消息属性  

                RemoteEndpointMessageProperty endpoint = properties[RemoteEndpointMessageProperty.Name] as RemoteEndpointMessageProperty; //获取消息发送的远程终结点IP和端口 
                if (endpoint != null)
                {
                    CgwConst.ClientIp = endpoint.Address; // 获取发送消息的客户端的 IP 地址。
                    logEx.Info("Client Connect MonitorManageService Successful,Current.Client IP is : {0}", CgwConst.ClientIp);
                }
                else
                {
                    logEx.Info("Client Connect MonitorManageService Successful,Current.Client IP is  null.");
                }
            }
            else
            {
                err.SetErrorNo(CgwError.ERR_CGW_BUSINESS_SESSION_COUNT_MAX);
                logEx.Warn("Session Count is  Top Of Max number !");
            }

            return err;
        }

        /// <summary>
        /// 停止云台控制，摄像头控制
        /// </summary>
        /// <param name="cameraNo">摄像头编号</param>
        /// <param name="ptzCommand">命令类型</param>
        /// <returns></returns>
        public SmcErr StopControlPtz(string cameraNo, PtzCommandType ptzCommand)
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: TiandyVideoMonitor.StopControlPtz({0}).", cameraNo);
            SmcErr err = new CgwError();

            int handel = CgwConst.START_RECEIVE_VIDEO_DATA_FAILED;
            if (this.handelOperateLock.TryEnterReadLock(CgwConst.ENTER_LOCK_WAIT_TIME))
            {
                try
                {
                    if (this.cameraVideoHandeDic.ContainsKey(cameraNo))
                    {
                        handel = this.cameraVideoHandeDic[cameraNo];
                    }
                    else
                    {
                        logEx.Warn("The camera was not Preview.Don't need to end the control.Camera No:{0}.", cameraNo);
                    }
                }
                finally
                {
                    this.handelOperateLock.ExitReadLock();
                }

            }

            if (handel != CgwConst.START_RECEIVE_VIDEO_DATA_FAILED)
            {
                Client_PTZ_Command client_ptz_command = new Client_PTZ_Command();
                client_ptz_command.start = false;

                //将ptz命令转换成天地伟业的命令
                string name = Enum.GetName(typeof(PtzCommandType), ptzCommand);
                if (Enum.IsDefined(typeof(TiandyPtzCommandType), name))
                {
                    TiandyPtzCommandType tiandyPtzCommandType = (TiandyPtzCommandType)Enum.Parse(typeof(TiandyPtzCommandType), name);
                    client_ptz_command.cmd = (int)tiandyPtzCommandType;
                }
                else
                {
                    err.SetErrorNo(CgwError.STOP_CONTROL_PTZ_FAILED);
                    logEx.Error("The tiandy monitor is not support the command.ptzCommand:{0}.", ptzCommand);
                    return err;
                }

                bool result = this.sdkClient.ControlPtz(handel, client_ptz_command);
                if (result)
                {
                    logEx.Info("Stop control camera ptz success.Camera No:{0}.", cameraNo);
                }
                else
                {
                    err.SetErrorNo(CgwError.STOP_CONTROL_PTZ_FAILED);
                    logEx.Error("Stop control camera ptz failed.Camera No:{0}.", cameraNo);
                }
            }
            else
            {
                err.SetErrorNo(CgwError.STOP_CONTROL_PTZ_FAILED);
                logEx.Error("Handel is not found. Stop control camera ptz failed. Camera No:{0}.", cameraNo);
                return err;
            }

            return err;
        }

        /// <summary>
        /// 写日志回调函数
        /// </summary>
        /// <param name="level"></param>
        /// <param name="log"></param>
        /// <param name="len"></param>
        /// <returns></returns>
        private uint WriteLog(NLogLevel level, string log, int len)
        {
            NLog.Logger sotLog = NLog.LogManager.GetLogger("SoftTerminal");
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(sotLog);

            try
            {
                switch (level)
                {
                    case NLogLevel.Error:
                        logEx.Error(log);
                        break;
                    case NLogLevel.Warn:
                        logEx.Warn(log);
                        break;
                    case NLogLevel.Info:
                        logEx.Info(log);
                        break;
                    case NLogLevel.Trace:
                        logEx.Trace(log);
                        break;
                    default:
                        break;
                }
            }
            catch (System.Exception ex)
            {
                logEx.Error(ex, "WriteLog Exception level:{0}, log:{1}.", level, log);
            }

            return 1;
        }

        /// <summary>
        /// 停止预览
        /// </summary>
        /// <param name="cameraNo">摄像头编号</param>
        /// <returns>成功返回0，失败返回错误码</returns>
        public SmcError.SmcErr StopReceiveVideo(string cameraNo)
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: eLTEVideoMonitor.StopReceiveVideo({0}).", cameraNo);
            SmcErr err = new CgwError();
            //需要停止的预览句柄
            uint needToStopChannel = CgwConst.T28181_ERROR_HANDLE;
            if (this.handelOperateLock.TryEnterWriteLock(CgwConst.ENTER_LOCK_WAIT_TIME))
            {
                try
                {
                    if (this.cameraVideoChannelDic.ContainsKey(cameraNo))
                    {
                        needToStopChannel = this.cameraVideoChannelDic[cameraNo];
                        this.videoChannelDataSenderDic.Remove(needToStopChannel);
                        this.cameraVideoChannelDic.Remove(cameraNo);

                        //释放用户数据内存 
                        foreach (KeyValuePair<UInt32, IntPtr> kvp in channelInPtrDic)
                        {
                            if (kvp.Key == needToStopChannel)
                            {
                                Marshal.FreeHGlobal(kvp.Value);
                                channelInPtrDic.Remove(kvp.Key);
                                break;
                            }
                        }

                        //用户参数,4字节整数
                        IntPtr pUser = Marshal.AllocHGlobal(4);
                        NetSourcedInterface.IVS_NETSOURCE_SetDataCallBack(needToStopChannel, null, pUser);
                        //释放NETSOURCE通道资源
                        IVS_NETSOURCE_RESULT iNet = NetSourcedInterface.IVS_NETSOURCE_CloseNetStream(needToStopChannel);
                        if (iNet != IVS_NETSOURCE_RESULT.SUCCESS)
                        {
                            logEx.Error("IVS_NETSOURCE_CloseNetStream failed channel={0}", needToStopChannel);
                            err.SetErrorNo(CgwError.STOP_RECEIVE_VIDEO_FAILED);
                        }

                        iNet = NetSourcedInterface.IVS_NETSOURCE_FreeChannel(needToStopChannel);
                        if (iNet != IVS_NETSOURCE_RESULT.SUCCESS)
                        {
                            logEx.Error("IVS_NETSOURCE_FreeChannel failed channel={0}", needToStopChannel);
                            err.SetErrorNo(CgwError.STOP_RECEIVE_VIDEO_FAILED);
                        }

                        //关闭rtp回调
                        rtpAdapter.ESDK_RTP_CloseChannel(needToStopChannel);
                    }
                    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 (needToStopChannel != CgwConst.T28181_ERROR_HANDLE)
            {
                ELTE_RESULT result = (ELTE_RESULT)this.lteSdkClient.StopP2PVideo(Convert.ToInt32(cameraNo));
                //如果不为0，表示预览失败
                if (result != ELTE_RESULT.RET_SUCCESS)
                {
                    err.SetErrorNo(CgwError.STOP_RECEIVE_VIDEO_FAILED);
                    logEx.Error("Stop Receive camera video data failed.eLTE sdk error code:{0}", result);
                    return err;
                }
                logEx.Info("Stop Receive camera video data success.Camera No:{0},Handle:{1}.", cameraNo, needToStopChannel);
            }
            return err;
        }

        /// <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>
        /// 获取摄像头列表及分组信息定时器
        /// 1、获取系统中所有的域
        /// 2、循环所有的域，查询域下面的分组，递归处理，获取节点关系
        /// 3、查询设备列表
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void GetAllCamerasTimer(object sender, System.Timers.ElapsedEventArgs e)
        {
            //查询设备未完成，需要阻塞直到查询结束
            System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();

            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: T28181VideoMonitor.GetAllCamerasTimer().");

            try
            {
                //获取设备列表
                sipStack.GetDeviceList(username, deviceID);
                //开始计时
                stopwatch.Start();

                //查询结束或者超时时结束等待
                while (!getDeviceEndFlg && stopwatch.ElapsedMilliseconds < iQueryDeviceTimeOut )
                {
                    Thread.Sleep(CgwConst.Thread_Sleep_Time);
                }
                if (stopwatch.ElapsedMilliseconds >= iQueryDeviceTimeOut)
                {
                    logEx.Warn("GetAllCamerasTimer Timeout");
                }
            }
            catch (System.Exception ex)
            {
                logEx.Error("GetAllCamerasTimer failed.Exception message:{0}", ex.Message);
            }
            finally
            {
                //停止计时、获取设备完成标志复位
                stopwatch.Stop();
                getDeviceEndFlg = false;

                logEx.Info("cameraList.{0}", cameraList.Count);
                logEx.Info("groupList.{0}", groupList.Count);
                logEx.Info("nodeRelationList.{0}", nodeRelationList.Count);
                logEx.Trace("Leave: T28181VideoMonitor.GetAllCamerasTimer().");
            }
        }

        /// <summary>
        /// 停止预览
        /// </summary>
        /// <param name="cameraNo">摄像头编号</param>
        /// <returns>成功返回0，失败返回错误码</returns>
        public SmcErr StopReceiveVideo(string cameraNo)
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: T28181VideoMonitor.StopReceiveVideo({0}).", cameraNo);
            SmcErr err = new CgwError();
            //需要停止的预览句柄
            uint needToStopChannel = 0;
            if (this.handelOperateLock.TryEnterWriteLock(CgwConst.ENTER_LOCK_WAIT_TIME))
            {
                try
                {
                    if (this.cameraVideoChannelDic.ContainsKey(cameraNo))
                    {
                        needToStopChannel = this.cameraVideoChannelDic[cameraNo];
                        this.videoChannelDataSenderDic.Remove(needToStopChannel);
                        this.cameraVideoChannelDic.Remove(cameraNo);
                        //关闭rtp回调
                        rtpAdapter.ESDK_RTP_CloseChannel(needToStopChannel);
                    }
                    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 (needToStopChannel != 0)
            {
                int result = sipStack.StopRecvStream(needToStopChannel);
                //如果不为0，表示预览失败
                if (result != CgwConst.IVS_SDK_SUCCESS_TAG)
                {
                    err.SetErrorNo(CgwError.STOP_RECEIVE_VIDEO_FAILED);
                    logEx.Error("Stop Receive camera video data failed. error code:{0}", result);
                    return err;
                }
                logEx.Info("Stop Receive camera video data success.Camera No:{0},Handle:{1}.", cameraNo, needToStopChannel);
            }

            return err;
        }

        /// <summary>
        /// 初始化监控平台
        /// </summary>
        /// <returns></returns>
        public SmcErr Load()
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Info("Enter: VideoMonitorManage.Load()");
            SmcErr err = new CgwError();
            XmlElement monitorsRootElement = ConfigSettings.MonitorSettings;
            if (monitorsRootElement == null)
            {
                err.SetErrorNo(CgwError.MONITOR_CONFIG_FILE_INVALID);
                logEx.Error("Monitor config file is invalid.Can not found monitorSettings node.");
                return err;
            }

            foreach (XmlNode monitorNode in monitorsRootElement)
            {
                XmlElement monitorElement = monitorNode as XmlElement;

                if (monitorElement == null)
                {
                    continue;
                }
                else if (CgwConst.MONITOR_TAG.Equals(monitorElement.Name))
                {
                    //判断监控平台是否启用
                    string isEnable = monitorElement.GetAttribute(CgwConst.ENABLE_TAG).Trim();
                    if (!CgwConst.TRUE_TAG.Equals(isEnable.ToLower()))
                    {
                        logEx.Warn("This monitor is disable.");
                        continue;
                    }

                    string monitorId;
                    string className;
                    err = GetMonitorConfig(monitorElement, out monitorId, out className);

                    if (!err.IsSuccess())
                    {
                        return err;
                    }

                    IVideoMonitor videoMonitor;
                    //加载监控平台
                    err = CreateMonitor(monitorId, className, out videoMonitor);
                    if (!err.IsSuccess())
                    {
                        logEx.Error("Create monitor failed.monitorId:{0}, className:{1}, Error code:{2}", monitorId, className, err.ErrNo);
                        return err;
                    }

                    err = videoMonitor.Load(monitorElement);
                    if (err.IsSuccess())
                    {
                        if (this.monitorsOperateLock.TryEnterWriteLock(CgwConst.ENTER_LOCK_WAIT_TIME))
                        {
                            try
                            {
                                monitorsDictionary.Add(monitorId, videoMonitor);
                            }
                            catch (Exception e)
                            {
                                logEx.Error("Load monitor failed.Execption message:{0}", e.Message);
                                return err;
                            }
                            finally
                            {
                                this.monitorsOperateLock.ExitWriteLock();
                            }
                        }
                    }
                    else
                    {
                        logEx.Error("Load monitor failed.MonitorId:{0},Error code:{1}", monitorId, err.ErrNo);
                        return err;
                    }
                }
            }

            logEx.Info("Load all monitors success.");
            return err;
        }

        /// <summary>
        /// 停止预览
        /// </summary>
        /// <param name="cameraNo">摄像头编号</param>
        /// <returns>成功返回0，失败返回错误码</returns>
        public SmcErr StopReceiveVideo(string cameraNo)
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: T28181VideoMonitor.StopReceiveVideo({0}).", cameraNo);
            SmcErr err = new CgwError();
            //需要停止的预览句柄
            uint needToStopChannel = 0;
            if (this.handelOperateLock.TryEnterWriteLock(CgwConst.ENTER_LOCK_WAIT_TIME))
            {
                try
                {
                    if (this.cameraVideoChannelDic.ContainsKey(cameraNo))
                    {
                        needToStopChannel = this.cameraVideoChannelDic[cameraNo];
                        this.videoChannelDataSenderDic.Remove(needToStopChannel);
                        this.cameraVideoChannelDic.Remove(cameraNo);

                        //用户参数,4字节整数
                        IntPtr pUser = Marshal.AllocHGlobal(4);
                        NetSourcedInterface.IVS_NETSOURCE_SetDataCallBack(needToStopChannel, null, pUser);

                        //释放NETSOURCE通道资源
                        IVS_NETSOURCE_RESULT iNet = NetSourcedInterface.IVS_NETSOURCE_CloseNetStream(needToStopChannel);
                        if (iNet != IVS_NETSOURCE_RESULT.SUCCESS)
                        {
                            logEx.Error("IVS_NETSOURCE_CloseNetStream failed channel={0}", needToStopChannel);
                            err.SetErrorNo(CgwError.STOP_RECEIVE_VIDEO_FAILED);
                        }

                        //关闭rtp回调
                        rtpAdapter.ESDK_RTP_CloseChannel(needToStopChannel);
                    }
                    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 (needToStopChannel != 0)
            {
                EM_SIP_RESULT iRet = sipStack.StopRecvStream(needToStopChannel);
                //如果不为0，表示预览失败
                if (iRet != EM_SIP_RESULT.RET_SUCCESS)
                {
                    err.SetErrorNo(CgwError.STOP_RECEIVE_VIDEO_FAILED);
                    logEx.Error("Stop Receive camera video data failed. error code:{0}", iRet);
                    return err;
                }
                logEx.Info("Stop Receive camera video data success.Camera No:{0},Handle:{1}.", cameraNo, needToStopChannel);
            }

            return err;
        }

        /// <summary>
        /// 连接融合网关
        /// </summary>
        /// <param name="cgwPwd">连接字符串</param>
        /// <returns></returns>
        public SmcErr Connect(string cgwPwd)
        {
            SmcErr err = new CgwError();
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            if (isLoadSuccess == false)
            {
                err.SetErrorNo(CgwError.ERR_CGW_IS_LOADING);
                return err;
            }
            //if (false == string.IsNullOrEmpty(cgwPwd))
            //{

                ////进行SHA256加密
                //string newPassword = CommonFunction.SHA256Encrypt(strPwd);
                //保存当前会话
                //if (newPassword == cgwPwd)
                //{
                    //获取SessionManage中Session个数
                    if (SessionManage.Instance().GetSessionsCount() == 0)
                    {
                        Guid sessionGuid = Guid.NewGuid();
                        //保存至CGW的session管理中
                        CgwSession CgwSession = new CgwSession(sessionGuid, OperationContext.Current.SessionId);

                        isChangeLic = false;
                        MessageProperties properties = OperationContext.Current.IncomingMessageProperties;   //获取传进的消息属性

                        RemoteEndpointMessageProperty endpoint = properties[RemoteEndpointMessageProperty.Name] as RemoteEndpointMessageProperty; //获取消息发送的远程终结点IP和端口
                        if (endpoint != null)
                        {
                            CgwConst.SmcIp = endpoint.Address; // 获取发送消息的客户端的 IP 地址。
                            logEx.Info("SMC Connect CgwService Successful,Current.SMC IP is : {0}", CgwConst.SmcIp);
                        }
                        else
                        {
                            logEx.Info("SMC Connect CgwService Successful,Current.SMC IP is  null.");
                        }
                    }
                    else
                    {
                        err.SetErrorNo(CgwError.ERR_CGW_BUSINESS_SESSION_COUNT_MAX);
                        logEx.Warn("Session Count is  Top Of Max number !");
                    }

                //}
                //else
                //{
                //    err.SetErrorNo(CgwError.ERR_CGW_BUSINESS_PASSWORD_INCORRECT);
                //    logEx.Error("Connect Password is Incorrect !");
                //}
            //}
            //else
            //{
            //    err.SetErrorNo(CgwError.ERR_CGW_BUSINESS_PASSWORD_NULL);
            //    logEx.Error("Connect Password is null !");
            //}
            return err;
        }

        /// <summary>
        /// 断开融合网关
        /// </summary>
        /// <returns></returns>
        public SmcErr DisConnect()
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            SmcErr err = new CgwError();
            if (OperationContext.Current != null)
            {
                string strSessionId = OperationContext.Current.SessionId;
                if (!string.IsNullOrEmpty(strSessionId))
                {
                    err = SessionManage.Instance().RemoveSessionBySessionId(strSessionId);
                    logEx.Trace("DisConnect Successful,Current.SessionId is : ", strSessionId);
                }
                else
                {
                    err.SetErrorNo(CgwError.ERR_CGW_BUSINESS_CURRENTSESSION_NULL);
                    logEx.Warn("Current SessionId is null ! ");
                }
            }
            else
            {
                err.SetErrorNo(CgwError.ERR_CGW_BUSINESS_CURRENTSESSION_NULL);
                logEx.Warn("Current SessionId is null ! ");
            }

            return err;
        }

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

            try
            {
                IPAddress serverAddress = IPAddress.Parse(serverIP);
                //IPAddress[] arrIPAddresses = Dns.GetHostAddresses(Dns.GetHostName());
                IPAddress[] arrIPAddresses = Dns.GetHostAddresses(System.Environment.MachineName);
                foreach (IPAddress ip in arrIPAddresses)
                {
                    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("eLTEVideoMonitor.try GetLocalIP ={0}.", ip.ToString());
                                return ip.ToString();
                            }
                            else
                            {
                                logEx.Info("socketClient is not Connected.");
                            }
                        }
                        catch (SocketException e)
                        {
                            logEx.Warn("eLTEVideoMonitor.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("eLTEVideoMonitor.catch GetLocalIP ={0}.", ip.ToString());
                                return ip.ToString();
                            }
                        }
                        finally
                        {
                            socketClient.Close();
                            logEx.Info("eLTEVideoMonitor.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("eLTEVideoMonitor.GetLocalIP failed.serverIP={0},serverPort={1},localPort={2},Execption message:{0}", serverIP, serverPort, localPort, ex.Message);
                return null;
            }
        }