@pinwheel/react-native-pinwheel 3.0.5 → 3.2.0-rc.0

package/android/src/main/java/com/rtnpinwheel/Pinwheel.kt

@@ -0,0 +1,103 @@
+package com.rtnpinwheel
+
+import android.content.Context
+import android.graphics.Color
+import android.os.Handler
+import android.os.Looper
+import android.util.AttributeSet
+import android.util.Log
+import android.view.Choreographer
+import android.view.View
+import android.widget.FrameLayout
+import androidx.fragment.app.FragmentActivity
+import com.facebook.react.bridge.ReactApplicationContext
+import com.underdog_tech.pinwheel_android.PinwheelEventListener
+import com.underdog_tech.pinwheel_android.PinwheelFragment
+import com.facebook.react.uimanager.ThemedReactContext
+
+class Pinwheel : FrameLayout {
+  private var token: String? = null
+  private var pinwheelFragment: PinwheelFragment? = null
+  private var pinwheelEventListener: PinwheelEventListener? = null
+
+  constructor(context: Context) : super(context) {
+    init()
+  }
+
+  constructor(context: Context, attrs: AttributeSet?) : super(context, attrs) {
+    init()
+  }
+
+  constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int) : super(
+    context,
+    attrs,
+    defStyleAttr
+  ) {
+    init()
+  }
+
+  private fun init() {
+    // Match background color of Link. We may want to have a loader here in the future.
+    setBackgroundColor(Color.WHITE)
+  }
+
+  fun setToken(token: String?) {
+    this.token = token
+  }
+
+  private fun createFragment() {
+    Handler(Looper.getMainLooper()).post {
+      this.token?.let {
+        val pinwheelFragment = PinwheelFragment.newInstance(it, "react native", "3.1.0")
+        pinwheelEventListener?.let { listener ->
+          pinwheelFragment.pinwheelEventListener = listener
+        }
+        val reactContext = context as ThemedReactContext
+        val activity = reactContext.currentActivity as? FragmentActivity
+
+        activity?.supportFragmentManager
+          ?.beginTransaction()
+          ?.replace(id, pinwheelFragment, id.toString())
+          ?.commit()
+
+        this.pinwheelFragment = pinwheelFragment
+      }
+    }
+
+    Handler(Looper.getMainLooper()).post {
+      Choreographer.getInstance().postFrameCallback(object: Choreographer.FrameCallback {
+        override fun doFrame(frameTimeNanos: Long) {
+          setupLayoutSizing()
+          // TODO: functionality works without this line, but it was present in the old SDK code
+          //  view.viewTreeObserver.dispatchOnGlobalLayout()
+          Choreographer.getInstance().postFrameCallback(this)
+        }
+      })
+    }
+  }
+
+  fun setupLayoutSizing() {
+    val width = this.width
+    val height = this.height
+    this.measure(
+      View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY),
+      View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY))
+
+    this.layout(0, 0, width, height)
+  }
+
+  override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+    super.onLayout(changed, left, top, right, bottom)
+
+    if (changed && this.pinwheelFragment == null) {
+      createFragment()
+    }
+  }
+
+  fun setPinwheelEventListener(listener: PinwheelEventListener) {
+    pinwheelEventListener = listener
+    pinwheelFragment?.let {
+      it.pinwheelEventListener = listener
+    }
+  }
+}

package/android/src/main/java/com/{underdog_tech/react/PinwheelViewManager.kt → rtnpinwheel/PinwheelEventsModule.kt}

@@ -1,24 +1,16 @@
-package com.underdog_tech.react
+package com.rtnpinwheel
 
-import android.view.Choreographer
-import android.view.View
-import android.view.ViewGroup
-import android.widget.FrameLayout
-import androidx.fragment.app.FragmentActivity
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.modules.core.DeviceEventManagerModule
-import com.facebook.react.uimanager.ThemedReactContext
-import com.facebook.react.uimanager.ViewGroupManager
-import com.facebook.react.uimanager.annotations.ReactPropGroup
-import com.facebook.react.uimanager.annotations.ReactProp
-import com.underdog_tech.pinwheel_android.PinwheelFragment
 import com.underdog_tech.pinwheel_android.PinwheelEventListener
-import com.underdog_tech.pinwheel_android.model.PinwheelEventType
 import com.underdog_tech.pinwheel_android.model.PinwheelEventPayload
+import com.underdog_tech.pinwheel_android.model.PinwheelEventType
 import com.underdog_tech.pinwheel_android.model.PinwheelInputAllocationPayload
 import com.underdog_tech.pinwheel_android.model.PinwheelTarget
 import com.underdog_tech.pinwheel_android.model.PinwheelAllocation
