public string GetDataNetworkPath()
{
AndroidJavaObject telManager = GetTelephonyManager();
if (telManager == null)
{
return("");
}
const string readPhoneStatePermissionString = "android.permission.READ_PHONE_STATE";
try
{
if (Permission.HasUserAuthorizedPermission(readPhoneStatePermissionString))
{
int nType = PlatformIntegrationUtil.Call <int>(telManager, "getDataNetworkType");
NetworkDataType datatype = (NetworkDataType)nType;
return(datatype.ToString());
}
else
{
return("");
}
}
catch (Exception e)
{
Logger.LogWarning("Exception retrieving properties: " + e.GetBaseException() + ", " + e.Message);
return("");
}
}
void OnNetworkReceived(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
if (reader.UserDataSize >= 4)
{
NetworkDataType networkDataType = (NetworkDataType)reader.GetInt();
if (networkDataType == NetworkDataType.SendCalibration)
{
SetCalibration(peer.Id, reader);
SendCalibrationToReceivers(peer.Id);
}
if (networkDataType == NetworkDataType.SendDepthData)
{
SendDepthDataToReceivers(peer.Id, reader);
}
if (networkDataType == NetworkDataType.SendDepthAndColorData)
{
SendDepthAndColorDataToReceivers(peer.Id, reader);
}
else if (networkDataType == NetworkDataType.RegisterTextureReceiver)
{
RegisterTextureReceiver(peer.Id, reader);
}
else if (networkDataType == NetworkDataType.UnregisterTextureReceiver)
{
UnregisterTextureReceiver(peer.Id, reader);
}
}
}
public static INetworkData Parse(byte[] rawData)
{
if (rawData.Length < 2)
{
throw new ExceptionFreeserf("Unknown network data.");
}
NetworkDataType type = (NetworkDataType)BitConverter.ToUInt16(rawData, 0);
switch (type)
{
case NetworkDataType.Request:
return(new RequestData().Parse(rawData));
case NetworkDataType.Heartbeat:
return(new Heartbeat().Parse(rawData));
case NetworkDataType.LobbyData:
return(new LobbyData().Parse(rawData));
// TODO ...
default:
throw new ExceptionFreeserf("Unknown network data.");
}
}
public static IEnumerable <INetworkData> Parse(byte[] rawData)
{
if (rawData.Length < 2)
{
Log.Error.Write(ErrorSystemType.Network, $"Invalid network data received: {rawData}");
throw new ExceptionFreeserf("Invalid network data received.");
}
int offset = 0;
while (offset < rawData.Length)
{
NetworkDataType type = (NetworkDataType)BitConverter.ToUInt16(rawData, offset);
switch (type)
{
case NetworkDataType.Request:
yield return(new RequestData().Parse(rawData, ref offset));
break;
case NetworkDataType.Response:
yield return(new ResponseData().Parse(rawData, ref offset));
break;
case NetworkDataType.Heartbeat:
yield return(new Heartbeat().Parse(rawData, ref offset));
break;
case NetworkDataType.LobbyData:
yield return(new LobbyData().Parse(rawData, ref offset));
break;
case NetworkDataType.InSync:
yield return(new InSyncData().Parse(rawData, ref offset));
break;
case NetworkDataType.SyncData:
yield return(new SyncData().Parse(rawData, ref offset));
break;
case NetworkDataType.UserActionData:
yield return(new UserActionData().Parse(rawData, ref offset));
break;
// TODO ...
default:
Log.Error.Write(ErrorSystemType.Network, $"Unknown network data received: {rawData}");
throw new ExceptionFreeserf("Unknown network data.");
}
}
}
public void SendData(List <byte> buffer, NetworkDataType type, NetworkCommand command)
{
if (sendingTask != null && !sendingTask.IsCompleted)
{
return;
}
sendingTask = new Task(() => SendDataAsync(buffer, type, command));
sendingTask.Start(); sendingTask.Wait();
}
void OnNetworkReceived(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
if (reader.UserDataSize >= 4)
{
NetworkDataType networkDataType = (NetworkDataType)reader.GetInt();
if (networkDataType == NetworkDataType.PlayerTransform)
{
UpdatePlayerTransform(peer, reader);
}
}
}
void OnNetworkReceived(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
if (reader.UserDataSize >= 4)
{
NetworkDataType networkDataType = (NetworkDataType)reader.GetInt();
if (networkDataType == NetworkDataType.ReceiveOwnCliendId)
{
ClientId = reader.GetInt();
Debug.Log("Own Client ID : " + ClientId);
}
}
}
public NetworkSession(Session session)
{
_session = session;
_requestHeaders = new Dictionary <string, string>();
_requestDataType = NetworkDataType.Unknown;
_responseHeaders = new Dictionary <string, string>();
_responseDataType = NetworkDataType.Unknown;
ParseRequest();
}
void OnNetworkReceived(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
if (reader.UserDataSize >= 4)
{
NetworkDataType networkDataType = (NetworkDataType)reader.GetInt();
if (networkDataType == NetworkDataType.PlayerTransformArray)
{
UpdateNetworkPlayerPosition(peer, reader);
}
else if (networkDataType == NetworkDataType.PlayerLeave)
{
int playerId = reader.GetInt();
DestroyImmediate(_networkPlayersDictionary[playerId].gameObject);
_networkPlayersDictionary.Remove(playerId);
}
}
}
/// <summary>
/// NetworkData constructor
/// </summary>
/// <param name="user">User info</param>
/// <param name="dataType">Type of network data</param>
/// <param name="data">A message containing data</param>
/// <param name="date">A date in string form</param>
public NetworkData(User user, NetworkDataType dataType, string data = "",
ResponseType responseType = ResponseType.None, string date = "")
{
User = user;
DataType = dataType;
Data = data;
ResponseType = responseType;
if (date == "")
{
Date = DateTime.Now.ToString();
}
else
{
Date = date;
}
}
internal void ParseResponse()
{
_responseHeaders.Clear();
HTTPResponseHeaders headers = _session.oResponse.headers;
foreach (HTTPHeaderItem item in headers)
{
_responseHeaders.Add(item.Name, item.Value);
}
string contentType = string.Empty;
if (_responseHeaders.TryGetValue("content-type", out contentType) && !string.IsNullOrEmpty(contentType))
{
_responseDataType = GetType(contentType);
}
}
void OnNetworkReceived(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
if (reader.UserDataSize >= 4)
{
NetworkDataType networkDataType = (NetworkDataType)reader.GetInt();
if (networkDataType == NetworkDataType.SendTexture)
{
SendTextureToReceivers(peer.Id, reader);
}
else if (networkDataType == NetworkDataType.RegisterTextureReceiver)
{
RegisterTextureReceiver(peer.Id, reader);
}
else if (networkDataType == NetworkDataType.UnregisterTextureReceiver)
{
UnregisterTextureReceiver(peer.Id, reader);
}
}
}
public static IEnumerable <INetworkData> Parse(byte[] rawData)
{
if (rawData.Length < 2)
{
throw new ExceptionFreeserf("Unknown network data.");
}
int offset = 0;
while (offset < rawData.Length)
{
NetworkDataType type = (NetworkDataType)BitConverter.ToUInt16(rawData, offset);
switch (type)
{
case NetworkDataType.Request:
yield return(new RequestData().Parse(rawData, ref offset));
break;
case NetworkDataType.Response:
yield return(new ResponseData().Parse(rawData, ref offset));
break;
case NetworkDataType.Heartbeat:
yield return(new Heartbeat().Parse(rawData, ref offset));
break;
case NetworkDataType.LobbyData:
yield return(new LobbyData().Parse(rawData, ref offset));
break;
// TODO ...
default:
throw new ExceptionFreeserf("Unknown network data.");
}
}
}
private NetworkDataType GetType(string contentType)
{
NetworkDataType type = NetworkDataType.Unknown;
if (string.IsNullOrEmpty(contentType))
{
return(type);
}
contentType = contentType.ToLower();
if (contentType.Contains("multipart/related") ||
contentType.Contains("multipart/batching"))
{
type = NetworkDataType.Multipart;
}
else if (contentType.Contains("text/html") ||
contentType.Contains("application/x-javascript"))
{
type = NetworkDataType.Text;
}
else if (contentType.Contains("image/"))
{
type = NetworkDataType.Image;
}
else if (contentType.Contains("xml"))
{
type = NetworkDataType.XML;
}
else if (contentType.Contains("json"))
{
type = NetworkDataType.JSON;
}
return(type);
}
public Message(NetworkDataType type, byte[] payload = null)
{
DataType = type;
switch (DataType)
{
case NetworkDataType.KeepAlive:
RawBytes = BitConverter.GetBytes(0);
return;
case NetworkDataType.Choke:
case NetworkDataType.Unchoke:
case NetworkDataType.Interested:
case NetworkDataType.NotInterested:
RawBytes = BitConverter.GetBytes(1);
RawBytes.Append(Convert.ToByte((int)DataType));
return;
case NetworkDataType.Bitfield:
case NetworkDataType.Have:
case NetworkDataType.Request:
default:
return;
}
}
public async Task ReceiveDataAsync()
{
byte[] inputBuffer = null;
#if !UNITY_EDITOR
while (true)
{
string errorLog = string.Empty;
var stream = ClientSocket.InputStream.AsStreamForRead();
byte[] inputDataTypeBuffer = new byte[2];
byte[] inputLengthBuffer = new byte[4];
await stream.ReadAsync(inputDataTypeBuffer, 0, 2);
NetworkDataType inputType = (NetworkDataType)BitConverter.ToInt16(inputDataTypeBuffer, 0);
await stream.ReadAsync(inputLengthBuffer, 0, 4);
var inputLength = BitConverter.ToInt32(inputLengthBuffer, 0);
inputBuffer = new byte[inputLength];
await stream.ReadAsync(inputBuffer, 0, inputBuffer.Length);
NetworkDataHandler.HandleNetworkData(inputBuffer, inputType);
}
#endif
}
void OnNetworkReceived(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
if (reader.UserDataSize >= 4)
{
NetworkDataType networkDataType = (NetworkDataType)reader.GetInt();
if (networkDataType == NetworkDataType.ReceiveOwnCliendId)
{
ClientId = reader.GetInt();
Debug.Log("Own Client ID : " + ClientId);
}
else if (networkDataType == NetworkDataType.ReceiveCalibration)
{
OnReceivedCalibrationHandler(peer, reader);
}
else if (networkDataType == NetworkDataType.ReceiveDepthData)
{
OnReceivedDepthData(peer, reader);
}
else if (networkDataType == NetworkDataType.ReceiveDepthAndColorData)
{
OnReceivedDepthAndColorData(peer, reader);
}
}
}
// Placeholder, if available, just use the Unity version
#if UNITY_ANDROID
public Dictionary<string, string> GetDeviceInfo()
{
CarrierInfoClass carrierInfo = new CarrierInfoClass();
Dictionary<string, string> map = new Dictionary<string, string>();
int sdk_int = carrierInfo.getAndroidSDKVers();
map["Build.VERSION.SDK_INT"] = sdk_int.ToString();
if (UnityEngine.XR.XRSettings.loadedDeviceName.Contains("oculus"))
{
return map;
}
AndroidJavaObject telephonyManager = carrierInfo.GetTelephonyManager();
if (telephonyManager == null)
{
Logger.Log("No TelephonyManager!");
return map;
}
const string readPhoneStatePermissionString = "android.permission.READ_PHONE_STATE";
try
{
if (Permission.HasUserAuthorizedPermission(readPhoneStatePermissionString))
{
string ver = PlatformIntegrationUtil.Call<string>(telephonyManager, "getDeviceSoftwareVersion");
if (ver != null)
{
map["DeviceSoftwareVersion"] = ver.ToString();
}
}
}
catch (Exception e)
{
Logger.LogWarning("Exception retrieving properties: " + e.GetBaseException() + ", " + e.Message);
}
try
{
if (Permission.HasUserAuthorizedPermission(readPhoneStatePermissionString))
{
int nType = PlatformIntegrationUtil.Call<int>(telephonyManager, "getDataNetworkType");
NetworkDataType datatype = (NetworkDataType)nType;
map["DataNetworkType"] = datatype.ToString();
}
}
catch (Exception e)
{
Logger.LogWarning("Exception retrieving properties: " + e.GetBaseException() + ", " + e.Message);
}
AndroidJavaClass versionCodesClass = new AndroidJavaClass("android.os.Build$VERSION_CODES");
int versionCode = PlatformIntegrationUtil.GetStatic<int>(versionCodesClass, "Q");
if (sdk_int > versionCode)
{
string mc = PlatformIntegrationUtil.Call<string>(telephonyManager, "getManufacturerCode");
if (mc != null)
{
map["ManufacturerCode"] = mc;
}
}
string niso = PlatformIntegrationUtil.Call<string>(telephonyManager, "getNetworkCountryIso");
if (niso != null)
{
map["NetworkCountryIso"] = niso;
}
string siso = PlatformIntegrationUtil.Call<string>(telephonyManager, "getSimCountryIso");
if (siso != null)
{
map["SimCountryCodeIso"] = siso;
}
int phoneType = PlatformIntegrationUtil.Call<int>(telephonyManager, "getPhoneType");
map["PhoneType"] = phoneType.ToString();
// Default one.
string simOperatorName = PlatformIntegrationUtil.Call<string>(telephonyManager, "getSimOperatorName");
if (simOperatorName != null)
{
map["SimOperatorName"] = simOperatorName;
}
// Default one.
string networkOperator = PlatformIntegrationUtil.Call<string>(telephonyManager, "getNetworkOperatorName");
if (networkOperator != null)
{
map["NetworkOperatorName"] = networkOperator;
}
return map;
}
public static void HandleNetworkData(byte[] buffer, NetworkDataType type)
{
handlers[(int)type].Invoke(buffer);
}
public async Task SendDataAsync(List <byte> buffer, NetworkDataType type, NetworkCommand command)
{
try
{
#if !UNITY_EDITOR
using (var writer = new DataWriter(ClientSocket.OutputStream))
{
NetworkDataHandler.lastBufferSent = buffer; NetworkDataHandler.lastTypeSent = type;
writer.ByteOrder = ByteOrder.BigEndian;
writer.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
chunks = buffer.Count / chunkSize;
residual = buffer.Count % chunkSize;
/*
* Header of the package so that the other side knows how much and what kind of data to receive
*/
writer.WriteInt16((short)command);
writer.WriteInt16((short)type);
writer.WriteInt32(chunkSize);
writer.WriteInt32(chunks);
writer.WriteInt32(residual);
var stream = ClientSocket.InputStream.AsStreamForRead();
byte[] response_buffer = new byte[2];
NetworkResponseType response;
int percentage = 0;
for (int i = 0; i < chunks; i++)
{
bool chunk_received = false;
response = NetworkResponseType.DataCorrupt;
while (response == NetworkResponseType.DataCorrupt)
{
writer.WriteBytes(buffer.GetRange(i * chunkSize, chunkSize).ToArray());
await writer.StoreAsync();
await writer.FlushAsync();
await stream.ReadAsync(response_buffer, 0, 2);
stream.Flush();
response = (NetworkResponseType)BitConverter.ToInt16(response_buffer, 0);
}
percentage = ((int)(((float)(i + 1)) / ((float)chunks) * 100));
client.NotifyMainThread(percentage, "Sending data, Chunk#" + i + " of " + chunks, 0);
}
response = NetworkResponseType.DataCorrupt;
while (response == NetworkResponseType.DataCorrupt)
{
writer.WriteBytes(buffer.GetRange(chunks * chunkSize, residual).ToArray());
await writer.StoreAsync();
await writer.FlushAsync();
await stream.ReadAsync(response_buffer, 0, 2);
response = (NetworkResponseType)BitConverter.ToInt16(response_buffer, 0);
}
writer.DetachStream();
}
#endif
}
catch (Exception e)
{
client.NotifyMainThread(0, "SendDataAsync Error" + e.ToString(), 0);
}
}
