Flatten uhabits-android into a single gradle module

uhabits-android/src/main/java/com/android/colorpicker/ColorPickerDialog.java

@@ -0,0 +1,204 @@
+/*
+ * Copyright (C) 2013 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.colorpicker;
+
+import android.app.Activity;
+import android.app.Dialog;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.ProgressBar;
+
+import androidx.appcompat.app.AlertDialog;
+import androidx.appcompat.app.AppCompatDialogFragment;
+
+import com.android.colorpicker.ColorPickerSwatch.OnColorSelectedListener;
+
+import org.isoron.uhabits.R;
+
+/**
+ * A dialog which takes in as input an array of palette and creates a palette allowing the user to
+ * select a specific color swatch, which invokes a listener.
+ */
+public class ColorPickerDialog extends AppCompatDialogFragment implements OnColorSelectedListener {
+
+    public static final int SIZE_LARGE = 1;
+    public static final int SIZE_SMALL = 2;
+
+    protected AlertDialog mAlertDialog;
+
+    protected static final String KEY_TITLE_ID = "title_id";
+    protected static final String KEY_COLORS = "palette";
+    protected static final String KEY_SELECTED_COLOR = "selected_color";
+    protected static final String KEY_COLUMNS = "columns";
+    protected static final String KEY_SIZE = "size";
+
+    protected int mTitleResId = R.string.color_picker_default_title;
+    protected int[] mColors = null;
+    protected int mSelectedColor;
+    protected int mColumns;
+    protected int mSize;
+
+    private ColorPickerPalette mPalette;
+    private ProgressBar mProgress;
+
+    protected OnColorSelectedListener mListener;
+
+    public ColorPickerDialog() {
+        // Empty constructor required for dialog fragments.
+    }
+
+    public static ColorPickerDialog newInstance(int titleResId, int[] colors, int selectedColor,
+            int columns, int size) {
+        ColorPickerDialog ret = new ColorPickerDialog();
+        ret.initialize(titleResId, colors, selectedColor, columns, size);
+        return ret;
+    }
+
+    public void initialize(int titleResId, int[] colors, int selectedColor, int columns, int size) {
+        setArguments(titleResId, columns, size);
+        setColors(colors, selectedColor);
+    }
+
+    public void setArguments(int titleResId, int columns, int size) {
+        Bundle bundle = new Bundle();
+        bundle.putInt(KEY_TITLE_ID, titleResId);
+        bundle.putInt(KEY_COLUMNS, columns);
+        bundle.putInt(KEY_SIZE, size);
+        setArguments(bundle);
+    }
+
+    public void setOnColorSelectedListener(OnColorSelectedListener listener) {
+        mListener = listener;
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        if (getArguments() != null) {
+            mTitleResId = getArguments().getInt(KEY_TITLE_ID);
+            mColumns = getArguments().getInt(KEY_COLUMNS);
+            mSize = getArguments().getInt(KEY_SIZE);
+        }
+
+        if (savedInstanceState != null) {
+            mColors = savedInstanceState.getIntArray(KEY_COLORS);
+            mSelectedColor = (Integer) savedInstanceState.getSerializable(KEY_SELECTED_COLOR);
+        }
+    }
+
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        final Activity activity = getActivity();
+
+        View view = LayoutInflater.from(getActivity()).inflate(R.layout.color_picker_dialog, null);
+        mProgress = (ProgressBar) view.findViewById(android.R.id.progress);
+        mPalette = (ColorPickerPalette) view.findViewById(R.id.color_picker);
+        mPalette.init(mSize, mColumns, this);
+
+        if (mColors != null) {
+            showPaletteView();
+        }
+
+        mAlertDialog = new AlertDialog.Builder(activity)
+            .setTitle(mTitleResId)
+            .setView(view)
+            .create();
+
+        return mAlertDialog;
+    }
+
+    @Override
+    public void onColorSelected(int color) {
+        if (mListener != null) {
+            mListener.onColorSelected(color);
+        }
+
+        if (getTargetFragment() instanceof OnColorSelectedListener) {
+            final OnColorSelectedListener listener =
+                    (OnColorSelectedListener) getTargetFragment();
+            listener.onColorSelected(color);
+        }
+
+        if (color != mSelectedColor) {
+            mSelectedColor = color;
+            // Redraw palette to show checkmark on newly selected color before dismissing.
+            mPalette.drawPalette(mColors, mSelectedColor);
+        }
+
+        dismiss();
+    }
+
+    public void showPaletteView() {
+        if (mProgress != null && mPalette != null) {
+            mProgress.setVisibility(View.GONE);
+            refreshPalette();
+            mPalette.setVisibility(View.VISIBLE);
+        }
+    }
+
+    public void showProgressBarView() {
+        if (mProgress != null && mPalette != null) {
+            mProgress.setVisibility(View.VISIBLE);
+            mPalette.setVisibility(View.GONE);
+        }
+    }
+
+    public void setColors(int[] colors, int selectedColor) {
+        if (mColors != colors || mSelectedColor != selectedColor) {
+            mColors = colors;
+            mSelectedColor = selectedColor;
+            refreshPalette();
+        }
+    }
+
+    public void setColors(int[] colors) {
+        if (mColors != colors) {
+            mColors = colors;
+            refreshPalette();
+        }
+    }
+
+    public void setSelectedColor(int color) {
+        if (mSelectedColor != color) {
+            mSelectedColor = color;
+            refreshPalette();
+        }
+    }
+
+    private void refreshPalette() {
+        if (mPalette != null && mColors != null) {
+            mPalette.drawPalette(mColors, mSelectedColor);
+        }
+    }
+
+    public int[] getColors() {
+        return mColors;
+    }
+
+    public int getSelectedColor() {
+        return mSelectedColor;
+    }
+
+    @Override
+    public void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        outState.putIntArray(KEY_COLORS, mColors);
+        outState.putSerializable(KEY_SELECTED_COLOR, mSelectedColor);
+    }
+}

uhabits-android/src/main/java/com/android/colorpicker/ColorPickerPalette.java

@@ -0,0 +1,186 @@
+/*
+ * Copyright (C) 2013 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.colorpicker;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.util.AttributeSet;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.TableLayout;
+import android.widget.TableRow;
+
+import com.android.colorpicker.ColorPickerSwatch.OnColorSelectedListener;
+
+import org.isoron.uhabits.R;
+
+/**
+ * A color picker custom view which creates an grid of color squares.  The number of squares per
+ * row (and the padding between the squares) is determined by the user.
+ */
+public class ColorPickerPalette extends TableLayout {
+
+    public OnColorSelectedListener mOnColorSelectedListener;
+
+    private String mDescription;
+    private String mDescriptionSelected;
+
+    private int mSwatchLength;
+    private int mMarginSize;
+    private int mNumColumns;
+
+    public ColorPickerPalette(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public ColorPickerPalette(Context context) {
+        super(context);
+    }
+
+    /**
+     * Initialize the size, columns, and listener.  Size should be a pre-defined size (SIZE_LARGE
+     * or SIZE_SMALL) from ColorPickerDialogFragment.
+     */
+    public void init(int size, int columns, OnColorSelectedListener listener) {
+        mNumColumns = columns;
+        Resources res = getResources();
+        if (size == ColorPickerDialog.SIZE_LARGE) {
+            mSwatchLength = res.getDimensionPixelSize(R.dimen.color_swatch_large);
+            mMarginSize = res.getDimensionPixelSize(R.dimen.color_swatch_margins_large);
+        } else {
+            mSwatchLength = res.getDimensionPixelSize(R.dimen.color_swatch_small);
+            mMarginSize = res.getDimensionPixelSize(R.dimen.color_swatch_margins_small);
+        }
+        mOnColorSelectedListener = listener;
+
+        mDescription = res.getString(R.string.color_swatch_description);
+        mDescriptionSelected = res.getString(R.string.color_swatch_description_selected);
+    }
+
+    private TableRow createTableRow() {
+        TableRow row = new TableRow(getContext());
+        ViewGroup.LayoutParams params = new ViewGroup.LayoutParams(LayoutParams.WRAP_CONTENT,
+                LayoutParams.WRAP_CONTENT);
+        row.setLayoutParams(params);
+        return row;
+    }
+
+    /**
+     * Adds swatches to table in a serpentine format.
+     */
+    public void drawPalette(int[] colors, int selectedColor) {
+        if (colors == null) {
+            return;
+        }
+
+        this.removeAllViews();
+        int tableElements = 0;
+        int rowElements = 0;
+        int rowNumber = 0;
+
+        // Fills the table with swatches based on the array of palette.
+        TableRow row = createTableRow();
+        for (int color : colors) {
+            tableElements++;
+
+            View colorSwatch = createColorSwatch(color, selectedColor);
+            setSwatchDescription(rowNumber, tableElements, rowElements, color == selectedColor,
+                    colorSwatch);
+            addSwatchToRow(row, colorSwatch, rowNumber);
+
+            rowElements++;
+            if (rowElements == mNumColumns) {
+                addView(row);
+                row = createTableRow();
+                rowElements = 0;
+                rowNumber++;
+            }
+        }
+
+        // Create blank views to fill the row if the last row has not been filled.
+        if (rowElements > 0) {
+            while (rowElements != mNumColumns) {
+                addSwatchToRow(row, createBlankSpace(), rowNumber);
+                rowElements++;
+            }
+            addView(row);
+        }
+    }
+
+    /**
+     * Appends a swatch to the end of the row for even-numbered rows (starting with row 0),
+     * to the beginning of a row for odd-numbered rows.
+     */
+    private static void addSwatchToRow(TableRow row, View swatch, int rowNumber) {
+        if (rowNumber % 2 == 0) {
+            row.addView(swatch);
+        } else {
+            row.addView(swatch, 0);
+        }
+    }
+
+    /**
+     * Add a content description to the specified swatch view. Because the palette get added in a
+     * snaking form, every other row will need to compensate for the fact that the palette are added
+     * in an opposite direction from their left->right/top->bottom order, which is how the system
+     * will arrange them for accessibility purposes.
+     */
+    private void setSwatchDescription(int rowNumber, int index, int rowElements, boolean selected,
+            View swatch) {
+        int accessibilityIndex;
+        if (rowNumber % 2 == 0) {
+            // We're in a regular-ordered row
+            accessibilityIndex = index;
+        } else {
+            // We're in a backwards-ordered row.
+            int rowMax = ((rowNumber + 1) * mNumColumns);
+            accessibilityIndex = rowMax - rowElements;
+        }
+
+        String description;
+        if (selected) {
+            description = String.format(mDescriptionSelected, accessibilityIndex);
+        } else {
+            description = String.format(mDescription, accessibilityIndex);
+        }
+        swatch.setContentDescription(description);
+    }
+
+    /**
+     * Creates a blank space to fill the row.
+     */
+    private ImageView createBlankSpace() {
+        ImageView view = new ImageView(getContext());
+        TableRow.LayoutParams params = new TableRow.LayoutParams(mSwatchLength, mSwatchLength);
+        params.setMargins(mMarginSize, mMarginSize, mMarginSize, mMarginSize);
+        view.setLayoutParams(params);
+        return view;
+    }
+
+    /**
+     * Creates a color swatch.
+     */
+    private ColorPickerSwatch createColorSwatch(int color, int selectedColor) {
+        ColorPickerSwatch view = new ColorPickerSwatch(getContext(), color,
+                color == selectedColor, mOnColorSelectedListener);
+        TableRow.LayoutParams params = new TableRow.LayoutParams(mSwatchLength, mSwatchLength);
+        params.setMargins(mMarginSize, mMarginSize, mMarginSize, mMarginSize);
+        view.setLayoutParams(params);
+        return view;
+    }
+}

uhabits-android/src/main/java/com/android/colorpicker/ColorPickerSwatch.java

@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2013 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.colorpicker;
+
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+
+import org.isoron.uhabits.R;
+
+/**
+ * Creates a circular swatch of a specified color.  Adds a checkmark if marked as checked.
+ */
+public class ColorPickerSwatch extends FrameLayout implements View.OnClickListener {
+    private int mColor;
+    private ImageView mSwatchImage;
+    private ImageView mCheckmarkImage;
+    private OnColorSelectedListener mOnColorSelectedListener;
+
+    /**
+     * Interface for a callback when a color square is selected.
+     */
+    public interface OnColorSelectedListener {
+
+        /**
+         * Called when a specific color square has been selected.
+         */
+        public void onColorSelected(int color);
+    }
+
+    public ColorPickerSwatch(Context context, int color, boolean checked,
+            OnColorSelectedListener listener) {
+        super(context);
+        mColor = color;
+        mOnColorSelectedListener = listener;
+
+        LayoutInflater.from(context).inflate(R.layout.color_picker_swatch, this);
+        mSwatchImage = (ImageView) findViewById(R.id.color_picker_swatch);
+        mCheckmarkImage = (ImageView) findViewById(R.id.color_picker_checkmark);
+        setColor(color);
+        setChecked(checked);
+        setOnClickListener(this);
+    }
+
+    protected void setColor(int color) {
+        Drawable[] colorDrawable = new Drawable[]
+                {getContext().getResources().getDrawable(R.drawable.color_picker_swatch)};
+        mSwatchImage.setImageDrawable(new ColorStateDrawable(colorDrawable, color));
+    }
+
+    private void setChecked(boolean checked) {
+        if (checked) {
+            mCheckmarkImage.setVisibility(View.VISIBLE);
+        } else {
+            mCheckmarkImage.setVisibility(View.GONE);
+        }
+    }
+
+    @Override
+    public void onClick(View v) {
+        if (mOnColorSelectedListener != null) {
+            mOnColorSelectedListener.onColorSelected(mColor);
+        }
+    }
+}

uhabits-android/src/main/java/com/android/colorpicker/ColorStateDrawable.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2013 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.colorpicker;
+
+import android.graphics.Color;
+import android.graphics.PorterDuff;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.LayerDrawable;
+
+/**
+ * A drawable which sets its color filter to a color specified by the user, and changes to a
+ * slightly darker color when pressed or focused.
+ */
+public class ColorStateDrawable extends LayerDrawable {
+
+    private static final float PRESSED_STATE_MULTIPLIER = 0.70f;
+
+    private int mColor;
+
+    public ColorStateDrawable(Drawable[] layers, int color) {
+        super(layers);
+        mColor = color;
+    }
+
+    @Override
+    protected boolean onStateChange(int[] states) {
+        boolean pressedOrFocused = false;
+        for (int state : states) {
+            if (state == android.R.attr.state_pressed || state == android.R.attr.state_focused) {
+                pressedOrFocused = true;
+                break;
+            }
+        }
+
+        if (pressedOrFocused) {
+            super.setColorFilter(getPressedColor(mColor), PorterDuff.Mode.SRC_ATOP);
+        } else {
+            super.setColorFilter(mColor, PorterDuff.Mode.SRC_ATOP);
+        }
+
+        return super.onStateChange(states);
+    }
+
+    /**
+     * Given a particular color, adjusts its value by a multiplier.
+     */
+    private static int getPressedColor(int color) {
+        float[] hsv = new float[3];
+        Color.colorToHSV(color, hsv);
+        hsv[2] = hsv[2] * PRESSED_STATE_MULTIPLIER;
+        return Color.HSVToColor(hsv);
+    }
+
+    @Override
+    public boolean isStateful() {
+        return true;
+    }
+}

uhabits-android/src/main/java/com/android/colorpicker/HsvColorComparator.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2013 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.colorpicker;
+
+import java.util.Comparator;
+
+import android.graphics.Color;
+
+/**
+ * A color comparator which compares based on hue, saturation, and value.
+ */
+public class HsvColorComparator implements Comparator<Integer> {
+
+    @Override
+    public int compare(Integer lhs, Integer rhs) {
+        float[] hsv = new float[3];
+        Color.colorToHSV(lhs, hsv);
+        float hue1 = hsv[0];
+        float sat1 = hsv[1];
+        float val1 = hsv[2];
+
+        float[] hsv2 = new float[3];
+        Color.colorToHSV(rhs, hsv2);
+        float hue2 = hsv2[0];
+        float sat2 = hsv2[1];
+        float val2 = hsv2[2];
+
+        if (hue1 < hue2) {
+            return 1;
+        } else if (hue1 > hue2) {
+            return -1;
+        } else {
+            if (sat1 < sat2) {
+                return 1;
+            } else if (sat1 > sat2) {
+                return -1;
+            } else {
+                if (val1 < val2) {
+                    return 1;
+                } else if (val1 > val2) {
+                    return -1;
+                }
+            }
+        }
+        return 0;
+    }
+}

uhabits-android/src/main/java/com/android/datetimepicker/AccessibleLinearLayout.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2013 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.datetimepicker;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.accessibility.AccessibilityEvent;
+import android.view.accessibility.AccessibilityNodeInfo;
+import android.widget.Button;
+import android.widget.LinearLayout;
+
+/**
+ * Fake Button class, used so TextViews can announce themselves as Buttons, for accessibility.
+ */
+public class AccessibleLinearLayout extends LinearLayout {
+
+    public AccessibleLinearLayout(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    @Override
+    public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
+        super.onInitializeAccessibilityEvent(event);
+        event.setClassName(Button.class.getName());
+    }
+
+    @Override
+    public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
+        super.onInitializeAccessibilityNodeInfo(info);
+        info.setClassName(Button.class.getName());
+    }
+}

uhabits-android/src/main/java/com/android/datetimepicker/AccessibleTextView.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2013 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.datetimepicker;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.accessibility.AccessibilityEvent;
+import android.view.accessibility.AccessibilityNodeInfo;
+import android.widget.Button;
+import android.widget.TextView;
+
+
+/**
+ * Fake Button class, used so TextViews can announce themselves as Buttons, for accessibility.
+ */
+public class AccessibleTextView extends TextView {
+
+    public AccessibleTextView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    @Override
+    public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
+        super.onInitializeAccessibilityEvent(event);
+        event.setClassName(Button.class.getName());
+    }
+
+    @Override
+    public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
+        super.onInitializeAccessibilityNodeInfo(info);
+        info.setClassName(Button.class.getName());
+    }
+}

uhabits-android/src/main/java/com/android/datetimepicker/HapticFeedbackController.java

@@ -0,0 +1,74 @@
+package com.android.datetimepicker;
+
+import android.app.Service;
+import android.content.Context;
+import android.database.ContentObserver;
+import android.net.Uri;
+import android.os.SystemClock;
+import android.os.Vibrator;
+import android.provider.Settings;
+
+/**
+ * A simple utility class to handle haptic feedback.
+ */
+public class HapticFeedbackController {
+    private static final int VIBRATE_DELAY_MS = 125;
+    private static final int VIBRATE_LENGTH_MS = 5;
+
+    private static boolean checkGlobalSetting(Context context) {
+        return Settings.System.getInt(context.getContentResolver(),
+                Settings.System.HAPTIC_FEEDBACK_ENABLED, 0) == 1;
+    }
+
+    private final Context mContext;
+    private final ContentObserver mContentObserver;
+
+    private Vibrator mVibrator;
+    private boolean mIsGloballyEnabled;
+    private long mLastVibrate;
+
+    public HapticFeedbackController(Context context) {
+        mContext = context;
+        mContentObserver = new ContentObserver(null) {
+            @Override
+            public void onChange(boolean selfChange) {
+                mIsGloballyEnabled = checkGlobalSetting(mContext);
+            }
+        };
+    }
+
+    /**
+     * Call to setup the controller.
+     */
+    public void start() {
+        mVibrator = (Vibrator) mContext.getSystemService(Service.VIBRATOR_SERVICE);
+
+        // Setup a listener for changes in haptic feedback settings
+        mIsGloballyEnabled = checkGlobalSetting(mContext);
+        Uri uri = Settings.System.getUriFor(Settings.System.HAPTIC_FEEDBACK_ENABLED);
+        mContext.getContentResolver().registerContentObserver(uri, false, mContentObserver);
+    }
+
+    /**
+     * Call this when you don't need the controller anymore.
+     */
+    public void stop() {
+        mVibrator = null;
+        mContext.getContentResolver().unregisterContentObserver(mContentObserver);
+    }
+
+    /**
+     * Try to vibrate. To prevent this becoming a single continuous vibration, nothing will
+     * happen if we have vibrated very recently.
+     */
+    public void tryVibrate() {
+        if (mVibrator != null && mIsGloballyEnabled) {
+            long now = SystemClock.uptimeMillis();
+            // We want to try to vibrate each individual tick discretely.
+            if (now - mLastVibrate >= VIBRATE_DELAY_MS) {
+                mVibrator.vibrate(VIBRATE_LENGTH_MS);
+                mLastVibrate = now;
+            }
+        }
+    }
+}

uhabits-android/src/main/java/com/android/datetimepicker/Utils.java