@@ -32,6 +24,56 @@ import com.underdog_tech.pinwheel_android.model.PinwheelLoginAttemptPayload
 import com.underdog_tech.pinwheel_android.model.PinwheelDDFormCreatePayload
 import com.underdog_tech.pinwheel_android.model.PinwheelScreenTransitionPayload
 
+@ReactModule(name = PinwheelEventsModule.NAME)
+class PinwheelEventsModule(private val context: ReactApplicationContext) : ReactContextBaseJavaModule(context), PinwheelEventListener {
+    init {
+        Companion.context = context
+    }
+
+    override fun getName(): String = NAME
+
+    @ReactMethod
+    fun setListener() {
+        hasListeners = true;
+    }
+
+    @ReactMethod
+    fun removeListener() {
+        hasListeners = false;
+    }
+
+    @ReactMethod
+    fun addListener(eventName: String) {
+        // Keep: Required for RN built in Event Emitter Calls.
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        // Keep: Required for RN built in Event Emitter Calls.
+    }
+
+    override fun onEvent(eventName: PinwheelEventType, payload: PinwheelEventPayload?) {
+        if (!hasListeners) return
+
+        val params = WritableNativeMap()
+        params.putString("name", eventName.toString())
+        if (payload != null) {
+            params.putMap("payload", payload.toWritableMap())
+        }
+        
+        context
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(Companion.PinwheelEventName, params)
+    }
+
+    companion object {
+        const val NAME = "RTNPinwheelEvents"
+        const val PinwheelEventName = "PINWHEEL_EVENT"
+        private var context: ReactApplicationContext? = null
+        private var hasListeners = false;
+    }
+}
+
 fun PinwheelTarget.toWritableMap(): WritableMap {
   return Arguments.createMap().apply {
     putString("accountType", this@toWritableMap.accountType)
@@ -100,110 +142,3 @@ fun PinwheelEventPayload.toWritableMap(): WritableMap = when (this) {
   }
   else -> throw IllegalArgumentException("Unsupported PinwheelEventPayload type")
 }
-
-class PinwheelViewManager(
-  private val reactContext: ReactApplicationContext
-) : ViewGroupManager<FrameLayout>(), PinwheelEventListener {
-  private var propWidth: Int? = reactContext.resources.displayMetrics.widthPixels
-  private var propHeight: Int? = reactContext.resources.displayMetrics.heightPixels
-  private var token: String? = null
-
-  override fun getName() = REACT_CLASS
-
-  /**
-   * Return a FrameLayout which will later hold the Fragment
-   */
-  override fun createViewInstance(reactContext: ThemedReactContext): FrameLayout {
-    return FrameLayout(reactContext)
-  }
-
-  /**
-   * Map the "create" command to an integer
-   */
-  override fun getCommandsMap() = mapOf("create" to COMMAND_CREATE)
-
-  /**
-   * Handle "create" command (called from JS) and call createFragment method
-   */
-  override fun receiveCommand(
-    root: FrameLayout,
-    commandId: String,
-    args: ReadableArray?
-  ) {
-    super.receiveCommand(root, commandId, args)
-    val reactNativeViewId = requireNotNull(args).getInt(0)
-
-    when (commandId.toInt()) {
-      COMMAND_CREATE -> createFragment(root, reactNativeViewId)
-    }
-  }
-
-  @ReactPropGroup(names = ["width", "height"], customType = "Style")
-  fun setStyle(view: FrameLayout, index: Int, value: Int) {
-    if (index == 0) propWidth = value
-    if (index == 1) propHeight = value
-  }
-
-  @ReactProp(name="token")
-  fun setToken(view: FrameLayout, token: String) {
-    this.token = token
-  }
-
-  /**
-   * Replace your React Native view with a custom fragment
-   */
-  fun createFragment(root: FrameLayout, reactNativeViewId: Int) {
-    val parentView = root.findViewById<ViewGroup>(reactNativeViewId)
-    setupLayout(parentView)
-
-
-    this.token?.let {
-      val pinwheelFragment = PinwheelFragment.newInstance(it, "react native", "3.0.5")
-      pinwheelFragment.pinwheelEventListener = this
-      val activity = reactContext.currentActivity as FragmentActivity
-      activity.supportFragmentManager
-        .beginTransaction()
-        .replace(reactNativeViewId, pinwheelFragment, reactNativeViewId.toString())
-        .commit()
-    }
-  }
-
-  fun setupLayout(view: View) {
-    Choreographer.getInstance().postFrameCallback(object: Choreographer.FrameCallback {
-      override fun doFrame(frameTimeNanos: Long) {
-        manuallyLayoutChildren(view)
-        view.viewTreeObserver.dispatchOnGlobalLayout()
-        Choreographer.getInstance().postFrameCallback(this)
-      }
-    })
-  }
-
-  override fun onEvent(eventName: PinwheelEventType, payload: PinwheelEventPayload?) {
-    val params = WritableNativeMap()
-    params.putString("name", eventName.toString())
-    params.putMap("payload", payload?.toWritableMap())
-    reactContext
-        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-        .emit("PINWHEEL_EVENT", params)
-  }
-
-  /**
-   * Layout all children properly
-   */
-  private fun manuallyLayoutChildren(view: View) {
-    // propWidth and propHeight coming from react-native props
-    val width = requireNotNull(propWidth)
-    val height = requireNotNull(propHeight)
-
-    view.measure(
-        View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY),
-        View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY))
-
-    view.layout(0, 0, width, height)
-  }
-
-  companion object {
-    private const val REACT_CLASS = "RNTPinwheel"
-    private const val COMMAND_CREATE = 1
-  }
-}

