react-native-theoplayer 1.7.2 → 1.8.0

package/android/src/main/java/com/theoplayer/track/TrackListAdapter.kt

@@ -0,0 +1,219 @@
+package com.theoplayer.track
+
+import com.facebook.react.bridge.Arguments
+import com.theoplayer.android.api.player.track.texttrack.TextTrackList
+import com.facebook.react.bridge.WritableArray
+import com.theoplayer.android.api.player.track.texttrack.TextTrack
+import com.facebook.react.bridge.WritableMap
+import com.theoplayer.android.api.player.track.mediatrack.MediaTrack
+import com.theoplayer.android.api.player.track.texttrack.cue.TextTrackCue
+import com.theoplayer.android.api.player.track.mediatrack.quality.Quality
+import com.theoplayer.android.api.player.track.mediatrack.quality.AudioQuality
+import com.theoplayer.android.api.player.track.mediatrack.quality.VideoQuality
+import com.theoplayer.android.api.player.track.mediatrack.MediaTrackList
+
+private const val PROP_ID = "id"
+private const val PROP_UID = "uid"
+private const val PROP_KIND = "kind"
+private const val PROP_LANGUAGE = "language"
+private const val PROP_MODE = "mode"
+private const val PROP_LABEL = "label"
+private const val PROP_TYPE = "type"
+private const val PROP_CODECS = "codecs"
+private const val PROP_NAME = "name"
+private const val PROP_SRC = "src"
+private const val PROP_FORCED = "forced"
+private const val PROP_AUDIO_SAMPLING_RATE = "audioSamplingRate"
+private const val PROP_BANDWIDTH = "bandwidth"
+private const val PROP_QUALITIES = "qualities"
+private const val PROP_ACTIVE_QUALITY = "activeQuality"
+private const val PROP_TARGET_QUALITY = "targetQuality"
+private const val PROP_WIDTH = "width"
+private const val PROP_HEIGHT = "height"
+private const val PROP_FRAMERATE = "framerate"
+private const val PROP_STARTTIME = "startTime"
+private const val PROP_ENDTIME = "endTime"
+private const val PROP_CUES = "cues"
+private const val PROP_CUE_CONTENT = "content"
+
+class TrackListAdapter {
+
+  fun fromTextTrackList(textTrackList: TextTrackList): WritableArray {
+    val textTracks = Arguments.createArray()
+    for (i in 0 until textTrackList.length()) {
+      textTracks.pushMap(fromTextTrack(textTrackList.getItem(i)))
+    }
+    return textTracks
+  }
+
+  fun fromTextTrack(textTrack: TextTrack): WritableMap {
+    val textTrackPayload = Arguments.createMap()
+    textTrackPayload.putString(PROP_ID, textTrack.id)
+    textTrackPayload.putInt(PROP_UID, textTrack.uid)
+    textTrackPayload.putString(PROP_KIND, textTrack.kind)
+    textTrackPayload.putString(PROP_LANGUAGE, textTrack.language)
+    textTrackPayload.putString(PROP_MODE, textTrack.mode.mode)
+    textTrackPayload.putString(PROP_LABEL, textTrack.label)
+    textTrackPayload.putString(PROP_TYPE, textTrack.type.type)
+
+    // THEOplayer v3.5+
+    textTrackPayload.putString(PROP_SRC, textTrack.source)
+    textTrackPayload.putBoolean(PROP_FORCED, textTrack.isForced)
+
+    // Optionally pass cue list.
+    val cueList = textTrack.cues
+    if (cueList != null) {
+      val cueListPayload = Arguments.createArray()
+      for (cue in cueList) {
+        cueListPayload.pushMap(fromTextTrackCue(cue))
+      }
+      textTrackPayload.putArray(PROP_CUES, cueListPayload)
+    }
+    return textTrackPayload
+  }
+
+  fun fromTextTrackCue(cue: TextTrackCue): WritableMap {
+    val cuePayload = Arguments.createMap()
+    cuePayload.putString(PROP_ID, cue.id)
+    cuePayload.putDouble(PROP_UID, cue.uid.toDouble())
+    cuePayload.putDouble(PROP_STARTTIME, (1e03 * cue.startTime).toLong().toDouble())
+    cuePayload.putDouble(PROP_ENDTIME, (1e03 * cue.endTime).toLong().toDouble())
+    val content = cue.content
+    if (content != null) {
+      cuePayload.putString(PROP_CUE_CONTENT, content.optString("content"))
+    }
+    return cuePayload
+  }
+
+  fun fromQuality(quality: Quality): WritableMap {
+    return if (quality is AudioQuality) fromAudioQuality(quality) else fromVideoQuality(quality as VideoQuality)
+  }
+
+  private fun fromAudioQuality(quality: AudioQuality): WritableMap {
+    val audioQualityPayload = Arguments.createMap()
+    audioQualityPayload.putString(PROP_ID, quality.id)
+    audioQualityPayload.putInt(PROP_UID, quality.uid)
+    audioQualityPayload.putString(PROP_CODECS, quality.codecs)
+    audioQualityPayload.putString(PROP_NAME, quality.name)
+    audioQualityPayload.putDouble(PROP_BANDWIDTH, quality.bandwidth.toDouble())
+    audioQualityPayload.putDouble(
+      PROP_AUDIO_SAMPLING_RATE,
+      quality.audioSamplingRate.toDouble()
+    )
+    return audioQualityPayload
+  }
+
+  fun <Q : Quality?> fromMediaTrack(
+    track: MediaTrack<Q>,
+    trackType: MediaTrackType
+  ): WritableMap {
+    return if (trackType === MediaTrackType.AUDIO) fromAudioTrack(track as MediaTrack<AudioQuality>)
+    else fromVideoTrack(track as MediaTrack<VideoQuality>)
+  }
+
+  private fun fromAudioTrack(audioTrack: MediaTrack<AudioQuality>): WritableMap {
+    val audioTrackPayload = Arguments.createMap()
+    audioTrackPayload.putString(PROP_ID, audioTrack.id)
+    audioTrackPayload.putInt(PROP_UID, audioTrack.uid)
+    audioTrackPayload.putString(PROP_KIND, audioTrack.kind)
+    audioTrackPayload.putString(PROP_LABEL, audioTrack.label)
+    audioTrackPayload.putString(PROP_LANGUAGE, audioTrack.language)
+    val qualityList = audioTrack.qualities
+    val qualities = Arguments.createArray()
+    if (qualityList != null) {
+      for (j in 0 until qualityList.length()) {
+        qualities.pushMap(fromAudioQuality(qualityList.getItem(j)))
+      }
+    }
+    audioTrackPayload.putArray(PROP_QUALITIES, qualities)
+    val targetQualityList = audioTrack.targetQualities
+    val targetQualities = Arguments.createArray()
+    if (targetQualityList != null) {
+      for (j in 0 until targetQualityList.length()) {
+        val quality = targetQualityList.getItem(j)
+        val audioQualityPayload = Arguments.createMap()
+        audioQualityPayload.putInt(PROP_UID, quality.uid)
+        targetQualities.pushMap(audioQualityPayload)
+      }
+    }
+    val activeQuality = audioTrack.activeQuality
+    if (activeQuality != null) {
+      audioTrackPayload.putInt(PROP_ACTIVE_QUALITY, activeQuality.uid)
+    }
+    val targetQuality = audioTrack.targetQuality
+    if (targetQuality != null) {
+      audioTrackPayload.putInt(PROP_TARGET_QUALITY, targetQuality.uid)
+    }
+    return audioTrackPayload
+  }
+
+  fun fromAudioTrackList(audioTrackList: MediaTrackList<AudioQuality>): WritableArray {
+    val audioTracks = Arguments.createArray()
+    for (i in 0 until audioTrackList.length()) {
+      audioTracks.pushMap(fromAudioTrack(audioTrackList.getItem(i)))
+    }
+    return audioTracks
+  }
+
+  private fun fromVideoQuality(quality: VideoQuality): WritableMap {
+    val videoQualityPayload = Arguments.createMap()
+    videoQualityPayload.putString(PROP_ID, quality.id)
+    videoQualityPayload.putInt(PROP_UID, quality.uid)
+    videoQualityPayload.putString(PROP_CODECS, quality.codecs)
+    videoQualityPayload.putString(PROP_NAME, quality.name)
+    videoQualityPayload.putDouble(PROP_BANDWIDTH, quality.bandwidth.toDouble())
+    videoQualityPayload.putDouble(PROP_WIDTH, quality.width.toDouble())
+    videoQualityPayload.putDouble(PROP_HEIGHT, quality.height.toDouble())
+    videoQualityPayload.putDouble(PROP_FRAMERATE, quality.frameRate)
+    return videoQualityPayload
+  }
+
+  private fun fromVideoTrack(videoTrack: MediaTrack<VideoQuality>): WritableMap {
+    val videoTrackPayload = Arguments.createMap()
+    videoTrackPayload.putString(PROP_ID, videoTrack.id)
+    videoTrackPayload.putInt(PROP_UID, videoTrack.uid)
+    videoTrackPayload.putString(PROP_KIND, videoTrack.kind)
+    videoTrackPayload.putString(PROP_LABEL, videoTrack.label)
+    videoTrackPayload.putString(PROP_LANGUAGE, videoTrack.language)
+    val qualityList = videoTrack.qualities
+    val qualities = Arguments.createArray()
+    if (qualityList != null) {
+      // Sort qualities according to (height, bandwidth)
+      val sortedQualityList = QualityListAdapter(qualityList)
+      sortedQualityList.sort { o: VideoQuality, t1: VideoQuality ->
+        if (o.height == t1.height) t1.bandwidth.compareTo(o.bandwidth) else t1.height.compareTo(o.height)
+      }
+      for (quality in sortedQualityList) {
+        qualities.pushMap(fromVideoQuality(quality as VideoQuality))
+      }
+    }
+    videoTrackPayload.putArray(PROP_QUALITIES, qualities)
+    val targetQualityList = videoTrack.targetQualities
+    val targetQualities = Arguments.createArray()
+    if (targetQualityList != null) {
+      for (j in 0 until targetQualityList.length()) {
+        val quality = targetQualityList.getItem(j)
+        val videoQualityPayload = Arguments.createMap()
+        videoQualityPayload.putInt(PROP_UID, quality.uid)
+        targetQualities.pushMap(videoQualityPayload)
+      }
+    }
+    val activeQuality = videoTrack.activeQuality
+    if (activeQuality != null) {
+      videoTrackPayload.putInt(PROP_ACTIVE_QUALITY, activeQuality.uid)
+    }
+    val targetQuality = videoTrack.targetQuality
+    if (targetQuality != null) {
+      videoTrackPayload.putInt(PROP_TARGET_QUALITY, targetQuality.uid)
+    }
+    return videoTrackPayload
+  }
+
+  fun fromVideoTrackList(videoTrackList: MediaTrackList<VideoQuality>): WritableArray {
+    val videoTracks = Arguments.createArray()
+    for (i in 0 until videoTrackList.length()) {
+      videoTracks.pushMap(fromVideoTrack(videoTrackList.getItem(i)))
+    }
+    return videoTracks
+  }
+}

