private void Call(Agent obj)
{
try
{
try
{
PhoneDialer.Open("0799710919");
}
catch (ArgumentNullException anEx)
{
// Number was null or white space
}
catch (FeatureNotSupportedException ex)
{
// Phone Dialer is not supported on this device.
}
catch (Exception ex)
{
// Other error has occurred.
}
}
catch (Exception)
{
}
}
public PlacePhoneCallStatus PlacePhoneCall(string phoneNumber)
{
if (string.IsNullOrWhiteSpace(phoneNumber))
{
return(PlacePhoneCallStatus.InvalidNumber);
}
var result = PlacePhoneCallStatus.Unknown;
try
{
PhoneDialer.Open(phoneNumber);
result = PlacePhoneCallStatus.Placed;
}
catch (FeatureNotSupportedException ex)
{
Debug.Write(ex);
result = PlacePhoneCallStatus.NotSupported;
}
catch (Exception ex)
{
Debug.Write(ex);
result = PlacePhoneCallStatus.Error;
}
return(result);
}
public PeopleViewModel()
{
People = new ObservableCollection <Person>();
RegisterPageCommand = new Command(async() =>
{
await App.Current.MainPage.Navigation.PushAsync(new RegisterPage(People));
});
DeletePersonCommand = new Command(() =>
{
People.Remove(People.Where(i => i.Name == selectedPerson.Name).Last());
});
MoreCommand = new Command(async() =>
{
var action = await App.Current.MainPage.DisplayActionSheet("", "Cancel", null, "Call " + selectedPerson.PhoneNumber, "Edit");
if (action == $"Call {selectedPerson.PhoneNumber}")
{
PhoneDialer.Open(selectedPerson.PhoneNumber);
}
else if (action == "Edit")
{
var editAction = await App.Current.MainPage.DisplayPromptAsync("Change Number", "Introduce the new number");
var found = People.FirstOrDefault(i => i.PhoneNumber == selectedPerson.PhoneNumber);
int place = People.IndexOf(found);
People[place] = new Person(selectedPerson.Name, editAction);
}
});
}
private async void BtnCall_Clicked(object sender, EventArgs e)
{
if (await this.DisplayAlert(
"Dial a Number",
"Would you like to call " + translatedNumber + "?",
"Yes",
"No"
))
{
try
{
PhoneDialer.Open(translatedNumber);
}
catch (ArgumentNullException)
{
await DisplayAlert("Unable to dial", "Phone number was not valid", "OK");
}
catch (FeatureNotSupportedException)
{
await DisplayAlert("Unable to dial", "Phone dialing is not supported", "OK");
}
catch (Exception)
{
await DisplayAlert("Unable to dial", "Phone dialing failed", "OK");
}
}
}
public async void MoreOptions(Models.Contact selectContact)
{
var selectedAction = await App.Current.MainPage.DisplayActionSheet(null, "Cancel", null, "Call", "Edit");
if (selectedAction == "Cancel")
{
//cancel action
}
else if (selectedAction == "Call")
{
try
{
PhoneDialer.Open(selectContact.Number);
}
catch (ArgumentNullException anEx)
{
// Number was null or white space
await App.Current.MainPage.DisplayAlert("Null", "Number Empty", "Ok");
}
catch (FeatureNotSupportedException ex)
{
// Phone Dialer is not supported on this device.
}
}
else if (selectedAction == "Edit")
{
await App.Current.MainPage.Navigation.PushAsync(new ModifyContactPage(selectContact), false);
}
}
private async void TapPhone_Tapped(object sender, EventArgs e)
{
try
{
var action = await DisplayActionSheet(Property.Vendor.Phone, "Cancel", null, "Call", "SMS");
switch (action)
{
case "Call":
PhoneDialer.Open(Property.Vendor.Phone);
break;
case "SMS":
await Sms.ComposeAsync(new SmsMessage(string.Format("Hej, {0}, angående {1}", Property.Vendor.FirstName, Property.Address), new[] { Property.Vendor.FullName }));
break;
}
}
catch (FeatureNotSupportedException fbsEx)
{
// Email is not supported on this device
}
catch (Exception ex)
{
// Some other exception occurred
}
}
// Dialer Button Handler
private void DialerButton_Clicked(object sender, EventArgs e)
{
var emergencyNum = EmerNum.Text;
if (emergencyNum != null)
{
try
{
PhoneDialer.Open(emergencyNum);
}
catch (ArgumentNullException anEx)
{
anEx.Message.ToString();
}
catch (FeatureNotSupportedException ex)
{
ex.Message.ToString();
}
catch (Exception ex)
{
ex.Message.ToString();
}
}
else
{
DisplayAlert("Error", "No number", "ok");
}
}
private void Phone_Tapped(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(SelectedPhone) && SelectedPhone.Length >= 10)
{
PhoneDialer.Open(SelectedPhone);
}
}
public async Task OpenPhoneDialer(string contactNumber)
{
try
{
PhoneDialer.Open(contactNumber);
}
catch (ArgumentNullException anEx)
{
await App.Current.MainPage.DisplayAlert("Error Occurred",
"Please verify that the contact number is a valid phone number",
"Ok");
}
catch (FeatureNotSupportedException ex)
{
await App.Current.MainPage.DisplayAlert("Error Occurred",
"Cannot Open Phone Dialer on this device, please dial number manually",
"Ok");
}
catch (Exception ex)
{
await App.Current.MainPage.DisplayAlert("Error Occurred",
"Unexpected Error, Please contact administrator",
"Ok");
}
}
public ContactsViewModel()
{
GetContacts();
GoToAddViewCommand = new Command(async() =>
{
await App.Current.MainPage.Navigation.PushAsync(new NewContactView(Contacts));
});
DeleteContactCommand = new Command <Contact>(async(contact) =>
{
await App.ContactDatabase.DeleteContact(contact.Id);
Contacts.Remove(contact);
});
RefreshListCommand = new Command(async() =>
{
Contacts = new ObservableCollection <Contact>(await App.ContactDatabase.GetContactsAsync());
IsRefreshingList = false;
});
DisplayMoreCommand = new Command <Contact>(async(contact) =>
{
var option = await App.Current.MainPage.DisplayActionSheet("More", "Cancel", "Close", $"Call {contact.CellNumber}", "Edit");
switch (option)
{
case "Edit":
await App.Current.MainPage.Navigation.PushAsync(new NewContactView(Contacts, contact));
break;
default:
PhoneDialer.Open(contact.CellNumber);
break;
}
});
}
private void PhoneBtn_Clicked(object sender, EventArgs e)
{
if (NumberPhone != "")
{
PhoneDialer.Open(NumberPhone);
}
}
public async void callAdvisor(object sender, EventArgs args)
{
Debug.WriteLine("Tap registered");
Frame myvar = (Frame)sender;
Person advisor = myvar.BindingContext as Person;
string phoneNumber = advisor.PhoneNumber;
if (phoneNumber == "")
{
await Application.Current.MainPage.DisplayAlert("Sorry!", $"Hmmm... We don't have a phone number on file", "OK");
}
else
{
//Console.WriteLine("ZZZZZZZZZZZZZZZ");
Debug.WriteLine("Manifest.ViewModels.AboutViewModel: Dialing Number:" + phoneNumber);
//Console.WriteLine("ZZZZZZZZZZZZZZZ");
try
{
PhoneDialer.Open(phoneNumber);
Debug.WriteLine("IN ABOUTVIEWMODEL. LAUNCHING PHONE");
}
catch (Exception e)
{
await DisplayAlert("Error", "Unable to perform a phone call", "OK");
}
//await Launcher.OpenAsync(new Uri("tel:" + phoneNumber));
}
}
public void PlacePhoneCall(string number)
{
try
{
PhoneDialer.Open(number);
}
catch (ArgumentNullException anEx)
{
// Number was null or white space.
Console.WriteLine(anEx);
exception.Text = "Number cannot be null or white space";
}
catch (FeatureNotSupportedException ex)
{
// Phone Dialer is not supported on this device.
Console.WriteLine(ex);
exception.Text = "Phone Dialer is not supported on this device";
}
catch (Exception ex)
{
// Other error has occurred.
Console.WriteLine(ex);
exception.Text = "Other error has occurred.";
}
}
async void OnCall(object sender, System.EventArgs e)
{
if (await this.DisplayAlert(
"Marcar Un Numero",
"Quieres LLamar a " + translatedNumber + " ?",
"Yes",
"No"))
{
try
{
PhoneDialer.Open(translatedNumber);
}
catch (ArgumentNullException)
{
await DisplayAlert("No Disponible para marcar", "El numero de telefono no es valido", "OK");
}
catch (FeatureNotSupportedException)
{
await DisplayAlert("No Disponible Para Marcar", "Marcado de telefono no soportada", "OK");
}
catch (Exception)
{
await DisplayAlert("No Disponible para Marcar", "Marcado de telefono con error", "OK");
}
}
}
private async void OnMore(Contact contact)
{
string option = await App.Current.MainPage.DisplayActionSheet(null, "Cancel", null, "Call +" + contact.Number, "Edit");
if (option == "Call +" + contact.Number)
{
try
{
PhoneDialer.Open(contact.Number);
}
catch (Exception)
{
await App.Current.MainPage.DisplayAlert("No se pudo realizar la llamada", "Intentelo mas tarde", "Ok");
}
}
else if (option == "Edit")
{
int newIndex = Contacts.IndexOf(contact);
var result = await App.Current.MainPage.DisplayPromptAsync("Add New Name", "Type Name", "Ok");
var phone = await App.Current.MainPage.DisplayPromptAsync("Add New Number", "Type Number", "Ok");
Contacts.Remove(contact);
Contacts.Add(new Contact(result, phone));
int oldIndex = Contacts.Count - 1;
Contacts.Move(oldIndex, newIndex);
}
}
async void OnCall(object sender, System.EventArgs e)
{
if (await this.DisplayAlert(
"Dial a Number",
"Would you like to call " + translatedNumber + "?",
"Yes",
"No"))
{
try
{
PhoneDialer.Open(translatedNumber);
}
catch (ArgumentNullException)
{
await DisplayAlert("Unable to dial", "Phone number was not valid.", "OK");
}
catch (FeatureNotSupportedException)
{
await DisplayAlert("Unable to dial", "Phone dialing not supported.", "OK");
}
catch (Exception)
{
// Other error has occurred.
await DisplayAlert("Unable to dial", "Phone dialing failed.", "OK");
}
}
}
private async void callPerson(object sender, EventArgs args)
{
Image myvar = (Image)sender;
Person person = myvar.BindingContext as Person;
string phoneNumber = person.PhoneNumber;
if (phoneNumber == "" || phoneNumber == null)
{
await DisplayAlert("Sorry!", $"Hmmm... We don't have a phone number on file", "OK");
}
else
{
//Console.WriteLine("ZZZZZZZZZZZZZZZ");
Debug.WriteLine("Manifest.ViewModels.AboutViewModel: Dialing Number:" + phoneNumber);
//Console.WriteLine("ZZZZZZZZZZZZZZZ");
try
{
PhoneDialer.Open(phoneNumber);
Debug.WriteLine("IN ABOUTVIEWMODEL. LAUNCHING PHONE");
}
catch (Exception e)
{
await DisplayAlert("Error", "Unable to perform a phone call", "OK");
}
//await Launcher.OpenAsync(new Uri("tel:" + phoneNumber));
}
}
private async void UsePhoneAsync(Vendor vendor)
{
try
{
var action = await DialogService.ShowActionSheetAsync(vendor.Phone, "Cancel", null, "Call", "SMS");
if (action == "Call")
{
PhoneDialer.Open(vendor.Phone);
}
else if (action == "SMS")
{
await Sms.ComposeAsync(new SmsMessage
{
Recipients = new List <string> {
vendor.Phone
},
Body = $"Hi {vendor.FirstName}, regarding {Property.Address} "
});
}
}
catch (FeatureNotSupportedException ex)
{
await DialogService.ShowAlertAsync("Your device does not support this feature", "Feature Not Supported");
}
}
public ContactViewModel()
{
Contacts.Add(new Contact()
{
Name = "Franklin", Phone = "5658456"
});
Contacts.Add(new Contact()
{
Name = "Someone", Phone = "123456"
});
DeleteElementCommand = new Command <Contact>((param) => {
Contacts.Remove(param);
});
GoToAddContactCommand = new Command(async() => {
await App.Current.MainPage.Navigation.PushAsync(new AddContactPage(Contacts));
});
MoreOptionCommand = new Command <Contact>(async(Contactselected) => {
var Selection = await App.Current.MainPage.DisplayActionSheet("Contact", "Cancel", null,
"Number: " + $"{Contactselected.Phone}", "Edit");
if (Selection == "Number: " + $"{Contactselected.Phone}")
{
PhoneDialer.Open(Contactselected.Phone);
}
else if (Selection == "Edit")
{
// await App.Current.MainPage.Navigation.PushAsync(new EditPage(Contactselected.Name));
//await App.Current.MainPage.Navigation.PushAsync(new EditPage(Contactselected.Phone));
}
});
}
private async Task CallAsync()
{
try
{
IsBusy = true;
try
{
PhoneDialer.Open("+5215573348266");
}
catch (ArgumentNullException anEx)
{
// Number was null or white space
}
catch (FeatureNotSupportedException ex)
{
// Phone Dialer is not supported on this device.
}
catch (Exception ex)
{
// Other error has occurred.
}
await Application.Current.MainPage.DisplayAlert("Error", "No fue posible completar su solicitud", "Aceptar");
}
finally
{
IsBusy = false;
}
}
//TODO : To Define Constructor..
public ProfilePageVM(INavigation _Nav)
{
Navigation = _Nav;
if (Constants.UserProfile != null)
{
MobileVisibility = (Constants.UserProfile.Role == "patient");
Mobile = Constants.UserProfile.Phone;
Email = Constants.UserProfile.Email;
FullName = Constants.UserProfile.Name;
}
// BackCommand = new DelegateCommand(BackCommandAsync);
LogoutCommand = new Command(LogoutCommandAsync);
UpdateCommand = new Command(UpdateCommandAsync);
RADIOLOGYCommand = new Command(() =>
{
App.Current.MainPage.Navigation.PushAsync(new TabbedPage(1));
//App.HomeView.Detail.Navigation.PushAsync(new RadioResultPage());
});
LABORATORYCommand = new Command(() =>
{
App.Current.MainPage.Navigation.PushAsync(new TabbedPage(0));
// App.HomeView.Detail.Navigation.PushAsync(new LabResultPage());
});
BloodSampleCommand = new Command(() =>
{
PhoneDialer.Open(Settings.AppSettings_BloodSampleNumber);
});
}
async public void OnCall(object obj, EventArgs eventArgs)
{
if (
await DisplayAlert("Dial a number", $"Do you want to call {translatedNumber}?", "Yes", "No")
)
{
try
{
PhoneDialer.Open(translatedNumber);
System.Diagnostics.Debug.WriteLine("DIALING");
}
catch (ArgumentNullException anEx)
{
// Number was null or white space
await DisplayAlert("Exception", $"Exception, NULL: {anEx.ToString()}", "OK");
}
catch (FeatureNotSupportedException ex)
{
// Phone Dialer is not supported on this device.
await DisplayAlert("Exception", $"Exception, NO FEATURE: {ex.ToString()}", "OK");
}
catch (Exception ex)
{
// Other error has occurred.
await DisplayAlert("Exception", $"Exception: {ex.ToString()}", "OK");
}
}
else
{
await DisplayAlert("NO", "NO", "OK");
}
}
public async void OnCall(object obj, EventArgs e)
{
if (await DisplayAlert(
"Dial a Number",
$"Would You Like To Call {translatedNumber}?",
"Yes",
"No"))
{
try
{
PhoneDialer.Open(translatedNumber);
}
catch (ArgumentNullException)
{
await DisplayAlert("Unable to dial", "Phone Number Was Not Valid", "Ok");
}
catch (FeatureNotSupportedException)
{
await DisplayAlert("Unable To Dial", "Phone Dialing Not Supported", "Ok");
}
catch (Exception)
{
await DisplayAlert("Unable To Dial", "Phone Dialing Failed", "Ok");
}
}
;
}
private void PhoneNumer_Tapped(object sender, EventArgs e)
{
// get phone numer
Label lbl = sender as Label;
try
{
PhoneDialer.Open(lbl.Text);
}
catch (ArgumentNullException anEx)
{
CrashTracker.Track(anEx);
// Number was null or white space
}
catch (FeatureNotSupportedException ex)
{
CrashTracker.Track(ex);
// Phone Dialer is not supported on this device.
}
catch (Exception ex)
{
CrashTracker.Track(ex);
// Other error has occurred.
}
}
//SOS button
private void SosButton_Click(object sender, System.EventArgs e)
{
requestGroupFragment = new RequestGroup(mapHelper.EstimateFares());
requestGroupFragment.Cancelable = false;
var trans = SupportFragmentManager.BeginTransaction();
newTripDetails = new NewTripDetails();
newTripDetails.DestinationAddress = destinationAddress;
newTripDetails.PickupAddress = pickupAddress;
newTripDetails.DestinationLat = destinationLatLng.Latitude;
newTripDetails.DestinationLng = destinationLatLng.Longitude;
newTripDetails.DistanceString = mapHelper.distanceString;
newTripDetails.DistanceValue = mapHelper.distance;
newTripDetails.DurationString = mapHelper.durationstring;
newTripDetails.DurationValue = mapHelper.duration;
newTripDetails.EstimateFare = mapHelper.EstimateFares();
newTripDetails.PickupLat = pickupLocationLatlng.Latitude;
newTripDetails.PickupLng = pickupLocationLatlng.Longitude;
newTripDetails.Timestamp = DateTime.Now;
//group
requestListener = new CreateRequestEventListener(newTripDetails);
requestListener.NoDriverAcceptedRequest += RequestListener_NoDriverAcceptedRequest;
requestListener.DriverAccepted += RequestListener_DriverAccepted;
requestListener.TripUpdates += RequestListener_TripUpdates;
requestListener.CreateSOSRequest();
PhoneDialer.Open("10111");
}
private void OnDialerCommandExecute(string numbers)
{
if (numbers.Contains(','))
{
numbers = numbers.Split(',').FirstOrDefault();
}
PhoneDialer.Open(numbers);
}
public AboutPage()
{
InitializeComponent();
var emailGestureRecognizer = new TapGestureRecognizer();
emailGestureRecognizer.Tapped += async(s, e) => {
try
{
var label = (Label)s;
var message = new EmailMessage
{
Subject = "Naslov",
Body = "",
To = new List <string>()
{
label.Text
},
//Cc = ccRecipients,
//Bcc = bccRecipients
};
await Email.ComposeAsync(message);
}
catch (FeatureNotSupportedException fbsEx)
{
// Email is not supported on this device
}
catch (Exception ex)
{
// Some other exception occurred
}
};
emailLabelGojko.GestureRecognizers.Add(emailGestureRecognizer);
emailLabelOffice.GestureRecognizers.Add(emailGestureRecognizer);
var phoneGestureRecognizer = new TapGestureRecognizer();
phoneGestureRecognizer.Tapped += (s, e) => {
try
{
PhoneDialer.Open(phoneLabel.Text.Replace(" ", string.Empty));
}
catch (ArgumentNullException anEx)
{
// Number was null or white space
}
catch (FeatureNotSupportedException ex)
{
// Phone Dialer is not supported on this device.
}
catch (Exception ex)
{
// Other error has occurred.
}
};
phoneLabel.GestureRecognizers.Add(phoneGestureRecognizer);
}
private async void OnMore(Contact contact)
{
var MoreAction = await App.Current.MainPage.DisplayActionSheet(null, "Cancel", null, $"Call {contact.Number}", "Edit");
if (MoreAction == $"Call {contact.Number}")
{
PhoneDialer.Open(contact.Number);
}
}
public ContactViewModel(IPageDialogService pageDialogService, ISettings settings)
{
PhoneCallCommand = new DelegateCommand(async() =>
{
try
{
PhoneDialer.Open(settings[Setting.PhoneNumber] as string);
}
catch
{
await pageDialogService.DisplayAlertAsync(
"Błąd", "Nie udało się zadzownić, spróbuj ponownie później", "Anuluj");
}
});
SendEmailCommand = new DelegateCommand(async() =>
{
try
{
EmailMessage message = new EmailMessage
{
To = { settings[Setting.ReportEmail] as string },
};
await Email.ComposeAsync(message);
}
catch
{
await pageDialogService.DisplayAlertAsync(
"Błąd", "Nie udało się wysłać wiadomości email", "Anuluj");
}
});
OpenLocationCommand = new DelegateCommand(async() =>
{
try
{
Placemark placemark = new Placemark
{
CountryName = "United States",
AdminArea = "WA",
Thoroughfare = "Microsoft Building 25",
Locality = "Redmond"
};
MapLaunchOptions options = new MapLaunchOptions {
Name = "Microsoft Building 25"
};
await Map.OpenAsync(placemark, options);
}
catch
{
await pageDialogService.DisplayAlertAsync(
"Błąd", "Nie udało się otworzyć lokalizacji.\nBrak aplikacji map.", "Anuluj");
}
});
}
private async void OnMoreAgenda(Agenda agenda)
{
var Alert = await App.Current.MainPage.DisplayActionSheet("", "Cancel", "", "Call", "Edit");
if (Alert == "Call")
{
PhoneDialer.Open(agenda.Number);
}
}