package/android/src/main/java/com/rtnpinwheel/PinwheelManager.kt

@@ -0,0 +1,54 @@
+package com.rtnpinwheel
+
+import android.view.ViewGroup
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.uimanager.annotations.ReactPropGroup
+import com.facebook.react.viewmanagers.RTNPinwheelManagerInterface
+import com.facebook.react.viewmanagers.RTNPinwheelManagerDelegate
+
+@ReactModule(name = PinwheelManager.NAME)
+class PinwheelManager(private val reactContext: ReactApplicationContext) : 
+    SimpleViewManager<Pinwheel>(),
+    RTNPinwheelManagerInterface<Pinwheel> {
+
+    private val delegate: RTNPinwheelManagerDelegate<Pinwheel, PinwheelManager> = RTNPinwheelManagerDelegate(this)
+    private var propWidth: Int? = null
+    private var propHeight: Int? = null
+
+    override fun getDelegate(): ViewManagerDelegate<Pinwheel> = delegate
+
+    override fun getName(): String = NAME
+
+    override fun createViewInstance(context: ThemedReactContext): Pinwheel {
+        val view = Pinwheel(context)
+        (reactContext.getNativeModule(PinwheelEventsModule::class.java) as? PinwheelEventsModule)?.let { module ->
+            view.setPinwheelEventListener(module)
+        }
+        
+        return view
+    }
+
+    @ReactProp(name = "token")
+    override fun setToken(view: Pinwheel, token: String?) {
+        view.setToken(token)
+    }
+
+    @ReactPropGroup(names = ["width", "height"], customType = "Style")
+    fun setStyle(view: Pinwheel, index: Int, value: Int) {
+        if (index == 0) propWidth = value
+        if (index == 1) propHeight = value
+        view.layoutParams = ViewGroup.LayoutParams(
+            if (propWidth != null) propWidth!! else ViewGroup.LayoutParams.WRAP_CONTENT,
+            if (propHeight != null) propHeight!! else ViewGroup.LayoutParams.WRAP_CONTENT
+        )
+    }
+
+    companion object {
+        const val NAME = "RTNPinwheel"
+    }
+}

package/android/src/main/java/com/{underdog_tech/react → rtnpinwheel}/PinwheelPackage.kt

@@ -1,16 +1,14 @@
-package com.underdog_tech.react
+package com.rtnpinwheel
 
 import com.facebook.react.ReactPackage
-import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
 
 class PinwheelPackage : ReactPackage {
-  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-        return listOf(RNTPinwheelEvents(reactContext)).toMutableList()
-    }
-        
-  override fun createViewManagers(
-      reactContext: ReactApplicationContext
-  ) = listOf(PinwheelViewManager(reactContext))
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+    listOf(PinwheelManager(reactContext))
+
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+    listOf(PinwheelEventsModule(reactContext))
 }

package/ios/RTNPinwheelEvents.h

@@ -0,0 +1,13 @@
+#import <RTNPinwheelSpec/RTNPinwheelSpec.h>
+#import <React/RCTEventEmitter.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RTNPinwheelEvents : RCTEventEmitter <NativePinwheelEventsSpec>
+
++ (instancetype)sharedInstance;
+- (void)handlePinwheelEvent:(NSDictionary<NSString *, id> *)payload;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/{RNTPinwheelEvents.m → RTNPinwheelEvents.mm}

@@ -1,6 +1,6 @@
-#import "RNTPinwheelEvents.h"
+#import "RTNPinwheelEvents.h"
 
