/*
 * Copyright (C) 2009 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.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.os.Bundle;
import android.os.PersistableBundle;
import android.os.SystemProperties;
import android.provider.Settings;
import android.telephony.CarrierConfigManager;
import android.util.Log;

import com.android.internal.telephony.Phone;
import com.android.internal.telephony.TelephonyCapabilities;

/**
 * Invisible activity that handles the com.android.phone.PERFORM_CDMA_PROVISIONING intent.
 * This activity is protected by the android.permission.PERFORM_CDMA_PROVISIONING permission.
 *
 * We handle the PERFORM_CDMA_PROVISIONING action by launching an OTASP
 * call via one of the OtaUtils helper methods: startInteractiveOtasp() on
 * regular phones, or startNonInteractiveOtasp() on data-only devices.
 *
 * TODO: The class name InCallScreenShowActivation is misleading, since
 * this activity is totally unrelated to the InCallScreen (which
 * implements the in-call UI.)  Let's eventually rename this to something
 * like CdmaProvisioningLauncher or CdmaProvisioningHandler...
 */
public class InCallScreenShowActivation extends Activity {
    private static final String LOG_TAG = "InCallScreenShowActivation";
    private static final boolean DBG =
            (PhoneGlobals.DBG_LEVEL >= 1) && (SystemProperties.getInt("ro.debuggable", 0) == 1);

