java/com/android/dialer/voicemail/settings/VoicemailChangePinActivity.java

/*
 * Copyright (C) 2016 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.dialer.voicemail.settings;

import android.annotation.TargetApi;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnDismissListener;
import android.os.Build.VERSION_CODES;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.annotation.Nullable;
import android.telecom.PhoneAccountHandle;
import android.text.Editable;
import android.text.InputFilter;
import android.text.InputFilter.LengthFilter;
import android.text.TextWatcher;
import android.view.KeyEvent;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.WindowManager;
import android.view.inputmethod.EditorInfo;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.TextView.OnEditorActionListener;
import android.widget.Toast;
import com.android.dialer.common.LogUtil;
import com.android.dialer.common.concurrent.DialerExecutor;
import com.android.dialer.common.concurrent.DialerExecutor.Worker;
import com.android.dialer.common.concurrent.DialerExecutorComponent;
import com.android.dialer.logging.DialerImpression;
import com.android.dialer.logging.Logger;
import com.android.voicemail.PinChanger;
import com.android.voicemail.PinChanger.ChangePinResult;
import com.android.voicemail.PinChanger.PinSpecification;
import com.android.voicemail.VoicemailClient;
import com.android.voicemail.VoicemailComponent;
import java.lang.ref.WeakReference;

/**
 * Dialog to change the voicemail PIN. The TUI (Telephony User Interface) PIN is used when accessing
 * traditional voicemail through phone call. The intent to launch this activity must contain {@link
 * VoicemailClient#PARAM_PHONE_ACCOUNT_HANDLE}
 */