-@implementation RNTPinwheelEvents
+@implementation RTNPinwheelEvents
 {
   bool hasListeners; // This is an instance variable declaration.
 }
@@ -11,7 +11,7 @@ RCT_EXPORT_MODULE();
 }
 
 + (instancetype)sharedInstance {
-    static RNTPinwheelEvents *sharedInstance = nil;
+    static RTNPinwheelEvents *sharedInstance = nil;
     static dispatch_once_t onceToken;
     dispatch_once(&onceToken, ^{
         sharedInstance = [[super allocWithZone:NULL] init];
@@ -59,4 +59,16 @@ RCT_EXPORT_MODULE();
   return @[@"PINWHEEL_EVENT"]; // Add more event names here.
 }
 
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
+    return std::make_shared<facebook::react::NativePinwheelEventsSpecJSI>(params);
+}
+
+- (void)removeListener { 
+    [self stopObserving];
+}
+
+- (void)setListener { 
+    [self startObserving];
+}
+
 @end

package/ios/RTNPinwheelManager.mm

@@ -0,0 +1,21 @@
+#import <React/RCTLog.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTViewManager.h>
+#import "RTNPinwheelView.h"
+
+@interface RTNPinwheelManager : RCTViewManager
+@end
+
+@implementation RTNPinwheelManager
+
+RCT_EXPORT_MODULE(RTNPinwheelView)
+
+- (UIView *)view
+{   
+    RTNPinwheelView *pv = [[RTNPinwheelView alloc] init];
+    return pv;
+}
+
+RCT_EXPORT_VIEW_PROPERTY(token, NSString);
+
+@end

package/ios/RTNPinwheelView.h

@@ -0,0 +1,17 @@
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+#import <ObjCWrapper/PinwheelVCWrapper.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RTNPinwheelView : RCTViewComponentView <PinwheelVCWrapperDelegate>
+
+@property (nonatomic, strong) PinwheelVCWrapper *pinwheelWrapperVC;
+@property (nonatomic, assign) NSString *token;
+
+- (instancetype)initWithFrame:(CGRect)frame token:(NSString *)token;
+
+@end
+
+NS_ASSUME_NONNULL_END
+

package/ios/RTNPinwheelView.mm

@@ -0,0 +1,102 @@
+#import "RTNPinwheelView.h"
+
+#import <react/renderer/components/RTNPinwheelSpec/ComponentDescriptors.h>
+#import <react/renderer/components/RTNPinwheelSpec/EventEmitters.h>
+#import <react/renderer/components/RTNPinwheelSpec/Props.h>
+#import <react/renderer/components/RTNPinwheelSpec/RCTComponentViewHelpers.h>
+
+#import "RTNPinwheelEvents.h"
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+
+@interface RTNPinwheelView () <RCTRTNPinwheelViewProtocol>
+@end
+
+@implementation RTNPinwheelView
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+    return concreteComponentDescriptorProvider<RTNPinwheelComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+    if ((self = [super initWithFrame:frame])) {
+        [self initPinwheelWrapperVC];
+    }
+    return self;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame token:(NSString *)token {
+    if ((self = [super initWithFrame:frame])) {
+        _token = token;
+    }
+    return self;
+}
+
+- (void)initPinwheelWrapperVC {
+    if (self.token != nil && self.pinwheelWrapperVC == nil) {    
+        self.pinwheelWrapperVC = [[PinwheelVCWrapper alloc] initWithToken:self.token delegate:self sdk:@"react native" version: @"3.0.5"];
+        [self addSubview:self.pinwheelWrapperVC.view];
+    }
+}
+
+- (void)setToken:(NSString *)newToken {
+    if (![_token isEqualToString:newToken]) {
+        _token = newToken;
+        [self initPinwheelWrapperVC];
+    }
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+    const auto &oldViewProps = *std::static_pointer_cast<RTNPinwheelProps const>(_props);
+    const auto &newViewProps = *std::static_pointer_cast<RTNPinwheelProps const>(props);
+
+    if (oldViewProps.token != newViewProps.token) {
+        NSString* convertedToken = [NSString stringWithUTF8String:newViewProps.token.c_str()];
+        [self setToken:convertedToken];
+    }
+
+    [super updateProps:props oldProps:oldProps];
+}
+
+- (void)layoutSubviews
+{
+  [super layoutSubviews];
+  self.pinwheelWrapperVC.view.frame = self.bounds;
+}
+
+- (void)onEventWithName:(NSString *)name event:(NSDictionary<NSString *, id> *)event {
+    NSLog(@"%@", name);
+    NSDictionary *dataToSend = @{@"name": name, @"payload": event};
+    [RTNPinwheelEvents.sharedInstance handlePinwheelEvent:dataToSend];
+}
+
+- (void)onExit:(NSDictionary<NSString *, id> *)error {
+    NSLog(@"%@", error);
+}
+
+- (void)onSuccess:(NSDictionary<NSString *, id> *)result {
+    NSLog(@"%@", result);
+}
+
+- (void)onLogin:(NSDictionary<NSString *, id> *)result {
+    NSLog(@"%@", result);
+}
+
+- (void)onLoginAttempt:(NSDictionary<NSString *, id> *)result {
+    NSLog(@"%@", result);
+}
+
+- (void)onError:(NSDictionary<NSString *, id> *)error {
+    NSLog(@"%@", error);
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RTNPinwheelCls(void)
+{
+  return RTNPinwheelView.class;
+}
+

package/package.json

@@ -1,24 +1,47 @@
 {
   "name": "@pinwheel/react-native-pinwheel",
-  "version": "3.0.5",
+  "version": "3.2.0-rc.0",
   "type": "module",
   "description": "Pinwheel React Native SDK",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "homepage": "https://github.com/underdog-tech/react-native-pinwheel",
+  "react-native": "src/index",
+  "source": "src/index",
+  "files": [
+    "src",
+    "android",
+    "ios",
+    "RNPinwheelSDK.podspec",
+    "PinwheelLinkSDKObjC",
+    "!android/build",
+    "!ios/build",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__"
+  ],
   "scripts": {
-    "build": "tsc",
-    "bump-pkg-version": "./scripts/bump-pkg-version.sh",
-    "dev": "./scripts/dev.sh"
+    "dev": "./scripts/dev_expo.sh"
   },
   "author": "Pinwheel",
   "license": "MIT",
   "peerDependencies": {
-    "react": "^16.13.1 || ^17 || ^18",
-    "react-native": "*",
-    "react-native-webview": "*"
+    "react": "*",
+    "react-native": "*"
   },
   "devDependencies": {
     "@types/react-native": "^0.72.2",
+    "prettier": "^3.3.3",
     "typescript": "^4.0.3"
+  },
+  "codegenConfig": {
+    "name": "RTNPinwheelSpec",
+    "type": "all",
+    "jsSrcsDir": "./src",
+    "outputDir": {
+      "ios": "ios/generated",
+      "android": "android/generated"
+    },
+    "android": {
+      "javaPackageName": "com.rtnpinwheel"
+    }
   }
 }

package/src/NativePinwheelEvents.ts

@@ -0,0 +1,62 @@
+import {
+  TurboModule,
+  TurboModuleRegistry,
+  EmitterSubscription,
+  NativeEventEmitter,
+} from "react-native";
+import type {Int32} from 'react-native/Libraries/Types/CodegenTypes';
+
+export interface Spec extends TurboModule {
+  setListener(): void;
+  removeListener(): void;
+  addListener(eventName: string): void;
+  removeListeners(count: Int32): void;
+}
+
+const PinwheelEventsTurboModule = TurboModuleRegistry.getEnforcing<Spec>("RTNPinwheelEvents");
+export default PinwheelEventsTurboModule;
+
+const EVENT_NAME = 'PINWHEEL_EVENT';
+const eventEmitter = new NativeEventEmitter(PinwheelEventsTurboModule);
+
+let listenerCount = eventEmitter.listenerCount;
+
+// listenerCount is only available from RN 0.64
+// Older versions only have `listeners`
+if (!listenerCount) {
+  listenerCount = (eventType: string) => {
+    // @ts-ignore
+    return eventEmitter.listeners(eventType).length;
+  };
+} else {
+  listenerCount = eventEmitter.listenerCount.bind(eventEmitter);
+}
+
+const addListener = (callback: (event: any) => void): EmitterSubscription => {
+  if (listenerCount(EVENT_NAME) === 0) {
+    PinwheelEventsTurboModule.setListener();
+  }
+
+  let res = eventEmitter.addListener(EVENT_NAME, callback);
+
+  // Path the remove call to also remove the native listener
+  // if we no longer have listeners
+  // @ts-ignore
+  res._remove = res.remove;
+  res.remove = function () {
+    // @ts-ignore
+    this._remove();
+    if (listenerCount(EVENT_NAME) === 0) {
+      PinwheelEventsTurboModule.removeListener();
+    }
+  };
+
+  return res;
+};
+
+const removeAllListeners = () => {
+  eventEmitter.removeAllListeners(EVENT_NAME);
+  PinwheelEventsTurboModule.removeListener();
+};
+
+export {addListener, removeAllListeners};