/*
* Copyright (C) 2007 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 android.widget;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.Widget;
import android.content.Context;
import android.content.res.Configuration;
import android.content.res.TypedArray;
import android.os.Parcelable;
import android.util.AttributeSet;
import android.view.accessibility.AccessibilityEvent;
import com.android.internal.R;
import java.util.Locale;
/**
* A widget for selecting the time of day, in either 24-hour or AM/PM mode.
* <p>
* For a dialog using this view, see {@link android.app.TimePickerDialog}. See
* the <a href="{@docRoot}guide/topics/ui/controls/pickers.html">Pickers</a>
* guide for more information.
*
* @attr ref android.R.styleable#TimePicker_timePickerMode
*/
@Widget
public class TimePicker extends FrameLayout {
private static final int MODE_SPINNER = 1;
private static final int MODE_CLOCK = 2;
private final TimePickerDelegate mDelegate;
/**
* The callback interface used to indicate the time has been adjusted.
*/
public interface OnTimeChangedListener {
/**
* @param view The view associated with this listener.
* @param hourOfDay The current hour.
* @param minute The current minute.
*/
void onTimeChanged(TimePicker view, int hourOfDay, int minute);
}
public TimePicker(Context context) {
this(context, null);
}
public TimePicker(Context context, AttributeSet attrs) {
this(context, attrs, R.attr.timePickerStyle);
}
public TimePicker(Context context, AttributeSet attrs, int defStyleAttr) {
this(context, attrs, defStyleAttr, 0);
}
public TimePicker(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
final TypedArray a = context.obtainStyledAttributes(
attrs, R.styleable.TimePicker, defStyleAttr, defStyleRes);
final int mode = a.getInt(R.styleable.TimePicker_timePickerMode, MODE_SPINNER);
a.recycle();
switch (mode) {
case MODE_CLOCK:
mDelegate = new TimePickerClockDelegate(
this, context, attrs, defStyleAttr, defStyleRes);
break;
case MODE_SPINNER:
default:
mDelegate = new TimePickerSpinnerDelegate(
this, context, attrs, defStyleAttr, defStyleRes);
break;
}
}
/**
* Sets the currently selected hour using 24-hour time.
*
* @param hour the hour to set, in the range (0-23)
* @see #getHour()
*/
public void setHour(int hour) {
mDelegate.setCurrentHour(hour);
}
/**
* Returns the currently selected hour using 24-hour time.
*
* @return the currently selected hour, in the range (0-23)
* @see #setHour(int)
*/
public int getHour() {
return mDelegate.getCurrentHour();
}
/**
* Sets the currently selected minute..
*
* @param minute the minute to set, in the range (0-59)
* @see #getMinute()
*/
public void setMinute(int minute) {
mDelegate.setCurrentMinute(minute);
}
/**
* Returns the currently selected minute.
*
* @return the currently selected minute, in the range (0-59)
* @see #setMinute(int)
*/
public int getMinute() {
return mDelegate.getCurrentMinute();
}
/**
* Sets the current hour.
*
* @deprecated Use {@link #setHour(int)}
*/
@Deprecated
public void setCurrentHour(@NonNull Integer currentHour) {
setHour(currentHour);
}
/**
* @return the current hour in the range (0-23)
* @deprecated Use {@link #getHour()}
*/
@NonNull
@Deprecated
public Integer getCurrentHour() {
return mDelegate.getCurrentHour();
}
/**
* Set the current minute (0-59).
*
* @deprecated Use {@link #setMinute(int)}
*/
@Deprecated
public void setCurrentMinute(@NonNull Integer currentMinute) {
mDelegate.setCurrentMinute(currentMinute);
}
/**
* @return the current minute
* @deprecated Use {@link #getMinute()}
*/
@NonNull
@Deprecated
public Integer getCurrentMinute() {
return mDelegate.getCurrentMinute();
}
/**
* Sets whether this widget displays time in 24-hour mode or 12-hour mode
* with an AM/PM picker.
*
* @param is24HourView {@code true} to display in 24-hour mode,
* {@code false} for 12-hour mode with AM/PM
* @see #is24HourView()
*/
public void setIs24HourView(@NonNull Boolean is24HourView) {
if (is24HourView == null) {
return;
}
mDelegate.setIs24HourView(is24HourView);
}
/**
* @return {@code true} if this widget displays time in 24-hour mode,
* {@code false} otherwise}
* @see #setIs24HourView(Boolean)
*/
public boolean is24HourView() {
return mDelegate.is24HourView();
}
/**
* Set the callback that indicates the time has been adjusted by the user.
*
* @param onTimeChangedListener the callback, should not be null.
*/
public void setOnTimeChangedListener(OnTimeChangedListener onTimeChangedListener) {
mDelegate.setOnTimeChangedListener(onTimeChangedListener);
}
/**
* Sets the callback that indicates the current time is valid.
*
* @param callback the callback, may be null
* @hide
*/
public void setValidationCallback(@Nullable ValidationCallback callback) {
mDelegate.setValidationCallback(callback);
}
@Override
public void setEnabled(boolean enabled) {
super.setEnabled(enabled);
mDelegate.setEnabled(enabled);
}
@Override
public boolean isEnabled() {
return mDelegate.isEnabled();
}
@Override
public int getBaseline() {
return mDelegate.getBaseline();
}
@Override
protected void onConfigurationChanged(Configuration newConfig) {
super.onConfigurationChanged(newConfig);
mDelegate.onConfigurationChanged(newConfig);
}
@Override
protected Parcelable onSaveInstanceState() {
Parcelable superState = super.onSaveInstanceState();
return mDelegate.onSaveInstanceState(superState);
}
@Override
protected void onRestoreInstanceState(Parcelable state) {
BaseSavedState ss = (BaseSavedState) state;
super.onRestoreInstanceState(ss.getSuperState());
mDelegate.onRestoreInstanceState(ss);
}
@Override
public CharSequence getAccessibilityClassName() {
return TimePicker.class.getName();
}
/** @hide */
@Override
public boolean dispatchPopulateAccessibilityEventInternal(AccessibilityEvent event) {
return mDelegate.dispatchPopulateAccessibilityEvent(event);
}
/**
* A delegate interface that defined the public API of the TimePicker. Allows different
* TimePicker implementations. This would need to be implemented by the TimePicker delegates
* for the real behavior.
*/
interface TimePickerDelegate {
void setCurrentHour(int currentHour);
int getCurrentHour();
void setCurrentMinute(int currentMinute);
int getCurrentMinute();
void setIs24HourView(boolean is24HourView);
boolean is24HourView();
void setOnTimeChangedListener(OnTimeChangedListener onTimeChangedListener);
void setValidationCallback(ValidationCallback callback);
void setEnabled(boolean enabled);
boolean isEnabled();
int getBaseline();
void onConfigurationChanged(Configuration newConfig);
Parcelable onSaveInstanceState(Parcelable superState);
void onRestoreInstanceState(Parcelable state);
boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event);
void onPopulateAccessibilityEvent(AccessibilityEvent event);
}
/**
* A callback interface for updating input validity when the TimePicker
* when included into a Dialog.
*
* @hide
*/
public static interface ValidationCallback {
void onValidationChanged(boolean valid);
}
/**
* An abstract class which can be used as a start for TimePicker implementations
*/
abstract static class AbstractTimePickerDelegate implements TimePickerDelegate {
// The delegator
protected TimePicker mDelegator;
// The context
protected Context mContext;
// The current locale
protected Locale mCurrentLocale;
// Callbacks
protected OnTimeChangedListener mOnTimeChangedListener;
protected ValidationCallback mValidationCallback;
public AbstractTimePickerDelegate(TimePicker delegator, Context context) {
mDelegator = delegator;
mContext = context;
// initialization based on locale
setCurrentLocale(Locale.getDefault());
}
public void setCurrentLocale(Locale locale) {
if (locale.equals(mCurrentLocale)) {
return;
}
mCurrentLocale = locale;
}
@Override
public void setValidationCallback(ValidationCallback callback) {
mValidationCallback = callback;
}
protected void onValidationChanged(boolean valid) {
if (mValidationCallback != null) {
mValidationCallback.onValidationChanged(valid);
}
}
}
}