package/android/src/main/java/com/theoplayer/util/ViewResolver.kt

@@ -0,0 +1,19 @@
+package com.theoplayer.util
+
+import android.os.Handler
+import android.os.Looper
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.UIManagerModule
+import com.theoplayer.ReactTHEOplayerView
+
+class ViewResolver(private val reactContext: ReactApplicationContext) {
+  private var uiManager: UIManagerModule? = null
+  private val handler = Handler(Looper.getMainLooper())
+
+  fun resolveViewByTag(tag: Int, onResolved: (view: ReactTHEOplayerView?) -> Unit) {
+    if (uiManager == null) {
+      uiManager = reactContext.getNativeModule(UIManagerModule::class.java)
+    }
+    handler.post { onResolved(uiManager?.resolveView(tag) as ReactTHEOplayerView) }
+  }
+}

package/ios/THEOplayerRCTAdAggregator.swift

@@ -23,9 +23,9 @@ let PROP_GOOGLE_AD_HEIGHT: String = "height"
 let PROP_GOOGLE_AD_CONTENT_TYPE: String = "contentType"
 let PROP_GOOGLE_AD_ID_REGISTRY: String = "adIdRegistry"
 let PROP_GOOGLE_AD_ID_VALUE: String = "adIdValue"
-let PROP_GOOLGE_AD_WRAPPER_AD_IDS: String = "wrapperAdIds"
-let PROP_GOOLGE_AD_WRAPPER_AD_SYSTEMS: String = "wrapperAdSystems"
-let PROP_GOOLGE_AD_WRAPPER_CREATIVE_IDS: String = "wrapperCreativeIds"
+let PROP_GOOGLE_AD_WRAPPER_AD_IDS: String = "wrapperAdIds"
+let PROP_GOOGLE_AD_WRAPPER_AD_SYSTEMS: String = "wrapperAdSystems"
+let PROP_GOOGLE_AD_WRAPPER_CREATIVE_IDS: String = "wrapperCreativeIds"
 let PROP_ADBREAK_MAX_DURATION: String = "maxDuration"
 let PROP_ADBREAK_TIME_OFFSET: String = "timeOffset"
 let PROP_ADBREAK_MAX_REMAINING_DURATION: String = "maxRemainingDuration"
