/*
* 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 com.android.internal.telephony.Phone;
import com.android.phone.OtaUtils.CdmaOtaInCallScreenUiState.State;
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.TextView;
/**
* Handles all OTA Call related logic and UI functionality.
* The InCallScreen interacts with this class to perform an OTA Call.
*
* OTA is a CDMA-specific feature:
* OTA or OTASP == Over The Air service provisioning
* SPC == Service Programming Code
* TODO: Include pointer to more detailed documentation.
*/
public class OtaUtils {
private static final String LOG_TAG = "OtaUtils";
private static final String UNACTIVATED_MIN2_VALUE = "000000";
private static final String UNACTIVATED_MIN_VALUE = "1111110111";
private static final boolean DBG = (PhoneApp.DBG_LEVEL >= 1);
public static final int OTA_SHOW_ACTIVATION_SCREEN_OFF = 0;
public static final int OTA_SHOW_ACTIVATION_SCREEN_ON = 1;
public static final int OTA_SHOW_LISTENING_SCREEN_OFF =0;
public static final int OTA_SHOW_LISTENING_SCREEN_ON =1;
public static final int OTA_SHOW_ACTIVATE_FAIL_COUNT_OFF = 0;
public static final int OTA_SHOW_ACTIVATE_FAIL_COUNT_THREE = 3;
public static final int OTA_PLAY_SUCCESS_FAILURE_TONE_OFF = 0;
public static final int OTA_PLAY_SUCCESS_FAILURE_TONE_ON = 1;
// SPC Timeout is 60 seconds
public final int OTA_SPC_TIMEOUT = 60;
public final int OTA_FAILURE_DIALOG_TIMEOUT = 2;
private InCallScreen mInCallScreen;
private Context mContext;
private PhoneApp mApplication;
private OtaWidgetData mOtaWidgetData;
private ViewGroup mInCallPanel;
private CallCard mCallCard;
// The DTMFTwelveKeyDialer instance owned by the InCallScreen, which
// the InCallScreen passes in to our constructor.
private DTMFTwelveKeyDialer mDialer;
//
// The DTMFTwelveKeyDialer instance that we create ourselves in
// initOtaInCallScreen(), and attach to the DTMFTwelveKeyDialerView
// ("otaDtmfDialerView") that comes from otacall_card.xml.
private DTMFTwelveKeyDialer mOtaCallCardDtmfDialer;
// TODO: we ought to share a single DTMFTwelveKeyDialer instance for
// both these uses, but see bug 2432289 for related issues.
private static boolean mIsWizardMode = true;
/**
* OtaWidgetData class represent all OTA UI elements
*/
private class OtaWidgetData {
public Button otaEndButton;
public Button otaActivateButton;
public Button otaSkipButton;
public Button otaNextButton;
public ToggleButton otaSpeakerButton;
public View otaCallCardBase;
public View callCardOtaButtonsFailSuccess;
public ProgressBar otaTextProgressBar;
public TextView otaTextSuccessFail;
public View callCardOtaButtonsActivate;
public View callCardOtaButtonsListenProgress;
public TextView otaTextActivate;
public TextView otaTextListenProgress;
public ScrollView otaTextListenProgressContainer;
public AlertDialog spcErrorDialog;
public AlertDialog otaFailureDialog;
public AlertDialog otaSkipConfirmationDialog;
public TextView otaTitle;
public DTMFTwelveKeyDialerView otaDtmfDialerView;
public Button otaTryAgainButton;
}
public OtaUtils(Context context,
InCallScreen inCallScreen,
ViewGroup inCallPanel,
CallCard callCard,
DTMFTwelveKeyDialer dialer) {
if (DBG) log("Enter OtaUtil constructor");
mInCallScreen = inCallScreen;
mContext = context;
mInCallPanel = inCallPanel;
mCallCard = callCard;
mDialer = dialer;
mApplication = PhoneApp.getInstance();
mOtaWidgetData = new OtaWidgetData();
// inflate OTA Call card and footers
ViewStub otaCallCardStub = (ViewStub) mInCallScreen.findViewById(R.id.otaCallCardStub);
otaCallCardStub.inflate();
readXmlSettings();
initOtaInCallScreen();
}
/**
* Returns true if the phone needs activation.
*
* @param minString the phone's MIN configuration string
* @return true if phone needs activation
* @throws OtaConfigurationException if the string is invalid
*/
public static boolean needsActivation(String minString) throws IllegalArgumentException {
if (minString == null || (minString.length() < 6)) {
throw new IllegalArgumentException();
}
return (minString.equals(UNACTIVATED_MIN_VALUE)
|| minString.substring(0,6).equals(UNACTIVATED_MIN2_VALUE))
|| SystemProperties.getBoolean("test_cdma_setup", false);
}
/**
* Starts the OTA provisioning call. If the MIN isn't available yet, it returns false and adds
* an event to return the request to the calling app when it becomes available.
*
* @param context
* @param handler
* @param request
* @return true if we were able to launch Ota activity or it's not required; false otherwise
*/
public static boolean maybeDoOtaCall(Context context, Handler handler, int request) {
PhoneApp app = PhoneApp.getInstance();
Phone phone = app.phone;
if (!isCdmaPhone()) {
if (DBG) Log.v("OtaUtils", "Can't run provisioning on a non-CDMA phone");
return true; // sanity check - a non-cdma phone doesn't need to run this
}
if (!phone.isMinInfoReady()) {
if (DBG) log("MIN is not ready. Registering to receive notification.");
phone.registerForSubscriptionInfoReady(handler, request, null);
return false;
}
phone.unregisterForSubscriptionInfoReady(handler);
String min = phone.getCdmaMin();
if (DBG) log("min_string: " + min);
boolean phoneNeedsActivation = false;
try {
phoneNeedsActivation = needsActivation(min);
} catch (IllegalArgumentException e) {
if (DBG) log("invalid MIN string, exit");
return true; // If the MIN string is wrong, there's nothing else we can do.
}
if (DBG) log("phoneNeedsActivation is set to " + phoneNeedsActivation);
int otaShowActivationScreen = context.getResources().getInteger(
R.integer.OtaShowActivationScreen);
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.");
} else {
if (DBG) log("activation intent NOT sent.");
}
return true;
}
private void setSpeaker(boolean state) {
if (DBG) log("setSpeaker : " + state );
if (state == PhoneUtils.isSpeakerOn(mContext)) {
if (DBG) log("no change. returning");
return;
}
if (state && mInCallScreen.isBluetoothAvailable()
&& mInCallScreen.isBluetoothAudioConnected()) {
mInCallScreen.disconnectBluetoothAudio();
}
PhoneUtils.turnOnSpeaker(mContext, state, true);
}
/**
* Handle OTA Provision events from Framework. Possible events are:
* OTA Commit Event - OTA provisioning was successful
* SPC retries exceeded - SPC failure retries has exceeded, and Phone needs to
* power down.
*/
public void onOtaProvisionStatusChanged(AsyncResult r) {
int OtaStatus[] = (int[]) r.result;
if (DBG) log("onOtaProvisionStatusChanged(): OtaStatus[0]" + OtaStatus[0]);
switch(OtaStatus[0]) {
case Phone.CDMA_OTA_PROVISION_STATUS_SPC_RETRIES_EXCEEDED:
otaShowInProgressScreen();
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");
break;
case Phone.CDMA_OTA_PROVISION_STATUS_SPL_UNLOCKED:
case Phone.CDMA_OTA_PROVISION_STATUS_A_KEY_EXCHANGED:
case Phone.CDMA_OTA_PROVISION_STATUS_SSD_UPDATED:
case Phone.CDMA_OTA_PROVISION_STATUS_NAM_DOWNLOADED:
case Phone.CDMA_OTA_PROVISION_STATUS_MDN_DOWNLOADED:
case Phone.CDMA_OTA_PROVISION_STATUS_IMSI_DOWNLOADED:
case Phone.CDMA_OTA_PROVISION_STATUS_PRL_DOWNLOADED:
case Phone.CDMA_OTA_PROVISION_STATUS_OTAPA_STARTED:
case Phone.CDMA_OTA_PROVISION_STATUS_OTAPA_STOPPED:
case Phone.CDMA_OTA_PROVISION_STATUS_OTAPA_ABORTED:
if (DBG) log("onOtaProvisionStatusChanged(): change to ProgressScreen");
otaShowInProgressScreen();
break;
default:
if (DBG) log("onOtaProvisionStatusChanged(): Ignoring OtaStatus " + OtaStatus[0]);
break;
}
}
private void otaShowHome() {
if (DBG) log("OtaShowHome()...");
mApplication.cdmaOtaScreenState.otaScreenState =
CdmaOtaScreenState.OtaScreenState.OTA_STATUS_UNDEFINED;
mInCallScreen.endInCallScreenSession();
Intent intent = new Intent(Intent.ACTION_MAIN);
intent.addCategory (Intent.CATEGORY_HOME);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
mContext.startActivity(intent);
return;
}
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
}
}
mInCallScreen.finish();
return;
}
private void otaPerformActivation() {
if (DBG) log("otaPerformActivation()...");
if (!mApplication.cdmaOtaProvisionData.inOtaSpcState) {
Intent newIntent = new Intent(Intent.ACTION_CALL);
newIntent.putExtra(Intent.EXTRA_PHONE_NUMBER, InCallScreen.OTA_NUMBER);
mInCallScreen.internalResolveIntent(newIntent);
otaShowListeningScreen();
}
return;
}
/**
* Show Activation Screen when phone powers up and OTA provision is
* required. Also shown when activation fails and user needs
* to re-attempt it. Contains ACTIVATE and SKIP buttons
* which allow user to start OTA activation or skip the activation process.
*/
public void otaShowActivateScreen() {
if (DBG) log("OtaShowActivationScreen()...");
if (mApplication.cdmaOtaConfigData.otaShowActivationScreen
== OTA_SHOW_ACTIVATION_SCREEN_ON) {
if (DBG) log("OtaShowActivationScreen(): show activation screen");
if (!isDialerOpened()) {
otaScreenInitialize();
mOtaWidgetData.otaSkipButton.setVisibility(mIsWizardMode ?
View.VISIBLE : View.INVISIBLE);
mOtaWidgetData.otaTextActivate.setVisibility(View.VISIBLE);
mOtaWidgetData.callCardOtaButtonsActivate.setVisibility(View.VISIBLE);
} else {
mDialer.setHandleVisible(true);
}
mApplication.cdmaOtaScreenState.otaScreenState =
CdmaOtaScreenState.OtaScreenState.OTA_STATUS_ACTIVATION;
} else {
if (DBG) log("OtaShowActivationScreen(): show home screen");
otaShowHome();
}
}
/**
* Show "Listen for Instruction" screen during OTA call. Shown when OTA Call
* is initiated and user needs to listen for network instructions and press
* appropriate DTMF digits to proceed to the "Programming in Progress" phase.
*/
private void otaShowListeningScreen() {
if (DBG) log("OtaShowListeningScreen()...");
if (mApplication.cdmaOtaConfigData.otaShowListeningScreen
== OTA_SHOW_LISTENING_SCREEN_ON) {
if (DBG) log("OtaShowListeningScreen(): show listening screen");
if (!isDialerOpened()) {
otaScreenInitialize();
mOtaWidgetData.otaTextListenProgressContainer.setVisibility(View.VISIBLE);
mOtaWidgetData.otaTextListenProgress.setText(R.string.ota_listen);
mOtaWidgetData.otaDtmfDialerView.setVisibility(View.VISIBLE);
mOtaWidgetData.callCardOtaButtonsListenProgress.setVisibility(View.VISIBLE);
mOtaWidgetData.otaSpeakerButton.setVisibility(View.VISIBLE);
boolean speakerOn = PhoneUtils.isSpeakerOn(mContext);
mOtaWidgetData.otaSpeakerButton.setChecked(speakerOn);
} else {
mDialer.setHandleVisible(true);
}
mApplication.cdmaOtaScreenState.otaScreenState =
CdmaOtaScreenState.OtaScreenState.OTA_STATUS_LISTENING;
// Update the state of the in-call menu items.
mInCallScreen.updateMenuItems();
} else {
if (DBG) log("OtaShowListeningScreen(): show progress screen");
otaShowInProgressScreen();
}
}
/**
* 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 (!isDialerOpened()) {
otaScreenInitialize();
mOtaWidgetData.otaTextListenProgressContainer.setVisibility(View.VISIBLE);
mOtaWidgetData.otaTextListenProgress.setText(R.string.ota_progress);
mOtaWidgetData.otaTextProgressBar.setVisibility(View.VISIBLE);
mOtaWidgetData.callCardOtaButtonsListenProgress.setVisibility(View.VISIBLE);
mOtaWidgetData.otaSpeakerButton.setVisibility(View.VISIBLE);
boolean speakerOn = PhoneUtils.isSpeakerOn(mContext);
mOtaWidgetData.otaSpeakerButton.setChecked(speakerOn);
} else {
mDialer.setHandleVisible(true);
}
mApplication.cdmaOtaScreenState.otaScreenState =
CdmaOtaScreenState.OtaScreenState.OTA_STATUS_PROGRESS;
// Update the state of the in-call menu items.
mInCallScreen.updateMenuItems();
}
/**
* Show programming failure dialog when OTA provisioning fails.
* If OTA provisioning attempts fail more than 3 times, then unsuccessful
* dialog is shown. Otherwise a two-second notice is shown with unsuccessful
* information. When notice expires, phone returns to activation screen.
*/
private void otaShowProgramFailure(int length) {
if (DBG) log("OtaShowProgramFailure()...");
mApplication.cdmaOtaProvisionData.activationCount++;
if ((mApplication.cdmaOtaProvisionData.activationCount <
mApplication.cdmaOtaConfigData.otaShowActivateFailTimes)
&& (mApplication.cdmaOtaConfigData.otaShowActivationScreen ==
OTA_SHOW_ACTIVATION_SCREEN_ON)) {
if (DBG) log("OtaShowProgramFailure(): activationCount"
+ mApplication.cdmaOtaProvisionData.activationCount);
if (DBG) log("OtaShowProgramFailure(): show failure notice");
otaShowProgramFailureNotice(length);
} else {
if (DBG) log("OtaShowProgramFailure(): show failure dialog");
otaShowProgramFailureDialog();
}
}
/**
* Show either programming success dialog when OTA provisioning succeeds, or
* programming failure dialog when it fails. See {@link otaShowProgramFailure}
* for more details.
*/
public void otaShowSuccessFailure() {
if (DBG) log("OtaShowSuccessFailure()...");
otaScreenInitialize();
if (DBG) log("OtaShowSuccessFailure(): isOtaCallCommitted"
+ mApplication.cdmaOtaProvisionData.isOtaCallCommitted);
if (mApplication.cdmaOtaProvisionData.isOtaCallCommitted) {
if (DBG) log("OtaShowSuccessFailure(), show success dialog");
otaShowProgramSuccessDialog();
} else {
if (DBG) log("OtaShowSuccessFailure(), show failure dialog");
otaShowProgramFailure(OTA_FAILURE_DIALOG_TIMEOUT);
}
return;
}
/**
* Show programming failure dialog when OTA provisioning fails more than 3
* times.
*/
private void otaShowProgramFailureDialog() {
if (DBG) log("OtaShowProgramFailureDialog()...");
mApplication.cdmaOtaScreenState.otaScreenState =
CdmaOtaScreenState.OtaScreenState.OTA_STATUS_SUCCESS_FAILURE_DLG;
mOtaWidgetData.otaTitle.setText(R.string.ota_title_problem_with_activation);
mOtaWidgetData.otaTextSuccessFail.setVisibility(View.VISIBLE);
mOtaWidgetData.otaTextSuccessFail.setText(R.string.ota_unsuccessful);
mOtaWidgetData.callCardOtaButtonsFailSuccess.setVisibility(View.VISIBLE);
mOtaWidgetData.otaTryAgainButton.setVisibility(View.VISIBLE);
//close the dialer if open
if (isDialerOpened()) {
mDialer.closeDialer(false);
}
}
/**
* Show programming success dialog when OTA provisioning succeeds.
*/
private void otaShowProgramSuccessDialog() {
if (DBG) log("OtaShowProgramSuccessDialog()...");
mApplication.cdmaOtaScreenState.otaScreenState =
CdmaOtaScreenState.OtaScreenState.OTA_STATUS_SUCCESS_FAILURE_DLG;
mOtaWidgetData.otaTitle.setText(R.string.ota_title_activate_success);
mOtaWidgetData.otaTextSuccessFail.setVisibility(View.VISIBLE);
mOtaWidgetData.otaTextSuccessFail.setText(R.string.ota_successful);
mOtaWidgetData.callCardOtaButtonsFailSuccess.setVisibility(View.VISIBLE);
mOtaWidgetData.otaNextButton.setVisibility(View.VISIBLE);
//close the dialer if open
if (isDialerOpened()) {
mDialer.closeDialer(false);
}
}
/**
* Show SPC failure notice when SPC attempts exceed 15 times.
* During OTA provisioning, if SPC code is incorrect OTA provisioning will
* fail. When SPC attempts are over 15, it shows SPC failure notice for one minute and
* then phone will power down.
*/
private void otaShowSpcErrorNotice(int length) {
if (DBG) log("OtaShowSpcErrorNotice()...");
if (mOtaWidgetData.spcErrorDialog == null) {
mApplication.cdmaOtaProvisionData.inOtaSpcState = true;
DialogInterface.OnKeyListener keyListener;
keyListener = new DialogInterface.OnKeyListener() {
public boolean onKey(DialogInterface dialog, int keyCode, KeyEvent event) {
log("Ignoring key events...");
return true;
}};
mOtaWidgetData.spcErrorDialog = new AlertDialog.Builder(mInCallScreen)
.setMessage(R.string.ota_spc_failure)
.setOnKeyListener(keyListener)
.create();
mOtaWidgetData.spcErrorDialog.getWindow().addFlags(
WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
| WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
mOtaWidgetData.spcErrorDialog.show();
//close the dialer if open
if (isDialerOpened()) {
mDialer.closeDialer(false);
}
long noticeTime = length*1000;
if (DBG) log("OtaShowSpcErrorNotice(), remaining SPC noticeTime" + noticeTime);
mInCallScreen.requestCloseSpcErrorNotice(noticeTime);
}
}
/**
* When SPC notice times out, force phone to power down.
*/
public void onOtaCloseSpcNotice() {
if (DBG) log("onOtaCloseSpcNotice(), send shutdown intent");
Intent shutdown = new Intent(Intent.ACTION_REQUEST_SHUTDOWN);
shutdown.putExtra(Intent.EXTRA_KEY_CONFIRM, false);
shutdown.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
mContext.startActivity(shutdown);
}
/**
* Show two-second notice when OTA provisioning fails and number of failed attempts
* is less then 3.
*/
private void otaShowProgramFailureNotice(int length) {
if (DBG) log("OtaShowProgramFailureNotice()...");
if (mOtaWidgetData.otaFailureDialog == null) {
mOtaWidgetData.otaFailureDialog = new AlertDialog.Builder(mInCallScreen)
.setMessage(R.string.ota_failure)
.create();
mOtaWidgetData.otaFailureDialog.getWindow().addFlags(
WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
| WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
mOtaWidgetData.otaFailureDialog.show();
long noticeTime = length*1000;
mInCallScreen.requestCloseOtaFailureNotice(noticeTime);
}
}
/**
* Handle OTA unsuccessful notice expiry. Dismisses the
* two-second notice and shows the activation screen.
*/
public void onOtaCloseFailureNotice() {
if (DBG) log("onOtaCloseFailureNotice()...");
if (mOtaWidgetData.otaFailureDialog != null) {
mOtaWidgetData.otaFailureDialog.dismiss();
mOtaWidgetData.otaFailureDialog = null;
}
otaShowActivateScreen();
}
/**
* Initialize all OTA UI elements to be gone. Also set inCallPanel,
* callCard and the dialpad handle to be gone. This is called before any OTA screen
* gets drawn.
*/
private void otaScreenInitialize() {
if (DBG) log("OtaScreenInitialize()...");
if (mInCallPanel != null) mInCallPanel.setVisibility(View.GONE);
if (mCallCard != null) mCallCard.hideCallCardElements();
mDialer.setHandleVisible(false);
mOtaWidgetData.otaTitle.setText(R.string.ota_title_activate);
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.otaDtmfDialerView.setVisibility(View.GONE);
mOtaWidgetData.otaSpeakerButton.setVisibility(View.GONE);
mOtaWidgetData.otaTryAgainButton.setVisibility(View.GONE);
mOtaWidgetData.otaNextButton.setVisibility(View.GONE);
mOtaWidgetData.otaCallCardBase.setVisibility(View.VISIBLE);
mOtaWidgetData.otaSkipButton.setVisibility(View.VISIBLE);
}
public void hideOtaScreen() {
if (DBG) log("hideOtaScreen()...");
mOtaWidgetData.callCardOtaButtonsActivate.setVisibility(View.GONE);
mOtaWidgetData.callCardOtaButtonsListenProgress.setVisibility(View.GONE);
mOtaWidgetData.callCardOtaButtonsFailSuccess.setVisibility(View.GONE);
mOtaWidgetData.otaCallCardBase.setVisibility(View.GONE);
}
public boolean isDialerOpened() {
return (mDialer != null && mDialer.isOpened());
}
/**
* Show the appropriate OTA screen based on the current state of OTA call.
* Shown whenever calling screen is resumed.
*/
public void otaShowProperScreen() {
if (DBG) log("otaShowProperScreen()...");
if (mInCallScreen.isForegroundActivity()) {
if (DBG) log("otaShowProperScreen(), OTA is foreground activity, currentstate ="
+ mApplication.cdmaOtaScreenState.otaScreenState);
if (mInCallPanel != null) {
mInCallPanel.setVisibility(View.GONE);
}
if (mApplication.cdmaOtaScreenState.otaScreenState
== CdmaOtaScreenState.OtaScreenState.OTA_STATUS_ACTIVATION) {
otaShowActivateScreen();
} else if (mApplication.cdmaOtaScreenState.otaScreenState
== CdmaOtaScreenState.OtaScreenState.OTA_STATUS_LISTENING) {
otaShowListeningScreen();
} else if (mApplication.cdmaOtaScreenState.otaScreenState
== CdmaOtaScreenState.OtaScreenState.OTA_STATUS_PROGRESS) {
otaShowInProgressScreen();
}
if (mApplication.cdmaOtaProvisionData.inOtaSpcState) {
otaShowSpcErrorNotice(getOtaSpcDisplayTime());
}
}
}
/**
* Read configuration values for each OTA screen from config.xml.
* These configuration values control visibility of each screen.
*/
private void readXmlSettings() {
if (DBG) log("readXmlSettings()...");
if (mApplication.cdmaOtaConfigData.configComplete) {
return;
}
mApplication.cdmaOtaConfigData.configComplete = true;
int tmpOtaShowActivationScreen =
mContext.getResources().getInteger(R.integer.OtaShowActivationScreen);
mApplication.cdmaOtaConfigData.otaShowActivationScreen = tmpOtaShowActivationScreen;
if (DBG) log("readXmlSettings(), otaShowActivationScreen"
+ mApplication.cdmaOtaConfigData.otaShowActivationScreen);
int tmpOtaShowListeningScreen =
mContext.getResources().getInteger(R.integer.OtaShowListeningScreen);
mApplication.cdmaOtaConfigData.otaShowListeningScreen = tmpOtaShowListeningScreen;
if (DBG) log("readXmlSettings(), otaShowListeningScreen"
+ mApplication.cdmaOtaConfigData.otaShowListeningScreen);
int tmpOtaShowActivateFailTimes =
mContext.getResources().getInteger(R.integer.OtaShowActivateFailTimes);
mApplication.cdmaOtaConfigData.otaShowActivateFailTimes = tmpOtaShowActivateFailTimes;
if (DBG) log("readXmlSettings(), otaShowActivateFailTimes"
+ mApplication.cdmaOtaConfigData.otaShowActivateFailTimes);
int tmpOtaPlaySuccessFailureTone =
mContext.getResources().getInteger(R.integer.OtaPlaySuccessFailureTone);
mApplication.cdmaOtaConfigData.otaPlaySuccessFailureTone = tmpOtaPlaySuccessFailureTone;
if (DBG) log("readXmlSettings(), otaPlaySuccessFailureTone"
+ mApplication.cdmaOtaConfigData.otaPlaySuccessFailureTone);
}
/**
* Handle the click events for OTA buttons.
*/
public void onClickHandler(int id) {
switch (id) {
case R.id.otaEndButton:
onClickOtaEndButton();
break;
case R.id.otaSpeakerButton:
onClickOtaSpeakerButton();
break;
case R.id.otaActivateButton:
onClickOtaActivateButton();
break;
case R.id.otaSkipButton:
onClickOtaActivateSkipButton();
break;
case R.id.otaNextButton:
onClickOtaActivateNextButton();
break;
case R.id.otaTryAgainButton:
onClickOtaTryAgainButton();
break;
default:
if (DBG) log ("onClickHandler: received a click event for unrecognized id");
break;
}
}
private void onClickOtaTryAgainButton() {
if (DBG) log("Activation Try Again Clicked!");
if (!mApplication.cdmaOtaProvisionData.inOtaSpcState) {
otaShowActivateScreen();
}
}
private void onClickOtaEndButton() {
if (DBG) log("Activation End Call Button Clicked!");
if (!mApplication.cdmaOtaProvisionData.inOtaSpcState) {
if (PhoneUtils.hangup(mApplication.mCM) == false) {
// If something went wrong when placing the OTA call,
// the screen is not updated by the call disconnect
// handler and we have to do it here
setSpeaker(false);
mInCallScreen.handleOtaCallEnd();
}
}
}
private void onClickOtaSpeakerButton() {
if (DBG) log("OTA Speaker button Clicked!");
if (!mApplication.cdmaOtaProvisionData.inOtaSpcState) {
boolean isChecked = !PhoneUtils.isSpeakerOn(mContext);
setSpeaker(isChecked);
}
}
private void onClickOtaActivateButton() {
if (DBG) log("Call Activation Clicked!");
otaPerformActivation();
}
private void onClickOtaActivateSkipButton() {
if (DBG) log("Activation Skip Clicked!");
DialogInterface.OnKeyListener keyListener;
keyListener = new DialogInterface.OnKeyListener() {
public boolean onKey(DialogInterface dialog, int keyCode,
KeyEvent event) {
if (DBG) log("Ignoring key events...");
return true;
}
};
mOtaWidgetData.otaSkipConfirmationDialog = new AlertDialog.Builder(mInCallScreen)
.setTitle(R.string.ota_skip_activation_dialog_title)
.setMessage(R.string.ota_skip_activation_dialog_message)
.setPositiveButton(
R.string.ota_skip_activation_dialog_skip_label,
new AlertDialog.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
otaSkipActivation();
}
})
.setNegativeButton(
R.string.ota_skip_activation_dialog_continue_label,
new AlertDialog.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
otaPerformActivation();
}
})
.setOnKeyListener(keyListener)
.create();
mOtaWidgetData.otaSkipConfirmationDialog.show();
}
private void onClickOtaActivateNextButton() {
if (DBG) log("Dialog Next Clicked!");
if (!mApplication.cdmaOtaProvisionData.inOtaSpcState) {
mApplication.cdmaOtaScreenState.otaScreenState =
CdmaOtaScreenState.OtaScreenState.OTA_STATUS_UNDEFINED;
otaShowHome();
}
}
public void dismissAllOtaDialogs() {
if (mOtaWidgetData.spcErrorDialog != null) {
if (DBG) log("- DISMISSING mSpcErrorDialog.");
mOtaWidgetData.spcErrorDialog.dismiss();
mOtaWidgetData.spcErrorDialog = null;
}
if (mOtaWidgetData.otaFailureDialog != null) {
if (DBG) log("- DISMISSING mOtaFailureDialog.");
mOtaWidgetData.otaFailureDialog.dismiss();
mOtaWidgetData.otaFailureDialog = null;
}
}
private int getOtaSpcDisplayTime() {
if (DBG) log("getOtaSpcDisplayTime()...");
int tmpSpcTime = 1;
if (mApplication.cdmaOtaProvisionData.inOtaSpcState) {
long tmpOtaSpcRunningTime = 0;
long tmpOtaSpcLeftTime = 0;
tmpOtaSpcRunningTime = SystemClock.elapsedRealtime();
tmpOtaSpcLeftTime =
tmpOtaSpcRunningTime - mApplication.cdmaOtaProvisionData.otaSpcUptime;
if (tmpOtaSpcLeftTime >= OTA_SPC_TIMEOUT*1000) {
tmpSpcTime = 1;
} else {
tmpSpcTime = OTA_SPC_TIMEOUT - (int)tmpOtaSpcLeftTime/1000;
}
}
if (DBG) log("getOtaSpcDisplayTime(), time for SPC error notice: " + tmpSpcTime);
return tmpSpcTime;
}
/**
* Initialize the OTA widgets for all OTA screens.
*/
private void initOtaInCallScreen() {
if (DBG) log("initOtaInCallScreen()...");
mOtaWidgetData.otaTitle = (TextView) mInCallScreen.findViewById(R.id.otaTitle);
mOtaWidgetData.otaTextActivate = (TextView) mInCallScreen.findViewById(R.id.otaActivate);
mOtaWidgetData.otaTextActivate.setVisibility(View.GONE);
mOtaWidgetData.otaTextListenProgressContainer =
(ScrollView) mInCallScreen.findViewById(R.id.otaListenProgressContainer);
mOtaWidgetData.otaTextListenProgress =
(TextView) mInCallScreen.findViewById(R.id.otaListenProgress);
mOtaWidgetData.otaTextProgressBar =
(ProgressBar) mInCallScreen.findViewById(R.id.progress_large);
mOtaWidgetData.otaTextProgressBar.setIndeterminate(true);
mOtaWidgetData.otaTextSuccessFail =
(TextView) mInCallScreen.findViewById(R.id.otaSuccessFailStatus);
mOtaWidgetData.otaCallCardBase = (View) mInCallScreen.findViewById(R.id.otaBase);
mOtaWidgetData.callCardOtaButtonsListenProgress =
(View) mInCallScreen.findViewById(R.id.callCardOtaListenProgress);
mOtaWidgetData.callCardOtaButtonsActivate =
(View) mInCallScreen.findViewById(R.id.callCardOtaActivate);
mOtaWidgetData.callCardOtaButtonsFailSuccess =
(View) mInCallScreen.findViewById(R.id.callCardOtaFailOrSuccessful);
mOtaWidgetData.otaEndButton = (Button) mInCallScreen.findViewById(R.id.otaEndButton);
mOtaWidgetData.otaEndButton.setOnClickListener(mInCallScreen);
mOtaWidgetData.otaSpeakerButton =
(ToggleButton) mInCallScreen.findViewById(R.id.otaSpeakerButton);
mOtaWidgetData.otaSpeakerButton.setOnClickListener(mInCallScreen);
mOtaWidgetData.otaActivateButton =
(Button) mInCallScreen.findViewById(R.id.otaActivateButton);
mOtaWidgetData.otaActivateButton.setOnClickListener(mInCallScreen);
mOtaWidgetData.otaSkipButton = (Button) mInCallScreen.findViewById(R.id.otaSkipButton);
mOtaWidgetData.otaSkipButton.setOnClickListener(mInCallScreen);
mOtaWidgetData.otaNextButton = (Button) mInCallScreen.findViewById(R.id.otaNextButton);
mOtaWidgetData.otaNextButton.setOnClickListener(mInCallScreen);
mOtaWidgetData.otaTryAgainButton =
(Button) mInCallScreen.findViewById(R.id.otaTryAgainButton);
mOtaWidgetData.otaTryAgainButton.setOnClickListener(mInCallScreen);
mOtaWidgetData.otaDtmfDialerView =
(DTMFTwelveKeyDialerView) mInCallScreen.findViewById(R.id.otaDtmfDialer);
// Sanity-check: the otaDtmfDialer widget should *always* be present.
if (mOtaWidgetData.otaDtmfDialerView == null) {
Log.e(LOG_TAG, "onCreate: couldn't find otaDtmfDialer", new IllegalStateException());
}
// Create a new DTMFTwelveKeyDialer instance purely for use by the
// DTMFTwelveKeyDialerView ("otaDtmfDialerView") that comes from
// otacall_card.xml.
// (But note that mDialer is a separate DTMFTwelveKeyDialer
// instance, that belongs to the InCallScreen. This is confusing;
// see the TODO comment above.)
mOtaCallCardDtmfDialer = new DTMFTwelveKeyDialer(mInCallScreen,
mOtaWidgetData.otaDtmfDialerView,
null /* no SlidingDrawer used here */);
// Initialize the new DTMFTwelveKeyDialer instance. This is
// needed to play local DTMF tones.
mOtaCallCardDtmfDialer.startDialerSession();
mOtaWidgetData.otaDtmfDialerView.setDialer(mOtaCallCardDtmfDialer);
}
/**
* Clear out all OTA UI widget elements. Needs to get called
* when OTA call ends or InCallScreen is destroyed.
* @param disableSpeaker parameter control whether Speaker should be turned off.
*/
public void cleanOtaScreen(boolean disableSpeaker) {
if (DBG) log("OTA ends, cleanOtaScreen!");
mApplication.cdmaOtaScreenState.otaScreenState =
CdmaOtaScreenState.OtaScreenState.OTA_STATUS_UNDEFINED;
mApplication.cdmaOtaProvisionData.isOtaCallCommitted = false;
mApplication.cdmaOtaProvisionData.isOtaCallIntentProcessed = false;
mApplication.cdmaOtaProvisionData.inOtaSpcState = false;
mApplication.cdmaOtaProvisionData.activationCount = 0;
mApplication.cdmaOtaProvisionData.otaSpcUptime = 0;
mApplication.cdmaOtaInCallScreenUiState.state = State.UNDEFINED;
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();
}
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
if (disableSpeaker) {
setSpeaker(false);
}
}
/**
* Defines OTA information that needs to be maintained during
* an OTA call when display orientation changes.
*/
public static class CdmaOtaProvisionData {
public boolean isOtaCallCommitted;
public boolean isOtaCallIntentProcessed;
public boolean inOtaSpcState;
public int activationCount;
public long otaSpcUptime;
}
/**
* Defines OTA screen configuration items read from config.xml
* and used to control OTA display.
*/
public static class CdmaOtaConfigData {
public int otaShowActivationScreen;
public int otaShowListeningScreen;
public int otaShowActivateFailTimes;
public int otaPlaySuccessFailureTone;
public boolean configComplete;
public CdmaOtaConfigData() {
if (DBG) log("CdmaOtaConfigData constructor!");
otaShowActivationScreen = OTA_SHOW_ACTIVATION_SCREEN_OFF;
otaShowListeningScreen = OTA_SHOW_LISTENING_SCREEN_OFF;
otaShowActivateFailTimes = OTA_SHOW_ACTIVATE_FAIL_COUNT_OFF;
otaPlaySuccessFailureTone = OTA_PLAY_SUCCESS_FAILURE_TONE_OFF;
}
}
/**
* The state of the OTA InCallScreen UI.
*/
public static class CdmaOtaInCallScreenUiState {
public enum State {
UNDEFINED,
NORMAL,
ENDED
}
public State state;
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;
}
/**
* Save the Ota InCallScreen UI state
*/
public void setCdmaOtaInCallScreenUiState(CdmaOtaInCallScreenUiState.State state) {
if (DBG) log("setCdmaOtaInCallScreenState: " + state);
mApplication.cdmaOtaInCallScreenUiState.state = state;
}
/**
* Get the Ota InCallScreen UI state
*/
public CdmaOtaInCallScreenUiState.State getCdmaOtaInCallScreenUiState() {
if (DBG) log("getCdmaOtaInCallScreenState: " + mApplication.cdmaOtaInCallScreenUiState.state);
return mApplication.cdmaOtaInCallScreenUiState.state;
}
/**
* The OTA screen state machine.
*/
public static class CdmaOtaScreenState {
public enum OtaScreenState {
OTA_STATUS_UNDEFINED,
OTA_STATUS_ACTIVATION,
OTA_STATUS_LISTENING,
OTA_STATUS_PROGRESS,
OTA_STATUS_SUCCESS_FAILURE_DLG
}
public OtaScreenState otaScreenState;
public CdmaOtaScreenState() {
otaScreenState = OtaScreenState.OTA_STATUS_UNDEFINED;
}
}
private static void log(String msg) {
Log.d(LOG_TAG, msg);
}
public static boolean isCdmaPhone() {
return (PhoneApp.getInstance().phone.getPhoneType() == Phone.PHONE_TYPE_CDMA);
}
}