From 13c6c99fa4799c3af18b45a4deaa9edbb6de04d0 Mon Sep 17 00:00:00 2001 From: Artem Shvadskiy Date: Mon, 9 May 2016 11:17:08 -0700 Subject: Update LookupProvider to new CallerInfoAPI spec Change-Id: Icfd981473fdece5bf90016223909be54ee0f4b05 issue-id: DIALER-719 DIALER-724 --- .../common/activity/BlockContactActivity.java | 2 +- .../contacts/common/util/BlockContactHelper.java | 17 ++-- .../contacts/common/util/SingletonHolder.java | 93 ++++++++++++++++++++++ src/com/android/contacts/common/util/UriUtils.java | 19 +++++ .../phonenumber/contract/LookupProvider.java | 42 +++++++--- .../phonenumber/util/LookupHandlerThread.java | 6 +- 6 files changed, 154 insertions(+), 25 deletions(-) create mode 100644 src/com/android/contacts/common/util/SingletonHolder.java (limited to 'src') diff --git a/src/com/android/contacts/common/activity/BlockContactActivity.java b/src/com/android/contacts/common/activity/BlockContactActivity.java index 4dff6180..a9514a63 100644 --- a/src/com/android/contacts/common/activity/BlockContactActivity.java +++ b/src/com/android/contacts/common/activity/BlockContactActivity.java @@ -44,7 +44,7 @@ public class BlockContactActivity extends Activity implements BlockContactDialog return; } - mBlockContactHelper = new BlockContactHelper(this, new LookupProviderImpl(this)); + mBlockContactHelper = new BlockContactHelper(this); mBlockContactHelper.setContactInfo(phoneNumber); } diff --git a/src/com/android/contacts/common/util/BlockContactHelper.java b/src/com/android/contacts/common/util/BlockContactHelper.java index e5867b32..f04a12cb 100644 --- a/src/com/android/contacts/common/util/BlockContactHelper.java +++ b/src/com/android/contacts/common/util/BlockContactHelper.java @@ -42,7 +42,6 @@ public class BlockContactHelper { private BlockRequest mBlockRequest; private LookupProvider mLookupProvider; private volatile boolean mIsBlacklisted; - private volatile boolean mIsProviderInitialized; private boolean mBackgroundTaskCompleted; private StatusCallbacks mListener; @@ -51,9 +50,9 @@ public class BlockContactHelper { UNBLOCK } - public BlockContactHelper(Context context, LookupProvider lookupProvider) { + public BlockContactHelper(Context context) { mContext = context; - mLookupProvider = lookupProvider; + mLookupProvider = LookupProviderImpl.INSTANCE.get(context); } public void setContactInfo(Contact contact) { @@ -102,10 +101,6 @@ public class BlockContactHelper { break; } } - - if (mLookupProvider.initialize()) { - mIsProviderInitialized = true; - } } public boolean isContactBlacklisted() { @@ -118,7 +113,7 @@ public class BlockContactHelper { } public String getLookupProviderName() { - if (mIsProviderInitialized) { + if (mLookupProvider.isEnabled()) { return mLookupProvider.getDisplayName(); } else { return null; @@ -163,7 +158,7 @@ public class BlockContactHelper { for (String phoneNumber : mBlockRequest.phoneNumbers) { toggleBlacklistStatus(phoneNumber, true /*block contact*/); - if (notifyLookupProvider && mIsProviderInitialized && + if (notifyLookupProvider && mLookupProvider.isEnabled() && mLookupProvider.supportsSpamReporting()) { mLookupProvider.markAsSpam(phoneNumber); } @@ -184,7 +179,7 @@ public class BlockContactHelper { for (String phoneNumber : mBlockRequest.phoneNumbers) { toggleBlacklistStatus(phoneNumber, false /*unblock contact*/); - if (notifyLookupProvider && mIsProviderInitialized && + if (notifyLookupProvider && mLookupProvider.isEnabled() && mLookupProvider.supportsSpamReporting()) { mLookupProvider.unmarkAsSpam(phoneNumber); } @@ -238,7 +233,7 @@ public class BlockContactHelper { if (mBackgroundTask != null) { mBackgroundTask.cancel(true /*interrupt*/); } - mLookupProvider.disable(); + LookupProviderImpl.INSTANCE.release(); } public interface StatusCallbacks { diff --git a/src/com/android/contacts/common/util/SingletonHolder.java b/src/com/android/contacts/common/util/SingletonHolder.java new file mode 100644 index 00000000..c1a183d4 --- /dev/null +++ b/src/com/android/contacts/common/util/SingletonHolder.java @@ -0,0 +1,93 @@ +/* + * Copyright (C) 2016 The CyanogenMod Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License + * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express + * or implied. See the License for the specific language governing permissions and limitations under + * the License. + */ + +package com.android.contacts.common.util; + +/** + * Encapsulates a threadsafe singleton pattern. + * + * This class is designed to be used as a public constant, living within a class that has a private constructor. + * It defines a {@link #create(I)} method that will only ever be called once, upon the first call of {@link #get(I)}. + * That method is responsible for creating the actual singleton instance, and that instance will be returned for all + * future calls of {@link #get(I)}. + * + * Example: + * + * public class FooSingleton { + * public static final SingletonHolder<FooSingleton, ParamObject> HOLDER = + * new SingletonHolder<FooSingleton, ParamObject>() { + * @Override + * protected FooSingleton create(ParamObject param) { + * return new FooSingleton(param); + * } + * }; + * + * private FooSingleton(ParamObject param) { + * + * } + * } + * + * // somewhere else + * FooSingleton.HOLDER.get(params).doStuff(); + * + * @param The type of the class to hold as a singleton. + * @param A parameter object to use during creation of the singleton object. + */ +public abstract class SingletonHolder { + E mInstance; + final Object LOCK = new Object(); + + public E get(I initializer) { + if (null == mInstance) { + synchronized (LOCK) { + if (null == mInstance) { + mInstance = create(initializer); + } + } + } + + return mInstance; + } + + protected abstract E create(I initializer); + + /** + * Specialized version of {@link SingletonHolder} which will keep a count of referring + * objects, and clear the instance when all references have been removed. + * + * @param The type of the class to hold as a singleton. + * @param A parameter object to use during creation of the singleton object. + */ + public static abstract class RefCountedSingletonHolder extends SingletonHolder { + private int mRefCount; + + public E get(I initializer) { + synchronized (LOCK) { + mRefCount++; + } + return super.get(initializer); + } + + public void release() { + synchronized (LOCK) { + if(--mRefCount == 0) { + destroy(mInstance); + mInstance = null; + } + } + } + + protected abstract void destroy(E instance); + } +} diff --git a/src/com/android/contacts/common/util/UriUtils.java b/src/com/android/contacts/common/util/UriUtils.java index 41ef62f6..bc098d36 100644 --- a/src/com/android/contacts/common/util/UriUtils.java +++ b/src/com/android/contacts/common/util/UriUtils.java @@ -74,6 +74,25 @@ public class UriUtils { return ContactsContract.AUTHORITY.equals(uri.getAuthority()) ? uri : null; } + /** + * @return true if this uri represents a local contact, false otherwise. + */ + public static boolean isLocalContactUri(Uri uri) { + if (uri == null) { + return false; + } + + if (isEncodedContactUri(uri)) { + return false; + } + + if (!uri.getScheme().equals(ContactsContract.AUTHORITY)) { + return false; + } + + return true; + } + /** * Parses the given URI to determine the original lookup key of the contact. */ diff --git a/src/com/cyanogen/lookup/phonenumber/contract/LookupProvider.java b/src/com/cyanogen/lookup/phonenumber/contract/LookupProvider.java index 652443f4..fec6dd48 100644 --- a/src/com/cyanogen/lookup/phonenumber/contract/LookupProvider.java +++ b/src/com/cyanogen/lookup/phonenumber/contract/LookupProvider.java @@ -1,3 +1,17 @@ +/* + * Copyright (C) 2016 The CyanogenMod Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License + * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express + * or implied. See the License for the specific language governing permissions and limitations under + * the License. + */ + package com.cyanogen.lookup.phonenumber.contract; import com.cyanogen.lookup.phonenumber.request.LookupRequest; @@ -9,13 +23,28 @@ import com.cyanogen.lookup.phonenumber.response.LookupResponse; public interface LookupProvider { /** - * Explicit call to the provider to initialize itself. Decoupling it from provider construction - * to enable explicit setup and tear down based on resource constraints. + * Callback for clients that are interested in changes to the Provider's status */ - boolean initialize(); + interface StatusCallback { + void onStatusChanged(boolean isEnabled); + } /** - * Returns true if the provider is installed and enabled + * Register a callback to be notified when the provider's status changes + * + * @param callback listener to be called if provider is changed + */ + void registerStatusCallback(StatusCallback callback); + + /** + * Unregister a previously registered callback + * + * @param callback listener that was previously registered + */ + void unregisterStatusCallback(StatusCallback callback); + + /** + * Returns true if the provider is installed and enabled. */ boolean isEnabled(); @@ -31,11 +60,6 @@ public interface LookupProvider { */ LookupResponse blockingFetchInfo(LookupRequest lookupRequest); - /** - * Explicit call to disable provider and free resources - */ - void disable(); - /** * flag a phone number as spam * diff --git a/src/com/cyanogen/lookup/phonenumber/util/LookupHandlerThread.java b/src/com/cyanogen/lookup/phonenumber/util/LookupHandlerThread.java index f7d7cfd8..d80bec87 100644 --- a/src/com/cyanogen/lookup/phonenumber/util/LookupHandlerThread.java +++ b/src/com/cyanogen/lookup/phonenumber/util/LookupHandlerThread.java @@ -41,14 +41,13 @@ public class LookupHandlerThread extends HandlerThread implements Handler.Callba if (mInitialized) { return true; } - - mInitialized = mLookupProvider.initialize(); + mInitialized = mLookupProvider.isEnabled(); if (mInitialized) { mSubmittedRequests = new HashSet<>(); start(); mHandler = new Handler(getLooper(), this); } else { - Log.w(TAG, "Failed to initialize!"); + Log.e(TAG, "Failed to initialize!"); } return mInitialized; @@ -61,7 +60,6 @@ public class LookupHandlerThread extends HandlerThread implements Handler.Callba public void tearDown() { if (mInitialized) { quit(); - mLookupProvider.disable(); mInitialized = false; } } -- cgit v1.2.3