C# OpenMetaverse.NetworkManager类代码示例

 /// <summary>
 /// Register an event handler
 /// </summary>
 /// <remarks>Use PacketType.Default to fire this event on every 
 /// incoming packet</remarks>
 /// <param name="packetType">Packet type to register the handler for</param>
 /// <param name="eventHandler">Callback to be fired</param>
 public void RegisterEvent(PacketType packetType, NetworkManager.PacketCallback eventHandler)
 {
     lock (_EventTable)
     {
         if (_EventTable.ContainsKey(packetType))
             _EventTable[packetType] += eventHandler;
         else
             _EventTable[packetType] = eventHandler;
     }
 }

 public static void DisconnectHandler(NetworkManager.DisconnectType type, string message)
 {
     if (type == NetworkManager.DisconnectType.NetworkTimeout)
     {
         Console.WriteLine("Network connection timed out, disconnected");
     }
     else if (type == NetworkManager.DisconnectType.ServerInitiated)
     {
         Console.WriteLine("Server disconnected us: " + message);
     }
 }

 public void RegisterLoginResponseCallback(NetworkManager.LoginResponseCallback callback, string[] options)
 {
     return;
 }

 private void Network_OnDisconnected(NetworkManager.DisconnectType reason, string message)
 {
     if (InterpolationTimer != null)
     {
         InterpolationTimer.Dispose();
         InterpolationTimer = null;
     }
 }

 public void Network_OnDisconnected(NetworkManager.DisconnectType reason, string message)
 {
     if (OnDisconnected != null)
     {
         OnDisconnected(this, EventType.DISCONNECTED);
     }
 }

        /// <summary>
        /// Group Management Routines, Methods and Packet Handlers
        /// </summary>
        /// <param name="client">A reference to the current <seealso cref="GridClient"/> instance</param>
        public GroupManager(LoggerInstance log, NetworkManager network, AgentManager self)
        {
            Log = log;
            Network = network;
            Self = self;

            GroupMembersCaches = new InternalDictionary<UUID, Dictionary<UUID, GroupMember>>();
            GroupMembersRequests = new List<UUID>();
            GroupRolesCaches = new InternalDictionary<UUID, Dictionary<UUID, GroupRole>>();
            GroupRolesRequests = new List<UUID>();
            GroupRolesMembersCaches = new InternalDictionary<UUID, List<KeyValuePair<UUID, UUID>>>();
            GroupRolesMembersRequests = new List<UUID>();
            GroupName2KeyCache  = new InternalDictionary<UUID, string>();

            Network.RegisterEventCallback("AgentGroupDataUpdate", new Caps.EventQueueCallback(AgentGroupDataUpdateHandler));
            Network.RegisterCallback(PacketType.AgentDropGroup, new NetworkManager.PacketCallback(AgentDropGroupHandler));
            Network.RegisterCallback(PacketType.GroupTitlesReply, new NetworkManager.PacketCallback(GroupTitlesHandler));
            Network.RegisterCallback(PacketType.GroupProfileReply, new NetworkManager.PacketCallback(GroupProfileHandler));
            Network.RegisterCallback(PacketType.GroupMembersReply, new NetworkManager.PacketCallback(GroupMembersHandler));
            Network.RegisterCallback(PacketType.GroupRoleDataReply, new NetworkManager.PacketCallback(GroupRoleDataHandler));
            Network.RegisterCallback(PacketType.GroupRoleMembersReply, new NetworkManager.PacketCallback(GroupRoleMembersHandler));
            Network.RegisterCallback(PacketType.GroupActiveProposalItemReply, new NetworkManager.PacketCallback(GroupActiveProposalItemHandler));
            Network.RegisterCallback(PacketType.GroupVoteHistoryItemReply, new NetworkManager.PacketCallback(GroupVoteHistoryItemHandler));
            Network.RegisterCallback(PacketType.GroupAccountSummaryReply, new NetworkManager.PacketCallback(GroupAccountSummaryHandler));
            Network.RegisterCallback(PacketType.CreateGroupReply, new NetworkManager.PacketCallback(CreateGroupReplyHandler));
            Network.RegisterCallback(PacketType.JoinGroupReply, new NetworkManager.PacketCallback(JoinGroupReplyHandler));
            Network.RegisterCallback(PacketType.LeaveGroupReply, new NetworkManager.PacketCallback(LeaveGroupReplyHandler));
            Network.RegisterCallback(PacketType.UUIDGroupNameReply, new NetworkManager.PacketCallback(UUIDGroupNameReplyHandler));
            Network.RegisterCallback(PacketType.EjectGroupMemberReply, new NetworkManager.PacketCallback(EjectGroupMemberReplyHandler));
            Network.RegisterCallback(PacketType.GroupNoticesListReply, new NetworkManager.PacketCallback(GroupNoticesListReplyHandler));
        }

        //public bool SendPings;
        //public int NetworkTickInterval;
        //public int PingInterval;
        //public bool SendAgentUpdates;
        //public int SimulatorTimeout;
        //public bool EnableCaps;
        #endregion

        /// <summary>
        /// 
        /// </summary>
        /// <param name="client">Reference to the GridClient object</param>
        /// <param name="address">IPEndPoint of the simulator</param>
        /// <param name="handle">handle of the simulator</param>
        public Simulator(LoggerInstance log, NetworkManager network, IPEndPoint address, ulong handle)
            : base(address)
        {
            //Client = client;
            Log = log;
            Handle = handle;
            Network = network;
            PacketArchive = new IncomingPacketIDCollection(Settings.PACKET_ARCHIVE_SIZE);
            InBytes = new Queue<long>(Network.StatsQueueSize);
            OutBytes = new Queue<long>(Network.StatsQueueSize);
        }

        private void Network_OnDisconnected(NetworkManager.DisconnectType reason, string message)
        {
            if (RebakeScheduleTimer != null)
            {
                RebakeScheduleTimer.Dispose();
                RebakeScheduleTimer = null;
            }

            if (AppearanceThread != null)
            {
                if (AppearanceThread.IsAlive)
                {
                    AppearanceThread.Abort();
                }
                AppearanceThread = null;
                AppearanceThreadRunning = 0;
            }
        }

 /// <summary>
 /// Unregister an event handler
 /// </summary>
 /// <param name="packetType">Packet type to unregister the handler for</param>
 /// <param name="eventHandler">Callback to be unregistered</param>
 public void UnregisterEvent(PacketType packetType, NetworkManager.PacketCallback eventHandler)
 {
     lock (_EventTable)
     {
         if (_EventTable.ContainsKey(packetType) && _EventTable[packetType] != null)
             _EventTable[packetType] -= eventHandler;
     }
 }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="client">Instance of GridClient object to associate with this GridManager instance</param>
		public GridManager(LoggerInstance log, NetworkManager network)
		{
            Log = log;
            Network = network;

            //Network.RegisterCallback(PacketType.MapLayerReply, MapLayerReplyHandler);
            Network.RegisterCallback(PacketType.MapBlockReply, MapBlockReplyHandler);
            Network.RegisterCallback(PacketType.MapItemReply, MapItemReplyHandler);
            Network.RegisterCallback(PacketType.SimulatorViewerTimeMessage, TimeMessageHandler);
            Network.RegisterCallback(PacketType.CoarseLocationUpdate, CoarseLocationHandler);
            Network.RegisterCallback(PacketType.RegionIDAndHandleReply, RegionHandleReplyHandler);
		}

            /// <summary>Default constructor</summary>
            public AgentMovement(LoggerInstance log, AgentManager self, NetworkManager network)
            {
                Log = log;
                Network = network;
                Self = self;
                Camera = new AgentCamera();

                updateInterval = Settings.DEFAULT_AGENT_UPDATE_INTERVAL;
                updateTimer = new Timer(new TimerCallback(UpdateTimer_Elapsed), null, Settings.DEFAULT_AGENT_UPDATE_INTERVAL,
                    Settings.DEFAULT_AGENT_UPDATE_INTERVAL);
            }

 private void Network_OnDisconnected(NetworkManager.DisconnectType reason, string message)
 {
     CleanupTimer();
 }

        /// <summary>
        /// Internal constructor
        /// </summary>
        /// <param name="client">A reference to the GridClient Object</param>
        internal FriendsManager(LoggerInstance log, NetworkManager network, InventoryManager inventory, AgentManager self, AvatarManager avatars)
        {
            Log = log;
            Network = network;
            Inventory = inventory;
            Self = self;
            Avatars = avatars;

            Network.OnConnected += new NetworkManager.ConnectedCallback(Network_OnConnect);
            Avatars.OnAvatarNames += new AvatarManager.AvatarNamesCallback(Avatars_OnAvatarNames);
            Self.OnInstantMessage += new AgentManager.InstantMessageCallback(MainAvatar_InstantMessage);

            Network.RegisterCallback(PacketType.OnlineNotification, OnlineNotificationHandler);
            Network.RegisterCallback(PacketType.OfflineNotification, OfflineNotificationHandler);
            Network.RegisterCallback(PacketType.ChangeUserRights, ChangeUserRightsHandler);
            Network.RegisterCallback(PacketType.TerminateFriendship, TerminateFriendshipHandler);
            Network.RegisterCallback(PacketType.FindAgent, OnFindAgentReplyHandler);

            Network.RegisterLoginResponseCallback(new NetworkManager.LoginResponseCallback(Network_OnLoginResponse),
                new string[] { "buddy-list" });
        }

        // FIXME: Create a class-level appearance thread so multiple threads can't be launched

        /// <summary>
        /// Default constructor
        /// </summary>
        /// <param name="client">This agents <seealso cref="OpenMetaverse.GridClient"/> Object</param>
        /// <param name="assets">Reference to an AssetManager object</param>
        public AppearanceManager(LoggerInstance log, NetworkManager network, InventoryManager inventory, AssetManager assets, ObjectManager objects, AgentManager self)
        {
            Log = log;
            Network = network;
            Inventory = inventory;
            Assets = assets;
            Self = self;
            Objects = objects;

            // Initialize AgentTextures to zero UUIDs
            for (int i = 0; i < AgentTextures.Length; i++)
                AgentTextures[i] = UUID.Zero;

            Network.RegisterCallback(PacketType.AgentWearablesUpdate, new NetworkManager.PacketCallback(AgentWearablesUpdateHandler));
            Network.RegisterCallback(PacketType.AgentCachedTextureResponse, new NetworkManager.PacketCallback(AgentCachedTextureResponseHandler));
            Network.RegisterCallback(PacketType.RebakeAvatarTextures,new NetworkManager.PacketCallback(RebakeAvatarTexturesHandler));
            Network.OnDisconnected += new NetworkManager.DisconnectedCallback(Network_OnDisconnected);
        }

 void Network_OnDisconnected(NetworkManager.DisconnectType reason, string message)
 {
     ParcelsDownloaded.Set();
 }