void ShowPersonViewController()
{
var predicate = CNContact.GetPredicateForContacts("Appleseed");
ICNKeyDescriptor[] toFetch = { CNContactViewController.DescriptorForRequiredKeys };
CNContactStore store = new CNContactStore();
NSError fetchError;
CNContact[] contacts = store.GetUnifiedContacts(predicate, toFetch, out fetchError);
if (contacts != null && contacts.Length > 0)
{
CNContact contact = contacts[0];
var peopleViewController = CNContactViewController.FromContact(contact);
peopleViewController.AllowsEditing = true;
NavigationController.PushViewController(peopleViewController, true);
}
else
{
var alert = UIAlertController.Create("Error", "Could not find Appleseed in the Contacts application", UIAlertControllerStyle.Alert);
alert.AddAction(UIAlertAction.Create("Cancel", UIAlertActionStyle.Default, null));
PresentViewController(alert, true, null);
}
}
static Task <IEnumerable <PhoneContact> > PlataformGetContacts(int pageSize)
{
var keysToFetch = new[] { CNContactKey.GivenName, CNContactKey.FamilyName, CNContactKey.PhoneNumbers, CNContactKey.EmailAddresses };
var contactList = new List <CNContact>();
using (var store = new CNContactStore())
{
var request = new CNContactFetchRequest(keysToFetch);
store.EnumerateContacts(request, out NSError error, new CNContactStoreListContactsHandler(
(CNContact contact, ref bool stop) => contactList.Add(contact)));
}
var contacts = new List <PhoneContact>();
foreach (var item in contactList)
{
var numbers = item.PhoneNumbers.Select(x => x.Value.StringValue);
var emails = item.EmailAddresses.Select(x => x.Value.ToString());
var bd = item.Birthday.Date.ToString();
var address = item.PostalAddresses.Select(x => x.Value.ToString());
contacts.Add(new PhoneContact(
item.GivenName + item.FamilyName,
numbers,
emails,
bd));
}
return(Task.FromResult(contacts.AsEnumerable()));
}
public TestThreads()
{
_contactStore = new CNContactStore();
_blockingSemaphore = new SemaphoreSlim(0);
_poolSemaphore = new SemaphoreSlim(2);
_urlsList = new List <string>();
}
List <CNContact> GetIosContacts()
{
var result = new List <CNContact>();
using (var store = new CNContactStore())
{
NSError error;
var allContainers = store.GetContainers(null, out error);
foreach (var container in allContainers)
{
try
{
using (var predicate = CNContact.GetPredicateForContactsInContainer(container.Identifier))
{
var containerResults = store.GetUnifiedContacts(predicate, _keys, out error);
result.AddRange(containerResults);
}
}
catch (Exception ex)
{
ExceptionHandler.HandleException(ex);
}
}
}
return(result);
}
public List <PhoneContactIOSModel> GetAllContacts()
{
var keysTOFetch = new[] { CNContactKey.GivenName, CNContactKey.FamilyName, CNContactKey.EmailAddresses, CNContactKey.PhoneNumbers, CNContactKey.ThumbnailImageData };
NSError error;
CNContact[] contactList;
var ContainerId = new CNContactStore().DefaultContainerIdentifier;
using (var predicate = CNContact.GetPredicateForContactsInContainer(ContainerId))
using (var store = new CNContactStore())
{
contactList = store.GetUnifiedContacts(predicate, keysTOFetch, out error);
}
var contacts = new List <PhoneContactIOSModel>();
foreach (var item in contactList)
{
if (null != item && null != item.EmailAddresses)
{
contacts.Add(new PhoneContactIOSModel
{
GivenName = item.GivenName,
FamilyName = item.FamilyName,
EmailId = item.EmailAddresses.Select(m => m.Value.ToString()).FirstOrDefault(),
PhoneNumbers = item.PhoneNumbers.Select(m => m.Value.StringValue).FirstOrDefault(),
ThumbnailImageData = item.ThumbnailImageData
});
}
}
return(contacts);
}
public string DeleteContact(string id)
{
try
{
CNContactStore contactStore = new CNContactStore();
CNSaveRequest saveRequest = new CNSaveRequest();
NSError searchError;
NSString searchId = NSString.StringWithUTF8String(id);
CNContact nativeContact = contactStore.UnifiedContactWithIdentifier(searchId, GetPropertyKeys(), out searchError);
if (searchError != null)
{
return(searchError.LocalizedDescription);
}
saveRequest.DeleteContact(nativeContact.MutableCopy());
NSError deleteError;
bool executeSuccess = contactStore.ExecuteSaveRequest(saveRequest, out deleteError);
return(executeSuccess
? null
: deleteError != null
? deleteError.LocalizedDescription
: ExecuteSaveRequestFailedMessage);
}
catch (Exception e)
{
return(e.Message);
}
}
public SUGARContact[] GetAllContacts()
{
List <SUGARContact> resultList = new List <SUGARContact>();
CNContactStore store = new CNContactStore();
CNContactFetchRequest request = new CNContactFetchRequest(
CNContactKey.GivenName, CNContactKey.FamilyName, CNContactKey.PhoneNumbers);
store.EnumerateContacts(request, out NSError err, (CNContact contact, ref Boolean stop) =>
{
CNLabeledValue <CNPhoneNumber>[] phoneNumberValues = contact.PhoneNumbers;
List <string> phoneNumbersAsStrings = new List <string>();
List <long> phoneNumbersAsLongs = new List <long>();
foreach (var labeledValue in phoneNumberValues)
{
string stringValue = labeledValue.Value.StringValue;
phoneNumbersAsStrings.Add(stringValue);
phoneNumbersAsLongs.Add(ParseNumberAsLong(stringValue));
}
SUGARContact nextContact = new SUGARContact($"{contact.GivenName} {contact.FamilyName}",
phoneNumbersAsStrings, phoneNumbersAsLongs);
resultList.Add(nextContact);
});
return(resultList.ToArray());
}
public IEnumerable <CNContact> GetAllRaw(NSString[] keys)
{
List <CNContact> results = new List <CNContact>();
using (var store = new CNContactStore())
{
var allContainers = store.GetContainers(null, out var error);
if (error != null)
{
throw new Exception($"iOS Exception: {error}");
}
foreach (var container in allContainers)
{
try
{
using (var predicate = CNContact.GetPredicateForContactsInContainer(container.Identifier))
{
var containerResults = store.GetUnifiedContacts(predicate, keys, out error);
results.AddRange(containerResults);
}
}
catch (Exception ex)
{
Console.WriteLine($"DeviceContacts_iOS Error: {ex}");
// ignore missed contacts from errors
}
}
}
return(results);
}
/// <summary>
/// Gets all contact from phone.
/// </summary>
/// <returns>The all contact from phone.</returns>
public Dictionary <string, object> GetAllContactFromPhone()
{
NSError error;
var keyToFetchs = new NSString[] { CNContactKey.Birthday,
CNContactKey.Dates,
CNContactKey.DepartmentName,
CNContactKey.EmailAddresses,
CNContactKey.FamilyName, CNContactKey.GivenName, CNContactKey.Identifier, CNContactKey.ImageData, CNContactKey.ImageDataAvailable,
CNContactKey.InstantMessageAddresses, CNContactKey.JobTitle, CNContactKey.MiddleName, CNContactKey.NamePrefix, CNContactKey.NameSuffix,
CNContactKey.Nickname, CNContactKey.NonGregorianBirthday, CNContactKey.Note, CNContactKey.OrganizationName,
CNContactKey.PhoneNumbers, CNContactKey.PhoneticFamilyName, CNContactKey.PhoneticGivenName, CNContactKey.PhoneticMiddleName,
CNContactKey.PhoneticOrganizationName, CNContactKey.PostalAddresses, CNContactKey.PreviousFamilyName,
CNContactKey.Relations, CNContactKey.SocialProfiles, CNContactKey.ThumbnailImageData, CNContactKey.Type, CNContactKey.UrlAddresses };
CNContactStore store = new CNContactStore();
CNContactFetchRequest request = new CNContactFetchRequest(keyToFetchs);
request.SortOrder = CNContactSortOrder.GivenName;
totalContactListWithoutGrouping = new List <ContactItem>();
store.EnumerateContacts(request, out error, HandleCNContactStoreListContactsHandler);
var dict = new Dictionary <string, object>
{
{ "Group", totalContactList },
{ "List", totalContactListWithoutGrouping }
};
return(dict);
}
/// <summary>
/// Gets contact in main thread
/// !!!Not Recommended
/// </summary>
public IEnumerable <Contact> GetContactList(Func <Contact, bool> filter = null)
{
//try
//{
var keysToFetch = new[] { CNContactKey.Identifier, CNContactKey.GivenName, CNContactKey.FamilyName, CNContactKey.EmailAddresses, CNContactKey.PhoneNumbers, CNContactKey.ImageDataAvailable, CNContactKey.ThumbnailImageData };
NSError error;
//var containerId = new CNContactStore().DefaultContainerIdentifier;
// using the container id of null to get all containers.
// If you want to get contacts for only a single container type, you can specify that here
var contactList = new List <CNContact>();
using (var store = new CNContactStore())
{
var allContainers = store.GetContainers(null, out error);
foreach (var container in allContainers)
{
try
{
using (var predicate = CNContact.GetPredicateForContactsInContainer(container.Identifier))
{
var containerResults = store.GetUnifiedContacts(predicate, keysToFetch, out error);
contactList.AddRange(containerResults);
}
}
catch (Exception ex)
{
Debug.WriteLine("\n\n\n" + ex.ToString() + "\n\n\n");
if (ex.GetType() != typeof(NullReferenceException))
{
Debug.WriteLine(ex.ToString());
}
continue;
}
}
}
//var contacts = new List<Contact>();
var result = new List <Contact>();
foreach (var item in contactList)
{
if (item.GivenName == null)
{
continue;
}
Contact _contact = new Contact();
if (filter != null && !filter(_contact))
{
continue;
}
result.Add(_contact);
}
return(result);
}
//========================================================================================================================================
// PUBLIC CLASS PROPERTIES
//========================================================================================================================================
//========================================================================================================================================
// Constructor
//========================================================================================================================================
/// <summary>
/// Initializes a new instance of the <see cref="ContactPicker.FakeRepositorySeederHelper"/> class.
/// </summary>
public FakeRepositorySeederHelper(bool access)
{
this.access = access;
if (access)
{
store = new CNContactStore();
}
}
public async Task <IEnumerable <PhoneContact> > GetAllContactsAsync()
{
var keysToFetch = new[]
{
CNContactKey.GivenName,
CNContactKey.FamilyName,
CNContactKey.PhoneNumbers
};
NSError error;
//var containerId = new CNContactStore().DefaultContainerIdentifier;
// using the container id of null to get all containers.
// If you want to get contacts for only a single container type,
// you can specify that here
var contactList = new List <CNContact>();
await Task.Run(() =>
{
using (var store = new CNContactStore())
{
var allContainers = store.GetContainers(null, out error);
foreach (var container in allContainers)
{
try
{
using (var predicate = CNContact.GetPredicateForContactsInContainer(container.Identifier))
{
var containerResults = store.GetUnifiedContacts(predicate, keysToFetch, out error);
contactList.AddRange(containerResults);
}
}
catch
{
// ignore missed contacts from errors
}
}
}
});
var contacts = new List <PhoneContact>();
foreach (var item in contactList)
{
var numbers = item.PhoneNumbers;
if (numbers != null)
{
foreach (var item2 in numbers)
{
contacts.Add(new PhoneContact
{
FirstName = item.GivenName,
LastName = item.FamilyName,
PhoneNumber = item2.Value.StringValue
});
}
}
}
return(contacts);
}
void RequestContactStoreAccess ()
{
var contactStore = new CNContactStore();
contactStore.RequestAccess(CNEntityType.Contacts, (granted, error) => {
if (granted) {
DispatchQueue.MainQueue.DispatchAsync(() => AccessGrantedForContactStore());
}
});
}
public async Task <IEnumerable <PhoneContact> > GetAllContacts()
{
//Permission
if (!(await PermissionGranting()))
{
return(new List <PhoneContact>());
}
//Contacts
var keysToFetch = new[] { CNContactKey.GivenName, CNContactKey.FamilyName, CNContactKey.EmailAddresses, CNContactKey.ThumbnailImageData };
//var containerId = new CNContactStore().DefaultContainerIdentifier;
// using the container id of null to get all containers.
// If you want to get contacts for only a single container type, you can specify that here
var contactList = new List <CNContact>();
using (var store = new CNContactStore())
{
var allContainers = store.GetContainers(null, out NSError error);
foreach (var container in allContainers)
{
try
{
using (var predicate = CNContact.GetPredicateForContactsInContainer(container.Identifier))
{
var containerResults = store.GetUnifiedContacts(predicate, keysToFetch, out error);
contactList.AddRange(containerResults);
}
}
catch (Exception e) { Console.WriteLine(e.Message); } // ignore missed contacts from errors
}
}
var contacts = new List <PhoneContact>();
foreach (var item in contactList)
{
var emails = item.EmailAddresses;
if (emails != null)
{
try
{
var stream = item.ThumbnailImageData?.AsStream();
contacts.Add(new PhoneContact
{
FirstName = item.GivenName,
LastName = item.FamilyName,
FullName = $"{item.GivenName} {item.FamilyName}",
Email = (emails.GetLength(0) > 0) ? emails[0].Value : String.Empty,
PhotoThumbnail = "ic_user"//Xamarin.Forms.ImageSource.FromStream(() => stream)
});
}
catch (Exception ex) { Console.WriteLine(ex.Message); }
}
}
return(contacts);
}
public void GetUnifiedContacts()
{
string identifier = null;
TestRuntime.CheckContactsPermission();
var fetchKeys = new [] { CNContactKey.Identifier, CNContactKey.GivenName, CNContactKey.FamilyName };
NSError error;
using (var predicate = CNContact.GetPredicateForContacts("Appleseed"))
using (var store = new CNContactStore()) {
var contacts = store.GetUnifiedContacts(predicate, fetchKeys, out error);
// we can't be sure what's on devices, so check there's no error is the only thing we do
Assert.Null(error, "error");
// but it's in the default simulator build (but not the watchOS simulator)
#if !__WATCHOS__ && !MONOMAC
if (Runtime.Arch == Arch.SIMULATOR)
{
Assert.That(contacts.Length, Is.EqualTo(1), "Length");
identifier = contacts [0].Identifier;
}
#endif
}
// if we can't find the previous contact then we don't have an identifier for the GetUnifiedContact API
// and we can't hardcode one as each simulator instance has a different identifier...
if (identifier == null)
{
return;
}
using (var store = new CNContactStore()) {
var contact = store.GetUnifiedContact(identifier, fetchKeys, out error);
// it's in the default simulator build
#if !MONOMAC
if (Runtime.Arch == Arch.SIMULATOR)
{
Assert.Null(error, "error");
Assert.NotNull(contact, "contact");
Assert.False(contact.AreKeysAvailable(CNContactOptions.OrganizationName | CNContactOptions.Note), "AreKeysAvailable-1");
Assert.True(contact.AreKeysAvailable(CNContactOptions.None), "AreKeysAvailable-2");
Assert.True(contact.AreKeysAvailable(fetchKeys), "AreKeysAvailable-3");
}
else
{
#endif
// and it's a safe bet that id does not exists on any device
Assert.NotNull(error, "error"); // Updated Record Does Not Exist
#if !MONOMAC
}
#endif
}
}
private static IEnumerable <CNContact> ReadRawContactList(IEnumerable <NSString> keysToFetch)
{
//var containerId = new CNContactStore().DefaultContainerIdentifier;
// using the container id of null to get all containers.
// If you want to get contacts for only a single container type, you can specify that here
using (var store = new CNContactStore())
{
var allContainers = store.GetContainers(null, out _);
return(ContactListFromAllContainers(keysToFetch, allContainers, store));
}
}
void RequestContactStoreAccess()
{
var contactStore = new CNContactStore();
contactStore.RequestAccess(CNEntityType.Contacts, (granted, error) => {
if (granted)
{
DispatchQueue.MainQueue.DispatchAsync(() => AccessGrantedForContactStore());
}
});
}
public IEnumerable <Contact> GetContacts()
{
var keys = CNContactFormatter.GetDescriptorForRequiredKeys(CNContactFormatterStyle.FullName);
var keysToFetch = new [] {
CNContactKey.Identifier, CNContactKey.GivenName, CNContactKey.FamilyName,
CNContactKey.EmailAddresses, CNContactKey.PhoneNumbers, CNContactKey.ImageData,
CNContactKey.ImageDataAvailable, CNContactKey.ThumbnailImageData,
};
NSError error;
//var containerId = new CNContactStore().DefaultContainerIdentifier;
// using the container id of null to get all containers.
// If you want to get contacts for only a single container type, you can specify that here
var contactList = new List <CNContact> ();
using (var store = new CNContactStore()) {
var allContainers = store.GetContainers(null, out error);
foreach (var container in allContainers)
{
try {
using (var predicate = CNContact.GetPredicateForContactsInContainer(container.Identifier)) {
var containerResults = store.GetUnifiedContacts(predicate, keysToFetch, out error);
contactList.AddRange(containerResults);
}
} catch (Exception ex) {
continue;
}
}
foreach (var item in contactList)
{
if (item.GivenName == null)
{
continue;
}
var image = item.ImageDataAvailable ? CacheImage(item.ImageData) : null;
var thumb = CacheImage(item.ThumbnailImageData);
var formatterKey = new [] { CNContactFormatter.GetDescriptorForRequiredKeys(CNContactFormatterStyle.FullName) };
var altItem = store.GetUnifiedContact <ICNKeyDescriptor> (item.Identifier, formatterKey, out error);
var contact = new Contact()
{
FirstName = item.GivenName,
LastName = item.FamilyName,
FullName = CNContactFormatter.GetStringFrom(altItem, CNContactFormatterStyle.FullName),
ImagePath = image,
ThumbnailPath = thumb
};
contact.Numbers.AddRange(ToPhoneNumbers(item.PhoneNumbers));
yield return(contact);
}
}
}
/// <summary>
/// Load contacts asynchronously, fact reading method of address book.
/// </summary>
/// <returns></returns>
async Task <IList <Contact> > LoadContactsAsync()
{
IList <Contact> contacts = new List <Contact>();
var hasPermission = await RequestPermissionAsync();
if (hasPermission)
{
NSError error = null;
var keysToFetch = new[] { CNContactKey.PhoneNumbers, CNContactKey.GivenName, CNContactKey.FamilyName, CNContactKey.EmailAddresses, CNContactKey.ImageDataAvailable, CNContactKey.ThumbnailImageData };
var request = new CNContactFetchRequest(keysToFetch: keysToFetch);
request.SortOrder = CNContactSortOrder.GivenName;
using (var store = new CNContactStore())
{
var result = store.EnumerateContacts(request, out error, new CNContactStoreListContactsHandler((CNContact c, ref bool stop) =>
{
string path = null;
if (c.ImageDataAvailable)
{
path = path = Path.Combine(Path.GetTempPath(), $"{ThumbnailPrefix}-{Guid.NewGuid()}");
if (!File.Exists(path))
{
var imageData = c.ThumbnailImageData;
imageData?.Save(path, true);
}
}
var contact = new Contact()
{
Name = string.IsNullOrEmpty(c.FamilyName) ? c.GivenName : $"{c.GivenName} {c.FamilyName}",
Image = path,
PhoneNumbers = c.PhoneNumbers?.Select(p => p?.Value?.StringValue).ToArray(),
Emails = c.EmailAddresses?.Select(p => p?.Value?.ToString()).ToArray(),
};
if (!string.IsNullOrWhiteSpace(contact.Name))
{
OnContactLoaded?.Invoke(this, new ContactEventArgs(contact));
contacts.Add(contact);
}
stop = requestStop;
}));
}
}
return(contacts);
}
public IEnumerable <PhoneContact> GetAllContacts()
{
var keysTOFetch = new[] { CNContactKey.GivenName, CNContactKey.FamilyName, CNContactKey.PhoneNumbers };
NSError error;
//var containerId = new CNContactStore().DefaultContainerIdentifier;
// using the container id of null to get all containers
var contactList = new List <CNContact>();
//test
using (var store = new CNContactStore())
{
var request = new CNContactFetchRequest(keysTOFetch);
store.EnumerateContacts(request, out error, new CNContactStoreListContactsHandler((CNContact contact, ref bool stop) => contactList.Add(contact)));
}
var contacts = new List <PhoneContact>();
foreach (var item in contactList)
{
var numbers = item.PhoneNumbers;
if (numbers != null)
{
if (item.GivenName == "SPAM")
{
foreach (var item2 in numbers)
{
var givenName = item2.Label.Split('-');
contacts.Add(new PhoneContact
{
FirstName = givenName.Length > 1 ? givenName[1] : "",
LastName = item.FamilyName,
PhoneNumber = item2.Value.StringValue
});
}
}
else
{
foreach (var item2 in numbers)
{
contacts.Add(new PhoneContact
{
FirstName = item.GivenName,
LastName = item.FamilyName,
PhoneNumber = item2.Value.StringValue
});
}
}
}
}
return(contacts);
}
public IEnumerable <Contact> GetAllContacts()
{
var contacts = new List <Contact>();
// Define fields to be searched
var fetchKeys = new NSString[] { CNContactKey.Identifier, CNContactKey.GivenName, CNContactKey.FamilyName, CNContactKey.EmailAddresses, CNContactKey.Nickname, CNContactKey.ImageData, CNContactKey.PhoneNumbers };
NSError error;
store = new CNContactStore();
if (CNContactStore.GetAuthorizationStatus(CNEntityType.Contacts) != CNAuthorizationStatus.Denied)
{
var cnContainers = store.GetContainers(null, out error);
if (cnContainers != null)
{
foreach (var container in cnContainers)
{
// Create predicate to locate requested contact
var predicate = CNContact.GetPredicateForContactsInContainer(container.Identifier);
var cnContacts = store.GetUnifiedContacts(predicate, fetchKeys, out error);
if (CNContactStore.GetAuthorizationStatus(CNEntityType.Contacts) == CNAuthorizationStatus.Authorized)
{
foreach (var c in cnContacts)
{
var con = new Contact();
con.Email = new List <string>();
foreach (var email in c.EmailAddresses)
{
con.Email.Add(email.ToString());
}
con.PhoneNumber = new List <string>();
foreach (var phone in c.PhoneNumbers)
{
con.PhoneNumber.Add(phone.ToString());
}
con.ID = c.Identifier;
con.FirsName = c.GivenName;
con.LastName = c.FamilyName;
con.ImageSource = c.ImageData != null?ImageSource.FromStream(() => c.ImageData.AsStream()) : null;
con.DisplayName = c.GivenName + " " + c.FamilyName;
con.NickName = c.Nickname;
contacts.Add(con);
}
}
}
}
}
return(contacts);
}
public Task <List <ContactModel> > GetContactListAsync()
{
var contactList = new List <ContactModel>();
try
{
var keysToFetch = new[]
{
CNContactKey.GivenName,
CNContactKey.FamilyName,
CNContactKey.PhoneNumbers
};
using (var store = new CNContactStore())
{
var allContainers = store.GetContainers(null, out var _);
foreach (var container in allContainers)
{
using (var predicate = CNContact.GetPredicateForContactsInContainer(container.Identifier))
{
var containerResults = store.GetUnifiedContacts(predicate, keysToFetch, out _);
foreach (var contact in containerResults)
{
var name = string.Concat(contact.GivenName, " ", contact.FamilyName);
for (var i = 0; i < contact.PhoneNumbers.Length; i++)
{
var number = contact.PhoneNumbers[i];
contactList.Add(new ContactModel
{
Name = string.Concat(name, i > 0 ? $" {i + 1}" : ""),
Number = number.Value.StringValue
});
}
}
}
}
}
}
catch (Exception e)
{
Debug.WriteLine($"--- Error: {e.StackTrace}");
}
return(Task.FromResult(contactList));
}
public string sendMsg()
{
var keysToFetch = new[] { CNContactKey.GivenName, CNContactKey.FamilyName, CNContactKey.PhoneNumbers };
NSError error;
bool check = false;
using (var store = new CNContactStore())
{
var allContainers = store.GetContainers(null, out error);
foreach (var container in allContainers)
{
try
{
using (var predicate = CNContact.GetPredicateForContactsInContainer(container.Identifier))
{
var containerResults = store.GetUnifiedContacts(predicate, keysToFetch, out error);
foreach (var item in containerResults)
{
var num = item.PhoneNumbers;
foreach (var cn in num)
{
string mob = cn.Value.StringValue;
if (mob == ProfileContentView.phone)
{
check = true;
}
}
}
}
}
catch
{
}
}
}
if (check == false)
{
var store = new CNContactStore();
var contact = new CNMutableContact();
var cellPhone = new CNLabeledValue <CNPhoneNumber>(CNLabelPhoneNumberKey.Mobile, new CNPhoneNumber(ProfileContentView.phone));
var phoneNumber = new[] { cellPhone };
contact.PhoneNumbers = phoneNumber;
contact.GivenName = ProfileContentView.name;
var saveRequest = new CNSaveRequest();
saveRequest.AddContact(contact, store.DefaultContainerIdentifier);
}
return("1");
}
/// <summary>
/// Asynchronous request permission
/// </summary>
/// <returns></returns>
public async Task <bool> RequestPermissionAsync()
{
var status = CNContactStore.GetAuthorizationStatus(CNEntityType.Contacts);
Tuple <bool, NSError> authotization = new Tuple <bool, NSError>(status == CNAuthorizationStatus.Authorized, null);
if (status == CNAuthorizationStatus.NotDetermined)
{
using (var store = new CNContactStore())
{
authotization = await store.RequestAccessAsync(CNEntityType.Contacts);
}
}
return(authotization.Item1);
}
//========================================================================================================================================
// PRIVATE METHODS
//========================================================================================================================================
/// <summary>
/// This method attempts to request access if the access level is not granted. If the user accepts we
/// set our access boolean to true and continue otherwise we force an alert message to be displayed.
/// </summary>
private void requestAccess()
{
var store = new CNContactStore();
store.RequestAccess(CNEntityType.Contacts, (auth, error) => {
if (auth)
{
access = true;
}
else
{
showMessage(error);
}
});
}
public void SaveContact(ContactModel contact)
{
var store = new CNContactStore();
var iosContact = new CNMutableContact();
List <CNLabeledValue <CNPhoneNumber> > phoneNumbers = new List <CNLabeledValue <CNPhoneNumber> >();
List <CNLabeledValue <NSString> > emails = new List <CNLabeledValue <NSString> >();
List <CNLabeledValue <NSString> > websites = new List <CNLabeledValue <NSString> >();
foreach (PhoneField phoneField in contact.PhoneNumbers)
{
phoneNumbers.Add(new CNLabeledValue <CNPhoneNumber>(PhoneNumberTypeToKey(phoneField.Type), new CNPhoneNumber(phoneField.Number)));
}
foreach (EmailField emailField in contact.Emails)
{
emails.Add(new CNLabeledValue <NSString>(EmailTypeToKey(emailField.Type), new NSString(emailField.Email)));
}
foreach (ContactField websiteField in contact.Websites)
{
websites.Add(new CNLabeledValue <NSString>(CNLabelKey.UrlAddressHomePage, new NSString(websiteField.Text)));
}
iosContact.PhoneNumbers = phoneNumbers.ToArray();
iosContact.FamilyName = contact.LastName;
iosContact.GivenName = contact.FirstName;
iosContact.OrganizationName = !string.IsNullOrEmpty(contact.Company.Text) ? contact.Company.Text : string.Empty;
iosContact.EmailAddresses = emails.ToArray();
iosContact.UrlAddresses = websites.ToArray();
if (!string.IsNullOrEmpty(contact.ProfileImage))
{
iosContact.ImageData = NSData.FromFile(contact.ProfileImage);
}
var saveRequest = new CNSaveRequest();
saveRequest.AddContact(iosContact, store.DefaultContainerIdentifier);
if (store.ExecuteSaveRequest(saveRequest, out NSError error))
{
Console.WriteLine("New contact saved");
}
else
{
Console.WriteLine("Save error: {0}", error);
}
}
private static IEnumerable <CNContact> ContactListFromAllContainers(
IEnumerable <NSString> keysToFetch,
IEnumerable <CNContainer> allContainers,
CNContactStore store)
{
var nsStrings = keysToFetch.ToList();
var contactList = new List <CNContact>();
foreach (var container in allContainers)
{
var contacts = ReadFromContainer(nsStrings, container, store);
contactList.AddRange(contacts);
}
return(contactList);
}
public void CheckPermission()
{
CNAuthorizationStatus authStatus = CNContactStore.GetAuthorizationStatus(CNEntityType.Contacts);
if (authStatus == CNAuthorizationStatus.Denied || authStatus == CNAuthorizationStatus.Restricted)
{
Debug.WriteLine("Contacts Denied or Restricted");
var okCancelAlertController = UIAlertController.Create("Alert", "Need permission to access contac", UIAlertControllerStyle.Alert);
//Add Actions
okCancelAlertController.AddAction(UIAlertAction.Create("Setting", UIAlertActionStyle.Default, (UIAlertAction obj) =>
{
MoveToSetting();
}));
okCancelAlertController.AddAction(UIAlertAction.Create("Cancel", UIAlertActionStyle.Cancel, null));
//Present Alert
UIApplication.SharedApplication.KeyWindow.RootViewController.PresentViewController(okCancelAlertController, true, null);
}
else if (authStatus == CNAuthorizationStatus.NotDetermined)
{
var store = new CNContactStore();
store.RequestAccess(CNEntityType.Contacts, (granted, error) =>
{
if (!granted)
{
var okCancelAlertController = UIAlertController.Create("Alert ", "Need permission to access contact", UIAlertControllerStyle.Alert);
//Add Actions
okCancelAlertController.AddAction(UIAlertAction.Create("Setting", UIAlertActionStyle.Default, (UIAlertAction obj) =>
{
MoveToSetting();
}));
okCancelAlertController.AddAction(UIAlertAction.Create("Cancel", UIAlertActionStyle.Cancel, null));
}
else
{
//check = ContactEnum.Granted;
CustomPermissionStatus?.Invoke(ContactEnum.Granted, EventArgs.Empty);
}
});
}
else
{
CustomPermissionStatus?.Invoke(ContactEnum.Granted, EventArgs.Empty);
}
}
public void GetUnifiedContacts()
{
string identifier = null;
TestRuntime.CheckContactsPermission();
var fetchKeys = new [] { CNContactKey.Identifier, CNContactKey.GivenName, CNContactKey.FamilyName };
NSError error;
using (var predicate = CNContact.GetPredicateForContacts("Appleseed"))
using (var store = new CNContactStore()) {
var contacts = store.GetUnifiedContacts(predicate, fetchKeys, out error);
// we can't be sure what's on devices, so check there's no error is the only thing we do
// but it's in the default simulator build (but not the watchOS simulator)
#if !MONOMAC && !__WATCHOS__ && !__MACCATALYST__
if ((error == null) && (Runtime.Arch == Arch.SIMULATOR))
{
Assert.That(contacts.Length, Is.EqualTo(1), "Length");
identifier = contacts [0].Identifier;
}
#endif
}
// if we can't find the previous contact then we don't have an identifier for the GetUnifiedContact API
// and we can't hardcode one as each simulator instance has a different identifier...
if (identifier == null)
{
return;
}
using (var store = new CNContactStore()) {
var contact = store.GetUnifiedContact(identifier, fetchKeys, out error);
// it's in the default simulator build
if (TestRuntime.IsSimulatorOrDesktop)
{
// it fails on some bots (watchOS 4.2 on jenkins) so we cannot assume it always work
if (error != null)
{
return;
}
Assert.NotNull(contact, "contact");
Assert.False(contact.AreKeysAvailable(CNContactOptions.OrganizationName | CNContactOptions.Note), "AreKeysAvailable-1");
Assert.True(contact.AreKeysAvailable(CNContactOptions.None), "AreKeysAvailable-2");
Assert.True(contact.AreKeysAvailable(fetchKeys), "AreKeysAvailable-3");
}
}
}
public List <Contact> GetContactList()
{
var keysToFetch = new[] { CNContactKey.GivenName, CNContactKey.FamilyName, CNContactKey.PhoneNumbers, CNContactKey.EmailAddresses };
NSError error;
var contactList = new List <CNContact>();
using (var store = new CNContactStore())
{
var allContainers = store.GetContainers(null, out error);
foreach (var container in allContainers)
{
try
{
using (var predicate = CNContact.GetPredicateForContactsInContainer(container.Identifier))
{
var containerResults = store.GetUnifiedContacts(predicate, keysToFetch, out error);
contactList.AddRange(containerResults);
}
}
catch (Exception)
{
// ignore missed contacts from errors
throw;
}
}
}
var contacts = new List <Contact>();
foreach (var item in contactList)
{
var numbers = item.PhoneNumbers;
if (numbers != null)
{
foreach (var item2 in numbers)
{
contacts.Add(new Contact
{
Name = item.GivenName,
Number = item2.Value.StringValue,
});
}
}
}
return(contacts);
}
private static IEnumerable <CNContact> ReadFromContainer(
IEnumerable <NSString> keysToFetch,
CNContainer container,
CNContactStore store)
{
try
{
using (var predicate = CNContact.GetPredicateForContactsInContainer(container.Identifier))
{
return(store.GetUnifiedContacts(predicate, keysToFetch.ToArray(), out _));
}
}
catch (Exception ex)
{
Debug.WriteLine($"\n\n\n{ex}\n\n\n");
}
return(null);
}
void ShowPersonViewController ()
{
var predicate = CNContact.GetPredicateForContacts("Appleseed");
ICNKeyDescriptor[] toFetch = { CNContactViewController.DescriptorForRequiredKeys };
CNContactStore store = new CNContactStore();
NSError fetchError;
CNContact[] contacts = store.GetUnifiedContacts(predicate, toFetch, out fetchError);
if (contacts != null && contacts.Length > 0)
{
CNContact contact = contacts[0];
var peopleViewController = CNContactViewController.FromContact(contact);
peopleViewController.AllowsEditing = true;
NavigationController.PushViewController(peopleViewController, true);
}
else {
var alert = UIAlertController.Create("Error", "Could not find Appleseed in the Contacts application", UIAlertControllerStyle.Alert);
alert.AddAction(UIAlertAction.Create("Cancel", UIAlertActionStyle.Default, null));
PresentViewController(alert, true, null);
}
}
