public WifiHandler()
{
this.context = Android.App.Application.Context;
_connectivityManager = Application.Context.GetSystemService(Context.ConnectivityService) as ConnectivityManager;
_callback = new NetworkCallback
{
NetworkAvailable = network =>
{
// we are connected!
_callbackStatus = $"Requested network connected";
_connectivityManager.BindProcessToNetwork(network);
Static.RuntimeSettings.IsWifiRequestingFinished = true;
},
NetworkUnavailable = () =>
{
_callbackStatus = $"Requested network unavailable";
Static.RuntimeSettings.IsWifiRequestingFinished = true;
},
NetworkLost = network =>
{
_callbackStatus = $"Requested network lost";
_connectivityManager.BindProcessToNetwork(null);
_connectivityManager.UnregisterNetworkCallback(_callback);
}
};
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
SetContentView(Resource.Layout.activity_main);
var requestButton = FindViewById <Button>(Resource.Id.buttonRequest);
var suggestButton = FindViewById <Button>(Resource.Id.buttonSuggest);
_statusText = FindViewById <TextView>(Resource.Id.statusText);
_ssid = FindViewById <EditText>(Resource.Id.ssid);
_passphrase = FindViewById <EditText>(Resource.Id.passphrase);
requestButton.Click += (s, e) => RequestNetwork();
suggestButton.Click += (s, e) => SuggestNetwork();
_callback = new NetworkCallback
{
NetworkAvailable = network =>
{
// we are connected!
_statusText.Text = $"Request network available";
},
NetworkUnavailable = () =>
{
_statusText.Text = $"Request network unavailable";
}
};
}
static IEnumerator HandlePackage()
{
while (connected)
{
lock (packageQueue)
{
if (packageQueue.Count > 0)
{
Package package = packageQueue.Dequeue();
if (callbackDict.ContainsKey(package.type))
{
List <NetworkCallback> callbackList = callbackDict[package.type];
for (int i = callbackList.Count - 1; i >= 0; i--)
{
NetworkCallback callback = callbackList[i];
callback.func(package.data);
if (callback.isDelete)
{
callbackList.RemoveAt(i);
}
}
}
}
}
yield return(null);
}
DisconnectedUI.Show();
}
public void CalculatePoints()
{
List <int> allPoints = new List <int>();
int highestPoints;
for (int i = 0; i < NetworkCallback.GetPlayers().Count; i++)
{
allPoints.Add(NetworkCallback.GetPlayers()[i].GetComponent <NetworkPlayer>().GetPoints());
// if (player.playerState != null)
//{
highestPoints = Mathf.Max(allPoints.ToArray());
Debug.Log(highestPoints);
/*
* if (player.playerState.PlayerScore >= highestScore)
* {
* highestScore = player.playerState.PlayerScore;
* highestScoringPlayer = player.networkPlayer;
* highestScoringPlayerState = player.playerState;
* }
*/
//}
}
}
public void Send(byte[] byteData, NetworkCallback sendCallback)
{
// Begin sending the data to the remote device.
this.secondCallback = sendCallback;
client.BeginSend(byteData, 0, byteData.Length, 0,
new AsyncCallback(SendCallback), this.client);
}
// Update is called once per frame
void FixedUpdate()
{
if (NetworkCallback.GetPlayers()[0])
{
if (NetworkCallback.GetPlayers()[0].GetComponent <NetworkPlayer>().isVictory)
{
diceButton.GetComponent <Button>().interactable = false;
}
}
if (NetworkCallback.GetPlayers()[1])
{
if (NetworkCallback.GetPlayers()[1].GetComponent <NetworkPlayer>().isVictory)
{
diceButton.GetComponent <Button>().interactable = false;
}
}
/*
* Debug.LogWarning(NetworkCallback.GetPlayers()[0].GetComponent<NetworkPlayer>().transform.position);
* if(NetworkCallback.GetPlayers().Count == 2)
* Debug.LogWarning(NetworkCallback.GetPlayers()[1].GetComponent<NetworkPlayer>().transform.position);
* /*
* for (int i = 0; i < NetworkCallback.GetPlayers().Count; i++)
* {
* if (NetworkCallback.GetPlayers().Where(c => c.GetComponent<NetworkPlayer>().isReady).Count() == 0) {
* for (int j = 0; j < NetworkCallback.GetPlayers().Count; j++)
* {
* diceButton.GetComponent<Button>().interactable = true;
* }
* }
* Debug.Log(NetworkCallback.GetPlayers().Where(c => c.GetComponent<NetworkPlayer>().isReady).Count());
* }
*/
}
public bool ConnectAsyn(string host, int port)
{
IPAddress addr;
if (!IPAddress.TryParse(host, out addr))
{
return(false);
}
sock = new TcpClient();
sock.NoDelay = true;
sock.BeginConnect(addr, port, (ar) =>
{
TcpClient client = (TcpClient)ar.AsyncState;
client.EndConnect(ar);
if (client.Connected)
{
this.status = NetworkState.Connected;
}
else
{
this.status = NetworkState.DisConnected;
}
NetworkCallback temp = ConnectCompleted;
if (temp != null)
{
temp(new NetWorkArgs(client.Connected?NetworkState.Connected:NetworkState.DisConnected));
}
}, sock);
this.status = NetworkState.Connecting;
return(true);
}
public static void Receive(Socket socket, byte[] buffer, int offset, int count, object state,
NetworkCallback callback)
{
var data = Cache.Get().Init(socket, buffer, offset, count, callback, state);
ReceiveBase(data);
}
public void RemoveCallBack(int type, NetworkCallback callback)
{
if (callbackDic.ContainsKey(type))
{
callbackDic[type] -= callback;
}
}
public static void Send(Socket socket, byte[] buffer, int offset, int count, object state,
NetworkCallback callback)
{
NetworkState data = Cache.Get().Init(socket, buffer, offset, count, callback, state);
SendBase(data);
}
public async void ConnectToWifi(string ssid, string password)
{
if (Android.OS.Build.VERSION.SdkInt < Android.OS.BuildVersionCodes.Q)
{
var formattedSsid = $"\"{ssid}\"";
var formattedPassword = $"\"{password}\"";
var wifiConfig = new WifiConfiguration
{
Ssid = formattedSsid,
PreSharedKey = formattedPassword
};
var wifiManager = (WifiManager)Android.App.Application.Context
.GetSystemService(Context.WifiService);
var addNetwork = wifiManager.AddNetwork(wifiConfig);
var network = new WifiConfiguration();
IList <Android.Net.Wifi.WifiConfiguration> networks = wifiManager.ConfiguredNetworks.ToList <WifiConfiguration>();
foreach (var n in networks)
{
Console.WriteLine($"Config Networks: {n.Bssid}");
if (n.Ssid == formattedSsid)
{
network = n;
}
}
if (network == null)
{
Console.WriteLine($"Cannot connect to network: {ssid}");
return;
}
wifiManager.Disconnect();
var enableNetwork = wifiManager.EnableNetwork(network.NetworkId, true);
wifiManager.Reconnect();
await Application.Current.MainPage.DisplayAlert("Failed to connect", ssid, "OK");
}
else
{
WifiNetworkSpecifier.Builder builder = new WifiNetworkSpecifier.Builder();
WifiNetworkSpecifier networkSpecifier = builder
.SetSsid(ssid)
.SetWpa2Passphrase(password)
.Build();
NetworkRequest.Builder networkRequest = new NetworkRequest.Builder();
networkRequest
.SetNetworkSpecifier(networkSpecifier)
.Build();
ConnectivityManager connectivityManager = (ConnectivityManager)Android.App.Application.Context.GetSystemService(Context.ConnectivityService);
NetworkCallback networkCallback = new NetworkCallback(connectivityManager);
}
}
public recvObject(byte[] b, int o, int size, NetworkStream s, NetworkCallback c)
{
this.buff = b;
this.offet = o;
this.size = size;
this.stream = s;
this.callback = c;
}
public void RegisterCallback(int id, NetworkCallback <T> callback)
{
if (id < 0)
{
throw new ArgumentOutOfRangeException();
}
callbacks[id] = callback;
}
private void sendtoken(NetworkIOArgs args)
{
NetworkCallback temp = this.requestServerCompleted;
if (temp != null)
{
temp(null);
}
}
private void Recv(byte[] buf, int offset, int size, NetworkCallback callback)
{
if (this.status != NetworkState.Connected)
{
throw new NetworkException("NetworkClient:client did not connect server yet");
}
NetworkStream sockstream = sock.GetStream();
sockstream.BeginRead(buf, offset, size, recvCallback, new recvObject(buf, offset, size, sockstream, callback));
}
public virtual bool AddCallback(int id, NetworkCallback networkCallback)
{
if (networkCallbacks.ContainsKey(id))
{
return(false);
}
networkCallbacks.Add(id, networkCallback);
return(true);
}
public void AddCallBack(int type, NetworkCallback callback)
{
if (!callbackDic.ContainsKey(type))
{
callbackDic.Add(type, callback);
}
else
{
callbackDic[type] += callback;
}
}
public LocalClient(Window window)
{
Window = window;
ManagedMoonlightCore = new ManagedMoonlightCore();
_recvCallback = OnPacketReceived;
_sendCallback = OnPacketSend;
ManagedMoonlightCore.SetRecvCallback(_recvCallback);
ManagedMoonlightCore.SetSendCallback(_sendCallback);
}
public NetworkState Init(Socket socket, NetworkCallback callback, object state)
{
Socket = socket;
State = state;
Offset = 0;
Remaining = 0;
Count = 0;
Buffer = null;
Callback = callback;
return(this);
}
public GameSession()
{
Id = Guid.NewGuid();
Character = new Character(this);
sendCallback = OnPacketSend;
recvCallback = OnPacketReceived;
Bridge.AddSendCallback(sendCallback);
Bridge.AddRecvCallback(recvCallback);
}
public NetworkState Init(Socket socket, byte[] buffer, int offset, int count, NetworkCallback callback,
object state)
{
Socket = socket;
State = state;
Offset = offset;
Remaining = count;
Count = count;
Buffer = buffer;
Callback = callback;
return(this);
}
private void recvServers(NetworkIOArgs args)
{
client.RecvCompleted -= Client_RecvCompleted;
client.SendCompleted -= Client_SendCompleted;
this.token = null;
NetworkCallback temp = loginCompleted;
if (temp != null)
{
temp(args);
}
}
public void SendPackage(/*int proto ,*/ byte[] buf, NetworkCallback callback)
{
if (buf.Length > 65535)
{
throw new NetworkException("NetworkClient:buf sended is too big");
}
byte[] pack = new byte[buf.Length + TCPPACKBYTES];
pack[0] = (byte)((buf.Length >> 8) & 0xff);
pack[1] = (byte)(buf.Length & 0xff);
Buffer.BlockCopy(buf, 0, pack, TCPPACKBYTES, buf.Length);
this.Send(pack, 0, pack.Length, callback);
}
public bool Initialize(string moduleName, NetworkCallback callback)
{
if (MEngine.Instance.CreateEngine(false) == false)
{
Debug.ErrorLog(MethodBase.GetCurrentMethod(), "Failed - MEngine.Instance.CreateEngine() Failed");
return(false);
}
Callback = callback;
return(true);
}
// Called on the frame this script is enabled, before Update().
private void Start()
{
fireTimer = fireRate;
reloadTimer = reloadSpeed;
inicialPosition = transform.parent.localPosition;
weaponIndex = GetWeaponIndex();
playerAmmo = GameObject.Find("Ammo").GetComponent <Text>();
animator = localNetworkUser.GetComponent <Animator>();
networkCallback = localNetworkUser.GetComponent <NetworkCallback>();
}
public void Connect(NetworkCallback callback)
{
IPHostEntry ipHostInfo = Dns.Resolve(this.hostId);
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);
this.client = new Socket(ipAddress.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
// Connect to the remote endpoint.
// TODO : find a way to pass it directly into BeginConnect
this.connectCallback = callback;
this.client.BeginConnect(remoteEP,
new AsyncCallback(ConnectCallback), this.client);
}
public static void Connect(Socket socket, IPEndPoint endpoint, object state, NetworkCallback callback)
{
NetworkState data = Cache.Get().Init(socket, callback, state);
try
{
socket.BeginConnect(endpoint, EndConnectCallback, data);
}
catch
{
callback(false, 0, state);
Cache.Put(data);
}
}
public static void AddListener(MessageID id, NetworkCallback handle, object target)
{
MessageCallbackData d = null;
m_MessageDispatchs.TryGetValue(id, out d);
if (d == null)
{
d = new MessageCallbackData();
m_MessageDispatchs[id] = d;
}
d.Handler = handle;
d.Target = target;
d.ID = id;
}
public void RecvPackage()
{
if (!this.recvIdle)
{
return;
}
this.recvIdle = false;
Array.Clear(this.buffer, 0, BUFFERSIZE);
NetworkStream stream = this.sock.GetStream();
stream.BeginRead(this.buffer, 0, TCPPACKBYTES, (ar) => {
try
{
int n = stream.EndRead(ar);
int count;
if (n == 0)
{
this.Close();
NetworkCallback temp = RecvCompleted;
if (temp != null)
{
temp(new NetworkIOArgs(NetworkState.Closed, null, 0));
}
}
else if (n == TCPPACKBYTES)
{
count = buffer[0] << 8 | buffer[1];
Array.Clear(buffer, 0, TCPPACKBYTES);
if (count <= BUFFERSIZE)
{
this.Recv(this.buffer, 0, count);
}
else
{
}
}
else
{
throw new NetworkException("NetworkClient:wrong packet size");
}
}
catch
{
this.Close();
}
}, null);
}
// Update is called once per frame
void Update()
{ /*
* Debug.LogError(TutorialPlayerObjectRegistry.players[0].character.GetComponent<NetworkPlayer>().isReady) ;
* if (TutorialPlayerObjectRegistry.players.Count == 2) {
* Debug.LogError(TutorialPlayerObjectRegistry.players[1].character.GetComponent<NetworkPlayer>().isReady);
* }
* if (TutorialPlayerObjectRegistry.players[0].character);
*/
if (PlayerInstance.instance.isFinished == true)
{
PlayerInstance.instance.trophies = timer;
if (NetworkCallback.GetPlayers()[0].GetComponent <NetworkPlayer>().isReady)
{
if (NetworkCallback.GetBool().TrueForAll(x => x) == true)
{
//PlayerInstance.instance.isReady = false;
List <int> scoreList = NetworkCallback.GetScore().OrderBy(l => l).ToList <int>();
if (scoreList[0] != 0)
{
if (PlayerInstance.instance.trophies == scoreList[0])
{
RoundSystem.Instance.MoveForward(2);
PlayerInstance.instance.isReady = false;
SceneManager.UnloadSceneAsync(2);
}
else if (PlayerInstance.instance.trophies == scoreList[1])
{
RoundSystem.Instance.MoveForward(1);
PlayerInstance.instance.isReady = false;
SceneManager.UnloadSceneAsync(2);
}
else
{
PlayerInstance.instance.isReady = false;
SceneManager.UnloadSceneAsync(2);
}
}
}
}
}
else
{
timer++;
}
distance.text = timer.ToString();
}
internal void RegisterListeningSocket(Socket listeningSocket, NetworkCallback callback)
{
con.RegisterListeningSocket(listeningSocket, callback);
}
