From b154630235935e1aab2a41eff9ed794d40084a02 Mon Sep 17 00:00:00 2001
From: David Brown <dab@google.com>
Date: Wed, 28 Jul 2010 13:46:24 -0700
Subject: [PATCH] Add "non-interactive" mode for the OTASP (CDMA provisioning)
 call.

Non-voice-capable devices (like Stingray) have no built-in phone UI, but
do still need to make a special phone call when first "activating" the
device.

Till now, the code handling the OTASP call (OtaUtils.java) was very
tightly coupled to the InCallScreen, using special modes of the in-call UI
to display the "skip" and "activate" choices, and display a DTMF dialpad
and Speaker button and progress info during the call.

This change decouples the OtaUtils and InCallScreen code, and allows the
OTASP call to run in "non-interactive" mode.  Now, on data-only devices we
launch the OTASP call without involving the InCallScreen at all.

This change also cleans up the way we send results back to the
SetupWizard:

  - First of all, in non-interactive mode, we now return an activity result
    right away after kicking off the OTASP call.  This lets our caller know
    either that the OTASP call started (and is running in the background),
    or that that we couldn't start the OTASP call at all.

  - And as before, when the OTASP call ultimately finishes, we send back a
    PendingIntent that was originally provided by our caller.  But now, we
    explicitly add an extra called EXTRA_OTASP_RESULT_CODE to that
    PendingIntent.  That extra's value is an integer code, which allows
    the caller to distinguish among several possible outcomes, namely
    "success", "failure", and "user skipped".

Finally, this change includes a test activity called OtaspTestActivity which
exercises the whole "non-interactive" OTASP sequence (which basically
mimics the PERFORM_CDMA_PROVISIONING behavior of SetupWizard.)

More details:

  - When we handle the PERFORM_CDMA_PROVISIONING intent (see
    InCallScreenShowActivation.java) we check a config resource called
    R.bool.voice_capable to decide whether to use the in-call UI.  (That
    resource is true by default, but overridden to false on Stingray.)

  - The singleton OtaUtils instance is now owned by the PhoneApp, not the
    InCallScreen, since we can now have an OtaUtils instance *without* an
    InCallScreen.

  - I renamed the "com.android.phone.InCallScreen.SHOW_ACTIVATION" intent
    action to be "com.android.phone.PERFORM_CDMA_PROVISIONING", to be more
    precise, and especially to make it clear that it's not tied to the
    InCallScreen.

  - Moved all OTASP-releated string constants into OtaUtils (rather than
    having them sprinkled around in 3 or 4 places.)

Bug: 2837917

Change-Id: Ifa82591478ccb2ec9501163963944d0d0659b9ea
---
 AndroidManifest.xml                           |  24 +-
 res/layout/ota_test_activity.xml              |  68 +++
 src/com/android/phone/CallNotifier.java       |   9 +
 src/com/android/phone/InCallScreen.java       | 107 ++--
 .../phone/InCallScreenShowActivation.java     | 125 ++++-
 src/com/android/phone/OtaUtils.java           | 486 +++++++++++++++---
 src/com/android/phone/OtaspTestActivity.java  | 269 ++++++++++
 src/com/android/phone/PhoneApp.java           |  57 +-
 8 files changed, 987 insertions(+), 158 deletions(-)
 create mode 100644 res/layout/ota_test_activity.xml
 create mode 100644 src/com/android/phone/OtaspTestActivity.java

diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index 10abd589..b97f28e0 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -73,6 +73,7 @@
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
     <uses-permission android:name="android.permission.SHUTDOWN" />
     <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.PERFORM_CDMA_PROVISIONING" />
 
     <!-- This tells the activity manager to not delay any of our activity
          start requests, even if they happen immediately after the user
@@ -202,6 +203,10 @@
             </intent-filter>
         </receiver>
 
+        <!-- Main in-call UI activity.  This is never launched directly
+             from outside the phone app; instead, it's either launched by
+             the OutgoingCallBroadcaster (for outgoing calls), or as the
+             fullScreenIntent of a notification (for incoming calls.) -->
         <activity android:name="InCallScreen"
             android:theme="@android:style/Theme.NoTitleBar"
             android:label="@string/phoneIconLabel"
@@ -212,12 +217,13 @@
             android:exported="false">
         </activity>
 
+        <!-- Trampoline activity that handles the PERFORM_CDMA_PROVISIONING intent. -->
         <activity android:name="InCallScreenShowActivation"
             android:permission="android.permission.PERFORM_CDMA_PROVISIONING"
             android:label="@string/phoneIconLabel"
             android:excludeFromRecents="true">
             <intent-filter>
-                <action android:name="com.android.phone.InCallScreen.SHOW_ACTIVATION" />
+                <action android:name="com.android.phone.PERFORM_CDMA_PROVISIONING" />
                 <category android:name="android.intent.category.DEFAULT" />
             </intent-filter>
         </activity>
@@ -423,6 +429,20 @@
                 android:configChanges="orientation|keyboardHidden">
         </activity>
 
+        <!-- Test activity mimicking the PERFORM_CDMA_PROVISIONING behavior of
+             SetupWizard, useful for testing "non-interactive" OTASP.
+             STOPSHIP: During initial Stingray OTASP testing, this is
+             exposed in the LAUNCHER category.  It should ultimately move
+             into the "tests" manifest, though, at which point we can
+             remove it *and* the PERFORM_CDMA_PROVISIONING permission from here. -->
+        <activity android:name="OtaspTestActivity"
+                  android:label="OtaspTest">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+
     </application>
 </manifest>
-
diff --git a/res/layout/ota_test_activity.xml b/res/layout/ota_test_activity.xml
new file mode 100644
index 00000000..371a6d44
--- /dev/null
+++ b/res/layout/ota_test_activity.xml
@@ -0,0 +1,68 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+
+<!-- Ultra-simple test activity for triggering an OTASP call. -->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="vertical"
+    android:gravity="center_vertical|center_horizontal"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:paddingTop="64dip"
+    >
+
+    <TextView android:id="@+id/label1"
+              android:layout_width="wrap_content"
+              android:layout_height="wrap_content"
+              android:layout_marginTop="30dip"
+              android:textAppearance="?android:attr/textAppearanceLarge"
+              />
+
+    <View android:layout_width="1dip"
+          android:layout_height="1dip"
+          android:layout_weight="1" />
+
+    <ProgressBar android:id="@+id/progress_bar"
+              style="?android:attr/progressBarStyleHorizontal"
+              android:layout_width="240dip"
+              android:layout_height="wrap_content"
+              android:indeterminate="true"
+              android:visibility="invisible" />
+
+    <TextView android:id="@+id/result1"
+              android:layout_width="wrap_content"
+              android:layout_height="wrap_content"
+              android:textAppearance="?android:attr/textAppearanceLarge"
+              android:visibility="invisible" />
+
+    <View android:layout_width="1dip"
+          android:layout_height="1dip"
+          android:layout_weight="1" />
+
+    <Button android:id="@+id/button1"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_marginTop="10dip"
+            android:layout_marginBottom="10dip"
+            android:paddingLeft="32dip"
+            android:paddingRight="32dip"
+            android:textAppearance="?android:attr/textAppearanceMedium"
+            />
+
+    <View android:layout_width="1dip"
+          android:layout_height="1dip"
+          android:layout_weight="1" />
+
+</LinearLayout>
diff --git a/src/com/android/phone/CallNotifier.java b/src/com/android/phone/CallNotifier.java
index 3f17c355..ebfac6d0 100755
--- a/src/com/android/phone/CallNotifier.java
+++ b/src/com/android/phone/CallNotifier.java
@@ -975,6 +975,15 @@ private void onDisconnect(AsyncResult r) {
             mCallWaitingTonePlayer = null;
         }
 
+        // If this is the end of an OTASP call, pass it on to the PhoneApp.
+        if (c != null && TelephonyCapabilities.supportsOtasp(mPhone)) {
+            final String number = c.getAddress();
+            if (mPhone.isOtaSpNumber(number)) {
+                if (DBG) log("onDisconnect: this was an OTASP call!");
+                mApplication.handleOtaspDisconnect();
+            }
+        }
+
         // Check for the various tones we might need to play (thru the
         // earpiece) after a call disconnects.
         int toneToPlay = InCallTonePlayer.TONE_NONE;
diff --git a/src/com/android/phone/InCallScreen.java b/src/com/android/phone/InCallScreen.java
index 23a3a6ad..b6b4eddb 100755
--- a/src/com/android/phone/InCallScreen.java
+++ b/src/com/android/phone/InCallScreen.java
@@ -173,12 +173,6 @@ public class InCallScreen extends Activity
     private static final int EVENT_HIDE_PROVIDER_OVERLAY = 121;  // Time to remove the overlay.
     private static final int REQUEST_UPDATE_TOUCH_UI = 122;
 
-    //following constants are used for OTA Call
-    public static final String ACTION_SHOW_ACTIVATION =
-           "com.android.phone.InCallScreen.SHOW_ACTIVATION";
-    public static final String OTA_NUMBER = "*228";
-    public static final String EXTRA_OTA_CALL = "android.phone.extra.OTA_CALL";
-
     // When InCallScreenMode is UNDEFINED set the default action
     // to ACTION_UNDEFINED so if we are resumed the activity will
     // know its undefined. In particular checkIsOtaCall will return
