Added RxTimePicker and RxDatePicker

rxbinding/src/androidTest/AndroidManifest.xml

@@ -12,6 +12,8 @@
     <activity android:name=".widget.RxRatingBarTestActivity"/>
     <activity android:name=".widget.RxSeekBarTestActivity"/>
     <activity android:name=".widget.RxPopupMenuTestActivity"/>
+    <activity android:name=".widget.RxTimePickerTestActivity"/>
+    <activity android:name=".widget.RxDatePickerTestActivity"/>
     <activity
         android:name=".widget.RxToolbarTestActivity"
         android:theme="@android:style/Theme.Material"

rxbinding/src/androidTest/java/com/jakewharton/rxbinding/widget/RxDatePickerTest.java

@@ -0,0 +1,135 @@
+package com.jakewharton.rxbinding.widget;
+
+import android.annotation.TargetApi;
+import android.app.Instrumentation;
+import android.support.test.InstrumentationRegistry;
+import android.support.test.annotation.UiThreadTest;
+import android.support.test.rule.ActivityTestRule;
+import android.support.test.runner.AndroidJUnit4;
+import android.view.View;
+import android.widget.DatePicker;
+
+import com.jakewharton.rxbinding.RecordingObserver;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import rx.Subscription;
+import rx.android.schedulers.AndroidSchedulers;
+import rx.functions.Action1;
+
+import static com.google.common.truth.Truth.assertThat;
+
+@RunWith(AndroidJUnit4.class)
+public class RxDatePickerTest {
+
+    @Rule
+    public final ActivityTestRule<RxDatePickerTestActivity> activityRule =
+            new ActivityTestRule<>(RxDatePickerTestActivity.class);
+
+    /**
+     * The time picker view
+     */
+    private DatePicker datePicker;
+
+    /**
+     * The instrumentation object
+     */
+    private final Instrumentation instrumentation = InstrumentationRegistry.getInstrumentation();
+
+    @Before
+    public void setUp() {
+        datePicker = activityRule.getActivity().datePicker;
+    }
+
+    @Test
+    public void testDateChanges() {
+        RecordingObserver<DatePickerChangeEvent> o = new RecordingObserver<>();
+        Subscription subscription = RxDatePicker.init(datePicker, 2016, 5, 10) //
+                .subscribeOn(AndroidSchedulers.mainThread()) //
+                .subscribe(o);
+        assertThat(o.takeNext()).isEqualTo(DatePickerChangeEvent.create(datePicker, 2016, 5, 10));
+
+        instrumentation.runOnMainSync(new Runnable() {
+            @Override
+            public void run() {
+                datePicker.updateDate(2016, 1, 1);
+                datePicker.updateDate(2016, 1, 2);
+                datePicker.updateDate(2016, 2, 2);
+                datePicker.updateDate(2017, 11, 25);
+            }
+        });
+        assertThat(o.takeNext()).isEqualTo(DatePickerChangeEvent.create(datePicker, 2016, 1, 1));
+        assertThat(o.takeNext()).isEqualTo(DatePickerChangeEvent.create(datePicker, 2016, 1, 2));
+        assertThat(o.takeNext()).isEqualTo(DatePickerChangeEvent.create(datePicker, 2016, 2, 2));
+        assertThat(o.takeNext()).isEqualTo(DatePickerChangeEvent.create(datePicker, 2017, 11, 25));
+
+        subscription.unsubscribe();
+    }
+
+    @Test
+    @UiThreadTest
+    public void testUpdateDate(){
+        Action1<? super Integer> action = RxDatePicker.updateYear(datePicker);
+        action.call(1);
+        assertThat(datePicker.getYear()).isEqualTo(1);
+        action.call(12);
+        assertThat(datePicker.getYear()).isEqualTo(12);
+
+        Action1<? super Integer> action2 = RxDatePicker.updateDayOfMonth(datePicker);
+        action2.call(25);
+        assertThat(datePicker.getDayOfMonth()).isEqualTo(25);
+        action2.call(2);
+        assertThat(datePicker.getDayOfMonth()).isEqualTo(2);
+
+        Action1<? super Integer> action3 = RxDatePicker.updateMonthOfYear(datePicker);
+        action3.call(11);
+        assertThat(datePicker.getMonth()).isEqualTo(11);
+        action3.call(5);
+        assertThat(datePicker.getMonth()).isEqualTo(5);
+    }
+
+    @Test
+    @UiThreadTest
+    @TargetApi(21)
+    public void testSetFirstDayOfWeek(){
+        Action1<? super Integer> action = RxDatePicker.firstDayOfWeek(datePicker);
+        action.call(1);
+        assertThat(datePicker.getFirstDayOfWeek()).isEqualTo(1);
+        action.call(7);
+        assertThat(datePicker.getFirstDayOfWeek()).isEqualTo(7);
+        assertThat(datePicker.getFirstDayOfWeek()).isNotEqualTo(5);
+    }
+
+    @Test
+    @UiThreadTest
+    public void testMaxMinDate(){
+        Action1<? super Long> action = RxDatePicker.maxDate(datePicker);
+        action.call(1L);
+        assertThat(datePicker.getMaxDate()).isEqualTo(1L);
+        action.call(1232131232131L);
+        assertThat(datePicker.getMaxDate()).isEqualTo(1232131232131L);
+
+        Action1<? super Long> action2 = RxDatePicker.minDate(datePicker);
+        action2.call(12L);
+        assertThat(datePicker.getMinDate()).isEqualTo(12L);
+        action2.call(3232L);
+        assertThat(datePicker.getMinDate()).isEqualTo(3232L);
+    }
+
+    @Test
+    @UiThreadTest
+    public void testShownSpinners(){
+        Action1<? super Boolean> action = RxDatePicker.spinnersShown(datePicker);
+//        action.call(true);
+        datePicker.setSpinnersShown(true);
+        //it is false because the spinners are not shown on calendar mode
+        assertThat(datePicker.getSpinnersShown()).isFalse();
+        action.call(false);
+        assertThat(datePicker.getSpinnersShown()).isFalse();
+
+    }
+
+}

