Home | History | Annotate | Download | only in widget 
      1 /*
      2  * Copyright (C) 2017 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package android.widget;
     18 
     19 import android.content.Context;
     20 import android.text.Editable;
     21 import android.text.InputFilter;
     22 import android.text.TextWatcher;
     23 import android.util.AttributeSet;
     24 import android.util.MathUtils;
     25 import android.view.View;
     26 
     27 import com.android.internal.R;
     28 
     29 /**
     30  * View to show text input based time picker with hour and minute fields and an optional AM/PM
     31  * spinner.
     32  *
     33  * @hide
     34  */
     35 public class TextInputTimePickerView extends RelativeLayout {
     36     public static final int HOURS = 0;
     37     public static final int MINUTES = 1;
     38     public static final int AMPM = 2;
     39 
     40     private static final int AM = 0;
     41     private static final int PM = 1;
     42 
     43     private final EditText mHourEditText;
     44     private final EditText mMinuteEditText;
     45     private final TextView mInputSeparatorView;
     46     private final Spinner mAmPmSpinner;
     47     private final TextView mErrorLabel;
     48     private final TextView mHourLabel;
     49     private final TextView mMinuteLabel;
     50 
     51     private boolean mIs24Hour;
     52     private boolean mHourFormatStartsAtZero;
     53     private OnValueTypedListener mListener;
     54 
     55     private boolean mErrorShowing;
     56 
     57     interface OnValueTypedListener {
     58         void onValueChanged(int inputType, int newValue);
     59     }
     60 
     61     public TextInputTimePickerView(Context context) {
     62         this(context, null);
     63     }
     64 
     65     public TextInputTimePickerView(Context context, AttributeSet attrs) {
     66         this(context, attrs, 0);
     67     }
     68 
     69     public TextInputTimePickerView(Context context, AttributeSet attrs, int defStyle) {
     70         this(context, attrs, defStyle, 0);
     71     }
     72 
     73     public TextInputTimePickerView(Context context, AttributeSet attrs, int defStyle,
     74             int defStyleRes) {
     75         super(context, attrs, defStyle, defStyleRes);
     76 
     77         inflate(context, R.layout.time_picker_text_input_material, this);
     78 
     79         mHourEditText = findViewById(R.id.input_hour);
     80         mMinuteEditText = findViewById(R.id.input_minute);
     81         mInputSeparatorView = findViewById(R.id.input_separator);
     82         mErrorLabel = findViewById(R.id.label_error);
     83         mHourLabel = findViewById(R.id.label_hour);
     84         mMinuteLabel = findViewById(R.id.label_minute);
     85 
     86         mHourEditText.addTextChangedListener(new TextWatcher() {
     87             @Override
     88             public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {}
     89 
     90             @Override
     91             public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {}
     92 
     93             @Override
     94             public void afterTextChanged(Editable editable) {
     95                 parseAndSetHourInternal(editable.toString());
     96             }
     97         });
     98 
     99         mMinuteEditText.addTextChangedListener(new TextWatcher() {
    100             @Override
    101             public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {}
    102 
    103             @Override
    104             public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {}
    105 
    106             @Override
    107             public void afterTextChanged(Editable editable) {
    108                 parseAndSetMinuteInternal(editable.toString());
    109             }
    110         });
    111 
    112         mAmPmSpinner = findViewById(R.id.am_pm_spinner);
    113         final String[] amPmStrings = TimePicker.getAmPmStrings(context);
    114         ArrayAdapter<CharSequence> adapter =
    115                 new ArrayAdapter<CharSequence>(context, R.layout.simple_spinner_dropdown_item);
    116         adapter.add(TimePickerClockDelegate.obtainVerbatim(amPmStrings[0]));
    117         adapter.add(TimePickerClockDelegate.obtainVerbatim(amPmStrings[1]));
    118         mAmPmSpinner.setAdapter(adapter);
    119         mAmPmSpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
    120             @Override
    121             public void onItemSelected(AdapterView<?> adapterView, View view, int position,
    122                     long id) {
    123                 if (position == 0) {
    124                     mListener.onValueChanged(AMPM, AM);
    125                 } else {
    126                     mListener.onValueChanged(AMPM, PM);
    127                 }
    128             }
    129 
    130             @Override
    131             public void onNothingSelected(AdapterView<?> adapterView) {}
    132         });
    133     }
    134 
    135     void setListener(OnValueTypedListener listener) {
    136         mListener = listener;
    137     }
    138 
    139     void setHourFormat(int maxCharLength) {
    140         mHourEditText.setFilters(new InputFilter[] {
    141                 new InputFilter.LengthFilter(maxCharLength)});
    142         mMinuteEditText.setFilters(new InputFilter[] {
    143                 new InputFilter.LengthFilter(maxCharLength)});
    144     }
    145 
    146     boolean validateInput() {
    147         final boolean inputValid = parseAndSetHourInternal(mHourEditText.getText().toString())
    148                 && parseAndSetMinuteInternal(mMinuteEditText.getText().toString());
    149         setError(!inputValid);
    150         return inputValid;
    151     }
    152 
    153     void updateSeparator(String separatorText) {
    154         mInputSeparatorView.setText(separatorText);
    155     }
    156 
    157     private void setError(boolean enabled) {
    158         mErrorShowing = enabled;
    159 
    160         mErrorLabel.setVisibility(enabled ? View.VISIBLE : View.INVISIBLE);
    161         mHourLabel.setVisibility(enabled ? View.INVISIBLE : View.VISIBLE);
    162         mMinuteLabel.setVisibility(enabled ? View.INVISIBLE : View.VISIBLE);
    163     }
    164 
    165     /**
    166      * Computes the display value and updates the text of the view.
    167      * <p>
    168      * This method should be called whenever the current value or display
    169      * properties (leading zeroes, max digits) change.
    170      */
    171     void updateTextInputValues(int localizedHour, int minute, int amOrPm, boolean is24Hour,
    172             boolean hourFormatStartsAtZero) {
    173         final String format = "%d";
    174 
    175         mIs24Hour = is24Hour;
    176         mHourFormatStartsAtZero = hourFormatStartsAtZero;
    177 
    178         mAmPmSpinner.setVisibility(is24Hour ? View.INVISIBLE : View.VISIBLE);
    179 
    180         if (amOrPm == AM) {
    181             mAmPmSpinner.setSelection(0);
    182         } else {
    183             mAmPmSpinner.setSelection(1);
    184         }
    185 
    186         mHourEditText.setText(String.format(format, localizedHour));
    187         mMinuteEditText.setText(String.format(format, minute));
    188 
    189         if (mErrorShowing) {
    190             validateInput();
    191         }
    192     }
    193 
    194     private boolean parseAndSetHourInternal(String input) {
    195         try {
    196             final int hour = Integer.parseInt(input);
    197             if (!isValidLocalizedHour(hour)) {
    198                 final int minHour = mHourFormatStartsAtZero ? 0 : 1;
    199                 final int maxHour = mIs24Hour ? 23 : 11 + minHour;
    200                 mListener.onValueChanged(HOURS, getHourOfDayFromLocalizedHour(
    201                         MathUtils.constrain(hour, minHour, maxHour)));
    202                 return false;
    203             }
    204             mListener.onValueChanged(HOURS, getHourOfDayFromLocalizedHour(hour));
    205             return true;
    206         } catch (NumberFormatException e) {
    207             // Do nothing since we cannot parse the input.
    208             return false;
    209         }
    210     }
    211 
    212     private boolean parseAndSetMinuteInternal(String input) {
    213         try {
    214             final int minutes = Integer.parseInt(input);
    215             if (minutes < 0 || minutes > 59) {
    216                 mListener.onValueChanged(MINUTES, MathUtils.constrain(minutes, 0, 59));
    217                 return false;
    218             }
    219             mListener.onValueChanged(MINUTES, minutes);
    220             return true;
    221         } catch (NumberFormatException e) {
    222             // Do nothing since we cannot parse the input.
    223             return false;
    224         }
    225     }
    226 
    227     private boolean isValidLocalizedHour(int localizedHour) {
    228         final int minHour = mHourFormatStartsAtZero ? 0 : 1;
    229         final int maxHour = (mIs24Hour ? 23 : 11) + minHour;
    230         return localizedHour >= minHour && localizedHour <= maxHour;
    231     }
    232 
    233     private int getHourOfDayFromLocalizedHour(int localizedHour) {
    234         int hourOfDay = localizedHour;
    235         if (mIs24Hour) {
    236             if (!mHourFormatStartsAtZero && localizedHour == 24) {
    237                 hourOfDay = 0;
    238             }
    239         } else {
    240             if (!mHourFormatStartsAtZero && localizedHour == 12) {
    241                 hourOfDay = 0;
    242             }
    243             if (mAmPmSpinner.getSelectedItemPosition() == 1) {
    244                 hourOfDay += 12;
    245             }
    246         }
    247         return hourOfDay;
    248     }
    249 }
    250