public static unsafe NSData SendSynchronousRequest(NSUrlRequest request, out NSUrlResponse response, out NSError error)
{
IntPtr responseStorage = IntPtr.Zero;
IntPtr errorStorage = IntPtr.Zero;
void *resp = &responseStorage;
void *errp = &errorStorage;
IntPtr rhandle = (IntPtr) resp;
IntPtr ehandle = (IntPtr) errp;
var res = Messaging.IntPtr_objc_msgSend_IntPtr_IntPtr_IntPtr (
class_ptr,
selSendSynchronousRequestReturningResponseError.Handle,
request.Handle,
rhandle,
ehandle);
if (responseStorage != IntPtr.Zero)
response = (NSUrlResponse) Runtime.GetNSObject (responseStorage);
else
response = null;
if (errorStorage != IntPtr.Zero)
error = (NSError) Runtime.GetNSObject (errorStorage);
else
error = null;
return (NSData) Runtime.GetNSObject (res);
}
public override NSCachedUrlResponse CachedResponseForRequest (NSUrlRequest request)
{
var uri = (Uri) request.Url;
int index;
if ((index = related.IndexOf (uri)) != -1) {
var part = related[index] as MimePart;
if (part != null) {
var mimeType = part.ContentType.MimeType;
var charset = part.ContentType.Charset;
NSUrlResponse response;
NSData data;
using (var content = part.ContentObject.Open ())
data = NSData.FromStream (content);
response = new NSUrlResponse (request.Url, mimeType, (int) data.Length, charset);
return new NSCachedUrlResponse (response, data);
}
}
return base.CachedResponseForRequest (request);
}
public override void ReceivedResponse(NSUrlConnection connection, NSUrlResponse response)
{
try
{
responseMessage.RequestMessage.RequestUri = new Uri(response.Url.ToString()); //At least attempt to get the url right if we redirected
var httpResponse = response as NSHttpUrlResponse;
if (httpResponse != null)
{
stream = new ByteArrayListStream();
content = new CancellableStreamContent(stream, () =>
{
isComplete = true;
stream.SetException(new OperationCanceledException());
});
responseMessage.StatusCode = (HttpStatusCode)httpResponse.StatusCode;
responseMessage.Content = content;
foreach (var header in httpResponse.AllHeaderFields)
{
if (header.Key != null && header.Value != null)
{
responseMessage.Headers.TryAddWithoutValidation(header.Key.ToString(), header.Value.ToString());
responseMessage.Content.Headers.TryAddWithoutValidation(header.Key.ToString(), header.Value.ToString());
}
}
}
}
finally
{
waitEvent.Set();
}
}
public override void ReceivedResponse(NSUrlConnection connection, NSUrlResponse response)
{
var httpResponse = response as NSHttpUrlResponse;
Resp = httpResponse;
if (httpResponse == null)
{
_statusCode = -1;
return;
}
_statusCode = httpResponse.StatusCode;
}
public override void StartLoading ()
{
var value = Request.Url.Path.Substring (1);
using (var image = Render (value)) {
using (var response = new NSUrlResponse (Request.Url, "image/jpeg", -1, null)) {
using (var data = image.AsJPEG ()) {
Client.ReceivedResponse (this, response, NSUrlCacheStoragePolicy.NotAllowed);
Client.DataLoaded (this, data);
Client.FinishedLoading (this);
}
}
}
}
public override void StartLoading()
{
var value = Request.Url.Path.Substring(1);
using (var image = Render(value)) {
using (var response = new NSUrlResponse(Request.Url, "image/jpeg", -1, null)) {
using (var data = image.AsJPEG()) {
Client.ReceivedResponse(this, response, NSUrlCacheStoragePolicy.NotAllowed);
Client.DataLoaded(this, data);
Client.FinishedLoading(this);
}
}
}
}
public override void ReceivedResponse(NSUrlConnection connection, NSUrlResponse response)
{
var http_response = response as NSHttpUrlResponse;
if (http_response == null)
{
Console.WriteLine("Received non HTTP url response: '{0}'", response);
status_code = -1;
return;
}
status_code = http_response.StatusCode;
Console.WriteLine("Status code of result: '{0}'", status_code);
}
public void StartUrlSchemeTask(WKWebView webView, IWKUrlSchemeTask urlSchemeTask)
{
var responseBytes = GetResponseBytes(urlSchemeTask.Request.Url.AbsoluteString, out var contentType, statusCode: out var statusCode);
if (statusCode == 200)
{
using (var response = new NSUrlResponse(urlSchemeTask.Request.Url, contentType, responseBytes.Length, null))
{
urlSchemeTask.DidReceiveResponse(response);
}
urlSchemeTask.DidReceiveData(NSData.FromArray(responseBytes));
urlSchemeTask.DidFinish();
}
}
private void ResponseHandler(NSData data, NSUrlResponse response, NSError error)
{
if (data == null)
{
Debug.WriteLine("no data");
return;
}
NSString dataString = NSString.FromData(data, NSStringEncoding.UTF8);
InvokeOnMainThread(() => {
ResultTextView.Text = dataString;
});
}
public override NSUrlRequest WillSendRequest(NSUrlConnection connection, NSUrlRequest request,
NSUrlResponse response)
{
NSMutableUrlRequest mutableRequest = (NSMutableUrlRequest)request.MutableCopy();
CustomHeaderHandler.ApplyHeadersTo(mutableRequest);
if (response != null)
{
RemoveProperty("MsalCustomUrlProtocol", mutableRequest);
_handler.Client.Redirected(_handler, mutableRequest, response);
}
return(mutableRequest);
}
public override void FinishedLoading(NSUrlConnection connection)
{
Client.FinishedLoading(this);
var cachePath = CachePathForRequest(this.Request);
var cache = new MtRnCachedData();
cache.Response = this.Response;
cache.Data = this.Data;
NSKeyedArchiver.ArchiveRootObjectToFile(cache, cachePath);
Connection = null;
Data = null;
Response = null;
}
private void Do_NSUrlConnection()
{
//NSUrlConnection urlConnection;
//string localFilename = Path.GetTempPath() + Path.GetFileName(url);
UIAlertView alertView = null;
try
{
NSUrlResponse response = null;
NSError error = null;
NSUrlRequest urlRequest = new NSUrlRequest(new NSUrl(url), NSUrlRequestCachePolicy.ReloadIgnoringLocalAndRemoteCacheData, 120);
NSData data = NSUrlConnection.SendSynchronousRequest(urlRequest, out response, out error);
if (data == null)
{
alertView = new UIAlertView("Error", "NSUrlConnection.SendSynchronousRequest returned null\n" + error.LocalizedDescription, null, "Ok", null);
}
else
{
NSString dataString = NSString.FromData(data, NSStringEncoding.ASCIIStringEncoding);
if (dataString == null)
{
alertView = new UIAlertView("Error", "NSString.FromData returned null", null, "Ok", null);
}
else
{
alertView = new UIAlertView("Success", dataString.ToString(), null, "Ok", null);
}
}
}
catch (Exception e)
{
if (alertView == null)
{
alertView = new UIAlertView("Error", e.Message, null, "Ok", null);
}
Console.WriteLine(e.Message);
}
alertView.Show();
//ProxyTest_NSUrlConnectionDelegate connectionDelegate = new ProxyTest_NSUrlConnectionDelegate();
//urlConnection = new NSUrlConnection(DownloadRequest, connectionDelegate, true);
}
void HandleCacheItemAdded(object sender, CachedEventArgs e)
{
var url = NSUrl.FromString(e.Url);
if (url == null)
{
return;
}
var req = NSUrlRequest.FromUrl(url);
var data = NSData.FromStream(e.Item.DataSource());
var resp = new NSUrlResponse(url, e.Item.MimeType, (nint)data.Length, "UTF-8");
var cachedResponse = new NSCachedUrlResponse(resp, data);
NSUrlCache.SharedCache.StoreCachedResponse(cachedResponse, req);
}
public void ConstructorTest()
{
// See https://bugzilla.xamarin.com/show_bug.cgi?id=3835
using (var response = new NSUrlResponse())
using (var data = new NSData()) {
// Test that UserInfo is NullAllowed
using (var res1 = new NSCachedUrlResponse(response, data, null, NSUrlCacheStoragePolicy.Allowed)) {
Assert.That(res1.StoragePolicy, Is.EqualTo(NSUrlCacheStoragePolicy.Allowed), "StoragePolicy-1");
Assert.Null(res1.UserInfo, "UserInfo-1");
}
using (var res2 = new NSCachedUrlResponse(response, data)) {
Assert.That(res2.StoragePolicy, Is.EqualTo(NSUrlCacheStoragePolicy.Allowed), "StoragePolicy-2");
Assert.Null(res2.UserInfo, "UserInfo-2");
}
}
}
public override void StartLoading ()
{
var value = Request.Url.Path.Substring (1);
using (var image = Render (value))
{
using (var response = new NSUrlResponse (Request.Url, "image/jpeg", -1, null))
{
var client = (NSUrlProtocolClient)this.WeakClient;
client.ReceivedResponse (this, response, NSUrlCacheStoragePolicy.NotAllowed);
this.InvokeOnMainThread (delegate
{
using (var data = ImageAsJPEG (image))
{
client.DataLoaded (this, data);
}
client.FinishedLoading (this);
});
}
}
}
public unsafe static NSData SendSynchronousRequest(NSUrlRequest request, out NSUrlResponse response, out NSError error)
{
IntPtr responseStorage = IntPtr.Zero;
IntPtr errorStorage = IntPtr.Zero;
void * resp = &responseStorage;
void * errp = &errorStorage;
IntPtr rhandle = (IntPtr)resp;
IntPtr ehandle = (IntPtr)errp;
#if NET
var res = Messaging.NativeHandle_objc_msgSend_NativeHandle_NativeHandle_NativeHandle(
#else
var res = Messaging.IntPtr_objc_msgSend_IntPtr_IntPtr_IntPtr(
#endif
class_ptr,
Selector.GetHandle(selSendSynchronousRequestReturningResponseError),
request.Handle,
rhandle,
ehandle);
if (responseStorage != IntPtr.Zero)
{
response = (NSUrlResponse)Runtime.GetNSObject(responseStorage);
}
else
{
response = null;
}
if (errorStorage != IntPtr.Zero)
{
error = (NSError)Runtime.GetNSObject(errorStorage);
}
else
{
error = null;
}
return (NSData) Runtime.GetNSObject(res);
}
static unsafe NSData SendSynchronousRequest(NSUrlRequest request, out NSUrlResponse response, NSError error)
{
IntPtr storage = IntPtr.Zero;
void *p = &storage;
IntPtr handle = (IntPtr) p;
var res = Messaging.IntPtr_objc_msgSend_IntPtr_IntPtr_IntPtr (
class_ptr,
selSendSynchronousRequestReturningResponseError.Handle,
request.Handle,
handle,
error != null ? error.Handle : IntPtr.Zero);
if (storage != IntPtr.Zero)
response = (NSUrlResponse) Runtime.GetNSObject (storage);
else
response = null;
return (NSData) Runtime.GetNSObject (res);
}
public override void StartLoading()
{
var value = Request.Url.Path.Substring(1);
using (var image = Render(value))
{
using (var response = new NSUrlResponse(Request.Url, "image/jpeg", -1, null))
{
var client = (NSUrlProtocolClient)this.WeakClient;
client.ReceivedResponse(this, response, NSUrlCacheStoragePolicy.NotAllowed);
this.InvokeOnMainThread(delegate
{
using (var data = ImageAsJPEG(image))
{
client.DataLoaded(this, data);
}
client.FinishedLoading(this);
});
}
}
}
void RequestCompletionHandler(NSUrlResponse responce, NSData data, NSError error)
{
UIApplication.SharedApplication.NetworkActivityIndicatorVisible = false;
if (error != null)
{
HandleError(error);
}
else
{
var httpResponse = (NSHttpUrlResponse)responce;
if (httpResponse.StatusCode / 100 == 2 && responce.MimeType == "application/json")
{
var parseOperation = new APLParseOperation(data, PersistentStoreCoordinator);
parseQueue.AddOperation(parseOperation);
}
else
{
var userInfo = new NSDictionary(NSError.LocalizedDescriptionKey, "Problems with connection.");
var reportError = new NSError(new NSString("HTTP"), httpResponse.StatusCode, userInfo);
HandleError(reportError);
}
}
}
public override NSCachedUrlResponse CachedResponseForRequest(NSUrlRequest request)
{
var uri = (Uri)request.Url;
int index;
// walk up our multipart/related stack looking for the MIME part for the requested URL
for (int i = stack.Count - 1; i >= 0; i--)
{
var related = stack[i];
if ((index = related.IndexOf(uri)) == -1)
{
continue;
}
var part = related[index] as MimePart;
if (part != null)
{
var mimeType = part.ContentType.MimeType;
var charset = part.ContentType.Charset;
NSUrlResponse response;
NSData data;
// create an NSData wrapper for the MIME part's decoded content stream
using (var content = part.Content.Open())
data = NSData.FromStream(content);
// construct our response
response = new NSUrlResponse(request.Url, mimeType, (int)data.Length, charset);
return(new NSCachedUrlResponse(response, data));
}
}
return(base.CachedResponseForRequest(request));
}
public void StartUrlSchemeTask(WKWebView webView, IWKUrlSchemeTask urlSchemeTask)
{
try
{
var urlToFetch = urlSchemeTask.Request.Url.ToString();
if (!urlToFetch.Contains("favicon"))
{
var safeResponse = AsyncContext.Run(() => WebFetchService.FetchResourceAsync(urlToFetch));
var stream = new MemoryStream(safeResponse.Data);
var response = new NSUrlResponse(urlSchemeTask.Request.Url, safeResponse.MimeType, (nint)stream.Length, null);
if (safeResponse.FetchDataType == typeof(FilesContainer))
{
var currentWebView = webView as HybridWebViewRenderer;
currentWebView.SetCurrentPageVersion(safeResponse.CurrentNrsVersion);
currentWebView.SetLatestPageVersion(safeResponse.LatestNrsVersion);
}
urlSchemeTask.DidReceiveResponse(response);
urlSchemeTask.DidReceiveData(NSData.FromStream(stream));
urlSchemeTask.DidFinish();
}
}
catch (Exception ex)
{
Logger.Error(ex);
if (ex.InnerException != null)
{
var stream = new MemoryStream();
var response = new NSUrlResponse(urlSchemeTask.Request.Url, "text/html", 0, null);
urlSchemeTask.DidReceiveResponse(response);
urlSchemeTask.DidReceiveData(NSData.FromStream(stream));
urlSchemeTask.DidFinish();
}
}
}
public override NSUrlRequest WillSendRequest(NSUrlConnection connection, NSUrlRequest request,
NSUrlResponse response)
{
NSMutableUrlRequest mutableRequest = (NSMutableUrlRequest)request.MutableCopy();
if (response != null)
{
RemoveProperty("ADURLProtocol", mutableRequest);
handler.Client.Redirected(handler, mutableRequest, response);
connection.Cancel();
if (!request.Headers.ContainsKey(new NSString("x-ms-PkeyAuth")))
{
mutableRequest[BrokerConstants.ChallengeHeaderKey] = BrokerConstants.ChallengeHeaderValue;
}
return(mutableRequest);
}
if (!request.Headers.ContainsKey(new NSString(BrokerConstants.ChallengeHeaderKey)))
{
mutableRequest[BrokerConstants.ChallengeHeaderKey] = BrokerConstants.ChallengeHeaderValue;
}
return(mutableRequest);
}
public void OnReceivedResponse(WebView sender, NSObject identifier, NSUrlResponse responseReceived, WebDataSource dataSource)
{
Console.WriteLine("OnReceivedResponse: {0}", responseReceived.ExpectedContentLength);
}
/// <summary>
/// Should be authed now, start up the webview request again
/// </summary>
public override void ReceivedResponse(NSUrlConnection connection, NSUrlResponse response)
{
_auth = true;
_view.LoadRequest(connection.CurrentRequest);
connection.Cancel();
}
public override void StartLoading()
{
//SystemLogger.Log (SystemLogger.Module.PLATFORM, "# IPhoneNSUrlProtocol MANAGED SERVICE - Start Loading Content - HttpMethod: " + Request.HttpMethod);
NSMutableUrlRequest newRequest = (NSMutableUrlRequest)Request.MutableCopy (); // change to mutable in case we need to change something
string requestUrl = null;
if (newRequest != null && newRequest.Url != null)
requestUrl = newRequest.Url.ToString ();
SystemLogger.Log (SystemLogger.Module.PLATFORM, "# IPhoneNSUrlProtocol - Start Loading Content - Request URl: " + requestUrl);
/* TO BE REMOVED - 5.0.6 [AMOB-30]
if (Request.HttpMethod == "OPTIONS")
{
//In case of an OPTIONS, we allow the access to the origin of the petition
var vlsOrigin = Request.Headers["ORIGIN"];
//SystemLogger.Log (SystemLogger.Module.PLATFORM, "# IPhoneNSUrlProtocol - StartLoading: vlsOrigin: " + vlsOrigin);
NSMutableDictionary headers = new NSMutableDictionary ();
NSHttpUrlResponse Response = new NSHttpUrlResponse (Request.Url, 403, "1.1", headers);
// if (vlsOrigin!=null && vlsOrigin.ToString() == String.Format(IPhoneServiceLocator.INTERNAL_SERVER_URL, IPhoneServiceLocator.CurrentDelegate.GetListeningPort()) ) {
if (vlsOrigin!=null && vlsOrigin.ToString() == IPhoneServiceLocator.APPVERSE_HOST ) {
headers.Add (new NSString ("Access-Control-Allow-Origin"), vlsOrigin);
headers.Add (new NSString ("Access-Control-Allow-Methods"), new NSString ("POST"));
headers.Add (new NSString ("Access-Control-Allow-Headers"), new NSString ("accept, content-type"));
headers.Add (new NSString ("Access-Control-Max-Age"), new NSString ("1728000"));
Response = new NSHttpUrlResponse (Request.Url, 200, "1.1", headers);
} else {
SystemLogger.Log (SystemLogger.Module.PLATFORM, "# IPhoneNSUrlProtocol - StartLoading: WARNING - origin not allowed: " + vlsOrigin);
}
Client.ReceivedResponse(this, Response, NSUrlCacheStoragePolicy.NotAllowed);
} else
*/
if (requestUrl != null) {
if (Request.HttpMethod == "POST") {
string serviceName = "undefined";
string methodName = "undefined";
Object service = null;
if (requestUrl.StartsWith (IPhoneServiceLocator.APPVERSE_SERVICE_URI)) {
SystemLogger.Log (SystemLogger.Module.PLATFORM, "# IPhoneNSUrlProtocol MANAGED SERVICE");
// get service path
string commandParams = requestUrl.Substring (IPhoneServiceLocator.APPVERSE_SERVICE_URI.Length);
//SystemLogger.Log (SystemLogger.Module.PLATFORM, "# IPhoneNSUrlProtocol - commandParams: " + commandParams);
string[] commandParamsArray = commandParams.Split (new char[] { '/' });
serviceName = commandParamsArray [0];
methodName = commandParamsArray [1];
//SystemLogger.Log (SystemLogger.Module.PLATFORM, "# IPhoneNSUrlProtocol - serviceName: " + serviceName + ", methodName: " + methodName);
service = serviceLocator.GetService (serviceName);
String query = null;
if (newRequest.Body != null) {
SystemLogger.Log (SystemLogger.Module.PLATFORM,
"# IPhoneNSUrlProtocol - query data [ONLY FOR TESTING PURPOSES, PLEASE REMOVE THIS TRACE FROM LOG] request length: " + newRequest.Body.Length);
query = NSString.FromData (newRequest.Body, NSStringEncoding.UTF8);
}
SystemLogger.Log (SystemLogger.Module.PLATFORM, "# IPhoneNSUrlProtocol - sending Async POST result for service: " + serviceName + ", and method: " + methodName);
serviceURIHandler.ProcessAsyncPOSTResult (serviceInvocationManager, service, methodName, query);
NSData nsDataResponse = NSData.FromString ("MANAGED SERVICE (data returned using callback or global listener)");
NSUrlResponse response = new NSUrlResponse (newRequest.Url, "text/html", (nint)nsDataResponse.Length, "utf-8");
SystemLogger.Log (SystemLogger.Module.PLATFORM, "# IPhoneNSUrlProtocol MANAGED SERVICE - Service executed (data will be returned using callback or global listener)");
Client.ReceivedResponse (this, response, NSUrlCacheStoragePolicy.NotAllowed);
Client.DataLoaded (this, nsDataResponse);
}
} else if (Request.HttpMethod == "GET") {
if (requestUrl.StartsWith (IPhoneServiceLocator.APPVERSE_RESOURCE_URI)) {
SystemLogger.Log (SystemLogger.Module.PLATFORM, "# IPhoneNSUrlProtocol MANAGED WEB RESOURCE");
String resourcePath = newRequest.Url.Path;
String mimeType = resourceURIHandler.GetWebResourceMimeType (resourcePath, true);
NSData nsDataResponse = resourceURIHandler.ProcessWebResource (resourcePath);
if (nsDataResponse == null) {
SystemLogger.Log (SystemLogger.Module.PLATFORM, "# IPhoneNSUrlProtocol MANAGED WEB RESOURCE no data bytes - " + requestUrl);
nsDataResponse = NSData.FromString ("MANAGED WEB RESOURCE : no data bytes");
}
NSUrlResponse response = new NSUrlResponse (newRequest.Url, mimeType, (nint)nsDataResponse.Length, "utf-8");
Client.ReceivedResponse (this, response, NSUrlCacheStoragePolicy.NotAllowed);
Client.DataLoaded (this, nsDataResponse);
} else if (requestUrl.StartsWith (IPhoneServiceLocator.APPVERSE_DOCUMENT_URI)) {
SystemLogger.Log (SystemLogger.Module.PLATFORM, "# IPhoneNSUrlProtocol MANAGED DOCUMENT RESOURCE");
String resourcePath = newRequest.Url.Path.Substring (IPhoneServiceLocator.APPVERSE_DOCUMENT_PATH.Length);
String mimeType = resourceURIHandler.GetWebResourceMimeType (resourcePath.ToLower (), false);
NSData nsDataResponse = resourceURIHandler.ProcessDocumentResource (resourcePath);
if (nsDataResponse == null) {
SystemLogger.Log (SystemLogger.Module.PLATFORM, "# IPhoneNSUrlProtocol MANAGED DOCUMENT RESOURCE no data bytes - " + requestUrl);
nsDataResponse = NSData.FromString ("MANAGED DOCUMENT RESOURCE : no data bytes");
}
NSUrlResponse response = new NSUrlResponse (newRequest.Url, mimeType, (nint)nsDataResponse.Length, "utf-8");
Client.ReceivedResponse (this, response, NSUrlCacheStoragePolicy.NotAllowed);
Client.DataLoaded (this, nsDataResponse);
}
}
}
Client.FinishedLoading (this);
}
public override void ReceivedResponse(NSUrlConnection connection, NSUrlResponse response)
{
iExpectedContentLength = response.ExpectedContentLength;
}
public void Redirected(NSUrlProtocol protocol, NSUrlRequest redirectedToEequest, NSUrlResponse redirectResponse)
{
Messaging.void_objc_msgSend_IntPtr_IntPtr_IntPtr(this.Handle, Selector.GetHandle(selUrlProtocolWasRedirectedToRequestRedirectResponse_), protocol.Handle, redirectedToEequest.Handle, redirectResponse.Handle);
}
public override void ReceivedResponse (NSUrlConnection connection, NSUrlResponse response)
{
long length = response.ExpectedContentLength;
if (length == -1) {
length = 1* 1024 * 1024;
}
ResponseData = new byte[length];
_receivedDataLength = 0;
}
public virtual void DidReceiveResponse(NSUrlSession session, NSUrlSessionDataTask dataTask, NSUrlResponse response, Action <NSUrlSessionResponseDisposition> completionHandler)
{
State = -3;
completionHandler(NSUrlSessionResponseDisposition.Allow);
this.Client.ReceivedResponse(this, response, NSUrlCacheStoragePolicy.Allowed);
}
public override void ReceivedResponse(NSUrlConnection connection, NSUrlResponse response)
{
buffer.Length = 0;
}
public override void ReceivedResponse (NSUrlConnection connection, NSUrlResponse response)
{
// TODO: Implement - see: http://go-mono.com/docs/index.aspx?link=T%3aMonoTouch.Foundation.ModelAttribute
}
private void RequestCompletionHandler (NSUrlResponse responce, NSData data, NSError error)
{
UIApplication.SharedApplication.NetworkActivityIndicatorVisible = false;
if (error != null) {
HandleError (error);
} else {
var httpResponse = (NSHttpUrlResponse)responce;
if (httpResponse.StatusCode / 100 == 2 && responce.MimeType == "application/json") {
var parseOperation = new APLParseOperation (data, PersistentStoreCoordinator);
parseQueue.AddOperation (parseOperation);
} else {
var errorString = new NSString ("Problems with connection.");
var userInfo = NSDictionary.FromObjectAndKey (errorString, NSError.LocalizedDescriptionKey);
var reportError = new NSError (new NSString ("HTTP"), httpResponse.StatusCode, userInfo);
HandleError (reportError);
}
}
}
public void ReceivedResponse(NSUrlProtocol protocol, NSUrlResponse response, NSUrlCacheStoragePolicy policy)
{
Messaging.void_objc_msgSend_IntPtr_IntPtr_int (this.Handle, selUrlProtocolDidReceiveResponseCacheStoragePolicy_, protocol.Handle, response.Handle, (int)policy);
}
public void Redirected(NSUrlProtocol protocol, NSUrlRequest redirectedToEequest, NSUrlResponse redirectResponse)
{
Messaging.void_objc_msgSend_IntPtr_IntPtr_IntPtr (this.Handle, selUrlProtocolWasRedirectedToRequestRedirectResponse_, protocol.Handle, redirectedToEequest.Handle, redirectResponse.Handle);
}
public override void ReceivedResponse (NSUrlConnection connection, NSUrlResponse response)
{
var http_response = response as NSHttpUrlResponse;
if (http_response == null) {
Console.WriteLine ("Received non HTTP url response: '{0}'", response);
status_code = -1;
return;
}
status_code = http_response.StatusCode;
Console.WriteLine ("Status code of result: '{0}'", status_code);
}
public override void ReceivedResponse(NSUrlConnection connection, NSUrlResponse response)
{
handler.Client.ReceivedResponse(handler, response, NSUrlCacheStoragePolicy.NotAllowed);
}
public override void DidReceiveResponse(NSUrlSession session, NSUrlSessionDataTask dataTask, NSUrlResponse response, Action <NSUrlSessionResponseDisposition> completionHandler)
{
var data = GetResponseForTask(dataTask);
try
{
if (data.CancellationToken.IsCancellationRequested)
{
dataTask.Cancel();
}
var resp = (NSHttpUrlResponse)response;
var content = new CancellableStreamContent(data.ResponseBody, () =>
{
if (!data.IsCompleted)
{
dataTask.Cancel();
}
data.IsCompleted = true;
data.ResponseBody.SetException(new OperationCanceledException());
})
{
Progress = data.Progress
};
// NB: The double cast is because of a Xamarin compiler bug
var status = (int)resp.StatusCode;
var ret = new HttpResponseMessage((HttpStatusCode)status)
{
Content = content,
RequestMessage = data.Request,
};
ret.RequestMessage.RequestUri = new Uri(resp.Url.AbsoluteString);
foreach (var v in resp.AllHeaderFields)
{
// NB: Cocoa trolling us so hard by giving us back dummy dictionary entries
if (v.Key == null || v.Value == null)
{
continue;
}
ret.Headers.TryAddWithoutValidation(v.Key.ToString(), v.Value.ToString());
ret.Content.Headers.TryAddWithoutValidation(v.Key.ToString(), v.Value.ToString());
}
data.FutureResponse.TrySetResult(ret);
}
catch (Exception ex)
{
data.FutureResponse.TrySetException(ex);
}
completionHandler(NSUrlSessionResponseDisposition.Allow);
}
public override void DidReceiveResponse(NSUrlSession session, NSUrlSessionDataTask dataTask, NSUrlResponse response, Action<NSUrlSessionResponseDisposition> completionHandler)
{
var data = getResponseForTask(dataTask);
try {
if (data.CancellationToken.IsCancellationRequested) {
dataTask.Cancel();
}
var resp = (NSHttpUrlResponse)response;
var ret = new HttpResponseMessage((HttpStatusCode)resp.StatusCode) {
Content = new CancellableStreamContent(data.ResponseBody, () => {
//Console.WriteLine("Cancelling!");
if (!data.IsCompleted) dataTask.Cancel();
data.IsCompleted = true;
data.ResponseBody.SetException(new OperationCanceledException());
}),
RequestMessage = data.Request,
};
foreach(var v in resp.AllHeaderFields) {
// NB: Cocoa trolling us so hard by giving us back dummy
// dictionary entries
if (v.Key == null || v.Value == null) continue;
ret.Headers.TryAddWithoutValidation(v.Key.ToString(), v.Value.ToString());
ret.Content.Headers.TryAddWithoutValidation(v.Key.ToString(), v.Value.ToString());
}
data.FutureResponse.TrySetResult(ret);
} catch (Exception ex) {
data.FutureResponse.TrySetException(ex);
}
completionHandler(NSUrlSessionResponseDisposition.Allow);
}
// Preform the download
private void Download(bool isAsync, string path)
{
_stringBuilder.Clear();
NSMutableUrlRequest request = null;
NSError error = null;
try
{
#if DEBUG
DateTime start = DateTime.Now;
#endif
request = new NSMutableUrlRequest(new NSUrl(_url), NSUrlRequestCachePolicy.ReloadIgnoringLocalAndRemoteCacheData, _timeout);
if (_post != String.Empty)
{
request.HttpMethod = "POST";
request["Content-Length"] = _post.Length.ToString();;
request["Content-Type"] = "application/x-www-form-urlencoded";
request.Body = _post;
}
if (isAsync)
{
DataDownloader_NSUrlConnectionDelegate connectionDelegate = new DataDownloader_NSUrlConnectionDelegate();
connectionDelegate.AsyncDownloadComplete += delegate(object sender, AsyncDownloadComplete_EventArgs e) {
if (path != String.Empty)
{
((DataDownloader_NSUrlConnectionDelegate)sender).WriteResultToFile(path);
}
if (AsyncDownloadComplete != null)
{
AsyncDownloadComplete(this, e);
}
};
if (AsyncDownloadProgressChanged != null)
{
connectionDelegate.AsyncDownloadProgressChanged += delegate(object sender, AsyncDownloadProgressChanged_EventArgs e) {
AsyncDownloadProgressChanged(this, e);
};
}
connectionDelegate.AsyncDownloadFailed += delegate(object sender, AsyncDownloadFailed_EventArgs e) {
_exception = new Exception(e.Error.LocalizedDescription);
if (AsyncDownloadFailed != null)
{
AsyncDownloadFailed(this, e);
}
};
// Not using matching functions, but I'll live.
//NSUrlConnection.SendAsynchronousRequest(request, new NSOperationQueue(), connectionDelegate);
_connection = new NSUrlConnection(request, connectionDelegate, true);
}
else
{
NSUrlResponse response = null;
NSData output = NSUrlConnection.SendSynchronousRequest(request, out response, out error);
if (output == null)
{
if (error != null)
{
_exception = new Exception(error.LocalizedDescription);
}
else if (response == null)
{
_exception = new Exception("Could not get a response from the server.");
}
else
{
_exception = new Exception("Could not get data from server.");
}
}
if (path != String.Empty)
{
File.WriteAllText(path, output.ToString());
}
_stringBuilder = new StringBuilder(output.ToString());
Console.WriteLine(_stringBuilder.ToString());
}
#if DEBUG
Console.WriteLine("NSData.FromUrl: " + (DateTime.Now - start).TotalMilliseconds);
start = DateTime.Now;
#endif
}
catch (Exception err)
{
_exception = err;
Console.WriteLine("StreamLoading Error: " + err.Message);
}
finally
{
}
}
/// <summary>
/// Obtengo codigo response.
/// </summary>
/// <param name="session">Session.</param>
/// <param name="dataTask">Data task.</param>
/// <param name="response">Response.</param>
/// <param name="completionHandler">Completion handler.</param>
public override void DidReceiveResponse(NSUrlSession session, NSUrlSessionDataTask dataTask, NSUrlResponse response, Action <NSUrlSessionResponseDisposition> completionHandler)
{
// Compruebo si es null
if (!(response is NSHttpUrlResponse http_response))
{
status_code = -1;
return;
}
// Obtengo codigo
status_code = http_response.StatusCode;
// Conexion
completionHandler(status_code == 200 || status_code == 201 ? NSUrlSessionResponseDisposition.Allow : NSUrlSessionResponseDisposition.Cancel);
}
public override void DidReceiveResponse(NSUrlSession session, NSUrlSessionDataTask dataTask, NSUrlResponse response, Action <NSUrlSessionResponseDisposition> completionHandler)
{
System.Diagnostics.Debug.WriteLine("DidReceiveResponse: " + response.ToString());
completionHandler.Invoke(NSUrlSessionResponseDisposition.Allow);
}
public void ReceivedResponse(NSUrlProtocol protocol, NSUrlResponse response, NSUrlCacheStoragePolicy policy)
{
Messaging.void_objc_msgSend_intptr_intptr_nuint(this.Handle, Selector.GetHandle(selUrlProtocolDidReceiveResponseCacheStoragePolicy_), protocol.Handle, response.Handle, (nuint)policy);
}
public override void ReceivedResponse(NSUrlConnection connection, NSUrlResponse response)
{
_handler.Client.ReceivedResponse(_handler, response, NSUrlCacheStoragePolicy.NotAllowed);
}
public override void DidReceiveResponse(NSUrlSession session, NSUrlSessionDataTask dataTask, NSUrlResponse response, Action <NSUrlSessionResponseDisposition> completionHandler)
{
var inflight = GetInflightData(dataTask);
if (inflight == null)
{
return;
}
try {
var urlResponse = (NSHttpUrlResponse)response;
var status = (int)urlResponse.StatusCode;
var content = new NSUrlSessionDataTaskStreamContent(inflight.Stream, () => {
if (!inflight.Completed)
{
dataTask.Cancel();
}
inflight.Disposed = true;
inflight.Stream.TrySetException(new ObjectDisposedException("The content stream was disposed."));
sessionHandler.RemoveInflightData(dataTask);
}, inflight.CancellationTokenSource.Token);
// NB: The double cast is because of a Xamarin compiler bug
var httpResponse = new HttpResponseMessage((HttpStatusCode)status)
{
Content = content,
RequestMessage = inflight.Request
};
httpResponse.RequestMessage.RequestUri = new Uri(urlResponse.Url.AbsoluteString);
foreach (var v in urlResponse.AllHeaderFields)
{
// NB: Cocoa trolling us so hard by giving us back dummy dictionary entries
if (v.Key == null || v.Value == null)
{
continue;
}
// NSUrlSession tries to be smart with cookies, we will not use the raw value but the ones provided by the cookie storage
if (v.Key.ToString() == SetCookie)
{
continue;
}
httpResponse.Headers.TryAddWithoutValidation(v.Key.ToString(), v.Value.ToString());
httpResponse.Content.Headers.TryAddWithoutValidation(v.Key.ToString(), v.Value.ToString());
}
var cookies = session.Configuration.HttpCookieStorage.CookiesForUrl(response.Url);
for (var index = 0; index < cookies.Length; index++)
{
httpResponse.Headers.TryAddWithoutValidation(SetCookie, cookies [index].GetHeaderValue());
}
inflight.Response = httpResponse;
// We don't want to send the response back to the task just yet. Because we want to mimic .NET behavior
// as much as possible. When the response is sent back in .NET, the content stream is ready to read or the
// request has completed, because of this we want to send back the response in DidReceiveData or DidCompleteWithError
if (dataTask.State == NSUrlSessionTaskState.Suspended)
{
dataTask.Resume();
}
} catch (Exception ex) {
inflight.CompletionSource.TrySetException(ex);
inflight.Stream.TrySetException(ex);
sessionHandler.RemoveInflightData(dataTask);
}
completionHandler(NSUrlSessionResponseDisposition.Allow);
}
public override NSUrlRequest WillSendRequest(NSUrlConnection connection, NSUrlRequest request,
NSUrlResponse response)
{
NSMutableUrlRequest mutableRequest = (NSMutableUrlRequest) request.MutableCopy();
CustomHeaderHandler.ApplyHeadersTo(mutableRequest);
if (response != null)
{
RemoveProperty("MsalCustomUrlProtocol", mutableRequest);
_handler.Client.Redirected(_handler, mutableRequest, response);
}
return mutableRequest;
}
public override void ReceivedResponse(NSUrlConnection connection, NSUrlResponse response)
{
expectedBytes = response.ExpectedContentLength;
}
public override NSUrlRequest OnSendRequest(WebView sender, NSObject identifier, NSUrlRequest request, NSUrlResponse redirectResponse, WebDataSource dataSource);
public override void ReceivedResponse(NSUrlConnection connection, NSUrlResponse response)
{
throw new System.NotImplementedException ();
}
public override void OnReceivedResponse(WebView sender, NSObject identifier, NSUrlResponse responseReceived, WebDataSource dataSource);
public override void DidReceiveResponse(NSUrlSession session, NSUrlSessionDataTask dataTask, NSUrlResponse response, Action <NSUrlSessionResponseDisposition> completionHandler)
{
var data = getResponseForTask(dataTask);
try {
if (data.CancellationToken.IsCancellationRequested)
{
dataTask.Cancel();
}
var resp = (NSHttpUrlResponse)response;
var req = data.Request;
if (This.throwOnCaptiveNetwork && req.RequestUri.Host != resp.Url.Host)
{
throw new CaptiveNetworkException(req.RequestUri, new Uri(resp.Url.ToString()));
}
var content = new CancellableStreamContent(data.ResponseBody, () => {
if (!data.IsCompleted)
{
dataTask.Cancel();
}
data.IsCompleted = true;
data.ResponseBody.SetException(new OperationCanceledException());
});
content.Progress = data.Progress;
// NB: The double cast is because of a Xamarin compiler bug
int status = (int)resp.StatusCode;
var ret = new HttpResponseMessage((HttpStatusCode)status)
{
Content = content,
RequestMessage = data.Request,
};
foreach (var v in resp.AllHeaderFields)
{
// NB: Cocoa trolling us so hard by giving us back dummy
// dictionary entries
if (v.Key == null || v.Value == null)
{
continue;
}
ret.Headers.TryAddWithoutValidation(v.Key.ToString(), v.Value.ToString());
ret.Content.Headers.TryAddWithoutValidation(v.Key.ToString(), v.Value.ToString());
}
// NB: The awaiting code can synchronously call read, which will block, and we'll
// never get a didReceiveData, because we have not returned from DidReceiveResponse.
Task.Run(() => { data.FutureResponse.TrySetResult(ret); });
} catch (Exception ex) {
data.FutureResponse.TrySetException(ex);
}
completionHandler(NSUrlSessionResponseDisposition.Allow);
}
public override void ReceivedResponse(NSUrlConnection connection, NSUrlResponse response)
{
buffer.SetLength (0);
}
public override void DidReceiveResponse(NSUrlSession session, NSUrlSessionDataTask dataTask, NSUrlResponse response, Action<NSUrlSessionResponseDisposition> completionHandler)
{
var data = getResponseForTask(dataTask);
try {
if (data.CancellationToken.IsCancellationRequested) {
dataTask.Cancel();
}
var resp = (NSHttpUrlResponse)response;
var req = data.Request;
if (This.throwOnCaptiveNetwork && req.RequestUri.Host != resp.Url.Host) {
throw new CaptiveNetworkException(req.RequestUri, new Uri(resp.Url.ToString()));
}
var content = new CancellableStreamContent(data.ResponseBody, () => {
if (!data.IsCompleted) {
dataTask.Cancel();
}
data.IsCompleted = true;
data.ResponseBody.SetException(new OperationCanceledException());
});
content.Progress = data.Progress;
// NB: The double cast is because of a Xamarin compiler bug
int status = (int)resp.StatusCode;
var ret = new HttpResponseMessage((HttpStatusCode)status) {
Content = content,
RequestMessage = data.Request,
};
ret.RequestMessage.RequestUri = new Uri(resp.Url.AbsoluteString);
foreach(var v in resp.AllHeaderFields) {
// NB: Cocoa trolling us so hard by giving us back dummy
// dictionary entries
if (v.Key == null || v.Value == null) continue;
ret.Headers.TryAddWithoutValidation(v.Key.ToString(), v.Value.ToString());
ret.Content.Headers.TryAddWithoutValidation(v.Key.ToString(), v.Value.ToString());
}
data.FutureResponse.TrySetResult(ret);
} catch (Exception ex) {
data.FutureResponse.TrySetException(ex);
}
completionHandler(NSUrlSessionResponseDisposition.Allow);
}
public override void ReceivedResponse (NSUrlConnection connection, NSUrlResponse response)
{
del.expectedLength = response.ExpectedContentLength;
del.currentLength = 0;
hud.Mode = MBProgressHUDMode.Determinate;
}
public void OnReceivedResponse(WebView sender, NSObject identifier, NSUrlResponse responseReceived, WebDataSource dataSource)
{
Console.WriteLine("OnReceivedResponse: {0}", responseReceived.ExpectedContentLength);
}
public override void Request(FBRequest request, NSUrlResponse response)
{
}
