private void Client_ReceiveCompleted(object sender, SocketHelper.Events.ReceiveEventArgs args)
        {
            if (args.ByteLength > 0)
            {
                using (MemoryStream ms = new MemoryStream(args.ReceivedBytes))
                {
                    using (BinaryReader br = new BinaryReader(ms))
                    {
                        int code = br.ReadInt32();
                        switch ((ParamCode)code)
                        {
                        case ParamCode.TimePeriods:
                        {
                            OnVideoDataInfoReceived(VideoTimePeriodsPacket.Decode(ms));
                        }
                        break;

                        case ParamCode.LocalDownSource:
                        {
                            OnTreeNodesReceived(LocalVideosInfoPacket.Decode(ms));
                        }
                        break;

                        case ParamCode.Message:
                            onMessage(MessagePacket.Decode(ms));
                            break;
                        }
                    }
                }
            }
        }
Example #2
0
        private static void Sc_ReceiveCompleted(object sender, SocketHelper.Events.ReceiveEventArgs args)
        {
            if (args.ByteLenght >= 4)
            {
                int code = BitConverter.ToInt32(args.ReceivedBytes, 0);
                switch (code)
                {
                case StreamEntityCode.FfmpegHeader:
                {
                    Console.WriteLine("FFmpeg包头Received:" + (args.ByteLenght - 4));
                }
                break;

                case StreamEntityCode.HikvHeader:
                {
                    Console.WriteLine("Hikv包头Received:" + (args.ByteLenght - 4));
                }
                break;

                case StreamEntityCode.StreamData:
                {
                    Console.WriteLine("码流数据Received:" + (args.ByteLenght - 4));
                }
                break;
                }
            }
        }
Example #3
0
        private void _adapter_ReceiveCompleted(object sender, SocketHelper.Events.ReceiveEventArgs args)
        {
            if (args.ByteLenght >= 4)
            {
                int code = BitConverter.ToInt32(args.ReceivedBytes, 0);
                switch (code)
                {
                case MessageCode.StartServer:
                {
                    GatewayServer.StartServer();
                }
                break;

                case MessageCode.StopServer:
                {
                    GatewayServer.StopServer();
                }
                break;

                case MessageCode.StartRegister:
                {
                    StringPacket sp = StringPacket.DeserializeObject(args.ReceivedBytes);
                    GatewayServer.StartRegister(sp.Content);
                }
                break;

                case MessageCode.StopRegister:
                {
                    StringPacket sp = StringPacket.DeserializeObject(args.ReceivedBytes);
                    GatewayServer.StopRegister(sp.Content);
                }
                break;

                case MessageCode.IsServerStarted:
                {
                    send(new BoolPacket(code, GatewayServer.IsServerStarted()));
                }
                break;

                case MessageCode.IsSuperiorOnline:
                {
                    StringPacket sp = StringPacket.DeserializeObject(args.ReceivedBytes);
                    send(new BoolPacket(code, GatewayServer.IsSuperOnline(sp.Content)));
                }
                break;

                case MessageCode.ShareDevice:
                {
                    StringPacket sp = StringPacket.DeserializeObject(args.ReceivedBytes);
                    GatewayServer.ShareToPlatform(sp.Content);
                }
                break;
                }
            }
        }
Example #4
0
 private void Client_ReceiveCompleted(object sender, SocketHelper.Events.ReceiveEventArgs args)
 {
     if (args.ByteLength == 4)
     {
         if (BitConverter.ToInt32(args.ReceivedBytes, 0) == (int)ParamCode.EnsureConnect)
         {
             if (_waitHandle != null)
             {
                 _waitHandle.Set();
             }
         }
     }
 }
Example #5
0
        private void _client_ReceiveCompleted(object sender, SocketHelper.Events.ReceiveEventArgs args)
        {
            if (args.ByteLenght >= 4)
            {
                int code = BitConverter.ToInt32(args.ReceivedBytes, 0);
                switch (code)
                {
                case MessageCode.EnsureConnect:
                    if (_ensureConn != null)
                    {
                        _ensureConn.Set();
                    }
                    break;

                case MessageCode.StartServer:
                    break;

                case MessageCode.StopServer:
                    break;

                case MessageCode.StartRegister:
                    break;

                case MessageCode.StopRegister:
                    break;

                case MessageCode.IsServerStarted:
                case MessageCode.IsSuperiorOnline:
                case MessageCode.IsLowerOnline:
                    _receiveObj = BoolPacket.DeserializeObject(args.ReceivedBytes);
                    if (_wait != null)
                    {
                        _wait.Set();
                    }
                    break;
                }
            }
        }
Example #6
0
 private void _adapter_ReceiveCompleted(object sender, SocketHelper.Events.ReceiveEventArgs args)
 {
     if (args.ByteLenght >= 4)
     {
         int code = BitConverter.ToInt32(args.ReceivedBytes, 0);
         switch (code)
         {
         case StreamEntityCode.StreamAddress:
         {
             StreamAddress sa = StreamAddress.DeserializeTo(args.ReceivedBytes);
             destoryLinker();
             Console.WriteLine("Uri:" + sa.Url);
             _linker = StreamLinkerManager.Instance.GetStreamLinker(sa);
             if (_linker != null)
             {
                 _linker.StreamHeaderReceived += linker_StreamHeaderReceived;
                 _linker.StreamDataReceived   += linker_StreamDataReceived;
                 _linker.ErrorOccurred        += linker_ErrorOccurred;
             }
         }
         break;
         }
     }
 }