rxbinding/src/androidTest/java/com/jakewharton/rxbinding/widget/RxDatePickerTestActivity.java

@@ -0,0 +1,19 @@
+package com.jakewharton.rxbinding.widget;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.widget.DatePicker;
+
+public class RxDatePickerTestActivity extends Activity {
+
+    DatePicker datePicker;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        datePicker = new DatePicker(this);
+        setContentView(datePicker);
+    }
+
+}

rxbinding/src/androidTest/java/com/jakewharton/rxbinding/widget/RxRatingBarTest.java

@@ -65,8 +65,8 @@
 
   @Test public void ratingChangeEvents() {
     RecordingObserver<RatingBarChangeEvent> o = new RecordingObserver<>();
-    Subscription subscription = RxRatingBar.ratingChangeEvents(view) //
-        .subscribeOn(AndroidSchedulers.mainThread()) //
+    Subscription subscription = RxRatingBar.ratingChangeEvents(view)
+        .subscribeOn(AndroidSchedulers.mainThread())
         .subscribe(o);
     assertThat(o.takeNext()).isEqualTo(RatingBarChangeEvent.create(view, 0f, false));
 

rxbinding/src/androidTest/java/com/jakewharton/rxbinding/widget/RxTimePickerTest.java

@@ -0,0 +1,116 @@
+package com.jakewharton.rxbinding.widget;
+
+import android.app.Instrumentation;
+import android.support.test.InstrumentationRegistry;
+import android.support.test.annotation.UiThreadTest;
+import android.support.test.rule.ActivityTestRule;
+import android.support.test.runner.AndroidJUnit4;
+import android.widget.TimePicker;
+
+import com.jakewharton.rxbinding.RecordingObserver;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import rx.Subscription;
+import rx.android.schedulers.AndroidSchedulers;
+import rx.functions.Action1;
+
+import static com.google.common.truth.Truth.assertThat;
+
+@RunWith(AndroidJUnit4.class)
+public class RxTimePickerTest {
+    @Rule
+    public final ActivityTestRule<RxTimePickerTestActivity> activityRule =
+            new ActivityTestRule<>(RxTimePickerTestActivity.class);
+
+    /**
+     * The time picker view
+     */
+    private TimePicker timePicker;
+
+    /**
+     * The instrumentation object
+     */
+    private final Instrumentation instrumentation = InstrumentationRegistry.getInstrumentation();
+
+    @Before
+    public void setUp() {
+        timePicker = activityRule.getActivity().timePicker;
+    }
+
+    @Test
+    public void testTimeChanges() {
+        RecordingObserver<TimePickerTimeChangeEvent> o = new RecordingObserver<>();
+        Subscription subscription = RxTimePicker.timeChange(timePicker) //
+                .subscribeOn(AndroidSchedulers.mainThread()) //
+                .subscribe(o);
+        assertThat(o.takeNext()).isNotNull();
+
+        instrumentation.runOnMainSync(new Runnable() {
+            @Override
+            public void run() {
+                timePicker.setCurrentMinute(59);
+                timePicker.setCurrentHour(11);
+                timePicker.setCurrentMinute(23);
+            }
+        });
+        TimePickerTimeChangeEvent event = o.takeNext();
+        assertThat(event).isEqualTo(TimePickerTimeChangeEvent.create(timePicker, event.getHourOfDay(), 59));
+
+
+        //there is a bug in the android system that calls onTimeChange twice
+        o.takeNext();
+        event = o.takeNext();
+        assertThat(event).isEqualTo(TimePickerTimeChangeEvent.create(timePicker, 11, event.getMinute()));
+
+        //there is a bug in the android system that calls onTimeChange twice
+        o.takeNext();
+        event = o.takeNext();
+        assertThat(event).isEqualTo(TimePickerTimeChangeEvent.create(timePicker, event.getHourOfDay(), 23));
+
+        subscription.unsubscribe();
+    }
+
+    @Test
+    @UiThreadTest
+    public void testIs24HourMode() {
+        Action1<? super Boolean> action = RxTimePicker.is24HourView(timePicker);
+        action.call(true);
+        assertThat(timePicker.is24HourView()).isTrue();
+        action.call(false);
+        assertThat(timePicker.is24HourView()).isFalse();
+    }
+
+
+    @Test
+    @UiThreadTest
+    public void testHour() {
+        Action1<? super Integer> action = RxTimePicker.hour(timePicker);
+        action.call(12);
+        assertThat(timePicker.getCurrentHour()).isEqualTo(12);
+        action.call(13);
+        assertThat(timePicker.getCurrentHour()).isEqualTo(13);
+        action.call(1);
+        assertThat(timePicker.getCurrentHour()).isEqualTo(1);
+        action.call(23);
+        assertThat(timePicker.getCurrentHour()).isEqualTo(23);
+    }
+
+    @Test
+    @UiThreadTest
+    public void testMinute() {
+        Action1<? super Integer> action = RxTimePicker.minute(timePicker);
+        action.call(59);
+        assertThat(timePicker.getCurrentMinute()).isEqualTo(59);
+        action.call(13);
+        assertThat(timePicker.getCurrentMinute()).isEqualTo(13);
+        action.call(45);
+        assertThat(timePicker.getCurrentMinute()).isEqualTo(45);
+        action.call(33);
+        assertThat(timePicker.getCurrentMinute()).isEqualTo(33);
+    }
+
+}

rxbinding/src/androidTest/java/com/jakewharton/rxbinding/widget/RxTimePickerTestActivity.java

@@ -0,0 +1,18 @@
+package com.jakewharton.rxbinding.widget;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.widget.TimePicker;
+
+public final class RxTimePickerTestActivity extends Activity {
+
+    TimePicker timePicker;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        timePicker = new TimePicker(this);
+        setContentView(timePicker);
+    }
+}

