/*
|
* Copyright (c) 2010-2020 Belledonne Communications SARL.
|
*
|
* This file is part of linphone-iphone
|
*
|
* This program is free software: you can redistribute it and/or modify
|
* it under the terms of the GNU General Public License as published by
|
* the Free Software Foundation, either version 3 of the License, or
|
* (at your option) any later version.
|
*
|
* This program is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* GNU General Public License for more details.
|
*
|
* You should have received a copy of the GNU General Public License
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
*/
|
|
#ifdef __IPHONE_9_0
|
#import <Contacts/Contacts.h>
|
#endif
|
#import "FastAddressBook.h"
|
#import "LinphoneManager.h"
|
#import "ContactsListView.h"
|
#import "Utils.h"
|
|
@implementation FastAddressBook {
|
CNContactStore* store;
|
}
|
|
+ (UIImage *)imageForContact:(Contact *)contact {
|
@synchronized(LinphoneManager.instance.fastAddressBook.addressBookMap) {
|
UIImage *retImage = [contact avatar];
|
if (retImage == nil) {
|
retImage = [UIImage imageNamed:@"avatar.png"];
|
}
|
if (retImage.size.width != retImage.size.height) {
|
retImage = [retImage squareCrop];
|
}
|
return retImage;
|
}
|
}
|
|
+ (UIImage *)imageForAddress:(const LinphoneAddress *)addr {
|
if ([LinphoneManager isMyself:addr] && [LinphoneUtils hasSelfAvatar]) {
|
return [LinphoneUtils selfAvatar];
|
}
|
return [FastAddressBook imageForContact:[FastAddressBook getContactWithAddress:addr]];
|
}
|
|
+ (UIImage *)imageForSecurityLevel:(LinphoneChatRoomSecurityLevel)level {
|
switch (level) {
|
case LinphoneChatRoomSecurityLevelUnsafe:
|
return [UIImage imageNamed:@"security_alert_indicator.png"];
|
case LinphoneChatRoomSecurityLevelEncrypted:
|
return [UIImage imageNamed:@"security_1_indicator.png.png"];
|
case LinphoneChatRoomSecurityLevelSafe:
|
return [UIImage imageNamed:@"security_2_indicator.png.png"];
|
|
default:
|
return nil;
|
}
|
}
|
|
+ (Contact *)getContact:(NSString *)address {
|
if (LinphoneManager.instance.fastAddressBook != nil) {
|
@synchronized(LinphoneManager.instance.fastAddressBook.addressBookMap) {
|
return [LinphoneManager.instance.fastAddressBook.addressBookMap objectForKey:address];
|
}
|
}
|
return nil;
|
}
|
|
+ (Contact *)getContactWithAddress:(const LinphoneAddress *)address {
|
Contact *contact = nil;
|
if (address) {
|
char *uri = linphone_address_as_string_uri_only(address);
|
NSString *normalizedSipAddress = [FastAddressBook normalizeSipURI:[NSString stringWithUTF8String:uri]];
|
contact = [FastAddressBook getContact:normalizedSipAddress];
|
ms_free(uri);
|
|
if (!contact) {
|
LinphoneFriend *friend = linphone_core_find_friend(LC, address);
|
MSList *numbers = linphone_friend_get_phone_numbers(friend);
|
while (numbers) {
|
NSString *phone = [NSString stringWithUTF8String:numbers->data];
|
LinphoneAccount *account = linphone_core_get_default_account(LC);
|
|
if (account) {
|
const char *normvalue = linphone_account_normalize_phone_number(account, phone.UTF8String);
|
LinphoneAddress *addr = linphone_account_normalize_sip_uri(account, normvalue);
|
char *phone_addr = linphone_address_as_string_uri_only(addr);
|
contact = [FastAddressBook getContact:[NSString stringWithUTF8String:phone_addr]];
|
ms_free(phone_addr);
|
} else {
|
contact = [FastAddressBook getContact:phone];
|
}
|
|
if (contact) {
|
break;
|
}
|
numbers = numbers->next;
|
}
|
}
|
}
|
return contact;
|
}
|
|
+ (BOOL)isSipURI:(NSString *)address {
|
return [address hasPrefix:@"sip:"] || [address hasPrefix:@"sips:"];
|
}
|
|
+ (BOOL)isSipAddress:(CNLabeledValue<CNInstantMessageAddress *> *)sipAddr {
|
NSString *username = sipAddr.value.username;
|
NSString *service = sipAddr.value.service;
|
LOGI(@"Parsing contact with username : %@ and service : %@", username, service);
|
if (!username || [username isEqualToString:@""])
|
return FALSE;
|
|
if (!service || [service isEqualToString:@""])
|
return [FastAddressBook isSipURI:username];
|
|
// use caseInsensitiveCompare, because ios13 saves "SIP" by "Sip"
|
if ([service caseInsensitiveCompare:LinphoneManager.instance.contactSipField] == NSOrderedSame)
|
return TRUE;
|
|
return FALSE;
|
}
|
|
+ (NSString *)normalizeSipURI:(NSString *)address {
|
// replace all whitespaces (non-breakable, utf8 nbsp etc.) by the "classical" whitespace
|
NSString *normalizedSipAddress = nil;
|
LinphoneAddress *addr = linphone_core_interpret_url(LC, [address UTF8String]);
|
if (addr != NULL) {
|
linphone_address_clean(addr);
|
char *tmp = linphone_address_as_string(addr);
|
normalizedSipAddress = [NSString stringWithUTF8String:tmp];
|
ms_free(tmp);
|
linphone_address_destroy(addr);
|
return normalizedSipAddress;
|
}else {
|
normalizedSipAddress = [[address componentsSeparatedByCharactersInSet:[NSCharacterSet whitespaceCharacterSet]] componentsJoinedByString:@" "];
|
return normalizedSipAddress;
|
}
|
}
|
|
+ (BOOL)isAuthorized {
|
return [CNContactStore authorizationStatusForEntityType:CNEntityTypeContacts];
|
}
|
|
- (FastAddressBook *)init {
|
if ((self = [super init]) != nil) {
|
store = [[CNContactStore alloc] init];
|
_addressBookMap = [NSMutableDictionary dictionary];
|
|
[NSNotificationCenter.defaultCenter addObserver:self
|
selector:@selector(onPresenceChanged:)
|
name:kLinphoneNotifyPresenceReceivedForUriOrTel
|
object:nil];
|
}
|
self.needToUpdate = FALSE;
|
if (floor(NSFoundationVersionNumber) >= NSFoundationVersionNumber_iOS_9_x_Max) {
|
if ([CNContactStore class]) {
|
// ios9 or later
|
if (store == NULL)
|
store = [[CNContactStore alloc] init];
|
[self fetchContactsInBackGroundThread];
|
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(updateAddressBook:) name:CNContactStoreDidChangeNotification object:nil];
|
}
|
}
|
return self;
|
}
|
|
- (void) fetchContactsInBackGroundThread{
|
[_addressBookMap removeAllObjects];
|
_addressBookMap = [NSMutableDictionary dictionary];
|
CNEntityType entityType = CNEntityTypeContacts;
|
[store requestAccessForEntityType:entityType completionHandler:^(BOOL granted, NSError *_Nullable error) {
|
BOOL success = FALSE;
|
if(granted){
|
LOGD(@"CNContactStore authorization granted");
|
|
NSError *contactError;
|
CNContactStore* store = [[CNContactStore alloc] init];
|
[store containersMatchingPredicate:[CNContainer predicateForContainersWithIdentifiers:@[ store.defaultContainerIdentifier]] error:&contactError];
|
NSArray *keysToFetch = @[
|
CNContactEmailAddressesKey, CNContactPhoneNumbersKey,
|
CNContactFamilyNameKey, CNContactGivenNameKey, CNContactNicknameKey,
|
CNContactPostalAddressesKey, CNContactIdentifierKey,
|
CNInstantMessageAddressUsernameKey, CNContactInstantMessageAddressesKey,
|
CNInstantMessageAddressUsernameKey, CNContactImageDataKey, CNContactOrganizationNameKey
|
];
|
CNContactFetchRequest *request = [[CNContactFetchRequest alloc] initWithKeysToFetch:keysToFetch];
|
|
success = [store enumerateContactsWithFetchRequest:request error:&contactError usingBlock:^(CNContact *__nonnull contact, BOOL *__nonnull stop) {
|
if (contactError) {
|
NSLog(@"error fetching contacts %@",
|
contactError);
|
} else {
|
Contact *newContact = [[Contact alloc] initWithCNContact:contact];
|
[self registerAddrsFor:newContact];
|
}
|
}];
|
}
|
|
// load Linphone friends
|
const MSList *lists = linphone_core_get_friends_lists(LC);
|
while (lists) {
|
LinphoneFriendList *fl = lists->data;
|
const MSList *friends = linphone_friend_list_get_friends(fl);
|
while (friends) {
|
LinphoneFriend *f = friends->data;
|
// only append friends that are not native contacts (already added
|
// above)
|
if (linphone_friend_get_ref_key(f) == NULL) {
|
Contact *contact = [[Contact alloc] initWithFriend:f];
|
[self registerAddrsFor:contact];
|
}
|
friends = friends->next;
|
}
|
linphone_friend_list_update_subscriptions(fl);
|
lists = lists->next;
|
}
|
[self dumpContactsDisplayNamesToUserDefaults];
|
|
[NSNotificationCenter.defaultCenter
|
postNotificationName:kLinphoneAddressBookUpdate
|
object:self];
|
}];
|
}
|
|
-(void) updateAddressBook:(NSNotification*) notif {
|
LOGD(@"address book has changed");
|
self.needToUpdate = TRUE;
|
}
|
|
- (void)registerAddrsFor:(Contact *)contact {
|
if (!contact)
|
return;
|
|
Contact* mContact = contact;
|
if (!_addressBookMap)
|
return;
|
|
LinphoneAccount *account = linphone_core_get_default_account(LC);
|
|
for (NSString *phone in mContact.phones) {
|
char *normalizedPhone = account? linphone_account_normalize_phone_number(account, phone.UTF8String) : nil;
|
NSString *name = [FastAddressBook normalizeSipURI:normalizedPhone ? [NSString stringWithUTF8String:normalizedPhone] : phone];
|
if (phone != NULL)
|
[_addressBookMap setObject:mContact forKey:(name ?: [FastAddressBook localizedLabel:phone])];
|
|
if (normalizedPhone)
|
ms_free(normalizedPhone);
|
}
|
|
for (NSString *sip in mContact.sipAddresses)
|
[_addressBookMap setObject:mContact forKey:([FastAddressBook normalizeSipURI:sip] ?: sip)];
|
}
|
|
#pragma mark - Tools
|
|
+ (NSString *)localizedLabel:(NSString *)label {
|
if (label)
|
return [CNLabeledValue localizedStringForLabel:label];
|
|
return @"";
|
}
|
|
+ (BOOL)contactHasValidSipDomain:(Contact *)contact {
|
if (!contact)
|
return NO;
|
|
// Check if one of the contact' sip URI matches the expected SIP filter
|
NSString *domain = LinphoneManager.instance.contactFilter;
|
|
for (NSString *sip in contact.sipAddresses) {
|
// check domain
|
LinphoneAddress *address = linphone_core_interpret_url(LC, sip.UTF8String);
|
if (address) {
|
const char *dom = linphone_address_get_domain(address);
|
BOOL match = false;
|
if (dom != NULL) {
|
NSString *contactDomain = [NSString stringWithCString:dom encoding:[NSString defaultCStringEncoding]];
|
match = (([domain compare:@"*" options:NSCaseInsensitiveSearch] == NSOrderedSame) ||
|
([domain compare:contactDomain options:NSCaseInsensitiveSearch] == NSOrderedSame));
|
}
|
linphone_address_destroy(address);
|
if (match)
|
return YES;
|
}
|
}
|
return NO;
|
}
|
|
+ (BOOL) isSipURIValid:(NSString*)addr {
|
NSString *domain = LinphoneManager.instance.contactFilter;
|
LinphoneAddress* address = linphone_core_interpret_url(LC, addr.UTF8String);
|
if (address) {
|
const char *dom = linphone_address_get_domain(address);
|
BOOL match = false;
|
if (dom != NULL) {
|
NSString *contactDomain = [NSString stringWithCString:dom encoding:[NSString defaultCStringEncoding]];
|
match = (([domain compare:@"*" options:NSCaseInsensitiveSearch] == NSOrderedSame) ||
|
([domain compare:contactDomain options:NSCaseInsensitiveSearch] == NSOrderedSame));
|
}
|
linphone_address_destroy(address);
|
if (match) {
|
return YES;
|
}
|
}
|
return NO;
|
}
|
|
+ (NSString *)displayNameForContact:(Contact *)contact {
|
return contact.displayName;
|
}
|
|
+ (NSString *)displayNameForAddress:(const LinphoneAddress *)addr {
|
Contact *contact = [FastAddressBook getContactWithAddress:addr];
|
if (contact && ![contact.displayName isEqualToString:NSLocalizedString(@"Unknown", nil)])
|
return [FastAddressBook displayNameForContact:contact];
|
|
LinphoneFriend *friend = linphone_core_find_friend(LC, addr);
|
if (friend)
|
return [NSString stringWithUTF8String:linphone_friend_get_name(friend)];
|
|
const char *displayName = linphone_address_get_display_name(addr);
|
if (displayName)
|
return [NSString stringWithUTF8String:displayName];
|
|
const char *userName = linphone_address_get_username(addr);
|
if (userName)
|
return [NSString stringWithUTF8String:userName];
|
|
return NSLocalizedString(@"Unknown", nil);
|
}
|
|
|
- (CNContact *)getCNContactFromContact:(Contact *)acontact {
|
NSArray *keysToFetch = @[
|
CNContactEmailAddressesKey, CNContactPhoneNumbersKey,
|
CNContactFamilyNameKey, CNContactGivenNameKey, CNContactPostalAddressesKey,
|
CNContactIdentifierKey, CNContactInstantMessageAddressesKey,
|
CNInstantMessageAddressUsernameKey, CNContactImageDataKey
|
];
|
CNMutableContact *mCNContact =
|
[[store unifiedContactWithIdentifier:acontact.identifier
|
keysToFetch:keysToFetch
|
error:nil] mutableCopy];
|
return mCNContact;
|
}
|
|
- (BOOL)deleteCNContact:(CNContact *)contact {
|
return TRUE;//[self deleteContact:] ;
|
}
|
|
- (BOOL)deleteContact:(Contact *)contact {
|
[self removeContactFromUserDefaults:contact];
|
|
CNSaveRequest *saveRequest = [[CNSaveRequest alloc] init];
|
NSArray *keysToFetch = @[
|
CNContactEmailAddressesKey, CNContactPhoneNumbersKey,
|
CNContactInstantMessageAddressesKey, CNInstantMessageAddressUsernameKey,
|
CNContactFamilyNameKey, CNContactGivenNameKey, CNContactPostalAddressesKey,
|
CNContactIdentifierKey, CNContactImageDataKey, CNContactNicknameKey
|
];
|
CNMutableContact *mCNContact =
|
[[store unifiedContactWithIdentifier:contact.identifier
|
keysToFetch:keysToFetch
|
error:nil] mutableCopy];
|
if(mCNContact != nil){
|
[saveRequest deleteContact:mCNContact];
|
@try {
|
[self removeFriend:contact ];
|
[LinphoneManager.instance setContactsUpdated:TRUE];
|
if([contact.sipAddresses count] > 0){
|
for (NSString *sip in contact.sipAddresses) {
|
[_addressBookMap removeObjectForKey:([FastAddressBook normalizeSipURI:sip] ?: sip)];
|
}
|
}
|
if([contact.phones count] > 0){
|
for (NSString *phone in contact.phones) {
|
[_addressBookMap removeObjectForKey:([FastAddressBook normalizeSipURI:phone] ?: phone)];
|
}
|
}
|
BOOL success = [store executeSaveRequest:saveRequest error:nil];
|
NSLog(@"Success %d", success);
|
} @catch (NSException *exception) {
|
NSLog(@"description = %@", [exception description]);
|
return FALSE;
|
}
|
}
|
return TRUE;
|
}
|
|
|
- (BOOL)deleteAllContacts {
|
NSArray *keys = @[ CNContactPhoneNumbersKey ];
|
NSString *containerId = store.defaultContainerIdentifier;
|
NSPredicate *predicate = [CNContact predicateForContactsInContainerWithIdentifier:containerId];
|
NSError *error;
|
NSArray *cnContacts = [store unifiedContactsMatchingPredicate:predicate
|
keysToFetch:keys
|
error:&error];
|
if (error) {
|
NSLog(@"error fetching contacts %@", error);
|
return FALSE;
|
} else {
|
CNSaveRequest *saveRequest = [[CNSaveRequest alloc] init];
|
for (CNContact *contact in cnContacts) {
|
[saveRequest deleteContact:[contact mutableCopy]];
|
}
|
@try {
|
NSLog(@"Success %d", [store executeSaveRequest:saveRequest error:nil]);
|
} @catch (NSException *exception) {
|
NSLog(@"description = %@", [exception description]);
|
return FALSE;
|
}
|
NSLog(@"Deleted contacts %lu", (unsigned long)cnContacts.count);
|
}
|
return TRUE;
|
}
|
|
- (BOOL)saveContact:(Contact *)contact {
|
return [self saveCNContact:contact.person contact:contact];
|
}
|
|
- (BOOL)saveCNContact:(CNContact *)cNContact contact:(Contact *)contact {
|
CNSaveRequest *saveRequest = [[CNSaveRequest alloc] init];
|
NSArray *keysToFetch = @[
|
CNContactEmailAddressesKey, CNContactPhoneNumbersKey,
|
CNContactInstantMessageAddressesKey, CNInstantMessageAddressUsernameKey,
|
CNContactFamilyNameKey, CNContactGivenNameKey, CNContactPostalAddressesKey,
|
CNContactIdentifierKey, CNContactImageDataKey, CNContactNicknameKey
|
];
|
CNMutableContact *mCNContact =
|
[[store unifiedContactWithIdentifier:contact.identifier
|
keysToFetch:keysToFetch
|
error:nil] mutableCopy];
|
if(mCNContact == NULL){
|
[saveRequest addContact:[cNContact mutableCopy] toContainerWithIdentifier:nil];
|
}else{
|
[mCNContact setGivenName:contact.firstName];
|
[mCNContact setFamilyName:contact.lastName];
|
[mCNContact setNickname:contact.displayName];
|
[mCNContact setPhoneNumbers:contact.person.phoneNumbers];
|
[mCNContact setEmailAddresses:contact.person.emailAddresses];
|
[mCNContact
|
setInstantMessageAddresses:contact.person.instantMessageAddresses];
|
[mCNContact setImageData:UIImageJPEGRepresentation(contact.avatar, 0.9f)];
|
|
[saveRequest updateContact:mCNContact];
|
}
|
NSError *saveError;
|
@try {
|
[self updateFriend:contact];
|
[LinphoneManager.instance setContactsUpdated:TRUE];
|
NSLog(@"Success %d", [store executeSaveRequest:saveRequest error:&saveError]);
|
} @catch (NSException *exception) {
|
NSLog(@"=====>>>>> CNContact SaveRequest failed : description = %@", [exception description]);
|
return FALSE;
|
}
|
[self fetchContactsInBackGroundThread];
|
return TRUE;
|
}
|
|
-(void)updateFriend:(Contact*) contact{
|
bctbx_list_t *phonesList = linphone_friend_get_phone_numbers(contact.friend);
|
for (NSString *phone in contact.phones) {
|
if(!(bctbx_list_find(phonesList, [phone UTF8String]))){
|
linphone_friend_edit(contact.friend);
|
linphone_friend_add_phone_number(contact.friend, [phone UTF8String]);
|
linphone_friend_enable_subscribes(contact.friend, TRUE);
|
linphone_friend_done(contact.friend);
|
}
|
}
|
|
BOOL enabled = [LinphoneManager.instance lpConfigBoolForKey:@"use_rls_presence"];
|
const MSList *lists = linphone_core_get_friends_lists(LC);
|
while (lists) {
|
linphone_friend_list_enable_subscriptions(lists->data, FALSE);
|
linphone_friend_list_enable_subscriptions(lists->data, enabled);
|
linphone_friend_list_update_subscriptions(lists->data);
|
lists = lists->next;
|
}
|
}
|
|
-(void)removeFriend:(Contact*) contact{
|
BOOL enabled = [LinphoneManager.instance lpConfigBoolForKey:@"use_rls_presence"];
|
const MSList *lists = linphone_core_get_friends_lists(LC);
|
while (lists) {
|
linphone_friend_list_remove_friend(lists->data, contact.friend);
|
linphone_friend_list_enable_subscriptions(lists->data, FALSE);
|
linphone_friend_list_enable_subscriptions(lists->data, enabled);
|
linphone_friend_list_update_subscriptions(lists->data);
|
lists = lists->next;
|
}
|
}
|
|
- (void)reloadFriends {
|
dispatch_async(dispatch_get_main_queue(), ^{
|
[_addressBookMap enumerateKeysAndObjectsUsingBlock:^(NSString *name, Contact *contact, BOOL *stop) {
|
[contact reloadFriend];
|
}];
|
});
|
}
|
|
- (void)clearFriends {
|
[_addressBookMap enumerateKeysAndObjectsUsingBlock:^(NSString *name, Contact *contact, BOOL *stop) {
|
[contact clearFriend];
|
}];
|
}
|
|
- (void)dumpContactsDisplayNamesToUserDefaults {
|
LOGD(@"dumpContactsDisplayNamesToUserDefaults");
|
NSUserDefaults *defaults = [[NSUserDefaults alloc] initWithSuiteName:kLinphoneMsgNotificationAppGroupId];
|
__block NSDictionary *oldDisplayNames = [defaults dictionaryForKey:@"addressBook"];
|
LinphoneAccount *account = linphone_core_get_default_account(LC);
|
|
__block NSMutableDictionary *displayNames = [[NSMutableDictionary dictionary] init];
|
[_addressBookMap enumerateKeysAndObjectsUsingBlock:^(NSString *name, Contact *contact, BOOL *stop) {
|
if ([FastAddressBook isSipURIValid:name]) {
|
NSString *key = name;
|
LinphoneAddress *addr = linphone_address_new(name.UTF8String);
|
|
if (addr && linphone_account_is_phone_number(account, linphone_address_get_username(addr))) {
|
if (oldDisplayNames[name] != nil && [FastAddressBook isSipURI:oldDisplayNames[name]]) {
|
NSString *addrForTel = [NSString stringWithString:oldDisplayNames[name]];
|
/* we keep the link between tel number and sip addr to have the information quickly.
|
If we don't do that, between the startup and presence callback we don't have the dispay name for this address */
|
LOGD(@"add %s -> %s link to userdefaults", name.UTF8String, addrForTel.UTF8String);
|
[displayNames setObject:addrForTel forKey:name];
|
key = addrForTel;
|
}
|
}
|
LOGD(@"add %s to userdefaults", key.UTF8String);
|
[displayNames setObject:[contact displayName] forKey:key];
|
linphone_address_unref(addr);
|
} else {
|
LOGD(@"cannot add %s to userdefaults: bad sip address", name.UTF8String);
|
}
|
}];
|
|
[defaults setObject:displayNames forKey:@"addressBook"];
|
}
|
|
- (void)removeContactFromUserDefaults:(Contact *)contact {
|
LOGD(@"removeContactFromUserDefaults contact: [%p]", contact);
|
NSUserDefaults *defaults = [[NSUserDefaults alloc] initWithSuiteName:kLinphoneMsgNotificationAppGroupId];
|
NSMutableDictionary *displayNames = [[NSMutableDictionary alloc] initWithDictionary:[defaults dictionaryForKey:@"addressBook"]];
|
if (displayNames == nil) return;
|
|
|
LinphoneAccount *account = linphone_core_get_default_account(LC);
|
for (NSString *phone in contact.phones) {
|
char *normalizedPhone = account? linphone_account_normalize_phone_number(account, phone.UTF8String) : nil;
|
NSString *name = [FastAddressBook normalizeSipURI:normalizedPhone ? [NSString stringWithUTF8String:normalizedPhone] : phone];
|
if (phone != NULL) {
|
if ([FastAddressBook isSipURI:displayNames[name]]) {
|
LOGD(@"removed %s from userdefaults addressBook", ((NSString *)displayNames[name]).UTF8String);
|
[displayNames removeObjectForKey:displayNames[name]];
|
}
|
[displayNames removeObjectForKey:name];
|
LOGD(@"removed %s from userdefaults addressBook", ((NSString *)name).UTF8String);
|
}
|
|
if (normalizedPhone)
|
ms_free(normalizedPhone);
|
}
|
|
NSMutableArray *addresses = contact.sipAddresses;
|
for (id addr in addresses) {
|
[displayNames removeObjectForKey:addr];
|
LOGD(@"removed %s from userdefaults addressBook", ((NSString *)addr).UTF8String);
|
}
|
|
[defaults setObject:displayNames forKey:@"addressBook"];
|
}
|
|
- (void)onPresenceChanged:(NSNotification *)k {
|
NSString *uri = [NSString stringWithUTF8String:[[k.userInfo valueForKey:@"uri"] pointerValue]];
|
NSString *telAddr;
|
|
if ([FastAddressBook isSipURI:uri]) {
|
LinphoneAddress *addr = linphone_address_new(uri.UTF8String);
|
if (linphone_account_is_phone_number(linphone_core_get_default_account(LC), linphone_address_get_username(addr))) {
|
telAddr = uri;
|
}
|
linphone_address_unref(addr);
|
} else {
|
telAddr = [FastAddressBook normalizeSipURI:uri];
|
}
|
|
if (telAddr) {
|
LOGD(@"presence changed for tel [%s]", telAddr.UTF8String);
|
|
NSUserDefaults *defaults = [[NSUserDefaults alloc] initWithSuiteName:kLinphoneMsgNotificationAppGroupId];
|
NSMutableDictionary *displayNames = [[NSMutableDictionary alloc] initWithDictionary:[defaults dictionaryForKey:@"addressBook"]];
|
if (displayNames == nil) return;
|
|
id displayName = [displayNames objectForKey:telAddr];
|
if (displayName == nil) return;
|
|
const LinphonePresenceModel *m = [[k.userInfo valueForKey:@"presence_model"] pointerValue];
|
char *str = linphone_presence_model_get_contact(m);
|
if (str == nil) {
|
return;
|
}
|
|
NSString *contact = [NSString stringWithUTF8String:str];
|
ms_free(str);
|
NSString *sipAddr = [FastAddressBook normalizeSipURI:contact];
|
|
if (sipAddr != nil && [displayNames objectForKey:sipAddr] == nil) {
|
[displayNames setObject:displayName forKey:sipAddr];
|
[displayNames removeObjectForKey:telAddr];
|
[displayNames setObject:sipAddr forKey:telAddr];
|
LOGD(@"add %s -> %s link to userdefaults", telAddr.UTF8String, sipAddr.UTF8String);
|
/* we keep the link between tel number and sip addr to have the information on the next startup.
|
If we don't do that, between the startup and this callback we don't have the dispay name for this address */
|
LOGD(@"Replaced %s by %s in userdefaults addressBook", telAddr.UTF8String, sipAddr.UTF8String);
|
[defaults setObject:displayNames forKey:@"addressBook"];
|
}
|
}
|
}
|
|
@end
|
