protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.Main);
//This API is only available in Mono and Xamarin products.
//You can filter and/or re-order the ciphers suites that the SSL/TLS server will accept from a client.
//The following example removes weak (export) ciphers from the list that will be offered to the server.
ServicePointManager.ClientCipherSuitesCallback += (protocol, allCiphers) =>
allCiphers.Where(x => !x.Contains("EXPORT")).ToList();
//Here we accept any certificate and just print the cert's data.
ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) => {
System.Diagnostics.Debug.WriteLine("Callback Server Certificate: " + sslPolicyErrors);
foreach (var el in chain.ChainElements)
{
System.Diagnostics.Debug.WriteLine(el.Certificate.GetCertHashString());
System.Diagnostics.Debug.WriteLine(el.Information);
}
return(true);
};
// Get our button from the layout resource,
// and attach an event to it
var button = FindViewById <Button>(Resource.Id.doIt);
var cancel = FindViewById <Button>(Resource.Id.cancelButton);
var result = FindViewById <TextView>(Resource.Id.result);
var hashView = FindViewById <TextView>(Resource.Id.md5sum);
var status = FindViewById <TextView>(Resource.Id.status);
progress = FindViewById <ProgressBar>(Resource.Id.progress);
var resp = default(HttpResponseMessage);
cancel.Click += (o, e) => {
Console.WriteLine("Canceled token {0:x8}", this.currentToken.Token.GetHashCode());
this.currentToken.Cancel();
if (resp != null)
{
resp.Content.Dispose();
}
};
button.Click += async(o, e) => {
var handler = new NativeMessageHandler();
var client = new HttpClient(handler);
currentToken = new CancellationTokenSource();
var st = new Stopwatch();
st.Start();
try {
//var url = "https://github.com/downloads/nadlabak/android/cm-9.1.0a-umts_sholes.zip";
var url = "https://github.com/paulcbetts/ModernHttpClient/releases/download/0.9.0/ModernHttpClient-0.9.zip";
var request = new HttpRequestMessage(HttpMethod.Get, url);
handler.RegisterForProgress(request, HandleDownloadProgress);
resp = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, currentToken.Token);
result.Text = "Got the headers!";
status.Text = string.Format("HTTP {0}: {1}", (int)resp.StatusCode, resp.ReasonPhrase);
foreach (var v in resp.Headers)
{
Console.WriteLine("{0}: {1}", v.Key, String.Join(",", v.Value));
}
var stream = await resp.Content.ReadAsStreamAsync();
var ms = new MemoryStream();
await stream.CopyToAsync(ms, 4096, currentToken.Token);
var bytes = ms.ToArray();
result.Text = String.Format("Read {0} bytes", bytes.Length);
var md5 = MD5.Create();
var hash = md5.ComputeHash(bytes);
hashView.Text = ToHex(hash, false);
} catch (Exception ex) {
result.Text = ex.ToString();
} finally {
st.Stop();
result.Text = (result.Text ?? "") + String.Format("\n\nTook {0} milliseconds", st.ElapsedMilliseconds);
}
};
}
async Task <IHttpTransferResult> _doDownload(DownloadQueueObject obj, IHttpTransferConfig downloadConfig)
{
// add support for Gzip decompression
var native = new NativeMessageHandler();
var httpClient = new HttpClient(native);
using (httpClient)
{
var method = HttpMethod.Get;
switch (obj.Verb)
{
case "GET":
method = HttpMethod.Get;
break;
case "POST":
method = HttpMethod.Post;
break;
case "PUT":
method = HttpMethod.Put;
break;
case "DELETE":
method = HttpMethod.Delete;
break;
}
using (var message = new HttpRequestMessage(method, obj.Url))
{
native.RegisterForProgress(message, (bytes, totalBytes, expected) => new TransferProgressMessage(obj.Url, bytes, totalBytes, expected, downloadConfig.Verb.ToLower() != "get").Send());
if (downloadConfig.Headers != null)
{
foreach (var item in downloadConfig.Headers)
{
message.Headers.Add(item.Key, item.Value);
}
}
// Accept-Encoding:
if (downloadConfig.AcceptEncoding != null)
{
//message.Headers.AcceptEncoding.Add(new StringWithQualityHeaderValue(""));
message.Headers.Add("Accept-Encoding", downloadConfig.AcceptEncoding);
}
// Accept:
if (!string.IsNullOrWhiteSpace(downloadConfig.Accept))
{
message.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(downloadConfig.Accept));
}
if (!string.IsNullOrWhiteSpace(obj.Data))
{
var content = new StringContent(obj.Data, Encoding.UTF8,
downloadConfig.ContentEncoding ?? "application/json");
message.Content = content;
}
if (obj.ByteData != null)
{
var content = new ByteArrayContent(obj.ByteData, 0, obj.ByteData.Length);
message.Content = content;
}
if (downloadConfig.Auth != null && downloadConfig.AuthScheme != null)
{
message.Headers.Authorization = new AuthenticationHeaderValue(downloadConfig.AuthScheme,
downloadConfig.Auth);
}
try
{
Debug.WriteLine("{0}: {1}", downloadConfig.Verb.ToLower() == "get" ? "Downloading" : "Uploading", obj.Url);
using (var result = await httpClient.SendAsync(message))
{
Debug.WriteLine("Finished: {0}", obj.Url);
return(await _httpTransferService.GetResult(result, downloadConfig));
}
}
catch (HttpRequestException ex)
{
Debug.WriteLine("Warning - HttpRequestException encountered: {0}", ex.Message);
return(_httpTransferService.GetExceptionResult(ex,
"XamlingCore.Portable.Net.Downloaders.HttpClientDownloader", downloadConfig));
}
catch (Exception ex)
{
Debug.WriteLine("Warning - general HTTP exception encountered: {0}", ex.Message);
return(_httpTransferService.GetExceptionResult(ex,
"XamlingCore.Portable.Net.Downloaders.HttpClientDownloader", downloadConfig));
}
}
}
}
public static string GetRequest(string link, Dictionary <string, string> header = null, bool verbose = false, bool databyte = false, bool autoredirect = true, WebProxy proxy = null)
{
try
{
_clearCookies = false;
if (header != null)
{
foreach (var entry in header)
{
if (entry.Key == "Cookie")
{
_clearCookies = true;
CookieContainer.SetCookies(new Uri(link), entry.Value.Replace(";", ","));
}
}
}
HttpClientHandler handler = null;
if (link.IndexOf("https://") == 0)
{
handler = new NativeMessageHandler()
{
AllowAutoRedirect = autoredirect
}
}
;
else
{
handler = new HttpClientHandler()
{
AllowAutoRedirect = autoredirect
}
};
SetHandler(handler);
using (var httpClient = new HttpClient(handler))
{
AddHeader(httpClient, header);
var response = httpClient.GetAsync(link).Result;
if (_clearCookies)
{
var cookies = handler.CookieContainer.GetCookies(new Uri(link));
foreach (Cookie co in cookies)
{
co.Expires = DateTime.Now.Subtract(TimeSpan.FromDays(1));
}
}
//return response.ToString();
Console.WriteLine("HEADS");
if (verbose)
{
string sh = "";
try
{
var headers = response.Headers.Concat(response.Content.Headers);
foreach (var i in headers)
{
foreach (var j in i.Value)
{
Console.WriteLine(i.Key + ": " + j);
sh += i.Key + ": " + j + "\n";
}
}
}
catch (Exception e)
{
Console.WriteLine("Err get headers: " + e.ToString());
}
return(string.Format("{0}\n{1}", sh, ReadContext(response.Content)));
}
else
{
return(ReadContext(response.Content, databyte));
}
}
}
catch (Exception ex)
{
Console.WriteLine("HttpUtility->GetRequest: " + ex.ToString());
return(ex.Message);
}
}
public static string PostRequest(string link, string data,
Dictionary <string, string> header = null, bool verbose = false, bool autoredirect = true, WebProxy proxy = null)
{
try
{
_clearCookies = false;
if (header != null)
{
foreach (var entry in header)
{
if (entry.Key == "Cookie")
{
_clearCookies = true;
CookieContainer.SetCookies(new Uri(link), entry.Value.Replace(";", ","));
}
}
}
HttpClientHandler handler = null;
if (link.IndexOf("https://") == 0)
{
handler = new NativeMessageHandler()
{
AllowAutoRedirect = autoredirect
}
}
;
else
{
handler = new HttpClientHandler()
{
AllowAutoRedirect = autoredirect
}
};
if (proxy != null)
{
handler.Proxy = proxy;
}
SetHandler(handler);
using (var httpClient = new HttpClient(handler))
{
AddHeader(httpClient, header);
var response = httpClient.PostAsync(link, new StringContent(data, Encoding.UTF8, "application/x-www-form-urlencoded")).Result;
if (_clearCookies)
{
var cookies = handler.CookieContainer.GetCookies(new Uri(link));
foreach (Cookie co in cookies)
{
co.Expires = DateTime.Now.Subtract(TimeSpan.FromDays(1));
}
}
if (verbose)
{
var headers = response.Headers.Concat(response.Content.Headers);
string sh = "";
foreach (var i in headers)
{
foreach (var j in i.Value)
{
Console.WriteLine(i.Key + ": " + j);
sh += i.Key + ": " + j + "\n";
}
}
return(string.Format("{0}\n{1}", sh, ReadContext(response.Content)));
}
else
{
return(ReadContext(response.Content));
}
}
}
catch (Exception ex)
{
return(ex.Message);
}
}
async void Button_Clicked(System.Object sender, System.EventArgs e)
{
if (ExamType.SelectedIndex == -1)
{
DependencyService.Get <IMessage>().ShortAlert("Select a Type of Exam !");
return;
}
if (Convert.ToInt32(mark.Text) <= 0)
{
DependencyService.Get <IMessage>().ShortAlert("Enter Mark Of Exam");
mark.Focus();
return;
}
if (Hour.Text == "" || Hour.Text == null)
{
DependencyService.Get <IMessage>().ShortAlert("Enter Duration Of The Exam !");
Hour.Focus();
return;
}
if (Detail.Text == "" || Detail.Text == null)
{
DependencyService.Get <IMessage>().ShortAlert("Enter Detail Of The Exam !");
Detail.Focus();
return;
}
if (dt_selectQ.Rows.Count == 0)
{
DependencyService.Get <IMessage>().ShortAlert("Select Question From QuestionBank!");
return;
}
var action = await DisplayAlert("Online Examination", "Add New Exam" + " ? ", "Yes", "No");
if (action)
{
saveBut.IsEnabled = false;
var current = Connectivity.NetworkAccess;
if (current == NetworkAccess.Internet)
{
if (CrossConnectivity.Current.IsConnected)
{
try
{
NativeMessageHandler ttk = new NativeMessageHandler {
UseProxy = false
};
HttpClient _client = new HttpClient(ttk);
_client.Timeout = TimeSpan.FromMilliseconds(60000);
string dtt = dateExam.Date.Year.ToString() + "-" + dateExam.Date.Month.ToString() + "-" + dateExam.Date.Day.ToString();
string cont = "?mark=" + mark.Text + "&q_type=" + ExamType.SelectedIndex.ToString() + "&Des=" + Detail.Text + "&hour=" + Hour.Text + "&dat=" + dtt + "&tim=" + timeExam.Time + "&course_id=" + Course.course_id;
string Url = "https://onlineexamination.a2hosted.com/OnlineExamination/insert_Exam.php" + cont;
DataRow[] fr2 = dt_selectQ.Select();
List <SaveAnswer> list = new List <SaveAnswer> {
};
for (int i = 0; i < fr2.Length; i++)
{
list.Add(new SaveAnswer
{
QId = fr2[i]["q_id"].ToString(),
});
}
var myContent = JsonConvert.SerializeObject(list);
_client.DefaultRequestHeaders.Clear();
_client.DefaultRequestHeaders.Add("Accept", "application/json;charset=utf-8");
_client.DefaultRequestHeaders.Add("Accept-Language", "ar");
var request = new HttpRequestMessage()
{
RequestUri = new Uri(Url),
Method = HttpMethod.Post,
};
request.Content = new StringContent(myContent, Encoding.UTF8, "application/json");//CONTENT-TYPE header
var resp = await _client.SendAsync(request);
if (resp.IsSuccessStatusCode)
{
string ddt = dtt.ToString() + " Time : " + timeExam.Time.ToString();
send_nav(Course.course_name, ddt);
await Shell.Current.Navigation.PopAsync();
}
else
{
DependencyService.Get <IMessage>().ShortAlert("تأكد من الاتصال بالانترنت");
}
}
catch (Exception er)
{
string tt = er.Message;
}
}
else
{
DependencyService.Get <IMessage>().ShortAlert("تأكد من الاتصال بالانترنت");
}
}
else
{
DependencyService.Get <IMessage>().ShortAlert("تأكد من الاتصال بالانترنت");
}
saveBut.IsEnabled = true;
}
}
public static async Task <ApiResponse> ExecuteCommand(ApiCommand command, string[] pars)
{
var response = new ApiResponse();
ReqLog.Add(response);
// Get command string from commsnd's attribute
var apiAttr = command.GetAttribute <ApiCommandAttribute>();
if (apiAttr.ParamCount != pars.Length)
{
response.ErrorMessage = "Ошибка формирования запроса к серверу.";
return(response);
}
string url = API_URL;
response.Request = url + string.Format(apiAttr.FormatString, pars);
while (isBusy)
{
await Task.Delay(200);
}
try
{
isBusy = true;
if (HttpClient == null)
{
httpCookieHandler = new NativeCookieHandler();
httpMessageHandler = new NativeMessageHandler(true, false, httpCookieHandler);
httpMessageHandler.ClientCertificateOptions = ClientCertificateOption.Automatic;
HttpClient = new HttpClient(httpMessageHandler, false);
}
try
{
Debug.WriteLine("Request: {0}", response.Request);
var res = await HttpClient.GetAsync(response.Request).ConfigureAwait(false);
Debug.WriteLine("Read content");
response.Response = await res.Content.ReadAsStringAsync().ConfigureAwait(false);
//response.response = await httpClient.GetStringAsync(response.request);
Debug.WriteLine("Response: {0}", response.Response);
// Обработка напильником, блять!
//response.response = response.response.Replace("\"vUser\":[],", string.Empty);
if (string.IsNullOrEmpty(response.Response))
{
response.ErrorMessage = "Сервер не отвечает, попробуйте повторить позже";
return(response);
}
response.RequestDone = true;
}
catch (Exception e)
{
response.BoolResult = false;
response.ErrorMessage = "Ошибка отправки запроса на сервер " + Environment.NewLine + e.Message;
//GoogleAnalyticsHelper.SendException("MFService:ExecuteCommand " + e.Message, false);
return(response);
}
try
{
long x = 0;
JsonConvert.PopulateObject(response.Response, response);
response.BoolResult = response?.Result?.ToUpper() == "TRUE" || response?.Result?.ToUpper() == "OK";
if (!response.BoolResult)
{
if (!string.IsNullOrEmpty(response.Error))
{
response.ErrorMessage = response.Error;
}
else if (string.IsNullOrEmpty(response.ErrorMessage))
{
response.ErrorMessage = "Запрос к серверу вернул отрицательный результат";
}
}
return(response);
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
response.BoolResult = false;
response.ErrorMessage = "Ошибка при разборе ответа от сервера";
//GoogleAnalyticsHelper.SendException("MFService:ExecuteCommand " + e.Message, false);
return(response);
}
}
finally
{
isBusy = false;
}
}
protected async Task ExecuteLoginCommand()
{
Error = string.Empty;
if (Username.Equals(string.Empty) || Password.Equals(string.Empty))
{
Error = Settings.MSG_EMPTY_USERNAME_OR_PWD;
return;
}
if (isLoading)
{
return;
}
IsLoading = true;
Info = "We're processing...";
Settings.UseTreeMenu = UseTreeMenu;
try {
var content = new FormUrlEncodedContent(new[] {
new KeyValuePair <string, string> (Settings.WP_USERNAME_FIELD, Username),
new KeyValuePair <string, string> (Settings.WP_PWD_FIELD, Password)
});
NativeCookieHandler cookieHandler = Settings.mNativeCookieHandler; //new NativeCookieHandler ();
NativeMessageHandler handler = new NativeMessageHandler(true, true, cookieHandler)
{
UseCookies = true,
};
handler.AllowAutoRedirect = false;
HttpClient client = new HttpClient(handler);
HttpResponseMessage response = await client.PostAsync(Settings.LoginUrl, content);
if (response.StatusCode == HttpStatusCode.Redirect)
{
Debug.WriteLine("Redirect: " + response.ToString());
Settings.wpLoggedIn = true;
Settings.wpUsername = Username;
Settings.wpPassword = Password;
}
else
{
string resultContent = await response.Content.ReadAsStringAsync();
response.EnsureSuccessStatusCode();
string responseUri = response.RequestMessage.RequestUri.ToString();
Debug.WriteLine(responseUri);
Debug.WriteLine(resultContent);
if (Settings.LoginUrl.ToLower().Equals(responseUri.ToLower()))
{
//login failed
Error = Settings.MSG_INVALID_USERNAME_OR_PWD;
}
else
{
Settings.wpLoggedIn = true;
Settings.wpUsername = Username;
Settings.wpPassword = Password;
}
}
if (Settings.wpLoggedIn)
{
if (Settings.CHECK_UPDATE)
{
var buildDetail = Mvx.Resolve <IBuildDetails>();
var respUpdate = await Service.GetUpdate(new RequestUpdate(buildDetail.OS, buildDetail.VersionCode));
if (respUpdate.Update_info != null)
{
Settings.UpdateInfo = respUpdate;
IsLoading = false;
return;
}
System.Diagnostics.Debug.WriteLine("Build detail os={0} version_code={1}", buildDetail.OS, buildDetail.VersionCode);
}
//go to profile to get more cookies
response = await client.GetAsync(Settings.ProfileUrl);
//get user info and gen cookie for json api auth controller
var retAuth = await Service.GenrateAuthCookie();
if (retAuth != null)
{
Settings.WP_AuthCookie = retAuth;
}
else
{
Settings.WP_AuthCookie = null;
}
}
} catch (Exception e) {
Error = Settings.MSG_NETWORK_COMMON;
#if DEBUG
System.Diagnostics.Debug.WriteLine("Login Error: " + e.Message);
Error += e.ToString();
#endif
}
Info = string.Empty;
IsLoading = false;
}
void Awake()
{
Singleton = this;
}
private static async Task <T> ProcessRequestAsync <T>(string url, HttpContent postData
, List <KeyValuePair <string, IEnumerable <string> > > headers, string errorMessage)
{
using (var handler = new NativeMessageHandler())
{
//if (handler.SupportsAutomaticDecompression)
// handler.AutomaticDecompression = DecompressionMethods.Deflate;
using (var httpClient = new HttpClient(handler))
{
using (var message = new HttpRequestMessage())
{
message.RequestUri = new Uri(url);
message.Method = postData == null ? HttpMethod.Get : HttpMethod.Post;
if (postData != null)
{
if (postData.ReadAsStringAsync().Result != "")
{
message.Content = postData;
}
}
if (headers != null)
{
foreach (KeyValuePair <string, IEnumerable <string> > header in headers)
{
message.Headers.Add(header.Key, header.Value);
}
}
string data = "";
try
{
var response = await httpClient.SendAsync(message);
data = await response.Content.ReadAsStringAsync();
}
catch (Exception)
{
throw new Exception(errorMessage);
}
if (!string.IsNullOrEmpty(data))
{
try
{
return(JsonConvert.DeserializeObject <T>(data));
}
catch (Exception)
{
throw new Exception(errorMessage);
}
}
else
{
throw new Exception(errorMessage);
}
}
}
}
throw new Exception(errorMessage);
}
