ReactNotificationService to allow communication between native modules

change/react-native-windows-2020-05-19-13-43-33-MS_Notifications.json

@@ -0,0 +1,8 @@
+{
+  "type": "prerelease",
+  "comment": "ReactNotificationService to allow communications between native modules",
+  "packageName": "react-native-windows",
+  "email": "[email protected]",
+  "dependentChangeType": "patch",
+  "date": "2020-05-19T20:43:32.803Z"
+}

packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCPP/SampleModuleCPP.h

@@ -39,8 +39,18 @@ struct SampleModuleCppImpl {
     DEBUG_OUTPUT("C++ Properties.Prop1:", *reactContext.Properties().Get(myProp1));
     DEBUG_OUTPUT("C++ Properties.Prop2:", winrt::to_string(*reactContext.Properties().Get(myProp2)));
 
+    const ReactNotificationId<int> cppTimerNotification{L"SampleModuleCppImpl", L"TimerNotification"};
+    const ReactNotificationId<int> csTimerNotification{L"SampleModuleCS", L"TimerNotification"};
+
+    reactContext.Notifications().Subscribe(csTimerNotification, [
+    ](winrt::Windows::Foundation::IInspectable const &, ReactNotificationArgs<int> const &args) noexcept {
+      DEBUG_OUTPUT("C++ module, C# timer:", *args.Data());
+    });
+
     m_timer = winrt::Windows::System::Threading::ThreadPoolTimer::CreatePeriodicTimer(
-        [this](const winrt::Windows::System::Threading::ThreadPoolTimer) noexcept {
+        [ this, cppTimerNotification, notifications = reactContext.Notifications() ](
+            const winrt::Windows::System::Threading::ThreadPoolTimer) noexcept {
+          notifications.SendNotification(cppTimerNotification, m_timerCount);
           TimedEvent(++m_timerCount);
           if (m_timer && m_timerCount == 5) {
             m_timer.Cancel();

packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCS/SampleModuleCS.cs

@@ -29,8 +29,15 @@ public void Initialize(ReactContext reactContext)
             Debug.WriteLine($"C# Properties.Prop1: {reactContext.Handle.Properties.Get(ReactPropertyBagHelper.GetName(null, "Prop1"))}");
             Debug.WriteLine($"C# Properties.Prop2: {reactContext.Handle.Properties.Get(ReactPropertyBagHelper.GetName(null, "Prop2"))}");
 
+            var cppTimerNotification = ReactPropertyBagHelper.GetName(ReactPropertyBagHelper.GetNamespace("SampleModuleCppImpl"), "TimerNotification");
+            var csTimerNotification = ReactPropertyBagHelper.GetName(ReactPropertyBagHelper.GetNamespace("SampleModuleCS"), "TimerNotification");
+
+            reactContext.Handle.Notifications.Subscribe(cppTimerNotification, null,
+                (object sender, IReactNotificationArgs args) => Debug.WriteLine($"C# module, C++ timer:: {args.Data}"));
+
             _timer = ThreadPoolTimer.CreatePeriodicTimer(new TimerElapsedHandler((timer) =>
             {
+                reactContext.Handle.Notifications.SendNotification(csTimerNotification, null, _timerCount);
                 TimedEvent?.Invoke(++_timerCount);
                 if (_timerCount == 5)
                 {

vnext/Microsoft.ReactNative.Cxx/Microsoft.ReactNative.Cxx.vcxitems

@@ -19,6 +19,7 @@
   <ItemGroup>
     <ClInclude Include="$(MSBuildThisFileDirectory)CppWinRTIncludes.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Crash.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)ReactHandleHelper.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)JSValue.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)JSValueReader.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)JSValueTreeReader.h" />
@@ -28,7 +29,9 @@
     <ClInclude Include="$(MSBuildThisFileDirectory)ModuleRegistration.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)NamespaceRedirect.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)NativeModules.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)ReactDispatcher.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)ReactNonAbiValue.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)ReactNotificationService.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)ReactPropertyBag.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)ReactContext.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)ReactError.h" />

vnext/Microsoft.ReactNative.Cxx/ReactContext.h

@@ -8,6 +8,7 @@
 #include <CppWinRTIncludes.h>
 #include <string_view>
 #include "JSValueWriter.h"
+#include "ReactNotificationService.h"
 #include "ReactPropertyBag.h"
 
 namespace winrt::Microsoft::ReactNative {
@@ -32,6 +33,10 @@ struct ReactContext {
     return ReactPropertyBag{m_handle.Properties()};
   }
 
+  ReactNotificationService Notifications() const noexcept {
+    return ReactNotificationService{m_handle.Notifications()};
+  }
+
   // Call methodName JS function of module with moduleName.
   // args are either function arguments or a single lambda with 'IJSValueWriter const&' argument.
   template <class... TArgs>

vnext/Microsoft.ReactNative.Cxx/ReactDispatcher.h

@@ -0,0 +1,49 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#ifndef MICROSOFT_REACTNATIVE_REACTDISPATCHER
+#define MICROSOFT_REACTNATIVE_REACTDISPATCHER
+
+#include <winrt/Microsoft.ReactNative.h>
+#include "ReactHandleHelper.h"
+
+namespace winrt::Microsoft::ReactNative {
+
+// Represents a dispatcher queue to invoke work item asynchronously.
+// It wraps up the IReactDispatcher and adds convenience methods for
+// working with C++ types.
+struct ReactDispatcher {
+  ReactDispatcher(std::nullptr_t = nullptr) noexcept {}
+
+  explicit ReactDispatcher(IReactDispatcher const &handle) noexcept : m_handle{handle} {}
+
+  IReactDispatcher const &Handle() const noexcept {
+    return m_handle;
+  }
+
+  explicit operator bool() const noexcept {
+    return static_cast<bool>(m_handle);
+  }
+
+  void Post(ReactDispatcherCallback const &callback) const noexcept {
+    if (m_handle) {
+      m_handle.Post(callback);
+    }
+  }
+
+  bool HasThreadAccess() const noexcept {
+    return m_handle ? m_handle.HasThreadAccess() : false;
+  }
+
+  static ReactDispatcher CreateSerialDispatcher() noexcept {
+    return ReactDispatcher{ReactDispatcherHelper::CreateSerialDispatcher()};
+  }
+
+ private:
+  IReactDispatcher m_handle;
+};
+
+} // namespace winrt::Microsoft::ReactNative
+
+#endif // MICROSOFT_REACTNATIVE_REACTDISPATCHER

vnext/Microsoft.ReactNative.Cxx/ReactHandleHelper.h

@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#ifndef MICROSOFT_REACTNATIVE_REACTHANDLEHELPER
+#define MICROSOFT_REACTNATIVE_REACTHANDLEHELPER
+
+//
+// Helper methods for types that have Handle() method that return
+// an IInspectable-inherited value.
+//
+
+#include <winrt/Microsoft.ReactNative.h>
+#include <type_traits>
+
+namespace winrt::Microsoft::ReactNative {
+
+namespace Internal {
+template <class T>
+auto TestHandle(int) -> decltype(std::declval<T>().Handle());
+template <class>
+auto TestHandle(int *) -> void;
+} // namespace Internal
+
+template <class T>
+inline constexpr bool HasHandleV =
+    std::is_base_of_v<Windows::Foundation::IInspectable, std::decay_t<decltype(Internal::TestHandle<T>(0))>>;
+
+// True if two types with Handle() have the same handle.
+template <class T, std::enable_if_t<HasHandleV<T>, int> = 0>
+inline bool operator==(T const &left, T const &right) noexcept {
+  return left.Handle() == right.Handle();
+}
+
+// True if two types with Handle() have different handles.
+template <class T, std::enable_if_t<HasHandleV<T>, int> = 0>
+inline bool operator!=(T const &left, T const &right) noexcept {
+  return left.Handle() != right.Handle();
+}
+
+// True if handle of left is null.
+template <class T, std::enable_if_t<HasHandleV<T>, int> = 0>
+inline bool operator==(T const &left, std::nullptr_t) noexcept {
+  return !static_cast<bool>(left.Handle());
+}
+
+// True if handle of left is not null.
+template <class T, std::enable_if_t<HasHandleV<T>, int> = 0>
+inline bool operator!=(T const &left, std::nullptr_t) noexcept {
+  return static_cast<bool>(left.Handle());
+}
+
+// True if handle of right is null.
+template <class T, std::enable_if_t<HasHandleV<T>, int> = 0>
+inline bool operator==(std::nullptr_t, T const &right) noexcept {
+  return !static_cast<bool>(right.Handle());
+}
+
+// True if handle of left is not null.
+template <class T, std::enable_if_t<HasHandleV<T>, int> = 0>
+inline bool operator!=(std::nullptr_t, T const &right) noexcept {
+  return static_cast<bool>(right.Handle());
+}
+
+} // namespace winrt::Microsoft::ReactNative
+
+#endif // MICROSOFT_REACTNATIVE_REACTHANDLEHELPER