@@ -58,7 +58,11 @@ class THEOplayerRCTAdAggregator {
            let adBreak = ad.adBreak {
             adData[PROP_AD_BREAK] = THEOplayerRCTAdAggregator.aggregateAdBreak(adBreak: adBreak)
         }
+        
+#if os(iOS)
         adData[PROP_AD_COMPANIONS] = THEOplayerRCTAdAggregator.aggregateCompanionAds(companionAds: ad.companions)
+#endif
+        
         adData[PROP_AD_UNIVERSAL_AD_IDS] = []
         
         // Add additional properties for Linear Ads
@@ -69,11 +73,13 @@ class THEOplayerRCTAdAggregator {
         }
         
         // Add additional properties for NonLinear Ads
+#if os(iOS)
         if let nonLinearAd = ad as? NonLinearAd {
             if let adClickThrough = nonLinearAd.clickThrough {
                 adData[PROP_AD_CLICK_THROUGH] = adClickThrough
             }
         }
+#endif
 
         // Add additional properties for GoogleIma Ads
         if let googleImaAd = ad as? GoogleImaAd {
@@ -105,9 +111,9 @@ class THEOplayerRCTAdAggregator {
                 }
                 adData[PROP_AD_UNIVERSAL_AD_IDS] = adIdList
             }
-            adData[PROP_GOOLGE_AD_WRAPPER_AD_IDS] = googleImaAd.wrapperAdIds
-            adData[PROP_GOOLGE_AD_WRAPPER_AD_SYSTEMS] = googleImaAd.wrapperAdSystems
-            adData[PROP_GOOLGE_AD_WRAPPER_CREATIVE_IDS] = googleImaAd.wrapperCreativeIds
+            adData[PROP_GOOGLE_AD_WRAPPER_AD_IDS] = googleImaAd.wrapperAdIds
+            adData[PROP_GOOGLE_AD_WRAPPER_AD_SYSTEMS] = googleImaAd.wrapperAdSystems
+            adData[PROP_GOOGLE_AD_WRAPPER_CREATIVE_IDS] = googleImaAd.wrapperCreativeIds
         }
         
         return adData

