/*
* 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.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Binder;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Parcel;
import android.os.Parcelable;
import android.test.PerformanceTestCase;
import android.util.Log;
class MyBadParcelable implements Parcelable {
public MyBadParcelable() {
}
public void writeToParcel(Parcel out, int flags) {
out.writeString("I am bad");
}
public int describeContents() {
return 0;
}
public static final Parcelable.Creator<MyBadParcelable> CREATOR
= new Parcelable.Creator<MyBadParcelable>() {
public MyBadParcelable createFromParcel(Parcel in) {
return new MyBadParcelable(in);
}
public MyBadParcelable[] newArray(int size) {
return new MyBadParcelable[size];
}
};
public MyBadParcelable(Parcel in) {
String nm = in.readString();
}
}
public class LaunchpadActivity extends Activity {
public interface CallingTest extends PerformanceTestCase.Intermediates {
public void startTiming(boolean realTime);
public void addIntermediate(String name);
public void addIntermediate(String name, long timeInNS);
public void finishTiming(boolean realTime);
public void activityFinished(int resultCode, Intent data,
RuntimeException where);
}
// Also used as the Binder interface descriptor string in these tests
public static final String LAUNCH = "com.android.frameworks.coretests.activity.LAUNCH";
public static final String FORWARD_RESULT =
"com.android.frameworks.coretests.activity.FORWARD_RESULT";
public static final String RETURNED_RESULT =
"com.android.frameworks.coretests.activity.RETURNED_RESULT";
public static final String BAD_PARCELABLE =
"comcom.android.frameworks.coretests.activity.BAD_PARCELABLE";
public static final int LAUNCHED_RESULT = 1;
public static final int FORWARDED_RESULT = 2;
public static final String LIFECYCLE_BASIC =
"com.android.frameworks.coretests.activity.LIFECYCLE_BASIC";
public static final String LIFECYCLE_SCREEN =
"com.android.frameworks.coretests.activity.LIFECYCLE_SCREEN";
public static final String LIFECYCLE_DIALOG =
"com.android.frameworks.coretests.activity.LIFECYCLE_DIALOG";
public static final String LIFECYCLE_FINISH_CREATE =
"com.android.frameworks.coretests.activity.LIFECYCLE_FINISH_CREATE";
public static final String LIFECYCLE_FINISH_START =
"com.android.frameworks.coretests.activity.LIFECYCLE_FINISH_START";
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_REMOTE =
"com.android.frameworks.coretests.activity.BROADCAST_REMOTE";
public static final String BROADCAST_ALL =
"com.android.frameworks.coretests.activity.BROADCAST_ALL";
public static final String BROADCAST_REPEAT =
"com.android.frameworks.coretests.activity.BROADCAST_REPEAT";
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 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 DATA_1 = "one";
public static final String DATA_2 = "two";
public static final String ON_START = "onStart";
public static final String ON_RESTART = "onRestart";
public static final String ON_RESUME = "onResume";
public static final String ON_FREEZE = "onSaveInstanceState";
public static final String ON_PAUSE = "onPause";
public static final String ON_STOP = "onStop";
public static final String ON_DESTROY = "onDestroy";
public static final String DO_FINISH = "finish";
public static final String DO_LOCAL_SCREEN = "local-screen";
public static final String DO_LOCAL_DIALOG = "local-dialog";
private boolean mBadParcelable = false;
private boolean mStarted = false;
private long mStartTime;
private int mResultCode = RESULT_CANCELED;
private Intent mData = (new Intent()).setAction("No result received");
private RuntimeException mResultStack = null;
private String[] mExpectedLifecycle = null;
private int mNextLifecycle;
private String[] mExpectedReceivers = null;
private int mNextReceiver;
private String[] mExpectedData = null;
private boolean[] mReceivedData = null;
boolean mReceiverRegistered = false;
private static CallingTest sCallingTest = null;
public static void setCallingTest(CallingTest ct) {
sCallingTest = ct;
}
public LaunchpadActivity() {
mStartTime = System.currentTimeMillis();
}
@Override
protected void onCreate(Bundle icicle) {
super.onCreate(icicle);
String action = getIntent().getAction();
if (ActivityTests.DEBUG_LIFECYCLE) Log.v("test", "CREATE lauchpad "
+ Integer.toHexString(System.identityHashCode(this)) + ": " + getIntent());
if (LIFECYCLE_BASIC.equals(action)) {
setExpectedLifecycle(new String[]{ON_START, ON_RESUME,
DO_FINISH, ON_PAUSE, ON_STOP, ON_DESTROY});
} else if (LIFECYCLE_SCREEN.equals(action)) {
setExpectedLifecycle(new String[]{ON_START, ON_RESUME,
DO_LOCAL_SCREEN, ON_FREEZE, ON_PAUSE, ON_STOP,
ON_RESTART, ON_START, ON_RESUME,
DO_FINISH, ON_PAUSE, ON_STOP, ON_DESTROY});
} else if (LIFECYCLE_DIALOG.equals(action)) {
setExpectedLifecycle(new String[]{ON_START, ON_RESUME,
DO_LOCAL_DIALOG, ON_FREEZE, ON_PAUSE, ON_RESUME,
DO_FINISH, ON_PAUSE, ON_STOP, ON_DESTROY});
} else if (LIFECYCLE_FINISH_CREATE.equals(action)) {
// This one behaves a little differently when running in a group.
if (getParent() == null) {
setExpectedLifecycle(new String[]{ON_DESTROY});
} else {
setExpectedLifecycle(new String[]{ON_START, ON_STOP, ON_DESTROY});
}
finish();
} else if (LIFECYCLE_FINISH_START.equals(action)) {
setExpectedLifecycle(new String[]{ON_START, DO_FINISH,
ON_STOP, ON_DESTROY});
}
}
@Override
protected void onStart() {
super.onStart();
if (ActivityTests.DEBUG_LIFECYCLE) Log.v("test", "START lauchpad "
+ Integer.toHexString(System.identityHashCode(this)) + ": " + getIntent());
checkLifecycle(ON_START);
}
@Override
protected void onRestart() {
super.onStart();
checkLifecycle(ON_RESTART);
}
@Override
protected void onResume() {
super.onResume();
if (ActivityTests.DEBUG_LIFECYCLE) Log.v("test", "RESUME lauchpad "
+ Integer.toHexString(System.identityHashCode(this)) + ": " + getIntent());
checkLifecycle(ON_RESUME);
if (!mStarted) {
mStarted = true;
mHandler.postDelayed(mTimeout, 5 * 1000);
String action = getIntent().getAction();
sCallingTest.startTiming(true);
if (LAUNCH.equals(action)) {
Intent intent = getIntent();
intent.setFlags(0);
intent.setComponent((ComponentName)
intent.getParcelableExtra("component"));
//System.out.println("*** Launchpad is starting: comp=" + intent.component);
startActivityForResult(intent, LAUNCHED_RESULT);
} else if (FORWARD_RESULT.equals(action)) {
Intent intent = getIntent();
intent.setFlags(0);
intent.setClass(this, LocalScreen.class);
startActivityForResult(intent, FORWARDED_RESULT);
} else if (BAD_PARCELABLE.equals(action)) {
mBadParcelable = true;
Intent intent = getIntent();
intent.setFlags(0);
intent.setClass(this, LocalScreen.class);
startActivityForResult(intent, LAUNCHED_RESULT);
} else if (BROADCAST_REGISTERED.equals(action)) {
setExpectedReceivers(new String[]{RECEIVER_REG});
registerMyReceiver(new IntentFilter(BROADCAST_REGISTERED));
sCallingTest.addIntermediate("after-register");
sendBroadcast(makeBroadcastIntent(BROADCAST_REGISTERED));
} else if (BROADCAST_LOCAL.equals(action)) {
setExpectedReceivers(new String[]{RECEIVER_LOCAL});
sendBroadcast(makeBroadcastIntent(BROADCAST_LOCAL));
} else if (BROADCAST_REMOTE.equals(action)) {
setExpectedReceivers(new String[]{RECEIVER_REMOTE});
sendBroadcast(makeBroadcastIntent(BROADCAST_REMOTE));
} else if (BROADCAST_ALL.equals(action)) {
setExpectedReceivers(new String[]{
RECEIVER_REMOTE, RECEIVER_REG, RECEIVER_LOCAL});
registerMyReceiver(new IntentFilter(BROADCAST_ALL));
sCallingTest.addIntermediate("after-register");
sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_ALL), null);
} else if (BROADCAST_MULTI.equals(action)) {
setExpectedReceivers(new String[]{
RECEIVER_REMOTE, RECEIVER_REG, RECEIVER_LOCAL,
RECEIVER_REMOTE, RECEIVER_REG, RECEIVER_LOCAL,
RECEIVER_REMOTE, RECEIVER_REG, RECEIVER_LOCAL,
RECEIVER_LOCAL, RECEIVER_REMOTE,
RECEIVER_LOCAL, RECEIVER_REMOTE,
RECEIVER_REMOTE, RECEIVER_REG, RECEIVER_LOCAL,
RECEIVER_REMOTE, RECEIVER_REG, RECEIVER_LOCAL,
RECEIVER_REMOTE, RECEIVER_REG, RECEIVER_LOCAL,
RECEIVER_REMOTE, RECEIVER_LOCAL,
RECEIVER_REMOTE, RECEIVER_LOCAL});
registerMyReceiver(new IntentFilter(BROADCAST_ALL));
sCallingTest.addIntermediate("after-register");
sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_ALL), null);
sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_ALL), null);
sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_ALL), null);
sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_LOCAL), null);
sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_REMOTE), null);
sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_LOCAL), null);
sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_REMOTE), null);
sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_ALL), null);
sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_ALL), null);
sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_ALL), null);
sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_REPEAT), null);
} else if (BROADCAST_ABORT.equals(action)) {
setExpectedReceivers(new String[]{
RECEIVER_REMOTE, RECEIVER_ABORT});
registerMyReceiver(new IntentFilter(BROADCAST_ABORT));
sCallingTest.addIntermediate("after-register");
sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_ABORT), null);
} else if (BROADCAST_STICKY1.equals(action)) {
setExpectedReceivers(new String[]{RECEIVER_REG});
setExpectedData(new String[]{DATA_1});
registerMyReceiver(new IntentFilter(BROADCAST_STICKY1));
sCallingTest.addIntermediate("after-register");
} else if (BROADCAST_STICKY2.equals(action)) {
setExpectedReceivers(new String[]{RECEIVER_REG, RECEIVER_REG});
setExpectedData(new String[]{DATA_1, DATA_2});
IntentFilter filter = new IntentFilter(BROADCAST_STICKY1);
filter.addAction(BROADCAST_STICKY2);
registerMyReceiver(filter);
sCallingTest.addIntermediate("after-register");
}
}
}
@Override
protected void onSaveInstanceState(Bundle icicle) {
super.onSaveInstanceState(icicle);
checkLifecycle(ON_FREEZE);
if (mBadParcelable) {
icicle.putParcelable("baddy", new MyBadParcelable());
}
}
@Override
protected void onPause() {
super.onPause();
if (ActivityTests.DEBUG_LIFECYCLE) Log.v("test", "PAUSE lauchpad "
+ Integer.toHexString(System.identityHashCode(this)) + ": " + getIntent());
checkLifecycle(ON_PAUSE);
}
@Override
protected void onStop() {
super.onStop();
if (ActivityTests.DEBUG_LIFECYCLE) Log.v("test", "STOP lauchpad "
+ Integer.toHexString(System.identityHashCode(this)) + ": " + getIntent());
checkLifecycle(ON_STOP);
}
@Override
protected void onActivityResult(int requestCode, int resultCode,
Intent data) {
switch (requestCode) {
case LAUNCHED_RESULT:
sCallingTest.finishTiming(true);
finishWithResult(resultCode, data);
break;
case FORWARDED_RESULT:
sCallingTest.finishTiming(true);
if (RETURNED_RESULT.equals(data.getAction())) {
finishWithResult(resultCode, data);
} else {
finishWithResult(RESULT_CANCELED, (new Intent()).setAction(
"Bad data returned: " + data));
}
break;
default:
sCallingTest.finishTiming(true);
finishWithResult(RESULT_CANCELED, (new Intent()).setAction(
"Unexpected request code: " + requestCode));
break;
}
}
@Override
protected void onDestroy() {
super.onDestroy();
if (ActivityTests.DEBUG_LIFECYCLE) Log.v("test", "DESTROY lauchpad "
+ Integer.toHexString(System.identityHashCode(this)) + ": " + getIntent());
checkLifecycle(ON_DESTROY);
sCallingTest.activityFinished(mResultCode, mData, mResultStack);
}
private void setExpectedLifecycle(String[] lifecycle) {
mExpectedLifecycle = lifecycle;
mNextLifecycle = 0;
}
private void checkLifecycle(String where) {
if (mExpectedLifecycle == null) return;
if (mNextLifecycle >= mExpectedLifecycle.length) {
finishBad("Activity lifecycle incorrect: received " + where
+ " but don't expect any more calls");
mExpectedLifecycle = null;
return;
}
if (!mExpectedLifecycle[mNextLifecycle].equals(where)) {
finishBad("Activity lifecycle incorrect: received " + where
+ " but expected " + mExpectedLifecycle[mNextLifecycle]
+ " at " + mNextLifecycle);
mExpectedLifecycle = null;
return;
}
mNextLifecycle++;
if (mNextLifecycle >= mExpectedLifecycle.length) {
setTestResult(RESULT_OK, null);
return;
}
String next = mExpectedLifecycle[mNextLifecycle];
if (where.equals(ON_DESTROY)) {
finishBad("Activity lifecycle incorrect: received " + where
+ " but expected more actions (next is " + next + ")");
mExpectedLifecycle = null;
return;
} else if (next.equals(DO_FINISH)) {
mNextLifecycle++;
if (mNextLifecycle >= mExpectedLifecycle.length) {
setTestResult(RESULT_OK, null);
}
if (!isFinishing()) {
finish();
}
} else if (next.equals(DO_LOCAL_SCREEN)) {
mNextLifecycle++;
Intent intent = new Intent(TestedScreen.WAIT_BEFORE_FINISH);
intent.setClass(this, LocalScreen.class);
startActivity(intent);
} else if (next.equals(DO_LOCAL_DIALOG)) {
mNextLifecycle++;
Intent intent = new Intent(TestedScreen.WAIT_BEFORE_FINISH);
intent.setClass(this, LocalDialog.class);
startActivity(intent);
}
}
private void setExpectedReceivers(String[] receivers) {
mExpectedReceivers = receivers;
mNextReceiver = 0;
}
private void setExpectedData(String[] data) {
mExpectedData = data;
mReceivedData = new boolean[data.length];
}
private Intent makeBroadcastIntent(String action) {
Intent intent = new Intent(action, null);
intent.putExtra("caller", mCallTarget);
return intent;
}
private void finishGood() {
finishWithResult(RESULT_OK, null);
}
private void finishBad(String error) {
finishWithResult(RESULT_CANCELED, (new Intent()).setAction(error));
}
private void finishWithResult(int resultCode, Intent data) {
setTestResult(resultCode, data);
finish();
}
private void setTestResult(int resultCode, Intent data) {
mHandler.removeCallbacks(mTimeout);
unregisterMyReceiver();
mResultCode = resultCode;
mData = data;
mResultStack = new RuntimeException("Original error was here");
mResultStack.fillInStackTrace();
}
private void registerMyReceiver(IntentFilter filter) {
mReceiverRegistered = true;
//System.out.println("Registering: " + mReceiver);
registerReceiver(mReceiver, filter);
}
private void unregisterMyReceiver() {
if (mReceiverRegistered) {
mReceiverRegistered = false;
//System.out.println("Unregistering: " + mReceiver);
unregisterReceiver(mReceiver);
}
}
private Handler mHandler = new Handler() {
public void handleMessage(Message msg) {
}
};
static final int GOT_RECEIVE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION;
static final int ERROR_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 1;
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 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();
sCallingTest.addIntermediate(mNextReceiver + "-" + 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"));
}
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));
} else if (!mExpectedReceivers[mNextReceiver].equals(name)) {
finishBad("Receive out of order: got " + name + " but expected "
+ mExpectedReceivers[mNextReceiver] + " at "
+ mNextReceiver);
} else {
mNextReceiver++;
if (mNextReceiver == mExpectedReceivers.length) {
mHandler.post(mUnregister);
}
}
}
}
private Runnable mUnregister = new Runnable() {
public void run() {
if (mReceiverRegistered) {
sCallingTest.addIntermediate("before-unregister");
unregisterMyReceiver();
}
sCallingTest.finishTiming(true);
finishGood();
}
};
private Runnable mTimeout = new Runnable() {
public void run() {
Log.i("foo", "**** TIMEOUT");
String msg = "Timeout";
if (mExpectedReceivers != null
&& mNextReceiver < mExpectedReceivers.length) {
msg = msg + " waiting for " + mExpectedReceivers[mNextReceiver];
}
finishBad(msg);
}
};
private BroadcastReceiver mReceiver = new BroadcastReceiver() {
public void onReceive(Context context, Intent intent) {
//System.out.println("Receive in: " + this + ": " + intent);
gotReceive(RECEIVER_REG, intent);
}
};
}
|
