/*
* 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.tests;
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;
import com.android.phone.OtaUtils;
/**
* Test activity that mimics the PERFORM_CDMA_PROVISIONING behavior of
* SetupWizard, useful for testing "non-interactive" OTASP.
* @see OtaUtils.startNonInteractiveOtasp
*
*/
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.otasp_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);
}
}
}