Thread

24     public int updateIntervalOnSerialize; // time [ms] between consecutive RunViewUpdate calls (sending syncs, etc)
35     protected void Awake()
36     {
37         if (SP != null && SP != this && SP.gameObject != null)
38         {
39             GameObject.DestroyImmediate(SP.gameObject);
40         }
41
42         SP = this;
43         DontDestroyOnLoad(this.gameObject);
44
45         this.updateInterval = 1000 / PhotonNetwork.sendRate;
46         this.updateIntervalOnSerialize = 1000 / PhotonNetwork.sendRateOnSerialize;
47
48         PhotonHandler.StartFallbackSendAckThread();
49     }

52     protected void OnApplicationQuit()
53     {
54         PhotonHandler.AppQuits = true;
55         PhotonHandler.StopFallbackSendAckThread();
56         PhotonNetwork.Disconnect();
57     }

128     public static void StartFallbackSendAckThread()
129     {
130         if (sendThreadShouldRun)
131         {
132             return;
133         }
134
135         sendThreadShouldRun = true;
136         SupportClass.CallInBackground(FallbackSendAckThread); // thread will call this every 100ms until method returns false
137     }

139     public static void StopFallbackSendAckThread()
140     {
141         sendThreadShouldRun = false;
142     }

144     public static bool FallbackSendAckThread()
145     {
146         if (sendThreadShouldRun && PhotonNetwork.networkingPeer != null)
147         {
148             PhotonNetwork.networkingPeer.SendAcksOnly();
149         }
150
151         return sendThreadShouldRun;
152     }

712     {
713         get
714         {
715             return m_isMessageQueueRunning;
716         }
717
718         set
719         {
720             if (value) PhotonHandler.StartFallbackSendAckThread();
721             networkingPeer.IsSendingOnlyAcks = !value;
722             m_isMessageQueueRunning = value;
723         }
724     }

1025     /// Connect(serverAddress, , appID, gameVersion)
1036     public static void SwitchToProtocol(ConnectionProtocol cp)
1037     {
1038         if (networkingPeer.UsedProtocol == cp)
1039         {
1040             return;
1041         }
1042         try
1043         {
1044             networkingPeer.Disconnect();
1045             networkingPeer.StopThread();
1046         }
1047         catch
1048         {
1049
1050         }
1051
1052         // set up a new NetworkingPeer
1053         NetworkingPeer newPeer = new NetworkingPeer(photonMono, String.Empty, cp);
1054         newPeer.mAppVersion = networkingPeer.mAppVersion;
1055         newPeer.CustomAuthenticationValues = networkingPeer.CustomAuthenticationValues;
1056         newPeer.PlayerName= networkingPeer.PlayerName;
1057         newPeer.mLocalActor = networkingPeer.mLocalActor;
1058         newPeer.DebugOut = networkingPeer.DebugOut;
1059         newPeer.CrcEnabled = networkingPeer.CrcEnabled;
1060         newPeer.lobby = networkingPeer.lobby;
1061         newPeer.LimitOfUnreliableCommands = networkingPeer.LimitOfUnreliableCommands;
1062         newPeer.SentCountAllowance = networkingPeer.SentCountAllowance;
1063         newPeer.TrafficStatsEnabled = networkingPeer.TrafficStatsEnabled;
1064
1065         networkingPeer = newPeer;
1066         Debug.LogWarning("Protocol switched to: " + cp + ".");
1067     }

39         public override bool Connect()
40         {
41             lock (this.syncer)
42             {
43                 bool baseOk = base.Connect();
44                 if (!baseOk)
45                 {
46                     return false;
47                 }
48
49                 this.State = PhotonSocketState.Connecting;
50
51                 Thread dns = new Thread(this.DnsAndConnect);
52                 dns.Name = "photon dns thread";
53                 dns.IsBackground = true;
54                 dns.Start();
55
56                 return true;
57             }
58         }

119         internal void DnsAndConnect()
120         {
121             try
122             {
123                 lock (this.syncer)
124                 {
125                     this.sock = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
126
127                     IPAddress ep = IPhotonSocket.GetIpAddress(this.ServerAddress);
128                     this.sock.Connect(ep, this.ServerPort);
129
130                     this.State = PhotonSocketState.Connected;
131                 }
132             }
133             catch (SecurityException se)
134             {
135                 if (this.ReportDebugOfLevel(DebugLevel.ERROR))
136                 {
137                     this.Listener.DebugReturn(DebugLevel.ERROR, "Connect() failed: " + se.ToString());
138                 }
139
140                 this.HandleException(StatusCode.SecurityExceptionOnConnect);
141                 return;
142             }
143             catch (Exception se)
144             {
145                 if (this.ReportDebugOfLevel(DebugLevel.ERROR))
146                 {
147                     this.Listener.DebugReturn(DebugLevel.ERROR, "Connect() failed: " + se.ToString());
148                 }
149
150                 this.HandleException(StatusCode.ExceptionOnConnect);
151                 return;
152             }
153
154             Thread run = new Thread(new ThreadStart(ReceiveLoop));
155             run.Name = "photon receive thread";
156             run.IsBackground = true;
157             run.Start();
158         }

174         public void Service()
175         {
176             if (this.HasPeer && (Environment.TickCount - msTimestampOfLastServiceCall > msDeltaForServiceCalls || msTimestampOfLastServiceCall == 0))
177             {
178                 msTimestampOfLastServiceCall = Environment.TickCount;
179                 this.chatPeer.Service(); //TODO: make sure to call service regularly. in best case it could be integrated into PhotonHandler.FallbackSendAckThread()!
180             }
181         }