xref: /packages/services/Telephony/tests/src/com/android/phone/tests/OtaspTestActivity.java

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