/// <summary>
/// Navigates to a root page of the app.
/// </summary>
/// <returns></returns>
public async Task GoToRootPage()
{
try
{
if (!Connectivity.CheckConnectionAndDisplayToast())
{
return;
}
if (App.NavPage.CurrentPage.GetType() ==
App.NavPage.Navigation.NavigationStack.FirstOrDefault()?.GetType())
{
App.MenuPage.IsPresented = false;
return;
}
App.UpdateLoading(true);
await Task.Delay(500);
await App.NavPage.Navigation.PopToRootAsync();
App.MenuPage.IsPresented = false;
}
catch (Exception e)
{
// ignored
}
finally
{
App.UpdateLoading(false);
}
}
/// <summary>
/// Navigates to a new page.
/// </summary>
/// <param name="page">
/// Page should be initialized e.g. new CustomPage()
/// </param>
/// <returns></returns>
public async Task GoToPage(Page page)
{
try
{
if (!Connectivity.CheckConnectionAndDisplayToast())
{
return;
}
if (App.NavPage.CurrentPage.GetType() == page.GetType())
{
App.MenuPage.IsPresented = false;
return;
}
App.InstantiatingPageType = page.GetType();
App.UpdateLoading(true);
await Task.Delay(500);
await App.NavPage.Navigation.PushAsync(page);
App.MenuPage.IsPresented = false;
}
catch (Exception e)
{
// ignored
}
finally
{
App.UpdateLoading(false);
}
}
public void Disconnect(Tile a, Tile b, Connectivity connection)
{
Connectivity rotated = connection.Rotate(4);
a.Connectivity &= ~connection;
b.Connectivity &= ~rotated;
}
void CrossConnectivity_Current_ConnectivityChanged (object sender, Connectivity.Plugin.Abstractions.ConnectivityChangedEventArgs e)
{
InvokeOnMainThread(() =>
{
new UIAlertView("status", "Connected: " + e.IsConnected + " Connected: " + CrossConnectivity.Current.IsConnected, null, "OK").Show();
});
}
private async void btnEditTraining_Clicked(object sender, EventArgs e)
{
await Connectivity.DoIfConnectedAndReachable(async() =>
{
await Navigation.PushAsync(new EditSelectedTrainingPage(BindingContext as TrainingsViewModel));
});
}
public async void SubmitPartnerToServer(object sender, EventArgs e)
{
WaitToggle(false);
await Task.Delay(100);
var SaveResult = await SavePartner();
if (!SaveResult.Success)
{
WaitToggle(false);
App.ShowError("خطا", SaveResult.Message, "خوب");
}
else
{
var submitResult = await Connectivity.SubmitPartnersAsync(new Partner[] { SaveResult.Data });
if (!submitResult.Success)
{
WaitToggle(false);
App.ShowError("خطا", "اطلاعات مشتری به صورت محلی ثبت شد اما در ارسال اطلاعات به سرور خطایی رخ داده است: " + submitResult.Message, "خوب");
}
else
{
WaitToggle(true);
App.ToastMessageHandler.ShowMessage("اطلاعات مشتری با موفقیت به سرور ارسال شد.", Helpers.ToastMessageDuration.Long);
try { await Navigation.PopAsync(); } catch (Exception) { }
}
}
}
private void GetAllCourses()
{
string selectQuery = string.Format("SELECT name,code,credits,aps,faculty FROM Course");
try
{
using (SqlConnection conn = new SqlConnection(Connectivity.ConnectionString()))
{
using (SqlCommand command = new SqlCommand(selectQuery, conn))
{
command.CommandType = CommandType.Text;
DataTable dt = new DataTable();
conn.Open();
SqlDataReader sdr = command.ExecuteReader();
dt.Load(sdr);
conn.Close();
ViewCourseDataGridView.DataSource = dt;
}
}
}
catch (Exception ex)
{
Essentials.SetErrorMessage(ex.Message, "Error");
}
}
private async void tbItemAdministrateLocations_Clicked(object sender, EventArgs e)
{
await Connectivity.DoIfConnectedAndReachable(async() =>
{
await Navigation.PushAsync(new EditLocationsPage());
});
}
private async void tbItemAdministrateAccount_Clicked(object sender, EventArgs e)
{
await Connectivity.DoIfConnectedAndReachable(async() =>
{
await Navigation.PushAsync(new PlayerAccountPage());
});
}
public void Connect(Tile a, Tile b, Connectivity connection)
{
Connectivity rotated = connection.Rotate(4);
a.Connectivity |= connection;
b.Connectivity |= rotated;
}
/// <summary>
/// Navigates to a page with side menu. OwnerMenu page content is defined in OwnerMenu.xaml.
/// </summary>
/// <param name="page">
/// Page should be initialized e.g. new CustomPage() and this page represents Detail.
/// </param>
/// <param name="userType">
/// Type of user (Owner or Washer)
/// </param>
/// <returns></returns>
public async Task GoToMasterRootPage(Page page, UserTypeViewModel.UserTypeOf userType)
{
try
{
if (!Connectivity.CheckConnectionAndDisplayToast())
{
return;
}
App.InstantiatingPageType = page.GetType();
App.UpdateLoading(true);
await Task.Delay(500);
App.NavPage = new NavigationPage(page);
App.MenuPage = userType == UserTypeViewModel.UserTypeOf.Owner
? (MasterDetailPage) new OwnerMenu()
{
Detail = App.NavPage
}
: (MasterDetailPage) new WasherMenu()
{
Detail = App.NavPage
}; // TODO: add WasherMenu
Application.Current.MainPage = App.MenuPage;
}
catch (Exception e)
{
// ignored
}
finally
{
App.UpdateLoading(false);
}
}
private void btnSave_Click(object sender, EventArgs e)
{
const string updateQuery = "Update ApplicationInfotbl SET role=@role,appStatus=@appStatus WHERE name=@name";
try
{
using (SqlConnection conn = new SqlConnection(Connectivity.ConnectionString()))
{
using (SqlCommand command = new SqlCommand(updateQuery, conn))
{
command.CommandType = CommandType.Text;
command.Parameters.AddWithValue("@role", GetRole());
command.Parameters.AddWithValue("@appStatus", GetAdmissionStatus());
command.Parameters.AddWithValue("@name", cboUsers.Text);
conn.Open();
command.ExecuteNonQuery();
conn.Close();
Essentials.DisplayMessage("role changed successfully", "Roles");
Essentials.ResetControls(rdoAdmin, rdoNoAccess, rdoStudent);
}
}
}catch (Exception ex)
{
Essentials.SetErrorMessage(ex.Message, "Role Update Error");
}
}
private async Task btnAddGoalOpponent_Clicked(object sender, EventArgs e)
{
await Connectivity.DoIfConnectedAndReachable(async() =>
{
await Navigation.PushAsync(new EditOpponentScorePage(BindingContext as MatchesViewModel));
});
}
public bool OnInfo(MediaPlayer mp, MediaInfo what, int extra)
{
if ((int)what == 703 && extra == 0)
{
if (MediaPlayer == null)
{
Play();
}
else
{
if (MediaPlayer.IsPlaying)
{
if (!Connectivity.IsConnected(ApplicationContext))
{
HandleError();
}
}
else
{
Play();
}
}
return(true);
}
return(false);
}
public async Task <User> GetCurrentUser()
{
if (await Connectivity.IsRemoteReachable("https://www.google.com"))
{
if (Settings.TimeSecondsOffline != 0)
{
var isupdated = await MeditationStore.AddMeditationTimeAsync(Settings.TimeSecondsOffline);
if (isupdated)
{
Settings.TimeSecondsOffline = 0;
}
}
var item = await GetItemAsync("me");
if (item != null)
{
Settings.User = JsonConvert.SerializeObject(item);
}
return(item);
}
else
{
var user = getUser();
return(user);
}
}
public static void Main()
{
//CREATE TABLE
//connectivity = new Connectivity(query: "CREATE TABLE TEMPORARY(ID INT, NAME VARCHAR(100))", commandType: CommandType.Command.CREATE);
//connectivity.ExecuteQuery();
//INSERT DATA INTO TABLE
//connectivity = new Connectivity(query: "INSERT INTO TEMPORARY VALUES(9,'Pooja Sarwani');", commandType: CommandType.Command.INSERT);
//connectivity.ExecuteQuery();
//Getting The Data
connectivity = new Connectivity(query: "SELECT * FROM TEMPORARY", commandType: CommandType.Command.SELECT);
connectivity.ExecuteQuery();
var result = connectivity.OutputForSelect;
Console.WriteLine("Result:\n" + result);
//Deleting the data
//connectivity = new Connectivity(query: "DELETE FROM TEMPORARY WHERE ID=9", commandType: CommandType.Command.DELETE);
//connectivity.ExecuteQuery();
//SELECT BY DATA SET
connectivity = new Connectivity(query: "", commandType: CommandType.Command.SELECTDATASET);
connectivity.ExecuteQuery();
Experiment exp = new Experiment(connectivity.returnData);
exp.Show();
Console.ReadKey();
}
internal static async void GetProfileListAsync()
{
var list = await ConnectionProfileManager.GetProfileListAsync(ProfileListType.Connected);
profiles.Clear();
foreach (var result in list)
{
switch (result.Type)
{
case ConnectionProfileType.Bt:
profiles.Add(ConnectionProfile.Bluetooth);
break;
case ConnectionProfileType.Cellular:
profiles.Add(ConnectionProfile.Cellular);
break;
case ConnectionProfileType.Ethernet:
profiles.Add(ConnectionProfile.Ethernet);
break;
case ConnectionProfileType.WiFi:
profiles.Add(ConnectionProfile.WiFi);
break;
}
}
Connectivity.OnConnectivityChanged();
}
private async void ToolbarItem_Backup_Activated(object sender, EventArgs e)
{
OperationInProgress = true;
RefreshToolbarItems();
UploadingBackup = new BackupModel()
{
ProgressPercent = 0
};
var newList = new List <BackupModel> {
UploadingBackup
};
newList.AddRange(Backups.ToList());
Backups = new ObservableCollection <BackupModel>(newList);
BackupsList.ItemsSource = null;
BackupsList.ItemsSource = Backups;
var result = await Connectivity.UploadBackupToServerAsync(new UploadFileCompleted(UploadFileCompleted), new UploadProgressChanged(UploadProgressChanged));
if (!result.Success)
{
App.ShowError("خطا", result.Message, "خوب");
}
Backups = new ObservableCollection <BackupModel>(Backups.ToList().Union(new BackupModel[] { UploadingBackup }));
UploadingBackup = null;
BackupsList.ItemsSource = null;
BackupsList.ItemsSource = Backups;
OperationInProgress = false;
BackupsList_Refreshing(null, null);
App.ToastMessageHandler.ShowMessage("پشتیبان اطلاعات با موفقیت به سرور ارسال شد.", ToastMessageDuration.Long);
}
public void InsertData()
{
using (SqlConnection connection = new SqlConnection(Connectivity.ConnectionString()))
{
using (SqlCommand cmd = new SqlCommand("sp_AddCourse", connection))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@courseName", name);
cmd.Parameters.AddWithValue("@courseCode", code);
cmd.Parameters.AddWithValue("@credits", credits);
cmd.Parameters.AddWithValue("@faculty", getFaculty);
cmd.Parameters.AddWithValue("@description", description);
cmd.Parameters.AddWithValue("@dateOfAddition", date);
cmd.Parameters.AddWithValue("@courseAps", courseAps);
connection.Open();
cmd.ExecuteNonQuery();
Essentials.DisplayMessage("Course Successfully Added", "Course Addition");
Essentials.ResetControls(edtAPSPoint, edtCourseCode, edtCourseName, edtCredits, txtBoxDescribtion);
connection.Close();
}
}
}
async void SendPointsToServer()
{
try
{
var UnsentLocations = App.DB.conn.Table <LocationModel>().Where(a => !a.SentToApplication)
.OrderBy(a => a.Timestamp).ToList().Take(100).ToArray();
if (UnsentLocations.Count() >= 5)
{
var result = await Connectivity.SubmitLocationsAsync(UnsentLocations);
if (result.Success)
{
foreach (var item in UnsentLocations)
{
item.SentToApplication = true;
}
await App.DB.InsertOrUpdateAllRecordsAsync(UnsentLocations);
}
else
{
throw new Exception(result.Message);
}
}
}
catch (Exception err)
{
Log.Error("Kara Tracking Service", "exception: " + err.Message + ", StackTrace: " + (err.StackTrace == null ? "---" : err.StackTrace));
}
}
private async void ToolbarItem_SendToServer_Activated(object sender, EventArgs e)
{
var SelectedPartners = MultiSelectionMode ? PartnersList.Where(a => a.Selected).ToArray() : new DBRepository.PartnerListModel[] { LastSelectedPartner };
if (SelectedPartners.Length == 0)
{
App.ShowError("خطا", "هیچ مشتری انتخاب نشده است.", "خوب");
return;
}
WaitToggle(false);
var submitResult = await Connectivity.SubmitPartnersAsync(SelectedPartners.Select(a => a.PartnerData).ToArray());
if (!submitResult.Success)
{
WaitToggle(false);
App.ShowError("خطا", submitResult.Message, "خوب");
if (submitResult.Data != 0)
{
ExitMultiSelectionMode();
FillPartners(VisitsSearchBar.Text);
InsertedInformations.Partners.FillPartners();
}
}
else
{
ExitMultiSelectionMode();
WaitToggle(true);
FillPartners(VisitsSearchBar.Text);
InsertedInformations.Partners.FillPartners();
}
}
void HandleConnectivityChanged (object sender, Connectivity.Plugin.Abstractions.ConnectivityChangedEventArgs e)
{
Type currentPage = this.MainPage.GetType();
if (e.IsConnected && currentPage != typeof(NetworkViewPage))
this.MainPage = new NetworkViewPage();
else if (!e.IsConnected && currentPage != typeof(NoNetworkPage))
this.MainPage = new NoNetworkPage();
}
public IContact CreateContact(IModelSend modelSend)
{
var sender = Connectivity.GetInstance().GetCurrent().IsConnected
? GetConnection(modelSend.TypeMarker)
: new ConnectSender();
var contactTable = new Contact(sender);
return(contactTable);
}
private static async void OnTimerCallback(object state)
{
if (!await Connectivity.IsInternetAvailable())
{
cancellationTokenSource.Cancel();
if (cancellationTokenSource.IsCancellationRequested)
{
timer?.Change(Timeout.Infinite, Timeout.Infinite);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ConnectivityViewModel"/> class.
/// </summary>
public ConnectivityViewModel(IConnectivity connectivity)
{
_connectivity = connectivity;
_hostScreen = Locator.Current.GetService <IScreen>();
ConnectionInteraction = new Interaction <string, bool>();
Connectivity.Subscribe(_ =>
ConnectionInteraction
.Handle($"Connectivity Changed: {_.NetworkAccess}")
.Subscribe());
}
void CrossConnectivity_Current_ConnectivityChanged(object sender, Connectivity.Plugin.Abstractions.ConnectivityChangedEventArgs e)
{
if (e.IsConnected)
{
MainPage = new NetworkViewPage();
}
else
{
MainPage = new NoNetworkPage();
}
}
private void ExportXml(XmlWriter writer, List <string> tablenames, SqlSelectDelegate sqlSelect, MetadataSelectDelegate metaSelect, bool encryptPatientId)
{
List <string> expandedTablenames = ExpandAndSortTablenames(tablenames);
using (SqlConnection connection = Connectivity.GetConnection())
{
connection.Open();
writer.WriteStartDocument();
writer.WriteStartElement("data");
int userExportId = (int)userExport[UserExport.UserExportId];
StringBuilder comment = new StringBuilder(" UserExportId = ");
comment.Append(userExportId.ToString());
comment.Append(" ");
writer.WriteComment(comment.ToString());
foreach (string tablename in expandedTablenames)
{
if (HasLookupTable(tablename))
{
SqlCommand lookupCmd = new SqlCommand(GetLookupSql(tablename, userExportId, connection), connection);
using (SqlDataReader r = lookupCmd.ExecuteReader())
{
WriteXml(r, writer, GetLookupTablename(tablename), encryptPatientId);
}
}
SqlCommand cmd = new SqlCommand(sqlSelect(tablename, connection), connection);
// TODO: fix command; can we validate a command with the server?
using (SqlDataReader reader = cmd.ExecuteReader())
{
WriteXml(reader, writer, tablename, encryptPatientId);
}
}
ExportEntireTable("MetaDataTables", connection, writer);
ExportEntireTable("MetaDataFields", connection, writer);
SqlCommand metaCmd = new SqlCommand(metaSelect(expandedTablenames), connection);
using (SqlDataReader metaReader = metaCmd.ExecuteReader())
{
WriteXml(metaReader, writer, "MetaDataFieldValues", encryptPatientId);
}
writer.WriteEndElement();
writer.WriteEndDocument();
}
}
private static Connectivity GetNetworkConnectivity(Context context)
{
var connectivityManager = (ConnectivityManager)context.GetSystemService(Context.ConnectivityService);
var activeNetwork = connectivityManager.ActiveNetworkInfo;
if (activeNetwork != null && activeNetwork.IsConnected)
{
return(Connectivity.FromNetworkType((int)activeNetwork.Type));
}
return(Connectivity.Offline);
}
public static int GetLoginInfo(Models.Login login)
{
SqlConnection Connection = Connectivity.getConnection();
SqlCommand ac = new SqlCommand();
ac.Connection = Connection;
ac.CommandType = System.Data.CommandType.Text;
ac.CommandText = "Select count(*) from Login Where username = @username and [Password] = @password";
ac.Parameters.Add(new SqlParameter("@username", login.UserName));
ac.Parameters.Add(new SqlParameter("@password", login.PassWord));
return(Convert.ToInt32(ac.ExecuteScalar()));
}
public override async void OnNavigatedTo(NavigationParameters parameters)
{
base.OnNavigatedTo(parameters);
while (!Connectivity.IsConnected())
{
await _dialogService.DisplayAlertAsync("Connection issue", "Please check the Internet connection", "Ok");
}
await Navigate(NavigationMap.EntryPoint);
}
private bool FeedDataVideoFUA(Stream pData, uint dataLength, uint processedLength, uint totalLength, uint absoluteTimestamp)
{
uint sentAmount = 0;
while (sentAmount != dataLength)
{
var chunkSize = dataLength - sentAmount;
chunkSize = chunkSize < _maxRTPPacketSize ? chunkSize : _maxRTPPacketSize;
//1. Flags
_videoData.Buffers[0][1] = processedLength + sentAmount + chunkSize == totalLength ?(byte)0xe1 : (byte)0x61;
//2. counter
_videoData.Buffers[0].Write(2, _videoCounter);
_videoCounter++;
//3. Timestamp
_videoData.Buffers[0].Write(4, BaseConnectivity.ToRTPTS(absoluteTimestamp, 90000));
if (chunkSize == totalLength)
{
//4. No chunking
Array.Resize(ref _videoData.Buffers[0], 12);
Array.Resize(ref _videoData.Buffers[1], (int)chunkSize);
pData.Read(_videoData.Buffers[1], 0, (int)chunkSize);
}
else
{
//5. Chunking
Array.Resize(ref _videoData.Buffers[0], 14);
if (processedLength + sentAmount == 0)
{
//6. First chunk
var firstByte = (byte)pData.ReadByte();
_videoData.Buffers[0][12] = (byte)(firstByte & 0xe0 | (byte)NaluType.NALU_TYPE_FUA);
_videoData.Buffers[0][13] = (byte)(firstByte & 0x1f | 0x80);
Array.Resize(ref _videoData.Buffers[1], (int)chunkSize - 1);
pData.Read(_videoData.Buffers[1], 0, (int)chunkSize - 1);
}
else
{
_videoData.Buffers[0][13] &= 0x1f;
if (processedLength + sentAmount + chunkSize == totalLength)
{
//7. Last chunk
_videoData.Buffers[0][13] |= 0x40;
}
Array.Resize(ref _videoData.Buffers[1], (int)chunkSize);
pData.Read(_videoData.Buffers[1], 0, (int)chunkSize);
}
}
Connectivity.FeedVideoData(ref _videoData, absoluteTimestamp);
sentAmount += chunkSize;
}
return(true);
}
private async void EditInfo_Tapped(object sender, EventArgs e)
{
await Connectivity.DoIfConnectedAndReachable(async() =>
{
var img = sender as Image;
var info = img.BindingContext as Info;
var infoViewModel = this.BindingContext as InfoViewModel;
infoViewModel.SelectedInfo = info;
await Navigation.PushAsync(new EditSelectedInfoPage(infoViewModel));
});
}
private void TimerElapsed(object sender, ElapsedEventArgs e)
{
try
{
if (!Connectivity.IsConnected())
{
ProcessCommand(ShutdownType);
//to avoid error or non-shutdown/restart/log off operation
OnCancel();
}
}
catch { }
}
public Link Build(string firstAnchor, string secondAnchor, Connectivity connectivity)
{
var link = this.Build(new List<string>() { firstAnchor, secondAnchor });
link.UniqueKeys = new List<TSqlColumnList>();
switch (connectivity)
{
case Connectivity.OneToOne:
link.UniqueKeys.Add(new TSqlColumnList() { link.ForeignKeys[0], link.DateKey });
link.UniqueKeys.Add(new TSqlColumnList() { link.ForeignKeys[1], link.DateKey });
break;
case Connectivity.OneToMany:
link.UniqueKeys.Add(new TSqlColumnList()
{
link.ForeignKeys[0]
, link.DateKey
});
break;
case Connectivity.ManyToOne:
link.UniqueKeys.Add(new TSqlColumnList()
{
link.ForeignKeys[1]
, link.DateKey
});
break;
case Connectivity.ManyToMany:
link.UniqueKeys.Add(new TSqlColumnList()
{
link.ForeignKeys[0]
, link.ForeignKeys[1]
, link.DateKey
});
break;
default:
break;
}
return link;
}
public static extern int imaqMorphologyReconstruct(IntPtr dstImage, IntPtr srcImage, IntPtr markerImage, ref PointFloat points, int numOfPoints, MorphologyReconstructOperation operation, Connectivity connectivity, ref ROI roi);
private void OnConnectionStatusChanged (object sender, Connectivity.Plugin.Abstractions.ConnectivityChangedEventArgs e)
{
HasInternetConnection = e.IsConnected;
if (HasInternetConnection) {
_notificator.Notify (ToastNotificationType.Success, "Интернет соединение доступно", "Приложение работает с актиальными данными", TimeSpan.FromSeconds (1));
} else {
_notificator.Notify (ToastNotificationType.Error, "Интернет соединение отключено", "Приложение работает с кешем", TimeSpan.FromSeconds (1));
}
}
void HandleConnectivityChanged(object sender, Connectivity.Plugin.Abstractions.ConnectivityChangedEventArgs e)
{
App.IsConnected = e.IsConnected;
}
protected override void handleNetworkConnectionChanged(object sender, Connectivity.Plugin.Abstractions.ConnectivityChangedEventArgs e)
{
base.handleNetworkConnectionChanged(sender, e);
if (e.IsConnected)
{
this.ReloadCommand.Execute(null);
}
}
void CrossConnectivity_Current_ConnectivityChanged(object sender, Connectivity.Plugin.Abstractions.ConnectivityChangedEventArgs e)
{
UpdateNetworkInfo();
}