@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2013 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.datetimepicker;
+
+import java.util.Calendar;
+
+import android.animation.Keyframe;
+import android.animation.ObjectAnimator;
+import android.animation.PropertyValuesHolder;
+import android.annotation.SuppressLint;
+import android.os.Build;
+import android.text.format.Time;
+import android.view.View;
+
+/**
+ * Utility helper functions for time and date pickers.
+ */
+public class Utils {
+
+    public static final int MONDAY_BEFORE_JULIAN_EPOCH = Time.EPOCH_JULIAN_DAY - 3;
+    public static final int PULSE_ANIMATOR_DURATION = 544;
+
+    // Alpha level for time picker selection.
+    public static final int SELECTED_ALPHA = 51;
+    public static final int SELECTED_ALPHA_THEME_DARK = 102;
+    // Alpha level for fully opaque.
+    public static final int FULL_ALPHA = 255;
+
+
+    static final String SHARED_PREFS_NAME = "com.android.calendar_preferences";
+
+    public static boolean isJellybeanOrLater() {
+      return Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN;
+    }
+
+    /**
+     * Try to speak the specified text, for accessibility. Only available on JB or later.
+     * @param text Text to announce.
+     */
+    @SuppressLint("NewApi")
+    public static void tryAccessibilityAnnounce(View view, CharSequence text) {
+        if (isJellybeanOrLater() && view != null && text != null) {
+            view.announceForAccessibility(text);
+        }
+    }
+
+    public static int getDaysInMonth(int month, int year) {
+        switch (month) {
+            case Calendar.JANUARY:
+            case Calendar.MARCH:
+            case Calendar.MAY:
+            case Calendar.JULY:
+            case Calendar.AUGUST:
+            case Calendar.OCTOBER:
+            case Calendar.DECEMBER:
+                return 31;
+            case Calendar.APRIL:
+            case Calendar.JUNE:
+            case Calendar.SEPTEMBER:
+            case Calendar.NOVEMBER:
+                return 30;
+            case Calendar.FEBRUARY:
+                return (year % 4 == 0) ? 29 : 28;
+            default:
+                throw new IllegalArgumentException("Invalid Month");
+        }
+    }
+
+    /**
+     * Takes a number of weeks since the epoch and calculates the Julian day of
+     * the Monday for that week.
+     *
+     * This assumes that the week containing the {@link Time#EPOCH_JULIAN_DAY}
+     * is considered week 0. It returns the Julian day for the Monday
+     * {@code week} weeks after the Monday of the week containing the epoch.
+     *
+     * @param week Number of weeks since the epoch
+     * @return The julian day for the Monday of the given week since the epoch
+     */
+    public static int getJulianMondayFromWeeksSinceEpoch(int week) {
+        return MONDAY_BEFORE_JULIAN_EPOCH + week * 7;
+    }
+
+    /**
+     * Returns the week since {@link Time#EPOCH_JULIAN_DAY} (Jan 1, 1970)
+     * adjusted for first day of week.
+     *
+     * This takes a julian day and the week start day and calculates which
+     * week since {@link Time#EPOCH_JULIAN_DAY} that day occurs in, starting
+     * at 0. *Do not* use this to compute the ISO week number for the year.
+     *
+     * @param julianDay The julian day to calculate the week number for
+     * @param firstDayOfWeek Which week day is the first day of the week,
+     *          see {@link Time#SUNDAY}
+     * @return Weeks since the epoch
+     */
+    public static int getWeeksSinceEpochFromJulianDay(int julianDay, int firstDayOfWeek) {
+        int diff = Time.THURSDAY - firstDayOfWeek;
+        if (diff < 0) {
+            diff += 7;
+        }
+        int refDay = Time.EPOCH_JULIAN_DAY - diff;
+        return (julianDay - refDay) / 7;
+    }
+
+    /**
+     * Render an animator to pulsate a view in place.
+     * @param labelToAnimate the view to pulsate.
+     * @return The animator object. Use .start() to begin.
+     */
+    public static ObjectAnimator getPulseAnimator(View labelToAnimate, float decreaseRatio,
+            float increaseRatio) {
+        Keyframe k0 = Keyframe.ofFloat(0f, 1f);
+        Keyframe k1 = Keyframe.ofFloat(0.275f, decreaseRatio);
+        Keyframe k2 = Keyframe.ofFloat(0.69f, increaseRatio);
+        Keyframe k3 = Keyframe.ofFloat(1f, 1f);
+
+        PropertyValuesHolder scaleX = PropertyValuesHolder.ofKeyframe("scaleX", k0, k1, k2, k3);
+        PropertyValuesHolder scaleY = PropertyValuesHolder.ofKeyframe("scaleY", k0, k1, k2, k3);
+        ObjectAnimator pulseAnimator =
+                ObjectAnimator.ofPropertyValuesHolder(labelToAnimate, scaleX, scaleY);
+        pulseAnimator.setDuration(PULSE_ANIMATOR_DURATION);
+
+        return pulseAnimator;
+    }
+}

uhabits-android/src/main/java/com/android/datetimepicker/date/AccessibleDateAnimator.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2013 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.datetimepicker.date;
+
+import android.content.Context;
+import android.text.format.DateUtils;
+import android.util.AttributeSet;
+import android.view.accessibility.AccessibilityEvent;
+import android.widget.ViewAnimator;
+
+public class AccessibleDateAnimator extends ViewAnimator {
+    private long mDateMillis;
+
+    public AccessibleDateAnimator(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public void setDateMillis(long dateMillis) {
+        mDateMillis = dateMillis;
+    }
+
+    /**
+     * Announce the currently-selected date when launched.
+     */
+    @Override
+    public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
+        if (event.getEventType() == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED) {
+            // Clear the event's current text so that only the current date will be spoken.
+            event.getText().clear();
+            int flags = DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_YEAR |
+                    DateUtils.FORMAT_SHOW_WEEKDAY;
+
+            String dateString = DateUtils.formatDateTime(getContext(), mDateMillis, flags);
+            event.getText().add(dateString);
+            return true;
+        }
+        return super.dispatchPopulateAccessibilityEvent(event);
+    }
+}

uhabits-android/src/main/java/com/android/datetimepicker/date/DatePickerController.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2013 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.datetimepicker.date;
+
+import com.android.datetimepicker.date.DatePickerDialog.OnDateChangedListener;
+import com.android.datetimepicker.date.MonthAdapter.CalendarDay;
+
+/**
+ * Controller class to communicate among the various components of the date picker dialog.
+ */
+public interface DatePickerController {
+
+    void onYearSelected(int year);
+
+    void onDayOfMonthSelected(int year, int month, int day);
+
+    void registerOnDateChangedListener(OnDateChangedListener listener);
+
+    void unregisterOnDateChangedListener(OnDateChangedListener listener);
+
+    CalendarDay getSelectedDay();
+
+    int getFirstDayOfWeek();
+
+    int getMinYear();
+
+    int getMaxYear();
+
+    void tryVibrate();
+}

uhabits-android/src/main/java/com/android/datetimepicker/date/DatePickerDialog.java

@@ -0,0 +1,484 @@
+/*
+ * Copyright (C) 2013 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.datetimepicker.date;
+
+import android.animation.ObjectAnimator;
+import android.app.Activity;
+import android.app.DialogFragment;
+import android.content.res.Resources;
+import android.os.Bundle;
+import android.text.format.DateUtils;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup;
+import android.view.Window;
+import android.view.WindowManager;
+import android.view.animation.AlphaAnimation;
+import android.view.animation.Animation;
+import android.widget.Button;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import com.android.datetimepicker.HapticFeedbackController;
+import com.android.datetimepicker.Utils;
+import com.android.datetimepicker.date.MonthAdapter.CalendarDay;
+
+import org.isoron.uhabits.R;
+
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Locale;
+
+/**
+ * Dialog allowing users to select a date.
+ */
+public class DatePickerDialog extends DialogFragment implements
+        OnClickListener, DatePickerController {
+
+    private static final String TAG = "DatePickerDialog";
+
+    private static final int UNINITIALIZED = -1;
+    private static final int MONTH_AND_DAY_VIEW = 0;
+    private static final int YEAR_VIEW = 1;
+
+    private static final String KEY_SELECTED_YEAR = "year";
+    private static final String KEY_SELECTED_MONTH = "month";
+    private static final String KEY_SELECTED_DAY = "day";
+    private static final String KEY_LIST_POSITION = "list_position";
+    private static final String KEY_WEEK_START = "week_start";
+    private static final String KEY_YEAR_START = "year_start";
+    private static final String KEY_YEAR_END = "year_end";
+    private static final String KEY_CURRENT_VIEW = "current_view";
+    private static final String KEY_LIST_POSITION_OFFSET = "list_position_offset";
+
+    private static final int DEFAULT_START_YEAR = 1900;
+    private static final int DEFAULT_END_YEAR = 2100;
+
+    private static final int ANIMATION_DURATION = 300;
+    private static final int ANIMATION_DELAY = 500;
+
+    private static SimpleDateFormat YEAR_FORMAT = new SimpleDateFormat("yyyy", Locale.getDefault());
+    private static SimpleDateFormat DAY_FORMAT = new SimpleDateFormat("dd", Locale.getDefault());
+
+    private final Calendar mCalendar = Calendar.getInstance();
+    private OnDateSetListener mCallBack;
+    private HashSet<OnDateChangedListener> mListeners = new HashSet<OnDateChangedListener>();
+
+    private AccessibleDateAnimator mAnimator;
+
+    private TextView mDayOfWeekView;
+    private LinearLayout mMonthAndDayView;
+    private TextView mSelectedMonthTextView;
+    private TextView mSelectedDayTextView;
+    private TextView mYearView;
+    private DayPickerView mDayPickerView;
+    private YearPickerView mYearPickerView;
+
+    private int mCurrentView = UNINITIALIZED;
+
+    private int mWeekStart = mCalendar.getFirstDayOfWeek();
+    private int mMinYear = DEFAULT_START_YEAR;
+    private int mMaxYear = DEFAULT_END_YEAR;
+
+    private HapticFeedbackController mHapticFeedbackController;
+
+    private boolean mDelayAnimation = true;
+
+    // Accessibility strings.
+    private String mDayPickerDescription;
+    private String mSelectDay;
+    private String mYearPickerDescription;
+    private String mSelectYear;
+
+    /**
+     * The callback used to indicate the user is done filling in the date.
+     */
+    public interface OnDateSetListener {
+
+        /**
+         * @param view The view associated with this listener.
+         * @param year The year that was set.
+         * @param monthOfYear The month that was set (0-11) for compatibility
+         *            with {@link java.util.Calendar}.
+         * @param dayOfMonth The day of the month that was set.
+         */
+        void onDateSet(DatePickerDialog dialog, int year, int monthOfYear, int dayOfMonth);
+
+        void onDateCleared(DatePickerDialog dialog);
+    }
+
+    /**
+     * The callback used to notify other date picker components of a change in selected date.
+     */
+    public interface OnDateChangedListener {
+
+        public void onDateChanged();
+    }
+
+
+    public DatePickerDialog() {
+        // Empty constructor required for dialog fragment.
+    }
+
+    /**
+     * @param callBack How the parent is notified that the date is set.
+     * @param year The initial year of the dialog.
+     * @param monthOfYear The initial month of the dialog.
+     * @param dayOfMonth The initial day of the dialog.
+     */
+    public static DatePickerDialog newInstance(OnDateSetListener callBack, int year,
+            int monthOfYear,
+            int dayOfMonth) {
+        DatePickerDialog ret = new DatePickerDialog();
+        ret.initialize(callBack, year, monthOfYear, dayOfMonth);
+        return ret;
+    }
+
+    public void initialize(OnDateSetListener callBack, int year, int monthOfYear, int dayOfMonth) {
+        mCallBack = callBack;
+        mCalendar.set(Calendar.YEAR, year);
+        mCalendar.set(Calendar.MONTH, monthOfYear);
+        mCalendar.set(Calendar.DAY_OF_MONTH, dayOfMonth);
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        final Activity activity = getActivity();
+        activity.getWindow().setSoftInputMode(
+                WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
+        if (savedInstanceState != null) {
+            mCalendar.set(Calendar.YEAR, savedInstanceState.getInt(KEY_SELECTED_YEAR));
+            mCalendar.set(Calendar.MONTH, savedInstanceState.getInt(KEY_SELECTED_MONTH));
+            mCalendar.set(Calendar.DAY_OF_MONTH, savedInstanceState.getInt(KEY_SELECTED_DAY));
+        }
+    }
+
+    @Override
+    public void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        outState.putInt(KEY_SELECTED_YEAR, mCalendar.get(Calendar.YEAR));
+        outState.putInt(KEY_SELECTED_MONTH, mCalendar.get(Calendar.MONTH));
+        outState.putInt(KEY_SELECTED_DAY, mCalendar.get(Calendar.DAY_OF_MONTH));
+        outState.putInt(KEY_WEEK_START, mWeekStart);
+        outState.putInt(KEY_YEAR_START, mMinYear);
+        outState.putInt(KEY_YEAR_END, mMaxYear);
+        outState.putInt(KEY_CURRENT_VIEW, mCurrentView);
+        int listPosition = -1;
+        if (mCurrentView == MONTH_AND_DAY_VIEW) {
+            listPosition = mDayPickerView.getMostVisiblePosition();
+        } else if (mCurrentView == YEAR_VIEW) {
+            listPosition = mYearPickerView.getFirstVisiblePosition();
+            outState.putInt(KEY_LIST_POSITION_OFFSET, mYearPickerView.getFirstPositionOffset());
+        }
+        outState.putInt(KEY_LIST_POSITION, listPosition);
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+            Bundle savedInstanceState) {
+        Log.d(TAG, "onCreateView: ");
+        getDialog().getWindow().requestFeature(Window.FEATURE_NO_TITLE);
+
+        View view = inflater.inflate(R.layout.date_picker_dialog, null);
+
+        mDayOfWeekView = (TextView) view.findViewById(R.id.date_picker_header);
+        mMonthAndDayView = (LinearLayout) view.findViewById(R.id.date_picker_month_and_day);
+        mMonthAndDayView.setOnClickListener(this);
+        mSelectedMonthTextView = (TextView) view.findViewById(R.id.date_picker_month);
+        mSelectedDayTextView = (TextView) view.findViewById(R.id.date_picker_day);
+        mYearView = (TextView) view.findViewById(R.id.date_picker_year);
+        mYearView.setOnClickListener(this);
+
+        int listPosition = -1;
+        int listPositionOffset = 0;
+        int currentView = MONTH_AND_DAY_VIEW;
+        if (savedInstanceState != null) {
+            mWeekStart = savedInstanceState.getInt(KEY_WEEK_START);
+            mMinYear = savedInstanceState.getInt(KEY_YEAR_START);
+            mMaxYear = savedInstanceState.getInt(KEY_YEAR_END);
+            currentView = savedInstanceState.getInt(KEY_CURRENT_VIEW);
+            listPosition = savedInstanceState.getInt(KEY_LIST_POSITION);
+            listPositionOffset = savedInstanceState.getInt(KEY_LIST_POSITION_OFFSET);
+        }
+
+        final Activity activity = getActivity();
+        mDayPickerView = new SimpleDayPickerView(activity, this);
+        mYearPickerView = new YearPickerView(activity, this);
+
+        Resources res = getResources();
+        mDayPickerDescription = res.getString(R.string.day_picker_description);
+        mSelectDay = res.getString(R.string.select_day);
+        mYearPickerDescription = res.getString(R.string.year_picker_description);
+        mSelectYear = res.getString(R.string.select_year);
+
+        mAnimator = (AccessibleDateAnimator) view.findViewById(R.id.animator);
+        mAnimator.addView(mDayPickerView);
+        mAnimator.addView(mYearPickerView);
+        mAnimator.setDateMillis(mCalendar.getTimeInMillis());
+        // TODO: Replace with animation decided upon by the design team.
+        Animation animation = new AlphaAnimation(0.0f, 1.0f);
+        animation.setDuration(ANIMATION_DURATION);
+        mAnimator.setInAnimation(animation);
+        // TODO: Replace with animation decided upon by the design team.
+        Animation animation2 = new AlphaAnimation(1.0f, 0.0f);
+        animation2.setDuration(ANIMATION_DURATION);
+        mAnimator.setOutAnimation(animation2);
+
+        Button mDoneButton = (Button) view.findViewById(R.id.done);
+        mDoneButton.setOnClickListener(new OnClickListener()
+        {
+            @Override
+            public void onClick(View v)
+            {
+                tryVibrate();
+                if (mCallBack != null)
+                {
+                    mCallBack.onDateSet(DatePickerDialog.this, mCalendar.get(Calendar.YEAR),
+                            mCalendar.get(Calendar.MONTH), mCalendar.get(Calendar.DAY_OF_MONTH));
+                }
+                dismiss();
+            }
+        });
+
+        Button mClearButton = (Button) view.findViewById(R.id.clear);
+        mClearButton.setOnClickListener(new OnClickListener()
+        {
+            @Override
+            public void onClick(View v)
+            {
+                tryVibrate();
+                if (mCallBack != null)
+                {
+                    mCallBack.onDateCleared(DatePickerDialog.this);
+                }
+                dismiss();
+            }
+        });
+
+        updateDisplay(false);
+        setCurrentView(currentView);
+
+        if (listPosition != -1) {
+            if (currentView == MONTH_AND_DAY_VIEW) {
+                mDayPickerView.postSetSelection(listPosition);
+            } else if (currentView == YEAR_VIEW) {
+                mYearPickerView.postSetSelectionFromTop(listPosition, listPositionOffset);
+            }
+        }
+
+        mHapticFeedbackController = new HapticFeedbackController(activity);
+        return view;
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        mHapticFeedbackController.start();
+    }
+
+    @Override
+    public void onPause() {
+        super.onPause();
+        mHapticFeedbackController.stop();
+    }
+
+    private void setCurrentView(final int viewIndex) {
+        long millis = mCalendar.getTimeInMillis();
+
+        switch (viewIndex) {
+            case MONTH_AND_DAY_VIEW:
+                ObjectAnimator pulseAnimator = Utils.getPulseAnimator(mMonthAndDayView, 0.9f,
+                        1.05f);
+                if (mDelayAnimation) {
+                    pulseAnimator.setStartDelay(ANIMATION_DELAY);
+                    mDelayAnimation = false;
+                }
+                mDayPickerView.onDateChanged();
+                if (mCurrentView != viewIndex) {
+                    mMonthAndDayView.setSelected(true);
+                    mYearView.setSelected(false);
+                    mAnimator.setDisplayedChild(MONTH_AND_DAY_VIEW);
+                    mCurrentView = viewIndex;
+                }
+                pulseAnimator.start();
+
+                int flags = DateUtils.FORMAT_SHOW_DATE;
+                String dayString = DateUtils.formatDateTime(getActivity(), millis, flags);
+                mAnimator.setContentDescription(mDayPickerDescription+": "+dayString);
+                Utils.tryAccessibilityAnnounce(mAnimator, mSelectDay);
+                break;
+            case YEAR_VIEW:
+                pulseAnimator = Utils.getPulseAnimator(mYearView, 0.85f, 1.1f);
+                if (mDelayAnimation) {
+                    pulseAnimator.setStartDelay(ANIMATION_DELAY);
+                    mDelayAnimation = false;
+                }
+                mYearPickerView.onDateChanged();
+                if (mCurrentView != viewIndex) {
+                    mMonthAndDayView.setSelected(false);
+                    mYearView.setSelected(true);
+                    mAnimator.setDisplayedChild(YEAR_VIEW);
+                    mCurrentView = viewIndex;
+                }
+                pulseAnimator.start();
+
+                CharSequence yearString = YEAR_FORMAT.format(millis);
+                mAnimator.setContentDescription(mYearPickerDescription+": "+yearString);
+                Utils.tryAccessibilityAnnounce(mAnimator, mSelectYear);
+                break;
+        }
+    }
+
+    private void updateDisplay(boolean announce) {
+        if (mDayOfWeekView != null) {
+            mDayOfWeekView.setText(mCalendar.getDisplayName(Calendar.DAY_OF_WEEK, Calendar.LONG,
+                    Locale.getDefault()).toUpperCase(Locale.getDefault()));
+        }
+
+        mSelectedMonthTextView.setText(mCalendar.getDisplayName(Calendar.MONTH, Calendar.SHORT,
+                Locale.getDefault()).toUpperCase(Locale.getDefault()));
+        mSelectedDayTextView.setText(DAY_FORMAT.format(mCalendar.getTime()));
+        mYearView.setText(YEAR_FORMAT.format(mCalendar.getTime()));
+
+        // Accessibility.
+        long millis = mCalendar.getTimeInMillis();
+        mAnimator.setDateMillis(millis);
+        int flags = DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_NO_YEAR;
+        String monthAndDayText = DateUtils.formatDateTime(getActivity(), millis, flags);
+        mMonthAndDayView.setContentDescription(monthAndDayText);
+
+        if (announce) {
+            flags = DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_YEAR;
+            String fullDateText = DateUtils.formatDateTime(getActivity(), millis, flags);
+            Utils.tryAccessibilityAnnounce(mAnimator, fullDateText);
+        }
+    }
+
+    public void setFirstDayOfWeek(int startOfWeek) {
+        if (startOfWeek < Calendar.SUNDAY || startOfWeek > Calendar.SATURDAY) {
+            throw new IllegalArgumentException("Value must be between Calendar.SUNDAY and " +
+                    "Calendar.SATURDAY");
+        }
+        mWeekStart = startOfWeek;
+        if (mDayPickerView != null) {
+            mDayPickerView.onChange();
+        }
+    }
+
+    public void setYearRange(int startYear, int endYear) {
+        if (endYear <= startYear) {
+            throw new IllegalArgumentException("Year end must be larger than year start");
+        }
+        mMinYear = startYear;
+        mMaxYear = endYear;
+        if (mDayPickerView != null) {
+            mDayPickerView.onChange();
+        }
+    }
+
+    public void setOnDateSetListener(OnDateSetListener listener) {
+        mCallBack = listener;
+    }
+
+    // If the newly selected month / year does not contain the currently selected day number,
+    // change the selected day number to the last day of the selected month or year.
+    //      e.g. Switching from Mar to Apr when Mar 31 is selected -> Apr 30
+    //      e.g. Switching from 2012 to 2013 when Feb 29, 2012 is selected -> Feb 28, 2013
+    private void adjustDayInMonthIfNeeded(int month, int year) {
+        int day = mCalendar.get(Calendar.DAY_OF_MONTH);
+        int daysInMonth = Utils.getDaysInMonth(month, year);
+        if (day > daysInMonth) {
+            mCalendar.set(Calendar.DAY_OF_MONTH, daysInMonth);
+        }
+    }
+
+    @Override
+    public void onClick(View v) {
+        tryVibrate();
+        if (v.getId() == R.id.date_picker_year) {
+            setCurrentView(YEAR_VIEW);
+        } else if (v.getId() == R.id.date_picker_month_and_day) {
+            setCurrentView(MONTH_AND_DAY_VIEW);
+        }
+    }
+
+    @Override
+    public void onYearSelected(int year) {
+        adjustDayInMonthIfNeeded(mCalendar.get(Calendar.MONTH), year);
+        mCalendar.set(Calendar.YEAR, year);
+        updatePickers();
+        setCurrentView(MONTH_AND_DAY_VIEW);
+        updateDisplay(true);
+    }
+
+    @Override
+    public void onDayOfMonthSelected(int year, int month, int day) {
+        mCalendar.set(Calendar.YEAR, year);
+        mCalendar.set(Calendar.MONTH, month);
+        mCalendar.set(Calendar.DAY_OF_MONTH, day);
+        updatePickers();
+        updateDisplay(true);
+    }
+
+    private void updatePickers() {
+        Iterator<OnDateChangedListener> iterator = mListeners.iterator();
+        while (iterator.hasNext()) {
+            iterator.next().onDateChanged();
+        }
+    }
+
+
+    @Override
+    public CalendarDay getSelectedDay() {
+        return new CalendarDay(mCalendar);
+    }
+
+    @Override
+    public int getMinYear() {
+        return mMinYear;
+    }
+
+    @Override
+    public int getMaxYear() {
+        return mMaxYear;
+    }
+
+    @Override
+    public int getFirstDayOfWeek() {
+        return mWeekStart;
+    }
+
+    @Override
+    public void registerOnDateChangedListener(OnDateChangedListener listener) {
+        mListeners.add(listener);
+    }
+
+    @Override
+    public void unregisterOnDateChangedListener(OnDateChangedListener listener) {
+        mListeners.remove(listener);
+    }
+
+    @Override
+    public void tryVibrate() {
+        mHapticFeedbackController.tryVibrate();
+    }
+}

