Android example source code file (LaunchpadActivity.java)

This example Android source code file (LaunchpadActivity.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Android by Example" ^TM.

Java - Android tags/keywords

android, app, content, do_finish, intent, intentfilter, mybadparcelable, on_destroy, on_pause, on_resume, on_start, on_stop, os, override, receiver_local, receiver_reg, receiver_remote, string, test, util

The LaunchpadActivity.java Android example source code

/*
 * 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);
        }
    };
}