public Job(Socket socket, IOCallback ioCallback)
{
this.socket = socket;
this.buffer = new MemoryStreamBuffer();
this.ioCallback = ioCallback;
}
public TunnelWriter(TunnelPipeline tunnelPipeline, byte[] headerBuffer, IPacket packet, IOCallback <TState> callback, TState state)
{
this.tunnelPipeline = tunnelPipeline;
this.packet = packet;
this.callback = callback;
this.state = state;
this.headerBuffer = headerBuffer;
}
public void AddCallback(IOCallback callback)
{
EffekseerNativePINVOKE.IO_AddCallback(swigCPtr, IOCallback.getCPtr(callback));
if (EffekseerNativePINVOKE.SWIGPendingException.Pending)
{
throw EffekseerNativePINVOKE.SWIGPendingException.Retrieve();
}
}
internal void Construct <TState>(IOCallback <TState> callback, TState state)
{
if (dataProvider == null)
{
dataProvider = new HttpDataProvider(source);
}
dataProvider.ReadLine(ParseProtocol <TState>, new object[] { callback, state });
}
public void Output <TState>(IPacket packet, IOCallback <TState> callback, TState state = default(TState))
{
if (packet.Disposed)
{
throw new InvalidOperationException("packet is disposed.");
}
new TunnelWriter <TState>(this, header, packet, callback, state).Execute();
}
void WriteTunnelPacket <TWriteState>(TunnelPacket packet, IOCallback <TWriteState> callback, TWriteState state)
{
var pipeline = tunnelPipeline.TransPipeline;
pipeline.Output(
(BufferPacket)packet.HeaderData,
CompleteHeaderWrite <TWriteState>,
new object[] { packet, callback, state }
);
}
void IPipeline.Input <TState>(IOCallback <TState> callback, TState state)
{
if (!input.Disposed)
{
throw new InvalidOperationException("Current packet is not disposed.");
}
try
{
GetStream().BeginRead(packetBuffer, 0, packetBuffer.Length, CompleteInput <TState>, new object[] { callback, state });
}
catch (IOException) { Interrupte(); }
catch (ObjectDisposedException) { Interrupte(); }
}
public void Input <TState>(IOCallback <TState> callback, TState state = default(TState))
{
if (!packet.Disposed)
{
throw new InvalidOperationException("Current packet is NOT disposed.");
}
try
{
Stream.BeginRead(packet.Buffer, 0, packet.Buffer.Length, OnInput <TState>, new object[] { callback, state });
}
catch (IOException) { Interrupte(); }
catch (ObjectDisposedException) { }
}
void ContinueConstruct <TState>(IOCallback <TState> callback, TState state)
{
for (; headerSize < HeaderSize && sourceOffset < sourceSize; headerSize++)
{
header[headerSize] = source[sourceOffset++];
}
if (headerSize < HeaderSize) // 信息头未解析完成
{
ReadMoreData <TState>(new object[] { callback, state });
return;
}
HeaderSerializer.Deserialize(header, this);
// 检查报文有效性
if (Magic != MagicValue || Version != VersionValue)
{
trans.Interrupte();
return;
}
length = Length;
callback(Source, this, state);
}
void IPipeline.Output <TState>(IPacket packet, IOCallback <TState> callback, TState state)
{
if (packet.Disposed)
{
throw new InvalidOperationException("Packet is disposed.");
}
var args = new object[] { callback, packet, state, 0 };
if (Interlocked.Exchange(ref outputting, 1) == 1)
{
lock (queueLocker)
{
if (outputQueue == null)
{
outputQueue = new Queue <object[]>(1);
}
outputQueue.Enqueue(args);
}
return;
}
packet.Read(WritePacketData <TState>, args);
}
/// <summary>
/// 创建包
/// </summary>
/// <typeparam name="TState"></typeparam>
/// <param name="callback"></param>
/// <param name="state"></param>
public void Construct <TState>(IOCallback <TState> callback, TState state)
{
headerSize = 0;
ContinueConstruct(callback, state);
}
//private int maxSocketCountPerWorker = 200;
//private int maxWorkerCount = 100;
public Listener(Socket socket, IOCallback ioCallback)
{
this.socket = socket;
this.ioCallback = ioCallback;
}
public void AddCallback(IOCallback callback)
{
callbacks.Add (callback);
}
public void RemoveCallback(IOCallback callback)
{
callbacks.Remove (callback);
}
/// <summary>
/// Sends a message with optional POST content to the server.
/// </summary>
/// <param name="anUrl">URL to send data to.</param>
/// <param name="aPostContent">POST content or null if there is none.</param>
/// <param name="aCallback">Callback that will be invoked once sending has finished.</param>
private IEnumerator DoSend(string anUrl, string aPostContent, IOCallback aCallback)
{
// debug
#if DEBUG || UNITY_EDITOR
IQUSDK.Instance.AddLog("[Network][Sending] " + anUrl);
if (aPostContent != null) {
IQUSDK.Instance.AddLog("[Network][Content] " + aPostContent);
}
#endif
switch (IQUSDK.Instance.TestMode)
{
case IQUTestMode.SimulateOffline:
// wait for 2 seconds
yield return new WaitForSeconds(2);
this.SimulateOffline(aCallback);
return false;
case IQUTestMode.SimulateServer:
// wait for 2 seconds
yield return new WaitForSeconds(2);
this.SimulateServer(aCallback);
return false;
}
// set custom headers
#if UNITY_2 || UNITY_3 || UNITY_4_0 || UNITY_4_1 || UNITY_4_2 || UNITY_4_3 || UNITY_4_4
Hashtable postHeaders = new Hashtable(10);
#else
Dictionary<string, string> postHeaders = new Dictionary<string, string>(30);
#endif
postHeaders.Add("Content-Type", "application/json");
postHeaders.Add("SdkType", IQUSDK.SdkType);
postHeaders.Add("SdkVersion", IQUSDK.SdkVersion);
// encoding is used to get the JSON string in correct byte array
UTF8Encoding encoding = new UTF8Encoding();
// send request
WWW request = new WWW(anUrl, aPostContent == null ? null : encoding.GetBytes(aPostContent), postHeaders);
yield return request;
// check if server returned content
bool hasContent = String.IsNullOrEmpty(request.error) && !String.IsNullOrEmpty(request.text);
// debug
#if DEBUG || UNITY_EDITOR
IQUSDK.Instance.AddLog("[Network][Response] " + anUrl);
if (!String.IsNullOrEmpty(request.error))
{
IQUSDK.Instance.AddLog("[Network][Response][Error] " + request.error);
}
IQUSDK.Instance.AddLog("[Network][Response][Headers] " + this.GetHeaders(request));
if (hasContent)
{
string text = request.text.Replace("\n", "");
IQUSDK.Instance.AddLog("[Network][Response][Content] " + text);
}
#endif
// server returned content? Y: assume it is JSON and de-serialize it; N: create empty result
Dictionary<string,object> result = hasContent ? MiniJSON.Json.Deserialize(request.text) as Dictionary<string, object> : new Dictionary<string, object>(2);
// error parsing json?
if (result == null)
{
// yes, set error
result = new Dictionary<string, object>(2);
result.Add(IQUNetwork.Error, "error parsing JSON result data.");
}
else
{
// try to determine code
int code = this.GetResponseCode(request);
// sometimes server returns 100, even though all content has been received; replace with 200
if (code == 100)
{
code = 200;
}
// add code and error (if any)
if (code >= 0)
{
// add code
result.Add(IQUNetwork.Code, code);
// debug
IQUSDK.Instance.AddLog("[Network][Response][Code] " + code.ToString());
}
if (!String.IsNullOrEmpty(request.error))
{
result.Add(IQUNetwork.Error, request.error);
}
else if (((code < 200) || (code > 299)) && (code >= 0))
{
result.Add(IQUNetwork.Error, "http status code " + code.ToString() + " indicates invalid action");
}
}
aCallback(result);
}
public void RunCallback(IOCallback callback)
{
try {
callback ();
} catch (Exception e) {
HandleCallbackException (e);
}
}
/// <summary>
/// Invokes an url using GET.
/// </summary>
/// <param name="anUrl">An URL to invoke.</param>
/// <param name="aCallback">Callback that will be invoked once sending has finished.</param>
private void Send(string anUrl, IOCallback aCallback)
{
this.Send(anUrl, null, aCallback);
}
public void Input <TState>(IOCallback <TState> callback, TState state = default(TState))
{
inputPacket.Construct(callback, state);
}
/// <summary>
/// Sends data to an url.
/// </summary>
/// <param name="anUrl">An URL.</param>
/// <param name="aPostContent">A post content or null if there is no post content.</param>
/// <param name="aCallback">Callback that will be invoked once sending has finished.</param>
private void Send(string anUrl, string aPostContent, IOCallback aCallback)
{
IQUSDK.Instance.Helper.StartCoroutine(this.DoSend(anUrl, aPostContent, aCallback));
}
/// <summary>
///
/// </summary>
/// <typeparam name="TState"></typeparam>
/// <param name="packet"></param>
/// <param name="callback"></param>
/// <param name="state"></param>
public void Output <TState>(IPacket packet, IOCallback <TState> callback, TState state = default(TState))
{
packet.Read(OnRead <TState>, new object[] { packet, callback, state, 0 });
}
void IPipeline.Output <TState>(IPacket packet, IOCallback <TState> callback, TState state)
{
throw new NotImplementedException();
}
/// <summary>
/// Sends a signed message to the server.
/// </summary>
/// <param name="anUrl">URL without parameters</param>
/// <param name="aPostContent">Content that will be posted to the server.</param>
/// <param name="aCallback">Callback that will be invoked once sending has finished.</param>
private void SendSigned(string anUrl, string aPostContent, IOCallback aCallback)
{
string signature = this.GenerateHMACSHA512(this.m_secretKey, aPostContent);
this.Send(anUrl + "?api_key=" + this.m_apiKey + "&signature=" + signature, aPostContent, aCallback);
}
/// <summary>
/// Simulates an off-line state. The method invokes the callback with an error result.
/// </summary>
/// <param name="aCallback">Callback that will be invoked once sending has finished.</param>
private void SimulateOffline(IOCallback aCallback)
{
// debug
IQUSDK.Instance.AddLog("[Network] simulating off-line.");
// build result for off-line
Dictionary<string, object> result = new Dictionary<string, object>(1);
result.Add(IQUNetwork.Error, "simulating off-line, IQUSDK.Instance.TestMode == IQUTestMode.SimulateOffline");
aCallback(result);
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(IOCallback obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
/// <summary>
/// Simulates a correct response without any actual server communication. The method invokes the callback with a successful result.
/// </summary>
/// <param name="aCallback">Callback that will be invoked once sending has finished.</param>
private void SimulateServer(IOCallback aCallback)
{
// debug
IQUSDK.Instance.AddLog("[Network] simulating server response.");
// simulate on-line and successful attempt
Dictionary<string, object> result = new Dictionary<string, object>(4);
result.Add(IQUNetwork.Code, 200);
result.Add("status", "ok");
result.Add("request_id", "2a7-558bf465ed65-b79a84");
result.Add("time", "2015-06-26 12:00:00 UTC");
aCallback(result);
}
public static void SetIOCallback(IOCallback callback)
{
Callback = callback;
}
void IPipeline.Input <TState>(IOCallback <TState> callback, TState state)
{
request.Construct(callback, state);
}
