amazon-ivs-react-native-player 1.0.0

package/android/gradlew.bat

@@ -0,0 +1,84 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,11 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.amazonaws.ivs.reactnative.player">
+  <application>
+    <meta-data
+      android:name="com.amazonaws.ivs.player.FRAMEWORK_NAME"
+      android:value="reactnativeplayer" />
+    <meta-data
+      android:name="com.amazonaws.ivs.player.FRAMEWORK_VERSION"
+      android:value="${sdkVersion}" />
+  </application>
+</manifest>

package/android/src/main/java/com/amazonaws/ivs/reactnative/player/AmazonIvsPackage.kt

@@ -0,0 +1,16 @@
+package com.amazonaws.ivs.reactnative.player
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class AmazonIvsPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return emptyList()
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+      return listOf<ViewManager<*, *>>(AmazonIvsViewManager())
+    }
+}

package/android/src/main/java/com/amazonaws/ivs/reactnative/player/AmazonIvsView.kt

@@ -0,0 +1,410 @@
+package com.amazonaws.ivs.reactnative.player
+
+import android.net.Uri
+import android.widget.FrameLayout
+import com.amazonaws.ivs.player.*
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.events.RCTEventEmitter
+import java.util.*
+import java.util.concurrent.TimeUnit
+import kotlin.concurrent.timerTask
+
+class AmazonIvsView(private val context: ThemedReactContext) : FrameLayout(context), LifecycleEventListener {
+  private var playerView: PlayerView? = null
+  private var player: Player? = null
+  private var streamUri: Uri? = null
+  private val playerListener: Player.Listener?
+
+  var playerObserver: Timer? = null
+  private var lastLiveLatency: Long? = null
+  private var lastBitrate: Long? = null
+  private var lastDuration: Long? = null
+  private var finishedLoading: Boolean = false
+
+  enum class Events(private val mName: String) {
+    STATE_CHANGED("onPlayerStateChange"),
+    DURATION_CHANGED("onDurationChange"),
+    ERROR("onError"),
+    QUALITY_CHANGED("onQualityChange"),
+    CUE("onTextCue"),
+    METADATA_CUE("onTextMetadataCue"),
+    LOAD("onLoad"),
+    LOAD_START("onLoadStart"),
+    REBUFFERING("onRebuffering"),
+    SEEK("onSeek"),
+    DATA("onData"),
+    LIVE_LATENCY_CHANGED("onLiveLatencyChange"),
+    VIDEO_STATISTICS("onVideoStatistics"),
+    PROGRESS("onProgress");
+
+    override fun toString(): String {
+      return mName
+    }
+  }
+
+  init {
+    playerView = PlayerView(context)
+    player = playerView?.player
+    playerView?.controlsEnabled = false
+
+    (context as ThemedReactContext).addLifecycleEventListener(this)
+
+    playerListener = object : Player.Listener() {
+      override fun onStateChanged(state: Player.State) {
+        onPlayerStateChange(state)
+      }
+
+      override fun onDurationChanged(duration: Long) {
+        onDurationChange(duration)
+      }
+
+      override fun onRebuffering() {
+        onPlayerRebuffering()
+      }
+
+      override fun onSeekCompleted(position: Long) {
+        onSeek(position)
+      }
+
+      override fun onQualityChanged(quality: Quality) {
+        onQualityChange(quality)
+      }
+
+      override fun onVideoSizeChanged(p0: Int, p1: Int) {
+        post(mLayoutRunnable)
+      }
+
+      override fun onCue(cue: Cue) {
+        if (cue is TextCue) {
+          onTextCue(cue)
+        } else if (cue is TextMetadataCue) {
+          onTextMetadataCue(cue)
+        }
+      }
+
+      override fun onError(e: PlayerException) {
+        onError(e.errorMessage)
+      }
+    }
+
+    player?.addListener(playerListener);
+    addView(playerView)
+
+    playerObserver = Timer("observerInterval", false)
+    playerObserver?.schedule(timerTask {
+      intervalHandler()
+    }, 0, 1000)
+  }
+
+  fun setStreamUrl(streamUrl: String) {
+    player?.let { player ->
+      val reactContext = context as ReactContext
+      val uri = Uri.parse(streamUrl);
+      this.streamUri = uri;
+
+      finishedLoading = false
+      player.load(uri)
+
+      reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, Events.LOAD_START.toString(), Arguments.createMap())
+    }
+  }
+
+  fun setMuted(muted: Boolean) {
+    player?.isMuted = muted
+  }
+
+  fun setVolume(volume: Double) {
+    player?.setVolume(volume.toFloat())
+  }
+
+  fun setLiveLowLatency(liveLowLatency: Boolean) {
+    player?.setLiveLowLatencyEnabled(liveLowLatency)
+  }
+
+  fun setPlaybackRate(playbackRate: Double) {
+    player?.playbackRate = playbackRate.toFloat()
+  }
+
+  fun setLogLevel(logLevel: Double) {
+    when (logLevel.toInt()) {
+      0 -> player?.setLogLevel(Player.LogLevel.DEBUG)
+      1 -> player?.setLogLevel(Player.LogLevel.INFO)
+      2 -> player?.setLogLevel(Player.LogLevel.WARNING)
+      3 -> player?.setLogLevel(Player.LogLevel.ERROR)
+    }
+  }
+
+  private fun findQuality(quality: ReadableMap?): Quality? {
+    val newQuality = player?.qualities?.first { x ->
+        x.name == quality?.getString("name") &&
+        x.codecs == quality.getString("codecs") &&
+        x.bitrate == quality.getInt("bitrate") &&
+        x.framerate == quality.getDouble("framerate").toFloat() &&
+        x.width == quality.getInt("width") &&
+        x.height == quality.getInt("height")
+    }
+
+    return newQuality
+  }
+
+  fun setQuality(quality: ReadableMap?) {
+    if (quality != null) {
+      player?.quality = findQuality(quality)!!
+    }
+  }
+
+  fun setAutoMaxQuality(quality: ReadableMap?) {
+    if (quality != null) {
+      player?.setAutoMaxQuality(findQuality(quality)!!)
+    }
+  }
+
+  fun setAutoQualityMode(autoQualityMode: Boolean) {
+    player?.isAutoQualityMode = autoQualityMode
+  }
+
+  fun onTextCue(cue: TextCue) {
+    val reactContext = context as ReactContext
+
+    val textCue = Arguments.createMap()
+    textCue.putString("type", cue.javaClass.name)
+    textCue.putDouble("line", cue.line.toDouble())
+    textCue.putDouble("size", cue.size.toDouble())
+    textCue.putDouble("position", cue.position.toDouble())
+    textCue.putString("text", cue.text)
+    textCue.putInt("textAlignment", cue.textAlign.ordinal)
+
+    val data = Arguments.createMap()
+    data.putMap("textCue", textCue)
+
+    reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, Events.CUE.toString(), data)
+  }
+
+  fun setMaxBitrate(bitrate: Double) {
+    player?.setAutoMaxBitrate(bitrate.toInt())
+  }
+
+  fun setInitialBufferDuration(duration: Double) {
+    val valueInMilliseconds = duration * 1000
+    player?.setInitialBufferDuration(valueInMilliseconds.toLong())
+  }
+
+  fun onTextMetadataCue(cue: TextMetadataCue) {
+    val reactContext = context as ReactContext
+
+    val textMetadataCue = Arguments.createMap()
+    textMetadataCue.putString("type", cue.javaClass.name)
+    textMetadataCue.putString("text", cue.text)
+    textMetadataCue.putString("description", cue.description)
+
+    val data = Arguments.createMap()
+    data.putMap("textMetadataCue", textMetadataCue)
+
+    reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, Events.METADATA_CUE.toString(), data)
+  }
+
+  fun onDurationChange(duration: Long) {
+    val reactContext = context as ReactContext
+    val data = Arguments.createMap()
+    val parsedDuration = getDuration(duration);
+    data.putDouble("duration", parsedDuration)
+
+    reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, Events.DURATION_CHANGED.toString(), data)
+  }
+
+  fun onError(error: String) {
+    val reactContext = context as ReactContext
+    val data = Arguments.createMap()
+    data.putString("error", error)
+
+    reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, Events.ERROR.toString(), data)
+  }
+
+  fun onSeek(position: Long) {
+    val reactContext = context as ReactContext
+    val data = Arguments.createMap()
+    data.putInt("position", TimeUnit.MILLISECONDS.toSeconds(position).toInt())
+
+    reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, Events.SEEK.toString(), data)
+  }
+
+  fun onProgress(position: Long) {
+    val reactContext = context as ReactContext
+    val data = Arguments.createMap()
+    data.putInt("position", TimeUnit.MILLISECONDS.toSeconds(position).toInt())
+
+    reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, Events.PROGRESS.toString(), data)
+  }
+
+  private val mLayoutRunnable = Runnable {
+    measure(
+      MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+      MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY))
+    layout(left, top, right, bottom)
+  }
+
+  fun play() {
+    player?.play()
+  }
+
+  fun pause() {
+    player?.pause()
+  }
+
+  fun seekTo(position: Long) {
+    player?.seekTo(TimeUnit.SECONDS.toMillis(position))
+  }
+
+  fun onPlayerStateChange(state: Player.State) {
+    val reactContext = context as ReactContext
+
+    when (state) {
+      Player.State.PLAYING -> {
+        if (!finishedLoading) {
+          val onLoadData = Arguments.createMap()
+          val parsedDuration = getDuration(player!!.duration);
+          onLoadData.putDouble("duration", parsedDuration)
+
+          finishedLoading = true
+
+          reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, Events.LOAD.toString(), onLoadData)
+        }
+      }
+      Player.State.READY -> {
+        val data = Arguments.createMap()
+        val playerData = Arguments.createMap()
+        playerData.putString("version", player?.version)
+        playerData.putString("sessionId", player?.sessionId)
+
+        val qualities = Arguments.createArray()
+        for (quality in player!!.qualities) {
+          val parsedQuality = Arguments.createMap()
+          parsedQuality.putString("name", quality.name)
+          parsedQuality.putString("codecs", quality.codecs)
+          parsedQuality.putInt("bitrate", quality.bitrate)
+          parsedQuality.putDouble("framerate", quality.framerate.toDouble())
+          parsedQuality.putInt("width", quality.width)
+          parsedQuality.putInt("height", quality.height)
+          qualities.pushMap(parsedQuality)
+        }
+        playerData.putArray("qualities", qualities)
+        data.putMap("playerData", playerData)
+
+        reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, Events.DATA.toString(), data)
+      };
+    }
+
+    val onStateChangeData = Arguments.createMap()
+    onStateChangeData.putString("state", mapPlayerState(state))
+    reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, Events.STATE_CHANGED.toString(), onStateChangeData)
+  }
+
+  fun onQualityChange(quality: Quality) {
+    val reactContext = context as ReactContext
+
+    val newQuality = Arguments.createMap()
+    newQuality.putString("name", quality.name)
+    newQuality.putString("codecs", quality.codecs)
+    newQuality.putInt("bitrate", quality.bitrate)
+    newQuality.putDouble("framerate", quality.framerate.toDouble())
+    newQuality.putInt("width", quality.width)
+    newQuality.putInt("height", quality.height)
+
+    val data = Arguments.createMap()
+    data.putMap("quality", newQuality)
+
+    reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, Events.QUALITY_CHANGED.toString(), data)
+  }
+
+  fun onPlayerRebuffering() {
+    val reactContext = context as ReactContext
+    reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, Events.REBUFFERING.toString(), Arguments.createMap())
+  }
+
+  private fun intervalHandler() {
+    val reactContext = context as ReactContext
+
+    if (lastLiveLatency != player?.liveLatency) {
+      val liveLatencyData = Arguments.createMap()
+
+      player?.liveLatency?.let { liveLatency ->
+        liveLatencyData.putInt("liveLatency", liveLatency.toInt())
+      } ?: run {
+        liveLatencyData.putNull("liveLatency")
+      }
+      reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, Events.LIVE_LATENCY_CHANGED.toString(), liveLatencyData)
+
+      lastLiveLatency = player?.liveLatency
+    }
+
+
+    if (lastBitrate != player?.averageBitrate || lastDuration != player?.duration) {
+      val onVideoData = Arguments.createMap()
+      val videoData = Arguments.createMap()
+
+      player?.duration?.let { duration ->
+        val parsedDuration = getDuration(duration)
+        videoData.putDouble("duration", parsedDuration)
+      } ?: run {
+        videoData.putNull("duration")
+      }
+
+      player?.averageBitrate?.let { averageBitrate ->
+        videoData.putInt("bitrate", averageBitrate.toInt())
+      } ?: run {
+        videoData.putNull("bitrate")
+      }
+
+      onVideoData.putMap("videoData", videoData)
+      reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, Events.VIDEO_STATISTICS.toString(), onVideoData)
+
+      lastBitrate = player?.averageBitrate
+      lastDuration = player?.duration
+    }
+    player?.position?.let { position ->
+      if (position > 0 && player?.state === Player.State.PLAYING) {
+        onProgress(position)
+      }
+    }
+  }
+
+  private fun getDuration(duration: Long): Double {
+    val durationInSeconds = TimeUnit.MILLISECONDS.toSeconds(duration).toInt()
+    return durationInSeconds.toDouble()
+  }
+
+  private fun mapPlayerState(state: Player.State): String {
+    return when(state) {
+      Player.State.PLAYING -> "Playing"
+      Player.State.BUFFERING -> "Buffering"
+      Player.State.READY -> "Ready"
+      Player.State.IDLE -> "Idle"
+      Player.State.ENDED -> "Ended"
+    }
+  }
+
+  override fun onHostResume() {
+    play()
+  }
+
+  override fun onHostPause() {
+    pause()
+  }
+
+  override fun onHostDestroy() {
+    cleanup()
+  }
+
+  fun cleanup() {
+    player?.removeListener(playerListener!!)
+    player?.release()
+    player = null
+
+    playerObserver?.cancel()
+    playerObserver = null
+  }
+}