package/ios/THEOplayerRCTAdsAPI.swift

@@ -165,7 +165,46 @@ class THEOplayerRCTAdsAPI: NSObject, RCTBridgeModule {
             }
         }
     }
+#else
+    @objc(skip:)
+    func skip(_ node: NSNumber) -> Void {
+        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
+        return
+    }
+    
+    @objc(playing:resolver:rejecter:)
+    func playing(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
+        resolve(false)
+    }
+    
+    @objc(currentAdBreak:resolver:rejecter:)
+    func currentAdBreak(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
+        resolve([:])
+    }
     
+    @objc(currentAds:resolver:rejecter:)
+    func currentAds(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
+        resolve([])
+    }
+    
+    @objc(scheduledAdBreaks:resolver:rejecter:)
+    func scheduledAdBreaks(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
+        resolve([])
+        // TODO: handle request for scheduled adbreaks. Awaiting iOS SDK implementation
+    }
+    
+    @objc(schedule:ad:)
+    func schedule(_ node: NSNumber, adDict: NSDictionary) -> Void {
+        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
+        return
+    }
+#endif
+    
+#if os(iOS) && ADS && GOOGLE_DAI
     @objc(daiSnapback:resolver:rejecter:)
     func daiSnapback(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
         DispatchQueue.main.async {
@@ -234,46 +273,7 @@ class THEOplayerRCTAdsAPI: NSObject, RCTBridgeModule {
             }
         }
     }
-    
 #else
