private static void GetRequestStreamCallback <T>(IAsyncResult asynchronousResult)
{
RequestState <T> requestState = (RequestState <T>)asynchronousResult.AsyncState;
try
{
HttpWebRequest request = requestState.Request;
string requestJsonString = requestState.RequestJsonString;
// Request Data
using (Stream requestStream = request.EndGetRequestStream(asynchronousResult))
{
using (StreamWriter requestWriter = new StreamWriter(requestStream, System.Text.Encoding.UTF8))
requestWriter.Write(requestJsonString);
}
request.BeginGetResponse(new AsyncCallback(GetResponseCallback <T>), requestState);
}
catch (System.Exception ex)
{
BackendlessFault backendlessFault = new BackendlessFault(ex.Message);
if (requestState.Callback != null)
{
requestState.Callback.ErrorHandler.Invoke(backendlessFault);
}
}
}
public static void InvokeAsync <T>(Api api, object[] args, AsyncCallback <T> callback)
{
Method method = Method.UNKNOWN;
string url = null;
Dictionary <string, string> headers = null;
object data = null;
if (args != null && args.Length > 0)
{
data = args[0];
}
try
{
GetRestApiRequestCommand(api, args, out method, out url, out headers);
InvokeAsync <T>(api, method, url, headers, data, callback);
}
catch (BackendlessException ex)
{
BackendlessFault backendlessFault = new BackendlessFault(ex);
if (callback != null)
{
callback.ErrorHandler.Invoke(backendlessFault);
}
else
{
throw new BackendlessException(backendlessFault);
}
}
}
public void Logout()
{
try
{
Invoker.InvokeSync <object>(USER_MANAGER_SERVER_ALIAS, "logout",
new object[] { });
}
catch (BackendlessException exception)
{
BackendlessFault fault = exception.BackendlessFault;
if (fault != null)
{
int faultCode = int.Parse(fault.FaultCode);
if (faultCode != 3064 && faultCode != 3091 && faultCode != 3090 && faultCode != 3023)
{
throw exception;
}
}
}
CurrentUser = null;
HeadersManager.GetInstance().RemoveHeader(HeadersEnum.USER_TOKEN_KEY);
LoginStorage.DeleteFiles();
}
public void UnlatchWith(BackendlessFault backendlessFault)
{
testFault = backendlessFault;
for (int i = 0; i < testLatch.CurrentCount; i++)
{
testLatch.Signal();
}
}
public static void InvokeAsync <T>(Api api, Method method, string url, Dictionary <string, string> headers, object data, AsyncCallback <T> callback)
{
RequestState <T> requestState = new RequestState <T>();
try
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
// Set method
request.Method = method.ToString();
// Set Headers
foreach (KeyValuePair <string, string> header in headers)
{
request.Headers.Add(header.Key, header.Value);
}
requestState.Request = request;
requestState.Callback = callback;
requestState.Api = api;
if (method == Method.GET || data == null)
{
request.BeginGetResponse(new AsyncCallback(GetResponseCallback <T>), requestState);
}
else
{
// Convert Data to Json
string requestJsonString = JsonMapper.ToJson(data);
// Set ContentType, ContentLength
request.ContentType = "application/json";
//request.ContentLength = requestJsonString.Length;
requestState.RequestJsonString = requestJsonString;
request.BeginGetRequestStream(new System.AsyncCallback(GetRequestStreamCallback <T>), requestState);
}
}
catch (System.Exception ex)
{
BackendlessFault backendlessFault = new BackendlessFault(ex);
if (requestState.Callback != null)
{
requestState.Callback.ErrorHandler.Invoke(backendlessFault);
}
else
{
throw new BackendlessException(backendlessFault);
}
}
}
private static void ResponseCallback(IAsyncResult asyncResult)
{
var asyncState = (RequestStreamAsyncState <BackendlessFile>)asyncResult.AsyncState;
using (asyncState.Stream)
{
try
{
using (var response = asyncState.HttpRequest.EndGetResponse(asyncResult).GetResponseStream())
{
var encode = System.Text.Encoding.GetEncoding("utf-8");
var result = new StreamReader(response, encode).ReadToEnd();
string fileUrl = "";
try
{
JsonData successResponse = JsonMapper.ToObject(result);
fileUrl = (string)successResponse["fileURL"];
}
catch (System.Exception)
{
}
asyncState.Callback.ResponseHandler.Invoke(new BackendlessFile(fileUrl));
}
}
catch (WebException ex)
{
var response = new StreamReader(ex.Response.GetResponseStream()).ReadToEnd();
BackendlessFault fault = null;
try
{
JsonData errorResponse = JsonMapper.ToObject(response);
int code = (int)errorResponse["code"];
string message = (string)errorResponse["message"];
fault = new BackendlessFault(code.ToString(), message, null);
}
catch (System.Exception)
{
fault = new BackendlessFault(ex);
}
if (asyncState.Callback != null)
{
asyncState.Callback.ErrorHandler.Invoke(fault);
}
else
{
throw new BackendlessException(fault);
}
}
}
}
public static void InvokeAsync <T>(string className, string methodName, object[] args, bool enableUnderFlowInspection, AsyncCallback <T> callback)
{
var responder = new Responder <T>(response =>
{
if (callback != null)
{
callback.ResponseHandler.Invoke(response);
}
}, fault =>
{
var backendlessFault = new BackendlessFault(fault);
if (callback != null)
{
callback.ErrorHandler.Invoke(backendlessFault);
}
else
{
throw new BackendlessException(backendlessFault);
}
});
try
{
ResponseThreadConfigurator responseConfig = null;
if (enableUnderFlowInspection)
{
responseConfig = new ResponseThreadConfigurator(SetupUnderFlowListener);
}
client.Invoke <T>(className, methodName, args, null, HeadersManager.GetInstance().Headers, responder, responseConfig);
}
catch (System.Exception ex)
{
var backendlessFault = new BackendlessFault(ex.Message);
if (callback != null)
{
callback.ErrorHandler.Invoke(backendlessFault);
}
throw new BackendlessException(backendlessFault);
}
}
public static T InvokeSync <T>(string className, string methodName, object[] args, bool enableUnderFlowInspection)
{
T result = default(T);
BackendlessFault backendlessFault = null;
AutoResetEvent waiter = new AutoResetEvent(false);
var responder = new Responder <T>(r =>
{
result = r;
waiter.Set();
}, f =>
{
backendlessFault = new BackendlessFault(f);
waiter.Set();
});
try
{
ResponseThreadConfigurator responseConfig = null;
if (enableUnderFlowInspection)
{
responseConfig = new ResponseThreadConfigurator(SetupUnderFlowListener);
}
client.Invoke <T>(className, methodName, args, null, HeadersManager.GetInstance().Headers, responder, responseConfig);
waiter.WaitOne(System.Threading.Timeout.Infinite);
}
catch (System.Exception ex)
{
throw new BackendlessException(ex.Message);
}
if (backendlessFault != null)
{
throw new BackendlessException(backendlessFault);
}
return(result);
}
private static void ResponseCallback(IAsyncResult asyncResult)
{
var asyncState = (RequestStreamAsyncState <BackendlessFile>)asyncResult.AsyncState;
using (asyncState.FileStream)
{
try
{
using (var response = asyncState.HttpRequest.EndGetResponse(asyncResult).GetResponseStream())
{
var encode = Encoding.GetEncoding("utf-8");
var result = new StreamReader(response, encode).ReadToEnd();
var matchGroups = SERVER_RESULT_REGEXP.Match(result).Groups;
var fileUrl = matchGroups["fileUrl"].Value;
asyncState.Callback.ResponseHandler.Invoke(new BackendlessFile(fileUrl));
}
}
catch (WebException ex)
{
var response = new StreamReader(ex.Response.GetResponseStream()).ReadToEnd();
var matchGroups = SERVER_ERROR_REGEXP.Match(response).Groups;
var message = matchGroups["message"].Value;
var code = matchGroups["code"].Value;
var fault =
new BackendlessFault((string.IsNullOrEmpty(code) ? "" : "Code: " + code + "\n") + "Message: " +
message);
if (asyncState.Callback != null)
{
asyncState.Callback.ErrorHandler.Invoke(fault);
}
else
{
throw new BackendlessException(fault);
}
}
}
}
private IRTRequest HandleResult <T>(Object[] args, IDictionary <String, T> requestMap, String resultKey) where T : IRTRequest
{
if (args == null || args.Length < 1)
{
Log.log(Backendless.BACKENDLESSLOG, "subscription result is null or empty");
return(null);
}
AnonymousObject result = (AnonymousObject)WeborbSerializationHelper.Deserialize((byte[])args[0]);
String id = WeborbSerializationHelper.AsString(result, "id");
Log.log(Backendless.BACKENDLESSLOG, String.Format("Got result for subscription {0}", id));
IRTRequest request = requestMap[id];
if (request == null)
{
Log.log(Backendless.BACKENDLESSLOG, String.Format("There is no handler for subscription {0}", id));
return(null);
}
Object error = WeborbSerializationHelper.AsObject(result, "error");
if (error != null)
{
Log.log(Backendless.BACKENDLESSLOG, String.Format("got error {0}", error));
BackendlessFault fault = new BackendlessFault(error.ToString());
request.Callback.errorHandler(fault);
return(request);
}
IAdaptingType data = WeborbSerializationHelper.AsAdaptingType(result, resultKey);
request.Callback.responseHandler(data);
return(request);
}
public void Logout()
{
try
{
Invoker.InvokeSync <object>(Invoker.Api.USERSERVICE_LOGOUT, null);
}
catch (BackendlessException exception)
{
BackendlessFault fault = exception.BackendlessFault;
if (fault != null)
{
int faultCode = int.Parse(fault.FaultCode);
if (faultCode != 3064 && faultCode != 3091 && faultCode != 3090 && faultCode != 3023)
{
throw exception;
}
}
}
CurrentUser = null;
HeadersManager.GetInstance().RemoveHeader(HeadersEnum.USER_TOKEN_KEY);
}
private async Task <BackendlessFile> RequestStreamCallbackAsync(Stream postStream,
FileStream fileStream,
WebRequest httpRequest,
UploadCallback uploadCallback,
byte[] headerBytes,
byte[] boundaryBytes)
{
long fileLength = fileStream.Length;
long offset = 0;
int bufferLen = (int)(fileLength < UPLOAD_BUFFER_DEFAULT_LENGTH ? fileLength : UPLOAD_BUFFER_DEFAULT_LENGTH);
byte[] buffer = new byte[bufferLen];
// send the headers
postStream.Write(headerBytes, 0, headerBytes.Length);
int progress = 0;
int size = fileStream.Read(buffer, 0, bufferLen);
while (size > 0)
{
postStream.Write(buffer, 0, size);
offset += size;
if (!(uploadCallback is EmptyUploadCallback))
{
int currentProgress = (int)((offset / fileLength) * 100);
if (progress != currentProgress)
{
progress = currentProgress;
uploadCallback.ProgressHandler.Invoke(progress);
}
}
size = fileStream.Read(buffer, 0, bufferLen);
}
if (!(uploadCallback is EmptyUploadCallback) && progress != 100)
{
uploadCallback.ProgressHandler.Invoke(100);
}
postStream.Write(boundaryBytes, 0, boundaryBytes.Length);
WebResponse webResponse = await httpRequest.GetResponseAsync();
using ( fileStream )
{
try
{
var encode = Encoding.GetEncoding("utf-8");
var result = new StreamReader(webResponse.GetResponseStream(), encode).ReadToEnd();
var matchGroups = SERVER_RESULT_REGEXP.Match(result).Groups;
var fileUrl = matchGroups["fileUrl"].Value;
return(new BackendlessFile(fileUrl));
}
catch (WebException ex)
{
var response = new StreamReader(ex.Response.GetResponseStream()).ReadToEnd();
var matchGroups = SERVER_ERROR_REGEXP.Match(response).Groups;
var message = matchGroups["message"].Value;
var code = matchGroups["code"].Value;
var fault =
new BackendlessFault((string.IsNullOrEmpty(code) ? "" : "Code: " + code + "\n") + "Message: " +
message);
throw new BackendlessException(fault);
}
}
}
public override void CheckErrorCode(string expectedCode, BackendlessFault resultFault)
{
СheckStringExpectation(expectedCode, resultFault.Message);
CountDown();
}
public override void CheckErrorCode(int expectedCode, BackendlessFault resultFault)
{
base.CheckErrorCode(expectedCode, resultFault);
CountDown();
}
public void FailCountDownWith(BackendlessFault backendlessFault)
{
testFault = backendlessFault;
testLatch.Signal();
}
public static void InvokeAsync <T>(Api api, Method method, string url, Dictionary <string, string> headers, object data, AsyncCallback <T> callback)
{
ThreadPool.QueueUserWorkItem(new WaitCallback(delegate(object t)
{
SocketResponse response = null;
try
{
Uri uri = new Uri(url);
int maximumRetryCount = 5;
int retry = 0;
while (++retry < maximumRetryCount)
{
TcpClient client = new TcpClient();
client.Connect(uri.Host, uri.Port);
using (NetworkStream stream = client.GetStream())
{
Stream ostream = stream as Stream;
if (uri.Scheme.ToLower() == "https")
{
ostream = new SslStream(stream, false, new RemoteCertificateValidationCallback(ValidateServerCertificate));
try
{
SslStream ssl = ostream as SslStream;
ssl.AuthenticateAsClient(uri.Host);
}
catch (System.Exception e)
{
BackendlessFault backendlessFault = new BackendlessFault(e);
if (callback != null)
{
callback.ErrorHandler.Invoke(backendlessFault);
}
}
}
WriteToStream(method, uri, headers, data, ostream);
response = new SocketResponse();
response.ReadFromStream(ostream);
}
client.Close();
switch (response.status)
{
case 307:
case 302:
case 301:
uri = new Uri(response.GetHeader("Location"));
continue;
default:
retry = maximumRetryCount;
break;
}
}
}
catch (System.Exception ex)
{
BackendlessFault backendlessFault = new BackendlessFault(ex);
if (callback != null)
{
callback.ErrorHandler.Invoke(backendlessFault);
}
}
if (response.status == 200)
{
T result = default(T);
string responseJsonString = response.response;
if ((api >= Api.COUNTERSERVICE_GET && api <= Api.COUNTERSERVICE_COM_SET) || api == Api.CACHESERVICE_CONTAINS)
{
result = (T)Convert.ChangeType(responseJsonString, typeof(T));
}
else
{
if (string.IsNullOrEmpty(responseJsonString) == false)
{
result = JsonMapper.ToObject <T>(responseJsonString);
}
}
if (callback != null)
{
callback.ResponseHandler.Invoke(result);
}
}
else
{
BackendlessFault fault = null;
try
{
JsonData errorResponse = JsonMapper.ToObject(response.response);
int code = (int)errorResponse["code"];
string message = (string)errorResponse["message"];
fault = new BackendlessFault(code.ToString(), message, null);
}
catch (System.Exception ex)
{
fault = new BackendlessFault(ex);
}
if (callback != null)
{
callback.ErrorHandler.Invoke(fault);
}
}
}));
}
public void FailCountDownWith(string message)
{
testFault = new BackendlessFault(message);
testLatch.Signal();
}
public void FailCountDownWith(System.Exception e)
{
testFault = new BackendlessFault(e.Message);
testLatch.Signal();
}
private void errorHandler(BackendlessFault fault)
{
Toast.MakeText(this, "error registering", ToastLength.Short);
}
public void SetLatch(int count)
{
testLatch = new CountdownEvent(count);
testFault = null;
}
public static T InvokeSync <T>(Api api, Method method, string url, Dictionary <string, string> headers, object data)
{
try
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
// Set method
request.Method = method.ToString();
// Set Headers
foreach (KeyValuePair <string, string> header in headers)
{
request.Headers.Add(header.Key, header.Value);
}
// Convert Data to Json
if (method == Method.GET || data == null)
{
}
else
{
string requestJsonString = JsonMapper.ToJson(data);
// Set ContentType, ContentLength
request.ContentType = "application/json";
//request.ContentLength = requestJsonString.Length;
// Request Data
using (Stream requestStream = request.GetRequestStream())
{
using (StreamWriter requestWriter = new StreamWriter(requestStream, System.Text.Encoding.UTF8))
requestWriter.Write(requestJsonString);
}
}
// Response Data
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
using (Stream responseStream = response.GetResponseStream())
{
using (StreamReader responseReader = new StreamReader(responseStream, System.Text.Encoding.UTF8))
{
T result = default(T);
string responseJsonString = responseReader.ReadToEnd();
if ((api >= Api.COUNTERSERVICE_GET && api <= Api.COUNTERSERVICE_COM_SET) || api == Api.CACHESERVICE_CONTAINS)
{
result = (T)Convert.ChangeType(responseJsonString, typeof(T));
}
else
{
if (string.IsNullOrEmpty(responseJsonString) == false)
{
result = JsonMapper.ToObject <T>(responseJsonString);
}
}
return(result);
}
}
}
catch (WebException ex)
{
using (Stream responseStream = ex.Response.GetResponseStream())
{
using (StreamReader responseReader = new StreamReader(responseStream, System.Text.Encoding.UTF8))
{
string responseJsonString = responseReader.ReadToEnd();
BackendlessFault fault = null;
try
{
JsonData errorResponse = JsonMapper.ToObject(responseJsonString);
int code = (int)errorResponse["code"];
string message = (string)errorResponse["message"];
fault = new BackendlessFault(code.ToString(), message, null);
}
catch (System.Exception)
{
fault = new BackendlessFault(ex);
}
throw new BackendlessException(fault);
}
}
}
catch (System.Exception ex)
{
BackendlessFault backendlessFault = new BackendlessFault(ex);
throw new BackendlessException(backendlessFault);
}
}
private void errorHandler(BackendlessFault fault)
{
System.Diagnostics.Debug.WriteLine("error sending token to backendless");
}
public virtual void CheckErrorCode(string expectedCode, BackendlessFault resultFault)
{
СheckStringExpectation(expectedCode, resultFault.FaultCode);
}
public virtual void CheckErrorCode(int expectedCode, BackendlessFault resultFault)
{
CheckCodeExpectation(expectedCode, resultFault.FaultCode, resultFault.Message);
}
private void HandleFault(BackendlessFault fault)
{
Dispatcher.BeginInvoke(() => MessageBox.Show(fault.Message));
}
public static void FailCountDownWith(BackendlessFault fault)
{
SetTestResult(fault.ToString());
CountDownAll();
}
private static void GetResponseCallback <T>(IAsyncResult asynchronousResult)
{
RequestState <T> requestState = (RequestState <T>)asynchronousResult.AsyncState;
T result = default(T);
try
{
HttpWebRequest request = requestState.Request;
HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(asynchronousResult);
using (Stream responseStream = response.GetResponseStream())
{
using (StreamReader responseReader = new StreamReader(responseStream, System.Text.Encoding.UTF8))
{
string responseJsonString = responseReader.ReadToEnd();
if ((requestState.Api >= Api.COUNTERSERVICE_GET && requestState.Api <= Api.COUNTERSERVICE_COM_SET) || requestState.Api == Api.CACHESERVICE_CONTAINS)
{
result = (T)Convert.ChangeType(responseJsonString, typeof(T));
}
else
{
if (string.IsNullOrEmpty(responseJsonString) == false)
{
result = JsonMapper.ToObject <T>(responseJsonString);
}
}
}
}
response.Close();
if (requestState.Callback != null)
{
requestState.Callback.ResponseHandler.Invoke(result);
}
}
catch (WebException ex)
{
using (Stream responseStream = ex.Response.GetResponseStream())
{
using (StreamReader responseReader = new StreamReader(responseStream, System.Text.Encoding.UTF8))
{
string responseJsonString = responseReader.ReadToEnd();
BackendlessFault fault = null;
try
{
JsonData errorResponse = JsonMapper.ToObject(responseJsonString);
int code = (int)errorResponse["code"];
string message = (string)errorResponse["message"];
fault = new BackendlessFault(code.ToString(), message, null);
}
catch (System.Exception)
{
fault = new BackendlessFault(ex);
}
if (requestState.Callback != null)
{
requestState.Callback.ErrorHandler.Invoke(fault);
}
}
}
}
catch (System.Exception ex)
{
BackendlessFault backendlessFault = new BackendlessFault(ex);
if (requestState.Callback != null)
{
requestState.Callback.ErrorHandler.Invoke(backendlessFault);
}
}
}