    @Override
    protected void onCreate(Bundle icicle) {
        super.onCreate(icicle);

        Intent intent = getIntent();
        if (DBG) Log.d(LOG_TAG, "onCreate: intent = " + intent);
        Bundle extras = intent.getExtras();
        if (DBG && (extras != null)) {
            Log.d(LOG_TAG, "      - has extras: size = " + extras.size()); // forces an unparcel()
            Log.d(LOG_TAG, "      - extras = " + extras);
        }

        PhoneGlobals app = PhoneGlobals.getInstanceIfPrimary();
        if (app == null) {
            // TODO: All CDMA provisioning code should move into a BroadcastReceiver that runs
            // exclusively in the primary user's context.  This is because the majority of the
            // telephony logic -- and all of the important bits -- runs only as primary so we don't
            // have access to the things we need. We still need to maintain an Activity to support
            // legacy code which starts this using startActivity() but that Activity should be a
            // simple intent-trampoline for the new BroadcastReceiver.
            //
            // Though this conditional protects this code from NPEs on a secondary user due to an
            // uninitialized PhoneGlobals, there's not a good reason at the time of this writing as
            // to why a secondary user context shouldn't trigger a CDMA provisioning, or at least
            // nobody has expressed concern.
            Log.i(LOG_TAG, "Being asked to provision CDMA SIM from secondary user, skipping.");
            setResult(RESULT_CANCELED);
            finish();
            return;
        }

        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)) {

            PersistableBundle carrierConfig = app.getCarrierConfig();
            boolean usesHfa = carrierConfig.getBoolean(
                    CarrierConfigManager.KEY_USE_HFA_FOR_PROVISIONING_BOOL);
            if (usesHfa) {
                Log.i(LOG_TAG, "Starting Hfa from ACTION_PERFORM_CDMA_PROVISIONING");
                startHfa();
                finish();
                return;
            }

            boolean usesOtasp = carrierConfig.getBoolean(
                    CarrierConfigManager.KEY_USE_OTASP_FOR_PROVISIONING_BOOL);
            if (usesOtasp) {
                // On voice-capable devices, we perform CDMA provisioning in
                // "interactive" mode by directly launching the InCallScreen.
                // boolean interactiveMode = PhoneGlobals.sVoiceCapable;
                // TODO: Renable interactive mode for device provisioning.
                boolean interactiveMode = false;
                Log.i(LOG_TAG, "ACTION_PERFORM_CDMA_PROVISIONING (interactiveMode = "
                      + interactiveMode + ")...");

                // Testing: this intent extra allows test apps manually
                // enable/disable "interactive mode", regardless of whether
                // the current device is voice-capable.  This is allowed only
                // in userdebug or eng builds.
                if (intent.hasExtra(OtaUtils.EXTRA_OVERRIDE_INTERACTIVE_MODE)
                        && (SystemProperties.getInt("ro.debuggable", 0) == 1)) {
                    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, launch an OTASP call and arrange
                    // for the in-call UI to come up.  (The InCallScreen will
                    // notice that an OTASP call is active, and display the
                    // special OTASP UI instead of the usual in-call controls.)

                    if (DBG) Log.d(LOG_TAG, "==> Starting interactive CDMA provisioning...");
                    OtaUtils.startInteractiveOtasp(this);

                    // 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.)

                    if (DBG) Log.d(LOG_TAG, "==> Starting non-interactive CDMA provisioning...");
                    int callStatus = OtaUtils.startNonInteractiveOtasp(this);

                    if (callStatus == PhoneUtils.CALL_STATUS_DIALED) {
                        if (DBG) 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.i(LOG_TAG, "Skipping activation.");
            }
        } else {
            Log.e(LOG_TAG, "Unexpected intent action: " + intent);
            setResult(RESULT_CANCELED);
        }

        finish();
    }

    /**
     * On devices that provide a phone initialization wizard (such as Google Setup Wizard),
     * the wizard displays it's own activation UI. The Hfa activation started by this class
     * will show a UI or not depending on the status of the setup wizard. If the setup wizard
     * is running, do not show a UI, otherwise show our own UI since setup wizard will not.
     *
     * The method checks two properties:
     * 1. Does the device require a setup wizard (ro.setupwizard.mode == (REQUIRED|OPTIONAL))
     * 2. Is device_provisioned set to non-zero--a property that setup wizard sets at completion.
     * @return true if wizard is running, false otherwise.
     */
    private boolean isWizardRunning(Context context) {
        Intent intent = new Intent("android.intent.action.DEVICE_INITIALIZATION_WIZARD");
        ResolveInfo resolveInfo = context.getPackageManager().resolveActivity(intent,
                PackageManager.MATCH_DEFAULT_ONLY);
        boolean provisioned = Settings.Global.getInt(context.getContentResolver(),
                Settings.Global.DEVICE_PROVISIONED, 0) != 0;
        String mode = SystemProperties.get("ro.setupwizard.mode", "REQUIRED");
        boolean runningSetupWizard = "REQUIRED".equals(mode) || "OPTIONAL".equals(mode);
        if (DBG) {
            Log.v(LOG_TAG, "resolvInfo = " + resolveInfo + ", provisioned = " + provisioned
                    + ", runningSetupWizard = " + runningSetupWizard);
        }
        return resolveInfo != null && !provisioned && runningSetupWizard;
    }

    /**
     * Starts the HFA provisioning process by bringing up the HFA Activity.
     */
    private void startHfa() {
        boolean isWizardRunning = isWizardRunning(this);
        // We always run our HFA logic if we're in setup wizard, but if we're outside of setup
        // wizard then we have to check a config to see if we should still run HFA.
        if (isWizardRunning ||
                getResources().getBoolean(R.bool.config_allow_hfa_outside_of_setup_wizard)) {

            final Intent intent = new Intent();

            final PendingIntent otaResponseIntent = getIntent().getParcelableExtra(
                    OtaUtils.EXTRA_OTASP_RESULT_CODE_PENDING_INTENT);

            final boolean showUi = !isWizardRunning;
            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

            if (otaResponseIntent != null) {
                intent.putExtra(OtaUtils.EXTRA_OTASP_RESULT_CODE_PENDING_INTENT, otaResponseIntent);
            }

            Log.v(LOG_TAG, "Starting hfa activation activity");
            if (showUi) {
                intent.setClassName(this, HfaActivity.class.getName());
                startActivity(intent);
            } else {
                intent.setClassName(this, HfaService.class.getName());
                startService(intent);
            }

        }
        setResult(RESULT_OK);
    }
}