package/android/src/main/java/com/amazonaws/ivs/reactnative/player/AmazonIvsViewManager.kt

@@ -0,0 +1,115 @@
+package com.amazonaws.ivs.reactnative.player
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+
+class AmazonIvsViewManager : SimpleViewManager<AmazonIvsView>() {
+  private enum class Commands {
+    PLAY,
+    PAUSE,
+    SEEK_TO
+  }
+
+  override fun getName() = "AmazonIvs"
+
+  override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Map<String, String>>? {
+    val builder: MapBuilder.Builder<String, Map<String, String>> = MapBuilder.builder<String, Map<String, String>>()
+    for (event in AmazonIvsView.Events.values()) {
+      builder.put(event.toString(), MapBuilder.of("registrationName", event.toString()))
+    }
+    return builder.build()
+  }
+
+  override fun getCommandsMap(): Map<String, Int>? {
+    return MapBuilder.of(
+      "play",
+      Commands.PLAY.ordinal,
+      "pause",
+      Commands.PAUSE.ordinal,
+      "seekTo",
+      Commands.SEEK_TO.ordinal
+    )
+  }
+
+  override fun receiveCommand(view: AmazonIvsView, commandType: Int, args: ReadableArray?) {
+    when (commandType) {
+      Commands.PLAY.ordinal -> view.play()
+      Commands.PAUSE.ordinal -> view.pause()
+      Commands.SEEK_TO.ordinal -> {
+        args?.getInt(0)?.let { position ->
+          view.seekTo(position.toLong())
+        }
+      }
+      else -> {
+      }
+    }
+  }
+
+  @ReactProp(name = "streamUrl")
+  fun setStreamUrl(view: AmazonIvsView, streamUrl: String) {
+    view.setStreamUrl(streamUrl);
+  }
+
+  @ReactProp(name = "muted")
+  fun setMuted(view: AmazonIvsView, muted: Boolean) {
+    view.setMuted(muted)
+  }
+
+  @ReactProp(name = "volume")
+  fun setVolume(view: AmazonIvsView, volume: Double) {
+    view.setVolume(volume)
+  }
+
+  @ReactProp(name = "liveLowLatency")
+  fun setLiveLowLatency(view: AmazonIvsView, liveLowLatency: Boolean) {
+    view.setLiveLowLatency(liveLowLatency)
+  }
+
+  @ReactProp(name = "playbackRate")
+  fun setPlaybackRate(view: AmazonIvsView, playbackRate: Double) {
+    view.setPlaybackRate(playbackRate)
+  }
+
+  @ReactProp(name = "logLevel")
+  fun setLogLevel(view: AmazonIvsView, logLevel: Double) {
+    view.setLogLevel(logLevel)
+  }
+
+  @ReactProp(name = "quality")
+  fun setQuality(view: AmazonIvsView, quality: ReadableMap?) {
+    view.setQuality(quality)
+  }
+
+  @ReactProp(name = "autoMaxQuality")
+  fun setAutoMaxQuality(view: AmazonIvsView, quality: ReadableMap?) {
+    view.setAutoMaxQuality(quality)
+  }
+
+  @ReactProp(name = "autoQualityMode")
+  fun setAutoQualityMode(view: AmazonIvsView, autoQualityMode: Boolean) {
+    view.setAutoQualityMode(autoQualityMode)
+  }
+
+  @ReactProp(name = "maxBitrate")
+  fun setMaxBitrate(view: AmazonIvsView, bitrate: Double) {
+    view.setMaxBitrate(bitrate)
+  }
+
+  @ReactProp(name = "initialBufferDuration")
+  fun setInitialBufferDuration(view: AmazonIvsView, duration: Double) {
+    view.setInitialBufferDuration(duration)
+  }
+
+  override fun createViewInstance(reactContext: ThemedReactContext): AmazonIvsView {
+    return AmazonIvsView(reactContext)
+  }
+
+  override fun onDropViewInstance(view: AmazonIvsView) {
+    super.onDropViewInstance(view)
+    view.cleanup()
+  }
+}

package/ios/AmazonIvs-Bridging-Header.h

@@ -0,0 +1,3 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+#import "React/RCTUIManager.h"