Site Settings final pass - design, analytics, feature toggling

WordPress/src/main/java/org/wordpress/android/models/SiteSettingsModel.java

@@ -13,6 +13,7 @@
 /**
  * Holds blog settings and provides methods to (de)serialize .com and self-hosted network calls.
  */
+
 public class SiteSettingsModel {
     public static final int RELATED_POSTS_ENABLED_FLAG = 0x1;
     public static final int RELATED_POST_HEADER_FLAG = 0x2;
@@ -37,9 +38,12 @@ public class SiteSettingsModel {
     public static final String ALLOW_COMMENTS_COLUMN_NAME = "allowComments";
     public static final String SEND_PINGBACKS_COLUMN_NAME = "sendPingbacks";
     public static final String RECEIVE_PINGBACKS_COLUMN_NAME = "receivePingbacks";
+    public static final String SHOULD_CLOSE_AFTER_COLUMN_NAME = "shouldCloseAfter";
     public static final String CLOSE_AFTER_COLUMN_NAME = "closeAfter";
     public static final String SORT_BY_COLUMN_NAME = "sortBy";
+    public static final String SHOULD_THREAD_COLUMN_NAME = "shouldThread";
     public static final String THREADING_COLUMN_NAME = "threading";
+    public static final String SHOULD_PAGE_COLUMN_NAME = "shouldPage";
     public static final String PAGING_COLUMN_NAME = "paging";
     public static final String MANUAL_APPROVAL_COLUMN_NAME = "manualApproval";
     public static final String IDENTITY_REQUIRED_COLUMN_NAME = "identityRequired";
@@ -71,9 +75,12 @@ public class SiteSettingsModel {
                     ALLOW_COMMENTS_COLUMN_NAME + " BOOLEAN, " +
                     SEND_PINGBACKS_COLUMN_NAME + " BOOLEAN, " +
                     RECEIVE_PINGBACKS_COLUMN_NAME + " BOOLEAN, " +
+                    SHOULD_CLOSE_AFTER_COLUMN_NAME + " BOOLEAN, " +
                     CLOSE_AFTER_COLUMN_NAME + " INTEGER, " +
                     SORT_BY_COLUMN_NAME + " INTEGER, " +
+                    SHOULD_THREAD_COLUMN_NAME + " BOOLEAN, " +
                     THREADING_COLUMN_NAME + " INTEGER, " +
+                    SHOULD_PAGE_COLUMN_NAME + " BOOLEAN, " +
                     PAGING_COLUMN_NAME + " INTEGER, " +
                     MANUAL_APPROVAL_COLUMN_NAME + " BOOLEAN, " +
                     IDENTITY_REQUIRED_COLUMN_NAME + " BOOLEAN, " +
@@ -106,9 +113,12 @@ public class SiteSettingsModel {
     public boolean allowComments;
     public boolean sendPingbacks;
     public boolean receivePingbacks;
+    public boolean shouldCloseAfter;
     public int closeCommentAfter;
     public int sortCommentsBy;
+    public boolean shouldThreadComments;
     public int threadingLevels;
+    public boolean shouldPageComments;
     public int commentsPerPage;
     public boolean commentApprovalRequired;
     public boolean commentsRequireIdentity;
@@ -181,9 +191,12 @@ public void copyFrom(SiteSettingsModel other) {
         allowComments = other.allowComments;
         sendPingbacks = other.sendPingbacks;
         receivePingbacks = other.receivePingbacks;
+        shouldCloseAfter = other.shouldCloseAfter;
         closeCommentAfter = other.closeCommentAfter;
         sortCommentsBy = other.sortCommentsBy;
+        shouldThreadComments = other.shouldThreadComments;
         threadingLevels = other.threadingLevels;
+        shouldPageComments = other.shouldPageComments;
         commentsPerPage = other.commentsPerPage;
         commentApprovalRequired = other.commentApprovalRequired;
         commentsRequireIdentity = other.commentsRequireIdentity;
@@ -215,9 +228,12 @@ public void deserializeOptionsDatabaseCursor(Cursor cursor, Map<Integer, Categor
         allowComments = getBooleanFromCursor(cursor, ALLOW_COMMENTS_COLUMN_NAME);
         sendPingbacks = getBooleanFromCursor(cursor, SEND_PINGBACKS_COLUMN_NAME);
         receivePingbacks = getBooleanFromCursor(cursor, RECEIVE_PINGBACKS_COLUMN_NAME);
+        shouldCloseAfter = getBooleanFromCursor(cursor, SHOULD_CLOSE_AFTER_COLUMN_NAME);
         closeCommentAfter = getIntFromCursor(cursor, CLOSE_AFTER_COLUMN_NAME);
         sortCommentsBy = getIntFromCursor(cursor, SORT_BY_COLUMN_NAME);
+        shouldThreadComments = getBooleanFromCursor(cursor, SHOULD_THREAD_COLUMN_NAME);
         threadingLevels = getIntFromCursor(cursor, THREADING_COLUMN_NAME);
+        shouldPageComments = getBooleanFromCursor(cursor, SHOULD_PAGE_COLUMN_NAME);
         commentsPerPage = getIntFromCursor(cursor, PAGING_COLUMN_NAME);
         commentApprovalRequired = getBooleanFromCursor(cursor, MANUAL_APPROVAL_COLUMN_NAME);
         commentsRequireIdentity = getBooleanFromCursor(cursor, IDENTITY_REQUIRED_COLUMN_NAME);
@@ -283,9 +299,12 @@ public ContentValues serializeToDatabase() {
         values.put(ALLOW_COMMENTS_COLUMN_NAME, allowComments);
         values.put(SEND_PINGBACKS_COLUMN_NAME, sendPingbacks);
         values.put(RECEIVE_PINGBACKS_COLUMN_NAME, receivePingbacks);
+        values.put(SHOULD_CLOSE_AFTER_COLUMN_NAME, shouldCloseAfter);
         values.put(CLOSE_AFTER_COLUMN_NAME, closeCommentAfter);
         values.put(SORT_BY_COLUMN_NAME, sortCommentsBy);
+        values.put(SHOULD_THREAD_COLUMN_NAME, shouldThreadComments);
         values.put(THREADING_COLUMN_NAME, threadingLevels);
+        values.put(SHOULD_PAGE_COLUMN_NAME, shouldPageComments);
         values.put(PAGING_COLUMN_NAME, commentsPerPage);
         values.put(MANUAL_APPROVAL_COLUMN_NAME, commentApprovalRequired);
         values.put(IDENTITY_REQUIRED_COLUMN_NAME, commentsRequireIdentity);

WordPress/src/main/java/org/wordpress/android/ui/WPNumberPicker.java

@@ -1,49 +1,262 @@
 package org.wordpress.android.ui;
 
 import android.content.Context;
-import android.graphics.Typeface;
+import android.graphics.Canvas;
+import android.graphics.Paint;
 import android.util.AttributeSet;
 import android.view.View;
+import android.widget.EditText;
 import android.widget.NumberPicker;
 import android.widget.TextView;
 
 import org.wordpress.android.R;
-import org.wordpress.android.widgets.TypefaceCache;
+import org.wordpress.android.util.WPPrefUtils;
+
+import java.lang.reflect.Field;
 
 public class WPNumberPicker extends NumberPicker {
+    private static final String DIVIDER_FIELD = "mSelectionDivider";
+    private static final String INPUT_FIELD = "mInputText";
+    private static final String INDICES_FIELD = "mSelectorIndices";
+    private static final String CUR_OFFSET_FIELD = "mCurrentScrollOffset";
+    private static final String SELECTOR_HEIGHT_FIELD = "mSelectorElementHeight";
+    private static final String INITIAL_OFFSET_FIELD = "mInitialScrollOffset";
+    private static final String CURRENT_OFFSET_FIELD = "mCurrentScrollOffset";
+    private static final String PAINT_FIELD = "mSelectorWheelPaint";
+
+    private static final int DISPLAY_COUNT = 5;
+    private static final int MIDDLE_INDEX = 2;
+
+    private Field mOffsetField;
+    private Field mSelectorHeight;
+    private Field mSelectorIndices;
+    private Field mInitialOffset;
+    private Field mCurrentOffset;
+
+    private EditText mInputView;
+    private Formatter mFormatter;
+    private Paint mPaint;
+    private int[] mDisplayValues;
+
     public WPNumberPicker(Context context, AttributeSet attrs) {
         super(context, attrs);
-        setWrapSelectorWheel(false);
+        mDisplayValues = new int[DISPLAY_COUNT];
+        getFieldsViaReflection();
+    }
+
+    @Override
+    public void addView(View child, int index, android.view.ViewGroup.LayoutParams params) {
+        super.addView(child, index, params);
+        if (child instanceof TextView) {
+            WPPrefUtils.layoutAsNumberPickerPeek((TextView) child);
+        }
     }
 
     @Override
-    public void addView(View child) {
-        super.addView(child);
-        updateView(child);
+    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+        super.onLayout(changed, left, top, right, bottom);
+        updateIntitialOffset();
+        setVerticalFadingEdgeEnabled(false);
+        setHorizontalFadingEdgeEnabled(false);
+        mInputView.setVisibility(View.INVISIBLE);
     }
 
     @Override
-    public void addView(View child, int index,
-                        android.view.ViewGroup.LayoutParams params) {
-        super.addView(child, index, params);
-        updateView(child);
+    public void setValue(int value) {
+        if (value < getMinValue()) value = getMinValue();
+        if (value > getMaxValue()) value = getMaxValue();
+        super.setValue(value);
+        EditText view = (EditText) getChildAt(0);
+        WPPrefUtils.layoutAsNumberPickerSelected(view);
     }
 
     @Override
-    public void addView(View child, android.view.ViewGroup.LayoutParams params) {
-        super.addView(child, params);
-        updateView(child);
+    protected void onDraw(Canvas canvas) {
+        int[] selectorIndices = getIndices();
+        setIndices(new int[0]);
+        setIndices(selectorIndices);
+
+        // Draw the middle number with a different font
+        setDisplayValues();
+        float elementHeight = getSelectorElementHeight();
+        float x = ((getRight() - getLeft()) / 2.0f);
+        float y = getScrollOffset();
+        Paint paint = mInputView.getPaint();
+        paint.setTextAlign(Paint.Align.CENTER);
+        //noinspection deprecation
+        paint.setColor(getResources().getColor(R.color.blue_medium));
+        int alpha = isEnabled() ? 255 : 96;
+        paint.setAlpha(alpha);
+        mPaint.setAlpha(alpha);
+
+        int offset = getResources().getDimensionPixelSize(R.dimen.margin_medium);
+        // Draw the visible values
+        for (int i = 0; i < DISPLAY_COUNT; ++i) {
+            String scrollSelectorValue;
+            if (mFormatter != null) {
+                scrollSelectorValue = mFormatter.format(mDisplayValues[i]);
+            } else {
+                scrollSelectorValue = String.valueOf(mDisplayValues[i]);
+            }
+            if (i == MIDDLE_INDEX) {
+                canvas.drawText(scrollSelectorValue, x, y - ((paint.descent() + paint.ascent()) / 2) - offset, paint);
+            } else {
+                canvas.drawText(scrollSelectorValue, x, y - ((mPaint.descent() + mPaint.ascent()) / 2) - offset, mPaint);
+            }
+            y += elementHeight;
+        }
+    }
+
+    @Override
+    public void setFormatter(Formatter formatter) {
+        super.setFormatter(formatter);
+        mFormatter = formatter;
+    }
+
+    private void setDisplayValues() {
+        int value = getValue();
+        for (int i = 0; i < DISPLAY_COUNT; ++i) {
+            mDisplayValues[i] = value - MIDDLE_INDEX + i;
+            if (mDisplayValues[i] < getMinValue()) {
+                mDisplayValues[i] = getMaxValue() + (mDisplayValues[i] + 1 - getMinValue());
+            } else if (mDisplayValues[i] > getMaxValue()) {
+                mDisplayValues[i] = getMinValue() + (mDisplayValues[i] - getMaxValue() - 1);
+            }
+        }
+    }
+
+    private void setIndices(int[] indices) {
+        if (mSelectorIndices != null) {
+            try {
+                mSelectorIndices.set(this, indices);
+            } catch (IllegalArgumentException | IllegalAccessException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private int[] getIndices() {
+        if (mSelectorIndices != null) {
+            try {
+                return (int[]) mSelectorIndices.get(this);
+            } catch (IllegalArgumentException | IllegalAccessException e) {
+                e.printStackTrace();
+            }
+        }
+
+        return null;
     }
 
-    private void updateView(View view) {
-        if (view instanceof TextView) {
-            Typeface type = TypefaceCache.getTypeface(getContext(),
-                    TypefaceCache.FAMILY_OPEN_SANS,
-                    Typeface.NORMAL,
-                    TypefaceCache.VARIATION_NORMAL);
-            ((TextView) view).setTypeface(type);
-            ((TextView) view).setTextSize(24);
-            ((TextView) view).setTextColor(getResources().getColor(R.color.wp_blue));
+    private int getScrollOffset() {
+        if (mOffsetField != null) {
+            try {
+                return (Integer) mOffsetField.get(this);
+            } catch (IllegalArgumentException | IllegalAccessException e) {
+                e.printStackTrace();
+            }
         }
+
+        return 0;
+    }
+
+    private int getSelectorElementHeight() {
+        if (mSelectorHeight != null) {
+            try {
+                return (Integer) mSelectorHeight.get(this);
+            } catch (IllegalAccessException e) {
+                e.printStackTrace();
+            }
+        }
+
+        return 0;
+    }
+
+    private void updateIntitialOffset() {
+        if (mInitialOffset != null) {
+            try {
+                int offset = (Integer) mInitialOffset.get(this) - getSelectorElementHeight();
+                mInitialOffset.set(this, offset);
+                // Only do this once
+                mInitialOffset = null;
+
+                if (mCurrentOffset != null) {
+                    mCurrentOffset.set(this, offset);
+                }
+            } catch (IllegalAccessException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * From https://www.snip2code.com/Snippet/67740/NumberPicker-with-transparent-selection-
+     */
+    private void removeDividers(Class<?> clazz) {
+        Field selectionDivider = getFieldAndSetAccessible(clazz, DIVIDER_FIELD);
+        if (selectionDivider != null) {
+            try {
+                selectionDivider.set(this, null);
+            } catch (IllegalArgumentException | IllegalAccessException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private void getTextPaint(Class<?> clazz) {
+        Field paint = getFieldAndSetAccessible(clazz, PAINT_FIELD);
+        if (paint != null) {
+            try {
+                mPaint = (Paint) paint.get(this);
+            } catch (IllegalArgumentException | IllegalAccessException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private void getInputField(Class<?> clazz) {
+        Field inputField = getFieldAndSetAccessible(clazz, INPUT_FIELD);
+        if (inputField != null) {
+            try {
+                mInputView = ((EditText) inputField.get(this));
+            } catch (IllegalArgumentException | IllegalAccessException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * Gets a class field using reflection and makes it accessible.
+     */
+    private Field getFieldAndSetAccessible(Class<?> clazz, String fieldName) {
+        Field field = null;
+        try {
+            field = clazz.getDeclaredField(fieldName);
+            field.setAccessible(true);
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+
+        return field;
+    }
+
+    private void getFieldsViaReflection() {
+        Class<?> numberPickerClass = null;
+        try {
+            numberPickerClass = Class.forName(NumberPicker.class.getName());
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+        if (numberPickerClass == null) return;
+
+        mSelectorHeight = getFieldAndSetAccessible(numberPickerClass, SELECTOR_HEIGHT_FIELD);
+        mOffsetField = getFieldAndSetAccessible(numberPickerClass, CUR_OFFSET_FIELD);
+        mSelectorIndices = getFieldAndSetAccessible(numberPickerClass, INDICES_FIELD);
+        mInitialOffset = getFieldAndSetAccessible(numberPickerClass, INITIAL_OFFSET_FIELD);
+        mCurrentOffset = getFieldAndSetAccessible(numberPickerClass, CURRENT_OFFSET_FIELD);
+
+        getTextPaint(numberPickerClass);
+        getInputField(numberPickerClass);
+        removeDividers(numberPickerClass);
+        setIndices(new int[DISPLAY_COUNT]);
     }
 }