1 /* 2 * Copyright (C) 2006 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.app.activity; 18 19 import android.app.Activity; 20 import android.content.BroadcastReceiver; 21 import android.content.ComponentName; 22 import android.content.Context; 23 import android.content.Intent; 24 import android.content.IntentFilter; 25 import android.os.Binder; 26 import android.os.Bundle; 27 import android.os.Handler; 28 import android.os.IBinder; 29 import android.os.Message; 30 import android.os.Parcel; 31 import android.os.Parcelable; 32 import android.test.PerformanceTestCase; 33 import android.util.Log; 34 35 class MyBadParcelable implements Parcelable { MyBadParcelable()36 public MyBadParcelable() { 37 } 38 writeToParcel(Parcel out, int flags)39 public void writeToParcel(Parcel out, int flags) { 40 out.writeString("I am bad"); 41 } 42 describeContents()43 public int describeContents() { 44 return 0; 45 } 46 47 public static final Parcelable.Creator<MyBadParcelable> CREATOR 48 = new Parcelable.Creator<MyBadParcelable>() { 49 public MyBadParcelable createFromParcel(Parcel in) { 50 return new MyBadParcelable(in); 51 } 52 53 public MyBadParcelable[] newArray(int size) { 54 return new MyBadParcelable[size]; 55 } 56 }; 57 MyBadParcelable(Parcel in)58 public MyBadParcelable(Parcel in) { 59 String nm = in.readString(); 60 } 61 } 62 63 public class LaunchpadActivity extends Activity { 64 public interface CallingTest extends PerformanceTestCase.Intermediates { startTiming(boolean realTime)65 public void startTiming(boolean realTime); addIntermediate(String name)66 public void addIntermediate(String name); addIntermediate(String name, long timeInNS)67 public void addIntermediate(String name, long timeInNS); finishTiming(boolean realTime)68 public void finishTiming(boolean realTime); activityFinished(int resultCode, Intent data, RuntimeException where)69 public void activityFinished(int resultCode, Intent data, 70 RuntimeException where); 71 } 72 73 // Also used as the Binder interface descriptor string in these tests 74 public static final String LAUNCH = "com.android.frameworks.coretests.activity.LAUNCH"; 75 76 public static final String FORWARD_RESULT = 77 "com.android.frameworks.coretests.activity.FORWARD_RESULT"; 78 public static final String RETURNED_RESULT = 79 "com.android.frameworks.coretests.activity.RETURNED_RESULT"; 80 81 public static final String BAD_PARCELABLE = 82 "comcom.android.frameworks.coretests.activity.BAD_PARCELABLE"; 83 84 public static final int LAUNCHED_RESULT = 1; 85 public static final int FORWARDED_RESULT = 2; 86 87 public static final String LIFECYCLE_BASIC = 88 "com.android.frameworks.coretests.activity.LIFECYCLE_BASIC"; 89 public static final String LIFECYCLE_SCREEN = 90 "com.android.frameworks.coretests.activity.LIFECYCLE_SCREEN"; 91 public static final String LIFECYCLE_DIALOG = 92 "com.android.frameworks.coretests.activity.LIFECYCLE_DIALOG"; 93 public static final String LIFECYCLE_FINISH_CREATE = 94 "com.android.frameworks.coretests.activity.LIFECYCLE_FINISH_CREATE"; 95 public static final String LIFECYCLE_FINISH_START = 96 "com.android.frameworks.coretests.activity.LIFECYCLE_FINISH_START"; 97 98 public static final String BROADCAST_REGISTERED = 99 "com.android.frameworks.coretests.activity.BROADCAST_REGISTERED"; 100 public static final String BROADCAST_LOCAL = 101 "com.android.frameworks.coretests.activity.BROADCAST_LOCAL"; 102 public static final String BROADCAST_REMOTE = 103 "com.android.frameworks.coretests.activity.BROADCAST_REMOTE"; 104 public static final String BROADCAST_ALL = 105 "com.android.frameworks.coretests.activity.BROADCAST_ALL"; 106 public static final String BROADCAST_REPEAT = 107 "com.android.frameworks.coretests.activity.BROADCAST_REPEAT"; 108 public static final String BROADCAST_MULTI = 109 "com.android.frameworks.coretests.activity.BROADCAST_MULTI"; 110 public static final String BROADCAST_ABORT = 111 "com.android.frameworks.coretests.activity.BROADCAST_ABORT"; 112 113 public static final String BROADCAST_STICKY1 = 114 "com.android.frameworks.coretests.activity.BROADCAST_STICKY1"; 115 public static final String BROADCAST_STICKY2 = 116 "com.android.frameworks.coretests.activity.BROADCAST_STICKY2"; 117 118 public static final String RECEIVER_REG = "receiver-reg"; 119 public static final String RECEIVER_LOCAL = "receiver-local"; 120 public static final String RECEIVER_REMOTE = "receiver-remote"; 121 public static final String RECEIVER_ABORT = "receiver-abort"; 122 123 public static final String DATA_1 = "one"; 124 public static final String DATA_2 = "two"; 125 126 public static final String ON_START = "onStart"; 127 public static final String ON_RESTART = "onRestart"; 128 public static final String ON_RESUME = "onResume"; 129 public static final String ON_FREEZE = "onSaveInstanceState"; 130 public static final String ON_PAUSE = "onPause"; 131 public static final String ON_STOP = "onStop"; 132 public static final String ON_DESTROY = "onDestroy"; 133 134 public static final String DO_FINISH = "finish"; 135 public static final String DO_LOCAL_SCREEN = "local-screen"; 136 public static final String DO_LOCAL_DIALOG = "local-dialog"; 137 138 private boolean mBadParcelable = false; 139 140 private boolean mStarted = false; 141 private long mStartTime; 142 143 private int mResultCode = RESULT_CANCELED; 144 private Intent mData = (new Intent()).setAction("No result received"); 145 private RuntimeException mResultStack = null; 146 147 private String[] mExpectedLifecycle = null; 148 private int mNextLifecycle; 149 150 private String[] mExpectedReceivers = null; 151 private int mNextReceiver; 152 153 private String[] mExpectedData = null; 154 private boolean[] mReceivedData = null; 155 156 boolean mReceiverRegistered = false; 157 158 private static CallingTest sCallingTest = null; 159 setCallingTest(CallingTest ct)160 public static void setCallingTest(CallingTest ct) { 161 sCallingTest = ct; 162 } 163 LaunchpadActivity()164 public LaunchpadActivity() { 165 mStartTime = System.currentTimeMillis(); 166 } 167 168 @Override onCreate(Bundle icicle)169 protected void onCreate(Bundle icicle) { 170 super.onCreate(icicle); 171 String action = getIntent().getAction(); 172 if (ActivityTests.DEBUG_LIFECYCLE) Log.v("test", "CREATE lauchpad " 173 + Integer.toHexString(System.identityHashCode(this)) + ": " + getIntent()); 174 if (LIFECYCLE_BASIC.equals(action)) { 175 setExpectedLifecycle(new String[]{ON_START, ON_RESUME, 176 DO_FINISH, ON_PAUSE, ON_STOP, ON_DESTROY}); 177 } else if (LIFECYCLE_SCREEN.equals(action)) { 178 setExpectedLifecycle(new String[]{ON_START, ON_RESUME, 179 DO_LOCAL_SCREEN, ON_FREEZE, ON_PAUSE, ON_STOP, 180 ON_RESTART, ON_START, ON_RESUME, 181 DO_FINISH, ON_PAUSE, ON_STOP, ON_DESTROY}); 182 } else if (LIFECYCLE_DIALOG.equals(action)) { 183 setExpectedLifecycle(new String[]{ON_START, ON_RESUME, 184 DO_LOCAL_DIALOG, ON_FREEZE, ON_PAUSE, ON_RESUME, 185 DO_FINISH, ON_PAUSE, ON_STOP, ON_DESTROY}); 186 } else if (LIFECYCLE_FINISH_CREATE.equals(action)) { 187 // This one behaves a little differently when running in a group. 188 if (getParent() == null) { 189 setExpectedLifecycle(new String[]{ON_DESTROY}); 190 } else { 191 setExpectedLifecycle(new String[]{ON_START, ON_STOP, ON_DESTROY}); 192 } 193 finish(); 194 } else if (LIFECYCLE_FINISH_START.equals(action)) { 195 setExpectedLifecycle(new String[]{ON_START, DO_FINISH, 196 ON_STOP, ON_DESTROY}); 197 } 198 } 199 200 @Override onStart()201 protected void onStart() { 202 super.onStart(); 203 if (ActivityTests.DEBUG_LIFECYCLE) Log.v("test", "START lauchpad " 204 + Integer.toHexString(System.identityHashCode(this)) + ": " + getIntent()); 205 checkLifecycle(ON_START); 206 } 207 208 @Override onRestart()209 protected void onRestart() { 210 super.onStart(); 211 checkLifecycle(ON_RESTART); 212 } 213 214 @Override onResume()215 protected void onResume() { 216 super.onResume(); 217 218 if (ActivityTests.DEBUG_LIFECYCLE) Log.v("test", "RESUME lauchpad " 219 + Integer.toHexString(System.identityHashCode(this)) + ": " + getIntent()); 220 checkLifecycle(ON_RESUME); 221 222 if (!mStarted) { 223 mStarted = true; 224 225 mHandler.postDelayed(mTimeout, 5 * 1000); 226 227 String action = getIntent().getAction(); 228 229 sCallingTest.startTiming(true); 230 231 if (LAUNCH.equals(action)) { 232 Intent intent = getIntent(); 233 intent.setFlags(0); 234 intent.setComponent((ComponentName) 235 intent.getParcelableExtra("component")); 236 //System.out.println("*** Launchpad is starting: comp=" + intent.component); 237 startActivityForResult(intent, LAUNCHED_RESULT); 238 } else if (FORWARD_RESULT.equals(action)) { 239 Intent intent = getIntent(); 240 intent.setFlags(0); 241 intent.setClass(this, LocalScreen.class); 242 startActivityForResult(intent, FORWARDED_RESULT); 243 } else if (BAD_PARCELABLE.equals(action)) { 244 mBadParcelable = true; 245 Intent intent = getIntent(); 246 intent.setFlags(0); 247 intent.setClass(this, LocalScreen.class); 248 startActivityForResult(intent, LAUNCHED_RESULT); 249 } else if (BROADCAST_REGISTERED.equals(action)) { 250 setExpectedReceivers(new String[]{RECEIVER_REG}); 251 registerMyReceiver(new IntentFilter(BROADCAST_REGISTERED)); 252 sCallingTest.addIntermediate("after-register"); 253 sendBroadcast(makeBroadcastIntent(BROADCAST_REGISTERED)); 254 } else if (BROADCAST_LOCAL.equals(action)) { 255 setExpectedReceivers(new String[]{RECEIVER_LOCAL}); 256 sendBroadcast(makeBroadcastIntent(BROADCAST_LOCAL)); 257 } else if (BROADCAST_REMOTE.equals(action)) { 258 setExpectedReceivers(new String[]{RECEIVER_REMOTE}); 259 sendBroadcast(makeBroadcastIntent(BROADCAST_REMOTE)); 260 } else if (BROADCAST_ALL.equals(action)) { 261 setExpectedReceivers(new String[]{ 262 RECEIVER_REMOTE, RECEIVER_REG, RECEIVER_LOCAL}); 263 registerMyReceiver(new IntentFilter(BROADCAST_ALL)); 264 sCallingTest.addIntermediate("after-register"); 265 sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_ALL), null); 266 } else if (BROADCAST_MULTI.equals(action)) { 267 setExpectedReceivers(new String[]{ 268 RECEIVER_REMOTE, RECEIVER_REG, RECEIVER_LOCAL, 269 RECEIVER_REMOTE, RECEIVER_REG, RECEIVER_LOCAL, 270 RECEIVER_REMOTE, RECEIVER_REG, RECEIVER_LOCAL, 271 RECEIVER_LOCAL, RECEIVER_REMOTE, 272 RECEIVER_LOCAL, RECEIVER_REMOTE, 273 RECEIVER_REMOTE, RECEIVER_REG, RECEIVER_LOCAL, 274 RECEIVER_REMOTE, RECEIVER_REG, RECEIVER_LOCAL, 275 RECEIVER_REMOTE, RECEIVER_REG, RECEIVER_LOCAL, 276 RECEIVER_REMOTE, RECEIVER_LOCAL, 277 RECEIVER_REMOTE, RECEIVER_LOCAL}); 278 registerMyReceiver(new IntentFilter(BROADCAST_ALL)); 279 sCallingTest.addIntermediate("after-register"); 280 sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_ALL), null); 281 sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_ALL), null); 282 sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_ALL), null); 283 sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_LOCAL), null); 284 sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_REMOTE), null); 285 sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_LOCAL), null); 286 sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_REMOTE), null); 287 sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_ALL), null); 288 sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_ALL), null); 289 sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_ALL), null); 290 sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_REPEAT), null); 291 } else if (BROADCAST_ABORT.equals(action)) { 292 setExpectedReceivers(new String[]{ 293 RECEIVER_REMOTE, RECEIVER_ABORT}); 294 registerMyReceiver(new IntentFilter(BROADCAST_ABORT)); 295 sCallingTest.addIntermediate("after-register"); 296 sendOrderedBroadcast(makeBroadcastIntent(BROADCAST_ABORT), null); 297 } else if (BROADCAST_STICKY1.equals(action)) { 298 setExpectedReceivers(new String[]{RECEIVER_REG}); 299 setExpectedData(new String[]{DATA_1}); 300 registerMyReceiver(new IntentFilter(BROADCAST_STICKY1)); 301 sCallingTest.addIntermediate("after-register"); 302 } else if (BROADCAST_STICKY2.equals(action)) { 303 setExpectedReceivers(new String[]{RECEIVER_REG, RECEIVER_REG}); 304 setExpectedData(new String[]{DATA_1, DATA_2}); 305 IntentFilter filter = new IntentFilter(BROADCAST_STICKY1); 306 filter.addAction(BROADCAST_STICKY2); 307 registerMyReceiver(filter); 308 sCallingTest.addIntermediate("after-register"); 309 } 310 } 311 } 312 313 @Override onSaveInstanceState(Bundle icicle)314 protected void onSaveInstanceState(Bundle icicle) { 315 super.onSaveInstanceState(icicle); 316 checkLifecycle(ON_FREEZE); 317 if (mBadParcelable) { 318 icicle.putParcelable("baddy", new MyBadParcelable()); 319 } 320 } 321 322 @Override onPause()323 protected void onPause() { 324 super.onPause(); 325 if (ActivityTests.DEBUG_LIFECYCLE) Log.v("test", "PAUSE lauchpad " 326 + Integer.toHexString(System.identityHashCode(this)) + ": " + getIntent()); 327 checkLifecycle(ON_PAUSE); 328 } 329 330 @Override onStop()331 protected void onStop() { 332 super.onStop(); 333 if (ActivityTests.DEBUG_LIFECYCLE) Log.v("test", "STOP lauchpad " 334 + Integer.toHexString(System.identityHashCode(this)) + ": " + getIntent()); 335 checkLifecycle(ON_STOP); 336 } 337 338 @Override onActivityResult(int requestCode, int resultCode, Intent data)339 protected void onActivityResult(int requestCode, int resultCode, 340 Intent data) { 341 switch (requestCode) { 342 case LAUNCHED_RESULT: 343 sCallingTest.finishTiming(true); 344 finishWithResult(resultCode, data); 345 break; 346 case FORWARDED_RESULT: 347 sCallingTest.finishTiming(true); 348 if (RETURNED_RESULT.equals(data.getAction())) { 349 finishWithResult(resultCode, data); 350 } else { 351 finishWithResult(RESULT_CANCELED, (new Intent()).setAction( 352 "Bad data returned: " + data)); 353 } 354 break; 355 default: 356 sCallingTest.finishTiming(true); 357 finishWithResult(RESULT_CANCELED, (new Intent()).setAction( 358 "Unexpected request code: " + requestCode)); 359 break; 360 } 361 } 362 363 @Override onDestroy()364 protected void onDestroy() { 365 super.onDestroy(); 366 if (ActivityTests.DEBUG_LIFECYCLE) Log.v("test", "DESTROY lauchpad " 367 + Integer.toHexString(System.identityHashCode(this)) + ": " + getIntent()); 368 checkLifecycle(ON_DESTROY); 369 sCallingTest.activityFinished(mResultCode, mData, mResultStack); 370 } 371 setExpectedLifecycle(String[] lifecycle)372 private void setExpectedLifecycle(String[] lifecycle) { 373 mExpectedLifecycle = lifecycle; 374 mNextLifecycle = 0; 375 } 376 checkLifecycle(String where)377 private void checkLifecycle(String where) { 378 if (mExpectedLifecycle == null) return; 379 380 if (mNextLifecycle >= mExpectedLifecycle.length) { 381 finishBad("Activity lifecycle incorrect: received " + where 382 + " but don't expect any more calls"); 383 mExpectedLifecycle = null; 384 return; 385 } 386 if (!mExpectedLifecycle[mNextLifecycle].equals(where)) { 387 finishBad("Activity lifecycle incorrect: received " + where 388 + " but expected " + mExpectedLifecycle[mNextLifecycle] 389 + " at " + mNextLifecycle); 390 mExpectedLifecycle = null; 391 return; 392 } 393 394 mNextLifecycle++; 395 396 if (mNextLifecycle >= mExpectedLifecycle.length) { 397 setTestResult(RESULT_OK, null); 398 return; 399 } 400 401 String next = mExpectedLifecycle[mNextLifecycle]; 402 if (where.equals(ON_DESTROY)) { 403 finishBad("Activity lifecycle incorrect: received " + where 404 + " but expected more actions (next is " + next + ")"); 405 mExpectedLifecycle = null; 406 return; 407 } else if (next.equals(DO_FINISH)) { 408 mNextLifecycle++; 409 if (mNextLifecycle >= mExpectedLifecycle.length) { 410 setTestResult(RESULT_OK, null); 411 } 412 if (!isFinishing()) { 413 finish(); 414 } 415 } else if (next.equals(DO_LOCAL_SCREEN)) { 416 mNextLifecycle++; 417 Intent intent = new Intent(TestedScreen.WAIT_BEFORE_FINISH); 418 intent.setClass(this, LocalScreen.class); 419 startActivity(intent); 420 } else if (next.equals(DO_LOCAL_DIALOG)) { 421 mNextLifecycle++; 422 Intent intent = new Intent(TestedScreen.WAIT_BEFORE_FINISH); 423 intent.setClass(this, LocalDialog.class); 424 startActivity(intent); 425 } 426 } 427 setExpectedReceivers(String[] receivers)428 private void setExpectedReceivers(String[] receivers) { 429 mExpectedReceivers = receivers; 430 mNextReceiver = 0; 431 } 432 setExpectedData(String[] data)433 private void setExpectedData(String[] data) { 434 mExpectedData = data; 435 mReceivedData = new boolean[data.length]; 436 } 437 makeBroadcastIntent(String action)438 private Intent makeBroadcastIntent(String action) { 439 Intent intent = new Intent(action, null); 440 intent.putExtra("caller", mCallTarget); 441 return intent; 442 } 443 finishGood()444 private void finishGood() { 445 finishWithResult(RESULT_OK, null); 446 } 447 finishBad(String error)448 private void finishBad(String error) { 449 finishWithResult(RESULT_CANCELED, (new Intent()).setAction(error)); 450 } 451 finishWithResult(int resultCode, Intent data)452 private void finishWithResult(int resultCode, Intent data) { 453 setTestResult(resultCode, data); 454 finish(); 455 } 456 setTestResult(int resultCode, Intent data)457 private void setTestResult(int resultCode, Intent data) { 458 mHandler.removeCallbacks(mTimeout); 459 unregisterMyReceiver(); 460 mResultCode = resultCode; 461 mData = data; 462 mResultStack = new RuntimeException("Original error was here"); 463 mResultStack.fillInStackTrace(); 464 } 465 registerMyReceiver(IntentFilter filter)466 private void registerMyReceiver(IntentFilter filter) { 467 mReceiverRegistered = true; 468 //System.out.println("Registering: " + mReceiver); 469 registerReceiver(mReceiver, filter); 470 } 471 unregisterMyReceiver()472 private void unregisterMyReceiver() { 473 if (mReceiverRegistered) { 474 mReceiverRegistered = false; 475 //System.out.println("Unregistering: " + mReceiver); 476 unregisterReceiver(mReceiver); 477 } 478 } 479 480 private Handler mHandler = new Handler() { 481 public void handleMessage(Message msg) { 482 } 483 }; 484 485 static final int GOT_RECEIVE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION; 486 static final int ERROR_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 1; 487 488 private Binder mCallTarget = new Binder() { 489 public boolean onTransact(int code, Parcel data, Parcel reply, int flags) { 490 data.setDataPosition(0); 491 data.enforceInterface(LaunchpadActivity.LAUNCH); 492 if (code == GOT_RECEIVE_TRANSACTION) { 493 String name = data.readString(); 494 gotReceive(name, null); 495 return true; 496 } else if (code == ERROR_TRANSACTION) { 497 finishBad(data.readString()); 498 return true; 499 } 500 return false; 501 } 502 }; 503 gotReceive(String name, Intent intent)504 private final void gotReceive(String name, Intent intent) { 505 synchronized (this) { 506 507 //System.out.println("Got receive: " + name); 508 //System.out.println(mNextReceiver + " in " + mExpectedReceivers); 509 //new RuntimeException("stack").printStackTrace(); 510 511 sCallingTest.addIntermediate(mNextReceiver + "-" + name); 512 513 if (mExpectedData != null) { 514 int n = mExpectedData.length; 515 int i; 516 boolean prev = false; 517 for (i = 0; i < n; i++) { 518 if (mExpectedData[i].equals(intent.getStringExtra("test"))) { 519 if (mReceivedData[i]) { 520 prev = true; 521 continue; 522 } 523 mReceivedData[i] = true; 524 break; 525 } 526 } 527 if (i >= n) { 528 if (prev) { 529 finishBad("Receive got data too many times: " 530 + intent.getStringExtra("test")); 531 } else { 532 finishBad("Receive got unexpected data: " 533 + intent.getStringExtra("test")); 534 } 535 return; 536 } 537 } 538 539 if (mNextReceiver >= mExpectedReceivers.length) { 540 finishBad("Got too many onReceiveIntent() calls!"); 541 // System.out.println("Too many intents received: now at " 542 // + mNextReceiver + ", expect list: " 543 // + Arrays.toString(mExpectedReceivers)); 544 } else if (!mExpectedReceivers[mNextReceiver].equals(name)) { 545 finishBad("Receive out of order: got " + name + " but expected " 546 + mExpectedReceivers[mNextReceiver] + " at " 547 + mNextReceiver); 548 } else { 549 mNextReceiver++; 550 if (mNextReceiver == mExpectedReceivers.length) { 551 mHandler.post(mUnregister); 552 } 553 } 554 555 } 556 } 557 558 private Runnable mUnregister = new Runnable() { 559 public void run() { 560 if (mReceiverRegistered) { 561 sCallingTest.addIntermediate("before-unregister"); 562 unregisterMyReceiver(); 563 } 564 sCallingTest.finishTiming(true); 565 finishGood(); 566 } 567 }; 568 569 private Runnable mTimeout = new Runnable() { 570 public void run() { 571 Log.i("foo", "**** TIMEOUT"); 572 String msg = "Timeout"; 573 if (mExpectedReceivers != null 574 && mNextReceiver < mExpectedReceivers.length) { 575 msg = msg + " waiting for " + mExpectedReceivers[mNextReceiver]; 576 } 577 finishBad(msg); 578 } 579 }; 580 581 private BroadcastReceiver mReceiver = new BroadcastReceiver() { 582 public void onReceive(Context context, Intent intent) { 583 //System.out.println("Receive in: " + this + ": " + intent); 584 gotReceive(RECEIVER_REG, intent); 585 } 586 }; 587 } 588 589