@@ -271,9 +265,6 @@ private enum InCallInitStatus {
     // The formated address extracted from mProviderGatewayUri. User visible.
     private String mProviderAddress;
 
-    // For OTA Call
-    public OtaUtils otaUtils;
-
     private EditText mWildPromptText;
 
     // "Touch lock overlay" feature
@@ -469,20 +460,20 @@ public void handleMessage(Message msg) {
                     break;
 
                 case EVENT_OTA_PROVISION_CHANGE:
-                    if (otaUtils != null) {
-                        otaUtils.onOtaProvisionStatusChanged((AsyncResult) msg.obj);
+                    if (app.otaUtils != null) {
+                        app.otaUtils.onOtaProvisionStatusChanged((AsyncResult) msg.obj);
                     }
                     break;
 
                 case REQUEST_CLOSE_SPC_ERROR_NOTICE:
-                    if (otaUtils != null) {
-                        otaUtils.onOtaCloseSpcNotice();
+                    if (app.otaUtils != null) {
+                        app.otaUtils.onOtaCloseSpcNotice();
                     }
                     break;
 
                 case REQUEST_CLOSE_OTA_FAILURE_NOTICE:
-                    if (otaUtils != null) {
-                        otaUtils.onOtaCloseFailureNotice();
+                    if (app.otaUtils != null) {
+                        app.otaUtils.onOtaCloseFailureNotice();
                     }
                     break;
 
@@ -551,7 +542,7 @@ protected void onCreate(Bundle icicle) {
 
         setPhone(app.phone);  // Sets mPhone
 
-        mCM =  PhoneApp.getInstance().mCM;
+        mCM =  app.mCM;
 
         mBluetoothHandsfree = app.getBluetoothHandsfree();
         if (VDBG) log("- mBluetoothHandsfree: " + mBluetoothHandsfree);
@@ -922,8 +913,8 @@ protected void onStop() {
                 // if there are not active or ringing calls.
                 if (DBG) log("- onStop: calling finish() to clear activity history...");
                 moveTaskToBack(true);
-                if (otaUtils != null) {
-                    otaUtils.cleanOtaScreen(true);
+                if (app.otaUtils != null) {
+                    app.otaUtils.cleanOtaScreen(true);
                 }
             }
         }
@@ -1122,11 +1113,14 @@ protected void onNewIntent(Intent intent) {
         // outgoing call or answering an incoming one, and NOT handling
         // an aborted "Add Call" request), so we should let the mute state
         // be handled by the PhoneUtils phone state change handler.
+
         final PhoneApp app = PhoneApp.getInstance();
-        // If OTA Activation is configured for Power up scenario, then
-        // InCallScreen UI started with Intent of ACTION_SHOW_ACTIVATION
-        // to show OTA Activation screen at power up.
-        if ((action.equals(ACTION_SHOW_ACTIVATION))
+
+        // The ACTION_PERFORM_CDMA_PROVISIONING intent tells us to launch
+        // the CDMA OTASP call.  (Note: on non-voice-capable devices, this
+        // intent is handled by the OtaUtils class without involving the
+        // InCallScreen at all.)
+        if ((action.equals(OtaUtils.ACTION_PERFORM_CDMA_PROVISIONING))
                 && (TelephonyCapabilities.supportsOtasp(mPhone))) {
             setInCallScreenMode(InCallScreenMode.OTA_NORMAL);
             if ((app.cdmaOtaProvisionData != null)
@@ -1136,10 +1130,12 @@ protected void onNewIntent(Intent intent) {
                         CdmaOtaScreenState.OtaScreenState.OTA_STATUS_ACTIVATION;
             }
             return InCallInitStatus.SUCCESS;
+
         } else if (action.equals(Intent.ACTION_ANSWER)) {
             internalAnswerCall();
             app.setRestoreMuteOnInCallResume(false);
             return InCallInitStatus.SUCCESS;
+
         } else if (action.equals(Intent.ACTION_CALL)
                 || action.equals(Intent.ACTION_CALL_EMERGENCY)) {
             app.setRestoreMuteOnInCallResume(false);
@@ -1168,6 +1164,7 @@ protected void onNewIntent(Intent intent) {
                 app.setBeginningCall(true);
             }
             return status;
+
         } else if (action.equals(intent.ACTION_MAIN)) {
             // The MAIN action is used to bring up the in-call screen without
             // doing any other explicit action, like when you return to the
@@ -1192,8 +1189,10 @@ protected void onNewIntent(Intent intent) {
                 }
             }
             return InCallInitStatus.SUCCESS;
+
         } else if (action.equals(ACTION_UNDEFINED)) {
             return InCallInitStatus.SUCCESS;
+
         } else {
             Log.w(LOG_TAG, "internalResolveIntent: unexpected intent action: " + action);
             // But continue the best we can (basically treating this case
@@ -2299,9 +2298,9 @@ private void updateScreen() {
 
         if (mInCallScreenMode == InCallScreenMode.OTA_NORMAL) {
             if (DBG) log("- updateScreen: OTA call state NORMAL...");
-            if (otaUtils != null) {
-                if (DBG) log("- updateScreen: otaUtils is not null, call otaShowProperScreen");
-                otaUtils.otaShowProperScreen();
+            if (app.otaUtils != null) {
+                if (DBG) log("- updateScreen: app.otaUtils is not null, call otaShowProperScreen");
+                app.otaUtils.otaShowProperScreen();
             }
             return;
         } else if (mInCallScreenMode == InCallScreenMode.OTA_ENDED) {
@@ -2311,16 +2310,16 @@ private void updateScreen() {
             if (app.cdmaOtaScreenState.otaScreenState
                 == CdmaOtaScreenState.OtaScreenState.OTA_STATUS_ACTIVATION) {
                 if (DBG) log("- updateScreen: OTA_STATUS_ACTIVATION");
-                if (otaUtils != null) {
-                    if (DBG) log("- updateScreen: otaUtils is not null, "
+                if (app.otaUtils != null) {
+                    if (DBG) log("- updateScreen: app.otaUtils is not null, "
                                   + "call otaShowActivationScreen");
-                    otaUtils.otaShowActivateScreen();
+                    app.otaUtils.otaShowActivateScreen();
                 }
             } else {
                 if (DBG) log("- updateScreen: OTA Call end state for Dialogs");
-                if (otaUtils != null) {
+                if (app.otaUtils != null) {
                     if (DBG) log("- updateScreen: Show OTA Success Failure dialog");
-                    otaUtils.otaShowSuccessFailure();
+                    app.otaUtils.otaShowSuccessFailure();
                 }
             }
             return;
@@ -2934,10 +2933,11 @@ public void onClick(View view) {
                 break;
 
             default:
+                final PhoneApp app = PhoneApp.getInstance();
                 if  ((mInCallScreenMode == InCallScreenMode.OTA_NORMAL
                         || mInCallScreenMode == InCallScreenMode.OTA_ENDED)
-                        && otaUtils != null) {
-                    otaUtils.onClickHandler(id);
+                        && app.otaUtils != null) {
+                    app.otaUtils.onClickHandler(id);
                 } else {
                     Log.w(LOG_TAG,
                             "Got click from unexpected View ID " + id + " (View = " + view + ")");
@@ -3442,6 +3442,7 @@ private void bailOutAfterErrorDialog() {
      */
     private void dismissAllDialogs() {
         if (DBG) log("dismissAllDialogs()...");
+        final PhoneApp app = PhoneApp.getInstance();
 
         // Note it's safe to dismiss() a dialog that's already dismissed.
         // (Even if the AlertDialog object(s) below are still around, it's
@@ -3485,8 +3486,8 @@ private void dismissAllDialogs() {
         }
         if ((mInCallScreenMode == InCallScreenMode.OTA_NORMAL
                 || mInCallScreenMode == InCallScreenMode.OTA_ENDED)
-                && otaUtils != null) {
-            otaUtils.dismissAllOtaDialogs();
+                && app.otaUtils != null) {
+            app.otaUtils.dismissAllOtaDialogs();
         }
         if (mPausePromptDialog != null) {
             if (DBG) log("- DISMISSING mPausePromptDialog.");
@@ -3623,6 +3624,9 @@ private void internalSwapCalls() {
     private void setInCallScreenMode(InCallScreenMode newMode) {
         if (DBG) log("setInCallScreenMode: " + newMode);
         mInCallScreenMode = newMode;
+
+        final PhoneApp app = PhoneApp.getInstance();
+
         switch (mInCallScreenMode) {
             case MANAGE_CONFERENCE:
                 if (!PhoneUtils.isConferenceCall(mCM.getActiveFgCall())) {
@@ -3695,13 +3699,13 @@ private void setInCallScreenMode(InCallScreenMode newMode) {
                 break;
 
             case OTA_NORMAL:
-                otaUtils.setCdmaOtaInCallScreenUiState(
+                app.otaUtils.setCdmaOtaInCallScreenUiState(
                         OtaUtils.CdmaOtaInCallScreenUiState.State.NORMAL);
                 mInCallPanel.setVisibility(View.GONE);
                 break;
 
             case OTA_ENDED:
-                otaUtils.setCdmaOtaInCallScreenUiState(
+                app.otaUtils.setCdmaOtaInCallScreenUiState(
                         OtaUtils.CdmaOtaInCallScreenUiState.State.ENDED);
                 mInCallPanel.setVisibility(View.GONE);
                 break;
@@ -3734,8 +3738,8 @@ private void setInCallScreenMode(InCallScreenMode newMode) {
                 // Cleanup Ota Screen if necessary and set the panel
                 // to VISIBLE.
                 if (mCM.getState() != Phone.State.OFFHOOK) {
-                    if (otaUtils != null) {
-                        otaUtils.cleanOtaScreen(true);
+                    if (app.otaUtils != null) {
+                        app.otaUtils.cleanOtaScreen(true);
                     }
                 } else {
                     log("WARNING: Setting mode to UNDEFINED but phone is OFFHOOK,"
@@ -3892,6 +3896,7 @@ private void updateDialpadVisibility() {
      */
     /* package */ void onDialerOpen() {
         if (DBG) log("onDialerOpen()...");
+        final PhoneApp app = PhoneApp.getInstance();
 
         // ANY time the dialpad becomes visible, start the timer that will
         // eventually bring up the "touch lock" overlay.
@@ -3905,15 +3910,15 @@ private void updateDialpadVisibility() {
         updateDialpadVisibility();
 
         // This counts as explicit "user activity".
-        PhoneApp.getInstance().pokeUserActivity();
+        app.pokeUserActivity();
 
         //If on OTA Call, hide OTA Screen
         // TODO: This may not be necessary, now that the dialpad is
         // always visible in OTA mode.
         if  ((mInCallScreenMode == InCallScreenMode.OTA_NORMAL
                 || mInCallScreenMode == InCallScreenMode.OTA_ENDED)
-                && otaUtils != null) {
-            otaUtils.hideOtaScreen();
+                && app.otaUtils != null) {
+            app.otaUtils.hideOtaScreen();
         }
     }
 
@@ -3933,8 +3938,8 @@ private void updateDialpadVisibility() {
                 && (app.cdmaOtaScreenState.otaScreenState ==
                     CdmaOtaScreenState.OtaScreenState.OTA_STATUS_ACTIVATION))) {
             mDialer.setHandleVisible(false);
-            if (otaUtils != null) {
-                otaUtils.otaShowProperScreen();
+            if (app.otaUtils != null) {
+                app.otaUtils.otaShowProperScreen();
             }
         }
 
@@ -4711,10 +4716,10 @@ private boolean checkIsOtaCall(Intent intent) {
 
         String action = intent.getAction();
         boolean isOtaCall = false;
-        if (action.equals(ACTION_SHOW_ACTIVATION)) {
-            if (DBG) log("checkIsOtaCall action = ACTION_SHOW_ACTIVATION");
+        if (action.equals(OtaUtils.ACTION_PERFORM_CDMA_PROVISIONING)) {
+            if (DBG) log("checkIsOtaCall action = ACTION_PERFORM_CDMA_PROVISIONING");
             if (!app.cdmaOtaProvisionData.isOtaCallIntentProcessed) {
-                if (DBG) log("checkIsOtaCall: ACTION_SHOW_ACTIVATION is not handled before");
+                if (DBG) log("checkIsOtaCall: ACTION_PERFORM_CDMA_PROVISIONING is not handled before");
                 app.cdmaOtaProvisionData.isOtaCallIntentProcessed = true;
                 app.cdmaOtaScreenState.otaScreenState =
                         CdmaOtaScreenState.OtaScreenState.OTA_STATUS_ACTIVATION;
@@ -4756,9 +4761,9 @@ private boolean checkIsOtaCall(Intent intent) {
         }
 
         if (DBG) log("checkIsOtaCall: isOtaCall =" + isOtaCall);
-        if (isOtaCall && (otaUtils == null)) {
+        if (isOtaCall && (app.otaUtils == null)) {
             if (DBG) log("checkIsOtaCall: creating OtaUtils...");
-            otaUtils = new OtaUtils(getApplicationContext(),
+            app.otaUtils = new OtaUtils(getApplicationContext(),
                                     this, mInCallPanel, mCallCard, mDialer);
         }
         return isOtaCall;
@@ -4791,7 +4796,7 @@ private boolean initOtaState() {
             inOtaCall = checkIsOtaCall(getIntent());
             if (inOtaCall) {
                 OtaUtils.CdmaOtaInCallScreenUiState.State cdmaOtaInCallScreenState =
-                        otaUtils.getCdmaOtaInCallScreenUiState();
+                        app.otaUtils.getCdmaOtaInCallScreenUiState();
                 if (cdmaOtaInCallScreenState == OtaUtils.CdmaOtaInCallScreenUiState.State.NORMAL) {
                     if (DBG) log("initOtaState - in OTA Normal mode");
                     setInCallScreenMode(InCallScreenMode.OTA_NORMAL);
@@ -4808,8 +4813,8 @@ private boolean initOtaState() {
                     setInCallScreenMode(InCallScreenMode.OTA_NORMAL);
                 }
             } else {
-                if (otaUtils != null) {
-                    otaUtils.cleanOtaScreen(false);
+                if (app.otaUtils != null) {
+                    app.otaUtils.cleanOtaScreen(false);
                 }
             }
         }
diff --git a/src/com/android/phone/InCallScreenShowActivation.java b/src/com/android/phone/InCallScreenShowActivation.java
index 7ad096a9..dd9e5ada 100644
--- a/src/com/android/phone/InCallScreenShowActivation.java
+++ b/src/com/android/phone/InCallScreenShowActivation.java
@@ -16,42 +16,133 @@
 
 package com.android.phone;
 
-import com.android.internal.telephony.Phone;
-
 import android.app.Activity;
 import android.app.PendingIntent;
 import android.content.Intent;
 import android.os.Bundle;
 import android.util.Log;
 
+import com.android.internal.telephony.Phone;
+
 /**
- * Trampoline to InCallScreen protected by PERFORM_CDMA_PROVISIONING permission
- * to only expose SHOW_ACTIVATION.
+ * Trampoline activity that handles the com.android.phone.PERFORM_CDMA_PROVISIONING intent.
+ * This activity is protected by the android.permission.PERFORM_CDMA_PROVISIONING permission.
+ *
+ * On regular phones, we simply redirect to the InCallScreen, which will
+ * handle the PERFORM_CDMA_PROVISIONING action by launching an OTASP call.
+ *
+ * On data-only devices, though, we manually launch the OTASP call without
+ * displaying the in-call UI, and then immediately finish(), so that our
+ * caller (presumably the SetupWizard) can display some sort of progress UI.
+ *
+ * TODO: The class name InCallScreenShowActivation is misleading, since
+ * the InCallScreen is not involved at all in CDMA provisioning on some
+ * devices.  Let's eventually rename this to something like
+ * CdmaProvisioningLauncher or CdmaProvisioningHandler...
  */
 public class InCallScreenShowActivation extends Activity {
     private static final String LOG_TAG = "InCallScreenShowActivation";
 
-    // the pending intent we'll use to report the user skipped provisioning
-    // Note: this constant must match the one defined in SetupWizardActivity
-    private static final String EXTRA_USER_SKIP_PENDING_INTENT = "ota_user_skip_pending_intent";
-
     @Override
     protected void onCreate(Bundle icicle) {
         super.onCreate(icicle);
 
         Intent intent = getIntent();
-        if (intent.getAction().equals(InCallScreen.ACTION_SHOW_ACTIVATION)) {
-            Intent newIntent = new Intent().setClass(this, InCallScreen.class)
-                    .setAction(InCallScreen.ACTION_SHOW_ACTIVATION);
+        Log.d(LOG_TAG, "onCreate: intent = " + intent);
+        Bundle extras = intent.getExtras();
+        if (extras != null) {
+            Log.i(LOG_TAG, "      - has extras: size = " + extras.size()); // forces an unparcel()
+            Log.i(LOG_TAG, "      - extras = " + extras);
+        }
+
+        PhoneApp app = PhoneApp.getInstance();
+        Phone phone = app.getPhone();
+        if (!TelephonyCapabilities.supportsOtasp(phone)) {
+            Log.w(LOG_TAG, "CDMA Provisioning not supported on this device");
+            setResult(RESULT_CANCELED);
+            finish();
+            return;
+        }
+
+        if (intent.getAction().equals(OtaUtils.ACTION_PERFORM_CDMA_PROVISIONING)) {
+
+            // On voice-capable devices, we perform CDMA provisioning in
+            // "interactive" mode by directly launching the InCallScreen.
+
+            // The voice_capable flag currently comes from a resource,
+            // which is overrideable on a per-product basis.
+            // TODO: this resource needs to be used from apps/Contacts
+            // also, so we'll probably move it into the framework at some
+            // point...
+            boolean interactiveMode = getResources().getBoolean(R.bool.voice_capable);
+
+            // TODO: Or, this may eventually become a PackageManager "system
+            // feature", in which case we'd do something like this instead:
+            // boolean interactiveMode =
+            //   getPackageManager().hasSystemFeature(PackageManager.FEATURE_TELEPHONY_VOICE_CALLS);
+
+            Log.d(LOG_TAG, "- interactiveMode = " + interactiveMode);
+
+            // Testing: check the intent extra that allows the caller to
+            // manually enable/disable "interactive mode", regardless of
+            // whether the current device is voice-capable.
+            // STOPSHIP: disable before release.
+            if (intent.hasExtra(OtaUtils.EXTRA_OVERRIDE_INTERACTIVE_MODE)) {
+                interactiveMode =
+                        intent.getBooleanExtra(OtaUtils.EXTRA_OVERRIDE_INTERACTIVE_MODE, false);
+                Log.d(LOG_TAG, "===> MANUALLY OVERRIDING interactiveMode to " + interactiveMode);
+            }
+
+            // We allow the caller to pass a PendingIntent (as the
+            // EXTRA_NONINTERACTIVE_OTASP_RESULT_PENDING_INTENT extra)
+            // which we'll later use to notify them when the OTASP call
+            // fails or succeeds.
+            //
+            // Stash that away here, and we'll fire it off later in
+            // OtaUtils.sendOtaspResult().
+            app.cdmaOtaScreenState.otaspResultCodePendingIntent =
+                        (PendingIntent) intent.getParcelableExtra(
+                                OtaUtils.EXTRA_OTASP_RESULT_CODE_PENDING_INTENT);
+
+            if (interactiveMode) {
+                // On voice-capable devices, immediately bring up the in-call
+                // UI.  (By passing along the ACTION_PERFORM_CDMA_PROVISIONING
+                // intent, this will cause the InCallScreen to launch an OTASP
+                // call.)
+
+                Intent newIntent = new Intent().setClass(this, InCallScreen.class)
+                        .setAction(OtaUtils.ACTION_PERFORM_CDMA_PROVISIONING);
+
+                Log.d(LOG_TAG, "==> Launching in-call UI for CDMA provisioning: " + newIntent);
+                startActivity(newIntent);
+
+                // Note the result we set here is actually irrelevant, since
+                // the InCallScreen's "interactive" OTASP sequence never
+                // actually finish()es; it ends by directly launching the Home
+                // activity.  So our caller won't actually ever get an
+                // onActivityResult() call in this case.
+                setResult(OtaUtils.RESULT_INTERACTIVE_OTASP_STARTED);
+            } else {
+                // On data-only devices, manually launch the OTASP call
+                // *without* displaying any UI.  (Our caller, presumably
+                // SetupWizardActivity, is responsible for displaying some
+                // sort of progress UI.)
 
-            // tuck away the pending intent to send later if the user skips provisioning
-            PhoneApp app = PhoneApp.getInstance();
-            app.cdmaOtaInCallScreenUiState.reportSkipPendingIntent = (PendingIntent) intent
-                    .getParcelableExtra(EXTRA_USER_SKIP_PENDING_INTENT);
+                Log.d(LOG_TAG, "==> Starting non-interactive CDMA provisioning...");
+                int callStatus = OtaUtils.startNonInteractiveOtasp(this);
 
-            startActivity(newIntent);
+                if (callStatus == PhoneUtils.CALL_STATUS_DIALED) {
+                    Log.d(LOG_TAG, "  ==> successful result from startNonInteractiveOtasp(): "
+                          + callStatus);
+                    setResult(OtaUtils.RESULT_NONINTERACTIVE_OTASP_STARTED);
+                } else {
+                    Log.w(LOG_TAG, "Failure code from startNonInteractiveOtasp(): " + callStatus);
+                    setResult(OtaUtils.RESULT_NONINTERACTIVE_OTASP_FAILED);
+                }
+            }
         } else {
-            Log.e(LOG_TAG, "Inappropriate launch of InCallScreenShowActivation");
+            Log.e(LOG_TAG, "Unexpected intent action: " + intent);
+            setResult(RESULT_CANCELED);
         }
 
         finish();
diff --git a/src/com/android/phone/OtaUtils.java b/src/com/android/phone/OtaUtils.java
index 5990f6d5..3e68d3a7 100644
--- a/src/com/android/phone/OtaUtils.java
+++ b/src/com/android/phone/OtaUtils.java
@@ -19,42 +19,29 @@
 import com.android.internal.telephony.Phone;
 import com.android.phone.OtaUtils.CdmaOtaInCallScreenUiState.State;
 
+import android.app.Activity;
 import android.app.AlertDialog;
 import android.app.PendingIntent;
 import android.app.PendingIntent.CanceledException;
-import android.content.ActivityNotFoundException;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.Intent;
-import android.content.pm.ResolveInfo;
 import android.os.AsyncResult;
 import android.os.Handler;
-import android.os.Message;
 import android.os.SystemClock;
-import android.os.SystemProperties;
-import android.provider.Settings;
-
 import android.util.Log;
 import android.view.KeyEvent;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewStub;
 import android.view.WindowManager;
-
 import android.widget.Button;
-import android.widget.ScrollView;
-import android.widget.ToggleButton;
 import android.widget.ProgressBar;
+import android.widget.ScrollView;
 import android.widget.TextView;
+import android.widget.ToggleButton;
 
 /**
- * TODO: This is Over The Air Service Provisioning (OTASP)
- *       A better name would be OtaspUtils.java.
- *
- * TODO: OTASP could UI may be substantially different on
- *       future devices, and may not necessarily be built-in
- *       to the InCallScreen.
- *
  * Handles all OTA Call related logic and UI functionality.
  * The InCallScreen interacts with this class to perform an OTA Call.
  *
@@ -62,6 +49,9 @@
  *   OTA or OTASP == Over The Air service provisioning
  *   SPC == Service Programming Code
  *   TODO: Include pointer to more detailed documentation.
+ *
+ * TODO: This is Over The Air Service Provisioning (OTASP)
+ *       A better name would be OtaspUtils.java.
  */
 public class OtaUtils {
     private static final String LOG_TAG = "OtaUtils";
@@ -80,6 +70,44 @@ public class OtaUtils {
     public final int OTA_SPC_TIMEOUT = 60;
     public final int OTA_FAILURE_DIALOG_TIMEOUT = 2;
 
+    // Constants for OTASP-related Intents and intent extras.
+    // Watch out: these must agree with the corresponding constants in
+    // apps/SetupWizard!
+
+    // Intent action to launch an OTASP call.
+    public static final String ACTION_PERFORM_CDMA_PROVISIONING =
+           "com.android.phone.PERFORM_CDMA_PROVISIONING";
+
+    // Activity result codes for the ACTION_PERFORM_CDMA_PROVISIONING intent
+    // (see the InCallScreenShowActivation activity.)
+    public static final int RESULT_INTERACTIVE_OTASP_STARTED = Activity.RESULT_FIRST_USER;
+    public static final int RESULT_NONINTERACTIVE_OTASP_STARTED = Activity.RESULT_FIRST_USER + 1;
+    public static final int RESULT_NONINTERACTIVE_OTASP_FAILED = Activity.RESULT_FIRST_USER + 2;
+
+    // Testing: Extra for the ACTION_PERFORM_CDMA_PROVISIONING intent that
+    // allows the caller to manually enable/disable "interactive mode" for
+    // the OTASP call.
+    public static final String EXTRA_OVERRIDE_INTERACTIVE_MODE =
+            "ota_override_interactive_mode";
+
+    // Extra for the ACTION_PERFORM_CDMA_PROVISIONING intent, holding a
+    // PendingIntent which the phone app can use to send a result code
+    // back to the caller.
+    public static final String EXTRA_OTASP_RESULT_CODE_PENDING_INTENT =
+            "otasp_result_code_pending_intent";
+
+    // Extra attached to the above PendingIntent that indicates
+    // success or failure.
+    public static final String EXTRA_OTASP_RESULT_CODE =
+            "otasp_result_code";
+    public static final int OTASP_UNKNOWN = 0;
+    public static final int OTASP_USER_SKIPPED = 1;  // Only meaningful with interactive OTASP
+    public static final int OTASP_SUCCESS = 2;
+    public static final int OTASP_FAILURE = 3;
+
+    private static final String OTASP_NUMBER = "*228";
+    private static final String OTASP_NUMBER_NON_INTERACTIVE = "*22899";
+
     private InCallScreen mInCallScreen;
     private Context mContext;
     private PhoneApp mApplication;
@@ -100,6 +128,14 @@ public class OtaUtils {
 
     private static boolean mIsWizardMode = true;
 
+    // In "interactive mode", the OtaUtils object is tied to an
+    // InCallScreen instance, where we display a bunch of UI specific to
+    // the OTASP call.  But on devices that are not "voice capable", the
+    // OTASP call runs in a non-interactive mode, and we don't have
+    // an InCallScreen or CallCard or any OTASP UI elements at all.
+    private boolean mInteractive = true;
+
+
     /**
      * OtaWidgetData class represent all OTA UI elements
      */
@@ -142,11 +178,16 @@ public OtaUtils(Context context,
         mApplication = PhoneApp.getInstance();
         mOtaWidgetData = new OtaWidgetData();
 
-        // inflate OTA Call card and footers
-        ViewStub otaCallCardStub = (ViewStub) mInCallScreen.findViewById(R.id.otaCallCardStub);
-        otaCallCardStub.inflate();
-        readXmlSettings();
-        initOtaInCallScreen();
+        // If no InCallScreen was passed in, assume non-interactive mode.
+        mInteractive = (mInCallScreen != null);
+
+        if (mInteractive) {
+            // inflate OTA Call card and footers
+            ViewStub otaCallCardStub = (ViewStub) mInCallScreen.findViewById(R.id.otaCallCardStub);
+            otaCallCardStub.inflate();
+            readXmlSettings();
+            initOtaInCallScreen();
+        }
     }
 
     /**
@@ -164,7 +205,7 @@ public static boolean maybeDoOtaCall(Context context, Handler handler, int reque
         Phone phone = app.phone;
 
         if (!isCdmaPhone()) {
-            if (DBG) Log.v("OtaUtils", "Can't run provisioning on a non-CDMA phone");
+            if (DBG) log("Can't run provisioning on a non-CDMA phone");
             return true; // sanity check - a non-cdma phone doesn't need to run this
         }
 
@@ -183,22 +224,119 @@ public static boolean maybeDoOtaCall(Context context, Handler handler, int reque
 
         if (DBG) log("otaShowActivationScreen: " + otaShowActivationScreen);
 
-        if (phoneNeedsActivation && (otaShowActivationScreen == OTA_SHOW_ACTIVATION_SCREEN_ON)) {
-            app.cdmaOtaProvisionData.isOtaCallIntentProcessed = false;
-            Intent newIntent = new Intent(InCallScreen.ACTION_SHOW_ACTIVATION);
-            newIntent.setClass(context, InCallScreen.class);
-            newIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
-            mIsWizardMode = false;
-            context.startActivity(newIntent);
-            if (DBG) log("activation intent sent.");
+        // Run the OTASP call in "interactive" mode only if
+        // this is a "voice capable" device.
+        // TODO: this resource needs to be used from apps/Contacts also,
+        // so we'll probably move it into the framework at some point...
+        boolean voiceCapable = context.getResources().getBoolean(R.bool.voice_capable);
+
+        if (voiceCapable) {
+            if (phoneNeedsActivation
+                    && (otaShowActivationScreen == OTA_SHOW_ACTIVATION_SCREEN_ON)) {
+                app.cdmaOtaProvisionData.isOtaCallIntentProcessed = false;
+                Intent newIntent = new Intent(ACTION_PERFORM_CDMA_PROVISIONING);
+                newIntent.setClass(context, InCallScreen.class);
+                newIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                mIsWizardMode = false;
+                context.startActivity(newIntent);
+                if (DBG) log("maybeDoOtaCall: voice capable; activation intent sent.");
+            } else {
+                if (DBG) log("maybeDoOtaCall: voice capable; activation intent NOT sent.");
+            }
         } else {
-            if (DBG) log("activation intent NOT sent.");
+            if (phoneNeedsActivation) {
+                if (DBG) log("maybeDoOtaCall: non-interactive; need to start OTASP call...");
+
+                // TODO: Do nothing for now, since phone.needsOtaServiceProvisioning()
+                // is unreliable on Stingray right now.
+
+                // But eventually we'll need to fire off a non-interactive
+                // OTASP call (see startNonInteractiveOtasp()) *and* jump
+                // to some activity in the SetupWizard to show a progress
+                // UI to the user.
+
+            } else {
+                if (DBG) log("maybeDoOtaCall: non-interactive, no need for OTASP.");
+            }
         }
         return true;
     }
 
+    /**
+     * Starts the OTASP call *without* involving the InCallScreen or
+     * displaying any UI.
+     *
+     * This is used on data-only devices, which don't support any kind of
+     * in-call phone UI.
+     *
+     * @return PhoneUtils.CALL_STATUS_DIALED if we successfully
+     *         dialed the OTASP number, or one of the other
+     *         CALL_STATUS_* constants if there was a failure.
+     */
+    public static int startNonInteractiveOtasp(Context context) {
+        if (DBG) log("startNonInteractiveOtasp()...");
+        PhoneApp app = PhoneApp.getInstance();
+
+        if (app.otaUtils != null) {
+            // An OtaUtils instance already exists.
+            // TODO: Is this actually an error condition?
+            Log.w(LOG_TAG, "startNonInteractiveOtasp: "
+                  + "OtaUtils already exists; nuking the old one and starting again...");
+        }
+
+        // Create the OtaUtils instance, and indicate we're in
+        // "non-interactive mode" by passing in null for
+        // inCallScreen / callCard / dialer / etc.
+        app.otaUtils = new OtaUtils(context,
+                                    null, null, null, null);
+        if (DBG) log("- created OtaUtils: " + app.otaUtils);
+
+        // ... and kick off the OTASP call.
+        Phone phone = PhoneApp.getPhone();
+        String number = OTASP_NUMBER_NON_INTERACTIVE;
+        if (DBG) log("- placing call to '" + number + "'...");
+        int callStatus = PhoneUtils.placeCall(context,
+                                              phone,
+                                              number,
+                                              null,  // contactRef
+                                              false,  //isEmergencyCall
+                                              null);  // gatewayUri
+
+        if (callStatus == PhoneUtils.CALL_STATUS_DIALED) {
+            if (DBG) log("  ==> successful return from placeCall(): callStatus = " + callStatus);
+        } else {
+            Log.w(LOG_TAG, "Failure from placeCall() for OTA number '"
+                  + number + "': code " + callStatus);
+            return callStatus;
+        }
+
+        // TODO: temp hack while testing; this makes the OTA call easier to
+        //       hear on Sholes, and has no effect on Stingray.
+        // STOPSHIP: remove before release
+        PhoneUtils.turnOnSpeaker(context, true, true);
+
+        // TODO: Any other special work to do here?
+        // Such as:
+        //
+        // - manually kick off progress updates, either using TelephonyRegistry
+        //   or else by sending PendingIntents directly to our caller?
+        //
+        // - manually silence the in-call audio?  (Probably unnecessary
+        //   if Stingray truly has no audio path from phone baseband
+        //   to the device's speakers.)
+        //
+
+        return callStatus;
+    }
+
     private void setSpeaker(boolean state) {
         if (DBG) log("setSpeaker : " + state );
+
+        if (!mInteractive) {
+            if (DBG) log("non-interactive mode, ignoring setSpeaker.");
+            return;
+        }
+
         if (state == PhoneUtils.isSpeakerOn(mContext)) {
             if (DBG) log("no change. returning");
             return;
@@ -219,21 +357,28 @@ private void setSpeaker(boolean state) {
      */
     public void onOtaProvisionStatusChanged(AsyncResult r) {
         int OtaStatus[] = (int[]) r.result;
-        if (DBG) log("onOtaProvisionStatusChanged(): OtaStatus[0]" + OtaStatus[0]);
+        if (DBG) log("Provision status event!");
+        if (DBG) log("onOtaProvisionStatusChanged(): status = "
+                     + OtaStatus[0] + " ==> " + otaProvisionStatusToString(OtaStatus[0]));
+
+        // In practice, in a normal successful OTASP call, events come in as follows:
+        //   - SPL_UNLOCKED within a couple of seconds after the call starts
+        //   - then a delay of around 45 seconds
+        //   - then PRL_DOWNLOADED and MDN_DOWNLOADED and COMMITTED within a span of 2 seconds
 
         switch(OtaStatus[0]) {
             case Phone.CDMA_OTA_PROVISION_STATUS_SPC_RETRIES_EXCEEDED:
-                otaShowInProgressScreen();
+                if (DBG) log("onOtaProvisionStatusChanged(): RETRIES EXCEEDED");
+                updateOtaspProgress();
                 mApplication.cdmaOtaProvisionData.otaSpcUptime = SystemClock.elapsedRealtime();
                 otaShowSpcErrorNotice(OTA_SPC_TIMEOUT);
-                if (DBG) log("onOtaProvisionStatusChanged(): RETRIES EXCEEDED");
                 // Power.shutdown();
                 break;
 
             case Phone.CDMA_OTA_PROVISION_STATUS_COMMITTED:
-                otaShowInProgressScreen();
-                mApplication.cdmaOtaProvisionData.isOtaCallCommitted = true;
                 if (DBG) log("onOtaProvisionStatusChanged(): DONE, isOtaCallCommitted set to true");
+                updateOtaspProgress();
+                mApplication.cdmaOtaProvisionData.isOtaCallCommitted = true;
                 break;
 
             case Phone.CDMA_OTA_PROVISION_STATUS_SPL_UNLOCKED:
@@ -247,7 +392,7 @@ public void onOtaProvisionStatusChanged(AsyncResult r) {
             case Phone.CDMA_OTA_PROVISION_STATUS_OTAPA_STOPPED:
             case Phone.CDMA_OTA_PROVISION_STATUS_OTAPA_ABORTED:
                 if (DBG) log("onOtaProvisionStatusChanged(): change to ProgressScreen");
-                otaShowInProgressScreen();
+                updateOtaspProgress();
                 break;
 
             default:
@@ -256,6 +401,20 @@ public void onOtaProvisionStatusChanged(AsyncResult r) {
         }
     }
 
+    /**
+     * Handle a disconnect event from the OTASP call.
+     */
+    public void onOtaspDisconnect() {
+        if (DBG) log("onOtaspDisconnect()...");
+        // We only handle this event explicitly in non-interactive mode.
+        // (In interactive mode, the InCallScreen does any post-disconnect
+        // cleanup.)
+        if (!mInteractive) {
+            // Send a success or failure indication back to our caller.
+            updateNonInteractiveOtaSuccessFailure();
+        }
+    }
+
     private void otaShowHome() {
         if (DBG) log("OtaShowHome()...");
         mApplication.cdmaOtaScreenState.otaScreenState =
@@ -271,25 +430,27 @@ private void otaShowHome() {
     private void otaSkipActivation() {
         if (DBG) log("otaSkipActivation()...");
 
-        PhoneApp app = PhoneApp.getInstance();
-        if (app != null && app.cdmaOtaInCallScreenUiState.reportSkipPendingIntent != null) {
-            try {
-                app.cdmaOtaInCallScreenUiState.reportSkipPendingIntent.send();
-            } catch (CanceledException e) {
-                // should never happen because no code cancels the pending intent right now,
-                // but if it does, the user will simply be returned to the initial setup screen
-            }
-        }
+        sendOtaspResult(OTASP_USER_SKIPPED);
 
-        mInCallScreen.finish();
+        if (mInteractive) mInCallScreen.finish();
         return;
     }
 
+    /**
+     * Actually initiate the OTASP call.  This method is triggered by the
+     * onscreen "Activate" button, and is only used in interactive mode.
+     */
     private void otaPerformActivation() {
         if (DBG) log("otaPerformActivation()...");
+        if (!mInteractive) {
+            // We shouldn't ever get here in non-interactive mode!
+            Log.w(LOG_TAG, "otaPerformActivation: not interactive!");
+            return;
+        }
+
         if (!mApplication.cdmaOtaProvisionData.inOtaSpcState) {
             Intent newIntent = new Intent(Intent.ACTION_CALL);
-            newIntent.putExtra(Intent.EXTRA_PHONE_NUMBER, InCallScreen.OTA_NUMBER);
+            newIntent.putExtra(Intent.EXTRA_PHONE_NUMBER, OTASP_NUMBER);
             mInCallScreen.internalResolveIntent(newIntent);
             otaShowListeningScreen();
         }
@@ -330,7 +491,13 @@ public void otaShowActivateScreen() {
      * appropriate DTMF digits to proceed to the "Programming in Progress" phase.
      */
     private void otaShowListeningScreen() {
-        if (DBG) log("OtaShowListeningScreen()...");
+        if (DBG) log("otaShowListeningScreen()...");
+        if (!mInteractive) {
+            // We shouldn't ever get here in non-interactive mode!
+            Log.w(LOG_TAG, "otaShowListeningScreen: not interactive!");
+            return;
+        }
+
         if (mApplication.cdmaOtaConfigData.otaShowListeningScreen
                 == OTA_SHOW_LISTENING_SCREEN_ON) {
             if (DBG) log("OtaShowListeningScreen(): show listening screen");
@@ -357,12 +524,114 @@ private void otaShowListeningScreen() {
         }
     }
 
+    /**
+     * Do any necessary updates (of onscreen UI, for example)
+     * based on the latest status of the OTASP call.
+     */
+    private void updateOtaspProgress() {
+        if (DBG) log("updateOtaspProgress()...  mInteractive = " + mInteractive);
+        if (mInteractive) {
+            // On regular phones we just call through to
+            // otaShowInProgressScreen(), which updates the
+            // InCallScreen's onscreen UI.
+            otaShowInProgressScreen();
+        } else {
+            // We're not using the InCallScreen to show OTA progress.
+
+            // For now, at least, there's nothing to do here.
+            // The overall "success" or "failure" indication we send back
+            // (to our caller) is triggered by the DISCONNECT event;
+            // see updateNonInteractiveOtaSuccessFailure().
+
+            // But if we ever need to send *intermediate* progress updates back
+            // to our caller, we'd do that here, possbily using the same
+            // PendingIntent that we already use to indicate success or failure.
+        }
+    }
+
+    /**
+     * When a non-interactive OTASP call completes, send a success or
+     * failure indication back to our caller.
+     *
+     * This is basically the non-interactive equivalent of
+     * otaShowSuccessFailure().
+     */
+    private void updateNonInteractiveOtaSuccessFailure() {
+        // This is basically the same logic as otaShowSuccessFailure(): we
+        // check the isOtaCallCommitted bit, and if that's true it means
+        // that activation was successful.
+
+        if (DBG) log("updateNonInteractiveOtaSuccessFailure(): isOtaCallCommitted = "
+                     + mApplication.cdmaOtaProvisionData.isOtaCallCommitted);
+        int resultCode =
+                mApplication.cdmaOtaProvisionData.isOtaCallCommitted
+                ? OTASP_SUCCESS : OTASP_FAILURE;
+        sendOtaspResult(resultCode);
+    }
+
+    /**
+     * Sends the specified OTASP result code back to our caller (presumably
+     * SetupWizard) via the PendingIntent that they originally sent along with
+     * the ACTION_PERFORM_CDMA_PROVISIONING intent.
+     */
+    private void sendOtaspResult(int resultCode) {
+        if (DBG) log("sendOtaspResult: resultCode = " + resultCode);
+
+        // Pass the success or failure indication back to our caller by
+        // adding an additional extra to the PendingIntent we already
+        // have.
+        // (NB: there's a PendingIntent send() method that takes a resultCode
+        // directly, but we can't use that here since that call is only
+        // meaningful for pending intents that are actually used as activity
+        // results.)
+
+        Intent extraStuff = new Intent();
+        extraStuff.putExtra(EXTRA_OTASP_RESULT_CODE, resultCode);
+        // When we call PendingIntent.send() below, the extras from this
+        // intent will get merged with any extras already present in
+        // cdmaOtaScreenState.otaspResultCodePendingIntent.
+
+        if (mApplication.cdmaOtaScreenState == null) {
+            Log.e(LOG_TAG, "updateNonInteractiveOtaSuccessFailure: no cdmaOtaScreenState object!");
+            return;
+        }
+        if (mApplication.cdmaOtaScreenState.otaspResultCodePendingIntent == null) {
+            Log.w(LOG_TAG, "updateNonInteractiveOtaSuccessFailure: "
+                  + "null otaspResultCodePendingIntent!");
+            // This *should* never happen, since SetupWizard always passes this
+            // PendingIntent along with the ACTION_PERFORM_CDMA_PROVISIONING
+            // intent.
+            // (But if this happens it's not a fatal error, it just means that
+            // our original caller has no way of finding out whether the OTASP
+            // call ultimately failed or succeeded...)
+            return;
+        }
+
+        try {
+            if (DBG) log("- sendOtaspResult:  SENDING PENDING INTENT: " +
+                         mApplication.cdmaOtaScreenState.otaspResultCodePendingIntent);
+            mApplication.cdmaOtaScreenState.otaspResultCodePendingIntent.send(
+                    mContext,
+                    0, /* resultCode (unused) */
+                    extraStuff);
+        } catch (CanceledException e) {
+            // should never happen because no code cancels the pending intent right now,
+            Log.e(LOG_TAG, "PendingIntent send() failed: " + e);
+        }
+    }
+
     /**
      * Show "Programming In Progress" screen during OTA call. Shown when OTA
      * provisioning is in progress after user has selected an option.
      */
     private void otaShowInProgressScreen() {
-        if (DBG) log("OtaShowInProgressScreen()...");
+        if (DBG) log("otaShowInProgressScreen()...");
+        if (!mInteractive) {
+            // We shouldn't ever get here in non-interactive mode!
+            Log.w(LOG_TAG, "otaShowInProgressScreen: not interactive!");
+            return;
+        }
+
         if (!isDialerOpened()) {
             otaScreenInitialize();
             mOtaWidgetData.otaTextListenProgressContainer.setVisibility(View.VISIBLE);
@@ -411,7 +680,13 @@ private void otaShowProgramFailure(int length) {
      * for more details.
      */
     public void otaShowSuccessFailure() {
-        if (DBG) log("OtaShowSuccessFailure()...");
+        if (DBG) log("otaShowSuccessFailure()...");
+        if (!mInteractive) {
+            // We shouldn't ever get here in non-interactive mode!
+            Log.w(LOG_TAG, "otaShowSuccessFailure: not interactive!");
+            return;
+        }
+
         otaScreenInitialize();
         if (DBG) log("OtaShowSuccessFailure(): isOtaCallCommitted"
                 + mApplication.cdmaOtaProvisionData.isOtaCallCommitted);
@@ -546,7 +821,14 @@ public void onOtaCloseFailureNotice() {
      * gets drawn.
      */
     private void otaScreenInitialize() {
-        if (DBG) log("OtaScreenInitialize()...");
+        if (DBG) log("otaScreenInitialize()...");
+
+        if (!mInteractive) {
+            // We should never be doing anything with UI elements in
+            // non-interactive mode.
+            Log.w(LOG_TAG, "otaScreenInitialize: not interactive!");
+            return;
+        }
 
         if (mInCallPanel != null) mInCallPanel.setVisibility(View.GONE);
         if (mCallCard != null) mCallCard.hideCallCardElements();
@@ -583,10 +865,18 @@ public boolean isDialerOpened() {
 
     /**
      * Show the appropriate OTA screen based on the current state of OTA call.
-     * Shown whenever calling screen is resumed.
+     *
+     * This is called from the InCallScreen when the screen needs to be
+     * refreshed (and thus is only ever used in interactive mode.)
      */
     public void otaShowProperScreen() {
         if (DBG) log("otaShowProperScreen()...");
+        if (!mInteractive) {
+            // We shouldn't ever get here in non-interactive mode!
+            Log.w(LOG_TAG, "otaShowProperScreen: not interactive!");
+            return;
+        }
+
         if (mInCallScreen.isForegroundActivity()) {
             if (DBG) log("otaShowProperScreen(), OTA is foreground activity, currentstate ="
                     + mApplication.cdmaOtaScreenState.otaScreenState);
@@ -871,27 +1161,29 @@ public void cleanOtaScreen(boolean disableSpeaker) {
         mApplication.cdmaOtaProvisionData.otaSpcUptime = 0;
         mApplication.cdmaOtaInCallScreenUiState.state = State.UNDEFINED;
 
-        if (mInCallPanel != null) mInCallPanel.setVisibility(View.VISIBLE);
-        if (mCallCard != null) mCallCard.hideCallCardElements();
-        mDialer.setHandleVisible(true);
+        if (mInteractive) {
+            if (mInCallPanel != null) mInCallPanel.setVisibility(View.VISIBLE);
+            if (mCallCard != null) mCallCard.hideCallCardElements();
+            mDialer.setHandleVisible(true);
 
-        // Free resources from the DTMFTwelveKeyDialer instance we created
-        // in initOtaInCallScreen().
-        if (mOtaCallCardDtmfDialer != null) {
-            mOtaCallCardDtmfDialer.stopDialerSession();
-        }
+            // Free resources from the DTMFTwelveKeyDialer instance we created
+            // in initOtaInCallScreen().
+            if (mOtaCallCardDtmfDialer != null) {
+                mOtaCallCardDtmfDialer.stopDialerSession();
+            }
 
-        mOtaWidgetData.otaTextActivate.setVisibility(View.GONE);
-        mOtaWidgetData.otaTextListenProgressContainer.setVisibility(View.GONE);
-        mOtaWidgetData.otaTextProgressBar.setVisibility(View.GONE);
-        mOtaWidgetData.otaTextSuccessFail.setVisibility(View.GONE);
-        mOtaWidgetData.callCardOtaButtonsActivate.setVisibility(View.GONE);
-        mOtaWidgetData.callCardOtaButtonsListenProgress.setVisibility(View.GONE);
-        mOtaWidgetData.callCardOtaButtonsFailSuccess.setVisibility(View.GONE);
-        mOtaWidgetData.otaCallCardBase.setVisibility(View.GONE);
-        mOtaWidgetData.otaDtmfDialerView.setVisibility(View.GONE);
-        mOtaWidgetData.otaNextButton.setVisibility(View.GONE);
-        mOtaWidgetData.otaTryAgainButton.setVisibility(View.GONE);
+            mOtaWidgetData.otaTextActivate.setVisibility(View.GONE);
+            mOtaWidgetData.otaTextListenProgressContainer.setVisibility(View.GONE);
+            mOtaWidgetData.otaTextProgressBar.setVisibility(View.GONE);
+            mOtaWidgetData.otaTextSuccessFail.setVisibility(View.GONE);
+            mOtaWidgetData.callCardOtaButtonsActivate.setVisibility(View.GONE);
+            mOtaWidgetData.callCardOtaButtonsListenProgress.setVisibility(View.GONE);
+            mOtaWidgetData.callCardOtaButtonsFailSuccess.setVisibility(View.GONE);
+            mOtaWidgetData.otaCallCardBase.setVisibility(View.GONE);
+            mOtaWidgetData.otaDtmfDialerView.setVisibility(View.GONE);
+            mOtaWidgetData.otaNextButton.setVisibility(View.GONE);
+            mOtaWidgetData.otaTryAgainButton.setVisibility(View.GONE);
+        }
 
         // turn off the speaker in case it was turned on
         // but the OTA call could not be completed
@@ -947,9 +1239,6 @@ public CdmaOtaInCallScreenUiState() {
             if (DBG) log("CdmaOtaInCallScreenState: constructor init to UNDEFINED");
             state = CdmaOtaInCallScreenUiState.State.UNDEFINED;
         }
-
-        // the pending intent used to report when the user skips ota provisioning
-        public PendingIntent reportSkipPendingIntent;
     }
 
     /**
@@ -964,7 +1253,8 @@ public void setCdmaOtaInCallScreenUiState(CdmaOtaInCallScreenUiState.State state
      * Get the Ota InCallScreen UI state
      */
     public CdmaOtaInCallScreenUiState.State getCdmaOtaInCallScreenUiState() {
-        if (DBG) log("getCdmaOtaInCallScreenState: " + mApplication.cdmaOtaInCallScreenUiState.state);
+        if (DBG) log("getCdmaOtaInCallScreenState: "
+                     + mApplication.cdmaOtaInCallScreenUiState.state);
         return mApplication.cdmaOtaInCallScreenUiState.state;
     }
 
@@ -985,6 +1275,50 @@ public enum OtaScreenState {
         public CdmaOtaScreenState() {
             otaScreenState = OtaScreenState.OTA_STATUS_UNDEFINED;
         }
+
+        // PendingIntent used to report an OTASP result status code back
+        // to our caller.
+        //
+        // Our caller (presumably SetupWizard) creates this PendingIntent,
+        // pointing back at itself, and passes it along as an extra with the
+        // ACTION_PERFORM_CDMA_PROVISIONING intent.  Then, when there's an
+        // OTASP result to report, we send that PendingIntent back, adding an
+        // extra called EXTRA_OTASP_RESULT_CODE to indicate the result.
+        //
+        // Possible result values are the OTASP_RESULT_* constants.
+        public PendingIntent otaspResultCodePendingIntent;
+    }
+
+    /** @see com.android.internal.telephony.Phone */
+    private static String otaProvisionStatusToString(int status) {
+        switch (status) {
+            case Phone.CDMA_OTA_PROVISION_STATUS_SPL_UNLOCKED:
+                return "SPL_UNLOCKED";
+            case Phone.CDMA_OTA_PROVISION_STATUS_SPC_RETRIES_EXCEEDED:
+                return "SPC_RETRIES_EXCEEDED";
+            case Phone.CDMA_OTA_PROVISION_STATUS_A_KEY_EXCHANGED:
+                return "A_KEY_EXCHANGED";
+            case Phone.CDMA_OTA_PROVISION_STATUS_SSD_UPDATED:
+                return "SSD_UPDATED";
+            case Phone.CDMA_OTA_PROVISION_STATUS_NAM_DOWNLOADED:
+                return "NAM_DOWNLOADED";
+            case Phone.CDMA_OTA_PROVISION_STATUS_MDN_DOWNLOADED:
+                return "MDN_DOWNLOADED";
+            case Phone.CDMA_OTA_PROVISION_STATUS_IMSI_DOWNLOADED:
+                return "IMSI_DOWNLOADED";
+            case Phone.CDMA_OTA_PROVISION_STATUS_PRL_DOWNLOADED:
+                return "PRL_DOWNLOADED";
+            case Phone.CDMA_OTA_PROVISION_STATUS_COMMITTED:
+                return "COMMITTED";
+            case Phone.CDMA_OTA_PROVISION_STATUS_OTAPA_STARTED:
+                return "OTAPA_STARTED";
+            case Phone.CDMA_OTA_PROVISION_STATUS_OTAPA_STOPPED:
+                return "OTAPA_STOPPED";
+            case Phone.CDMA_OTA_PROVISION_STATUS_OTAPA_ABORTED:
+                return "OTAPA_ABORTED";
+            default:
+                return "<unknown status" + status + ">";
+        }
     }
 
     private static void log(String msg) {
diff --git a/src/com/android/phone/OtaspTestActivity.java b/src/com/android/phone/OtaspTestActivity.java
new file mode 100644
index 00000000..aed65884
--- /dev/null
+++ b/src/com/android/phone/OtaspTestActivity.java
@@ -0,0 +1,269 @@
+/*
+ * 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.phone;
+
+import android.app.Activity;
+import android.app.PendingIntent;
+import android.content.ActivityNotFoundException;
+import android.content.Intent;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.View;
+import android.widget.Button;
+import android.widget.ProgressBar;
+import android.widget.TextView;
+
+/**
+ * Test activity that mimics the PERFORM_CDMA_PROVISIONING behavior of
+ * SetupWizard, useful for testing "non-interactive" OTASP.
+ * @see OtaUtils.startNonInteractiveOtasp
+ *
+ * STOPSHIP: During initial Stingray OTASP testing, this is exposed as a
+ * public activity.  It should ultimately move into the "tests"
+ * subdirectory, though.
+ *
+ */
+public class OtaspTestActivity extends Activity implements View.OnClickListener {
+    private static final String LOG_TAG = "OtaspTestActivity";
+
+    // Request code used with startActivityForResult()
+    private static final int PERFORM_CDMA_PROVISIONING_REQUEST_CODE = 1;
+
+    // UI elements
+    private TextView mLabel;
+    private ProgressBar mProgressBar;
+    private TextView mResult;
+    private Button mButton;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        Intent intent = getIntent();
+        Log.i(LOG_TAG, "##### onCreate: intent = " + intent);
+        Bundle extras = intent.getExtras();
+        if (extras != null) {
+            Log.i(LOG_TAG, "      - has extras: size = " + extras.size()); // forces an unparcel()
+            Log.i(LOG_TAG, "      - extras = " + extras);
+        }
+
+        // Construct our basic UI:
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.ota_test_activity);
+
+        mLabel = (TextView) findViewById(R.id.label1);
+        mLabel.setText("OTA Test Activity");
+
+        mProgressBar = (ProgressBar) findViewById(R.id.progress_bar);
+        mResult = (TextView) findViewById(R.id.result1);
+
+        mButton = (Button) findViewById(R.id.button1);
+        mButton.setText("Make test call");
+        mButton.setOnClickListener(this);
+
+
+        // We can be launched either:
+        //
+        // (1) Directly from the launcher, in which case the current intent
+        //     will simply be an ACTION_MAIN intent
+        //
+        // (2) Via the PendingIntent that we sent along (when we originally
+        //     fired off the ACTION_PERFORM_CDMA_PROVISIONING intent) that
+        //     allows the phone app to send us back a result code.
+        //     We can identify this case by the presence of the
+        //     EXTRA_OTASP_RESULT_CODE extra.
+
+        if (intent.hasExtra(OtaUtils.EXTRA_OTASP_RESULT_CODE)) {
+            // Got a result from the OTASP call!
+            Log.i(LOG_TAG, "==> onCreate: got a result from the OTASP call!");
+
+            int resultCode = intent.getIntExtra(OtaUtils.EXTRA_OTASP_RESULT_CODE,
+                                                OtaUtils.OTASP_UNKNOWN);
+            Log.i(LOG_TAG, "    - resultCode = " + resultCode);
+
+            String resultString;
+            switch (resultCode) {
+                case OtaUtils.OTASP_USER_SKIPPED:
+                    resultString = "User skipped!";
+                    break;
+                case OtaUtils.OTASP_SUCCESS:
+                    resultString = "Success!";
+                    break;
+                case OtaUtils.OTASP_FAILURE:
+                    resultString = "FAILURE";
+                    break;
+                default:
+                    resultString = "Unexpected code: " + resultCode;
+                    break;
+            }
+            Log.i(LOG_TAG, "    - result: " + resultString);
+            mResult.setText(resultString);
+            mResult.setVisibility(View.VISIBLE);
+            mProgressBar.setVisibility(View.INVISIBLE);
+
+        } else {
+            // We must have gotten here directly from the launcher.
+            // Leave the UI in its initial state.
+            Log.i(LOG_TAG, "==> onCreate: entered from the launcher.");
+        }
+    }
+
+    @Override
+    protected void onNewIntent(Intent intent) {
+        Log.i(LOG_TAG, "onNewIntent: intent=" + intent);
+        Bundle extras = intent.getExtras();
+        if (extras != null) Log.i(LOG_TAG, "      - intent extras = " + extras);
+
+        // This method isn't actually used since this test activity is not
+        // launched in "singleTop" mode.
+
+        // Activities that *are* launched in singleTop mode, like the SetupWizard,
+        // would have to handle the various PendingIntents here just like
+        // we do above in onCreate().
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        Log.i(LOG_TAG, "onActivityResult: request " + requestCode
+              + " result " + resultCode + " data " + data);
+
+        // Note we receive this call immediately before onResume(), when
+        // we get re-started after launching the PERFORM_CDMA_PROVISIONING
+        // intent.
+
+        if (requestCode == PERFORM_CDMA_PROVISIONING_REQUEST_CODE) {
+            // The InCallScreenShowActivation activity can set the following
+            // result codes:
+            //
+            //   RESULT_INTERACTIVE_OTASP_STARTED
+            //   RESULT_NONINTERACTIVE_OTASP_STARTED
+            //   RESULT_NONINTERACTIVE_OTASP_FAILED
+            //
+            // but note that in practice we won't ever *get* the
+            // RESULT_INTERACTIVE_OTASP_STARTED result code, since the
+            // "interactive" OTASP sequence never actually finish()es;
+            // it ends by directly launching the Home activity.
+            //
+            // However, in non-interactive OTASP, the
+            // InCallScreenShowActivation activity will set one of the
+            // RESULT_NONINTERACTIVE_* codes and immediately
+            // finish(), so we *will* see that result here.
+            //
+            // Also, resultCode will be RESULT_CANCELED (= 0) if the
+            // InCallScreenShowActivation activity didn't return any
+            // result, or crashed.
+
+            switch (resultCode) {
+                case OtaUtils.RESULT_INTERACTIVE_OTASP_STARTED:
+                    Log.i(LOG_TAG, "==> onActivityResult: INTERACTIVE_OTASP_STARTED");
+                    break;
+                case OtaUtils.RESULT_NONINTERACTIVE_OTASP_STARTED:
+                    Log.i(LOG_TAG, "==> onActivityResult: NONINTERACTIVE_OTASP_STARTED");
+                    break;
+                case OtaUtils.RESULT_NONINTERACTIVE_OTASP_FAILED:
+                    Log.w(LOG_TAG, "==> onActivityResult: NONINTERACTIVE_OTASP_FAILED");
+                    // This means we couldn't even *initiate* an outgoing call
+                    // to start the OTASP process.  Not sure what could cause this.
+                    // TODO: Update UI to indicate the error.
+                    break;
+                case RESULT_CANCELED:
+                    Log.i(LOG_TAG, "==> onActivityResult: CANCELED");
+                    break;
+                default:
+                    Log.i(LOG_TAG, "==> onActivityResult: unknown result: " + resultCode);
+                    break;
+            }
+        }
+    }
+
+    @Override
+    protected void onResume() {
+        Log.i(LOG_TAG, "onResume()...");
+        super.onResume();
+    }
+
+    @Override
+    protected void onPause() {
+        Log.i(LOG_TAG, "onPause()...");
+        super.onPause();
+    }
+
+    // View.OnClickListener implementation
+    @Override
+    public void onClick(View view) {
+        int id = view.getId();
+        Log.i(LOG_TAG, "onClick(View " + view + ", id " + id + ")...");
+
+        switch (id) {
+            case R.id.button1:
+                Log.i(LOG_TAG, "onClick: button1...");
+                makeTestCall();
+                break;
+            default:
+                Log.w(LOG_TAG, "onClick: unexpected View: " + view);
+                break;
+        }
+    }
+
+    private void makeTestCall() {
+        Log.i(LOG_TAG, "##### makeTestCall()...");
+
+        mProgressBar.setVisibility(View.VISIBLE);
+        mResult.setVisibility(View.INVISIBLE);
+
+        try {
+            Intent performProvisioningIntent =
+                    new Intent(OtaUtils.ACTION_PERFORM_CDMA_PROVISIONING);
+
+            // Set the magic extra to force "non-interactive mode" for the
+            // OTASP call.
+            performProvisioningIntent.putExtra(OtaUtils.EXTRA_OVERRIDE_INTERACTIVE_MODE, false);
+
+            // Pass a PendingIntent along with the
+            // ACTION_PERFORM_CDMA_PROVISIONING intent, which allows
+            // results to be sent back to us.
+            Intent resultIntent = new Intent(this, this.getClass());
+            PendingIntent pendingResultIntent =
+                    PendingIntent.getActivity(this, 0,
+                                              resultIntent, 0);
+            performProvisioningIntent.putExtra(OtaUtils.EXTRA_OTASP_RESULT_CODE_PENDING_INTENT,
+                                               pendingResultIntent);
+
+            Log.i(LOG_TAG, "- Firing off PERFORM_CDMA_PROVISIONING intent: "
+                  + performProvisioningIntent);
+            Bundle extras = performProvisioningIntent.getExtras();
+            if (extras != null) Log.i(LOG_TAG, "      - intent extras = " + extras);
+
+            // Originally, we would simply call
+            //     startActivity(performProvisioningIntent);
+            // to launch the InCallScreenShowActivation activity and *not* expect
+            // a result.  (Note that calling the plain startActivity()
+            // method *guarantees* that your onActivityResult() method
+            // will NOT be called at all.)
+
+            // Now, we ask for a result:
+            startActivityForResult(performProvisioningIntent,
+                                   PERFORM_CDMA_PROVISIONING_REQUEST_CODE);
+
+            // On a non-voice-capable device, the InCallScreenShowActivation activity
+            // will kick off the OTASP call and immediately return, passing
+            // the code RESULT_STARTED_NONINTERACTIVE_OTASP to our
+            // onActivityResult method.
+
+        } catch (ActivityNotFoundException e) {
+            Log.w(LOG_TAG, "Couldn't show activiation UI; ActivityNotFoundException: " + e);
+        }
+    }
+}
diff --git a/src/com/android/phone/PhoneApp.java b/src/com/android/phone/PhoneApp.java
index 1f0a92a3..c49785fc 100644
--- a/src/com/android/phone/PhoneApp.java
+++ b/src/com/android/phone/PhoneApp.java
@@ -205,6 +205,11 @@ public enum WakeState {
     /** boolean indicating restoring mute state on InCallScreen.onResume() */
     private boolean mShouldRestoreMuteOnInCallResume;
 
+    /**
+     * The singleton OtaUtils instance used for OTASP calls.
+     */
+    public OtaUtils otaUtils;
+
     // Following are the CDMA OTA information Objects used during OTA Call.
     // cdmaOtaProvisionData object store static OTA information that needs
     // to be maintained even during Slider open/close scenarios.
@@ -719,21 +724,49 @@ void dismissCallScreen() {
     }
 
     /**
-     * Handle OTA events
+     * Handle OTASP events
+     *
+     * While an OTASP call is active, the CallNotifier forwards
+     * OTASP-related telephony events to this method.
      *
-     * When OTA call is active and display becomes dark, then CallNotifier will
-     * handle OTA Events by calling this api which then calls OtaUtil function.
+     * If the InCallScreen is in the foreground, it handles these events
+     * itself so we don't need to do anything here.  But if the screen
+     * goes off during the OTASP call, or if we're on a data-only device
+     * with no in-call UI at all, we handle these events here by
+     * forwarding them to the OtaUtils singleton.
      */
     void handleOtaEvents(Message msg) {
+        if (DBG) Log.d(LOG_TAG, "handleOtaEvents(message " + msg + ")...");
 
-        if (DBG) Log.d(LOG_TAG, "Enter handleOtaEvents");
-        if ((mInCallScreen != null) && (!isShowingCallScreen())) {
-            if (mInCallScreen.otaUtils != null) {
-                mInCallScreen.otaUtils.onOtaProvisionStatusChanged((AsyncResult) msg.obj);
-            }
+        if (otaUtils == null) {
+            // We shouldn't be getting OTASP events without ever
+            // having started the OTASP call in the first place!
+            Log.w(LOG_TAG, "handleOtaEvents: got an event but otaUtils is null! "
+                  + "message = " + msg);
+            return;
+        }
+
+        if (!isShowingCallScreen()) {
+            otaUtils.onOtaProvisionStatusChanged((AsyncResult) msg.obj);
         }
     }
 
+    /**
+     * Similarly, handle the disconnect event of an OTASP call
+     * by forwarding it to the OtaUtils instance.
+     */
+    /* package */ void handleOtaspDisconnect() {
+        if (DBG) Log.d(LOG_TAG, "handleOtaspDisconnect()...");
+
+        if (otaUtils == null) {
+            // We shouldn't be getting OTASP events without ever
+            // having started the OTASP call in the first place!
+            Log.w(LOG_TAG, "handleOtaspDisconnect: otaUtils is null!");
+            return;
+        }
+
+        otaUtils.onOtaspDisconnect();
+    }
 
     /**
      * Sets the activity responsible for un-PUK-blocking the device
@@ -1572,8 +1605,8 @@ public boolean isOtaCallInEndState() {
     public void clearOtaState() {
         if (DBG) Log.d(LOG_TAG, "- clearOtaState ...");
         if ((mInCallScreen != null)
-                && (mInCallScreen.otaUtils != null)) {
-            mInCallScreen.otaUtils.cleanOtaScreen(true);
+                && (otaUtils != null)) {
+            otaUtils.cleanOtaScreen(true);
             if (DBG) Log.d(LOG_TAG, "  - clearOtaState clears OTA screen");
         }
     }
@@ -1582,8 +1615,8 @@ public void clearOtaState() {
     public void dismissOtaDialogs() {
         if (DBG) Log.d(LOG_TAG, "- dismissOtaDialogs ...");
         if ((mInCallScreen != null)
-                && (mInCallScreen.otaUtils != null)) {
-            mInCallScreen.otaUtils.dismissAllOtaDialogs();
+                && (otaUtils != null)) {
+            otaUtils.dismissAllOtaDialogs();
             if (DBG) Log.d(LOG_TAG, "  - dismissOtaDialogs clears OTA dialogs");
         }
     }