path: root/src/com/android/tv/dialog/PinDialogFragment.java

/*
 * Copyright (C) 2015 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.tv.dialog;

import android.animation.Animator;
import android.animation.AnimatorInflater;
import android.animation.AnimatorListenerAdapter;
import android.animation.AnimatorSet;
import android.animation.ObjectAnimator;
import android.animation.ValueAnimator;
import android.app.ActivityManager;
import android.app.Dialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.SharedPreferences;
import android.content.res.Resources;
import android.media.tv.TvContentRating;
import android.os.Bundle;
import android.os.Handler;
import android.preference.PreferenceManager;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.util.Log;
import android.util.TypedValue;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewGroup.LayoutParams;
import android.widget.FrameLayout;
import android.widget.TextView;
import android.widget.Toast;

import com.android.tv.R;
import com.android.tv.TvApplication;
import com.android.tv.common.SoftPreconditions;
import com.android.tv.util.TvSettings;

public class PinDialogFragment extends SafeDismissDialogFragment {
    private static final String TAG = "PinDialogFragment";
    private static final boolean DEBUG = true;

    /**
     * PIN code dialog for unlock channel
     */
    public static final int PIN_DIALOG_TYPE_UNLOCK_CHANNEL = 0;

    /**
     * PIN code dialog for unlock content.
     * Only difference between {@code PIN_DIALOG_TYPE_UNLOCK_CHANNEL} is it's title.
     */
    public static final int PIN_DIALOG_TYPE_UNLOCK_PROGRAM = 1;

    /**
     * PIN code dialog for change parental control settings
     */
    public static final int PIN_DIALOG_TYPE_ENTER_PIN = 2;

    /**
     * PIN code dialog for set new PIN
     */
    public static final int PIN_DIALOG_TYPE_NEW_PIN = 3;

    // PIN code dialog for checking old PIN. This is internal only.
    private static final int PIN_DIALOG_TYPE_OLD_PIN = 4;

    /**
     * PIN code dialog for unlocking DVR playback
     */
    public static final int PIN_DIALOG_TYPE_UNLOCK_DVR = 5;

    private static final int MAX_WRONG_PIN_COUNT = 5;
    private static final int DISABLE_PIN_DURATION_MILLIS = 60 * 1000; // 1 minute

    private static final String INITIAL_TEXT = "—";
    private static final String TRACKER_LABEL = "Pin dialog";
    private static final String ARGS_TYPE = "args_type";
    private static final String ARGS_RATING = "args_rating";

    public static final String DIALOG_TAG = PinDialogFragment.class.getName();

    private static final int NUMBER_PICKERS_RES_ID[] = {
            R.id.first, R.id.second, R.id.third, R.id.fourth };

    private int mType;
    private int mRequestType;
    private boolean mPinChecked;
    private boolean mDismissSilently;

    private TextView mWrongPinView;
    private View mEnterPinView;
    private TextView mTitleView;
    private PinNumberPicker[] mPickers;
    private SharedPreferences mSharedPreferences;
    private String mPrevPin;
    private String mPin;
    private String mRatingString;
    private int mWrongPinCount;
    private long mDisablePinUntil;
    private final Handler mHandler = new Handler();

    public static PinDialogFragment create(int type) {
        return create(type, null);
    }

    public static PinDialogFragment create(int type, String rating) {
        PinDialogFragment fragment = new PinDialogFragment();
        Bundle args = new Bundle();
        args.putInt(ARGS_TYPE, type);
        args.putString(ARGS_RATING, rating);
        fragment.setArguments(args);
        return fragment;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mRequestType = getArguments().getInt(ARGS_TYPE, PIN_DIALOG_TYPE_ENTER_PIN);
        mType = mRequestType;
        mRatingString = getArguments().getString(ARGS_RATING);
        setStyle(STYLE_NO_TITLE, 0);
        mSharedPreferences = PreferenceManager.getDefaultSharedPreferences(getActivity());
        mDisablePinUntil = TvSettings.getDisablePinUntil(getActivity());
        if (ActivityManager.isUserAMonkey()) {
            // Skip PIN dialog half the time for monkeys
            if (Math.random() < 0.5) {
                exit(true);
            }
        }
        mPinChecked = false;
    }

    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        Dialog dlg = super.onCreateDialog(savedInstanceState);
        dlg.getWindow().getAttributes().windowAnimations = R.style.pin_dialog_animation;
        PinNumberPicker.loadResources(dlg.getContext());
        return dlg;
    }

    @Override
    public String getTrackerLabel() {
        return TRACKER_LABEL;
    }

    @Override
    public void onStart() {
        super.onStart();
        // Dialog size is determined by its windows size, not inflated view size.
        // So apply view size to window after the DialogFragment.onStart() where dialog is shown.
        Dialog dlg = getDialog();
        if (dlg != null) {
            dlg.getWindow().setLayout(
                    getResources().getDimensionPixelSize(R.dimen.pin_dialog_width),
                    LayoutParams.WRAP_CONTENT);
        }
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        final View v = inflater.inflate(R.layout.pin_dialog, container, false);

        mWrongPinView = (TextView) v.findViewById(R.id.wrong_pin);
        mEnterPinView = v.findViewById(R.id.enter_pin);
        mTitleView = (TextView) mEnterPinView.findViewById(R.id.title);
        if (TextUtils.isEmpty(getPin())) {
            // If PIN isn't set, user should set a PIN.
            // Successfully setting a new set is considered as entering correct PIN.
            mType = PIN_DIALOG_TYPE_NEW_PIN;
        }
        switch (mType) {
            case PIN_DIALOG_TYPE_UNLOCK_CHANNEL:
                mTitleView.setText(R.string.pin_enter_unlock_channel);
                break;
            case PIN_DIALOG_TYPE_UNLOCK_PROGRAM:
                mTitleView.setText(R.string.pin_enter_unlock_program);
                break;
            case PIN_DIALOG_TYPE_UNLOCK_DVR:
                TvContentRating tvContentRating =
                        TvContentRating.unflattenFromString(mRatingString);
                if (TvContentRating.UNRATED.equals(tvContentRating)) {
                    mTitleView.setText(getString(R.string.pin_enter_unlock_dvr_unrated));
                } else {
                    mTitleView.setText(
                            getString(
                                    R.string.pin_enter_unlock_dvr,
                                    TvApplication.getSingletons(getContext())
                                            .getTvInputManagerHelper()
                                            .getContentRatingsManager()
                                            .getDisplayNameForRating(tvContentRating)));
                }
                break;
            case PIN_DIALOG_TYPE_ENTER_PIN:
                mTitleView.setText(R.string.pin_enter_pin);
                break;
            case PIN_DIALOG_TYPE_NEW_PIN:
                if (TextUtils.isEmpty(getPin())) {
                    mTitleView.setText(R.string.pin_enter_create_pin);
                } else {
                    mTitleView.setText(R.string.pin_enter_old_pin);
                    mType = PIN_DIALOG_TYPE_OLD_PIN;
                }
        }

        mPickers = new PinNumberPicker[NUMBER_PICKERS_RES_ID.length];
        for (int i = 0; i < NUMBER_PICKERS_RES_ID.length; i++) {
            mPickers[i] = (PinNumberPicker) v.findViewById(NUMBER_PICKERS_RES_ID[i]);
            mPickers[i].setValueRangeAndResetText(0, 9);
            mPickers[i].setPinDialogFragment(this);
            mPickers[i].updateFocus(false);
        }
        for (int i = 0; i < NUMBER_PICKERS_RES_ID.length - 1; i++) {
            mPickers[i].setNextNumberPicker(mPickers[i + 1]);
        }

        if (mType != PIN_DIALOG_TYPE_NEW_PIN) {
            updateWrongPin();
        }
        return v;
    }

    private final Runnable mUpdateEnterPinRunnable = new Runnable() {
        @Override
        public void run() {
            updateWrongPin();
        }
    };

    private void updateWrongPin() {
        if (getActivity() == null) {
            // The activity is already detached. No need to update.
            mHandler.removeCallbacks(null);
            return;
        }

        int remainingSeconds = (int) ((mDisablePinUntil - System.currentTimeMillis()) / 1000);
        boolean enabled = remainingSeconds < 1;
        if (enabled) {
            mWrongPinView.setVisibility(View.INVISIBLE);
            mEnterPinView.setVisibility(View.VISIBLE);
            mWrongPinCount = 0;
        } else {
            mEnterPinView.setVisibility(View.INVISIBLE);
            mWrongPinView.setVisibility(View.VISIBLE);
            mWrongPinView.setText(getResources().getQuantityString(R.plurals.pin_enter_countdown,
                    remainingSeconds, remainingSeconds));
            mHandler.postDelayed(mUpdateEnterPinRunnable, 1000);
        }
    }

    private void exit(boolean pinChecked) {
        mPinChecked = pinChecked;
        dismiss();
    }

    /** Dismisses the pin dialog without calling activity listener. */
    public void dismissSilently() {
        mDismissSilently = true;
        dismiss();
    }

    @Override
    public void onDismiss(DialogInterface dialog) {
        super.onDismiss(dialog);
        if (DEBUG) Log.d(TAG, "onDismiss: mPinChecked=" + mPinChecked);
        SoftPreconditions.checkState(getActivity() instanceof OnPinCheckedListener);
        if (!mDismissSilently && getActivity() instanceof OnPinCheckedListener) {
            ((OnPinCheckedListener) getActivity()).onPinChecked(
                    mPinChecked, mRequestType, mRatingString);
        }
        mDismissSilently = false;
    }

    private void handleWrongPin() {
        if (++mWrongPinCount >= MAX_WRONG_PIN_COUNT) {
            mDisablePinUntil = System.currentTimeMillis() + DISABLE_PIN_DURATION_MILLIS;
            TvSettings.setDisablePinUntil(getActivity(), mDisablePinUntil);
            updateWrongPin();
        } else {
            showToast(R.string.pin_toast_wrong);
        }
    }

    private void showToast(int resId) {
        Toast.makeText(getActivity(), resId, Toast.LENGTH_SHORT).show();
    }

    private void done(String pin) {
        if (DEBUG) Log.d(TAG, "done: mType=" + mType + " pin=" + pin + " stored=" + getPin());
        switch (mType) {
            case PIN_DIALOG_TYPE_UNLOCK_CHANNEL:
            case PIN_DIALOG_TYPE_UNLOCK_PROGRAM:
            case PIN_DIALOG_TYPE_UNLOCK_DVR:
            case PIN_DIALOG_TYPE_ENTER_PIN:
                if (TextUtils.isEmpty(getPin()) || pin.equals(getPin())) {
                    exit(true);
                } else {
                    resetPinInput();
                    handleWrongPin();
                }
                break;
            case PIN_DIALOG_TYPE_NEW_PIN:
                resetPinInput();
                if (mPrevPin == null) {
                    mPrevPin = pin;
                    mTitleView.setText(R.string.pin_enter_again);
                } else {
                    if (pin.equals(mPrevPin)) {
                        setPin(pin);
                        exit(true);
                    } else {
                        if (TextUtils.isEmpty(getPin())) {
                            mTitleView.setText(R.string.pin_enter_create_pin);
                        } else {
                            mTitleView.setText(R.string.pin_enter_new_pin);
                        }
                        mPrevPin = null;
                        showToast(R.string.pin_toast_not_match);
                    }
                }
                break;
            case PIN_DIALOG_TYPE_OLD_PIN:
                // Call resetPinInput() here because we'll get additional PIN input
                // regardless of the result.
                resetPinInput();
                if (pin.equals(getPin())) {
                    mType = PIN_DIALOG_TYPE_NEW_PIN;
                    mTitleView.setText(R.string.pin_enter_new_pin);
                } else {
                    handleWrongPin();
                }
                break;
        }
    }

    public int getType() {
        return mType;
    }

    private void setPin(String pin) {
        if (DEBUG) Log.d(TAG, "setPin: " + pin);
        mPin = pin;
        mSharedPreferences.edit().putString(TvSettings.PREF_PIN, pin).apply();
    }

    private String getPin() {
        if (mPin == null) {
            mPin = mSharedPreferences.getString(TvSettings.PREF_PIN, "");
        }
        return mPin;
    }

    private String getPinInput() {
        String result = "";
        try {
            for (PinNumberPicker pnp : mPickers) {
                pnp.updateText();
                result += pnp.getValue();
            }
        } catch (IllegalStateException e) {
            result = "";
        }
        return result;
    }

    private void resetPinInput() {
        for (PinNumberPicker pnp : mPickers) {
            pnp.setValueRangeAndResetText(0, 9);
        }
        mPickers[0].requestFocus();
    }

    public static class PinNumberPicker extends FrameLayout {
        private static final int NUMBER_VIEWS_RES_ID[] = {
            R.id.previous2_number,
            R.id.previous_number,
            R.id.current_number,
            R.id.next_number,
            R.id.next2_number };
        private static final int CURRENT_NUMBER_VIEW_INDEX = 2;
        private static final int NOT_INITIALIZED = Integer.MIN_VALUE;

        private static Animator sFocusedNumberEnterAnimator;
        private static Animator sFocusedNumberExitAnimator;
        private static Animator sAdjacentNumberEnterAnimator;
        private static Animator sAdjacentNumberExitAnimator;

        private static float sAlphaForFocusedNumber;
        private static float sAlphaForAdjacentNumber;

        private int mMinValue;
        private int mMaxValue;
        private int mCurrentValue;
        // a value for setting mCurrentValue at the end of scroll animation.
        private int mNextValue;
        private final int mNumberViewHeight;
        private PinDialogFragment mDialog;
        private PinNumberPicker mNextNumberPicker;
        private boolean mCancelAnimation;

        private final View mNumberViewHolder;
        // When the PinNumberPicker has focus, mBackgroundView will show the focused background.
        // Also, this view is used for handling the text change animation of the current number
        // view which is required when the current number view text is changing from INITIAL_TEXT
        // to "0".
        private final TextView mBackgroundView;
        private final TextView[] mNumberViews;
        private final AnimatorSet mFocusGainAnimator;
        private final AnimatorSet mFocusLossAnimator;
        private final AnimatorSet mScrollAnimatorSet;

        public PinNumberPicker(Context context) {
            this(context, null);
        }

        public PinNumberPicker(Context context, AttributeSet attrs) {
            this(context, attrs, 0);
        }

        public PinNumberPicker(Context context, AttributeSet attrs, int defStyleAttr) {
            this(context, attrs, defStyleAttr, 0);
        }

        public PinNumberPicker(Context context, AttributeSet attrs, int defStyleAttr,
                int defStyleRes) {
            super(context, attrs, defStyleAttr, defStyleRes);
            View view = inflate(context, R.layout.pin_number_picker, this);
            mNumberViewHolder = view.findViewById(R.id.number_view_holder);
            mBackgroundView = (TextView) view.findViewById(R.id.focused_background);
            mNumberViews = new TextView[NUMBER_VIEWS_RES_ID.length];
            for (int i = 0; i < NUMBER_VIEWS_RES_ID.length; ++i) {
                mNumberViews[i] = (TextView) view.findViewById(NUMBER_VIEWS_RES_ID[i]);
            }
            Resources resources = context.getResources();
            mNumberViewHeight = resources.getDimensionPixelSize(
                    R.dimen.pin_number_picker_text_view_height);

            mNumberViewHolder.setOnFocusChangeListener(new OnFocusChangeListener() {
                @Override
                public void onFocusChange(View v, boolean hasFocus) {
                    updateFocus(true);
                }
            });

            mNumberViewHolder.setOnKeyListener(new OnKeyListener() {
                @Override
                public boolean onKey(View v, int keyCode, KeyEvent event) {
                    if (event.getAction() == KeyEvent.ACTION_DOWN) {
                        switch (keyCode) {
                            case KeyEvent.KEYCODE_DPAD_UP:
                            case KeyEvent.KEYCODE_DPAD_DOWN: {
                                if (mCancelAnimation) {
                                    mScrollAnimatorSet.end();
                                }
                                if (!mScrollAnimatorSet.isRunning()) {
                                    mCancelAnimation = false;
                                    if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {
                                        mNextValue = adjustValueInValidRange(mCurrentValue + 1);
                                        startScrollAnimation(true);
                                    } else {
                                        mNextValue = adjustValueInValidRange(mCurrentValue - 1);
                                        startScrollAnimation(false);
                                    }
                                }
                                return true;
                            }
                        }
                    } else if (event.getAction() == KeyEvent.ACTION_UP) {
                        switch (keyCode) {
                            case KeyEvent.KEYCODE_DPAD_UP:
                            case KeyEvent.KEYCODE_DPAD_DOWN: {
                                mCancelAnimation = true;
                                return true;
                            }
                        }
                    }
                    return false;
                }
            });
            mNumberViewHolder.setScrollY(mNumberViewHeight);

            mFocusGainAnimator = new AnimatorSet();
            mFocusGainAnimator.playTogether(
                    ObjectAnimator.ofFloat(mNumberViews[CURRENT_NUMBER_VIEW_INDEX - 1],
                            "alpha", 0f, sAlphaForAdjacentNumber),
                    ObjectAnimator.ofFloat(mNumberViews[CURRENT_NUMBER_VIEW_INDEX],
                            "alpha", sAlphaForFocusedNumber, 0f),
                    ObjectAnimator.ofFloat(mNumberViews[CURRENT_NUMBER_VIEW_INDEX + 1],
                            "alpha", 0f, sAlphaForAdjacentNumber),
                    ObjectAnimator.ofFloat(mBackgroundView, "alpha", 0f, 1f));
            mFocusGainAnimator.setDuration(context.getResources().getInteger(
                    android.R.integer.config_shortAnimTime));
            mFocusGainAnimator.addListener(new AnimatorListenerAdapter() {
                @Override
                public void onAnimationEnd(Animator animator) {
                    mNumberViews[CURRENT_NUMBER_VIEW_INDEX].setText(mBackgroundView.getText());
                    mNumberViews[CURRENT_NUMBER_VIEW_INDEX].setAlpha(sAlphaForFocusedNumber);
                    mBackgroundView.setText("");
                }
            });

            mFocusLossAnimator = new AnimatorSet();
            mFocusLossAnimator.playTogether(
                    ObjectAnimator.ofFloat(mNumberViews[CURRENT_NUMBER_VIEW_INDEX - 1],
                            "alpha", sAlphaForAdjacentNumber, 0f),
                    ObjectAnimator.ofFloat(mNumberViews[CURRENT_NUMBER_VIEW_INDEX + 1],
                            "alpha", sAlphaForAdjacentNumber, 0f),
                    ObjectAnimator.ofFloat(mBackgroundView, "alpha", 1f, 0f));
            mFocusLossAnimator.setDuration(context.getResources().getInteger(
                    android.R.integer.config_shortAnimTime));

            mScrollAnimatorSet = new AnimatorSet();
            mScrollAnimatorSet.setDuration(context.getResources().getInteger(
                    R.integer.pin_number_scroll_duration));
            mScrollAnimatorSet.addListener(new AnimatorListenerAdapter() {
                @Override
                public void onAnimationEnd(Animator animation) {
                    // Set mCurrent value when scroll animation is finished.
                    mCurrentValue = mNextValue;
                    updateText();
                    mNumberViewHolder.setScrollY(mNumberViewHeight);
                    mNumberViews[CURRENT_NUMBER_VIEW_INDEX - 1].setAlpha(sAlphaForAdjacentNumber);
                    mNumberViews[CURRENT_NUMBER_VIEW_INDEX].setAlpha(sAlphaForFocusedNumber);
                    mNumberViews[CURRENT_NUMBER_VIEW_INDEX + 1].setAlpha(sAlphaForAdjacentNumber);
                }
            });
        }

        static void loadResources(Context context) {
            if (sFocusedNumberEnterAnimator == null) {
                TypedValue outValue = new TypedValue();
                context.getResources().getValue(
                        R.dimen.pin_alpha_for_focused_number, outValue, true);
                sAlphaForFocusedNumber = outValue.getFloat();
                context.getResources().getValue(
                        R.dimen.pin_alpha_for_adjacent_number, outValue, true);
                sAlphaForAdjacentNumber = outValue.getFloat();

                sFocusedNumberEnterAnimator = AnimatorInflater.loadAnimator(context,
                        R.animator.pin_focused_number_enter);
                sFocusedNumberExitAnimator = AnimatorInflater.loadAnimator(context,
                        R.animator.pin_focused_number_exit);
                sAdjacentNumberEnterAnimator = AnimatorInflater.loadAnimator(context,
                        R.animator.pin_adjacent_number_enter);
                sAdjacentNumberExitAnimator = AnimatorInflater.loadAnimator(context,
                        R.animator.pin_adjacent_number_exit);
            }
        }

        @Override
        public boolean dispatchKeyEvent(KeyEvent event) {
            if (event.getAction() == KeyEvent.ACTION_UP) {
                int keyCode = event.getKeyCode();
                if (keyCode >= KeyEvent.KEYCODE_0 && keyCode <= KeyEvent.KEYCODE_9) {
                    mNextValue = adjustValueInValidRange(keyCode - KeyEvent.KEYCODE_0);
                    updateFocus(false);
                } else if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER
                        || keyCode == KeyEvent.KEYCODE_ENTER) {
                    if (mNextNumberPicker == null) {
                        String pin = mDialog.getPinInput();
                        if (!TextUtils.isEmpty(pin)) {
                            mDialog.done(pin);
                        }
                    } else {
                        mNextNumberPicker.requestFocus();
                    }
                    return true;
                }
            }
            return super.dispatchKeyEvent(event);
        }

        void startScrollAnimation(boolean scrollUp) {
            mFocusGainAnimator.end();
            mFocusLossAnimator.end();
            final ValueAnimator scrollAnimator = ValueAnimator.ofInt(
                    0, scrollUp ? mNumberViewHeight : -mNumberViewHeight);
            scrollAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
                @Override
                public void onAnimationUpdate(ValueAnimator animation) {
                    int value = (Integer) animation.getAnimatedValue();
                    mNumberViewHolder.setScrollY(value + mNumberViewHeight);
                }
            });
            scrollAnimator.setDuration(
                    getResources().getInteger(R.integer.pin_number_scroll_duration));

            if (scrollUp) {
                sAdjacentNumberExitAnimator.setTarget(mNumberViews[CURRENT_NUMBER_VIEW_INDEX - 1]);
                sFocusedNumberExitAnimator.setTarget(mNumberViews[CURRENT_NUMBER_VIEW_INDEX]);
                sFocusedNumberEnterAnimator.setTarget(mNumberViews[CURRENT_NUMBER_VIEW_INDEX + 1]);
                sAdjacentNumberEnterAnimator.setTarget(mNumberViews[CURRENT_NUMBER_VIEW_INDEX + 2]);
            } else {
                sAdjacentNumberEnterAnimator.setTarget(mNumberViews[CURRENT_NUMBER_VIEW_INDEX - 2]);
                sFocusedNumberEnterAnimator.setTarget(mNumberViews[CURRENT_NUMBER_VIEW_INDEX - 1]);
                sFocusedNumberExitAnimator.setTarget(mNumberViews[CURRENT_NUMBER_VIEW_INDEX]);
                sAdjacentNumberExitAnimator.setTarget(mNumberViews[CURRENT_NUMBER_VIEW_INDEX + 1]);
            }

            mScrollAnimatorSet.playTogether(scrollAnimator,
                    sAdjacentNumberExitAnimator, sFocusedNumberExitAnimator,
                    sFocusedNumberEnterAnimator, sAdjacentNumberEnterAnimator);
            mScrollAnimatorSet.start();
        }

        void setValueRangeAndResetText(int min, int max) {
            if (min > max) {
                throw new IllegalArgumentException(
                        "The min value should be greater than or equal to the max value");
            } else if (min == NOT_INITIALIZED) {
                throw new IllegalArgumentException(
                        "The min value should be greater than Integer.MIN_VALUE.");
            }
            mMinValue = min;
            mMaxValue = max;
            mNextValue = mCurrentValue = NOT_INITIALIZED;
            for (int i = 0; i < NUMBER_VIEWS_RES_ID.length; ++i) {
                mNumberViews[i].setText(i == CURRENT_NUMBER_VIEW_INDEX ? INITIAL_TEXT : "");
            }
            mBackgroundView.setText(INITIAL_TEXT);
        }

        void setPinDialogFragment(PinDialogFragment dlg) {
            mDialog = dlg;
        }

        void setNextNumberPicker(PinNumberPicker picker) {
            mNextNumberPicker = picker;
        }

        int getValue() {
            if (mCurrentValue < mMinValue || mCurrentValue > mMaxValue) {
                throw new IllegalStateException("Value is not set");
            }
            return mCurrentValue;
        }

        void updateFocus(boolean withAnimation) {
            mScrollAnimatorSet.end();
            mFocusGainAnimator.end();
            mFocusLossAnimator.end();
            updateText();
            if (mNumberViewHolder.isFocused()) {
                if (withAnimation) {
                    mBackgroundView.setText(String.valueOf(mCurrentValue));
                    mFocusGainAnimator.start();
                } else {
                    mBackgroundView.setAlpha(1f);
                    mNumberViews[CURRENT_NUMBER_VIEW_INDEX - 1].setAlpha(sAlphaForAdjacentNumber);
                    mNumberViews[CURRENT_NUMBER_VIEW_INDEX + 1].setAlpha(sAlphaForAdjacentNumber);
                }
            } else {
                if (withAnimation) {
                    mFocusLossAnimator.start();
                } else {
                    mBackgroundView.setAlpha(0f);
                    mNumberViews[CURRENT_NUMBER_VIEW_INDEX - 1].setAlpha(0f);
                    mNumberViews[CURRENT_NUMBER_VIEW_INDEX + 1].setAlpha(0f);
                }
                mNumberViewHolder.setScrollY(mNumberViewHeight);
            }
        }

        private void updateText() {
            boolean wasNotInitialized = false;
            if (mNumberViewHolder.isFocused() && mCurrentValue == NOT_INITIALIZED) {
                mNextValue = mCurrentValue = mMinValue;
                wasNotInitialized = true;
            }
            if (mCurrentValue >= mMinValue && mCurrentValue <= mMaxValue) {
                for (int i = 0; i < NUMBER_VIEWS_RES_ID.length; ++i) {
                    if (wasNotInitialized && i == CURRENT_NUMBER_VIEW_INDEX) {
                        // In order to show the text change animation, keep the text of
                        // mNumberViews[CURRENT_NUMBER_VIEW_INDEX].
                    } else {
                        mNumberViews[i].setText(String.valueOf(adjustValueInValidRange(
                                mCurrentValue - CURRENT_NUMBER_VIEW_INDEX + i)));
                    }
                }
            }
        }

        private int adjustValueInValidRange(int value) {
            int interval = mMaxValue - mMinValue + 1;
            if (value < mMinValue - interval || value > mMaxValue + interval) {
                throw new IllegalArgumentException("The value( " + value
                        + ") is too small or too big to adjust");
            }
            return (value < mMinValue) ? value + interval
                    : (value > mMaxValue) ? value - interval : value;
        }
    }

    /**
     * A listener to the result of {@link PinDialogFragment}. Any activity requiring pin code
     * checking should implement this listener to receive the result.
     */
    public interface OnPinCheckedListener {
        /**
         * Called when {@link PinDialogFragment} is dismissed.
         *
         * @param checked {@code true} if the pin code entered is checked to be correct,
         *                otherwise {@code false}.
         * @param type The dialog type regarding to what pin entering is for.
         * @param rating The target rating to unblock for.
         */
        void onPinChecked(boolean checked, int type, String rating);
    }
}