diff options
Diffstat (limited to 'src/com')
5 files changed, 98 insertions, 234 deletions
diff --git a/src/com/android/contacts/activities/PeopleActivity.java b/src/com/android/contacts/activities/PeopleActivity.java index 6cb286ea0..d73802378 100644 --- a/src/com/android/contacts/activities/PeopleActivity.java +++ b/src/com/android/contacts/activities/PeopleActivity.java @@ -20,6 +20,7 @@ import android.app.Fragment; import android.app.FragmentManager; import android.app.FragmentTransaction; import android.content.ActivityNotFoundException; +import android.content.Context; import android.content.Intent; import android.graphics.Rect; import android.net.Uri; @@ -845,7 +846,7 @@ public class PeopleActivity extends ContactsActivity implements // // Also check for ability to modify accounts. In limited user mode, you can't modify // accounts so there is no point sending users to account setup activity. - final UserManager userManager = UserManager.get(this); + final UserManager userManager = (UserManager) getSystemService(Context.USER_SERVICE); final boolean disallowModifyAccounts = userManager.getUserRestrictions().getBoolean( UserManager.DISALLOW_MODIFY_ACCOUNTS); if (!disallowModifyAccounts && !areContactWritableAccountsAvailable() && diff --git a/src/com/android/contacts/interactions/ContactDeletionInteraction.java b/src/com/android/contacts/interactions/ContactDeletionInteraction.java index 458556e71..f3db36c8f 100644 --- a/src/com/android/contacts/interactions/ContactDeletionInteraction.java +++ b/src/com/android/contacts/interactions/ContactDeletionInteraction.java @@ -77,7 +77,7 @@ public class ContactDeletionInteraction extends Fragment private AlertDialog mDialog; /** This is a wrapper around the fragment's loader manager to be used only during testing. */ - private TestLoaderManager mTestLoaderManager; + private TestLoaderManagerBase mTestLoaderManager; @VisibleForTesting int mMessageId; @@ -97,20 +97,20 @@ public class ContactDeletionInteraction extends Fragment } /** - * Starts the interaction and optionally set up a {@link TestLoaderManager}. + * Starts the interaction and optionally set up a {@link TestLoaderManagerBase}. * * @param activity the activity within which to start the interaction * @param contactUri the URI of the contact to delete * @param finishActivityWhenDone whether to finish the activity upon completion of the * interaction - * @param testLoaderManager the {@link TestLoaderManager} to use to load the data, may be null + * @param testLoaderManager the {@link TestLoaderManagerBase} to use to load the data, may be null * in which case the default {@link LoaderManager} is used * @return the newly created interaction */ @VisibleForTesting static ContactDeletionInteraction startWithTestLoaderManager( Activity activity, Uri contactUri, boolean finishActivityWhenDone, - TestLoaderManager testLoaderManager) { + TestLoaderManagerBase testLoaderManager) { if (contactUri == null) { return null; } @@ -147,7 +147,7 @@ public class ContactDeletionInteraction extends Fragment } /** Sets the TestLoaderManager that is used to wrap the actual LoaderManager in tests. */ - private void setTestLoaderManager(TestLoaderManager mockLoaderManager) { + private void setTestLoaderManager(TestLoaderManagerBase mockLoaderManager) { mTestLoaderManager = mockLoaderManager; } diff --git a/src/com/android/contacts/interactions/TestLoaderManager.java b/src/com/android/contacts/interactions/TestLoaderManager.java deleted file mode 100644 index a85bf8f87..000000000 --- a/src/com/android/contacts/interactions/TestLoaderManager.java +++ /dev/null @@ -1,226 +0,0 @@ -/* - * Copyright (C) 2010 The Android Open Source 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.interactions; - -import android.app.Activity; -import android.app.LoaderManager; -import android.content.AsyncTaskLoader; -import android.content.Loader; -import android.os.Bundle; -import android.util.Log; - -import com.google.common.annotations.VisibleForTesting; - -import junit.framework.Assert; - -import java.io.FileDescriptor; -import java.io.PrintWriter; -import java.util.ArrayList; -import java.util.HashSet; -import java.util.List; - -/** - * A {@link LoaderManager} that records which loaders have been completed. - * <p> - * You should wrap the existing LoaderManager with an instance of this class, which will then - * delegate to the original object. - * <p> - * Typically, one would override {@link Activity#getLoaderManager()} to return the - * TestLoaderManager and ensuring it wraps the {@link LoaderManager} for this object, e.g.: - * <pre> - * private TestLoaderManager mTestLoaderManager; - * - * public LoaderManager getLoaderManager() { - * LoaderManager loaderManager = super.getLoaderManager(); - * if (mTestLoaderManager != null) { - * mTestLoaderManager.setDelegate(loaderManager); - * return mTestLoaderManager; - * } else { - * return loaderManager; - * } - * } - * - * void setTestLoaderManager(TestLoaderManager testLoaderManager) { - * mTestLoaderManager = testLoaderManager; - * } - * </pre> - * In the tests, one would set the TestLoaderManager upon creating the activity, and then wait for - * the loader to complete. - * <pre> - * public void testLoadedCorrect() { - * TestLoaderManager testLoaderManager = new TestLoaderManager(); - * getActivity().setTestLoaderManager(testLoaderManager); - * runOnUiThread(new Runnable() { public void run() { getActivity().startLoading(); } }); - * testLoaderManager.waitForLoader(R.id.test_loader_id); - * } - * </pre> - * If the loader completes before the call to {@link #waitForLoaders(int...)}, the TestLoaderManager - * will have stored the fact that the loader has completed and correctly terminate immediately. - * <p> - * It one needs to wait for the same loader multiple times, call {@link #reset()} between the them - * as in: - * <pre> - * public void testLoadedCorrect() { - * TestLoaderManager testLoaderManager = new TestLoaderManager(); - * getActivity().setTestLoaderManager(testLoaderManager); - * runOnUiThread(new Runnable() { public void run() { getActivity().startLoading(); } }); - * testLoaderManager.waitForLoader(R.id.test_loader_id); - * testLoaderManager.reset(); - * // Load and wait again. - * runOnUiThread(new Runnable() { public void run() { getActivity().startLoading(); } }); - * testLoaderManager.waitForLoader(R.id.test_loader_id); - * } - * </pre> - */ -public class TestLoaderManager extends LoaderManager { - private static final String TAG = "TestLoaderManager"; - - private final HashSet<Integer> mFinishedLoaders; - - private LoaderManager mDelegate; - - @VisibleForTesting - public TestLoaderManager() { - mFinishedLoaders = new HashSet<Integer>(); - } - - /** - * Sets the object to which we delegate the actual work. - * <p> - * It can not be set to null. Once set, it cannot be changed (but it allows setting it to the - * same value again). - */ - public void setDelegate(LoaderManager delegate) { - if (delegate == null || (mDelegate != null && mDelegate != delegate)) { - throw new IllegalArgumentException("TestLoaderManager cannot be shared"); - } - - mDelegate = delegate; - } - - public LoaderManager getDelegate() { - return mDelegate; - } - - public void reset() { - mFinishedLoaders.clear(); - } - - /** - * Waits for the specified loaders to complete loading. - * <p> - * If one of the loaders has already completed since the last call to {@link #reset()}, it will - * not wait for it to complete again. - */ - @VisibleForTesting - /*package*/ synchronized void waitForLoaders(int... loaderIds) { - List<Loader<?>> loaders = new ArrayList<Loader<?>>(loaderIds.length); - for (int loaderId : loaderIds) { - if (mFinishedLoaders.contains(loaderId)) { - // This loader has already completed since the last reset, do not wait for it. - continue; - } - - final AsyncTaskLoader<?> loader = - (AsyncTaskLoader<?>) mDelegate.getLoader(loaderId); - if (loader == null) { - Assert.fail("Loader does not exist: " + loaderId); - return; - } - - loaders.add(loader); - } - - waitForLoaders(loaders.toArray(new Loader<?>[0])); - } - - /** - * Waits for the specified loaders to complete loading. - */ - public static void waitForLoaders(Loader<?>... loaders) { - // We want to wait for each loader using a separate thread, so that we can - // simulate race conditions. - Thread[] waitThreads = new Thread[loaders.length]; - for (int i = 0; i < loaders.length; i++) { - final AsyncTaskLoader<?> loader = (AsyncTaskLoader<?>) loaders[i]; - waitThreads[i] = new Thread("LoaderWaitingThread" + i) { - @Override - public void run() { - try { - loader.waitForLoader(); - } catch (Throwable e) { - Log.e(TAG, "Exception while waiting for loader: " + loader.getId(), e); - Assert.fail("Exception while waiting for loader: " + loader.getId()); - } - } - }; - waitThreads[i].start(); - } - - // Now we wait for all these threads to finish - for (Thread thread : waitThreads) { - try { - thread.join(); - } catch (InterruptedException e) { - // Ignore - } - } - } - - @Override - public <D> Loader<D> initLoader(final int id, Bundle args, final LoaderCallbacks<D> callback) { - return mDelegate.initLoader(id, args, new LoaderManager.LoaderCallbacks<D>() { - @Override - public Loader<D> onCreateLoader(int id, Bundle args) { - return callback.onCreateLoader(id, args); - } - - @Override - public void onLoadFinished(Loader<D> loader, D data) { - callback.onLoadFinished(loader, data); - synchronized (this) { - mFinishedLoaders.add(id); - } - } - - @Override - public void onLoaderReset(Loader<D> loader) { - callback.onLoaderReset(loader); - } - }); - } - - @Override - public <D> Loader<D> restartLoader(int id, Bundle args, LoaderCallbacks<D> callback) { - return mDelegate.restartLoader(id, args, callback); - } - - @Override - public void destroyLoader(int id) { - mDelegate.destroyLoader(id); - } - - @Override - public <D> Loader<D> getLoader(int id) { - return mDelegate.getLoader(id); - } - - @Override - public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) { - mDelegate.dump(prefix, fd, writer, args); - } -} diff --git a/src/com/android/contacts/interactions/TestLoaderManagerBase.java b/src/com/android/contacts/interactions/TestLoaderManagerBase.java new file mode 100644 index 000000000..92ae3b901 --- /dev/null +++ b/src/com/android/contacts/interactions/TestLoaderManagerBase.java @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2014 The Android Open Source 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.interactions; + +import android.app.LoaderManager; + +/** + * A {@link LoaderManager} that records which loaders have been completed. + * <p> + * You should wrap the existing LoaderManager with an instance of this class, which will then + * delegate to the original object. + * <p> + * Typically, one would override {@link android.app.Activity#getLoaderManager()} to return the + * TestLoaderManager and ensuring it wraps the {@link LoaderManager} for this object, e.g.: + * <pre> + * private TestLoaderManager mTestLoaderManager; + * + * public LoaderManager getLoaderManager() { + * LoaderManager loaderManager = super.getLoaderManager(); + * if (mTestLoaderManager != null) { + * mTestLoaderManager.setDelegate(loaderManager); + * return mTestLoaderManager; + * } else { + * return loaderManager; + * } + * } + * + * void setTestLoaderManager(TestLoaderManager testLoaderManager) { + * mTestLoaderManager = testLoaderManager; + * } + * </pre> + * In the tests, one would set the TestLoaderManager upon creating the activity, and then wait for + * the loader to complete. + * <pre> + * public void testLoadedCorrect() { + * TestLoaderManager testLoaderManager = new TestLoaderManager(); + * getActivity().setTestLoaderManager(testLoaderManager); + * runOnUiThread(new Runnable() { public void run() { getActivity().startLoading(); } }); + * testLoaderManager.waitForLoader(R.id.test_loader_id); + * } + * </pre> + * If the loader completes before the call to {@link #waitForLoaders(int...)}, the TestLoaderManager + * will have stored the fact that the loader has completed and correctly terminate immediately. + * <p> + * It one needs to wait for the same loader multiple times, call {@link #reset()} between the them + * as in: + * <pre> + * public void testLoadedCorrect() { + * TestLoaderManager testLoaderManager = new TestLoaderManager(); + * getActivity().setTestLoaderManager(testLoaderManager); + * runOnUiThread(new Runnable() { public void run() { getActivity().startLoading(); } }); + * testLoaderManager.waitForLoader(R.id.test_loader_id); + * testLoaderManager.reset(); + * // Load and wait again. + * runOnUiThread(new Runnable() { public void run() { getActivity().startLoading(); } }); + * testLoaderManager.waitForLoader(R.id.test_loader_id); + * } + * </pre> + */ +abstract class TestLoaderManagerBase extends LoaderManager { + + /** + * Waits for the specified loaders to complete loading. + */ + public abstract void waitForLoaders(int... loaderIds); + + /** + * Sets the object to which we delegate the actual work. + * <p> + * It can not be set to null. Once set, it cannot be changed (but it allows setting it to the + * same value again). + */ + public abstract void setDelegate(LoaderManager delegate); + +} diff --git a/src/com/android/contacts/util/PhoneCapabilityTester.java b/src/com/android/contacts/util/PhoneCapabilityTester.java index b2d10be4a..a510b7692 100644 --- a/src/com/android/contacts/util/PhoneCapabilityTester.java +++ b/src/com/android/contacts/util/PhoneCapabilityTester.java @@ -28,7 +28,6 @@ import android.provider.Telephony; import android.telephony.TelephonyManager; import com.android.contacts.common.ContactsUtils; -import com.android.contacts.R; import java.util.List; @@ -62,7 +61,8 @@ public final class PhoneCapabilityTester { } private static void initialize(Context context) { - final TelephonyManager telephonyManager = new TelephonyManager(context); + final TelephonyManager telephonyManager + = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE); sIsPhone = telephonyManager.isVoiceCapable(); sIsSipPhone = sIsPhone && SipManager.isVoipSupported(context); sIsInitialized = true; |