/*
|
* Copyright (c) 2010-2019 Belledonne Communications SARL.
|
*
|
* This file is part of linphone-android
|
* (see https://www.linphone.org).
|
*
|
* 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/>.
|
*/
|
package org.linphone.contacts;
|
|
import static android.os.AsyncTask.THREAD_POOL_EXECUTOR;
|
|
import android.Manifest;
|
import android.accounts.Account;
|
import android.accounts.AccountManager;
|
import android.content.ContentProviderClient;
|
import android.content.ContentProviderOperation;
|
import android.content.ContentResolver;
|
import android.content.ContentValues;
|
import android.content.Context;
|
import android.content.pm.PackageManager;
|
import android.database.ContentObserver;
|
import android.database.Cursor;
|
import android.net.Uri;
|
import android.os.Handler;
|
import android.os.Looper;
|
import android.os.RemoteException;
|
import android.provider.ContactsContract;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.List;
|
import java.util.Locale;
|
import org.linphone.LinphoneContext;
|
import org.linphone.LinphoneManager;
|
import org.linphone.R;
|
import org.linphone.compatibility.Compatibility;
|
import org.linphone.core.Address;
|
import org.linphone.core.Core;
|
import org.linphone.core.Friend;
|
import org.linphone.core.FriendList;
|
import org.linphone.core.FriendListListener;
|
import org.linphone.core.MagicSearch;
|
import org.linphone.core.PresenceBasicStatus;
|
import org.linphone.core.PresenceModel;
|
import org.linphone.core.ProxyConfig;
|
import org.linphone.core.tools.Log;
|
import org.linphone.settings.LinphonePreferences;
|
|
public class ContactsManager extends ContentObserver
|
implements FriendListListener, LinphoneContext.CoreStartedListener {
|
private List<LinphoneContact> mContacts, mSipContacts;
|
private final ArrayList<ContactsUpdatedListener> mContactsUpdatedListeners;
|
private MagicSearch mMagicSearch;
|
private boolean mContactsFetchedOnce = false;
|
private Context mContext;
|
private AsyncContactsLoader mLoadContactTask;
|
private boolean mInitialized = false;
|
|
public static ContactsManager getInstance() {
|
return LinphoneContext.instance().getContactsManager();
|
}
|
|
public ContactsManager(Context context) {
|
super(new Handler(Looper.getMainLooper()));
|
mContext = context;
|
mContactsUpdatedListeners = new ArrayList<>();
|
mContacts = new ArrayList<>();
|
mSipContacts = new ArrayList<>();
|
|
if (LinphoneManager.getCore() != null) {
|
mMagicSearch = LinphoneManager.getCore().createMagicSearch();
|
mMagicSearch.setLimitedSearch(false); // Do not limit the number of results
|
}
|
|
LinphoneContext.instance().addCoreStartedListener(this);
|
}
|
|
public void addContactsListener(ContactsUpdatedListener listener) {
|
mContactsUpdatedListeners.add(listener);
|
}
|
|
public void removeContactsListener(ContactsUpdatedListener listener) {
|
mContactsUpdatedListeners.remove(listener);
|
}
|
|
public ArrayList<ContactsUpdatedListener> getContactsListeners() {
|
return mContactsUpdatedListeners;
|
}
|
|
@Override
|
public void onChange(boolean selfChange) {
|
onChange(selfChange, null);
|
}
|
|
@Override
|
public void onChange(boolean selfChange, Uri uri) {
|
Log.i("[Contacts Manager] Content observer detected a changing in at least one contact");
|
fetchContactsAsync();
|
}
|
|
@Override
|
public void onCoreStarted() {
|
// Core has been started, fetch contacts again in case there are some
|
// in the configuration file or remote provisioning
|
fetchContactsAsync();
|
}
|
|
public synchronized List<LinphoneContact> getContacts() {
|
return mContacts;
|
}
|
|
synchronized void setContacts(List<LinphoneContact> c) {
|
mContacts = c;
|
}
|
|
public synchronized List<LinphoneContact> getSIPContacts() {
|
return mSipContacts;
|
}
|
|
synchronized void setSipContacts(List<LinphoneContact> c) {
|
mSipContacts = c;
|
}
|
|
public void destroy() {
|
mContext.getContentResolver().unregisterContentObserver(this);
|
LinphoneContext.instance().removeCoreStartedListener(this);
|
|
if (mLoadContactTask != null) {
|
mLoadContactTask.cancel(true);
|
}
|
// LinphoneContact has a Friend field and Friend can have a LinphoneContact has userData
|
// Friend also keeps a ref on the Core, so we have to clean them
|
for (LinphoneContact c : mContacts) {
|
c.setFriend(null);
|
}
|
mContacts.clear();
|
for (LinphoneContact c : mSipContacts) {
|
c.setFriend(null);
|
}
|
mSipContacts.clear();
|
|
Core core = LinphoneManager.getCore();
|
if (core != null) {
|
for (FriendList list : core.getFriendsLists()) {
|
list.removeListener(this);
|
}
|
}
|
}
|
|
public void fetchContactsAsync() {
|
if (mLoadContactTask != null) {
|
mLoadContactTask.cancel(true);
|
}
|
|
if (!hasReadContactsAccess()) {
|
Log.w(
|
"[Contacts Manager] Can't fetch native contacts without READ_CONTACTS permission");
|
}
|
|
mLoadContactTask = new AsyncContactsLoader(mContext);
|
mContactsFetchedOnce = true;
|
mLoadContactTask.executeOnExecutor(THREAD_POOL_EXECUTOR);
|
}
|
|
public MagicSearch getMagicSearch() {
|
return mMagicSearch;
|
}
|
|
public boolean contactsFetchedOnce() {
|
return mContactsFetchedOnce;
|
}
|
|
public List<LinphoneContact> getContacts(String search) {
|
search = search.toLowerCase(Locale.getDefault());
|
List<LinphoneContact> searchContactsBegin = new ArrayList<>();
|
List<LinphoneContact> searchContactsContain = new ArrayList<>();
|
for (LinphoneContact contact : getContacts()) {
|
if (contact.getFullName() != null) {
|
if (contact.getFullName().toLowerCase(Locale.getDefault()).startsWith(search)) {
|
searchContactsBegin.add(contact);
|
} else if (contact.getFullName()
|
.toLowerCase(Locale.getDefault())
|
.contains(search)) {
|
searchContactsContain.add(contact);
|
}
|
}
|
}
|
searchContactsBegin.addAll(searchContactsContain);
|
return searchContactsBegin;
|
}
|
|
public List<LinphoneContact> getSIPContacts(String search) {
|
search = search.toLowerCase(Locale.getDefault());
|
List<LinphoneContact> searchContactsBegin = new ArrayList<>();
|
List<LinphoneContact> searchContactsContain = new ArrayList<>();
|
for (LinphoneContact contact : getSIPContacts()) {
|
if (contact.getFullName() != null) {
|
if (contact.getFullName().toLowerCase(Locale.getDefault()).startsWith(search)) {
|
searchContactsBegin.add(contact);
|
} else if (contact.getFullName()
|
.toLowerCase(Locale.getDefault())
|
.contains(search)) {
|
searchContactsContain.add(contact);
|
}
|
}
|
}
|
searchContactsBegin.addAll(searchContactsContain);
|
return searchContactsBegin;
|
}
|
|
public void enableContactsAccess() {
|
LinphonePreferences.instance().disableFriendsStorage();
|
}
|
|
public boolean hasReadContactsAccess() {
|
if (mContext == null || mContext.getPackageManager() == null) {
|
return false;
|
}
|
|
boolean contactsR =
|
(PackageManager.PERMISSION_GRANTED
|
== mContext.getPackageManager()
|
.checkPermission(
|
android.Manifest.permission.READ_CONTACTS,
|
mContext.getPackageName()));
|
return contactsR
|
&& !mContext.getResources().getBoolean(R.bool.force_use_of_linphone_friends);
|
}
|
|
private boolean hasWriteContactsAccess() {
|
if (mContext == null) {
|
return false;
|
}
|
|
return (PackageManager.PERMISSION_GRANTED
|
== mContext.getPackageManager()
|
.checkPermission(
|
Manifest.permission.WRITE_CONTACTS, mContext.getPackageName()));
|
}
|
|
private boolean hasWriteSyncPermission() {
|
if (mContext == null) {
|
return false;
|
}
|
|
return (PackageManager.PERMISSION_GRANTED
|
== mContext.getPackageManager()
|
.checkPermission(
|
Manifest.permission.WRITE_SYNC_SETTINGS,
|
mContext.getPackageName()));
|
}
|
|
public boolean isLinphoneContactsPrefered() {
|
ProxyConfig lpc = LinphoneManager.getCore().getDefaultProxyConfig();
|
return lpc != null
|
&& lpc.getIdentityAddress()
|
.getDomain()
|
.equals(mContext.getString(R.string.default_domain));
|
}
|
|
public void initializeContactManager() {
|
if (!mInitialized) {
|
if (mContext.getResources().getBoolean(R.bool.use_linphone_tag)) {
|
if (hasReadContactsAccess()
|
&& hasWriteContactsAccess()
|
&& hasWriteSyncPermission()) {
|
if (LinphoneContext.isReady()) {
|
initializeSyncAccount();
|
mInitialized = true;
|
}
|
}
|
}
|
}
|
}
|
|
private void makeContactAccountVisible() {
|
ContentProviderClient client =
|
mContext.getContentResolver()
|
.acquireContentProviderClient(ContactsContract.AUTHORITY_URI);
|
if (client == null) {
|
Log.e(
|
"[Contacts Manager] Failed to get content provider client for contacts authority!");
|
return;
|
}
|
|
ContentValues values = new ContentValues();
|
values.put(
|
ContactsContract.Settings.ACCOUNT_NAME,
|
mContext.getString(R.string.sync_account_name));
|
values.put(
|
ContactsContract.Settings.ACCOUNT_TYPE,
|
mContext.getString(R.string.sync_account_type));
|
values.put(ContactsContract.Settings.UNGROUPED_VISIBLE, true);
|
|
try {
|
client.insert(
|
ContactsContract.Settings.CONTENT_URI
|
.buildUpon()
|
.appendQueryParameter(ContactsContract.CALLER_IS_SYNCADAPTER, "true")
|
.build(),
|
values);
|
Log.i("[Contacts Manager] Contacts account made visible");
|
} catch (RemoteException e) {
|
Log.e("[Contacts Manager] Couldn't make contacts account visible: " + e);
|
}
|
Compatibility.closeContentProviderClient(client);
|
}
|
|
private void initializeSyncAccount() {
|
AccountManager accountManager =
|
(AccountManager) mContext.getSystemService(Context.ACCOUNT_SERVICE);
|
|
Account[] accounts =
|
accountManager.getAccountsByType(mContext.getString(R.string.sync_account_type));
|
|
if (accounts != null && accounts.length == 0) {
|
Account newAccount =
|
new Account(
|
mContext.getString(R.string.sync_account_name),
|
mContext.getString(R.string.sync_account_type));
|
try {
|
accountManager.addAccountExplicitly(newAccount, null, null);
|
Log.i("[Contacts Manager] Contact account added");
|
makeContactAccountVisible();
|
} catch (Exception e) {
|
Log.e("[Contacts Manager] Couldn't initialize sync account: " + e);
|
}
|
} else if (accounts != null) {
|
for (Account account : accounts) {
|
Log.i(
|
"[Contacts Manager] Found account with name \""
|
+ account.name
|
+ "\" and type \""
|
+ account.type
|
+ "\"");
|
makeContactAccountVisible();
|
}
|
}
|
}
|
|
public String getAndroidContactIdFromUri(Uri uri) {
|
String[] projection = {ContactsContract.CommonDataKinds.SipAddress.CONTACT_ID};
|
Cursor cursor =
|
mContext.getApplicationContext()
|
.getContentResolver()
|
.query(uri, projection, null, null, null);
|
cursor.moveToFirst();
|
|
int nameColumnIndex =
|
cursor.getColumnIndex(ContactsContract.CommonDataKinds.SipAddress.CONTACT_ID);
|
String id = cursor.getString(nameColumnIndex);
|
cursor.close();
|
return id;
|
}
|
|
public synchronized LinphoneContact findContactFromAndroidId(String androidId) {
|
if (androidId == null) {
|
return null;
|
}
|
|
for (LinphoneContact c : getContacts()) {
|
if (c.getAndroidId() != null && c.getAndroidId().equals(androidId)) {
|
return c;
|
}
|
}
|
return null;
|
}
|
|
public synchronized LinphoneContact findContactFromAddress(Address address) {
|
if (address == null) return null;
|
Core core = LinphoneManager.getCore();
|
|
Friend lf = core.findFriend(address);
|
if (lf != null) {
|
return (LinphoneContact) lf.getUserData();
|
}
|
|
String username = address.getUsername();
|
if (username == null) {
|
Log.w("[Contacts Manager] Address ", address.asString(), " doesn't have a username!");
|
return null;
|
}
|
|
if (android.util.Patterns.PHONE.matcher(username).matches()) {
|
return findContactFromPhoneNumber(username);
|
}
|
|
return null;
|
}
|
|
public synchronized LinphoneContact findContactFromPhoneNumber(String phoneNumber) {
|
if (phoneNumber == null) return null;
|
|
if (!android.util.Patterns.PHONE.matcher(phoneNumber).matches()) {
|
Log.w(
|
"[Contacts Manager] Expected phone number but doesn't look like it: "
|
+ phoneNumber);
|
return null;
|
}
|
|
Core core = LinphoneManager.getCore();
|
ProxyConfig lpc = null;
|
if (core != null) {
|
lpc = core.getDefaultProxyConfig();
|
}
|
if (lpc == null) {
|
Log.i("[Contacts Manager] Couldn't find default proxy config...");
|
return null;
|
}
|
|
String normalized = lpc.normalizePhoneNumber(phoneNumber);
|
if (normalized == null) {
|
Log.w(
|
"[Contacts Manager] Couldn't normalize phone number "
|
+ phoneNumber
|
+ ", default proxy config prefix is "
|
+ lpc.getDialPrefix());
|
normalized = phoneNumber;
|
}
|
|
Address addr = lpc.normalizeSipUri(normalized);
|
if (addr == null) {
|
Log.w("[Contacts Manager] Couldn't normalize SIP URI " + normalized);
|
return null;
|
}
|
|
// Without this, the hashmap inside liblinphone won't find it...
|
addr.setUriParam("user", "phone");
|
Friend lf = core.findFriend(addr);
|
if (lf != null) {
|
return (LinphoneContact) lf.getUserData();
|
}
|
|
Log.w("[Contacts Manager] Couldn't find friend...");
|
return null;
|
}
|
|
public String getAddressOrNumberForAndroidContact(ContentResolver resolver, Uri contactUri) {
|
if (resolver == null || contactUri == null) return null;
|
|
// Phone Numbers
|
String[] projection = new String[] {ContactsContract.CommonDataKinds.Phone.NUMBER};
|
Cursor c = resolver.query(contactUri, projection, null, null, null);
|
if (c != null) {
|
if (c.moveToNext()) {
|
int numberIndex = c.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER);
|
String number = c.getString(numberIndex);
|
c.close();
|
return number;
|
}
|
c.close();
|
}
|
|
projection = new String[] {ContactsContract.CommonDataKinds.SipAddress.SIP_ADDRESS};
|
c = resolver.query(contactUri, projection, null, null, null);
|
if (c != null) {
|
if (c.moveToNext()) {
|
int numberIndex =
|
c.getColumnIndex(ContactsContract.CommonDataKinds.SipAddress.SIP_ADDRESS);
|
String address = c.getString(numberIndex);
|
c.close();
|
return address;
|
}
|
c.close();
|
}
|
|
return null;
|
}
|
|
private synchronized boolean refreshSipContact(Friend lf) {
|
if (lf == null) return false;
|
LinphoneContact contact = (LinphoneContact) lf.getUserData();
|
|
if (contact != null) {
|
if (LinphoneContext.instance()
|
.getApplicationContext()
|
.getResources()
|
.getBoolean(R.bool.use_linphone_tag)) {
|
if (LinphonePreferences.instance()
|
.isPresenceStorageInNativeAndroidContactEnabled()) {
|
// Inserting information in Android contact if the parameter is enabled
|
for (LinphoneNumberOrAddress noa : contact.getNumbersOrAddresses()) {
|
if (noa.isSIPAddress()) {
|
// We are only interested in phone numbers
|
continue;
|
}
|
String value = noa.getValue();
|
if (value == null || value.isEmpty()) {
|
continue;
|
}
|
|
// Test presence of the value
|
PresenceModel pm = contact.getFriend().getPresenceModelForUriOrTel(value);
|
// If presence is not null
|
if (pm != null
|
&& pm.getBasicStatus() != null
|
&& pm.getBasicStatus().equals(PresenceBasicStatus.Open)) {
|
// Add presence to native contact
|
AsyncContactPresence asyncContactPresence =
|
new AsyncContactPresence(contact, value);
|
asyncContactPresence.execute();
|
}
|
}
|
}
|
}
|
|
if (!mSipContacts.contains(contact)) {
|
mSipContacts.add(contact);
|
return true;
|
}
|
}
|
|
return false;
|
}
|
|
public void delete(String id) {
|
ArrayList<String> ids = new ArrayList<>();
|
ids.add(id);
|
deleteMultipleContactsAtOnce(ids);
|
}
|
|
public void deleteMultipleContactsAtOnce(List<String> ids) {
|
String select = ContactsContract.Data.CONTACT_ID + " = ?";
|
ArrayList<ContentProviderOperation> ops = new ArrayList<>();
|
|
for (String id : ids) {
|
Log.i("[Contacts Manager] Adding Android contact id ", id, " to batch removal");
|
String[] args = new String[] {id};
|
ops.add(
|
ContentProviderOperation.newDelete(ContactsContract.RawContacts.CONTENT_URI)
|
.withSelection(select, args)
|
.build());
|
}
|
|
try {
|
mContext.getContentResolver().applyBatch(ContactsContract.AUTHORITY, ops);
|
} catch (Exception e) {
|
Log.e("[Contacts Manager] " + e);
|
}
|
|
// To ensure removed contacts won't appear in the contacts list anymore
|
fetchContactsAsync();
|
}
|
|
public String getString(int resourceID) {
|
if (mContext == null) return null;
|
return mContext.getString(resourceID);
|
}
|
|
@Override
|
public void onContactCreated(FriendList list, Friend lf) {}
|
|
@Override
|
public void onContactDeleted(FriendList list, Friend lf) {}
|
|
@Override
|
public void onContactUpdated(FriendList list, Friend newFriend, Friend oldFriend) {}
|
|
@Override
|
public void onSyncStatusChanged(FriendList list, FriendList.SyncStatus status, String msg) {}
|
|
@Override
|
public void onPresenceReceived(FriendList list, Friend[] friends) {
|
boolean updated = false;
|
|
for (Friend lf : friends) {
|
boolean newContact = refreshSipContact(lf);
|
|
if (newContact) {
|
updated = true;
|
}
|
}
|
|
if (updated) {
|
Collections.sort(mSipContacts);
|
}
|
|
for (ContactsUpdatedListener listener : mContactsUpdatedListeners) {
|
listener.onContactsUpdated();
|
}
|
|
Compatibility.createChatShortcuts(mContext);
|
}
|
}
|
