private IEnumerator Creator(string path, HttpMethod httpMethod, byte[] formData, UniRx.IObserver <string> observer, CancellationToken cancellationToken)
{
string url = $"{m_baseUrl}{path}";
switch (httpMethod)
{
case HttpMethod.PUT:
using (UnityWebRequest www = UnityWebRequest.Put(url, formData)) {
www.SendWebRequest();
while (!www.isDone && !cancellationToken.IsCancellationRequested)
{
yield return(null);
}
if (cancellationToken.IsCancellationRequested)
{
yield break;
}
if (www.isNetworkError || www.isHttpError)
{
observer.OnError(new Exception(www.error));
}
else
{
observer.OnNext(www.downloadHandler.text);
observer.OnCompleted();
}
}
break;
default:
break;
}
}
public object RxBuildRequest <T>(UniRx.IObserver <T> o, Converter.Converter convert, RestMethodInfo methodInfo, string url)
{
Action <HttpResponseMessage <string> > responseMessage = message =>
{
string errorMessage = "";
if (IsRequestError(message, out errorMessage))
{
o.OnError(new Exception(errorMessage));
return;
}
string result = GetSuccessResponse(message);
// result = "[]";
// result = "[asd..s]";
if (EnableDebug)
{
Debug.LogFormat("Raw Response:{0}", result);
}
//Parse Json By Type
if (typeof(T) == typeof(string))
{
var resultData = (T)(object)result;
o.OnNext(resultData);
o.OnCompleted();
return;
}
T data = default(T);
bool formatError = false;
try
{
data = convert.FromBody <T>(result);
}
catch (ConversionException e)
{
formatError = true;
o.OnError(new Exception(e.Message));
}
if (!formatError)
{
o.OnNext(data);
o.OnCompleted();
}
};
HttpClientRequest httpClientRequest = new HttpClientRequest(new Uri(url), responseMessage);
ConfigureRESTfulApi(methodInfo, httpClientRequest);
return(httpClientRequest);
}
private static IEnumerator SendRequestCoroutine(HttpMethod httpMethod, string url, string postData,
Dictionary <string, string> headers, int timeout, UniRx.IObserver <string> observer, CancellationToken cancel)
{
UnityWebRequest webRequest = null;
switch (httpMethod)
{
case HttpMethod.Get:
webRequest = UnityWebRequest.Get(url);
break;
case HttpMethod.Post:
webRequest = UnityWebRequest.Post(url, postData);
break;
case HttpMethod.Put:
webRequest = UnityWebRequest.Put(url, postData);
break;
case HttpMethod.Delete:
webRequest = UnityWebRequest.Delete(url);
break;
}
webRequest.timeout = timeout;
foreach (var header in headers)
{
webRequest.SetRequestHeader(header.Key, header.Value);
}
using (webRequest)
{
webRequest.SendWebRequest();
yield return(new WaitUntil(() => webRequest.isDone || webRequest.isHttpError || webRequest.isNetworkError || cancel.IsCancellationRequested));
if (cancel.IsCancellationRequested)
{
yield break;
}
if (webRequest.isHttpError || webRequest.isNetworkError)
{
observer.OnError(new WWWErrorException(webRequest, webRequest.error));
}
else
{
var spliter = new string[] { "$!$" };
var package =
webRequest.downloadHandler.text.Split(spliter, StringSplitOptions.RemoveEmptyEntries)[1];
observer.OnNext(package);
observer.OnCompleted();
}
}
}
public bool MoveNext()
{
try
{
// OnCompleted
if (Cancellation.IsDisposed || !coroutine.MoveNext())
{
observer.OnCompleted();
return(false);
}
else
{
Current = coroutine.Current;
// OnNext
if (Current is T value)
{
observer.OnNext(value);
}
// OnError
else if (Current is Exception error)
{
observer.OnError(error);
return(false);
}
return(true);
}
}
// OnError
catch (Exception error)
{
observer.OnError(error);
return(false);
}
}
private IEnumerator RequesterArray <T>(string path, HttpMethod httpMethod, UniRx.IObserver <T[]> observer, CancellationToken cancellationToken)
{
string url = $"{m_baseUrl}{path}";
switch (httpMethod)
{
case HttpMethod.GET:
using (UnityWebRequest www = UnityWebRequest.Get(url)) {
www.SendWebRequest();
while (!www.isDone && !cancellationToken.IsCancellationRequested)
{
yield return(null);
}
if (cancellationToken.IsCancellationRequested)
{
yield break;
}
if (www.isNetworkError || www.isHttpError)
{
observer.OnError(new Exception(www.error));
}
else
{
if (www.responseCode == 200)
{
observer.OnNext(JsonHelper.FromJsonArray <T>(www.downloadHandler.text));
observer.OnCompleted();
}
else
{
observer.OnNext(default(T[]));
observer.OnCompleted();
}
}
}
break;
default:
break;
}
}
/// <summary>
/// The core method which run the async connection process.
/// </summary>
/// <param name="observer"> The return value of InitAsObservable() method </param>
/// <param name="cancelToken"> The cancel token object which signals to stop the currnet coroutine </param>
/// <returns></returns>
IEnumerator InitCore(UniRx.IObserver <Socket> observer, UniRx.CancellationToken cancelToken)
{
// Declare to connect in socket.io v1.0
_urlQueries.Add("EIO", "3");
_urlQueries.Add("transport", "polling");
_urlQueries.Add("t", TimeStamp.Now);
// Try get WebSocketTrigger instance if a connection already established _baseUrl.
var webSocketTrigger = SocketManager.Instance.GetWebSocketTrigger(BaseUrl);
if (webSocketTrigger == null || !webSocketTrigger.IsConnected)
{
var www = new WWW(PollingUrl);
while (!www.isDone && !cancelToken.IsCancellationRequested)
{
yield return(null);
}
if (cancelToken.IsCancellationRequested)
{
yield break;
}
if (!string.IsNullOrEmpty(www.error))
{
observer.OnError(new Exception(www.error));
yield break;
}
var textIndex = www.text.IndexOf('{');
var textEndIndex = www.text.IndexOf('}');
var json = www.text.Substring(textIndex, textEndIndex - (textIndex - 1));
Debug.LogFormat("json: {0}", json);
if (!string.IsNullOrEmpty(json))
{
var answer = JsonConvert.DeserializeObject <PollingUrlAnswer>(json);
//var answer = JsonUtility.FromJson<PollingUrlAnswer>(json);
Debug.LogFormat("{0}", answer);
_urlQueries.Add("sid", answer.sid);
}
if (webSocketTrigger == null)
{
webSocketTrigger = new GameObject(string.Format("WebSocket - {0}", BaseUrl)).AddComponent <WebSocketTrigger>();
SocketManager.Instance.RegisterWebSocketTrigger(BaseUrl, webSocketTrigger);
}
}
_urlQueries["transport"] = "websocket";
_urlQueries.Remove("t");
webSocketTrigger.WebSocket = new WebSocketWrapper(new Uri(WebSocketUrl));
Socket.transform.parent = webSocketTrigger.transform;
webSocketTrigger.WebSocket.Connect();
yield return(new WaitUntil(() => webSocketTrigger.IsConnected));
if (cancelToken.IsCancellationRequested)
{
webSocketTrigger.WebSocket.Close();
yield break;
}
webSocketTrigger.WebSocket.Send(Packet.Probe);
yield return(new WaitUntil(() => webSocketTrigger.IsProbed));
if (cancelToken.IsCancellationRequested)
{
webSocketTrigger.WebSocket.Close();
yield break;
}
webSocketTrigger.WebSocket.Send(new Packet(EnginePacketTypes.UPGRADE).Encode());
webSocketTrigger.IsUpgraded = true;
// Try to activate Socket.io namespace
if (Socket.HasNamespace)
{
webSocketTrigger.WebSocket.Send(new Packet(EnginePacketTypes.MESSAGE, SocketPacketTypes.CONNECT, Socket.Namespace, string.Empty).Encode());
}
var capturedSocket = Socket;
// Start to receive a incoming WebSocket packet
webSocketTrigger.OnRecvAsObservable()
.Subscribe(r => { capturedSocket.OnRecvWebSocketPacket(r); })
.AddTo(Socket);
observer.OnNext(Socket);
yield return(new WaitForSeconds(1f));
observer.OnCompleted();
}
