| /* |
| * Copyright (C) 2006 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 android.app.activity; |
| |
| import android.app.Activity; |
| import android.app.ActivityManagerNative; |
| import android.content.BroadcastReceiver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.os.Binder; |
| import android.os.Bundle; |
| import android.os.IBinder; |
| import android.os.Parcel; |
| import android.os.UserHandle; |
| import android.test.FlakyTest; |
| import android.test.suitebuilder.annotation.Suppress; |
| import android.util.Log; |
| |
| import java.util.Arrays; |
| |
| public class BroadcastTest extends ActivityTestsBase { |
| public static final int BROADCAST_TIMEOUT = 5 * 1000; |
| |
| public static final String BROADCAST_REGISTERED = |
| "com.android.frameworks.coretests.activity.BROADCAST_REGISTERED"; |
| public static final String BROADCAST_LOCAL = |
| "com.android.frameworks.coretests.activity.BROADCAST_LOCAL"; |
| public static final String BROADCAST_LOCAL_GRANTED = |
| "com.android.frameworks.coretests.activity.BROADCAST_LOCAL_GRANTED"; |
| public static final String BROADCAST_LOCAL_DENIED = |
| "com.android.frameworks.coretests.activity.BROADCAST_LOCAL_DENIED"; |
| public static final String BROADCAST_REMOTE = |
| "com.android.frameworks.coretests.activity.BROADCAST_REMOTE"; |
| public static final String BROADCAST_REMOTE_GRANTED = |
| "com.android.frameworks.coretests.activity.BROADCAST_REMOTE_GRANTED"; |
| public static final String BROADCAST_REMOTE_DENIED = |
| "com.android.frameworks.coretests.activity.BROADCAST_REMOTE_DENIED"; |
| public static final String BROADCAST_ALL = |
| "com.android.frameworks.coretests.activity.BROADCAST_ALL"; |
| public static final String BROADCAST_MULTI = |
| "com.android.frameworks.coretests.activity.BROADCAST_MULTI"; |
| public static final String BROADCAST_ABORT = |
| "com.android.frameworks.coretests.activity.BROADCAST_ABORT"; |
| |
| public static final String BROADCAST_STICKY1 = |
| "com.android.frameworks.coretests.activity.BROADCAST_STICKY1"; |
| public static final String BROADCAST_STICKY2 = |
| "com.android.frameworks.coretests.activity.BROADCAST_STICKY2"; |
| |
| public static final String BROADCAST_FAIL_REGISTER = |
| "com.android.frameworks.coretests.activity.BROADCAST_FAIL_REGISTER"; |
| public static final String BROADCAST_FAIL_BIND = |
| "com.android.frameworks.coretests.activity.BROADCAST_FAIL_BIND"; |
| |
| public static final String RECEIVER_REG = "receiver-reg"; |
| public static final String RECEIVER_LOCAL = "receiver-local"; |
| public static final String RECEIVER_REMOTE = "receiver-remote"; |
| public static final String RECEIVER_ABORT = "receiver-abort"; |
| public static final String RECEIVER_RESULTS = "receiver-results"; |
| |
| public static final String DATA_1 = "one"; |
| public static final String DATA_2 = "two"; |
| |
| public static final int GOT_RECEIVE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION; |
| public static final int ERROR_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 1; |
| |
| private String[] mExpectedReceivers = null; |
| private int mNextReceiver; |
| |
| private String[] mExpectedData = null; |
| private boolean[] mReceivedData = null; |
| |
| boolean mReceiverRegistered = false; |
| |
| public void setExpectedReceivers(String[] receivers) { |
| mExpectedReceivers = receivers; |
| mNextReceiver = 0; |
| } |
| |
| public void setExpectedData(String[] data) { |
| mExpectedData = data; |
| mReceivedData = new boolean[data.length]; |
| } |
| |
| public void onTimeout() { |
| String msg = "Timeout"; |
| if (mExpectedReceivers != null && mNextReceiver < mExpectedReceivers.length) { |
| msg = msg + " waiting for " + mExpectedReceivers[mNextReceiver]; |
| } |
| finishBad(msg); |
| } |
| |
| public Intent makeBroadcastIntent(String action) { |
| Intent intent = new Intent(action, null); |
| intent.putExtra("caller", mCallTarget); |
| return intent; |
| } |
| |
| public void finishWithResult(int resultCode, Intent data) { |
| unregisterMyReceiver(); |
| super.finishWithResult(resultCode, data); |
| } |
| |
| public final void gotReceive(String name, Intent intent) { |
| synchronized (this) { |
| |
| //System.out.println("Got receive: " + name); |
| //System.out.println(mNextReceiver + " in " + mExpectedReceivers); |
| //new RuntimeException("stack").printStackTrace(); |
| |
| addIntermediate(name); |
| |
| if (mExpectedData != null) { |
| int n = mExpectedData.length; |
| int i; |
| boolean prev = false; |
| for (i = 0; i < n; i++) { |
| if (mExpectedData[i].equals(intent.getStringExtra("test"))) { |
| if (mReceivedData[i]) { |
| prev = true; |
| continue; |
| } |
| mReceivedData[i] = true; |
| break; |
| } |
| } |
| if (i >= n) { |
| if (prev) { |
| finishBad("Receive got data too many times: " |
| + intent.getStringExtra("test")); |
| } else { |
| finishBad("Receive got unexpected data: " |
| + intent.getStringExtra("test")); |
| } |
| new RuntimeException("stack").printStackTrace(); |
| return; |
| } |
| } |
| |
| if (mNextReceiver >= mExpectedReceivers.length) { |
| finishBad("Got too many onReceiveIntent() calls!"); |
| // System.out.println("Too many intents received: now at " |
| // + mNextReceiver + ", expect list: " |
| // + Arrays.toString(mExpectedReceivers)); |
| fail("Got too many onReceiveIntent() calls!"); |
| } else if (!mExpectedReceivers[mNextReceiver].equals(name)) { |
| finishBad("Receive out of order: got " + name |
| + " but expected " |
| + mExpectedReceivers[mNextReceiver]); |
| fail("Receive out of order: got " + name |
| + " but expected " |
| + mExpectedReceivers[mNextReceiver]); |
| } else { |
| mNextReceiver++; |
| if (mNextReceiver == mExpectedReceivers.length) { |
| finishTest(); |
| } |
| } |
| } |
| } |
| |
| public void registerMyReceiver(IntentFilter filter, String permission) { |
| mReceiverRegistered = true; |
| //System.out.println("Registering: " + mReceiver); |
| getContext().registerReceiver(mReceiver, filter, permission, null); |
| } |
| |
| public void unregisterMyReceiver() { |
| if (mReceiverRegistered) { |
| unregisterMyReceiverNoCheck(); |
| } |
| } |
| |
| public void unregisterMyReceiverNoCheck() { |
| mReceiverRegistered = false; |
| //System.out.println("Unregistering: " + mReceiver); |
| getContext().unregisterReceiver(mReceiver); |
| } |
| |
| public void onRegisteredReceiver(Intent intent) { |
| gotReceive(RECEIVER_REG, intent); |
| } |
| |
| private Binder mCallTarget = new Binder() { |
| public boolean onTransact(int code, Parcel data, Parcel reply, |
| int flags) { |
| data.setDataPosition(0); |
| data.enforceInterface(LaunchpadActivity.LAUNCH); |
| if (code == GOT_RECEIVE_TRANSACTION) { |
| String name = data.readString(); |
| gotReceive(name, null); |
| return true; |
| } else if (code == ERROR_TRANSACTION) { |
| finishBad(data.readString()); |
| return true; |
| } |
| return false; |
| } |
| }; |
| |
| private void finishTest() { |
| if (mReceiverRegistered) { |
| addIntermediate("before-unregister"); |
| unregisterMyReceiver(); |
| } |
| finishTiming(true); |
| finishGood(); |
| } |
| |
| private BroadcastReceiver mReceiver = new BroadcastReceiver() { |
| public void onReceive(Context context, Intent intent) { |
| //System.out.println("Receive in: " + this + ": " + intent); |
| onRegisteredReceiver(intent); |
| } |
| }; |
| |
| // Mark flaky until http://b/issue?id=1191607 is resolved. |
| @FlakyTest(tolerance=2) |
| public void testRegistered() throws Exception { |
| runLaunchpad(LaunchpadActivity.BROADCAST_REGISTERED); |
| } |
| |
| public void testLocal() throws Exception { |
| runLaunchpad(LaunchpadActivity.BROADCAST_LOCAL); |
| } |
| |
| public void testRemote() throws Exception { |
| runLaunchpad(LaunchpadActivity.BROADCAST_REMOTE); |
| } |
| |
| public void testAbort() throws Exception { |
| runLaunchpad(LaunchpadActivity.BROADCAST_ABORT); |
| } |
| |
| @FlakyTest(tolerance=2) |
| public void testAll() throws Exception { |
| runLaunchpad(LaunchpadActivity.BROADCAST_ALL); |
| } |
| |
| @FlakyTest(tolerance=2) |
| public void testMulti() throws Exception { |
| runLaunchpad(LaunchpadActivity.BROADCAST_MULTI); |
| } |
| |
| private class TestBroadcastReceiver extends BroadcastReceiver { |
| public boolean mHaveResult = false; |
| |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| synchronized (BroadcastTest.this) { |
| mHaveResult = true; |
| BroadcastTest.this.notifyAll(); |
| } |
| } |
| } |
| |
| public void testResult() throws Exception { |
| TestBroadcastReceiver broadcastReceiver = new TestBroadcastReceiver(); |
| |
| synchronized (this) { |
| Bundle map = new Bundle(); |
| map.putString("foo", "you"); |
| map.putString("remove", "me"); |
| getContext().sendOrderedBroadcast( |
| new Intent("com.android.frameworks.coretests.activity.BROADCAST_RESULT"), |
| null, broadcastReceiver, null, 1, "foo", map); |
| while (!broadcastReceiver.mHaveResult) { |
| try { |
| wait(); |
| } catch (InterruptedException e) { |
| } |
| } |
| |
| //System.out.println("Code: " + mResultCode + ", data: " + mResultData); |
| //System.out.println("Extras: " + mResultExtras); |
| |
| assertEquals("Incorrect code: " + broadcastReceiver.getResultCode(), |
| 3, broadcastReceiver.getResultCode()); |
| |
| assertEquals("bar", broadcastReceiver.getResultData()); |
| |
| Bundle resultExtras = broadcastReceiver.getResultExtras(false); |
| assertEquals("them", resultExtras.getString("bar")); |
| assertEquals("you", resultExtras.getString("foo")); |
| assertNull(resultExtras.getString("remove")); |
| } |
| } |
| |
| public void testSetSticky() throws Exception { |
| Intent intent = new Intent(LaunchpadActivity.BROADCAST_STICKY1, null); |
| intent.putExtra("test", LaunchpadActivity.DATA_1); |
| ActivityManagerNative.getDefault().unbroadcastIntent(null, intent, |
| UserHandle.myUserId()); |
| |
| ActivityManagerNative.broadcastStickyIntent(intent, null, UserHandle.myUserId()); |
| addIntermediate("finished-broadcast"); |
| |
| IntentFilter filter = new IntentFilter(LaunchpadActivity.BROADCAST_STICKY1); |
| Intent sticky = getContext().registerReceiver(null, filter); |
| assertNotNull("Sticky not found", sticky); |
| assertEquals(LaunchpadActivity.DATA_1, sticky.getStringExtra("test")); |
| } |
| |
| public void testClearSticky() throws Exception { |
| Intent intent = new Intent(LaunchpadActivity.BROADCAST_STICKY1, null); |
| intent.putExtra("test", LaunchpadActivity.DATA_1); |
| ActivityManagerNative.broadcastStickyIntent(intent, null, UserHandle.myUserId()); |
| |
| ActivityManagerNative.getDefault().unbroadcastIntent( |
| null, new Intent(LaunchpadActivity.BROADCAST_STICKY1, null), |
| UserHandle.myUserId()); |
| addIntermediate("finished-unbroadcast"); |
| |
| IntentFilter filter = new IntentFilter(LaunchpadActivity.BROADCAST_STICKY1); |
| Intent sticky = getContext().registerReceiver(null, filter); |
| assertNull("Sticky not found", sticky); |
| } |
| |
| public void testReplaceSticky() throws Exception { |
| Intent intent = new Intent(LaunchpadActivity.BROADCAST_STICKY1, null); |
| intent.putExtra("test", LaunchpadActivity.DATA_1); |
| ActivityManagerNative.broadcastStickyIntent(intent, null, UserHandle.myUserId()); |
| intent.putExtra("test", LaunchpadActivity.DATA_2); |
| |
| ActivityManagerNative.broadcastStickyIntent(intent, null, UserHandle.myUserId()); |
| addIntermediate("finished-broadcast"); |
| |
| IntentFilter filter = new IntentFilter(LaunchpadActivity.BROADCAST_STICKY1); |
| Intent sticky = getContext().registerReceiver(null, filter); |
| assertNotNull("Sticky not found", sticky); |
| assertEquals(LaunchpadActivity.DATA_2, sticky.getStringExtra("test")); |
| } |
| |
| // Marking flaky until http://b/issue?id=1191337 is resolved |
| @FlakyTest(tolerance=2) |
| public void testReceiveSticky() throws Exception { |
| Intent intent = new Intent(LaunchpadActivity.BROADCAST_STICKY1, null); |
| intent.putExtra("test", LaunchpadActivity.DATA_1); |
| ActivityManagerNative.broadcastStickyIntent(intent, null, UserHandle.myUserId()); |
| |
| runLaunchpad(LaunchpadActivity.BROADCAST_STICKY1); |
| } |
| |
| // Marking flaky until http://b/issue?id=1191337 is resolved |
| @FlakyTest(tolerance=2) |
| public void testReceive2Sticky() throws Exception { |
| Intent intent = new Intent(LaunchpadActivity.BROADCAST_STICKY1, null); |
| intent.putExtra("test", LaunchpadActivity.DATA_1); |
| ActivityManagerNative.broadcastStickyIntent(intent, null, UserHandle.myUserId()); |
| intent = new Intent(LaunchpadActivity.BROADCAST_STICKY2, null); |
| intent.putExtra("test", LaunchpadActivity.DATA_2); |
| ActivityManagerNative.broadcastStickyIntent(intent, null, UserHandle.myUserId()); |
| |
| runLaunchpad(LaunchpadActivity.BROADCAST_STICKY2); |
| } |
| |
| public void testRegisteredReceivePermissionGranted() throws Exception { |
| setExpectedReceivers(new String[]{RECEIVER_REG}); |
| registerMyReceiver(new IntentFilter(BROADCAST_REGISTERED), PERMISSION_GRANTED); |
| addIntermediate("after-register"); |
| getContext().sendBroadcast(makeBroadcastIntent(BROADCAST_REGISTERED)); |
| waitForResultOrThrow(BROADCAST_TIMEOUT); |
| } |
| |
| public void testRegisteredReceivePermissionDenied() throws Exception { |
| setExpectedReceivers(new String[]{RECEIVER_RESULTS}); |
| registerMyReceiver(new IntentFilter(BROADCAST_REGISTERED), PERMISSION_DENIED); |
| addIntermediate("after-register"); |
| |
| BroadcastReceiver finish = new BroadcastReceiver() { |
| public void onReceive(Context context, Intent intent) { |
| gotReceive(RECEIVER_RESULTS, intent); |
| } |
| }; |
| |
| getContext().sendOrderedBroadcast( |
| makeBroadcastIntent(BROADCAST_REGISTERED), |
| null, finish, null, Activity.RESULT_CANCELED, null, null); |
| waitForResultOrThrow(BROADCAST_TIMEOUT); |
| } |
| |
| public void testRegisteredBroadcastPermissionGranted() throws Exception { |
| setExpectedReceivers(new String[]{RECEIVER_REG}); |
| registerMyReceiver(new IntentFilter(BROADCAST_REGISTERED), null); |
| addIntermediate("after-register"); |
| getContext().sendBroadcast( |
| makeBroadcastIntent(BROADCAST_REGISTERED), |
| PERMISSION_GRANTED); |
| waitForResultOrThrow(BROADCAST_TIMEOUT); |
| } |
| |
| public void testRegisteredBroadcastPermissionDenied() throws Exception { |
| setExpectedReceivers(new String[]{RECEIVER_RESULTS}); |
| registerMyReceiver(new IntentFilter(BROADCAST_REGISTERED), null); |
| addIntermediate("after-register"); |
| |
| BroadcastReceiver finish = new BroadcastReceiver() { |
| public void onReceive(Context context, Intent intent) { |
| gotReceive(RECEIVER_RESULTS, intent); |
| } |
| }; |
| |
| getContext().sendOrderedBroadcast( |
| makeBroadcastIntent(BROADCAST_REGISTERED), |
| PERMISSION_DENIED, finish, null, Activity.RESULT_CANCELED, |
| null, null); |
| waitForResultOrThrow(BROADCAST_TIMEOUT); |
| } |
| |
| public void testLocalReceivePermissionGranted() throws Exception { |
| setExpectedReceivers(new String[]{RECEIVER_LOCAL}); |
| getContext().sendBroadcast(makeBroadcastIntent(BROADCAST_LOCAL_GRANTED)); |
| waitForResultOrThrow(BROADCAST_TIMEOUT); |
| } |
| |
| public void testLocalReceivePermissionDenied() throws Exception { |
| setExpectedReceivers(new String[]{RECEIVER_RESULTS}); |
| |
| BroadcastReceiver finish = new BroadcastReceiver() { |
| public void onReceive(Context context, Intent intent) { |
| gotReceive(RECEIVER_RESULTS, intent); |
| } |
| }; |
| |
| getContext().sendOrderedBroadcast( |
| makeBroadcastIntent(BROADCAST_LOCAL_DENIED), |
| null, finish, null, Activity.RESULT_CANCELED, |
| null, null); |
| waitForResultOrThrow(BROADCAST_TIMEOUT); |
| } |
| |
| public void testLocalBroadcastPermissionGranted() throws Exception { |
| setExpectedReceivers(new String[]{RECEIVER_LOCAL}); |
| getContext().sendBroadcast( |
| makeBroadcastIntent(BROADCAST_LOCAL), |
| PERMISSION_GRANTED); |
| waitForResultOrThrow(BROADCAST_TIMEOUT); |
| } |
| |
| public void testLocalBroadcastPermissionDenied() throws Exception { |
| setExpectedReceivers(new String[]{RECEIVER_RESULTS}); |
| |
| BroadcastReceiver finish = new BroadcastReceiver() { |
| public void onReceive(Context context, Intent intent) { |
| gotReceive(RECEIVER_RESULTS, intent); |
| } |
| }; |
| |
| getContext().sendOrderedBroadcast( |
| makeBroadcastIntent(BROADCAST_LOCAL), |
| PERMISSION_DENIED, finish, null, Activity.RESULT_CANCELED, |
| null, null); |
| waitForResultOrThrow(BROADCAST_TIMEOUT); |
| } |
| |
| public void testRemoteReceivePermissionGranted() throws Exception { |
| setExpectedReceivers(new String[]{RECEIVER_REMOTE}); |
| getContext().sendBroadcast(makeBroadcastIntent(BROADCAST_REMOTE_GRANTED)); |
| waitForResultOrThrow(BROADCAST_TIMEOUT); |
| } |
| |
| public void testRemoteReceivePermissionDenied() throws Exception { |
| setExpectedReceivers(new String[]{RECEIVER_RESULTS}); |
| |
| BroadcastReceiver finish = new BroadcastReceiver() { |
| public void onReceive(Context context, Intent intent) { |
| gotReceive(RECEIVER_RESULTS, intent); |
| } |
| }; |
| |
| getContext().sendOrderedBroadcast( |
| makeBroadcastIntent(BROADCAST_REMOTE_DENIED), |
| null, finish, null, Activity.RESULT_CANCELED, |
| null, null); |
| waitForResultOrThrow(BROADCAST_TIMEOUT); |
| } |
| |
| public void testRemoteBroadcastPermissionGranted() throws Exception { |
| setExpectedReceivers(new String[]{RECEIVER_REMOTE}); |
| getContext().sendBroadcast( |
| makeBroadcastIntent(BROADCAST_REMOTE), |
| PERMISSION_GRANTED); |
| waitForResultOrThrow(BROADCAST_TIMEOUT); |
| } |
| |
| public void testRemoteBroadcastPermissionDenied() throws Exception { |
| setExpectedReceivers(new String[]{RECEIVER_RESULTS}); |
| |
| BroadcastReceiver finish = new BroadcastReceiver() { |
| public void onReceive(Context context, Intent intent) { |
| gotReceive(RECEIVER_RESULTS, intent); |
| } |
| }; |
| |
| getContext().sendOrderedBroadcast( |
| makeBroadcastIntent(BROADCAST_REMOTE), |
| PERMISSION_DENIED, finish, null, Activity.RESULT_CANCELED, |
| null, null); |
| waitForResultOrThrow(BROADCAST_TIMEOUT); |
| } |
| |
| public void testReceiverCanNotRegister() throws Exception { |
| setExpectedReceivers(new String[]{RECEIVER_LOCAL}); |
| getContext().sendBroadcast(makeBroadcastIntent(BROADCAST_FAIL_REGISTER)); |
| waitForResultOrThrow(BROADCAST_TIMEOUT); |
| } |
| |
| public void testReceiverCanNotBind() throws Exception { |
| setExpectedReceivers(new String[]{RECEIVER_LOCAL}); |
| getContext().sendBroadcast(makeBroadcastIntent(BROADCAST_FAIL_BIND)); |
| waitForResultOrThrow(BROADCAST_TIMEOUT); |
| } |
| |
| public void testLocalUnregisterTwice() throws Exception { |
| registerMyReceiver(new IntentFilter(BROADCAST_REGISTERED), null); |
| unregisterMyReceiverNoCheck(); |
| try { |
| unregisterMyReceiverNoCheck(); |
| fail("No exception thrown on second unregister"); |
| } catch (IllegalArgumentException e) { |
| Log.i("foo", "Unregister exception", e); |
| } |
| } |
| } |
