IEnumerator VerifyUpload(VimeoTicket ticket)
{
if (OnUploadProgress != null)
{
OnUploadProgress("Verifying", 0.9999999f);
}
byte[] data = new byte[] { 0x00 };
using (UnityWebRequest request = UnityWebRequest.Put(ticket.upload_link_secure, data)) {
request.chunkedTransfer = false;
request.SetRequestHeader("Content-Range", "bytes */*");
yield return(VimeoApi.SendRequest(request));
if (request.responseCode == 308)
{
StartCoroutine(CompleteUpload(ticket));
}
else
{
Debug.Log(request.responseCode);
}
}
}
private void ResumeUpload()
{
Debug.Assert(ResumableSessionInitiated && HasPayload);
if (uploadRequest != null)
{
uploadRequest.Abort();
uploadRequest.Dispose();
}
if (ResumeOffset == 0)
{
uploadRequest = UnityWebRequest.Put(ResumableSessionUri, RequestPayload);
}
else
{
var partialPayload = new byte[RequestPayload.Length - ResumeOffset];
Array.Copy(RequestPayload, ResumeOffset, partialPayload, 0, partialPayload.Length);
uploadRequest = UnityWebRequest.Put(ResumableSessionUri, partialPayload);
uploadRequest.SetRequestHeader("Content-Range", string.Format("bytes {0}-{1}/{2}", ResumeOffset, RequestPayload.Length - 1, RequestPayload.Length));
}
uploadRequest.SendWebRequest().completed += HandleUploadRequestCompleted;
}
IEnumerator PutRequest(string url)
{
WWWForm formWWW = new WWWForm();
//add fields between here
formWWW.AddField("highscore", bestscore.ToString());
//byte[] formData = System.Text.Encoding.UTF8.GetBytes(bestscore.ToString());
//string myString = System.Text.Encoding.UTF8.GetString(formData);
MyClass classData = new MyClass();
classData.highscore = bestscore;
Debug.Log(JsonUtility.ToJson(classData));
urlWeb = url + "/" + PublicLevel.id.ToString();
//add fields between here!
using (UnityWebRequest webRequest = UnityWebRequest.Put(urlWeb, JsonUtility.ToJson(classData)))
{
//webRequest header of request to HTTP server should be set to json
webRequest.SetRequestHeader("Content-type", "application/json");
yield return(webRequest.SendWebRequest());
if (webRequest.isNetworkError)
{
Debug.Log(":Request error:");
}
else
{
Debug.Log(":Request Sent:");
Debug.Log(urlWeb);
}
}
}
IEnumerator SendHttp(WordCandidate[] inputs)
{
string url = "localhost:3000/input";
inputData data = new inputData(inputs);
string inputJSON = JsonUtility.ToJson(data);
UnityWebRequest www = UnityWebRequest.Put(url, inputJSON);
www.SetRequestHeader("Content-Type", "application/json");
www.method = "POST";
yield return(www.SendWebRequest());
if (www.isNetworkError || www.isHttpError)
{
Debug.Log(www.error);
}
else
{
string response = www.downloadHandler.text;
inputResult tmp = JsonUtility.FromJson <inputResult>(response);
buttonContainer.newSet(tmp.suggestions);
master.wordCandidates.updateList(tmp.inputs);
}
}
IEnumerator Put(string api_path)
{
if (token != null)
{
byte[] data = new byte[] { 0x00 };
using (UnityWebRequest request = UnityWebRequest.Put(API_URL + api_path, data)) {
PrepareHeaders(request);
yield return(VimeoApi.SendRequest(request));
if (request.error != null)
{
Debug.LogError(request.downloadHandler.text);
if (OnError != null)
{
OnError(request.downloadHandler.text);
}
}
else
{
// TODO create event hook
}
}
}
}
IEnumerator CheckName()
{
result.text = " Loading ...";
JSONObject myData = new JSONObject(JSONObject.Type.OBJECT);
myData.AddField("name", roomDetails.name);
myData.AddField("username", playerName.value);
using (UnityWebRequest www = UnityWebRequest.Put(serverAddress.value + endPoint, myData.ToString()))
{
www.method = UnityWebRequest.kHttpVerbGET;
www.SetRequestHeader("Content-Type", "application/json");
www.SetRequestHeader("Accept", "application / json");
yield return(www.SendWebRequest());
JSONObject res = new JSONObject(www.downloadHandler.text);
if (res["error"] && res["error"].b)
{
result.text = res["message"].str;
yield break;
}
if (www.result != UnityWebRequest.Result.Success)
{
result.text = errorMessage.value;
Debug.Log(www.error);
yield break;
}
result.text = res["message"].str;
Successful();
}
}
public static IEnumerator GetAnInstance(Action <Instance> callback)
{
UnityWebRequest req = UnityWebRequest.Put("noneuclideangirl.net:13337/server/get", Auth);
req.method = UnityWebRequest.kHttpVerbPOST;
req.SetRequestHeader("Content-Type", "application/json");
req.SetRequestHeader("Accept", "application/json");
yield return(req.SendWebRequest());
if (!req.isNetworkError && req.responseCode == 200)
{
var res = req.downloadHandler.text;
try {
callback(JsonUtility.FromJson <Instance>(res));
} catch (ArgumentException e) {
Debug.LogError(e);
callback(null);
}
}
else
{
Debug.Log(req.error);
}
}
IEnumerator _request(string method, string url, WWWForm data, Callback callback, bool needAuthor = true)
{
UnityWebRequest _www;
switch (method)
{
case "POST":
_www = UnityWebRequest.Post(url, data);
break;
case "PUT":
_www = UnityWebRequest.Put(url, data.data);
_www.SetRequestHeader("Content-Type", "application/x-www-form-urlencoded");
break;
case "DELETE":
_www = UnityWebRequest.Delete(url);
break;
case "GET":
default:
_www = UnityWebRequest.Get(url);
break;
}
if (needAuthor)
{
_www.downloadHandler = new DownloadHandlerBuffer();
}
using (UnityWebRequest www = _www){
yield return(www.Send());
callback(new HttpResponse(www));
}
}
IEnumerator getConfigurationFromServer()
{
command = new SpeachToTextOfflineCommand();
command.action = "getVoicesList";
string json = JsonUtility.ToJson(command);
print(json);
byte[] myData = System.Text.Encoding.UTF8.GetBytes(json);
UnityWebRequest www = UnityWebRequest.Put(address, myData);
//UnityWebRequest www = UnityWebRequest.Post(address, json);
www.SetRequestHeader("Content-Type", "application/json");
yield return(www.Send());
if (www.isNetworkError)
{
if (www.error == "Cannot connect to destination host")
{
MagicRoomSpeachToText_active = false;
}
}
else
{
MagicRoomSpeachToText_active = true;
Debug.Log(www.downloadHandler.text);
SpeachToTextOfflineConfiguration conf = new SpeachToTextOfflineConfiguration();
conf = JsonUtility.FromJson <SpeachToTextOfflineConfiguration>(www.downloadHandler.text);
listofAssociatedNames = conf.voices;
string log = "";
foreach (VoicesOffline s in listofAssociatedNames)
{
log += "Available " + s.name + " as a voice, ";
}
Logger.addToLogNewLine("ServerTTSO", log);
}
}
private UnityWebRequest BakeRequest(string endpoint, string data, string method, bool requireLoginToken, bool requiresWssToken)
{
//// log it
//string sRequest = "==> BakeRequest for: " + endpoint;
//sRequest += "\n endpoint: " + endpoint;
//sRequest += "\n method: " + method;
//sRequest += "\n data: " + data;
//sRequest += "\n bRequiresLoginToken: " + requireLoginToken;
//sRequest += "\n bRequiresWssToken: " + requiresWssToken;
//if (requireLoginToken) sRequest += "\n loginToken: " + API.loginToken;
//if (requiresWssToken) sRequest += "\n wssToken: " + API.wssToken;
//Debug.Log(sRequest);
UnityWebRequest www;
if (method == "GET")
{
www = UnityWebRequest.Get(endpoint);
}
else
{
www = UnityWebRequest.Put(endpoint, data);
www.method = method;
}
www.SetRequestHeader("Content-Type", "application/json");
if (requireLoginToken)
{
www.SetRequestHeader("Authorization", "Bearer " + API.loginToken);
}
if (requiresWssToken)
{
www.SetRequestHeader("Authorization", "Bearer " + API.wssToken);
}
return(www);
}
IEnumerator Answer(string info, System.Action <string> callback = null)
{
byte[] bodyRaw = Encoding.UTF8.GetBytes(info);
using (UnityWebRequest request = UnityWebRequest.Put("https://webhooks.mongodb-realm.com/api/client/v2.0/app/covidwarrior-xhivn/service/CovidWarriorInfo/incoming_webhook/answered", bodyRaw))
{
yield return(request.SendWebRequest());
if (request.isNetworkError || request.isHttpError)
{
Debug.Log(request.error);
if (callback != null)
{
callback.Invoke("false");
}
}
else
{
if (callback != null)
{
callback.Invoke(request.downloadHandler.text);
}
}
}
}
private IEnumerator createRoom()
{
int net_count = 0;
float timeInterval = 1.0f;
isNetSuccee = false;
while (true)
{
createRoomJsonCls op_data;
op_data = new createRoomJsonCls(playerData.Instance.user_id);
string sendDataJson = UnityEngine.JsonUtility.ToJson(op_data);
UnityWebRequest request = UnityWebRequest.Put(Constants.ServerAdress, sendDataJson);
request.method = UnityWebRequest.kHttpVerbPOST;
yield return(request.SendWebRequest());
if (request.responseCode == 200)
{
string text = request.downloadHandler.text;
Constants.Room_id = playerData.Instance.user_id;
isNetSuccee = true;
break;
}
net_count++;
if (net_count > 3)
{
Debug.Log("YOU OUT");
Application.Quit();
}
Debug.Log(timeInterval);
yield return(new WaitForSeconds(timeInterval));
timeInterval *= 2;
}
}
public override IEnumerator RunJob()
{
Debug.Log("*************************** CoroutineJobLoadMap ***************************");
BaseMapper mapper = host as BaseMapper;
SDKMapRequest r = new SDKMapRequest();
r.token = mapper.token;
r.id = this.id;
string jsonString2 = JsonUtility.ToJson(r);
using (UnityWebRequest request = UnityWebRequest.Put(string.Format(Endpoint.URL_FORMAT, mapper.server, Endpoint.LOAD_MAP), jsonString2))
{
request.method = UnityWebRequest.kHttpVerbPOST;
request.useHttpContinue = false;
request.SetRequestHeader("Content-Type", "application/json");
request.SetRequestHeader("Accept", "application/json");
yield return(request.SendWebRequest());
//Debug.Log("Response code: " + request.responseCode);
if (request.isNetworkError || request.isHttpError)
{
Debug.LogError(request.error);
}
else if (request.responseCode == (long)HttpStatusCode.OK)
{
SDKMapResult result = JsonUtility.FromJson <SDKMapResult>(request.downloadHandler.text);
if (result.error == "none")
{
byte[] mapData = Convert.FromBase64String(result.b64);
Debug.Log("Load map " + this.id + " (" + mapData.Length + " bytes) (" + MD5(mapData) + "/" + result.md5_al + ")");
uint countMax = 16 * 1024;
Vector3[] vector3Array = new Vector3[countMax];
Task <int> t0 = Task.Run(() =>
{
return(Immersal.Core.LoadMap(mapData));
});
while (!t0.IsCompleted)
{
yield return(null);
}
int mapId = t0.Result;
Debug.Log("mapId " + mapId);
Task <int> t1 = Task.Run(() =>
{
return(Immersal.Core.GetPointCloud(mapId, vector3Array));
});
while (!t1.IsCompleted)
{
yield return(null);
}
int num = t1.Result;
Debug.Log("map points: " + num);
PointCloudRenderer renderer = go.AddComponent <PointCloudRenderer>();
renderer.CreateCloud(vector3Array, num);
renderer.mapId = mapId;
if (!mapper.pcr.ContainsKey(id))
{
mapper.pcr.Add(id, renderer);
}
mapper.stats.locFail = 0;
mapper.stats.locSucc = 0;
VisualizeManager.loadJobs.Remove(mapId);
}
}
}
}
public override IEnumerator RunJob()
{
Debug.Log("*************************** CoroutineJobLocalize On-Server ***************************");
BaseMapper mapper = host as BaseMapper;
byte[] capture = new byte[channels * width * height + 1024];
Task <(string, icvCaptureInfo)> t = Task.Run(() =>
{
icvCaptureInfo info = Immersal.Core.CaptureImage(capture, capture.Length, pixels, width, height, channels);
return(Convert.ToBase64String(capture, 0, info.captureSize), info);
});
while (!t.IsCompleted)
{
yield return(null);
}
string encodedImage = t.Result.Item1;
icvCaptureInfo captureInfo = t.Result.Item2;
SDKLocalizeRequest imageRequest = this.useGPS ? new SDKGeoLocalizeRequest() : new SDKLocalizeRequest();
imageRequest.token = mapper.token;
imageRequest.fx = intrinsics.x;
imageRequest.fy = intrinsics.y;
imageRequest.ox = intrinsics.z;
imageRequest.oy = intrinsics.w;
imageRequest.b64 = encodedImage;
if (this.useGPS)
{
SDKGeoLocalizeRequest gr = imageRequest as SDKGeoLocalizeRequest;
gr.latitude = this.latitude;
gr.longitude = this.longitude;
gr.radius = this.radius;
}
else
{
int n = mapper.pcr.Count;
imageRequest.mapIds = new SDKMapId[n];
int count = 0;
foreach (int id in mapper.pcr.Keys)
{
imageRequest.mapIds[count] = new SDKMapId();
imageRequest.mapIds[count++].id = id;
}
}
string jsonString = JsonUtility.ToJson(imageRequest);
string endpoint = this.useGPS ? Endpoint.SERVER_GEOLOCALIZE : Endpoint.SERVER_LOCALIZE;
SDKLocalizeResult locResult = new SDKLocalizeResult();
locResult.success = false;
Matrix4x4 m = new Matrix4x4();
Matrix4x4 cloudSpace = new Matrix4x4();
using (UnityWebRequest request = UnityWebRequest.Put(string.Format(Endpoint.URL_FORMAT, mapper.server, endpoint), jsonString))
{
request.method = UnityWebRequest.kHttpVerbPOST;
request.useHttpContinue = false;
request.SetRequestHeader("Content-Type", "application/json");
request.SetRequestHeader("Accept", "application/json");
yield return(request.SendWebRequest());
if (request.isNetworkError || request.isHttpError)
{
Debug.LogError(request.error);
}
else if (request.responseCode == (long)HttpStatusCode.OK)
{
locResult = JsonUtility.FromJson <SDKLocalizeResult>(request.downloadHandler.text);
if (locResult.success)
{
cloudSpace = Matrix4x4.identity;
cloudSpace.m00 = locResult.r00; cloudSpace.m01 = locResult.r01; cloudSpace.m02 = locResult.r02; cloudSpace.m03 = locResult.px;
cloudSpace.m10 = locResult.r10; cloudSpace.m11 = locResult.r11; cloudSpace.m12 = locResult.r12; cloudSpace.m13 = locResult.py;
cloudSpace.m20 = locResult.r20; cloudSpace.m21 = locResult.r21; cloudSpace.m22 = locResult.r22; cloudSpace.m23 = locResult.pz;
Matrix4x4 trackerSpace = Matrix4x4.TRS(position, rotation, Vector3.one);
mapper.stats.locSucc++;
Debug.Log("*************************** On-Server Localization Succeeded ***************************");
Debug.Log("fc 4x4\n" + cloudSpace + "\n" +
"ft 4x4\n" + trackerSpace);
m = trackerSpace * (cloudSpace.inverse);
foreach (KeyValuePair <int, PointCloudRenderer> p in mapper.pcr)
{
if (p.Key == locResult.map)
{
p.Value.go.transform.position = m.GetColumn(3);
p.Value.go.transform.rotation = m.rotation;
break;
}
}
Debug.Log(locResult.error);
}
else
{
mapper.stats.locFail++;
Debug.Log("*************************** On-Server Localization Failed ***************************");
}
}
}
if (locResult.success)
{
SDKEcefRequest ecefRequest = new SDKEcefRequest();
ecefRequest.token = mapper.token;
ecefRequest.id = locResult.map;
using (UnityWebRequest request = UnityWebRequest.Put(string.Format(Endpoint.URL_FORMAT, mapper.server, Endpoint.SERVER_ECEF), JsonUtility.ToJson(ecefRequest)))
{
request.method = UnityWebRequest.kHttpVerbPOST;
request.useHttpContinue = false;
request.SetRequestHeader("Content-Type", "application/json");
request.SetRequestHeader("Accept", "application/json");
yield return(request.SendWebRequest());
if (request.isNetworkError || request.isHttpError)
{
Debug.LogError(request.error);
}
else if (request.responseCode == (long)HttpStatusCode.OK)
{
SDKEcefResult result = JsonUtility.FromJson <SDKEcefResult>(request.downloadHandler.text);
Debug.Log(request.downloadHandler.text);
double[] wgs84 = new double[3];
Vector3 pos = cloudSpace.GetColumn(3);
Quaternion rot = cloudSpace.rotation;
int r = Immersal.Core.PosMapToWgs84(wgs84, pos, result.ecef);
mapper.vlatitude = wgs84[0];
mapper.vlongitude = wgs84[1];
mapper.valtitude = wgs84[2];
if (r == 0)
{
mapper.lastLocalizedPose = (true, result.ecef, m.inverse, new Pose(pos, rot));
}
}
}
}
}
public override IEnumerator RunJob()
{
Debug.Log("*************************** CoroutineJobCapture ***************************");
BaseMapper mapper = host as BaseMapper;
byte[] capture = new byte[channels * width * height + 1024];
Task <(string, icvCaptureInfo)> t = Task.Run(() =>
{
icvCaptureInfo info = Core.CaptureImage(capture, capture.Length, pixels, width, height, channels);
return(Convert.ToBase64String(capture, 0, info.captureSize), info);
});
while (!t.IsCompleted)
{
yield return(null);
}
string encodedImage = t.Result.Item1;
icvCaptureInfo captureInfo = t.Result.Item2;
mapper.NotifyIfConnected(captureInfo);
SDKImageRequest imageRequest = new SDKImageRequest();
imageRequest.token = mapper.token;
imageRequest.run = this.run;
imageRequest.bank = mapper.currentBank;
imageRequest.index = this.index;
imageRequest.anchor = this.anchor;
imageRequest.px = position.x;
imageRequest.py = position.y;
imageRequest.pz = position.z;
imageRequest.r00 = rotation.m00;
imageRequest.r01 = rotation.m01;
imageRequest.r02 = rotation.m02;
imageRequest.r10 = rotation.m10;
imageRequest.r11 = rotation.m11;
imageRequest.r12 = rotation.m12;
imageRequest.r20 = rotation.m20;
imageRequest.r21 = rotation.m21;
imageRequest.r22 = rotation.m22;
imageRequest.fx = intrinsics.x;
imageRequest.fy = intrinsics.y;
imageRequest.ox = intrinsics.z;
imageRequest.oy = intrinsics.w;
imageRequest.latitude = latitude;
imageRequest.longitude = longitude;
imageRequest.altitude = altitude;
imageRequest.b64 = encodedImage;
string jsonString = JsonUtility.ToJson(imageRequest);
using (UnityWebRequest request = UnityWebRequest.Put(string.Format(Endpoint.URL_FORMAT, mapper.server, Endpoint.CAPTURE_IMAGE), jsonString))
{
request.method = UnityWebRequest.kHttpVerbPOST;
request.useHttpContinue = false;
request.SetRequestHeader("Content-Type", "application/json");
request.SetRequestHeader("Accept", "application/json");
yield return(request.SendWebRequest());
Debug.Log("Response code: " + request.responseCode);
if (request.isNetworkError || request.isHttpError)
{
Debug.LogError(request.error);
}
else if (request.responseCode == (long)HttpStatusCode.OK)
{
SDKImageResult result = JsonUtility.FromJson <SDKImageResult>(request.downloadHandler.text);
if (result.error == "none")
{
Debug.Log("Image uploaded successfully");
}
}
}
}
private IEnumerator ProcessRequestQueue()
{
// yield AFTER we increment the connection count, so the Send() function can return immediately
_activeConnections += 1;
#if UNITY_EDITOR
if (!UnityEditorInternal.InternalEditorUtility.inBatchMode)
{
yield return(null);
}
#else
yield return(null);
#endif
while (_requests.Count > 0)
{
Request req = _requests.Dequeue();
if (req.Cancel)
{
continue;
}
string url = URL;
if (!string.IsNullOrEmpty(req.Function))
{
url += req.Function;
}
StringBuilder args = null;
foreach (var kp in req.Parameters)
{
var key = kp.Key;
var value = kp.Value;
if (value is string)
{
value = UnityWebRequest.EscapeURL((string)value);
}
else if (value is byte[])
{
value = Convert.ToBase64String((byte[])value);
}
else if (value is Int32 || value is Int64 || value is UInt32 || value is UInt64 || value is float)
{
value = value.ToString();
}
else if (value is bool)
{
value = value.ToString().ToLower();
}
else if (value is DateTime?)
{
value = String.Format("{0:yyyy-MM-ddThh:mm:ssZ}", value);//yyyy-MM-ddthh:mm:ssz
}
else if (value != null)
{
Log.Warning("RESTConnector.ProcessRequestQueue()", "Unsupported parameter value type {0}", value.GetType().Name);
}
else
{
Log.Error("RESTConnector.ProcessRequestQueue()", "Parameter {0} value is null", key);
}
if (args == null)
{
args = new StringBuilder();
}
else
{
args.Append("&");
}
args.Append(key + "=" + value);
}
if (args != null && args.Length > 0)
{
url += "?" + args.ToString();
}
AddHeaders(req.Headers);
Response resp = new Response();
DateTime startTime = DateTime.Now;
UnityWebRequest unityWebRequest = null;
if (req.Forms != null || req.Send != null)
{
// POST and PUT with data
if (req.Forms != null)
{
if (req.Send != null)
{
Log.Warning("RESTConnector", "Do not use both Send & Form fields in a Request object.");
}
WWWForm form = new WWWForm();
JObject bodyObject = new JObject();
try
{
foreach (var formData in req.Forms)
{
if (formData.Value.IsBinary)
{
form.AddBinaryData(formData.Key, formData.Value.Contents, formData.Value.FileName, formData.Value.MimeType);
bodyObject[formData.Key] = formData.Value.Contents;
}
else if (formData.Value.BoxedObject is string)
{
form.AddField(formData.Key, (string)formData.Value.BoxedObject);
bodyObject[formData.Key] = (string)formData.Value.BoxedObject;
}
else if (formData.Value.BoxedObject is int)
{
form.AddField(formData.Key, (int)formData.Value.BoxedObject);
bodyObject[formData.Key] = (int)formData.Value.BoxedObject;
}
else if (formData.Value.BoxedObject != null)
{
Log.Warning("RESTConnector.ProcessRequestQueue()", "Unsupported form field type {0}", formData.Value.BoxedObject.GetType().ToString());
}
}
}
catch (Exception e)
{
Log.Error("RESTConnector.ProcessRequestQueue()", "Exception when initializing WWWForm: {0}", e.ToString());
}
if (req.HttpMethod == UnityWebRequest.kHttpVerbPUT)
{
unityWebRequest = UnityWebRequest.Post(url, form);
unityWebRequest.method = "PUT";
}
else
{
var httpContent = bodyObject.ToString();
unityWebRequest = UnityWebRequest.Put(url, httpContent);
unityWebRequest.method = "POST";
}
}
else if (req.Send != null)
{
unityWebRequest = new UnityWebRequest(url, req.HttpMethod)
{
uploadHandler = (UploadHandler) new UploadHandlerRaw(req.Send)
};
unityWebRequest.SetRequestHeader("Content-Type", "application/json");
}
}
else
{
// GET, DELETE and POST without data
unityWebRequest = new UnityWebRequest
{
url = url,
method = req.HttpMethod
};
if (req.HttpMethod == UnityWebRequest.kHttpVerbPOST)
{
unityWebRequest.SetRequestHeader("Content-Type", "application/json");
}
}
foreach (KeyValuePair <string, string> kvp in req.Headers)
{
unityWebRequest.SetRequestHeader(kvp.Key, kvp.Value);
}
unityWebRequest.downloadHandler = new DownloadHandlerBuffer();
if (req.DisableSslVerification == true)
{
unityWebRequest.certificateHandler = new AcceptAllCertificates();
}
else
{
unityWebRequest.certificateHandler = null;
}
#if UNITY_2017_2_OR_NEWER
unityWebRequest.SendWebRequest();
#else
www.Send();
#endif
#if ENABLE_DEBUGGING
Log.Debug("RESTConnector", "URL: {0}", url);
#endif
// wait for the request to complete.
float timeout = Mathf.Max(Constants.Config.Timeout, req.Timeout);
while (!unityWebRequest.isDone)
{
if (req.Cancel)
{
break;
}
if ((DateTime.Now - startTime).TotalSeconds > timeout)
{
break;
}
if (req.OnUploadProgress != null)
{
req.OnUploadProgress(unityWebRequest.uploadProgress);
}
if (req.OnDownloadProgress != null)
{
req.OnDownloadProgress(unityWebRequest.downloadProgress);
}
#if UNITY_EDITOR
if (!UnityEditorInternal.InternalEditorUtility.inBatchMode)
{
yield return(null);
}
#else
yield return(null);
#endif
}
if (req.Cancel)
{
continue;
}
bool bError = false;
IBMError error = null;
if (!string.IsNullOrEmpty(unityWebRequest.error))
{
switch (unityWebRequest.responseCode)
{
case HTTP_STATUS_OK:
case HTTP_STATUS_CREATED:
case HTTP_STATUS_ACCEPTED:
bError = false;
break;
default:
bError = true;
break;
}
string errorMessage = GetErrorMessage(unityWebRequest.downloadHandler.text);
if (errorMessage.Equals(""))
{
errorMessage = unityWebRequest.error;
}
error = new IBMError()
{
Url = url,
StatusCode = unityWebRequest.responseCode,
ErrorMessage = errorMessage,
Response = unityWebRequest.downloadHandler.text,
ResponseHeaders = unityWebRequest.GetResponseHeaders()
};
if (bError)
{
Log.Error("RESTConnector.ProcessRequestQueue()", "URL: {0}, ErrorCode: {1}, Error: {2}, Response: {3}", url, unityWebRequest.responseCode, unityWebRequest.error,
string.IsNullOrEmpty(unityWebRequest.downloadHandler.text) ? "" : unityWebRequest.downloadHandler.text);
}
else
{
Log.Warning("RESTConnector.ProcessRequestQueue()", "URL: {0}, ErrorCode: {1}, Error: {2}, Response: {3}", url, unityWebRequest.responseCode, unityWebRequest.error,
string.IsNullOrEmpty(unityWebRequest.downloadHandler.text) ? "" : unityWebRequest.downloadHandler.text);
}
}
if (!unityWebRequest.isDone)
{
Log.Error("RESTConnector.ProcessRequestQueue()", "Request timed out for URL: {0}", url);
bError = true;
}
// generate the Response object now..
if (!bError)
{
resp.Success = true;
resp.Data = unityWebRequest.downloadHandler.data;
resp.HttpResponseCode = unityWebRequest.responseCode;
}
else
{
resp.Success = false;
resp.Error = error;
}
resp.Headers = unityWebRequest.GetResponseHeaders() ?? new Dictionary <string, string>();
resp.ElapsedTime = (float)(DateTime.Now - startTime).TotalSeconds;
// if the response is over a threshold, then log with status instead of debug
if (resp.ElapsedTime > LogResponseTime)
{
Log.Warning("RESTConnector.ProcessRequestQueue()", "Request {0} completed in {1} seconds.", url, resp.ElapsedTime);
}
if (req.OnResponse != null)
{
req.OnResponse(req, resp);
}
unityWebRequest.Dispose();
}
// reduce the connection count before we exit.
_activeConnections -= 1;
yield break;
}
UnityWebRequest CreateWebRequest(string url, LootLockerServerRequest request)
{
UnityWebRequest webRequest;
switch (request.httpMethod)
{
case LootLockerHTTPMethod.UPLOAD:
webRequest = UnityWebRequest.Post(url, request.form);
break;
case LootLockerHTTPMethod.POST:
case LootLockerHTTPMethod.PATCH:
// Defaults are fine for PUT
case LootLockerHTTPMethod.PUT:
if (request.payload == null && request.upload != null)
{
List <IMultipartFormSection> form = new List <IMultipartFormSection>
{
new MultipartFormFileSection(request.uploadName, request.upload, System.DateTime.Now.ToString(), request.uploadType)
};
// generate a boundary then convert the form to byte[]
byte[] boundary = UnityWebRequest.GenerateBoundary();
byte[] formSections = UnityWebRequest.SerializeFormSections(form, boundary);
// Set the content type - NO QUOTES around the boundary
string contentType = String.Concat("multipart/form-data; boundary=--", Encoding.UTF8.GetString(boundary));
//Debug.LogError("Content type Set: " + contentType);
// Make my request object and add the raw body. Set anything else you need here
webRequest = new UnityWebRequest();
webRequest.SetRequestHeader("Content-Type", "multipart/form-data; boundary=--");
webRequest.uri = new Uri(url);
Debug.Log(url); //the url is wrong in some cases
webRequest.uploadHandler = new UploadHandlerRaw(formSections);
webRequest.uploadHandler.contentType = contentType;
webRequest.useHttpContinue = false;
// webRequest.method = "POST";
webRequest.method = UnityWebRequest.kHttpVerbPOST;
}
else
{
string json = (request.payload != null && request.payload.Count > 0) ? JsonConvert.SerializeObject(request.payload) : request.jsonPayload;
#if UNITY_EDITOR
LootLockerSDKManager.DebugMessage("REQUEST BODY = " + json);
#endif
byte[] bytes = System.Text.Encoding.UTF8.GetBytes(string.IsNullOrEmpty(json) ? "{}" : json);
webRequest = UnityWebRequest.Put(url, bytes);
webRequest.method = request.httpMethod.ToString();
}
break;
case LootLockerHTTPMethod.OPTIONS:
case LootLockerHTTPMethod.HEAD:
case LootLockerHTTPMethod.GET:
// Defaults are fine for GET
webRequest = UnityWebRequest.Get(url);
webRequest.method = request.httpMethod.ToString();
break;
case LootLockerHTTPMethod.DELETE:
// Defaults are fine for DELETE
webRequest = UnityWebRequest.Delete(url);
break;
default:
throw new System.Exception("Invalid HTTP Method");
}
if (baseHeaders != null)
{
foreach (KeyValuePair <string, string> pair in baseHeaders)
{
if (pair.Key == "Content-Type" && request.upload != null)
{
continue;
}
webRequest.SetRequestHeader(pair.Key, pair.Value);
}
}
if (request.extraHeaders != null)
{
foreach (KeyValuePair <string, string> pair in request.extraHeaders)
{
webRequest.SetRequestHeader(pair.Key, pair.Value);
}
}
return(webRequest);
}
IEnumerator ConnectionCo()
{
if (Application.internetReachability == NetworkReachability.NotReachable)
{
if (OnFail != null)
{
Response tempResponse = new Response();
tempResponse._textData = "check the connectivity";
tempResponse._errorData = "ERROR : NO ACTIVE CONNECTION";
OnFail(this, tempResponse);
}
yield break;
}
bool isUrlExist = false;
string inUrl = _url;
if (shouldUseCache)
{
isUrlExist = WebCacheManager.Instance.LoadUrl(out _url, inUrl);
}
if (_requestType == RequestType.GET)
{
if (_responseType == ResponseType.IMAGE)
{
_www = UnityWebRequestTexture.GetTexture(_url);
}
else
{
_www = UnityWebRequest.Get(_url);
}
_www.chunkedTransfer = false;
}
else
{
if (_postData != null)
{
_www = _www == null ? UnityWebRequest.Put(_url, Encoding.ASCII.GetBytes(_postData)) : _www;
}
else
{
Debug.Log("Posting Web Request : "+_url);
_www = _www == null ? UnityWebRequest.Post(_url, _webForm) : _www;
}
_www.chunkedTransfer = false;
}
yield return _www.SendWebRequest();
if (debug)
{
// GLog.Log("Web data :" + _www.text);
// GLog.Log("Web Error :" + _www.error);
}
if (_www.error == null)
{
if (OnSuccess != null)
{
switch (_responseType)
{
case ResponseType.TEXT:
Response tempResponse = new Response();
Debug.LogError("response: "+ _www.downloadHandler.text);
tempResponse._textData = _www.downloadHandler.text;
if (shouldUseCache)
{
if (!isUrlExist)
{
// WebCacheManager.Instance.AddInCache(tempResponse, ResponseType.TEXT, _url);
}
}
OnSuccess(this, tempResponse);
break;
case ResponseType.IMAGE:
tempResponse = new Response();
if (_refImage == null)
{
#if _D_I
//Debug.Log("The Reference Image is null............");
#endif
tempResponse._image = new Texture2D(1, 1, TextureFormat.RGB24, false);
}
else
{
#if _D_I
// Debug.Log("The Reference Image is not null............");
#endif
tempResponse._image = _refImage;
}
if (_www != null)
{
tempResponse._image = ((DownloadHandlerTexture)_www.downloadHandler).texture;
}
/* if (_www != null)
_www.LoadImageIntoTexture(tempResponse._image);*/
if (shouldUseCache)
{
if (!isUrlExist)
{
// WebCacheManager.Instance.AddInCache(tempResponse, ResponseType.IMAGE, _url);
}
}
OnSuccess(this, tempResponse);
break;
}
}
}
else
{
if (OnFail != null)
{
Response tempResponse = new Response();
tempResponse._textData = _www.downloadHandler.text.ToString();
tempResponse._errorData = _www.error;
OnFail(this, tempResponse);
}
}
if (_autoDestroy)
{
Close();
}
//yield return null;
}
private static IEnumerator SimpleCallCoroutine(string method, string fullUrl, byte[] payload, Action <byte[]> successCallback, Action <string> errorCallback)
{
if (payload == null)
{
using (UnityWebRequest www = UnityWebRequest.Get(fullUrl))
{
#if UNITY_2017_2_OR_NEWER
yield return(www.SendWebRequest());
#else
yield return(www.Send());
#endif
if (!string.IsNullOrEmpty(www.error))
{
errorCallback(www.error);
}
else
{
successCallback(www.downloadHandler.data);
}
};
}
else
{
UnityWebRequest request;
if (method == "put")
{
request = UnityWebRequest.Put(fullUrl, payload);
}
else
{
request = new UnityWebRequest(fullUrl, "POST");
request.uploadHandler = (UploadHandler) new UploadHandlerRaw(payload);
request.downloadHandler = (DownloadHandler) new DownloadHandlerBuffer();
request.SetRequestHeader("Content-Type", "application/json");
//var strPayload = System.Text.Encoding.UTF8.GetString(payload);
//Debug.Log(strPayload);
}
#if UNITY_2017_2_OR_NEWER
request.chunkedTransfer = false; // can be removed after Unity's PUT will be more stable
request.SendWebRequest();
#else
request.Send();
#endif
#if !UNITY_WEBGL
while (request.uploadProgress < 1 && request.downloadProgress < 1)
{
yield return(1);
}
#else
while (!request.isDone)
{
yield return(1);
}
#endif
while (!request.isDone)
{
yield return(1);
}
if (!string.IsNullOrEmpty(request.error))
{
errorCallback(request.error);
}
else
{
successCallback(request.downloadHandler.data);
}
}
}
public IEnumerator WebRequest(HttpReqType type, string url, byte[] data = null, Action <string> successCallback = null, Action failCallback = null)
{
UnityWebRequest www = null;
switch (type)
{
case HttpReqType.GET:
www = UnityWebRequest.Get(Https + url);
break;
case HttpReqType.PUT:
www = UnityWebRequest.Put(Https + url, data);
break;
case HttpReqType.POST:
if (data != null)
{
www = UnityWebRequest.Put(Https + url, data);
}
else
{
JsonData json = new JsonData();
json["AppName"] = "MusicGame";
byte[] Data = System.Text.Encoding.UTF8.GetBytes(json.ToJson());
www = UnityWebRequest.Put(Https + url, Data);
}
www.method = UnityWebRequest.kHttpVerbPOST;
break;
}
www.SetRequestHeader("Content-Type", "application/json;charset=utf-8");
www.SetRequestHeader("Token", Token);
yield return(www.Send());
bool exceptionOccur = false;
try
{
if (!string.IsNullOrEmpty(www.error))
{
LogManager.Log(www.error);
}
else
{
if (successCallback != null)
{
successCallback.Invoke(www.downloadHandler.text);
}
}
}
catch (Exception e)
{
LogManager.LogError(e.StackTrace);
LogManager.LogError(e.Message + "\n webRequest faild: " + url);
exceptionOccur = true;
}
finally
{
if (failCallback != null && exceptionOccur)
{
failCallback.Invoke();
}
}
}
/// <summary>
/// Makes the HTTP request (Sync).
/// </summary>
/// <param name="path">URL path.</param>
/// <param name="method">HTTP method.</param>
/// <param name="queryParams">Query parameters.</param>
/// <param name="postBody">HTTP body (POST request).</param>
/// <param name="headerParams">Header parameters.</param>
/// <param name="formParams">Form parameters.</param>
/// <param name="fileParams">File parameters.</param>
/// <param name="authSettings">Authentication settings.</param>
/// <returns>IAsyncOperation<UnityWebRequest></returns>
public IAsyncOperation <UnityWebRequest> CallApi(String path, string method, Dictionary <String, String> queryParams, String postBody,
Dictionary <String, String> headerParams, Dictionary <String, String> formParams,
Dictionary <String, String> fileParams, String[] authSettings)
{
UnityWebRequest request = null;
var result = new AsyncCompletionSource <UnityWebRequest>();
switch (method)
{
case UnityWebRequest.kHttpVerbGET:
request = UnityWebRequest.Get(BasePath + path);
break;
case UnityWebRequest.kHttpVerbPOST:
request = UnityWebRequest.Post(BasePath + path, formParams);
break;
case UnityWebRequest.kHttpVerbPUT:
request = UnityWebRequest.Put(BasePath + path, postBody);
break;
case UnityWebRequest.kHttpVerbDELETE:
request = UnityWebRequest.Delete(BasePath + path);
break;
default:
throw new ApiException(500, "Method not available: " + method);
}
UpdateParamsForAuth(queryParams, headerParams, authSettings, true)
.Then(() =>
{
// add default header, if any
foreach (var defaultHeader in _defaultHeaderMap)
{
request.SetRequestHeader(defaultHeader.Key, defaultHeader.Value);
}
// add header parameter, if any
foreach (var param in headerParams)
{
request.SetRequestHeader(param.Key, param.Value);
}
if (queryParams.Count > 0 || formParams.Count > 0 && method != UnityWebRequest.kHttpVerbPOST)
{
request.url += "?";
}
// add query parameter, if any
if (queryParams.Count > 0)
{
request.url += String.Join("&", queryParams.Select(kv => kv.Key + "=" + kv.Value).ToArray());
}
foreach (var param in fileParams)
{
throw new ApiException(500, "Uploading files is not implemented.");
}
// add form parameter, if any
if (formParams.Count > 0 && method != UnityWebRequest.kHttpVerbPOST)
{
request.url += String.Join("&", formParams.Select(kv => kv.Key + "=" + kv.Value).ToArray());
}
// add file parameter, if any
foreach (var param in fileParams)
{
throw new ApiException(500, "Uploading files is not implemented.");
}
if (postBody != null)
{
// http body (model) parameter
var bodyBytes = System.Text.Encoding.UTF8.GetBytes(postBody);
request.SetRequestHeader("Content-Type", "application/json");
request.uploadHandler = new UploadHandlerRaw(bodyBytes);
request.downloadHandler = new DownloadHandlerBuffer();
}
result.AddProgressCallback((p) =>
{
UnityEngine.Debug.Log("ApiClientProgress: " + p);
if (!result.IsCompleted && !result.IsCanceled)
{
result.SetProgress(p);
}
});
Observable.FromCoroutine(() => DoRequest(result, request)).Subscribe();
})
.Catch(error =>
{
result.SetException(error);
});
return(result);
}
static bool PutRequestInit <O, I, W>(string endpoint, out UnityWebRequest uwr, out IWorker <O, I> worker, I param,
IWorker <O, I> workerDefault = null,
string token = null, params IMultipartFormSection[] parts)
where W : IWorker <O, I>, new()
where O : class
where I : class
{
bool useMock = false;
url = Instance.urlParam;
TokenPrefix = Instance.tokenPrefix;
string requestUrl = $"{url}/{endpoint}";
if (endpoint.StartsWith("http", StringComparison.OrdinalIgnoreCase))
{
requestUrl = endpoint;
}
string json = null;
byte[] jsonToSend = new byte[1];
if (workerDefault == null)
{
worker = new W();
}
else
{
worker = workerDefault;
}
uwr = new UnityWebRequest($"{requestUrl}", "PUT");
if (MocksResource != MocksResource.NONE)
{
var key = typeof(W).ToString();
if (!mocks.ContainsKey(key))
{
key = $"PUT:{endpoint}";
}
if (mocks.ContainsKey(key))
{
ToolsDebug.Log($"Use mock for Key:{key} Value:{mocks[key]?.Substring(0, Mathf.Min(mocks[key].Length, Instance.logLimit))}");
useMock = true;
}
else
{
ToolsDebug.Log($"Mocks for key {endpoint} or {typeof(W).ToString()} not found. Try real request.");
}
}
if (typeof(I) == typeof(Texture2D))
{
Texture2D sendTexture = param as Texture2D;
json = "Texture2D";
jsonToSend = ImageConversion.EncodeToPNG(sendTexture);
uwr.uploadHandler = (UploadHandler) new UploadHandlerRaw(jsonToSend);
uwr.SetRequestHeader("Content-Type", "image/png");
}
else
{
if (param != null)
{
json = worker.Serialize(param);
jsonToSend = new System.Text.UTF8Encoding().GetBytes(json);
}
if (parts != null && parts.Length != 0)
{
//TODO:
//Finish it
Debug.Log("WTF");
List <IMultipartFormSection> formData = new List <IMultipartFormSection>();
formData.Add(new MultipartFormDataSection("JSON Body", json, "application/json"));
formData.AddRange(parts);
var boundary = UnityWebRequest.GenerateBoundary();
byte[] formSections = UnityWebRequest.SerializeFormSections(formData, boundary);
uwr = UnityWebRequest.Put($"{requestUrl}", formSections);
uwr.SetRequestHeader("Content-Type", "multipart/form-data; boundary=" + System.Text.Encoding.UTF8.GetString(boundary));
uwr.uploadHandler.contentType = "multipart/form-data; boundary=" + System.Text.Encoding.UTF8.GetString(boundary);
}
else
{
uwr.uploadHandler = (UploadHandler) new UploadHandlerRaw(jsonToSend);
uwr.uploadHandler.contentType = "application/json";
}
}
uwr.downloadHandler = (DownloadHandler) new DownloadHandlerBuffer();
if (!string.IsNullOrEmpty(token))
{
uwr.SetRequestHeader("Authorization", $"{TokenPrefix} {token}");
}
ToolsDebug.Log($"{UnityWebRequest.kHttpVerbPUT}: {requestUrl} {uwr.GetRequestHeader("Authorization")} JSONBody:{json?.Substring(0, Mathf.Min(json.Length, Instance.logLimit))}");
worker.Request = param;
worker.Start();
return(useMock);
}
private IEnumerator PublishWorldUpdates(string worldName)
{
string channelName = null;
switch (preparedReleaseChannel)
{
case 0:
channelName = "live";
break;
case 1:
channelName = "beta";
break;
case 2:
channelName = "alpha";
break;
}
string uri = SDKUtil.API_ENDPOINT + "userworlds/" + userWorlds.First(w => w.key == worldName).id + "?channel=" + channelName;
// extract data from world descriptor
string worldJson = File.ReadAllText(GetWorldsRoot() + "/" + worldName + "/World.json");
World world = JsonConvert.DeserializeObject <World>(worldJson);
UserWorld userWorld = new UserWorld();
userWorld.cover_image = world.coverImage;
userWorld.world_json = worldJson;
userWorld.unity_version = Application.unityVersion;
userWorld.is_virtual = (byte)(world.isVirtual ? 1 : 0);
userWorld.android_size = verifications[worldName].distroSizeAndroid;
userWorld.pc_size = verifications[worldName].distroSizeStandaloneWin;
userWorld.linux_size = verifications[worldName].distroSizeStandaloneLinux;
// TODO: convert to SDKUtil function as well
byte[] data = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(userWorld));
using (UnityWebRequest webRequest = UnityWebRequest.Put(uri, data))
{
webRequest.SetRequestHeader("Accept", "application/json");
webRequest.SetRequestHeader("Authorization", "Bearer " + GetAPIToken());
webRequest.SetRequestHeader("Content-Type", "application/json");
yield return(webRequest.SendWebRequest());
if (webRequest.isNetworkError)
{
Debug.LogError($"Could not update world {worldName} due to network issues: {webRequest.error}");
uploadErrors = true;
}
else if (webRequest.isHttpError)
{
if (webRequest.responseCode == (int)HttpStatusCode.Unauthorized)
{
SDKUtil.invalidAPIToken = true;
Debug.LogError("Invalid or expired API Token.");
}
else
{
Debug.LogError($"There was an error updating world {worldName}: {webRequest.downloadHandler.text}");
}
uploadErrors = true;
}
}
}
public IEnumerator RequestSync(string url,
HTTPMethods methods = HTTPMethods.Get,
Dictionary <string, string> headers = null,
WWWForm param = null,
Action <DownloadHandler> onSuccess = null,
Action <float> onProgress = null,
Action <DownloadHandler> onError = null)
{
switch (methods)
{
case HTTPMethods.Get:
StringBuilder getUrl = new StringBuilder(url);
if (param != null)
{
getUrl.Append("?");
getUrl.Append(Encoding.UTF8.GetString(param.data));
}
webRequest = UnityWebRequest.Get(getUrl.ToString());
break;
case HTTPMethods.Post:
webRequest = UnityWebRequest.Post(url, param);
break;
case HTTPMethods.Put:
byte[] bodyData = null;
if (param != null)
{
bodyData = param.data;
}
webRequest = UnityWebRequest.Put(url, bodyData);
break;
case HTTPMethods.Delete:
StringBuilder deleteUrl = new StringBuilder(url);
if (param != null)
{
deleteUrl.Append("?");
deleteUrl.Append(Encoding.UTF8.GetString(param.data));
}
webRequest = UnityWebRequest.Delete(deleteUrl.ToString());
break;
case HTTPMethods.Head:
StringBuilder headUrl = new StringBuilder(url);
if (param != null)
{
headUrl.Append("?");
headUrl.Append(Encoding.UTF8.GetString(param.data));
}
webRequest = UnityWebRequest.Head(headUrl.ToString());
break;
}
if (headers != null)
{
foreach (KeyValuePair <string, string> header in headers)
{
webRequest.SetRequestHeader(header.Key, header.Value);
}
}
if (customDownloadHandler != null)
{
webRequest.downloadHandler = customDownloadHandler;
}
// 通信の前後でRequestとResponseのLogをとり、通信にかかった時間を計測する
Stopwatch stopWatch = new Stopwatch();
HTTPLogger.LogRequest(webRequest, param, headers);
stopWatch.Start();
webRequest.SendWebRequest();
while (!webRequest.isDone)
{
if (onProgress != null)
{
onProgress(webRequest.downloadProgress);
}
yield return(null);
}
if (onProgress != null)
{
onProgress(1.0f);
}
stopWatch.Stop();
HTTPLogger.LogResponse(webRequest, stopWatch.Elapsed, param);
if (webRequest.isHttpError)
{
if (onError != null)
{
onError(webRequest.downloadHandler);
}
}
else
{
if (onSuccess != null)
{
onSuccess(webRequest.downloadHandler);
}
}
yield return(webRequest.downloadHandler);
customDownloadHandler = null;
}
public IEnumerator SendLogFileCoroutine(string logFilePath)
{
while (IsLogBeingSent)
{
yield return(null);
}
IsLogBeingSent = true;
DebugLogger.Log("Sending log...");
DebugLogger.Log("Requesting PUT URL...");
var putLinkRequest = new PutLinkRequest()
{
AppId = "patcher-unity",
Version = Version.Value,
Priority = "201",
Guid = Guid.ToString(),
Compression = "gz"
};
string json = JsonConvert.SerializeObject(putLinkRequest);
UnityWebRequest putUrlRequest = new UnityWebRequest(PutUrlRequestUrl, "POST");
byte[] bodyRaw = Encoding.UTF8.GetBytes(json);
putUrlRequest.uploadHandler = new UploadHandlerRaw(bodyRaw);
putUrlRequest.downloadHandler = new DownloadHandlerBuffer();
putUrlRequest.SetRequestHeader("Content-Type", "application/json");
yield return(putUrlRequest.Send());
#if UNITY_2017_1_OR_NEWER
if (putUrlRequest.isNetworkError)
#else
if (putUrlRequest.isError)
#endif
{
DebugLogger.LogError("Error while requesting PUT URL: " + putUrlRequest.error);
IsLogBeingSent = false;
yield break;
}
var responseText = putUrlRequest.downloadHandler.text;
DebugLogger.Log("Got response: " + responseText);
var requestPutUrlJson = JsonConvert.DeserializeObject <PutLinkResponse>(responseText);
var putUrl = requestPutUrlJson.Url;
UnityWebRequest putRequest = UnityWebRequest.Put(putUrl, GetCompressedLogFileData(logFilePath));
yield return(putRequest.Send());
#if UNITY_2017_1_OR_NEWER
if (putRequest.isNetworkError)
#else
if (putRequest.isError)
#endif
{
DebugLogger.LogError("Error while sending log file: " + putRequest.error);
IsLogBeingSent = false;
yield break;
}
DebugLogger.Log("Log file sent!");
const float sendDelaySeconds = 5f;
DebugLogger.Log(string.Format("Waiting {0} seconds before next log could be sent...", sendDelaySeconds));
float startWaitTime = Time.unscaledTime;
while (Time.unscaledTime - startWaitTime < sendDelaySeconds && !_shouldAbortSending)
{
yield return(null);
}
_shouldAbortSending = false;
DebugLogger.Log("Next log can be now send.");
IsLogBeingSent = false;
}
IEnumerator uploadMatchData()
{
//If still in game, get data from player else get data from lobby player
if (isInGame)
{
Player[] players = FindObjectsOfType <Player>();
string disconnectPlayer;
if (players[0].isLocalPlayer)
{
//Condition to plus rating when opp disconnected
if ((players[0].score + players[0].totalScore) > (players[1].score + players[1].totalScore + 10))
{
MainPlayer.instance.playerData.rating += 5;
}
else
{
yield break;
}
disconnectPlayer = "player2";
}
else
{
if ((players[1].score + players[1].totalScore) > (players[0].score + players[0].totalScore + 10))
{
MainPlayer.instance.playerData.rating += 5;
}
else
{
yield break;
}
disconnectPlayer = "player1";
}
string dataPlayer1 = JsonUtility.ToJson(players[0]);
string dataPlayer2 = JsonUtility.ToJson(players[1]);
using (UnityWebRequest www = UnityWebRequest.Put("http://powerlishproject.dx.am/uploadMatchData.php", dataPlayer1 + "/" + dataPlayer2 + "/" + disconnectPlayer + "/" + localNick + "/" + oppNick))
{
www.SetRequestHeader("Content-Type", "application/json");
yield return(www.SendWebRequest());
if (www.isNetworkError || www.isHttpError)
{
Debug.Log(www.error);
}
else
{
}
}
}
else
{
string dataPlayer1 = JsonUtility.ToJson(lobbySlots[0]);
string dataPlayer2 = JsonUtility.ToJson(lobbySlots[1]);
using (UnityWebRequest www = UnityWebRequest.Put("http://powerlishproject.dx.am/uploadMatchData.php", dataPlayer1 + "/" + dataPlayer2 + "/None/" + localNick + "/" + oppNick))
{
www.SetRequestHeader("Content-Type", "application/json");
yield return(www.SendWebRequest());
if (www.isNetworkError || www.isHttpError)
{
Debug.Log(www.error);
}
else
{
}
}
}
}
private IEnumerator Login()
{
SDKLoginRequest loginRequest = new SDKLoginRequest();
loginRequest.login = emailField.text;
loginRequest.password = passwordField.text;
loginErrorText.gameObject.SetActive(false);
string jsonString = JsonUtility.ToJson(loginRequest);
//Debug.Log("jsonString: " + jsonString);
byte[] myData = System.Text.Encoding.UTF8.GetBytes(jsonString);
using (UnityWebRequest request = UnityWebRequest.Put(string.Format("{0}/{1}", m_server, "fcgi?6"), jsonString))
{
request.method = UnityWebRequest.kHttpVerbPOST;
request.useHttpContinue = false;
request.SetRequestHeader("Content-Type", "application/json");
request.SetRequestHeader("Accept", "application/json");
yield return(request.SendWebRequest());
//Debug.Log("Response code: " + request.responseCode);
if (request.isNetworkError || request.isHttpError)
{
Debug.Log(request.error);
if (request.responseCode == (long)HttpStatusCode.BadRequest)
{
loginErrorText.text = "Login failed, please try again";
loginErrorText.gameObject.SetActive(true);
}
}
else
{
Debug.Log(request.downloadHandler.text);
PlayerPrefs.SetString("login", loginRequest.login);
PlayerPrefs.SetString("password", loginRequest.password);
SDKLoginResult loginResult = JsonUtility.FromJson <SDKLoginResult>(request.downloadHandler.text);
if (loginResult.error == "none")
{
PlayerPrefs.SetString("token", loginResult.token);
m_sdkSettings.developerToken = loginResult.token;
m_toggleMappingMode.EnableMappingMode();
if (m_toggleMappingMode.MappingUI != null)
{
m_toggleMappingMode.MappingUI.GetComponent <Mapper>().OnLogOut += OnLogOut;
}
loginErrorText.gameObject.SetActive(false);
FadeOut();
}
else if (loginResult.error == "auth")
{
loginErrorText.text = "Login failed, please try again";
loginErrorText.gameObject.SetActive(true);
}
}
}
}
private UnityWebRequest BasicPut(string endpt, string content = "", bool ignoreAuth = false) => WrapRequest(UnityWebRequest.Put(baseUrl + endpt, content), ignoreAuth);
private IEnumerator JsonPost <T>(string urlPath, object data, Action <T> OnCompleted, Action <Exception> OnError, bool withAuth = true)
{
// The whole UnitytWebRequest.Put then changing method to POST thing is a janky workaround for JSON posting being broken in Unity...
using (UnityWebRequest req = UnityWebRequest.Put(new Uri(Config.RootApiUri, urlPath), JsonConvert.SerializeObject(data)))
{
req.method = "POST";
req.SetRequestHeader("Content-Type", "application/json");
if (Data?.Token != null && withAuth)
{
string authToken = null;
Exception error = null;
yield return(GetAuthToken((a) => authToken = a, (e) => error = e));
if (error != null)
{
OnError?.Invoke(error);
yield break;
}
req.SetRequestHeader("Authorization", "Bearer " + authToken);
}
yield return(req.SendWebRequest());
if (req.isNetworkError)
{
OnError(new SqApiNetworkException($"Unity Network Error: {req.error}"));
yield break;
}
else if (req.isHttpError)
{
if (req.responseCode == 401 || req.responseCode == 403)
{
OnError(new SqApiAuthException((int)req.responseCode, $"Unity Http Error: {req.error}"));
yield break;
}
else
{
OnError(new SqApiAuthException((int)req.responseCode, $"Unity Http Error: {req.error}"));
yield break;
}
}
if (req.responseCode == 204)
{
OnCompleted?.Invoke(default(T));
yield break;
}
var resStr = req.downloadHandler.text;
if (string.IsNullOrWhiteSpace(resStr))
{
OnCompleted?.Invoke(default(T));
yield break;
}
else
{
try
{
OnCompleted?.Invoke(JsonConvert.DeserializeObject <T>(resStr));
yield break;
}
catch (Exception ex)
{
Debug.WriteLine("Failed deserializing response from API", ex);
OnError?.Invoke(ex);
yield break;
}
}
}
}
System.Collections.IEnumerator ForceUploadLocalStorage(System.Action completed, System.Action failed)
{
bool hasFailed = false;
while (linesizes.Count > 1)
{
//get contents from file
int contentsize = linesizes.Pop();
int urlsize = linesizes.Pop();
int lastrequestsize = contentsize + urlsize + EOLByteCount + EOLByteCount;
fs.Seek(-lastrequestsize, SeekOrigin.End);
long originallength = fs.Length;
string tempurl = null;
string tempcontent = null;
char[] buffer = new char[urlsize];
while (sr.Peek() != -1)
{
sr.ReadBlock(buffer, 0, urlsize);
tempurl = new string(buffer);
//line return
for (int eolc = 0; eolc < EOLByteCount; eolc++)
{
sr.Read();
}
buffer = new char[contentsize];
sr.ReadBlock(buffer, 0, contentsize);
tempcontent = new string(buffer);
//line return
for (int eolc2 = 0; eolc2 < EOLByteCount; eolc2++)
{
sr.Read();
}
}
fs.SetLength(originallength - lastrequestsize);
//wait for post response
var bytes = System.Text.UTF8Encoding.UTF8.GetBytes(tempcontent);
using (UnityWebRequest request = UnityWebRequest.Put(tempurl, bytes))
{
request.method = "POST";
request.SetRequestHeader("Content-Type", "application/json");
request.SetRequestHeader("X-HTTP-Method-Override", "POST");
request.SetRequestHeader("Authorization", CognitiveStatics.ApplicationKey);
yield return(Sender.StartCoroutine(Sender.WaitForFullResponse(request, tempcontent, Sender.GenericPostFullResponse, false)));
//check internet access
var headers = request.GetResponseHeaders();
int responsecode = (int)request.responseCode;
if (responsecode == 200)
{
//check cvr header to make sure not blocked by capture portal
if (!headers.ContainsKey("cvr-request-time"))
{
hasFailed = true;
if (failed != null)
{
failed.Invoke();
}
yield break;
}
}
else
{
hasFailed = true;
if (failed != null)
{
failed.Invoke();
}
yield break;
}
}
}
if (!hasFailed)
{
if (completed != null)
{
completed.Invoke();
}
}
}