rxbinding/src/main/java/com/jakewharton/rxbinding/widget/DatePickerChangeEvent.java

@@ -0,0 +1,77 @@
+package com.jakewharton.rxbinding.widget;
+
+import android.support.annotation.CheckResult;
+import android.support.annotation.NonNull;
+import android.widget.DatePicker;
+
+import com.jakewharton.rxbinding.view.ViewEvent;
+
+public class DatePickerChangeEvent extends ViewEvent<DatePicker> {
+
+    @CheckResult
+    @NonNull
+    public static DatePickerChangeEvent create(@NonNull DatePicker view, int year, int monthOfYear,
+                                               int dayOfMonth) {
+        return new DatePickerChangeEvent(view, year, monthOfYear, dayOfMonth);
+    }
+
+    private int year;
+
+    private int monthOfYear;
+
+    private int dayOfMonth;
+
+    private DatePickerChangeEvent(@NonNull DatePicker view, int year, int monthOfYear,
+                                  int dayOfMonth) {
+        super(view);
+        this.year = year;
+        this.monthOfYear = monthOfYear;
+        this.dayOfMonth = dayOfMonth;
+    }
+
+    public int getYear() {
+        return year;
+    }
+
+    public int getMonthOfYear() {
+        return monthOfYear;
+    }
+
+    public int getDayOfMonth() {
+        return dayOfMonth;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = 17;
+        result = result * 37 + view().hashCode();
+        result = result * 37 + year;
+        result = result * 37 + monthOfYear;
+        result = result * 37 + dayOfMonth;
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o instanceof DatePickerChangeEvent) {
+            DatePickerChangeEvent other = (DatePickerChangeEvent) o;
+            return this == other || this.year == other.getYear()
+                    && this.monthOfYear == other.getMonthOfYear()
+                    && this.dayOfMonth == other.getDayOfMonth();
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return "DatePickerChangeEvent{view="
+                + view()
+                + ", year="
+                + year
+                + ", monthOfYear="
+                + monthOfYear
+                + ", dayOfMonth "
+                + dayOfMonth
+                + '}';
+    }
+}