-    
-    @objc(skip:)
-    func skip(_ node: NSNumber) -> Void {
-        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
-        return
-    }
-    
-    @objc(playing:resolver:rejecter:)
-    func playing(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
-        resolve(false)
-    }
-    
-    @objc(currentAdBreak:resolver:rejecter:)
-    func currentAdBreak(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
-        resolve([:])
-    }
-    
-    @objc(currentAds:resolver:rejecter:)
-    func currentAds(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
-        resolve([])
-    }
-    
-    @objc(scheduledAdBreaks:resolver:rejecter:)
-    func scheduledAdBreaks(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
-        resolve([])
-        // TODO: handle request for scheduled adbreaks. Awaiting iOS SDK implementation
-    }
-    
-    @objc(schedule:ad:)
-    func schedule(_ node: NSNumber, adDict: NSDictionary) -> Void {
-        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
-        return
-    }
-    
     @objc(daiSnapback:resolver:rejecter:)
     func daiSnapback(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
         if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
@@ -291,6 +291,5 @@ class THEOplayerRCTAdsAPI: NSObject, RCTBridgeModule {
         if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
         resolve(timeValue.doubleValue)
     }
-    
 #endif
 }

package/ios/THEOplayerRCTBridge.m

@@ -10,7 +10,9 @@
 #import <React/RCTBridgeModule.h>
 #import <React/RCTEventEmitter.h>
 
+// ----------------------------------------------------------------------------
 // View Manager
+// ----------------------------------------------------------------------------
 @interface RCT_EXTERN_MODULE(THEOplayerRCTViewManager, RCTViewManager)
 
 RCT_EXPORT_VIEW_PROPERTY(src, NSDictionary);
@@ -51,11 +53,16 @@ RCT_EXPORT_VIEW_PROPERTY(onNativeMediaTrackEvent, RCTDirectEventBlock);
 
 RCT_EXPORT_VIEW_PROPERTY(onNativeAdEvent, RCTDirectEventBlock);
 
+RCT_EXPORT_VIEW_PROPERTY(onNativeCastEvent, RCTDirectEventBlock);
+
 RCT_EXTERN_METHOD(destroy:(nonnull NSNumber *)node);
 
 @end
 
+// ----------------------------------------------------------------------------
 // Ads Module
+// ----------------------------------------------------------------------------
+
 @interface RCT_EXTERN_REMAP_MODULE(AdsModule, THEOplayerRCTAdsAPI, NSObject)
 
 RCT_EXTERN_METHOD(skip:(nonnull NSNumber *)node)
@@ -98,7 +105,9 @@ RCT_EXTERN_METHOD(daiStreamTimeForContentTime:(nonnull NSNumber *)node
 
 @end
 
-// ContentProtectionModule
+// ----------------------------------------------------------------------------
+// ContentProtection Module
+// ----------------------------------------------------------------------------
 @interface RCT_EXTERN_REMAP_MODULE(ContentProtectionModule, THEOplayerRCTContentProtectionAPI, RCTEventEmitter)
 
 RCT_EXTERN_METHOD(onBuildProcessed:(NSDictionary)result)
@@ -113,3 +122,45 @@ RCT_EXTERN_METHOD(registerContentProtectionIntegration:(nonnull NSString *)integ
                   keySystemId:(nonnull NSString *)keySystemId)
 
 @end
+
+// ----------------------------------------------------------------------------
+// Cast Module
+// ----------------------------------------------------------------------------
+
+@interface RCT_EXTERN_REMAP_MODULE(CastModule, THEOplayerRCTCastAPI, NSObject)
+
+RCT_EXTERN_METHOD(casting:(nonnull NSNumber *)node
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+// chromecast specific
+RCT_EXTERN_METHOD(chromecastCasting:(nonnull NSNumber *)node
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(chromecastState:(nonnull NSNumber *)node
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(chromecastStart:(nonnull NSNumber *)node)
+
+RCT_EXTERN_METHOD(chromecastStop:(nonnull NSNumber *)node)
+
+RCT_EXTERN_METHOD(chromecastJoin:(nonnull NSNumber *)node)
+
+RCT_EXTERN_METHOD(chromecastLeave:(nonnull NSNumber *)node)
+
+// airplay specific
+RCT_EXTERN_METHOD(airplayCasting:(nonnull NSNumber *)node
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(airplayState:(nonnull NSNumber *)node
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(airplayStart:(nonnull NSNumber *)node)
+
+RCT_EXTERN_METHOD(airplayStop:(nonnull NSNumber *)node)
+
+@end