Fix: OnSlidingComplete is launched at the end of tap event (#336)

* Fire the onSlidingStart on tap handler for iOS

* Send a lastValue instead of value when firing onSlidingStart

The Start event of Slider for Android sends the lastValue which acts as
a point where the thumb was when slider was clicked.
This value should also be sent on iOS platform to keep the behavior
consisent.

* Use a state machine for drag and tap events on Windows

The state machine for handling the Start->Update->Complete events is
used to avoid multiplication of events when flags for sending status are
used.
This solution was implemented because there's no clear way to override
the default drag/tap events on the slider. So to avoid reimplementing
the whole architecture the flags and state machines has been used.

* Remove unused LaunchEvents() method

* Remove redundant EventType enum

The `EventType` enum has been previously used to recognize the action
performed on the Slider. But due to using flags for a state machine this
enum is no longer required and can be safely removed.

Author: BartoszKlonowski

src/ios/RNCSliderManager.m

@@ -58,10 +58,18 @@ - (void)tapHandler:(UITapGestureRecognizer *)gesture {
   CGPoint touchPoint = [gesture locationInView:slider];
   float rangeWidth = slider.maximumValue - slider.minimumValue;
   float sliderPercent = touchPoint.x / slider.bounds.size.width;
+  slider.lastValue = slider.value;
   float value = slider.minimumValue + (rangeWidth * sliderPercent);
 
   [slider setValue:discreteValue(slider, value) animated: YES];
-  
+
+
+  if (slider.onRNCSliderSlidingStart) {
+    slider.onRNCSliderSlidingStart(@{
+      @"value": @(slider.lastValue),
+    });
+  }
+
   // Trigger onValueChange to address https://github.com/react-native-community/react-native-slider/issues/212
   if (slider.onRNCSliderValueChange) {
     slider.onRNCSliderValueChange(@{

src/windows/SliderWindows/SliderView.cpp

@@ -183,56 +183,86 @@ namespace winrt::SliderWindows::implementation {
         m_updating = false;
     }
 
-    void SliderView::OnValueChangedHandler(winrt::IInspectable const& /*sender*/,
-        xaml::Controls::Primitives::RangeBaseValueChangedEventArgs const& args){
-
-        if (!m_updating) {
+    void SliderView::OnValueChangedHandler( winrt::IInspectable const& /*sender*/,
+        xaml::Controls::Primitives::RangeBaseValueChangedEventArgs const& args )
+    {
+        if( !m_updating )
+        {
             m_reactContext.DispatchEvent(
                 *this,
                 L"topChange",
-                [&](winrt::Microsoft::ReactNative::IJSValueWriter const& eventDataWriter) noexcept {
+                [&]( winrt::Microsoft::ReactNative::IJSValueWriter const& eventDataWriter ) noexcept
+                {
                     eventDataWriter.WriteObjectBegin();
                     {
-                        WriteProperty(eventDataWriter, L"value", args.NewValue());
+                        WriteProperty( eventDataWriter, L"value", args.NewValue() );
                     }
                     eventDataWriter.WriteObjectEnd();
-                });
+                } );
+            onValueChangeSent = true;
         }
     }
 
-    void SliderView::OnManipulationStartingHandler(winrt::IInspectable const& sender,
-        xaml::Input::ManipulationStartingRoutedEventArgs const& args) {
-        if (!m_updating) {
+    void SliderView::OnManipulationStartingHandler( winrt::IInspectable const& sender,
+        xaml::Input::ManipulationStartingRoutedEventArgs const& args )
+    {
+        if( !m_updating )
+        {
             auto self = sender.try_as<xaml::Controls::Slider>();
 
             m_reactContext.DispatchEvent(
                 *this,
                 L"topSlidingStart",
-                [&](winrt::Microsoft::ReactNative::IJSValueWriter const& eventDataWriter) noexcept {
+                [&]( winrt::Microsoft::ReactNative::IJSValueWriter const& eventDataWriter ) noexcept
+                {
                     eventDataWriter.WriteObjectBegin();
                     {
-                        WriteProperty(eventDataWriter, L"value", self.Value());
+                        WriteProperty( eventDataWriter, L"value", self.Value() );
                     }
                     eventDataWriter.WriteObjectEnd();
-                });
+                } );
+
+            if( onValueChangeSent )
+            {
+                m_reactContext.DispatchEvent(
+                    *this,
+                    L"topSlidingComplete",
+                    [&]( winrt::Microsoft::ReactNative::IJSValueWriter const& eventDataWriter ) noexcept
+                    {
+                        eventDataWriter.WriteObjectBegin();
+                        {
+                            WriteProperty( eventDataWriter, L"value", self.Value() );
+                        }
+                        eventDataWriter.WriteObjectEnd();
+                    } );
+                onSlidingCompleteSent = true;
+            }
+            onValueChangeSent = false;
+            onSlidingStartSent = true;
+            onSlidingCompleteSent = false;
         }
     }
-    
-    void SliderView::OnManipulationCompletedHandler(winrt::IInspectable const& sender,
-        xaml::Input::ManipulationCompletedRoutedEventArgs const& args) {
-        if (!m_updating) {
+
+    void SliderView::OnManipulationCompletedHandler( winrt::IInspectable const& sender,
+        xaml::Input::ManipulationCompletedRoutedEventArgs const& args )
+    {
+        if( !m_updating && onSlidingCompleteSent == false )
+        {
             auto self = sender.try_as<xaml::Controls::Slider>();
 
             m_reactContext.DispatchEvent(
                 *this,
                 L"topSlidingComplete",
-                [&](winrt::Microsoft::ReactNative::IJSValueWriter const& eventDataWriter) noexcept {
+                [&]( winrt::Microsoft::ReactNative::IJSValueWriter const& eventDataWriter ) noexcept
+                {
                     eventDataWriter.WriteObjectBegin();
                     {
-                        WriteProperty(eventDataWriter, L"value", self.Value());
+                        WriteProperty( eventDataWriter, L"value", self.Value() );
                     }
                     eventDataWriter.WriteObjectEnd();
-                });
+                } );
+            onSlidingCompleteSent = true;
+            onValueChangeSent = false;
         }
     }
 

src/windows/SliderWindows/SliderView.h

@@ -8,9 +8,9 @@
 #include "NativeModules.h"
 
 namespace winrt::SliderWindows::implementation {
-    
+
     namespace xaml = winrt::Windows::UI::Xaml;
-    
+
     class SliderView : public SliderViewT<SliderView> {
     public:
         SliderView(Microsoft::ReactNative::IReactContext const& reactContext);
@@ -39,9 +39,11 @@ namespace winrt::SliderWindows::implementation {
 
         double m_maxValue, m_minValue;
         double m_value;
+
+        bool onValueChangeSent, onSlidingStartSent, onSlidingCompleteSent;
     };
 }
 
 namespace winrt::SliderWindows::factory_implementation {
     struct SliderView : SliderViewT<SliderView, implementation::SliderView> {};
-}
+}