@TargetApi(VERSION_CODES.O)
public class VoicemailChangePinActivity extends Activity
    implements OnClickListener, OnEditorActionListener, TextWatcher {

  private static final String TAG = "VmChangePinActivity";

  private static final int MESSAGE_HANDLE_RESULT = 1;

  private PhoneAccountHandle phoneAccountHandle;
  private PinChanger pinChanger;

  private static class ChangePinParams {
    PinChanger pinChanger;
    PhoneAccountHandle phoneAccountHandle;
    String oldPin;
    String newPin;
  }

  private DialerExecutor<ChangePinParams> changePinExecutor;

  private int pinMinLength;
  private int pinMaxLength;

  private State uiState = State.Initial;
  private String oldPin;
  private String firstPin;

  private ProgressDialog progressDialog;

  private TextView headerText;
  private TextView hintText;
  private TextView errorText;
  private EditText pinEntry;
  private Button cancelButton;
  private Button nextButton;

  private Handler handler = new ChangePinHandler(new WeakReference<>(this));

  private enum State {
    /**
     * Empty state to handle initial state transition. Will immediately switch into {@link
     * #VerifyOldPin} if a default PIN has been set by the OMTP client, or {@link #EnterOldPin} if
     * not.
     */
    Initial,
    /**
     * Prompt the user to enter old PIN. The PIN will be verified with the server before proceeding
     * to {@link #EnterNewPin}.
     */
    EnterOldPin {
      @Override
      public void onEnter(VoicemailChangePinActivity activity) {
        activity.setHeader(R.string.change_pin_enter_old_pin_header);
        activity.hintText.setText(R.string.change_pin_enter_old_pin_hint);
        activity.nextButton.setText(R.string.change_pin_continue_label);
        activity.errorText.setText(null);
      }

      @Override
      public void onInputChanged(VoicemailChangePinActivity activity) {
        activity.setNextEnabled(activity.getCurrentPasswordInput().length() > 0);
      }

      @Override
      public void handleNext(VoicemailChangePinActivity activity) {
        activity.oldPin = activity.getCurrentPasswordInput();
        activity.verifyOldPin();
      }

      @Override
      public void handleResult(VoicemailChangePinActivity activity, @ChangePinResult int result) {
        if (result == PinChanger.CHANGE_PIN_SUCCESS) {
          activity.updateState(State.EnterNewPin);
        } else {
          CharSequence message = activity.getChangePinResultMessage(result);
          activity.showError(message);
          activity.pinEntry.setText("");
        }
      }
    },
    /**
     * The default old PIN is found. Show a blank screen while verifying with the server to make
     * sure the PIN is still valid. If the PIN is still valid, proceed to {@link #EnterNewPin}. If
     * not, the user probably changed the PIN through other means, proceed to {@link #EnterOldPin}.
     * If any other issue caused the verifying to fail, show an error and exit.
     */
    VerifyOldPin {
      @Override
      public void onEnter(VoicemailChangePinActivity activity) {
        activity.findViewById(android.R.id.content).setVisibility(View.INVISIBLE);
        activity.verifyOldPin();
      }

      @Override
      public void handleResult(
          final VoicemailChangePinActivity activity, @ChangePinResult int result) {
        if (result == PinChanger.CHANGE_PIN_SUCCESS) {
          activity.updateState(State.EnterNewPin);
        } else if (result == PinChanger.CHANGE_PIN_SYSTEM_ERROR) {
          activity
              .getWindow()
              .setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
          activity.showError(
              activity.getString(R.string.change_pin_system_error),
              new OnDismissListener() {
                @Override
                public void onDismiss(DialogInterface dialog) {
                  activity.finish();
                }
              });
        } else {
          LogUtil.e(TAG, "invalid default old PIN: " + activity.getChangePinResultMessage(result));
          // If the default old PIN is rejected by the server, the PIN is probably changed
          // through other means, or the generated pin is invalid
          // Wipe the default old PIN so the old PIN input box will be shown to the user
          // on the next time.
          activity.pinChanger.setScrambledPin(null);
          activity.updateState(State.EnterOldPin);
        }
      }

      @Override
      public void onLeave(VoicemailChangePinActivity activity) {
        activity.findViewById(android.R.id.content).setVisibility(View.VISIBLE);
      }
    },
    /**
     * Let the user enter the new PIN and validate the format. Only length is enforced, PIN strength
     * check relies on the server. After a valid PIN is entered, proceed to {@link #ConfirmNewPin}
     */
    EnterNewPin {
      @Override
      public void onEnter(VoicemailChangePinActivity activity) {
        activity.headerText.setText(R.string.change_pin_enter_new_pin_header);
        activity.nextButton.setText(R.string.change_pin_continue_label);
        activity.hintText.setText(
            activity.getString(
                R.string.change_pin_enter_new_pin_hint,
                activity.pinMinLength,
                activity.pinMaxLength));
      }

      @Override
      public void onInputChanged(VoicemailChangePinActivity activity) {
        String password = activity.getCurrentPasswordInput();
        if (password.length() == 0) {
          activity.setNextEnabled(false);
          return;
        }
        CharSequence error = activity.validatePassword(password);
        if (error != null) {
          activity.errorText.setText(error);
          activity.setNextEnabled(false);
        } else {
          activity.errorText.setText(null);
          activity.setNextEnabled(true);
        }
      }

      @Override
      public void handleNext(VoicemailChangePinActivity activity) {
        CharSequence errorMsg;
        errorMsg = activity.validatePassword(activity.getCurrentPasswordInput());
        if (errorMsg != null) {
          activity.showError(errorMsg);
          return;
        }
        activity.firstPin = activity.getCurrentPasswordInput();
        activity.updateState(State.ConfirmNewPin);
      }
    },
    /**
     * Let the user type in the same PIN again to avoid typos. If the PIN matches then perform a PIN
     * change to the server. Finish the activity if succeeded. Return to {@link #EnterOldPin} if the
     * old PIN is rejected, {@link #EnterNewPin} for other failure.
     */
    ConfirmNewPin {
      @Override
      public void onEnter(VoicemailChangePinActivity activity) {
        activity.headerText.setText(R.string.change_pin_confirm_pin_header);
        activity.hintText.setText(null);
        activity.nextButton.setText(R.string.change_pin_ok_label);
      }

      @Override
      public void onInputChanged(VoicemailChangePinActivity activity) {
        if (activity.getCurrentPasswordInput().length() == 0) {
          activity.setNextEnabled(false);
          return;
        }
        if (activity.getCurrentPasswordInput().equals(activity.firstPin)) {
          activity.setNextEnabled(true);
          activity.errorText.setText(null);
        } else {
          activity.setNextEnabled(false);
          activity.errorText.setText(R.string.change_pin_confirm_pins_dont_match);
        }
      }

      @Override
      public void handleResult(VoicemailChangePinActivity activity, @ChangePinResult int result) {
        if (result == PinChanger.CHANGE_PIN_SUCCESS) {
          // If the PIN change succeeded we no longer know what the old (current) PIN is.
          // Wipe the default old PIN so the old PIN input box will be shown to the user
          // on the next time.
          activity.pinChanger.setScrambledPin(null);

          activity.finish();
          Logger.get(activity).logImpression(DialerImpression.Type.VVM_CHANGE_PIN_COMPLETED);
          Toast.makeText(
                  activity, activity.getString(R.string.change_pin_succeeded), Toast.LENGTH_SHORT)
              .show();
        } else {
          CharSequence message = activity.getChangePinResultMessage(result);
          LogUtil.i(TAG, "Change PIN failed: " + message);
          activity.showError(message);
          if (result == PinChanger.CHANGE_PIN_MISMATCH) {
            // Somehow the PIN has changed, prompt to enter the old PIN again.
            activity.updateState(State.EnterOldPin);
          } else {
            // The new PIN failed to fulfil other restrictions imposed by the server.
            activity.updateState(State.EnterNewPin);
          }
        }
      }

      @Override
      public void handleNext(VoicemailChangePinActivity activity) {
        activity.processPinChange(activity.oldPin, activity.firstPin);
      }
    };

    /** The activity has switched from another state to this one. */
    public void onEnter(VoicemailChangePinActivity activity) {
      // Do nothing
    }

    /**
     * The user has typed something into the PIN input field. Also called after {@link
     * #onEnter(VoicemailChangePinActivity)}
     */
    public void onInputChanged(VoicemailChangePinActivity activity) {
      // Do nothing
    }

    /** The asynchronous call to change the PIN on the server has returned. */
    public void handleResult(VoicemailChangePinActivity activity, @ChangePinResult int result) {
      // Do nothing
    }

    /** The user has pressed the "next" button. */
    public void handleNext(VoicemailChangePinActivity activity) {
      // Do nothing
    }

    /** The activity has switched from this state to another one. */
    public void onLeave(VoicemailChangePinActivity activity) {
      // Do nothing
    }
  }

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    phoneAccountHandle = getIntent().getParcelableExtra(VoicemailClient.PARAM_PHONE_ACCOUNT_HANDLE);
    pinChanger =
        VoicemailComponent.get(this)
            .getVoicemailClient()
            .createPinChanger(getApplicationContext(), phoneAccountHandle);
    setContentView(R.layout.voicemail_change_pin);
    setTitle(R.string.change_pin_title);

    readPinLength();

    View view = findViewById(android.R.id.content);

    cancelButton = (Button) view.findViewById(R.id.cancel_button);
    cancelButton.setOnClickListener(this);
    nextButton = (Button) view.findViewById(R.id.next_button);
    nextButton.setOnClickListener(this);

    pinEntry = (EditText) view.findViewById(R.id.pin_entry);
    pinEntry.setOnEditorActionListener(this);
    pinEntry.addTextChangedListener(this);
    if (pinMaxLength != 0) {
      pinEntry.setFilters(new InputFilter[] {new LengthFilter(pinMaxLength)});
    }

    headerText = (TextView) view.findViewById(R.id.headerText);
    hintText = (TextView) view.findViewById(R.id.hintText);
    errorText = (TextView) view.findViewById(R.id.errorText);

    changePinExecutor =
        DialerExecutorComponent.get(this)
            .dialerExecutorFactory()
            .createUiTaskBuilder(getFragmentManager(), "changePin", new ChangePinWorker())
            .onSuccess(this::sendResult)
            .onFailure((tr) -> sendResult(PinChanger.CHANGE_PIN_SYSTEM_ERROR))
            .build();

    if (isPinScrambled(this, phoneAccountHandle)) {
      oldPin = pinChanger.getScrambledPin();
      updateState(State.VerifyOldPin);
    } else {
      updateState(State.EnterOldPin);
    }
  }

  /** Extracts the pin length requirement sent by the server with a STATUS SMS. */
  private void readPinLength() {
    PinSpecification pinSpecification = pinChanger.getPinSpecification();
    pinMinLength = pinSpecification.minLength;
    pinMaxLength = pinSpecification.maxLength;
  }

  @Override
  public void onResume() {
    super.onResume();
    updateState(uiState);
  }

  public void handleNext() {
    if (pinEntry.length() == 0) {
      return;
    }
    uiState.handleNext(this);
  }

  @Override
  public void onClick(View v) {
    if (v.getId() == R.id.next_button) {
      handleNext();
    } else if (v.getId() == R.id.cancel_button) {
      finish();
    }
  }

  @Override
  public boolean onOptionsItemSelected(MenuItem item) {
    if (item.getItemId() == android.R.id.home) {
      onBackPressed();
      return true;
    }
    return super.onOptionsItemSelected(item);
  }

  @Override
  public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
    if (!nextButton.isEnabled()) {
      return true;
    }
    // Check if this was the result of hitting the enter or "done" key
    if (actionId == EditorInfo.IME_NULL
        || actionId == EditorInfo.IME_ACTION_DONE
        || actionId == EditorInfo.IME_ACTION_NEXT) {
      handleNext();
      return true;
    }
    return false;
  }

  @Override
  public void afterTextChanged(Editable s) {
    uiState.onInputChanged(this);
  }

  @Override
  public void beforeTextChanged(CharSequence s, int start, int count, int after) {
    // Do nothing
  }

  @Override
  public void onTextChanged(CharSequence s, int start, int before, int count) {
    // Do nothing
  }

  /**
   * After replacing the default PIN with a random PIN, call this to store the random PIN. The
   * stored PIN will be automatically entered when the user attempts to change the PIN.
   */
  public static boolean isPinScrambled(Context context, PhoneAccountHandle phoneAccountHandle) {
    return VoicemailComponent.get(context)
            .getVoicemailClient()
            .createPinChanger(context, phoneAccountHandle)
            .getScrambledPin()
        != null;
  }

  private String getCurrentPasswordInput() {
    return pinEntry.getText().toString();
  }

  private void updateState(State state) {
    State previousState = uiState;
    uiState = state;
    if (previousState != state) {
      previousState.onLeave(this);
      pinEntry.setText("");
      uiState.onEnter(this);
    }
    uiState.onInputChanged(this);
  }

  /**
   * Validates PIN and returns a message to display if PIN fails test.
   *
   * @param password the raw password the user typed in
   * @return error message to show to user or null if password is OK
   */
  private CharSequence validatePassword(String password) {
    if (pinMinLength == 0 && pinMaxLength == 0) {
      // Invalid length requirement is sent by the server, just accept anything and let the
      // server decide.
      return null;
    }

    if (password.length() < pinMinLength) {
      return getString(R.string.vm_change_pin_error_too_short);
    }
    return null;
  }

  private void setHeader(int text) {
    headerText.setText(text);
    pinEntry.setContentDescription(headerText.getText());
  }

  /**
   * Get the corresponding message for the {@link ChangePinResult}.<code>result</code> must not
   * {@link PinChanger#CHANGE_PIN_SUCCESS}
   */
  private CharSequence getChangePinResultMessage(@ChangePinResult int result) {
    switch (result) {
      case PinChanger.CHANGE_PIN_TOO_SHORT:
        return getString(R.string.vm_change_pin_error_too_short);
      case PinChanger.CHANGE_PIN_TOO_LONG:
        return getString(R.string.vm_change_pin_error_too_long);
      case PinChanger.CHANGE_PIN_TOO_WEAK:
        return getString(R.string.vm_change_pin_error_too_weak);
      case PinChanger.CHANGE_PIN_INVALID_CHARACTER:
        return getString(R.string.vm_change_pin_error_invalid);
      case PinChanger.CHANGE_PIN_MISMATCH:
        return getString(R.string.vm_change_pin_error_mismatch);
      case PinChanger.CHANGE_PIN_SYSTEM_ERROR:
        return getString(R.string.vm_change_pin_error_system_error);
      default:
        LogUtil.e(TAG, "Unexpected ChangePinResult " + result);
        return null;
    }
  }

  private void verifyOldPin() {
    processPinChange(oldPin, oldPin);
  }

  private void setNextEnabled(boolean enabled) {
    nextButton.setEnabled(enabled);
  }

  private void showError(CharSequence message) {
    showError(message, null);
  }

  private void showError(CharSequence message, @Nullable OnDismissListener callback) {
    new AlertDialog.Builder(this)
        .setMessage(message)
        .setPositiveButton(android.R.string.ok, null)
        .setOnDismissListener(callback)
        .show();
  }

  /** Asynchronous call to change the PIN on the server. */
  private void processPinChange(String oldPin, String newPin) {
    progressDialog = new ProgressDialog(this);
    progressDialog.setCancelable(false);
    progressDialog.setMessage(getString(R.string.vm_change_pin_progress_message));
    progressDialog.show();

    ChangePinParams params = new ChangePinParams();
    params.pinChanger = pinChanger;
    params.phoneAccountHandle = phoneAccountHandle;
    params.oldPin = oldPin;
    params.newPin = newPin;

    changePinExecutor.executeSerial(params);
  }

  private void sendResult(@ChangePinResult int result) {
    LogUtil.i(TAG, "Change PIN result: " + result);
    if (progressDialog.isShowing()
        && !VoicemailChangePinActivity.this.isDestroyed()
        && !VoicemailChangePinActivity.this.isFinishing()) {
      progressDialog.dismiss();
    } else {
      LogUtil.i(TAG, "Dialog not visible, not dismissing");
    }
    handler.obtainMessage(MESSAGE_HANDLE_RESULT, result, 0).sendToTarget();
  }

  private static class ChangePinHandler extends Handler {

    private final WeakReference<VoicemailChangePinActivity> activityWeakReference;

    private ChangePinHandler(WeakReference<VoicemailChangePinActivity> activityWeakReference) {
      this.activityWeakReference = activityWeakReference;
    }

    @Override
    public void handleMessage(Message message) {
      VoicemailChangePinActivity activity = activityWeakReference.get();
      if (activity == null) {
        return;
      }
      if (message.what == MESSAGE_HANDLE_RESULT) {
        activity.uiState.handleResult(activity, message.arg1);
      }
    }
  }

  private static class ChangePinWorker implements Worker<ChangePinParams, Integer> {

    @Nullable
    @Override
    public Integer doInBackground(@Nullable ChangePinParams input) throws Throwable {
      return input.pinChanger.changePin(input.oldPin, input.newPin);
    }
  }
}