uhabits-android/src/main/java/com/android/datetimepicker/date/DayPickerView.java

@@ -0,0 +1,507 @@
+/*
+ * Copyright (C) 2013 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.datetimepicker.date;
+
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Locale;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewConfiguration;
+import android.view.accessibility.AccessibilityEvent;
+import android.view.accessibility.AccessibilityNodeInfo;
+import android.widget.AbsListView;
+import android.widget.AbsListView.OnScrollListener;
+import android.widget.ListView;
+
+import com.android.datetimepicker.Utils;
+import com.android.datetimepicker.date.DatePickerDialog.OnDateChangedListener;
+import com.android.datetimepicker.date.MonthAdapter.CalendarDay;
+
+/**
+ * This displays a list of months in a calendar format with selectable days.
+ */
+public abstract class DayPickerView extends ListView implements OnScrollListener,
+    OnDateChangedListener {
+
+    private static final String TAG = "MonthFragment";
+
+    // Affects when the month selection will change while scrolling up
+    protected static final int SCROLL_HYST_WEEKS = 2;
+    // How long the GoTo fling animation should last
+    protected static final int GOTO_SCROLL_DURATION = 250;
+    // How long to wait after receiving an onScrollStateChanged notification
+    // before acting on it
+    protected static final int SCROLL_CHANGE_DELAY = 40;
+    // The number of days to display in each week
+    public static final int DAYS_PER_WEEK = 7;
+    public static int LIST_TOP_OFFSET = -1; // so that the top line will be
+                                            // under the separator
+    // You can override these numbers to get a different appearance
+    protected int mNumWeeks = 6;
+    protected boolean mShowWeekNumber = false;
+    protected int mDaysPerWeek = 7;
+    private static SimpleDateFormat YEAR_FORMAT = new SimpleDateFormat("yyyy", Locale.getDefault());
+
+    // These affect the scroll speed and feel
+    protected float mFriction = 1.0f;
+
+    protected Context mContext;
+    protected Handler mHandler;
+
+    // highlighted time
+    protected CalendarDay mSelectedDay = new CalendarDay();
+    protected MonthAdapter mAdapter;
+
+    protected CalendarDay mTempDay = new CalendarDay();
+
+    // When the week starts; numbered like Time.<WEEKDAY> (e.g. SUNDAY=0).
+    protected int mFirstDayOfWeek;
+    // The last name announced by accessibility
+    protected CharSequence mPrevMonthName;
+    // which month should be displayed/highlighted [0-11]
+    protected int mCurrentMonthDisplayed;
+    // used for tracking during a scroll
+    protected long mPreviousScrollPosition;
+    // used for tracking what state listview is in
+    protected int mPreviousScrollState = OnScrollListener.SCROLL_STATE_IDLE;
+    // used for tracking what state listview is in
+    protected int mCurrentScrollState = OnScrollListener.SCROLL_STATE_IDLE;
+
+    private DatePickerController mController;
+    private boolean mPerformingScroll;
+
+    public DayPickerView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init(context);
+    }
+
+    public DayPickerView(Context context, DatePickerController controller) {
+        super(context);
+        init(context);
+        setController(controller);
+    }
+
+    public void setController(DatePickerController controller) {
+        mController = controller;
+        mController.registerOnDateChangedListener(this);
+        refreshAdapter();
+        onDateChanged();
+    }
+
+    public void init(Context context) {
+        mHandler = new Handler();
+        setLayoutParams(new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+        setDrawSelectorOnTop(false);
+
+        mContext = context;
+        setUpListView();
+    }
+
+    public void onChange() {
+        refreshAdapter();
+    }
+
+    /**
+     * Creates a new adapter if necessary and sets up its parameters. Override
+     * this method to provide a custom adapter.
+     */
+    protected void refreshAdapter() {
+        if (mAdapter == null) {
+            mAdapter = createMonthAdapter(getContext(), mController);
+        } else {
+            mAdapter.setSelectedDay(mSelectedDay);
+        }
+        // refresh the view with the new parameters
+        setAdapter(mAdapter);
+    }
+
+    public abstract MonthAdapter createMonthAdapter(Context context,
+            DatePickerController controller);
+
+    /*
+     * Sets all the required fields for the list view. Override this method to
+     * set a different list view behavior.
+     */
+    protected void setUpListView() {
+        // Transparent background on scroll
+        setCacheColorHint(0);
+        // No dividers
+        setDivider(null);
+        // Items are clickable
+        setItemsCanFocus(true);
+        // The thumb gets in the way, so disable it
+        setFastScrollEnabled(false);
+        setVerticalScrollBarEnabled(false);
+        setOnScrollListener(this);
+        setFadingEdgeLength(0);
+        // Make the scrolling behavior nicer
+        setFriction(ViewConfiguration.getScrollFriction() * mFriction);
+    }
+
+    /**
+     * This moves to the specified time in the view. If the time is not already
+     * in range it will move the list so that the first of the month containing
+     * the time is at the top of the view. If the new time is already in view
+     * the list will not be scrolled unless forceScroll is true. This time may
+     * optionally be highlighted as selected as well.
+     *
+     * @param time The time to move to
+     * @param animate Whether to scroll to the given time or just redraw at the
+     *            new location
+     * @param setSelected Whether to set the given time as selected
+     * @param forceScroll Whether to recenter even if the time is already
+     *            visible
+     * @return Whether or not the view animated to the new location
+     */
+    public boolean goTo(CalendarDay day, boolean animate, boolean setSelected, boolean forceScroll) {
+
+        // Set the selected day
+        if (setSelected) {
+            mSelectedDay.set(day);
+        }
+
+        mTempDay.set(day);
+        final int position = (day.year - mController.getMinYear())
+                * MonthAdapter.MONTHS_IN_YEAR + day.month;
+
+        View child;
+        int i = 0;
+        int top = 0;
+        // Find a child that's completely in the view
+        do {
+            child = getChildAt(i++);
+            if (child == null) {
+                break;
+            }
+            top = child.getTop();
+            if (Log.isLoggable(TAG, Log.DEBUG)) {
+                Log.d(TAG, "child at " + (i - 1) + " has top " + top);
+            }
+        } while (top < 0);
+
+        // Compute the first and last position visible
+        int selectedPosition;
+        if (child != null) {
+            selectedPosition = getPositionForView(child);
+        } else {
+            selectedPosition = 0;
+        }
+
+        if (setSelected) {
+            mAdapter.setSelectedDay(mSelectedDay);
+        }
+
+        if (Log.isLoggable(TAG, Log.DEBUG)) {
+            Log.d(TAG, "GoTo position " + position);
+        }
+        // Check if the selected day is now outside of our visible range
+        // and if so scroll to the month that contains it
+        if (position != selectedPosition || forceScroll) {
+            setMonthDisplayed(mTempDay);
+            mPreviousScrollState = OnScrollListener.SCROLL_STATE_FLING;
+            if (animate) {
+                smoothScrollToPositionFromTop(
+                        position, LIST_TOP_OFFSET, GOTO_SCROLL_DURATION);
+                return true;
+            } else {
+                postSetSelection(position);
+            }
+        } else if (setSelected) {
+            setMonthDisplayed(mSelectedDay);
+        }
+        return false;
+    }
+
+    public void postSetSelection(final int position) {
+        clearFocus();
+        post(new Runnable() {
+
+            @Override
+            public void run() {
+                setSelection(position);
+            }
+        });
+        onScrollStateChanged(this, OnScrollListener.SCROLL_STATE_IDLE);
+    }
+
+    /**
+     * Updates the title and selected month if the view has moved to a new
+     * month.
+     */
+    @Override
+    public void onScroll(
+            AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
+        MonthView child = (MonthView) view.getChildAt(0);
+        if (child == null) {
+            return;
+        }
+
+        // Figure out where we are
+        long currScroll = view.getFirstVisiblePosition() * child.getHeight() - child.getBottom();
+        mPreviousScrollPosition = currScroll;
+        mPreviousScrollState = mCurrentScrollState;
+    }
+
+    /**
+     * Sets the month displayed at the top of this view based on time. Override
+     * to add custom events when the title is changed.
+     */
+    protected void setMonthDisplayed(CalendarDay date) {
+        mCurrentMonthDisplayed = date.month;
+        invalidateViews();
+    }
+
+    @Override
+    public void onScrollStateChanged(AbsListView view, int scrollState) {
+        // use a post to prevent re-entering onScrollStateChanged before it
+        // exits
+        mScrollStateChangedRunnable.doScrollStateChange(view, scrollState);
+    }
+
+    protected ScrollStateRunnable mScrollStateChangedRunnable = new ScrollStateRunnable();
+
+    protected class ScrollStateRunnable implements Runnable {
+        private int mNewState;
+
+        /**
+         * Sets up the runnable with a short delay in case the scroll state
+         * immediately changes again.
+         *
+         * @param view The list view that changed state
+         * @param scrollState The new state it changed to
+         */
+        public void doScrollStateChange(AbsListView view, int scrollState) {
+            mHandler.removeCallbacks(this);
+            mNewState = scrollState;
+            mHandler.postDelayed(this, SCROLL_CHANGE_DELAY);
+        }
+
+        @Override
+        public void run() {
+            mCurrentScrollState = mNewState;
+            if (Log.isLoggable(TAG, Log.DEBUG)) {
+                Log.d(TAG,
+                        "new scroll state: " + mNewState + " old state: " + mPreviousScrollState);
+            }
+            // Fix the position after a scroll or a fling ends
+            if (mNewState == OnScrollListener.SCROLL_STATE_IDLE
+                    && mPreviousScrollState != OnScrollListener.SCROLL_STATE_IDLE
+                    && mPreviousScrollState != OnScrollListener.SCROLL_STATE_TOUCH_SCROLL) {
+                mPreviousScrollState = mNewState;
+                int i = 0;
+                View child = getChildAt(i);
+                while (child != null && child.getBottom() <= 0) {
+                    child = getChildAt(++i);
+                }
+                if (child == null) {
+                    // The view is no longer visible, just return
+                    return;
+                }
+                int firstPosition = getFirstVisiblePosition();
+                int lastPosition = getLastVisiblePosition();
+                boolean scroll = firstPosition != 0 && lastPosition != getCount() - 1;
+                final int top = child.getTop();
+                final int bottom = child.getBottom();
+                final int midpoint = getHeight() / 2;
+                if (scroll && top < LIST_TOP_OFFSET) {
+                    if (bottom > midpoint) {
+                        smoothScrollBy(top, GOTO_SCROLL_DURATION);
+                    } else {
+                        smoothScrollBy(bottom, GOTO_SCROLL_DURATION);
+                    }
+                }
+            } else {
+                mPreviousScrollState = mNewState;
+            }
+        }
+    }
+
+    /**
+     * Gets the position of the view that is most prominently displayed within the list view.
+     */
+    public int getMostVisiblePosition() {
+        final int firstPosition = getFirstVisiblePosition();
+        final int height = getHeight();
+
+        int maxDisplayedHeight = 0;
+        int mostVisibleIndex = 0;
+        int i=0;
+        int bottom = 0;
+        while (bottom < height) {
+            View child = getChildAt(i);
+            if (child == null) {
+                break;
+            }
+            bottom = child.getBottom();
+            int displayedHeight = Math.min(bottom, height) - Math.max(0, child.getTop());
+            if (displayedHeight > maxDisplayedHeight) {
+                mostVisibleIndex = i;
+                maxDisplayedHeight = displayedHeight;
+            }
+            i++;
+        }
+        return firstPosition + mostVisibleIndex;
+    }
+
+    @Override
+    public void onDateChanged() {
+        goTo(mController.getSelectedDay(), false, true, true);
+    }
+
+    /**
+     * Attempts to return the date that has accessibility focus.
+     *
+     * @return The date that has accessibility focus, or {@code null} if no date
+     *         has focus.
+     */
+    private CalendarDay findAccessibilityFocus() {
+        final int childCount = getChildCount();
+        for (int i = 0; i < childCount; i++) {
+            final View child = getChildAt(i);
+            if (child instanceof MonthView) {
+                final CalendarDay focus = ((MonthView) child).getAccessibilityFocus();
+                if (focus != null) {
+                    if (Build.VERSION.SDK_INT == Build.VERSION_CODES.JELLY_BEAN_MR1) {
+                        // Clear focus to avoid ListView bug in Jelly Bean MR1.
+                        ((MonthView) child).clearAccessibilityFocus();
+                    }
+                    return focus;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Attempts to restore accessibility focus to a given date. No-op if
+     * {@code day} is {@code null}.
+     *
+     * @param day The date that should receive accessibility focus
+     * @return {@code true} if focus was restored
+     */
+    private boolean restoreAccessibilityFocus(CalendarDay day) {
+        if (day == null) {
+            return false;
+        }
+
+        final int childCount = getChildCount();
+        for (int i = 0; i < childCount; i++) {
+            final View child = getChildAt(i);
+            if (child instanceof MonthView) {
+                if (((MonthView) child).restoreAccessibilityFocus(day)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    protected void layoutChildren() {
+        final CalendarDay focusedDay = findAccessibilityFocus();
+        super.layoutChildren();
+        if (mPerformingScroll) {
+            mPerformingScroll = false;
+        } else {
+            restoreAccessibilityFocus(focusedDay);
+        }
+    }
+
+    @Override
+    public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
+        super.onInitializeAccessibilityEvent(event);
+        event.setItemCount(-1);
+   }
+
+    private static String getMonthAndYearString(CalendarDay day) {
+        Calendar cal = Calendar.getInstance();
+        cal.set(day.year, day.month, day.day);
+
+        StringBuffer sbuf = new StringBuffer();
+        sbuf.append(cal.getDisplayName(Calendar.MONTH, Calendar.LONG, Locale.getDefault()));
+        sbuf.append(" ");
+        sbuf.append(YEAR_FORMAT.format(cal.getTime()));
+        return sbuf.toString();
+    }
+
+    /**
+     * Necessary for accessibility, to ensure we support "scrolling" forward and backward
+     * in the month list.
+     */
+    @Override
+    public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
+      super.onInitializeAccessibilityNodeInfo(info);
+      info.addAction(AccessibilityNodeInfo.ACTION_SCROLL_FORWARD);
+      info.addAction(AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD);
+    }
+
+    /**
+     * When scroll forward/backward events are received, announce the newly scrolled-to month.
+     */
+    @SuppressLint("NewApi")
+    @Override
+    public boolean performAccessibilityAction(int action, Bundle arguments) {
+        if (action != AccessibilityNodeInfo.ACTION_SCROLL_FORWARD &&
+                action != AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD) {
+            return super.performAccessibilityAction(action, arguments);
+        }
+
+        // Figure out what month is showing.
+        int firstVisiblePosition = getFirstVisiblePosition();
+        int month = firstVisiblePosition % 12;
+        int year = firstVisiblePosition / 12 + mController.getMinYear();
+        CalendarDay day = new CalendarDay(year, month, 1);
+
+        // Scroll either forward or backward one month.
+        if (action == AccessibilityNodeInfo.ACTION_SCROLL_FORWARD) {
+            day.month++;
+            if (day.month == 12) {
+                day.month = 0;
+                day.year++;
+            }
+        } else if (action == AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD) {
+            View firstVisibleView = getChildAt(0);
+            // If the view is fully visible, jump one month back. Otherwise, we'll just jump
+            // to the first day of first visible month.
+            if (firstVisibleView != null && firstVisibleView.getTop() >= -1) {
+                // There's an off-by-one somewhere, so the top of the first visible item will
+                // actually be -1 when it's at the exact top.
+                day.month--;
+                if (day.month == -1) {
+                    day.month = 11;
+                    day.year--;
+                }
+            }
+        }
+
+        // Go to that month.
+        Utils.tryAccessibilityAnnounce(this, getMonthAndYearString(day));
+        goTo(day, true, false, true);
+        mPerformingScroll = true;
+        return true;
+    }
+}

uhabits-android/src/main/java/com/android/datetimepicker/date/MonthAdapter.java

@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2013 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.datetimepicker.date;
+
+import java.util.Calendar;
+import java.util.HashMap;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.text.format.Time;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.AbsListView.LayoutParams;
+import android.widget.BaseAdapter;
+
+import com.android.datetimepicker.date.MonthView.OnDayClickListener;
+
+/**
+ * An adapter for a list of {@link MonthView} items.
+ */
+public abstract class MonthAdapter extends BaseAdapter implements OnDayClickListener {
+
+    private static final String TAG = "SimpleMonthAdapter";
+
+    private final Context mContext;
+    private final DatePickerController mController;
+
+    private CalendarDay mSelectedDay;
+
+    protected static int WEEK_7_OVERHANG_HEIGHT = 7;
+    protected static final int MONTHS_IN_YEAR = 12;
+
+    /**
+     * A convenience class to represent a specific date.
+     */
+    public static class CalendarDay {
+        private Calendar calendar;
+        private Time time;
+        int year;
+        int month;
+        int day;
+
+        public CalendarDay() {
+            setTime(System.currentTimeMillis());
+        }
+
+        public CalendarDay(long timeInMillis) {
+            setTime(timeInMillis);
+        }
+
+        public CalendarDay(Calendar calendar) {
+            year = calendar.get(Calendar.YEAR);
+            month = calendar.get(Calendar.MONTH);
+            day = calendar.get(Calendar.DAY_OF_MONTH);
+        }
+
+        public CalendarDay(int year, int month, int day) {
+            setDay(year, month, day);
+        }
+
+        public void set(CalendarDay date) {
+            year = date.year;
+            month = date.month;
+            day = date.day;
+        }
+
+        public void setDay(int year, int month, int day) {
+            this.year = year;
+            this.month = month;
+            this.day = day;
+        }
+
+        public synchronized void setJulianDay(int julianDay) {
+            if (time == null) {
+                time = new Time();
+            }
+            time.setJulianDay(julianDay);
+            setTime(time.toMillis(false));
+        }
+
+        private void setTime(long timeInMillis) {
+            if (calendar == null) {
+                calendar = Calendar.getInstance();
+            }
+            calendar.setTimeInMillis(timeInMillis);
+            month = calendar.get(Calendar.MONTH);
+            year = calendar.get(Calendar.YEAR);
+            day = calendar.get(Calendar.DAY_OF_MONTH);
+        }
+    }
+
+    public MonthAdapter(Context context,
+            DatePickerController controller) {
+        mContext = context;
+        mController = controller;
+        init();
+        setSelectedDay(mController.getSelectedDay());
+    }
+
+    /**
+     * Updates the selected day and related parameters.
+     *
+     * @param day The day to highlight
+     */
+    public void setSelectedDay(CalendarDay day) {
+        mSelectedDay = day;
+        notifyDataSetChanged();
+    }
+
+    public CalendarDay getSelectedDay() {
+        return mSelectedDay;
+    }
+
+    /**
+     * Set up the gesture detector and selected time
+     */
+    protected void init() {
+        mSelectedDay = new CalendarDay(System.currentTimeMillis());
+    }
+
+    @Override
+    public int getCount() {
+        return ((mController.getMaxYear() - mController.getMinYear()) + 1) * MONTHS_IN_YEAR;
+    }
+
+    @Override
+    public Object getItem(int position) {
+        return null;
+    }
+
+    @Override
+    public long getItemId(int position) {
+        return position;
+    }
+
+    @Override
+    public boolean hasStableIds() {
+        return true;
+    }
+
+    @SuppressLint("NewApi")
+    @SuppressWarnings("unchecked")
+    @Override
+    public View getView(int position, View convertView, ViewGroup parent) {
+        MonthView v;
+        HashMap<String, Integer> drawingParams = null;
+        if (convertView != null) {
+            v = (MonthView) convertView;
+            // We store the drawing parameters in the view so it can be recycled
+            drawingParams = (HashMap<String, Integer>) v.getTag();
+        } else {
+            v = createMonthView(mContext);
+            // Set up the new view
+            LayoutParams params = new LayoutParams(
+                    LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
+            v.setLayoutParams(params);
+            v.setClickable(true);
+            v.setOnDayClickListener(this);
+        }
+        if (drawingParams == null) {
+            drawingParams = new HashMap<String, Integer>();
+        }
+        drawingParams.clear();
+
+        final int month = position % MONTHS_IN_YEAR;
+        final int year = position / MONTHS_IN_YEAR + mController.getMinYear();
+
+        int selectedDay = -1;
+        if (isSelectedDayInMonth(year, month)) {
+            selectedDay = mSelectedDay.day;
+        }
+
+        // Invokes requestLayout() to ensure that the recycled view is set with the appropriate
+        // height/number of weeks before being displayed.
+        v.reuse();
+
+        drawingParams.put(MonthView.VIEW_PARAMS_SELECTED_DAY, selectedDay);
+        drawingParams.put(MonthView.VIEW_PARAMS_YEAR, year);
+        drawingParams.put(MonthView.VIEW_PARAMS_MONTH, month);
+        drawingParams.put(MonthView.VIEW_PARAMS_WEEK_START, mController.getFirstDayOfWeek());
+        v.setMonthParams(drawingParams);
+        v.invalidate();
+        return v;
+    }
+
+    public abstract MonthView createMonthView(Context context);
+
+    private boolean isSelectedDayInMonth(int year, int month) {
+        return mSelectedDay.year == year && mSelectedDay.month == month;
+    }
+
+
+    @Override
+    public void onDayClick(MonthView view, CalendarDay day) {
+        if (day != null) {
+            onDayTapped(day);
+        }
+    }
+
+    /**
+     * Maintains the same hour/min/sec but moves the day to the tapped day.
+     *
+     * @param day The day that was tapped
+     */
+    protected void onDayTapped(CalendarDay day) {
+        mController.tryVibrate();
+        mController.onDayOfMonthSelected(day.year, day.month, day.day);
+        setSelectedDay(day);
+    }
+}

uhabits-android/src/main/java/com/android/datetimepicker/date/MonthView.java

@@ -0,0 +1,681 @@
+/*
+ * Copyright (C) 2013 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.datetimepicker.date;
+
+import android.content.*;
+import android.content.res.*;
+import android.graphics.*;
+import android.graphics.Paint.*;
+import android.os.*;
+import androidx.core.view.*;
+import androidx.core.view.accessibility.*;
+import androidx.core.widget.*;
+import android.text.format.*;
+import android.view.*;
+import android.view.accessibility.*;
+
+import androidx.customview.widget.ExploreByTouchHelper;
+
+import com.android.*;
+import com.android.datetimepicker.*;
+import com.android.datetimepicker.date.MonthAdapter.*;
+
+import org.isoron.uhabits.R;
+
+import java.security.*;
+import java.util.*;
+import java.util.Formatter;
+
+/**
+ * A calendar-like view displaying a specified month and the appropriate selectable day numbers
+ * within the specified month.
+ */
+public abstract class MonthView extends View {
+    private static final String TAG = "MonthView";
+
+    /**
+     * These params can be passed into the view to control how it appears.
+     * {@link #VIEW_PARAMS_WEEK} is the only required field, though the default
+     * values are unlikely to fit most layouts correctly.
+     */
+    /**
+     * This sets the height of this week in pixels
+     */
+    public static final String VIEW_PARAMS_HEIGHT = "height";
+    /**
+     * This specifies the position (or weeks since the epoch) of this week,
+     * calculated using {@link Utils#getWeeksSinceEpochFromJulianDay}
+     */
+    public static final String VIEW_PARAMS_MONTH = "month";
+    /**
+     * This specifies the position (or weeks since the epoch) of this week,
+     * calculated using {@link Utils#getWeeksSinceEpochFromJulianDay}
+     */
+    public static final String VIEW_PARAMS_YEAR = "year";
+    /**
+     * This sets one of the days in this view as selected {@link Time#SUNDAY}
+     * through {@link Time#SATURDAY}.
+     */
+    public static final String VIEW_PARAMS_SELECTED_DAY = "selected_day";
+    /**
+     * Which day the week should start on. {@link Time#SUNDAY} through
+     * {@link Time#SATURDAY}.
+     */
+    public static final String VIEW_PARAMS_WEEK_START = "week_start";
+    /**
+     * How many days to display at a time. Days will be displayed starting with
+     * {@link #mWeekStart}.
+     */
+    public static final String VIEW_PARAMS_NUM_DAYS = "num_days";
+    /**
+     * Which month is currently in focus, as defined by {@link Time#month}
+     * [0-11].
+     */
+    public static final String VIEW_PARAMS_FOCUS_MONTH = "focus_month";
+    /**
+     * If this month should display week numbers. false if 0, true otherwise.
+     */
+    public static final String VIEW_PARAMS_SHOW_WK_NUM = "show_wk_num";
+
+    protected static int DEFAULT_HEIGHT = 32;
+    protected static int MIN_HEIGHT = 10;
+    protected static final int DEFAULT_SELECTED_DAY = -1;
+    protected static final int DEFAULT_WEEK_START = Calendar.SUNDAY;
+    protected static final int DEFAULT_NUM_DAYS = 7;
+    protected static final int DEFAULT_SHOW_WK_NUM = 0;
+    protected static final int DEFAULT_FOCUS_MONTH = -1;
+    protected static final int DEFAULT_NUM_ROWS = 6;
+    protected static final int MAX_NUM_ROWS = 6;
+
+    private static final int SELECTED_CIRCLE_ALPHA = 60;
+
+    protected static int DAY_SEPARATOR_WIDTH = 1;
+    protected static int MINI_DAY_NUMBER_TEXT_SIZE;
+    protected static int MONTH_LABEL_TEXT_SIZE;
+    protected static int MONTH_DAY_LABEL_TEXT_SIZE;
+    protected static int MONTH_HEADER_SIZE;
+    protected static int DAY_SELECTED_CIRCLE_SIZE;
+
+    // used for scaling to the device density
+    protected static float mScale = 0;
+
+    // affects the padding on the sides of this view
+    protected int mPadding = 0;
+
+    private String mDayOfWeekTypeface;
+    private String mMonthTitleTypeface;
+
+    protected Paint mMonthNumPaint;
+    protected Paint mMonthTitlePaint;
+    protected Paint mMonthTitleBGPaint;
+    protected Paint mSelectedCirclePaint;
+    protected Paint mMonthDayLabelPaint;
+
+    private final Formatter mFormatter;
+    private final StringBuilder mStringBuilder;
+
+    // The Julian day of the first day displayed by this item
+    protected int mFirstJulianDay = -1;
+    // The month of the first day in this week
+    protected int mFirstMonth = -1;
+    // The month of the last day in this week
+    protected int mLastMonth = -1;
+
+    protected int mMonth;
+
+    protected int mYear;
+    // Quick reference to the width of this view, matches parent
+    protected int mWidth;
+    // The height this view should draw at in pixels, set by height param
+    protected int mRowHeight = DEFAULT_HEIGHT;
+    // If this view contains the today
+    protected boolean mHasToday = false;
+    // Which day is selected [0-6] or -1 if no day is selected
+    protected int mSelectedDay = -1;
+    // Which day is today [0-6] or -1 if no day is today
+    protected int mToday = DEFAULT_SELECTED_DAY;
+    // Which day of the week to start on [0-6]
+    protected int mWeekStart = DEFAULT_WEEK_START;
+    // How many days to display
+    protected int mNumDays = DEFAULT_NUM_DAYS;
+    // The number of days + a spot for week number if it is displayed
+    protected int mNumCells = mNumDays;
+    // The left edge of the selected day
+    protected int mSelectedLeft = -1;
+    // The right edge of the selected day
+    protected int mSelectedRight = -1;
+
+    private final Calendar mCalendar;
+    private final Calendar mDayLabelCalendar;
+    private final MonthViewTouchHelper mTouchHelper;
+
+    private int mNumRows = DEFAULT_NUM_ROWS;
+
+    // Optional listener for handling day click actions
+    private OnDayClickListener mOnDayClickListener;
+    // Whether to prevent setting the accessibility delegate
+    private boolean mLockAccessibilityDelegate;
+
+    protected int mDayTextColor;
+    protected int mTodayNumberColor;
+    protected int mMonthTitleColor;
+    protected int mMonthTitleBGColor;
+
+    public MonthView(Context context) {
+        super(context);
+
+        Resources res = context.getResources();
+
+        mDayLabelCalendar = Calendar.getInstance();
+        mCalendar = Calendar.getInstance();
+
+        mDayOfWeekTypeface = res.getString(R.string.day_of_week_label_typeface);
+        mMonthTitleTypeface = res.getString(R.string.sans_serif);
+
+        mDayTextColor = res.getColor(R.color.date_picker_text_normal);
+        mTodayNumberColor = res.getColor(R.color.blue);
+        mMonthTitleColor = res.getColor(R.color.white);
+        mMonthTitleBGColor = res.getColor(R.color.circle_background);
+
+        mStringBuilder = new StringBuilder(50);
+        mFormatter = new Formatter(mStringBuilder, Locale.getDefault());
+
+        MINI_DAY_NUMBER_TEXT_SIZE = res.getDimensionPixelSize(R.dimen.day_number_size);
+        MONTH_LABEL_TEXT_SIZE = res.getDimensionPixelSize(R.dimen.month_label_size);
+        MONTH_DAY_LABEL_TEXT_SIZE = res.getDimensionPixelSize(R.dimen.month_day_label_text_size);
+        MONTH_HEADER_SIZE = res.getDimensionPixelOffset(R.dimen.month_list_item_header_height);
+        DAY_SELECTED_CIRCLE_SIZE = res
+                .getDimensionPixelSize(R.dimen.day_number_select_circle_radius);
+
+        mRowHeight = (res.getDimensionPixelOffset(R.dimen.date_picker_view_animator_height)
+                - MONTH_HEADER_SIZE) / MAX_NUM_ROWS;
+
+        // Set up accessibility components.
+        mTouchHelper = new MonthViewTouchHelper(this);
+        ViewCompat.setAccessibilityDelegate(this, mTouchHelper);
+        ViewCompat.setImportantForAccessibility(this, ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_YES);
+        mLockAccessibilityDelegate = true;
+
+        // Sets up any standard paints that will be used
+        initView();
+    }
+
+    @Override
+    public void setAccessibilityDelegate(AccessibilityDelegate delegate) {
+        // Workaround for a JB MR1 issue where accessibility delegates on
+        // top-level ListView items are overwritten.
+        if (!mLockAccessibilityDelegate) {
+            super.setAccessibilityDelegate(delegate);
+        }
+    }
+
+    public void setOnDayClickListener(OnDayClickListener listener) {
+        mOnDayClickListener = listener;
+    }
+
+    @Override
+    public boolean dispatchHoverEvent(MotionEvent event) {
+        // First right-of-refusal goes the touch exploration helper.
+        if (mTouchHelper.dispatchHoverEvent(event)) {
+            return true;
+        }
+        return super.dispatchHoverEvent(event);
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        switch (event.getAction()) {
+            case MotionEvent.ACTION_UP:
+                final int day = getDayFromLocation(event.getX(), event.getY());
+                if (day >= 0) {
+                    onDayClick(day);
+                }
+                break;
+        }
+        return true;
+    }
+
+    /**
+     * Sets up the text and style properties for painting. Override this if you
+     * want to use a different paint.
+     */
+    protected void initView() {
+        mMonthTitlePaint = new Paint();
+        mMonthTitlePaint.setFakeBoldText(true);
+        mMonthTitlePaint.setAntiAlias(true);
+        mMonthTitlePaint.setTextSize(MONTH_LABEL_TEXT_SIZE);
+        mMonthTitlePaint.setTypeface(Typeface.create(mMonthTitleTypeface, Typeface.BOLD));
+        mMonthTitlePaint.setColor(mDayTextColor);
+        mMonthTitlePaint.setTextAlign(Align.CENTER);
+        mMonthTitlePaint.setStyle(Style.FILL);
+
+        mMonthTitleBGPaint = new Paint();
+        mMonthTitleBGPaint.setFakeBoldText(true);
+        mMonthTitleBGPaint.setAntiAlias(true);
+        mMonthTitleBGPaint.setColor(mMonthTitleBGColor);
+        mMonthTitleBGPaint.setTextAlign(Align.CENTER);
+        mMonthTitleBGPaint.setStyle(Style.FILL);
+
+        mSelectedCirclePaint = new Paint();
+        mSelectedCirclePaint.setFakeBoldText(true);
+        mSelectedCirclePaint.setAntiAlias(true);
+        mSelectedCirclePaint.setColor(mTodayNumberColor);
+        mSelectedCirclePaint.setTextAlign(Align.CENTER);
+        mSelectedCirclePaint.setStyle(Style.FILL);
+        mSelectedCirclePaint.setAlpha(SELECTED_CIRCLE_ALPHA);
+
+        mMonthDayLabelPaint = new Paint();
+        mMonthDayLabelPaint.setAntiAlias(true);
+        mMonthDayLabelPaint.setTextSize(MONTH_DAY_LABEL_TEXT_SIZE);
+        mMonthDayLabelPaint.setColor(mDayTextColor);
+        mMonthDayLabelPaint.setTypeface(Typeface.create(mDayOfWeekTypeface, Typeface.NORMAL));
+        mMonthDayLabelPaint.setStyle(Style.FILL);
+        mMonthDayLabelPaint.setTextAlign(Align.CENTER);
+        mMonthDayLabelPaint.setFakeBoldText(true);
+
+        mMonthNumPaint = new Paint();
+        mMonthNumPaint.setAntiAlias(true);
+        mMonthNumPaint.setTextSize(MINI_DAY_NUMBER_TEXT_SIZE);
+        mMonthNumPaint.setStyle(Style.FILL);
+        mMonthNumPaint.setTextAlign(Align.CENTER);
+        mMonthNumPaint.setFakeBoldText(false);
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        drawMonthTitle(canvas);
+        drawMonthDayLabels(canvas);
+        drawMonthNums(canvas);
+    }
+
+    private int mDayOfWeekStart = 0;
+
+    /**
+     * Sets all the parameters for displaying this week. The only required
+     * parameter is the week number. Other parameters have a default value and
+     * will only update if a new value is included, except for focus month,
+     * which will always default to no focus month if no value is passed in. See
+     * {@link #VIEW_PARAMS_HEIGHT} for more info on parameters.
+     *
+     * @param params A map of the new parameters, see
+     *            {@link #VIEW_PARAMS_HEIGHT}
+     */
+    public void setMonthParams(HashMap<String, Integer> params) {
+        if (!params.containsKey(VIEW_PARAMS_MONTH) && !params.containsKey(VIEW_PARAMS_YEAR)) {
+            throw new InvalidParameterException("You must specify month and year for this view");
+        }
+        setTag(params);
+        // We keep the current value for any params not present
+        if (params.containsKey(VIEW_PARAMS_HEIGHT)) {
+            mRowHeight = params.get(VIEW_PARAMS_HEIGHT);
+            if (mRowHeight < MIN_HEIGHT) {
+                mRowHeight = MIN_HEIGHT;
+            }
+        }
+        if (params.containsKey(VIEW_PARAMS_SELECTED_DAY)) {
+            mSelectedDay = params.get(VIEW_PARAMS_SELECTED_DAY);
+        }
+
+        // Allocate space for caching the day numbers and focus values
+        mMonth = params.get(VIEW_PARAMS_MONTH);
+        mYear = params.get(VIEW_PARAMS_YEAR);
+
+        // Figure out what day today is
+        final Time today = new Time(Time.getCurrentTimezone());
+        today.setToNow();
+        mHasToday = false;
+        mToday = -1;
+
+        mCalendar.set(Calendar.MONTH, mMonth);
+        mCalendar.set(Calendar.YEAR, mYear);
+        mCalendar.set(Calendar.DAY_OF_MONTH, 1);
+        mDayOfWeekStart = mCalendar.get(Calendar.DAY_OF_WEEK);
+
+        if (params.containsKey(VIEW_PARAMS_WEEK_START)) {
+            mWeekStart = params.get(VIEW_PARAMS_WEEK_START);
+        } else {
+            mWeekStart = mCalendar.getFirstDayOfWeek();
+        }
+
+        mNumCells = Utils.getDaysInMonth(mMonth, mYear);
+        for (int i = 0; i < mNumCells; i++) {
+            final int day = i + 1;
+            if (sameDay(day, today)) {
+                mHasToday = true;
+                mToday = day;
+            }
+        }
+        mNumRows = calculateNumRows();
+
+        // Invalidate cached accessibility information.
+        mTouchHelper.invalidateRoot();
+    }
+
+    public void reuse() {
+        mNumRows = DEFAULT_NUM_ROWS;
+        requestLayout();
+    }
+
+    private int calculateNumRows() {
+        int offset = findDayOffset();
+        int dividend = (offset + mNumCells) / mNumDays;
+        int remainder = (offset + mNumCells) % mNumDays;
+        return (dividend + (remainder > 0 ? 1 : 0));
+    }
+
+    private boolean sameDay(int day, Time today) {
+        return mYear == today.year &&
+                mMonth == today.month &&
+                day == today.monthDay;
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        setMeasuredDimension(MeasureSpec.getSize(widthMeasureSpec), mRowHeight * mNumRows
+                + MONTH_HEADER_SIZE);
+    }
+
+    @Override
+    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+        mWidth = w;
+
+        // Invalidate cached accessibility information.
+        mTouchHelper.invalidateRoot();
+    }
+
+    private String getMonthAndYearString() {
+        int flags = DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_YEAR
+                | DateUtils.FORMAT_NO_MONTH_DAY;
+        mStringBuilder.setLength(0);
+        long millis = mCalendar.getTimeInMillis();
+        return DateUtils.formatDateRange(getContext(), mFormatter, millis, millis, flags,
+                Time.getCurrentTimezone()).toString();
+    }
+
+    private void drawMonthTitle(Canvas canvas) {
+        int x = (mWidth + 2 * mPadding) / 2;
+        int y = (MONTH_HEADER_SIZE - MONTH_DAY_LABEL_TEXT_SIZE) / 2 + (MONTH_LABEL_TEXT_SIZE / 3);
+        canvas.drawText(getMonthAndYearString(), x, y, mMonthTitlePaint);
+    }
+
+    private void drawMonthDayLabels(Canvas canvas) {
+        int y = MONTH_HEADER_SIZE - (MONTH_DAY_LABEL_TEXT_SIZE / 2);
+        int dayWidthHalf = (mWidth - mPadding * 2) / (mNumDays * 2);
+
+        for (int i = 0; i < mNumDays; i++) {
+            int calendarDay = (i + mWeekStart) % mNumDays;
+            int x = (2 * i + 1) * dayWidthHalf + mPadding;
+            mDayLabelCalendar.set(Calendar.DAY_OF_WEEK, calendarDay);
+            canvas.drawText(mDayLabelCalendar.getDisplayName(Calendar.DAY_OF_WEEK, Calendar.SHORT,
+                    Locale.getDefault()).toUpperCase(Locale.getDefault()), x, y,
+                    mMonthDayLabelPaint);
+        }
+    }
+
+    /**
+     * Draws the week and month day numbers for this week. Override this method
+     * if you need different placement.
+     *
+     * @param canvas The canvas to draw on
+     */
+    protected void drawMonthNums(Canvas canvas) {
+        int y = (((mRowHeight + MINI_DAY_NUMBER_TEXT_SIZE) / 2) - DAY_SEPARATOR_WIDTH)
+                + MONTH_HEADER_SIZE;
+        int dayWidthHalf = (mWidth - mPadding * 2) / (mNumDays * 2);
+        int j = findDayOffset();
+        for (int dayNumber = 1; dayNumber <= mNumCells; dayNumber++) {
+            int x = (2 * j + 1) * dayWidthHalf + mPadding;
+
+            int yRelativeToDay = (mRowHeight + MINI_DAY_NUMBER_TEXT_SIZE) / 2 - DAY_SEPARATOR_WIDTH;
+
+            int startX = x - dayWidthHalf;
+            int stopX = x + dayWidthHalf;
+            int startY = y - yRelativeToDay;
+            int stopY = startY + mRowHeight;
+
+            drawMonthDay(canvas, mYear, mMonth, dayNumber, x, y, startX, stopX, startY, stopY);
+
+            j++;
+            if (j == mNumDays) {
+                j = 0;
+                y += mRowHeight;
+            }
+        }
+    }
+
+    /**
+     * This method should draw the month day.  Implemented by sub-classes to allow customization.
+     *
+     * @param canvas  The canvas to draw on
+     * @param year  The year of this month day
+     * @param month  The month of this month day
+     * @param day  The day number of this month day
+     * @param x  The default x position to draw the day number
+     * @param y  The default y position to draw the day number
+     * @param startX  The left boundary of the day number rect
+     * @param stopX  The right boundary of the day number rect
+     * @param startY  The top boundary of the day number rect
+     * @param stopY  The bottom boundary of the day number rect
+     */
+    public abstract void drawMonthDay(Canvas canvas, int year, int month, int day,
+            int x, int y, int startX, int stopX, int startY, int stopY);
+
+    private int findDayOffset() {
+        return (mDayOfWeekStart < mWeekStart ? (mDayOfWeekStart + mNumDays) : mDayOfWeekStart)
+                - mWeekStart;
+    }
+
+
+    /**
+     * Calculates the day that the given x position is in, accounting for week
+     * number. Returns the day or -1 if the position wasn't in a day.
+     *
+     * @param x The x position of the touch event
+     * @return The day number, or -1 if the position wasn't in a day
+     */
+    public int getDayFromLocation(float x, float y) {
+        int dayStart = mPadding;
+        if (x < dayStart || x > mWidth - mPadding) {
+            return -1;
+        }
+        // Selection is (x - start) / (pixels/day) == (x -s) * day / pixels
+        int row = (int) (y - MONTH_HEADER_SIZE) / mRowHeight;
+        int column = (int) ((x - dayStart) * mNumDays / (mWidth - dayStart - mPadding));
+
+        int day = column - findDayOffset() + 1;
+        day += row * mNumDays;
+        if (day < 1 || day > mNumCells) {
+            return -1;
+        }
+        return day;
+    }
+
+    /**
+     * Called when the user clicks on a day. Handles callbacks to the
+     * {@link OnDayClickListener} if one is set.
+     *
+     * @param day The day that was clicked
+     */
+    private void onDayClick(int day) {
+        if (mOnDayClickListener != null) {
+            mOnDayClickListener.onDayClick(this, new CalendarDay(mYear, mMonth, day));
+        }
+
+        // This is a no-op if accessibility is turned off.
+        mTouchHelper.sendEventForVirtualView(day, AccessibilityEvent.TYPE_VIEW_CLICKED);
+    }
+
+    /**
+     * @return The date that has accessibility focus, or {@code null} if no date
+     *         has focus
+     */
+    public CalendarDay getAccessibilityFocus() {
+        final int day = mTouchHelper.getFocusedVirtualView();
+        if (day >= 0) {
+            return new CalendarDay(mYear, mMonth, day);
+        }
+        return null;
+    }
+
+    /**
+     * Clears accessibility focus within the view. No-op if the view does not
+     * contain accessibility focus.
+     */
+    public void clearAccessibilityFocus() {
+        mTouchHelper.clearFocusedVirtualView();
+    }
+
+    /**
+     * Attempts to restore accessibility focus to the specified date.
+     *
+     * @param day The date which should receive focus
+     * @return {@code false} if the date is not valid for this month view, or
+     *         {@code true} if the date received focus
+     */
+    public boolean restoreAccessibilityFocus(CalendarDay day) {
+        if ((day.year != mYear) || (day.month != mMonth) || (day.day > mNumCells)) {
+            return false;
+        }
+        mTouchHelper.setFocusedVirtualView(day.day);
+        return true;
+    }
+
+    /**
+     * Provides a virtual view hierarchy for interfacing with an accessibility
+     * service.
+     */
+    private class MonthViewTouchHelper extends ExploreByTouchHelper {
+        private static final String DATE_FORMAT = "dd MMMM yyyy";
+
+        private final Rect mTempRect = new Rect();
+        private final Calendar mTempCalendar = Calendar.getInstance();
+
+        public MonthViewTouchHelper(View host) {
+            super(host);
+        }
+
+        public void setFocusedVirtualView(int virtualViewId) {
+            getAccessibilityNodeProvider(MonthView.this).performAction(
+                    virtualViewId, AccessibilityNodeInfoCompat.ACTION_ACCESSIBILITY_FOCUS, null);
+        }
+
+        public void clearFocusedVirtualView() {
+            final int focusedVirtualView = getFocusedVirtualView();
+            if (focusedVirtualView != ExploreByTouchHelper.INVALID_ID) {
+                getAccessibilityNodeProvider(MonthView.this).performAction(
+                        focusedVirtualView,
+                        AccessibilityNodeInfoCompat.ACTION_CLEAR_ACCESSIBILITY_FOCUS,
+                        null);
+            }
+        }
+
+        @Override
+        protected int getVirtualViewAt(float x, float y) {
+            final int day = getDayFromLocation(x, y);
+            if (day >= 0) {
+                return day;
+            }
+            return ExploreByTouchHelper.INVALID_ID;
+        }
+
+        @Override
+        protected void getVisibleVirtualViews(List<Integer> virtualViewIds) {
+            for (int day = 1; day <= mNumCells; day++) {
+                virtualViewIds.add(day);
+            }
+        }
+
+        @Override
+        protected void onPopulateEventForVirtualView(int virtualViewId, AccessibilityEvent event) {
+            event.setContentDescription(getItemDescription(virtualViewId));
+        }
+
+        @Override
+        protected void onPopulateNodeForVirtualView(int virtualViewId,
+                AccessibilityNodeInfoCompat node) {
+            getItemBounds(virtualViewId, mTempRect);
+
+            node.setContentDescription(getItemDescription(virtualViewId));
+            node.setBoundsInParent(mTempRect);
+            node.addAction(AccessibilityNodeInfo.ACTION_CLICK);
+
+            if (virtualViewId == mSelectedDay) {
+                node.setSelected(true);
+            }
+
+        }
+
+        @Override
+        protected boolean onPerformActionForVirtualView(int virtualViewId, int action,
+                Bundle arguments) {
+            switch (action) {
+                case AccessibilityNodeInfo.ACTION_CLICK:
+                    onDayClick(virtualViewId);
+                    return true;
+            }
+
+            return false;
+        }
+
+        /**
+         * Calculates the bounding rectangle of a given time object.
+         *
+         * @param day The day to calculate bounds for
+         * @param rect The rectangle in which to store the bounds
+         */
+        private void getItemBounds(int day, Rect rect) {
+            final int offsetX = mPadding;
+            final int offsetY = MONTH_HEADER_SIZE;
+            final int cellHeight = mRowHeight;
+            final int cellWidth = ((mWidth - (2 * mPadding)) / mNumDays);
+            final int index = ((day - 1) + findDayOffset());
+            final int row = (index / mNumDays);
+            final int column = (index % mNumDays);
+            final int x = (offsetX + (column * cellWidth));
+            final int y = (offsetY + (row * cellHeight));
+
+            rect.set(x, y, (x + cellWidth), (y + cellHeight));
+        }
+
+        /**
+         * Generates a description for a given time object. Since this
+         * description will be spoken, the components are ordered by descending
+         * specificity as DAY MONTH YEAR.
+         *
+         * @param day The day to generate a description for
+         * @return A description of the time object
+         */
+        private CharSequence getItemDescription(int day) {
+            mTempCalendar.set(mYear, mMonth, day);
+            final CharSequence date = DateFormat.format(DATE_FORMAT,
+                    mTempCalendar.getTimeInMillis());
+
+            if (day == mSelectedDay) {
+                return getContext().getString(R.string.item_is_selected, date);
+            }
+
+            return date;
+        }
+    }
+
+    /**
+     * Handles callbacks when the user clicks on a time object.
+     */
+    public interface OnDayClickListener {
+        public void onDayClick(MonthView view, CalendarDay day);
+    }
+}

uhabits-android/src/main/java/com/android/datetimepicker/date/SimpleDayPickerView.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2013 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.datetimepicker.date;
+
+import android.content.Context;
+import android.util.AttributeSet;
+
+/**
+ * A DayPickerView customized for {@link SimpleMonthAdapter}
+ */
+public class SimpleDayPickerView extends DayPickerView {
+
+    public SimpleDayPickerView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public SimpleDayPickerView(Context context, DatePickerController controller) {
+        super(context, controller);
+    }
+
+    @Override
+    public MonthAdapter createMonthAdapter(Context context, DatePickerController controller) {
+        return new SimpleMonthAdapter(context, controller);
+    }
+
+}

uhabits-android/src/main/java/com/android/datetimepicker/date/SimpleMonthAdapter.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2013 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.datetimepicker.date;
+
+import android.content.Context;
+
+/**
+ * An adapter for a list of {@link SimpleMonthView} items.
+ */
+public class SimpleMonthAdapter extends MonthAdapter {
+
+    public SimpleMonthAdapter(Context context, DatePickerController controller) {
+        super(context, controller);
+    }
+
+    @Override
+    public MonthView createMonthView(Context context) {
+        return new SimpleMonthView(context);
+    }
+}

uhabits-android/src/main/java/com/android/datetimepicker/date/SimpleMonthView.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2013 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.datetimepicker.date;
+
+import android.content.Context;
+import android.graphics.Canvas;
+
+public class SimpleMonthView extends MonthView {
+
+    public SimpleMonthView(Context context) {
+        super(context);
+    }
+
+    @Override
+    public void drawMonthDay(Canvas canvas, int year, int month, int day,
+            int x, int y, int startX, int stopX, int startY, int stopY) {
+        if (mSelectedDay == day) {
+            canvas.drawCircle(x , y - (MINI_DAY_NUMBER_TEXT_SIZE / 3), DAY_SELECTED_CIRCLE_SIZE,
+                    mSelectedCirclePaint);
+        }
+
+        if (mHasToday && mToday == day) {
+            mMonthNumPaint.setColor(mTodayNumberColor);
+        } else {
+            mMonthNumPaint.setColor(mDayTextColor);
+        }
+        canvas.drawText(String.format("%d", day), x, y, mMonthNumPaint);
+    }
+}

uhabits-android/src/main/java/com/android/datetimepicker/date/TextViewWithCircularIndicator.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2013 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.datetimepicker.date;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Paint.Align;
+import android.graphics.Paint.Style;
+import android.util.AttributeSet;
+import android.widget.TextView;
+
+import org.isoron.uhabits.R;
+
+/**
+ * A text view which, when pressed or activated, displays a blue circle around the text.
+ */
+public class TextViewWithCircularIndicator extends TextView {
+
+    private static final int SELECTED_CIRCLE_ALPHA = 60;
+
+    Paint mCirclePaint = new Paint();
+
+    private final int mRadius;
+    private final int mCircleColor;
+    private final String mItemIsSelectedText;
+
+    private boolean mDrawCircle;
+
+    public TextViewWithCircularIndicator(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        Resources res = context.getResources();
+        mCircleColor = res.getColor(R.color.blue);
+        mRadius = res.getDimensionPixelOffset(R.dimen.month_select_circle_radius);
+        mItemIsSelectedText = context.getResources().getString(R.string.item_is_selected);
+
+        init();
+    }
+
+    private void init() {
+        mCirclePaint.setFakeBoldText(true);
+        mCirclePaint.setAntiAlias(true);
+        mCirclePaint.setColor(mCircleColor);
+        mCirclePaint.setTextAlign(Align.CENTER);
+        mCirclePaint.setStyle(Style.FILL);
+        mCirclePaint.setAlpha(SELECTED_CIRCLE_ALPHA);
+    }
+
+    public void drawIndicator(boolean drawCircle) {
+        mDrawCircle = drawCircle;
+    }
+
+    @Override
+    public void onDraw(Canvas canvas) {
+        super.onDraw(canvas);
+        if (mDrawCircle) {
+            final int width = getWidth();
+            final int height = getHeight();
+            int radius = Math.min(width, height) / 2;
+            canvas.drawCircle(width / 2, height / 2, radius, mCirclePaint);
+        }
+    }
+
+    @Override
+    public CharSequence getContentDescription() {
+        CharSequence itemText = getText();
+        if (mDrawCircle) {
+            return String.format(mItemIsSelectedText, itemText);
+        } else {
+            return itemText;
+        }
+    }
+}

uhabits-android/src/main/java/com/android/datetimepicker/date/YearPickerView.java

@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2013 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.datetimepicker.date;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.drawable.StateListDrawable;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.accessibility.AccessibilityEvent;
+import android.widget.AdapterView;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.ArrayAdapter;
+import android.widget.ListView;
+import android.widget.TextView;
+
+import com.android.datetimepicker.date.DatePickerDialog.OnDateChangedListener;
+
+import org.isoron.uhabits.R;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Displays a selectable list of years.
+ */
+public class YearPickerView extends ListView implements OnItemClickListener, OnDateChangedListener {
+    private static final String TAG = "YearPickerView";
+
+    private final DatePickerController mController;
+    private YearAdapter mAdapter;
+    private int mViewSize;
+    private int mChildSize;
+    private TextViewWithCircularIndicator mSelectedView;
+
+    /**
+     * @param context
+     */
+    public YearPickerView(Context context, DatePickerController controller) {
+        super(context);
+        mController = controller;
+        mController.registerOnDateChangedListener(this);
+        ViewGroup.LayoutParams frame = new ViewGroup.LayoutParams(LayoutParams.MATCH_PARENT,
+                LayoutParams.WRAP_CONTENT);
+        setLayoutParams(frame);
+        Resources res = context.getResources();
+        mViewSize = res.getDimensionPixelOffset(R.dimen.date_picker_view_animator_height);
+        mChildSize = res.getDimensionPixelOffset(R.dimen.year_label_height);
+        setVerticalFadingEdgeEnabled(true);
+        setFadingEdgeLength(mChildSize / 3);
+        init(context);
+        setOnItemClickListener(this);
+        setSelector(new StateListDrawable());
+        setDividerHeight(0);
+        onDateChanged();
+    }
+
+    private void init(Context context) {
+        ArrayList<String> years = new ArrayList<String>();
+        for (int year = mController.getMinYear(); year <= mController.getMaxYear(); year++) {
+            years.add(String.format("%d", year));
+        }
+        mAdapter = new YearAdapter(context, R.layout.year_label_text_view, years);
+        setAdapter(mAdapter);
+    }
+
+    @Override
+    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
+        mController.tryVibrate();
+        TextViewWithCircularIndicator clickedView = (TextViewWithCircularIndicator) view;
+        if (clickedView != null) {
+            if (clickedView != mSelectedView) {
+                if (mSelectedView != null) {
+                    mSelectedView.drawIndicator(false);
+                    mSelectedView.requestLayout();
+                }
+                clickedView.drawIndicator(true);
+                clickedView.requestLayout();
+                mSelectedView = clickedView;
+            }
+            mController.onYearSelected(getYearFromTextView(clickedView));
+            mAdapter.notifyDataSetChanged();
+        }
+    }
+
+    private static int getYearFromTextView(TextView view) {
+        return Integer.valueOf(view.getText().toString());
+    }
+
+    private class YearAdapter extends ArrayAdapter<String> {
+
+        public YearAdapter(Context context, int resource, List<String> objects) {
+            super(context, resource, objects);
+        }
+
+        @Override
+        public View getView(int position, View convertView, ViewGroup parent) {
+            TextViewWithCircularIndicator v = (TextViewWithCircularIndicator)
+                    super.getView(position, convertView, parent);
+            v.requestLayout();
+            int year = getYearFromTextView(v);
+            boolean selected = mController.getSelectedDay().year == year;
+            v.drawIndicator(selected);
+            if (selected) {
+                mSelectedView = v;
+            }
+            return v;
+        }
+    }
+
+    public void postSetSelectionCentered(final int position) {
+        postSetSelectionFromTop(position, mViewSize / 2 - mChildSize / 2);
+    }
+
+    public void postSetSelectionFromTop(final int position, final int offset) {
+        post(new Runnable() {
+
+            @Override
+            public void run() {
+                setSelectionFromTop(position, offset);
+                requestLayout();
+            }
+        });
+    }
+
+    public int getFirstPositionOffset() {
+        final View firstChild = getChildAt(0);
+        if (firstChild == null) {
+            return 0;
+        }
+        return firstChild.getTop();
+    }
+
+    @Override
+    public void onDateChanged() {
+        mAdapter.notifyDataSetChanged();
+        postSetSelectionCentered(mController.getSelectedDay().year - mController.getMinYear());
+    }
+
+    @Override
+    public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
+        super.onInitializeAccessibilityEvent(event);
+        if (event.getEventType() == AccessibilityEvent.TYPE_VIEW_SCROLLED) {
+            event.setFromIndex(0);
+            event.setToIndex(0);
+        }
+    }
+}

uhabits-android/src/main/java/com/android/datetimepicker/time/AmPmCirclesView.java

@@ -0,0 +1,211 @@
+/*
+ * Copyright (C) 2013 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.datetimepicker.time;
+
+import android.content.*;
+import android.content.res.*;
+import android.graphics.*;
+import android.graphics.Paint.*;
+import android.util.*;
+import android.view.*;
+
+import com.android.*;
+import com.android.datetimepicker.*;
+
+import org.isoron.uhabits.R;
+
+import java.text.*;
+
+/**
+ * Draw the two smaller AM and PM circles next to where the larger circle will be.
+ */
+public class AmPmCirclesView extends View {
+    private static final String TAG = "AmPmCirclesView";
+
+    // Alpha level for selected circle.
+    private static final int SELECTED_ALPHA = Utils.SELECTED_ALPHA;
+    private static final int SELECTED_ALPHA_THEME_DARK = Utils.SELECTED_ALPHA_THEME_DARK;
+
+    private final Paint mPaint = new Paint();
+    private int mSelectedAlpha;
+    private int mUnselectedColor;
+    protected int mAmPmTextColor = Color.WHITE;
+    protected int mSelectedColor = Color.BLUE;
+    private float mCircleRadiusMultiplier;
+    private float mAmPmCircleRadiusMultiplier;
+    private String mAmText;
+    private String mPmText;
+    private boolean mIsInitialized;
+
+    private static final int AM = TimePickerDialog.AM;
+    private static final int PM = TimePickerDialog.PM;
+
+    private boolean mDrawValuesReady;
+    private int mAmPmCircleRadius;
+    private int mAmXCenter;
+    private int mPmXCenter;
+    private int mAmPmYCenter;
+    private int mAmOrPm;
+    private int mAmOrPmPressed;
+
+    public AmPmCirclesView(Context context) {
+        super(context);
+        mIsInitialized = false;
+    }
+
+    public void initialize(Context context, int amOrPm) {
+        if (mIsInitialized) {
+            Log.e(TAG, "AmPmCirclesView may only be initialized once.");
+            return;
+        }
+
+        Resources res = context.getResources();
+        mUnselectedColor = res.getColor(R.color.white);
+        //mSelectedColor = res.getColor(R.color.blue);
+        //mAmPmTextColor = res.getColor(R.color.ampm_text_color);
+        mSelectedAlpha = SELECTED_ALPHA;
+        String typefaceFamily = res.getString(R.string.sans_serif);
+        Typeface tf = Typeface.create(typefaceFamily, Typeface.NORMAL);
+        mPaint.setTypeface(tf);
+        mPaint.setAntiAlias(true);
+        mPaint.setTextAlign(Align.CENTER);
+
+        mCircleRadiusMultiplier =
+                Float.parseFloat(res.getString(R.string.circle_radius_multiplier));
+        mAmPmCircleRadiusMultiplier =
+                Float.parseFloat(res.getString(R.string.ampm_circle_radius_multiplier));
+        String[] amPmTexts = new DateFormatSymbols().getAmPmStrings();
+        mAmText = amPmTexts[0];
+        mPmText = amPmTexts[1];
+
+        setAmOrPm(amOrPm);
+        mAmOrPmPressed = -1;
+
+        mIsInitialized = true;
+    }
+
+    /* package */ void setTheme(Context context, boolean themeDark) {
+        Resources res = context.getResources();
+        if (themeDark) {
+            mUnselectedColor = res.getColor(R.color.dark_gray);
+            mSelectedColor = res.getColor(R.color.red);
+            mAmPmTextColor = res.getColor(R.color.white);
+            mSelectedAlpha = SELECTED_ALPHA_THEME_DARK;
+        } else {
+            mUnselectedColor = res.getColor(R.color.white);
+            //mSelectedColor = res.getColor(R.color.blue);
+            //mAmPmTextColor = res.getColor(R.color.ampm_text_color);
+            mSelectedAlpha = SELECTED_ALPHA;
+        }
+    }
+
+    public void setAmOrPm(int amOrPm) {
+        mAmOrPm = amOrPm;
+    }
+
+    public void setAmOrPmPressed(int amOrPmPressed) {
+        mAmOrPmPressed = amOrPmPressed;
+    }
+
+    /**
+     * Calculate whether the coordinates are touching the AM or PM circle.
+     */
+    public int getIsTouchingAmOrPm(float xCoord, float yCoord) {
+        if (!mDrawValuesReady) {
+            return -1;
+        }
+
+        int squaredYDistance = (int) ((yCoord - mAmPmYCenter)*(yCoord - mAmPmYCenter));
+
+        int distanceToAmCenter =
+                (int) Math.sqrt((xCoord - mAmXCenter)*(xCoord - mAmXCenter) + squaredYDistance);
+        if (distanceToAmCenter <= mAmPmCircleRadius) {
+            return AM;
+        }
+
+        int distanceToPmCenter =
+                (int) Math.sqrt((xCoord - mPmXCenter)*(xCoord - mPmXCenter) + squaredYDistance);
+        if (distanceToPmCenter <= mAmPmCircleRadius) {
+            return PM;
+        }
+
+        // Neither was close enough.
+        return -1;
+    }
+
+    @Override
+    public void onDraw(Canvas canvas) {
+        int viewWidth = getWidth();
+        if (viewWidth == 0 || !mIsInitialized) {
+            return;
+        }
+
+        if (!mDrawValuesReady) {
+            int layoutXCenter = getWidth() / 2;
+            int layoutYCenter = getHeight() / 2;
+            int circleRadius =
+                    (int) (Math.min(layoutXCenter, layoutYCenter) * mCircleRadiusMultiplier);
+            mAmPmCircleRadius = (int) (circleRadius * mAmPmCircleRadiusMultiplier);
+            int textSize = mAmPmCircleRadius * 3 / 4;
+            mPaint.setTextSize(textSize);
+
+            // Line up the vertical center of the AM/PM circles with the bottom of the main circle.
+            mAmPmYCenter = layoutYCenter - mAmPmCircleRadius / 2 + circleRadius;
+            // Line up the horizontal edges of the AM/PM circles with the horizontal edges
+            // of the main circle.
+            mAmXCenter = layoutXCenter - circleRadius + mAmPmCircleRadius;
+            mPmXCenter = layoutXCenter + circleRadius - mAmPmCircleRadius;
+
+            mDrawValuesReady = true;
+        }
+
+        // We'll need to draw either a lighter blue (for selection), a darker blue (for touching)
+        // or white (for not selected).
+        int amColor = mUnselectedColor;
+        int amAlpha = 255;
+        int pmColor = mUnselectedColor;
+        int pmAlpha = 255;
+        if (mAmOrPm == AM) {
+            amColor = mSelectedColor;
+            amAlpha = mSelectedAlpha;
+        } else if (mAmOrPm == PM) {
+            pmColor = mSelectedColor;
+            pmAlpha = mSelectedAlpha;
+        }
+        if (mAmOrPmPressed == AM) {
+            amColor = mSelectedColor;
+            amAlpha = mSelectedAlpha;
+        } else if (mAmOrPmPressed == PM) {
+            pmColor = mSelectedColor;
+            pmAlpha = mSelectedAlpha;
+        }
+
+        // Draw the two circles.
+        mPaint.setColor(amColor);
+        mPaint.setAlpha(amAlpha);
+        canvas.drawCircle(mAmXCenter, mAmPmYCenter, mAmPmCircleRadius, mPaint);
+        mPaint.setColor(pmColor);
+        mPaint.setAlpha(pmAlpha);
+        canvas.drawCircle(mPmXCenter, mAmPmYCenter, mAmPmCircleRadius, mPaint);
+
+        // Draw the AM/PM texts on top.
+        mPaint.setColor(mAmPmTextColor);
+        int textYCenter = mAmPmYCenter - (int) (mPaint.descent() + mPaint.ascent()) / 2;
+        canvas.drawText(mAmText, mAmXCenter, textYCenter, mPaint);
+        canvas.drawText(mPmText, mPmXCenter, textYCenter, mPaint);
+    }
+}

uhabits-android/src/main/java/com/android/datetimepicker/time/CircleView.java

@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2013 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.datetimepicker.time;
+
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.util.Log;
+import android.view.View;
+
+import org.isoron.uhabits.R;
+
+/**
+ * Draws a simple white circle on which the numbers will be drawn.
+ */
+public class CircleView extends View {
+    private static final String TAG = "CircleView";
+
+    private final Paint mPaint = new Paint();
+    private boolean mIs24HourMode;
+    private int mCircleColor;
+    private int mDotColor;
+    private float mCircleRadiusMultiplier;
+    private float mAmPmCircleRadiusMultiplier;
+    private boolean mIsInitialized;
+
+    private boolean mDrawValuesReady;
+    private int mXCenter;
+    private int mYCenter;
+    private int mCircleRadius;
+
+    public CircleView(Context context) {
+        super(context);
+
+        Resources res = context.getResources();
+        mCircleColor = res.getColor(R.color.white);
+        mDotColor = res.getColor(R.color.numbers_text_color);
+        mPaint.setAntiAlias(true);
+
+        mIsInitialized = false;
+    }
+
+    public void initialize(Context context, boolean is24HourMode) {
+        if (mIsInitialized) {
+            Log.e(TAG, "CircleView may only be initialized once.");
+            return;
+        }
+
+        Resources res = context.getResources();
+        mIs24HourMode = is24HourMode;
+        if (is24HourMode) {
+            mCircleRadiusMultiplier = Float.parseFloat(
+                    res.getString(R.string.circle_radius_multiplier_24HourMode));
+        } else {
+            mCircleRadiusMultiplier = Float.parseFloat(
+                    res.getString(R.string.circle_radius_multiplier));
+            mAmPmCircleRadiusMultiplier =
+                    Float.parseFloat(res.getString(R.string.ampm_circle_radius_multiplier));
+        }
+
+        mIsInitialized = true;
+    }
+
+    /* package */ void setTheme(Context context, boolean dark) {
+        Resources res = context.getResources();
+        if (dark) {
+            mCircleColor = res.getColor(R.color.dark_gray);
+            mDotColor = res.getColor(R.color.light_gray);
+        } else {
+            mCircleColor = res.getColor(R.color.white);
+            mDotColor = res.getColor(R.color.numbers_text_color);
+        }
+    }
+
+
+    @Override
+    public void onDraw(Canvas canvas) {
+        int viewWidth = getWidth();
+        if (viewWidth == 0 || !mIsInitialized) {
+            return;
+        }
+
+        if (!mDrawValuesReady) {
+            mXCenter = getWidth() / 2;
+            mYCenter = getHeight() / 2;
+            mCircleRadius = (int) (Math.min(mXCenter, mYCenter) * mCircleRadiusMultiplier);
+
+            if (!mIs24HourMode) {
+                // We'll need to draw the AM/PM circles, so the main circle will need to have
+                // a slightly higher center. To keep the entire view centered vertically, we'll
+                // have to push it up by half the radius of the AM/PM circles.
+                int amPmCircleRadius = (int) (mCircleRadius * mAmPmCircleRadiusMultiplier);
+                mYCenter -= amPmCircleRadius / 2;
+            }
+
+            mDrawValuesReady = true;
+        }
+
+        // Draw the white circle.
+        mPaint.setColor(mCircleColor);
+        canvas.drawCircle(mXCenter, mYCenter, mCircleRadius, mPaint);
+
+        // Draw a small black circle in the center.
+        mPaint.setColor(mDotColor);
+        canvas.drawCircle(mXCenter, mYCenter, 2, mPaint);
+    }
+}

uhabits-android/src/main/java/com/android/datetimepicker/time/RadialPickerLayout.java

@@ -0,0 +1,830 @@
+/*
+ * Copyright (C) 2013 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.datetimepicker.time;
+
+import android.animation.*;
+import android.annotation.*;
+import android.content.*;
+import android.content.res.*;
+import android.os.*;
+import android.text.format.*;
+import android.util.*;
+import android.view.*;
+import android.view.View.*;
+import android.view.accessibility.*;
+import android.widget.*;
+
+import com.android.*;
+import com.android.datetimepicker.*;
+
+import org.isoron.uhabits.R;
+
+/**
+ * The primary layout to hold the circular picker, and the am/pm buttons. This view well measure
+ * itself to end up as a square. It also handles touches to be passed in to views that need to know
+ * when they'd been touched.
+ */
+public class RadialPickerLayout extends FrameLayout implements OnTouchListener {
+    private static final String TAG = "RadialPickerLayout";
+
+    private final int TOUCH_SLOP;
+    private final int TAP_TIMEOUT;
+
+    private static final int VISIBLE_DEGREES_STEP_SIZE = 30;
+    private static final int HOUR_VALUE_TO_DEGREES_STEP_SIZE = VISIBLE_DEGREES_STEP_SIZE;
+    private static final int MINUTE_VALUE_TO_DEGREES_STEP_SIZE = 6;
+    private static final int HOUR_INDEX = TimePickerDialog.HOUR_INDEX;
+    private static final int MINUTE_INDEX = TimePickerDialog.MINUTE_INDEX;
+    private static final int AMPM_INDEX = TimePickerDialog.AMPM_INDEX;
+    private static final int ENABLE_PICKER_INDEX = TimePickerDialog.ENABLE_PICKER_INDEX;
+    private static final int AM = TimePickerDialog.AM;
+    private static final int PM = TimePickerDialog.PM;
+
+    private int mLastValueSelected;
+
+    private HapticFeedbackController mHapticFeedbackController;
+    private OnValueSelectedListener mListener;
+    private boolean mTimeInitialized;
+    private int mCurrentHoursOfDay;
+    private int mCurrentMinutes;
+    private boolean mIs24HourMode;
+    private boolean mHideAmPm;
+    private int mCurrentItemShowing;
+
+    private CircleView mCircleView;
+    private AmPmCirclesView mAmPmCirclesView;
+    private RadialTextsView mHourRadialTextsView;
+    private RadialTextsView mMinuteRadialTextsView;
+    private RadialSelectorView mHourRadialSelectorView;
+    private RadialSelectorView mMinuteRadialSelectorView;
+    private View mGrayBox;
+
+    private int[] mSnapPrefer30sMap;
+    private boolean mInputEnabled;
+    private int mIsTouchingAmOrPm = -1;
+    private boolean mDoingMove;
+    private boolean mDoingTouch;
+    private int mDownDegrees;
+    private float mDownX;
+    private float mDownY;
+    private AccessibilityManager mAccessibilityManager;
+
+    private AnimatorSet mTransition;
+    private Handler mHandler = new Handler();
+
+    public void setColor(int selectedColor)
+    {
+        mHourRadialSelectorView.mPaint.setColor(selectedColor);
+        mMinuteRadialSelectorView.mPaint.setColor(selectedColor);
+        mAmPmCirclesView.mSelectedColor = selectedColor;
+        mAmPmCirclesView.mAmPmTextColor = selectedColor;
+    }
+
+    public interface OnValueSelectedListener {
+        void onValueSelected(int pickerIndex, int newValue, boolean autoAdvance);
+    }
+
+    public RadialPickerLayout(Context context, AttributeSet attrs) {
+        super(context, attrs);
+
+        setOnTouchListener(this);
+        ViewConfiguration vc = ViewConfiguration.get(context);
+        TOUCH_SLOP = vc.getScaledTouchSlop();
+        TAP_TIMEOUT = ViewConfiguration.getTapTimeout();
+        mDoingMove = false;
+
+        mCircleView = new CircleView(context);
+        addView(mCircleView);
+
+        mAmPmCirclesView = new AmPmCirclesView(context);
+        addView(mAmPmCirclesView);
+
+        mHourRadialTextsView = new RadialTextsView(context);
+        addView(mHourRadialTextsView);
+        mMinuteRadialTextsView = new RadialTextsView(context);
+        addView(mMinuteRadialTextsView);
+
+        mHourRadialSelectorView = new RadialSelectorView(context);
+        addView(mHourRadialSelectorView);
+        mMinuteRadialSelectorView = new RadialSelectorView(context);
+        addView(mMinuteRadialSelectorView);
+
+        // Prepare mapping to snap touchable degrees to selectable degrees.
+        preparePrefer30sMap();
+
+        mLastValueSelected = -1;
+
+        mInputEnabled = true;
+        mGrayBox = new View(context);
+        mGrayBox.setLayoutParams(new ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
+        mGrayBox.setBackgroundColor(getResources().getColor(R.color.transparent_black));
+        mGrayBox.setVisibility(View.INVISIBLE);
+        addView(mGrayBox);
+
+        mAccessibilityManager = (AccessibilityManager) context.getSystemService(Context.ACCESSIBILITY_SERVICE);
+
+        mTimeInitialized = false;
+    }
+
+    /**
+     * Measure the view to end up as a square, based on the minimum of the height and width.
+     */
+    @Override
+    public void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        int measuredWidth = MeasureSpec.getSize(widthMeasureSpec);
+        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
+        int measuredHeight = MeasureSpec.getSize(heightMeasureSpec);
+        int heightMode = MeasureSpec.getMode(heightMeasureSpec);
+        int minDimension = Math.min(measuredWidth, measuredHeight);
+
+        super.onMeasure(MeasureSpec.makeMeasureSpec(minDimension, widthMode),
+                MeasureSpec.makeMeasureSpec(minDimension, heightMode));
+    }
+
+    public void setOnValueSelectedListener(OnValueSelectedListener listener) {
+        mListener = listener;
+    }
+
+    /**
+     * Initialize the Layout with starting values.
+     * @param context
+     * @param initialHoursOfDay
+     * @param initialMinutes
+     * @param is24HourMode
+     */
+    public void initialize(Context context, HapticFeedbackController hapticFeedbackController,
+            int initialHoursOfDay, int initialMinutes, boolean is24HourMode) {
+        if (mTimeInitialized) {
+            Log.e(TAG, "Time has already been initialized.");
+            return;
+        }
+
+        mHapticFeedbackController = hapticFeedbackController;
+        mIs24HourMode = is24HourMode;
+        mHideAmPm = mAccessibilityManager.isTouchExplorationEnabled()? true : mIs24HourMode;
+
+        // Initialize the circle and AM/PM circles if applicable.
+        mCircleView.initialize(context, mHideAmPm);
+        mCircleView.invalidate();
+        if (!mHideAmPm) {
+            mAmPmCirclesView.initialize(context, initialHoursOfDay < 12? AM : PM);
+            mAmPmCirclesView.invalidate();
+        }
+
+        // Initialize the hours and minutes numbers.
+        Resources res = context.getResources();
+        int[] hours = {12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+        int[] hours_24 = {0, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23};
+        int[] minutes = {0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55};
+        String[] hoursTexts = new String[12];
+        String[] innerHoursTexts = new String[12];
+        String[] minutesTexts = new String[12];
+        for (int i = 0; i < 12; i++) {
+            hoursTexts[i] = is24HourMode?
+                    String.format("%02d", hours_24[i]) : String.format("%d", hours[i]);
+            innerHoursTexts[i] = String.format("%d", hours[i]);
+            minutesTexts[i] = String.format("%02d", minutes[i]);
+        }
+        mHourRadialTextsView.initialize(res,
+                hoursTexts, (is24HourMode? innerHoursTexts : null), mHideAmPm, true);
+        mHourRadialTextsView.invalidate();
+        mMinuteRadialTextsView.initialize(res, minutesTexts, null, mHideAmPm, false);
+        mMinuteRadialTextsView.invalidate();
+
+        // Initialize the currently-selected hour and minute.
+        setValueForItem(HOUR_INDEX, initialHoursOfDay);
+        setValueForItem(MINUTE_INDEX, initialMinutes);
+        int hourDegrees = (initialHoursOfDay % 12) * HOUR_VALUE_TO_DEGREES_STEP_SIZE;
+        mHourRadialSelectorView.initialize(context, mHideAmPm, is24HourMode, true,
+                hourDegrees, isHourInnerCircle(initialHoursOfDay));
+        int minuteDegrees = initialMinutes * MINUTE_VALUE_TO_DEGREES_STEP_SIZE;
+        mMinuteRadialSelectorView.initialize(context, mHideAmPm, false, false,
+                minuteDegrees, false);
+
+        mTimeInitialized = true;
+    }
+
+    /* package */ void setTheme(Context context, boolean themeDark) {
+        mCircleView.setTheme(context, themeDark);
+        mAmPmCirclesView.setTheme(context, themeDark);
+        mHourRadialTextsView.setTheme(context, themeDark);
+        mMinuteRadialTextsView.setTheme(context, themeDark);
+        mHourRadialSelectorView.setTheme(context, themeDark);
+        mMinuteRadialSelectorView.setTheme(context, themeDark);
+   }
+
+    public void setTime(int hours, int minutes) {
+        setItem(HOUR_INDEX, hours);
+        setItem(MINUTE_INDEX, minutes);
+    }
+
+    /**
+     * Set either the hour or the minute. Will set the internal value, and set the selection.
+     */
+    private void setItem(int index, int value) {
+        if (index == HOUR_INDEX) {
+            setValueForItem(HOUR_INDEX, value);
+            int hourDegrees = (value % 12) * HOUR_VALUE_TO_DEGREES_STEP_SIZE;
+            mHourRadialSelectorView.setSelection(hourDegrees, isHourInnerCircle(value), false);
+            mHourRadialSelectorView.invalidate();
+        } else if (index == MINUTE_INDEX) {
+            setValueForItem(MINUTE_INDEX, value);
+            int minuteDegrees = value * MINUTE_VALUE_TO_DEGREES_STEP_SIZE;
+            mMinuteRadialSelectorView.setSelection(minuteDegrees, false, false);
+            mMinuteRadialSelectorView.invalidate();
+        }
+    }
+
+    /**
+     * Check if a given hour appears in the outer circle or the inner circle
+     * @return true if the hour is in the inner circle, false if it's in the outer circle.
+     */
+    private boolean isHourInnerCircle(int hourOfDay) {
+        // We'll have the 00 hours on the outside circle.
+        return mIs24HourMode && (hourOfDay <= 12 && hourOfDay != 0);
+    }
+
+    public int getHours() {
+        return mCurrentHoursOfDay;
+    }
+
+    public int getMinutes() {
+        return mCurrentMinutes;
+    }
+
+    /**
+     * If the hours are showing, return the current hour. If the minutes are showing, return the
+     * current minute.
+     */
+    private int getCurrentlyShowingValue() {
+        int currentIndex = getCurrentItemShowing();
+        if (currentIndex == HOUR_INDEX) {
+            return mCurrentHoursOfDay;
+        } else if (currentIndex == MINUTE_INDEX) {
+            return mCurrentMinutes;
+        } else {
+            return -1;
+        }
+    }
+
+    public int getIsCurrentlyAmOrPm() {
+        if (mCurrentHoursOfDay < 12) {
+            return AM;
+        } else if (mCurrentHoursOfDay < 24) {
+            return PM;
+        }
+        return -1;
+    }
+
+    /**
+     * Set the internal value for the hour, minute, or AM/PM.
+     */
+    private void setValueForItem(int index, int value) {
+        if (index == HOUR_INDEX) {
+            mCurrentHoursOfDay = value;
+        } else if (index == MINUTE_INDEX){
+            mCurrentMinutes = value;
+        } else if (index == AMPM_INDEX) {
+            if (value == AM) {
+                mCurrentHoursOfDay = mCurrentHoursOfDay % 12;
+            } else if (value == PM) {
+                mCurrentHoursOfDay = (mCurrentHoursOfDay % 12) + 12;
+            }
+        }
+    }
+
+    /**
+     * Set the internal value as either AM or PM, and update the AM/PM circle displays.
+     * @param amOrPm
+     */
+    public void setAmOrPm(int amOrPm) {
+        mAmPmCirclesView.setAmOrPm(amOrPm);
+        mAmPmCirclesView.invalidate();
+        setValueForItem(AMPM_INDEX, amOrPm);
+    }
+
+    /**
+     * Split up the 360 degrees of the circle among the 60 selectable values. Assigns a larger
+     * selectable area to each of the 12 visible values, such that the ratio of space apportioned
+     * to a visible value : space apportioned to a non-visible value will be 14 : 4.
+     * E.g. the output of 30 degrees should have a higher range of input associated with it than
+     * the output of 24 degrees, because 30 degrees corresponds to a visible number on the clock
+     * circle (5 on the minutes, 1 or 13 on the hours).
+     */
+    private void preparePrefer30sMap() {
+        // We'll split up the visible output and the non-visible output such that each visible
+        // output will correspond to a range of 14 associated input degrees, and each non-visible
+        // output will correspond to a range of 4 associate input degrees, so visible numbers
+        // are more than 3 times easier to get than non-visible numbers:
+        // {354-359,0-7}:0, {8-11}:6, {12-15}:12, {16-19}:18, {20-23}:24, {24-37}:30, etc.
+        //
+        // If an output of 30 degrees should correspond to a range of 14 associated degrees, then
+        // we'll need any input between 24 - 37 to snap to 30. Working out from there, 20-23 should
+        // snap to 24, while 38-41 should snap to 36. This is somewhat counter-intuitive, that you
+        // can be touching 36 degrees but have the selection snapped to 30 degrees; however, this
+        // inconsistency isn't noticeable at such fine-grained degrees, and it affords us the
+        // ability to aggressively prefer the visible values by a factor of more than 3:1, which
+        // greatly contributes to the selectability of these values.
+
+        // Our input will be 0 through 360.
+        mSnapPrefer30sMap = new int[361];
+
+        // The first output is 0, and each following output will increment by 6 {0, 6, 12, ...}.
+        int snappedOutputDegrees = 0;
+        // Count of how many inputs we've designated to the specified output.
+        int count = 1;
+        // How many input we expect for a specified output. This will be 14 for output divisible
+        // by 30, and 4 for the remaining output. We'll special case the outputs of 0 and 360, so
+        // the caller can decide which they need.
+        int expectedCount = 8;
+        // Iterate through the input.
+        for (int degrees = 0; degrees < 361; degrees++) {
+            // Save the input-output mapping.
+            mSnapPrefer30sMap[degrees] = snappedOutputDegrees;
+            // If this is the last input for the specified output, calculate the next output and
+            // the next expected count.
+            if (count == expectedCount) {
+                snappedOutputDegrees += 6;
+                if (snappedOutputDegrees == 360) {
+                    expectedCount = 7;
+                } else if (snappedOutputDegrees % 30 == 0) {
+                    expectedCount = 14;
+                } else {
+                    expectedCount = 4;
+                }
+                count = 1;
+            } else {
+                count++;
+            }
+        }
+    }
+
+    /**
+     * Returns mapping of any input degrees (0 to 360) to one of 60 selectable output degrees,
+     * where the degrees corresponding to visible numbers (i.e. those divisible by 30) will be
+     * weighted heavier than the degrees corresponding to non-visible numbers.
+     * See {@link #preparePrefer30sMap()} documentation for the rationale and generation of the
+     * mapping.
+     */
+    private int snapPrefer30s(int degrees) {
+        if (mSnapPrefer30sMap == null) {
+            return -1;
+        }
+        return mSnapPrefer30sMap[degrees];
+    }
+
+    /**
+     * Returns mapping of any input degrees (0 to 360) to one of 12 visible output degrees (all
+     * multiples of 30), where the input will be "snapped" to the closest visible degrees.
+     * @param degrees The input degrees
+     * @param forceAboveOrBelow The output may be forced to either the higher or lower step, or may
+     * be allowed to snap to whichever is closer. Use 1 to force strictly higher, -1 to force
+     * strictly lower, and 0 to snap to the closer one.
+     * @return output degrees, will be a multiple of 30
+     */
+    private static int snapOnly30s(int degrees, int forceHigherOrLower) {
+        int stepSize = HOUR_VALUE_TO_DEGREES_STEP_SIZE;
+        int floor = (degrees / stepSize) * stepSize;
+        int ceiling = floor + stepSize;
+        if (forceHigherOrLower == 1) {
+            degrees = ceiling;
+        } else if (forceHigherOrLower == -1) {
+            if (degrees == floor) {
+                floor -= stepSize;
+            }
+            degrees = floor;
+        } else {
+            if ((degrees - floor) < (ceiling - degrees)) {
+                degrees = floor;
+            } else {
+                degrees = ceiling;
+            }
+        }
+        return degrees;
+    }
+
+    /**
+     * For the currently showing view (either hours or minutes), re-calculate the position for the
+     * selector, and redraw it at that position. The input degrees will be snapped to a selectable
+     * value.
+     * @param degrees Degrees which should be selected.
+     * @param isInnerCircle Whether the selection should be in the inner circle; will be ignored
+     * if there is no inner circle.
+     * @param forceToVisibleValue Even if the currently-showing circle allows for fine-grained
+     * selection (i.e. minutes), force the selection to one of the visibly-showing values.
+     * @param forceDrawDot The dot in the circle will generally only be shown when the selection
+     * is on non-visible values, but use this to force the dot to be shown.
+     * @return The value that was selected, i.e. 0-23 for hours, 0-59 for minutes.
+     */
+    private int reselectSelector(int degrees, boolean isInnerCircle,
+            boolean forceToVisibleValue, boolean forceDrawDot) {
+        if (degrees == -1) {
+            return -1;
+        }
+        int currentShowing = getCurrentItemShowing();
+
+        int stepSize;
+        boolean allowFineGrained = !forceToVisibleValue && (currentShowing == MINUTE_INDEX);
+        if (allowFineGrained) {
+            degrees = snapPrefer30s(degrees);
+        } else {
+            degrees = snapOnly30s(degrees, 0);
+        }
+
+        RadialSelectorView radialSelectorView;
+        if (currentShowing == HOUR_INDEX) {
+            radialSelectorView = mHourRadialSelectorView;
+            stepSize = HOUR_VALUE_TO_DEGREES_STEP_SIZE;
+        } else {
+            radialSelectorView = mMinuteRadialSelectorView;
+            stepSize = MINUTE_VALUE_TO_DEGREES_STEP_SIZE;
+        }
+        radialSelectorView.setSelection(degrees, isInnerCircle, forceDrawDot);
+        radialSelectorView.invalidate();
+
+
+        if (currentShowing == HOUR_INDEX) {
+            if (mIs24HourMode) {
+                if (degrees == 0 && isInnerCircle) {
+                    degrees = 360;
+                } else if (degrees == 360 && !isInnerCircle) {
+                    degrees = 0;
+                }
+            } else if (degrees == 0) {
+                degrees = 360;
+            }
+        } else if (degrees == 360 && currentShowing == MINUTE_INDEX) {
+            degrees = 0;
+        }
+
+        int value = degrees / stepSize;
+        if (currentShowing == HOUR_INDEX && mIs24HourMode && !isInnerCircle && degrees != 0) {
+            value += 12;
+        }
+        return value;
+    }
+
+    /**
+     * Calculate the degrees within the circle that corresponds to the specified coordinates, if
+     * the coordinates are within the range that will trigger a selection.
+     * @param pointX The x coordinate.
+     * @param pointY The y coordinate.
+     * @param forceLegal Force the selection to be legal, regardless of how far the coordinates are
+     * from the actual numbers.
+     * @param isInnerCircle If the selection may be in the inner circle, pass in a size-1 boolean
+     * array here, inside which the value will be true if the selection is in the inner circle,
+     * and false if in the outer circle.
+     * @return Degrees from 0 to 360, if the selection was within the legal range. -1 if not.
+     */
+    private int getDegreesFromCoords(float pointX, float pointY, boolean forceLegal,
+            final Boolean[] isInnerCircle) {
+        int currentItem = getCurrentItemShowing();
+        if (currentItem == HOUR_INDEX) {
+            return mHourRadialSelectorView.getDegreesFromCoords(
+                    pointX, pointY, forceLegal, isInnerCircle);
+        } else if (currentItem == MINUTE_INDEX) {
+            return mMinuteRadialSelectorView.getDegreesFromCoords(
+                    pointX, pointY, forceLegal, isInnerCircle);
+        } else {
+            return -1;
+        }
+    }
+
+    /**
+     * Get the item (hours or minutes) that is currently showing.
+     */
+    public int getCurrentItemShowing() {
+        if (mCurrentItemShowing != HOUR_INDEX && mCurrentItemShowing != MINUTE_INDEX) {
+            Log.e(TAG, "Current item showing was unfortunately set to "+mCurrentItemShowing);
+            return -1;
+        }
+        return mCurrentItemShowing;
+    }
+
+    /**
+     * Set either minutes or hours as showing.
+     * @param animate True to animate the transition, false to show with no animation.
+     */
+    public void setCurrentItemShowing(int index, boolean animate) {
+        if (index != HOUR_INDEX && index != MINUTE_INDEX) {
+            Log.e(TAG, "TimePicker does not support view at index "+index);
+            return;
+        }
+
+        int lastIndex = getCurrentItemShowing();
+        mCurrentItemShowing = index;
+
+        if (animate && (index != lastIndex)) {
+            ObjectAnimator[] anims = new ObjectAnimator[4];
+            if (index == MINUTE_INDEX) {
+                anims[0] = mHourRadialTextsView.getDisappearAnimator();
+                anims[1] = mHourRadialSelectorView.getDisappearAnimator();
+                anims[2] = mMinuteRadialTextsView.getReappearAnimator();
+                anims[3] = mMinuteRadialSelectorView.getReappearAnimator();
+            } else if (index == HOUR_INDEX){
+                anims[0] = mHourRadialTextsView.getReappearAnimator();
+                anims[1] = mHourRadialSelectorView.getReappearAnimator();
+                anims[2] = mMinuteRadialTextsView.getDisappearAnimator();
+                anims[3] = mMinuteRadialSelectorView.getDisappearAnimator();
+            }
+
+            if (mTransition != null && mTransition.isRunning()) {
+                mTransition.end();
+            }
+            mTransition = new AnimatorSet();
+            mTransition.playTogether(anims);
+            mTransition.start();
+        } else {
+            int hourAlpha = (index == HOUR_INDEX) ? 255 : 0;
+            int minuteAlpha = (index == MINUTE_INDEX) ? 255 : 0;
+            mHourRadialTextsView.setAlpha(hourAlpha);
+            mHourRadialSelectorView.setAlpha(hourAlpha);
+            mMinuteRadialTextsView.setAlpha(minuteAlpha);
+            mMinuteRadialSelectorView.setAlpha(minuteAlpha);
+        }
+
+    }
+
+    @Override
+    public boolean onTouch(View v, MotionEvent event) {
+        final float eventX = event.getX();
+        final float eventY = event.getY();
+        int degrees;
+        int value;
+        final Boolean[] isInnerCircle = new Boolean[1];
+        isInnerCircle[0] = false;
+
+        switch(event.getAction()) {
+            case MotionEvent.ACTION_DOWN:
+                if (!mInputEnabled) {
+                    return true;
+                }
+
+                mDownX = eventX;
+                mDownY = eventY;
+
+                mLastValueSelected = -1;
+                mDoingMove = false;
+                mDoingTouch = true;
+                // If we're showing the AM/PM, check to see if the user is touching it.
+                if (!mHideAmPm) {
+                    mIsTouchingAmOrPm = mAmPmCirclesView.getIsTouchingAmOrPm(eventX, eventY);
+                } else {
+                    mIsTouchingAmOrPm = -1;
+                }
+                if (mIsTouchingAmOrPm == AM || mIsTouchingAmOrPm == PM) {
+                    // If the touch is on AM or PM, set it as "touched" after the TAP_TIMEOUT
+                    // in case the user moves their finger quickly.
+                    mHapticFeedbackController.tryVibrate();
+                    mDownDegrees = -1;
+                    mHandler.postDelayed(new Runnable() {
+                        @Override
+                        public void run() {
+                            mAmPmCirclesView.setAmOrPmPressed(mIsTouchingAmOrPm);
+                            mAmPmCirclesView.invalidate();
+                        }
+                    }, TAP_TIMEOUT);
+                } else {
+                    // If we're in accessibility mode, force the touch to be legal. Otherwise,
+                    // it will only register within the given touch target zone.
+                    boolean forceLegal = mAccessibilityManager.isTouchExplorationEnabled();
+                    // Calculate the degrees that is currently being touched.
+                    mDownDegrees = getDegreesFromCoords(eventX, eventY, forceLegal, isInnerCircle);
+                    if (mDownDegrees != -1) {
+                        // If it's a legal touch, set that number as "selected" after the
+                        // TAP_TIMEOUT in case the user moves their finger quickly.
+                        mHapticFeedbackController.tryVibrate();
+                        mHandler.postDelayed(new Runnable() {
+                            @Override
+                            public void run() {
+                                mDoingMove = true;
+                                int value = reselectSelector(mDownDegrees, isInnerCircle[0],
+                                        false, true);
+                                mLastValueSelected = value;
+                                mListener.onValueSelected(getCurrentItemShowing(), value, false);
+                            }
+                        }, TAP_TIMEOUT);
+                    }
+                }
+                return true;
+            case MotionEvent.ACTION_MOVE:
+                if (!mInputEnabled) {
+                    // We shouldn't be in this state, because input is disabled.
+                    Log.e(TAG, "Input was disabled, but received ACTION_MOVE.");
+                    return true;
+                }
+
+                float dY = Math.abs(eventY - mDownY);
+                float dX = Math.abs(eventX - mDownX);
+
+                if (!mDoingMove && dX <= TOUCH_SLOP && dY <= TOUCH_SLOP) {
+                    // Hasn't registered down yet, just slight, accidental movement of finger.
+                    break;
+                }
+
+                // If we're in the middle of touching down on AM or PM, check if we still are.
+                // If so, no-op. If not, remove its pressed state. Either way, no need to check
+                // for touches on the other circle.
+                if (mIsTouchingAmOrPm == AM || mIsTouchingAmOrPm == PM) {
+                    mHandler.removeCallbacksAndMessages(null);
+                    int isTouchingAmOrPm = mAmPmCirclesView.getIsTouchingAmOrPm(eventX, eventY);
+                    if (isTouchingAmOrPm != mIsTouchingAmOrPm) {
+                        mAmPmCirclesView.setAmOrPmPressed(-1);
+                        mAmPmCirclesView.invalidate();
+                        mIsTouchingAmOrPm = -1;
+                    }
+                    break;
+                }
+
+                if (mDownDegrees == -1) {
+                    // Original down was illegal, so no movement will register.
+                    break;
+                }
+
+                // We're doing a move along the circle, so move the selection as appropriate.
+                mDoingMove = true;
+                mHandler.removeCallbacksAndMessages(null);
+                degrees = getDegreesFromCoords(eventX, eventY, true, isInnerCircle);
+                if (degrees != -1) {
+                    value = reselectSelector(degrees, isInnerCircle[0], false, true);
+                    if (value != mLastValueSelected) {
+                        mHapticFeedbackController.tryVibrate();
+                        mLastValueSelected = value;
+                        mListener.onValueSelected(getCurrentItemShowing(), value, false);
+                    }
+                }
+                return true;
+            case MotionEvent.ACTION_UP:
+                if (!mInputEnabled) {
+                    // If our touch input was disabled, tell the listener to re-enable us.
+                    Log.d(TAG, "Input was disabled, but received ACTION_UP.");
+                    mListener.onValueSelected(ENABLE_PICKER_INDEX, 1, false);
+                    return true;
+                }
+
+                mHandler.removeCallbacksAndMessages(null);
+                mDoingTouch = false;
+
+                // If we're touching AM or PM, set it as selected, and tell the listener.
+                if (mIsTouchingAmOrPm == AM || mIsTouchingAmOrPm == PM) {
+                    int isTouchingAmOrPm = mAmPmCirclesView.getIsTouchingAmOrPm(eventX, eventY);
+                    mAmPmCirclesView.setAmOrPmPressed(-1);
+                    mAmPmCirclesView.invalidate();
+
+                    if (isTouchingAmOrPm == mIsTouchingAmOrPm) {
+                        mAmPmCirclesView.setAmOrPm(isTouchingAmOrPm);
+                        if (getIsCurrentlyAmOrPm() != isTouchingAmOrPm) {
+                            mListener.onValueSelected(AMPM_INDEX, mIsTouchingAmOrPm, false);
+                            setValueForItem(AMPM_INDEX, isTouchingAmOrPm);
+                        }
+                    }
+                    mIsTouchingAmOrPm = -1;
+                    break;
+                }
+
+                // If we have a legal degrees selected, set the value and tell the listener.
+                if (mDownDegrees != -1) {
+                    degrees = getDegreesFromCoords(eventX, eventY, mDoingMove, isInnerCircle);
+                    if (degrees != -1) {
+                        value = reselectSelector(degrees, isInnerCircle[0], !mDoingMove, false);
+                        if (getCurrentItemShowing() == HOUR_INDEX && !mIs24HourMode) {
+                            int amOrPm = getIsCurrentlyAmOrPm();
+                            if (amOrPm == AM && value == 12) {
+                                value = 0;
+                            } else if (amOrPm == PM && value != 12) {
+                                value += 12;
+                            }
+                        }
+                        setValueForItem(getCurrentItemShowing(), value);
+                        mListener.onValueSelected(getCurrentItemShowing(), value, true);
+                    }
+                }
+                mDoingMove = false;
+                return true;
+            default:
+                break;
+        }
+        return false;
+    }
+
+    /**
+     * Set touch input as enabled or disabled, for use with keyboard mode.
+     */
+    public boolean trySettingInputEnabled(boolean inputEnabled) {
+        if (mDoingTouch && !inputEnabled) {
+            // If we're trying to disable input, but we're in the middle of a touch event,
+            // we'll allow the touch event to continue before disabling input.
+            return false;
+        }
+        mInputEnabled = inputEnabled;
+        mGrayBox.setVisibility(inputEnabled? View.INVISIBLE : View.VISIBLE);
+        return true;
+    }
+
+    /**
+     * Necessary for accessibility, to ensure we support "scrolling" forward and backward
+     * in the circle.
+     */
+    @Override
+    public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
+      super.onInitializeAccessibilityNodeInfo(info);
+      info.addAction(AccessibilityNodeInfo.ACTION_SCROLL_FORWARD);
+      info.addAction(AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD);
+    }
+
+    /**
+     * Announce the currently-selected time when launched.
+     */
+    @Override
+    public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
+        if (event.getEventType() == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED) {
+            // Clear the event's current text so that only the current time will be spoken.
+            event.getText().clear();
+            Time time = new Time();
+            time.hour = getHours();
+            time.minute = getMinutes();
+            long millis = time.normalize(true);
+            int flags = DateUtils.FORMAT_SHOW_TIME;
+            if (mIs24HourMode) {
+                flags |= DateUtils.FORMAT_24HOUR;
+            }
+            String timeString = DateUtils.formatDateTime(getContext(), millis, flags);
+            event.getText().add(timeString);
+            return true;
+        }
+        return super.dispatchPopulateAccessibilityEvent(event);
+    }
+
+    /**
+     * When scroll forward/backward events are received, jump the time to the higher/lower
+     * discrete, visible value on the circle.
+     */
+    @SuppressLint("NewApi")
+    @Override
+    public boolean performAccessibilityAction(int action, Bundle arguments) {
+        if (super.performAccessibilityAction(action, arguments)) {
+            return true;
+        }
+
+        int changeMultiplier = 0;
+        if (action == AccessibilityNodeInfo.ACTION_SCROLL_FORWARD) {
+            changeMultiplier = 1;
+        } else if (action == AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD) {
+            changeMultiplier = -1;
+        }
+        if (changeMultiplier != 0) {
+            int value = getCurrentlyShowingValue();
+            int stepSize = 0;
+            int currentItemShowing = getCurrentItemShowing();
+            if (currentItemShowing == HOUR_INDEX) {
+                stepSize = HOUR_VALUE_TO_DEGREES_STEP_SIZE;
+                value %= 12;
+            } else if (currentItemShowing == MINUTE_INDEX) {
+                stepSize = MINUTE_VALUE_TO_DEGREES_STEP_SIZE;
+            }
+
+            int degrees = value * stepSize;
+            degrees = snapOnly30s(degrees, changeMultiplier);
+            value = degrees / stepSize;
+            int maxValue = 0;
+            int minValue = 0;
+            if (currentItemShowing == HOUR_INDEX) {
+                if (mIs24HourMode) {
+                    maxValue = 23;
+                } else {
+                    maxValue = 12;
+                    minValue = 1;
+                }
+            } else {
+                maxValue = 55;
+            }
+            if (value > maxValue) {
+                // If we scrolled forward past the highest number, wrap around to the lowest.
+                value = minValue;
+            } else if (value < minValue) {
+                // If we scrolled backward past the lowest number, wrap around to the highest.
+                value = maxValue;
+            }
+            setItem(currentItemShowing, value);
+            mListener.onValueSelected(currentItemShowing, value, false);
+            return true;
+        }
+
+        return false;
+    }
+}

uhabits-android/src/main/java/com/android/datetimepicker/time/RadialSelectorView.java

@@ -0,0 +1,393 @@
+/*
+ * Copyright (C) 2013 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.datetimepicker.time;
+
+import android.animation.Keyframe;
+import android.animation.ObjectAnimator;
+import android.animation.PropertyValuesHolder;
+import android.animation.ValueAnimator;
+import android.animation.ValueAnimator.AnimatorUpdateListener;
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.util.Log;
+import android.view.View;
+
+import com.android.datetimepicker.Utils;
+
+import org.isoron.uhabits.R;
+
+/**
+ * View to show what number is selected. This will draw a blue circle over the number, with a blue
+ * line coming from the center of the main circle to the edge of the blue selection.
+ */
+public class RadialSelectorView extends View {
+    private static final String TAG = "RadialSelectorView";
+
+    // Alpha level for selected circle.
+    private static final int SELECTED_ALPHA = Utils.SELECTED_ALPHA;
+    private static final int SELECTED_ALPHA_THEME_DARK = Utils.SELECTED_ALPHA_THEME_DARK;
+    // Alpha level for the line.
+    private static final int FULL_ALPHA = Utils.FULL_ALPHA;
+
+    protected final Paint mPaint = new Paint();
+
+    private boolean mIsInitialized;
+    private boolean mDrawValuesReady;
+
+    private float mCircleRadiusMultiplier;
+    private float mAmPmCircleRadiusMultiplier;
+    private float mInnerNumbersRadiusMultiplier;
+    private float mOuterNumbersRadiusMultiplier;
+    private float mNumbersRadiusMultiplier;
+    private float mSelectionRadiusMultiplier;
+    private float mAnimationRadiusMultiplier;
+    private boolean mIs24HourMode;
+    private boolean mHasInnerCircle;
+    private int mSelectionAlpha;
+
+    private int mXCenter;
+    private int mYCenter;
+    private int mCircleRadius;
+    private float mTransitionMidRadiusMultiplier;
+    private float mTransitionEndRadiusMultiplier;
+    private int mLineLength;
+    private int mSelectionRadius;
+    private InvalidateUpdateListener mInvalidateUpdateListener;
+
+    private int mSelectionDegrees;
+    private double mSelectionRadians;
+    private boolean mForceDrawDot;
+
+    public RadialSelectorView(Context context) {
+        super(context);
+        mIsInitialized = false;
+    }
+
+    /**
+     * Initialize this selector with the state of the picker.
+     * @param context Current context.
+     * @param is24HourMode Whether the selector is in 24-hour mode, which will tell us
+     * whether the circle's center is moved up slightly to make room for the AM/PM circles.
+     * @param hasInnerCircle Whether we have both an inner and an outer circle of numbers
+     * that may be selected. Should be true for 24-hour mode in the hours circle.
+     * @param disappearsOut Whether the numbers' animation will have them disappearing out
+     * or disappearing in.
+     * @param selectionDegrees The initial degrees to be selected.
+     * @param isInnerCircle Whether the initial selection is in the inner or outer circle.
+     * Will be ignored when hasInnerCircle is false.
+     */
+    public void initialize(Context context, boolean is24HourMode, boolean hasInnerCircle,
+            boolean disappearsOut, int selectionDegrees, boolean isInnerCircle) {
+        if (mIsInitialized) {
+            Log.e(TAG, "This RadialSelectorView may only be initialized once.");
+            return;
+        }
+
+        Resources res = context.getResources();
+
+        mPaint.setAntiAlias(true);
+        mSelectionAlpha = SELECTED_ALPHA;
+
+        // Calculate values for the circle radius size.
+        mIs24HourMode = is24HourMode;
+        if (is24HourMode) {
+            mCircleRadiusMultiplier = Float.parseFloat(
+                    res.getString(R.string.circle_radius_multiplier_24HourMode));
+        } else {
+            mCircleRadiusMultiplier = Float.parseFloat(
+                    res.getString(R.string.circle_radius_multiplier));
+            mAmPmCircleRadiusMultiplier =
+                    Float.parseFloat(res.getString(R.string.ampm_circle_radius_multiplier));
+        }
+
+        // Calculate values for the radius size(s) of the numbers circle(s).
+        mHasInnerCircle = hasInnerCircle;
+        if (hasInnerCircle) {
+            mInnerNumbersRadiusMultiplier =
+                    Float.parseFloat(res.getString(R.string.numbers_radius_multiplier_inner));
+            mOuterNumbersRadiusMultiplier =
+                    Float.parseFloat(res.getString(R.string.numbers_radius_multiplier_outer));
+        } else {
+            mNumbersRadiusMultiplier =
+                    Float.parseFloat(res.getString(R.string.numbers_radius_multiplier_normal));
+        }
+        mSelectionRadiusMultiplier =
+                Float.parseFloat(res.getString(R.string.selection_radius_multiplier));
+
+        // Calculate values for the transition mid-way states.
+        mAnimationRadiusMultiplier = 1;
+        mTransitionMidRadiusMultiplier = 1f + (0.05f * (disappearsOut? -1 : 1));
+        mTransitionEndRadiusMultiplier = 1f + (0.3f * (disappearsOut? 1 : -1));
+        mInvalidateUpdateListener = new InvalidateUpdateListener();
+
+        setSelection(selectionDegrees, isInnerCircle, false);
+        mIsInitialized = true;
+    }
+
+    /* package */ void setTheme(Context context, boolean themeDark) {
+        Resources res = context.getResources();
+        if (themeDark) {
+            mSelectionAlpha = SELECTED_ALPHA_THEME_DARK;
+        } else {
+            mSelectionAlpha = SELECTED_ALPHA;
+        }
+    }
+
+    /**
+     * Set the selection.
+     * @param selectionDegrees The degrees to be selected.
+     * @param isInnerCircle Whether the selection should be in the inner circle or outer. Will be
+     * ignored if hasInnerCircle was initialized to false.
+     * @param forceDrawDot Whether to force the dot in the center of the selection circle to be
+     * drawn. If false, the dot will be drawn only when the degrees is not a multiple of 30, i.e.
+     * the selection is not on a visible number.
+     */
+    public void setSelection(int selectionDegrees, boolean isInnerCircle, boolean forceDrawDot) {
+        mSelectionDegrees = selectionDegrees;
+        mSelectionRadians = selectionDegrees * Math.PI / 180;
+        mForceDrawDot = forceDrawDot;
+
+        if (mHasInnerCircle) {
+            if (isInnerCircle) {
+                mNumbersRadiusMultiplier = mInnerNumbersRadiusMultiplier;
+            } else {
+                mNumbersRadiusMultiplier = mOuterNumbersRadiusMultiplier;
+            }
+        }
+    }
+
+    /**
+     * Allows for smoother animations.
+     */
+    @Override
+    public boolean hasOverlappingRendering() {
+        return false;
+    }
+
+    /**
+     * Set the multiplier for the radius. Will be used during animations to move in/out.
+     */
+    public void setAnimationRadiusMultiplier(float animationRadiusMultiplier) {
+        mAnimationRadiusMultiplier = animationRadiusMultiplier;
+    }
+
+    public int getDegreesFromCoords(float pointX, float pointY, boolean forceLegal,
+            final Boolean[] isInnerCircle) {
+        if (!mDrawValuesReady) {
+            return -1;
+        }
+
+        double hypotenuse = Math.sqrt(
+                (pointY - mYCenter)*(pointY - mYCenter) +
+                (pointX - mXCenter)*(pointX - mXCenter));
+        // Check if we're outside the range
+        if (mHasInnerCircle) {
+            if (forceLegal) {
+                // If we're told to force the coordinates to be legal, we'll set the isInnerCircle
+                // boolean based based off whichever number the coordinates are closer to.
+                int innerNumberRadius = (int) (mCircleRadius * mInnerNumbersRadiusMultiplier);
+                int distanceToInnerNumber = (int) Math.abs(hypotenuse - innerNumberRadius);
+                int outerNumberRadius = (int) (mCircleRadius * mOuterNumbersRadiusMultiplier);
+                int distanceToOuterNumber = (int) Math.abs(hypotenuse - outerNumberRadius);
+
+                isInnerCircle[0] = (distanceToInnerNumber <= distanceToOuterNumber);
+            } else {
+                // Otherwise, if we're close enough to either number (with the space between the
+                // two allotted equally), set the isInnerCircle boolean as the closer one.
+                // appropriately, but otherwise return -1.
+                int minAllowedHypotenuseForInnerNumber =
+                        (int) (mCircleRadius * mInnerNumbersRadiusMultiplier) - mSelectionRadius;
+                int maxAllowedHypotenuseForOuterNumber =
+                        (int) (mCircleRadius * mOuterNumbersRadiusMultiplier) + mSelectionRadius;
+                int halfwayHypotenusePoint = (int) (mCircleRadius *
+                        ((mOuterNumbersRadiusMultiplier + mInnerNumbersRadiusMultiplier) / 2));
+
+                if (hypotenuse >= minAllowedHypotenuseForInnerNumber &&
+                        hypotenuse <= halfwayHypotenusePoint) {
+                    isInnerCircle[0] = true;
+                } else if (hypotenuse <= maxAllowedHypotenuseForOuterNumber &&
+                        hypotenuse >= halfwayHypotenusePoint) {
+                    isInnerCircle[0] = false;
+                } else {
+                    return -1;
+                }
+            }
+        } else {
+            // If there's just one circle, we'll need to return -1 if:
+            // we're not told to force the coordinates to be legal, and
+            // the coordinates' distance to the number is within the allowed distance.
+            if (!forceLegal) {
+                int distanceToNumber = (int) Math.abs(hypotenuse - mLineLength);
+                // The max allowed distance will be defined as the distance from the center of the
+                // number to the edge of the circle.
+                int maxAllowedDistance = (int) (mCircleRadius * (1 - mNumbersRadiusMultiplier));
+                if (distanceToNumber > maxAllowedDistance) {
+                    return -1;
+                }
+            }
+        }
+
+
+        float opposite = Math.abs(pointY - mYCenter);
+        double radians = Math.asin(opposite / hypotenuse);
+        int degrees = (int) (radians * 180 / Math.PI);
+
+        // Now we have to translate to the correct quadrant.
+        boolean rightSide = (pointX > mXCenter);
+        boolean topSide = (pointY < mYCenter);
+        if (rightSide && topSide) {
+            degrees = 90 - degrees;
+        } else if (rightSide && !topSide) {
+            degrees = 90 + degrees;
+        } else if (!rightSide && !topSide) {
+            degrees = 270 - degrees;
+        } else if (!rightSide && topSide) {
+            degrees = 270 + degrees;
+        }
+        return degrees;
+    }
+
+    @Override
+    public void onDraw(Canvas canvas) {
+        int viewWidth = getWidth();
+        if (viewWidth == 0 || !mIsInitialized) {
+            return;
+        }
+
+        if (!mDrawValuesReady) {
+            mXCenter = getWidth() / 2;
+            mYCenter = getHeight() / 2;
+            mCircleRadius = (int) (Math.min(mXCenter, mYCenter) * mCircleRadiusMultiplier);
+
+            if (!mIs24HourMode) {
+                // We'll need to draw the AM/PM circles, so the main circle will need to have
+                // a slightly higher center. To keep the entire view centered vertically, we'll
+                // have to push it up by half the radius of the AM/PM circles.
+                int amPmCircleRadius = (int) (mCircleRadius * mAmPmCircleRadiusMultiplier);
+                mYCenter -= amPmCircleRadius / 2;
+            }
+
+            mSelectionRadius = (int) (mCircleRadius * mSelectionRadiusMultiplier);
+
+            mDrawValuesReady = true;
+        }
+
+        // Calculate the current radius at which to place the selection circle.
+        mLineLength = (int) (mCircleRadius * mNumbersRadiusMultiplier * mAnimationRadiusMultiplier);
+        int pointX = mXCenter + (int) (mLineLength * Math.sin(mSelectionRadians));
+        int pointY = mYCenter - (int) (mLineLength * Math.cos(mSelectionRadians));
+
+        // Draw the selection circle.
+        mPaint.setAlpha(mSelectionAlpha);
+        canvas.drawCircle(pointX, pointY, mSelectionRadius, mPaint);
+
+        if (mForceDrawDot | mSelectionDegrees % 30 != 0) {
+            // We're not on a direct tick (or we've been told to draw the dot anyway).
+            mPaint.setAlpha(FULL_ALPHA);
+            canvas.drawCircle(pointX, pointY, (mSelectionRadius * 2 / 7), mPaint);
+        } else {
+            // We're not drawing the dot, so shorten the line to only go as far as the edge of the
+            // selection circle.
+            int lineLength = mLineLength;
+            lineLength -= mSelectionRadius;
+            pointX = mXCenter + (int) (lineLength * Math.sin(mSelectionRadians));
+            pointY = mYCenter - (int) (lineLength * Math.cos(mSelectionRadians));
+        }
+
+        // Draw the line from the center of the circle.
+        mPaint.setAlpha(255);
+        mPaint.setStrokeWidth(1);
+        canvas.drawLine(mXCenter, mYCenter, pointX, pointY, mPaint);
+    }
+
+    public ObjectAnimator getDisappearAnimator() {
+        if (!mIsInitialized || !mDrawValuesReady) {
+            Log.e(TAG, "RadialSelectorView was not ready for animation.");
+            return null;
+        }
+
+        Keyframe kf0, kf1, kf2;
+        float midwayPoint = 0.2f;
+        int duration = 500;
+
+        kf0 = Keyframe.ofFloat(0f, 1);
+        kf1 = Keyframe.ofFloat(midwayPoint, mTransitionMidRadiusMultiplier);
+        kf2 = Keyframe.ofFloat(1f, mTransitionEndRadiusMultiplier);
+        PropertyValuesHolder radiusDisappear = PropertyValuesHolder.ofKeyframe(
+                "animationRadiusMultiplier", kf0, kf1, kf2);
+
+        kf0 = Keyframe.ofFloat(0f, 1f);
+        kf1 = Keyframe.ofFloat(1f, 0f);
+        PropertyValuesHolder fadeOut = PropertyValuesHolder.ofKeyframe("alpha", kf0, kf1);
+
+        ObjectAnimator disappearAnimator = ObjectAnimator.ofPropertyValuesHolder(
+                this, radiusDisappear, fadeOut).setDuration(duration);
+        disappearAnimator.addUpdateListener(mInvalidateUpdateListener);
+
+        return disappearAnimator;
+    }
+
+    public ObjectAnimator getReappearAnimator() {
+        if (!mIsInitialized || !mDrawValuesReady) {
+            Log.e(TAG, "RadialSelectorView was not ready for animation.");
+            return null;
+        }
+
+        Keyframe kf0, kf1, kf2, kf3;
+        float midwayPoint = 0.2f;
+        int duration = 500;
+
+        // The time points are half of what they would normally be, because this animation is
+        // staggered against the disappear so they happen seamlessly. The reappear starts
+        // halfway into the disappear.
+        float delayMultiplier = 0.25f;
+        float transitionDurationMultiplier = 1f;
+        float totalDurationMultiplier = transitionDurationMultiplier + delayMultiplier;
+        int totalDuration = (int) (duration * totalDurationMultiplier);
+        float delayPoint = (delayMultiplier * duration) / totalDuration;
+        midwayPoint = 1 - (midwayPoint * (1 - delayPoint));
+
+        kf0 = Keyframe.ofFloat(0f, mTransitionEndRadiusMultiplier);
+        kf1 = Keyframe.ofFloat(delayPoint, mTransitionEndRadiusMultiplier);
+        kf2 = Keyframe.ofFloat(midwayPoint, mTransitionMidRadiusMultiplier);
+        kf3 = Keyframe.ofFloat(1f, 1);
+        PropertyValuesHolder radiusReappear = PropertyValuesHolder.ofKeyframe(
+                "animationRadiusMultiplier", kf0, kf1, kf2, kf3);
+
+        kf0 = Keyframe.ofFloat(0f, 0f);
+        kf1 = Keyframe.ofFloat(delayPoint, 0f);
+        kf2 = Keyframe.ofFloat(1f, 1f);
+        PropertyValuesHolder fadeIn = PropertyValuesHolder.ofKeyframe("alpha", kf0, kf1, kf2);
+
+        ObjectAnimator reappearAnimator = ObjectAnimator.ofPropertyValuesHolder(
+                this, radiusReappear, fadeIn).setDuration(totalDuration);
+        reappearAnimator.addUpdateListener(mInvalidateUpdateListener);
+        return reappearAnimator;
+    }
+
+    /**
+     * We'll need to invalidate during the animation.
+     */
+    private class InvalidateUpdateListener implements AnimatorUpdateListener {
+        @Override
+        public void onAnimationUpdate(ValueAnimator animation) {
+            RadialSelectorView.this.invalidate();
+        }
+    }
+}

uhabits-android/src/main/java/com/android/datetimepicker/time/RadialTextsView.java

@@ -0,0 +1,359 @@
+/*
+ * Copyright (C) 2013 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.datetimepicker.time;
+
+import android.animation.Keyframe;
+import android.animation.ObjectAnimator;
+import android.animation.PropertyValuesHolder;
+import android.animation.ValueAnimator;
+import android.animation.ValueAnimator.AnimatorUpdateListener;
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Paint.Align;
+import android.graphics.Typeface;
+import android.util.Log;
+import android.view.View;
+
+import org.isoron.uhabits.R;
+
+/**
+ * A view to show a series of numbers in a circular pattern.
+ */
+public class RadialTextsView extends View {
+    private final static String TAG = "RadialTextsView";
+
+    private final Paint mPaint = new Paint();
+
+    private boolean mDrawValuesReady;
+    private boolean mIsInitialized;
+
+    private Typeface mTypefaceLight;
+    private Typeface mTypefaceRegular;
+    private String[] mTexts;
+    private String[] mInnerTexts;
+    private boolean mIs24HourMode;
+    private boolean mHasInnerCircle;
+    private float mCircleRadiusMultiplier;
+    private float mAmPmCircleRadiusMultiplier;
+    private float mNumbersRadiusMultiplier;
+    private float mInnerNumbersRadiusMultiplier;
+    private float mTextSizeMultiplier;
+    private float mInnerTextSizeMultiplier;
+
+    private int mXCenter;
+    private int mYCenter;
+    private float mCircleRadius;
+    private boolean mTextGridValuesDirty;
+    private float mTextSize;
+    private float mInnerTextSize;
+    private float[] mTextGridHeights;
+    private float[] mTextGridWidths;
+    private float[] mInnerTextGridHeights;
+    private float[] mInnerTextGridWidths;
+
+    private float mAnimationRadiusMultiplier;
+    private float mTransitionMidRadiusMultiplier;
+    private float mTransitionEndRadiusMultiplier;
+    ObjectAnimator mDisappearAnimator;
+    ObjectAnimator mReappearAnimator;
+    private InvalidateUpdateListener mInvalidateUpdateListener;
+
+    public RadialTextsView(Context context) {
+        super(context);
+        mIsInitialized = false;
+    }
+
+    public void initialize(Resources res, String[] texts, String[] innerTexts,
+            boolean is24HourMode, boolean disappearsOut) {
+        if (mIsInitialized) {
+            Log.e(TAG, "This RadialTextsView may only be initialized once.");
+            return;
+        }
+
+        // Set up the paint.
+        int numbersTextColor = res.getColor(R.color.numbers_text_color);
+        mPaint.setColor(numbersTextColor);
+        String typefaceFamily = res.getString(R.string.radial_numbers_typeface);
+        mTypefaceLight = Typeface.create(typefaceFamily, Typeface.NORMAL);
+        String typefaceFamilyRegular = res.getString(R.string.sans_serif);
+        mTypefaceRegular = Typeface.create(typefaceFamilyRegular, Typeface.NORMAL);
+        mPaint.setAntiAlias(true);
+        mPaint.setTextAlign(Align.CENTER);
+
+        mTexts = texts;
+        mInnerTexts = innerTexts;
+        mIs24HourMode = is24HourMode;
+        mHasInnerCircle = (innerTexts != null);
+
+        // Calculate the radius for the main circle.
+        if (is24HourMode) {
+            mCircleRadiusMultiplier = Float.parseFloat(
+                    res.getString(R.string.circle_radius_multiplier_24HourMode));
+        } else {
+            mCircleRadiusMultiplier = Float.parseFloat(
+                    res.getString(R.string.circle_radius_multiplier));
+            mAmPmCircleRadiusMultiplier =
+                    Float.parseFloat(res.getString(R.string.ampm_circle_radius_multiplier));
+        }
+
+        // Initialize the widths and heights of the grid, and calculate the values for the numbers.
+        mTextGridHeights = new float[7];
+        mTextGridWidths = new float[7];
+        if (mHasInnerCircle) {
+            mNumbersRadiusMultiplier = Float.parseFloat(
+                    res.getString(R.string.numbers_radius_multiplier_outer));
+            mTextSizeMultiplier = Float.parseFloat(
+                    res.getString(R.string.text_size_multiplier_outer));
+            mInnerNumbersRadiusMultiplier = Float.parseFloat(
+                    res.getString(R.string.numbers_radius_multiplier_inner));
+            mInnerTextSizeMultiplier = Float.parseFloat(
+                    res.getString(R.string.text_size_multiplier_inner));
+
+            mInnerTextGridHeights = new float[7];
+            mInnerTextGridWidths = new float[7];
+        } else {
+            mNumbersRadiusMultiplier = Float.parseFloat(
+                    res.getString(R.string.numbers_radius_multiplier_normal));
+            mTextSizeMultiplier = Float.parseFloat(
+                    res.getString(R.string.text_size_multiplier_normal));
+        }
+
+        mAnimationRadiusMultiplier = 1;
+        mTransitionMidRadiusMultiplier = 1f + (0.05f * (disappearsOut? -1 : 1));
+        mTransitionEndRadiusMultiplier = 1f + (0.3f * (disappearsOut? 1 : -1));
+        mInvalidateUpdateListener = new InvalidateUpdateListener();
+
+        mTextGridValuesDirty = true;
+        mIsInitialized = true;
+    }
+
+    /* package */ void setTheme(Context context, boolean themeDark) {
+        Resources res = context.getResources();
+        int textColor;
+        if (themeDark) {
+            textColor = res.getColor(R.color.white);
+        } else {
+            textColor = res.getColor(R.color.numbers_text_color);
+        }
+        mPaint.setColor(textColor);
+    }
+
+    /**
+     * Allows for smoother animation.
+     */
+    @Override
+    public boolean hasOverlappingRendering() {
+        return false;
+    }
+
+    /**
+     * Used by the animation to move the numbers in and out.
+     */
+    public void setAnimationRadiusMultiplier(float animationRadiusMultiplier) {
+        mAnimationRadiusMultiplier = animationRadiusMultiplier;
+        mTextGridValuesDirty = true;
+    }
+
+    @Override
+    public void onDraw(Canvas canvas) {
+        int viewWidth = getWidth();
+        if (viewWidth == 0 || !mIsInitialized) {
+            return;
+        }
+
+        if (!mDrawValuesReady) {
+            mXCenter = getWidth() / 2;
+            mYCenter = getHeight() / 2;
+            mCircleRadius = Math.min(mXCenter, mYCenter) * mCircleRadiusMultiplier;
+            if (!mIs24HourMode) {
+                // We'll need to draw the AM/PM circles, so the main circle will need to have
+                // a slightly higher center. To keep the entire view centered vertically, we'll
+                // have to push it up by half the radius of the AM/PM circles.
+                float amPmCircleRadius = mCircleRadius * mAmPmCircleRadiusMultiplier;
+                mYCenter -= amPmCircleRadius / 2;
+            }
+
+            mTextSize = mCircleRadius * mTextSizeMultiplier;
+            if (mHasInnerCircle) {
+                mInnerTextSize = mCircleRadius * mInnerTextSizeMultiplier;
+            }
+
+            // Because the text positions will be static, pre-render the animations.
+            renderAnimations();
+
+            mTextGridValuesDirty = true;
+            mDrawValuesReady = true;
+        }
+
+        // Calculate the text positions, but only if they've changed since the last onDraw.
+        if (mTextGridValuesDirty) {
+            float numbersRadius =
+                    mCircleRadius * mNumbersRadiusMultiplier * mAnimationRadiusMultiplier;
+
+            // Calculate the positions for the 12 numbers in the main circle.
+            calculateGridSizes(numbersRadius, mXCenter, mYCenter,
+                    mTextSize, mTextGridHeights, mTextGridWidths);
+            if (mHasInnerCircle) {
+                // If we have an inner circle, calculate those positions too.
+                float innerNumbersRadius =
+                        mCircleRadius * mInnerNumbersRadiusMultiplier * mAnimationRadiusMultiplier;
+                calculateGridSizes(innerNumbersRadius, mXCenter, mYCenter,
+                        mInnerTextSize, mInnerTextGridHeights, mInnerTextGridWidths);
+            }
+            mTextGridValuesDirty = false;
+        }
+
+        // Draw the texts in the pre-calculated positions.
+        drawTexts(canvas, mTextSize, mTypefaceLight, mTexts, mTextGridWidths, mTextGridHeights);
+        if (mHasInnerCircle) {
+            drawTexts(canvas, mInnerTextSize, mTypefaceRegular, mInnerTexts,
+                    mInnerTextGridWidths, mInnerTextGridHeights);
+        }
+    }
+
+    /**
+     * Using the trigonometric Unit Circle, calculate the positions that the text will need to be
+     * drawn at based on the specified circle radius. Place the values in the textGridHeights and
+     * textGridWidths parameters.
+     */
+    private void calculateGridSizes(float numbersRadius, float xCenter, float yCenter,
+            float textSize, float[] textGridHeights, float[] textGridWidths) {
+        /*
+         * The numbers need to be drawn in a 7x7 grid, representing the points on the Unit Circle.
+         */
+        float offset1 = numbersRadius;
+        // cos(30) = a / r => r * cos(30) = a => r * √3/2 = a
+        float offset2 = numbersRadius * ((float) Math.sqrt(3)) / 2f;
+        // sin(30) = o / r => r * sin(30) = o => r / 2 = a
+        float offset3 = numbersRadius / 2f;
+        mPaint.setTextSize(textSize);
+        // We'll need yTextBase to be slightly lower to account for the text's baseline.
+        yCenter -= (mPaint.descent() + mPaint.ascent()) / 2;
+
+        textGridHeights[0] = yCenter - offset1;
+        textGridWidths[0] = xCenter - offset1;
+        textGridHeights[1] = yCenter - offset2;
+        textGridWidths[1] = xCenter - offset2;
+        textGridHeights[2] = yCenter - offset3;
+        textGridWidths[2] = xCenter - offset3;
+        textGridHeights[3] = yCenter;
+        textGridWidths[3] = xCenter;
+        textGridHeights[4] = yCenter + offset3;
+        textGridWidths[4] = xCenter + offset3;
+        textGridHeights[5] = yCenter + offset2;
+        textGridWidths[5] = xCenter + offset2;
+        textGridHeights[6] = yCenter + offset1;
+        textGridWidths[6] = xCenter + offset1;
+    }
+
+    /**
+     * Draw the 12 text values at the positions specified by the textGrid parameters.
+     */
+    private void drawTexts(Canvas canvas, float textSize, Typeface typeface, String[] texts,
+            float[] textGridWidths, float[] textGridHeights) {
+        mPaint.setTextSize(textSize);
+        mPaint.setTypeface(typeface);
+        canvas.drawText(texts[0], textGridWidths[3], textGridHeights[0], mPaint);
+        canvas.drawText(texts[1], textGridWidths[4], textGridHeights[1], mPaint);
+        canvas.drawText(texts[2], textGridWidths[5], textGridHeights[2], mPaint);
+        canvas.drawText(texts[3], textGridWidths[6], textGridHeights[3], mPaint);
+        canvas.drawText(texts[4], textGridWidths[5], textGridHeights[4], mPaint);
+        canvas.drawText(texts[5], textGridWidths[4], textGridHeights[5], mPaint);
+        canvas.drawText(texts[6], textGridWidths[3], textGridHeights[6], mPaint);
+        canvas.drawText(texts[7], textGridWidths[2], textGridHeights[5], mPaint);
+        canvas.drawText(texts[8], textGridWidths[1], textGridHeights[4], mPaint);
+        canvas.drawText(texts[9], textGridWidths[0], textGridHeights[3], mPaint);
+        canvas.drawText(texts[10], textGridWidths[1], textGridHeights[2], mPaint);
+        canvas.drawText(texts[11], textGridWidths[2], textGridHeights[1], mPaint);
+    }
+
+    /**
+     * Render the animations for appearing and disappearing.
+     */
+    private void renderAnimations() {
+        Keyframe kf0, kf1, kf2, kf3;
+        float midwayPoint = 0.2f;
+        int duration = 500;
+
+        // Set up animator for disappearing.
+        kf0 = Keyframe.ofFloat(0f, 1);
+        kf1 = Keyframe.ofFloat(midwayPoint, mTransitionMidRadiusMultiplier);
+        kf2 = Keyframe.ofFloat(1f, mTransitionEndRadiusMultiplier);
+        PropertyValuesHolder radiusDisappear = PropertyValuesHolder.ofKeyframe(
+                "animationRadiusMultiplier", kf0, kf1, kf2);
+
+        kf0 = Keyframe.ofFloat(0f, 1f);
+        kf1 = Keyframe.ofFloat(1f, 0f);
+        PropertyValuesHolder fadeOut = PropertyValuesHolder.ofKeyframe("alpha", kf0, kf1);
+
+        mDisappearAnimator = ObjectAnimator.ofPropertyValuesHolder(
+                this, radiusDisappear, fadeOut).setDuration(duration);
+        mDisappearAnimator.addUpdateListener(mInvalidateUpdateListener);
+
+
+        // Set up animator for reappearing.
+        float delayMultiplier = 0.25f;
+        float transitionDurationMultiplier = 1f;
+        float totalDurationMultiplier = transitionDurationMultiplier + delayMultiplier;
+        int totalDuration = (int) (duration * totalDurationMultiplier);
+        float delayPoint = (delayMultiplier * duration) / totalDuration;
+        midwayPoint = 1 - (midwayPoint * (1 - delayPoint));
+
+        kf0 = Keyframe.ofFloat(0f, mTransitionEndRadiusMultiplier);
+        kf1 = Keyframe.ofFloat(delayPoint, mTransitionEndRadiusMultiplier);
+        kf2 = Keyframe.ofFloat(midwayPoint, mTransitionMidRadiusMultiplier);
+        kf3 = Keyframe.ofFloat(1f, 1);
+        PropertyValuesHolder radiusReappear = PropertyValuesHolder.ofKeyframe(
+                "animationRadiusMultiplier", kf0, kf1, kf2, kf3);
+
+        kf0 = Keyframe.ofFloat(0f, 0f);
+        kf1 = Keyframe.ofFloat(delayPoint, 0f);
+        kf2 = Keyframe.ofFloat(1f, 1f);
+        PropertyValuesHolder fadeIn = PropertyValuesHolder.ofKeyframe("alpha", kf0, kf1, kf2);
+
+        mReappearAnimator = ObjectAnimator.ofPropertyValuesHolder(
+                this, radiusReappear, fadeIn).setDuration(totalDuration);
+        mReappearAnimator.addUpdateListener(mInvalidateUpdateListener);
+    }
+
+    public ObjectAnimator getDisappearAnimator() {
+        if (!mIsInitialized || !mDrawValuesReady || mDisappearAnimator == null) {
+            Log.e(TAG, "RadialTextView was not ready for animation.");
+            return null;
+        }
+
+        return mDisappearAnimator;
+    }
+
+    public ObjectAnimator getReappearAnimator() {
+        if (!mIsInitialized || !mDrawValuesReady || mReappearAnimator == null) {
+            Log.e(TAG, "RadialTextView was not ready for animation.");
+            return null;
+        }
+
+        return mReappearAnimator;
+    }
+
+    private class InvalidateUpdateListener implements AnimatorUpdateListener {
+        @Override
+        public void onAnimationUpdate(ValueAnimator animation) {
+            RadialTextsView.this.invalidate();
+        }
+    }
+}