react-native-theoplayer 1.6.1 → 1.7.0

package/android/src/main/java/com/theoplayer/SourceHelper.java

@@ -1,7 +1,6 @@
 package com.theoplayer;
 
 import android.text.TextUtils;
-import android.util.Log;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -9,7 +8,11 @@ import androidx.annotation.Nullable;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.google.gson.Gson;
+import com.theoplayer.android.api.error.ErrorCode;
+import com.theoplayer.android.api.error.THEOplayerException;
+import com.theoplayer.android.api.event.ads.AdIntegrationKind;
 import com.theoplayer.android.api.player.track.texttrack.TextTrackKind;
+import com.theoplayer.android.api.source.GoogleDaiTypedSource;
 import com.theoplayer.android.api.source.SourceDescription;
 import com.theoplayer.android.api.source.SourceType;
 import com.theoplayer.android.api.source.TextTrackDescription;
@@ -17,17 +20,12 @@ import com.theoplayer.android.api.source.TypedSource;
 import com.theoplayer.android.api.source.addescription.AdDescription;
 import com.theoplayer.android.api.source.addescription.GoogleImaAdDescription;
 import com.theoplayer.android.api.source.drm.DRMConfiguration;
-import com.theoplayer.android.api.source.drm.DRMIntegrationId;
-import com.theoplayer.android.api.source.drm.preintegration.AxinomDRMConfiguration;
-import com.theoplayer.android.api.source.drm.preintegration.AzureDRMConfiguration;
-import com.theoplayer.android.api.source.drm.preintegration.ConaxDRMConfiguration;
-import com.theoplayer.android.api.source.drm.preintegration.DRMTodayConfiguration;
-import com.theoplayer.android.api.source.drm.preintegration.IrdetoConfiguration;
-import com.theoplayer.android.api.source.drm.preintegration.KeyOSDRMConfiguration;
-import com.theoplayer.android.api.source.drm.preintegration.TitaniumDRMConfiguration;
-import com.theoplayer.android.api.source.drm.preintegration.VudrmDRMConfiguration;
-import com.theoplayer.android.api.source.drm.preintegration.XstreamConfiguration;
 import com.theoplayer.android.api.source.hls.HlsPlaybackConfiguration;
+import com.theoplayer.android.api.source.ssai.SsaiIntegration;
+import com.theoplayer.android.api.source.ssai.YoSpaceDescription;
+import com.theoplayer.android.api.source.ssai.dai.GoogleDaiLiveConfiguration;
+import com.theoplayer.android.api.source.ssai.dai.GoogleDaiVodConfiguration;
+import com.theoplayer.drm.ContentProtectionAdapter;
 
 import org.json.JSONArray;
 import org.json.JSONException;
@@ -42,18 +40,35 @@ import java.util.Map;
  */
 public class SourceHelper {
 
-  private static final String TAG = "SourceHelper";
-
   private static final String PROP_CONTENT_PROTECTION = "contentProtection";
-  private static final String PROP_CONTENT_PROTECTION_INTEGRATION = "integration";
   private static final String PROP_LIVE_OFFSET = "liveOffset";
   private static final String PROP_HLS_DATERANGE = "hlsDateRange";
   private static final String PROP_HLS_PLAYBACK_CONFIG = "hls";
   private static final String PROP_TIME_SERVER = "timeServer";
+  public static final String PROP_SSAI = "ssai";
+  public static final String PROP_TYPE = "type";
+  public static final String PROP_SRC = "src";
+  public static final String PROP_SOURCES = "sources";
+  public static final String PROP_DEFAULT = "default";
+  public static final String PROP_LABEL = "label";
+  public static final String PROP_KIND = "kind";
+  public static final String PROP_TIME_OFFSET = "timeOffset";
+  public static final String PROP_INTEGRATION = "integration";
+  public static final String PROP_TEXT_TRACKS = "textTracks";
+  public static final String PROP_POSTER = "poster";
+  public static final String PROP_ADS = "ads";
+  public static final String PROP_AVAILABILITY_TYPE = "availabilityType";
+
+  private static final String ERROR_DAI_NOT_ENABLED = "Google DAI support not enabled.";
+  private static final String ERROR_UNSUPPORTED_SSAI_INTEGRATION = "Unsupported SSAI integration";
+  private static final String ERROR_MISSING_SSAI_INTEGRATION = "Missing SSAI integration";
+  private static final String ERROR_IMA_NOT_ENABLED = "Google IMA support not enabled.";
+  private static final String ERROR_UNSUPPORTED_CSAI_INTEGRATION = "Unsupported CSAI integration";
+  private static final String ERROR_MISSING_CSAI_INTEGRATION = "Missing CSAI integration";
 
   private final Gson gson = new Gson();
 
-  public SourceDescription parseSourceFromJS(ReadableMap source) {
+  public SourceDescription parseSourceFromJS(ReadableMap source) throws THEOplayerException {
       HashMap<String, Object> hashmap = eliminateReadables(source);
       try {
         String json = gson.toJson(hashmap);
@@ -63,7 +78,7 @@ public class SourceHelper {
         ArrayList<TypedSource> typedSources = new ArrayList<>();
 
         // sources can be an array or single object
-        JSONArray jsonSources = jsonSourceObject.optJSONArray("sources");
+        JSONArray jsonSources = jsonSourceObject.optJSONArray(PROP_SOURCES);
         if (jsonSources != null) {
           for (int i = 0 ; i < jsonSources.length(); i++) {
             TypedSource typedSource = parseTypedSource((JSONObject)jsonSources.get(i));
@@ -72,32 +87,29 @@ public class SourceHelper {
             }
           }
         } else {
-          TypedSource typedSource = parseTypedSource(jsonSourceObject.getJSONObject("sources"));
+          TypedSource typedSource = parseTypedSource(jsonSourceObject.getJSONObject(PROP_SOURCES));
           if (typedSource != null) {
             typedSources.add(typedSource);
           }
         }
 
         // poster
-        String poster = jsonSourceObject.optString("poster");
+        String poster = jsonSourceObject.optString(PROP_POSTER);
 
         // ads
-        JSONArray jsonAds = jsonSourceObject.optJSONArray("ads");
+        JSONArray jsonAds = jsonSourceObject.optJSONArray(PROP_ADS);
         ArrayList<AdDescription> ads = new ArrayList<>();
         if (jsonAds != null) {
           for (int i = 0 ; i < jsonAds.length(); i++) {
             JSONObject jsonAdDescription = (JSONObject) jsonAds.get(i);
 
             // Currently only ima-ads are supported.
-            GoogleImaAdDescription ad = parseImaAdFromJS(jsonAdDescription);
-            if (ad != null) {
-              ads.add(ad);
-            }
+            ads.add(parseAdFromJS(jsonAdDescription));
           }
         }
 
         // Side-loaded text tracks
-        JSONArray textTracks = jsonSourceObject.optJSONArray("textTracks");
+        JSONArray textTracks = jsonSourceObject.optJSONArray(PROP_TEXT_TRACKS);
         ArrayList<TextTrackDescription> sideLoadedTextTracks = new ArrayList<>();
         if (textTracks != null) {
           for (int i = 0 ; i < textTracks.length(); i++) {
@@ -119,11 +131,47 @@ public class SourceHelper {
   }
 
   @Nullable
-  private TypedSource parseTypedSource(@NonNull final JSONObject jsonTypedSource) {
+  private TypedSource parseTypedSource(@NonNull final JSONObject jsonTypedSource) throws THEOplayerException {
     try {
+      TypedSource.Builder tsBuilder = TypedSource.Builder.typedSource();
       SourceType sourceType = parseSourceType(jsonTypedSource);
-      String src = jsonTypedSource.getString("src");
-      TypedSource.Builder tsBuilder = TypedSource.Builder.typedSource().src(src);
+
+      if (jsonTypedSource.has(PROP_SSAI)) {
+        final JSONObject ssaiJson = jsonTypedSource.getJSONObject(PROP_SSAI);
+
+        // Check for valid SsaiIntegration
+        final String ssaiIntegrationStr = ssaiJson.optString(PROP_INTEGRATION);
+        if (!TextUtils.isEmpty(ssaiIntegrationStr)) {
+          SsaiIntegration ssaiIntegration = SsaiIntegration.from(ssaiIntegrationStr);
+          if (ssaiIntegration == null) {
+            throw new THEOplayerException(ErrorCode.AD_ERROR, ERROR_UNSUPPORTED_SSAI_INTEGRATION + ": " + ssaiIntegrationStr);
+          }
+          switch (ssaiIntegration) {
+            case GOOGLE_DAI:
+              if (!BuildConfig.EXTENSION_GOOGLE_DAI) {
+                throw new THEOplayerException(ErrorCode.AD_ERROR, ERROR_DAI_NOT_ENABLED);
+              }
+              if (ssaiJson.optString(PROP_AVAILABILITY_TYPE).equals("vod")) {
+                tsBuilder = new GoogleDaiTypedSource.Builder(gson.fromJson(ssaiJson.toString(), GoogleDaiVodConfiguration.class));
+              } else {
+                tsBuilder = new GoogleDaiTypedSource.Builder(gson.fromJson(ssaiJson.toString(), GoogleDaiLiveConfiguration.class));
+              }
+              // Prefer DASH if not SSAI type specified
+              if (sourceType == null) {
+                tsBuilder.type(SourceType.DASH);
+              }
+              break;
+            case YOSPACE:
+              tsBuilder.ssai(gson.fromJson(ssaiJson.toString(), YoSpaceDescription.class));
+              break;
+            default:
+              throw new THEOplayerException(ErrorCode.AD_ERROR, ERROR_UNSUPPORTED_SSAI_INTEGRATION + ": " + ssaiIntegrationStr);
+          }
+        } else {
+          throw new THEOplayerException(ErrorCode.AD_ERROR, ERROR_MISSING_SSAI_INTEGRATION);
+        }
+      }
+      tsBuilder.src(jsonTypedSource.optString(PROP_SRC));
       if (sourceType != null) {
         tsBuilder.type(sourceType);
       }
@@ -142,54 +190,21 @@ public class SourceHelper {
         tsBuilder.timeServer(jsonTypedSource.getString(PROP_TIME_SERVER));
       }
       if (jsonTypedSource.has(PROP_CONTENT_PROTECTION)) {
-        JSONObject contentProtection = jsonTypedSource.getJSONObject(PROP_CONTENT_PROTECTION);
-
-        // Look for specific DRM pre-integration, otherwise use default.
-        final String integration = contentProtection.optString(PROP_CONTENT_PROTECTION_INTEGRATION);
-        DRMIntegrationId integrationId = null;
-        if (!TextUtils.isEmpty(integration)) {
-          integrationId = DRMIntegrationId.from(integration);
-          if (integrationId == null) {
-            Log.e(TAG, "ContentProtection integration not supported: " + integration);
-          }
-        }
-        if (integrationId != null) {
-          switch (integrationId) {
-            case AXINOM:
-              tsBuilder.drm(gson.fromJson(contentProtection.toString(), AxinomDRMConfiguration.class)); break;
-            case AZURE:
-              tsBuilder.drm(gson.fromJson(contentProtection.toString(), AzureDRMConfiguration.class)); break;
-            case CONAX:
-              tsBuilder.drm(gson.fromJson(contentProtection.toString(), ConaxDRMConfiguration.class)); break;
-            case DRMTODAY:
-              tsBuilder.drm(gson.fromJson(contentProtection.toString(), DRMTodayConfiguration.class)); break;
-            case IRDETO:
-              tsBuilder.drm(gson.fromJson(contentProtection.toString(), IrdetoConfiguration.class)); break;
-            case KEYOS:
-              tsBuilder.drm(gson.fromJson(contentProtection.toString(), KeyOSDRMConfiguration.class)); break;
-            case TITANIUM:
-              tsBuilder.drm(gson.fromJson(contentProtection.toString(), TitaniumDRMConfiguration.class)); break;
-            case VUDRM:
-              tsBuilder.drm(gson.fromJson(contentProtection.toString(), VudrmDRMConfiguration.class)); break;
-            case XSTREAM:
-              tsBuilder.drm(gson.fromJson(contentProtection.toString(), XstreamConfiguration.class)); break;
-            default:
-              Log.e(TAG, "ContentProtection integration not supported: " + integration);
-          }
-        } else {
-          tsBuilder.drm(gson.fromJson(jsonTypedSource.get(PROP_CONTENT_PROTECTION).toString(), DRMConfiguration.class));
+        DRMConfiguration drmConfig =
+          ContentProtectionAdapter.INSTANCE.drmConfigurationFromJson(jsonTypedSource.getJSONObject(PROP_CONTENT_PROTECTION));
+        if (drmConfig != null) {
+          tsBuilder.drm(drmConfig);
         }
       }
       return tsBuilder.build();
-    }
-    catch(JSONException e) {
+    } catch (JSONException e) {
       e.printStackTrace();
     }
     return null;
   }
 
   private static SourceType parseSourceType(@NonNull final JSONObject jsonTypedSource) {
-    String type = jsonTypedSource.optString("type");
+    String type = jsonTypedSource.optString(PROP_TYPE);
     if (!type.isEmpty()) {
       if ("application/dash+xml".equals(type)) {
         return SourceType.DASH;
@@ -211,7 +226,7 @@ public class SourceHelper {
       }
     } else {
       // No type given, check for known extension.
-      String src = jsonTypedSource.optString("src");
+      String src = jsonTypedSource.optString(PROP_SRC);
       if (src.endsWith(".mpd")) {
         return SourceType.DASH;
       }
@@ -229,22 +244,64 @@ public class SourceHelper {
   }
 
   @Nullable
-  private static GoogleImaAdDescription parseImaAdFromJS(JSONObject jsonAdDescription) throws JSONException {
-    if (jsonAdDescription.optString("integration").equals("google-ima")) {
-      return GoogleImaAdDescription.Builder.googleImaAdDescription()
-        .source(jsonAdDescription.optString("sources"))
-        .timeOffset(jsonAdDescription.optString("timeOffset"))
-        .build();
+  public AdDescription parseAdFromJS(ReadableMap map) throws THEOplayerException {
+    HashMap<String, Object> hashmap = eliminateReadables(map);
+    try {
+      JSONObject jsonAdDescription = new JSONObject(gson.toJson(hashmap));
+      return parseAdFromJS(jsonAdDescription);
+    } catch(JSONException e) {
+      e.printStackTrace();
+      return null;
     }
-    return null;
+  }
+
+  @NonNull
+  public static AdDescription parseAdFromJS(JSONObject jsonAdDescription) throws JSONException, THEOplayerException {
+    final String integrationKindStr = jsonAdDescription.optString(PROP_INTEGRATION);
+    if (!TextUtils.isEmpty(integrationKindStr)) {
+      AdIntegrationKind integrationKind = AdIntegrationKind.from(integrationKindStr);
+      switch (integrationKind) {
+        // Currently only IMA is supported.
+        case GOOGLE_IMA:
+          return parseImaAdFromJS(jsonAdDescription);
+        case DEFAULT:
+        case THEO:
+        case FREEWHEEL:
+        case SPOTX:
+        default: {
+          throw new THEOplayerException(ErrorCode.AD_ERROR, ERROR_UNSUPPORTED_CSAI_INTEGRATION + ": " + integrationKindStr);
+        }
+      }
+    } else {
+      throw new THEOplayerException(ErrorCode.AD_ERROR, ERROR_MISSING_CSAI_INTEGRATION + ": " + integrationKindStr);
+    }
+  }
+
+  @NonNull
+  private static GoogleImaAdDescription parseImaAdFromJS(JSONObject jsonAdDescription) throws THEOplayerException {
+    if (!BuildConfig.EXTENSION_GOOGLE_IMA) {
+      throw new THEOplayerException(ErrorCode.AD_ERROR, ERROR_IMA_NOT_ENABLED);
+    }
+    String source;
+    // Property `sources` is of type string | AdSource.
+    JSONObject sourceObj = jsonAdDescription.optJSONObject(PROP_SOURCES);
+    if (sourceObj != null) {
+      source = sourceObj.optString(PROP_SRC);
+    } else {
+      source = jsonAdDescription.optString(PROP_SOURCES);
+    }
+    return GoogleImaAdDescription.Builder.googleImaAdDescription()
+      .source(source)
+      .timeOffset(jsonAdDescription.optString(PROP_TIME_OFFSET))
+      .build();
   }
 
   private static TextTrackDescription parseTextTrackFromJS(JSONObject jsonTextTrack) throws JSONException {
     TextTrackDescription.Builder builder = TextTrackDescription.Builder.textTrackDescription()
-      .isDefault(jsonTextTrack.optBoolean("default"))
-      .src(jsonTextTrack.optString("src"))
-      .label(jsonTextTrack.optString("label"))
-      .kind(parseTextTrackKind(jsonTextTrack.optString("kind")));
+      .isDefault(jsonTextTrack.optBoolean(PROP_DEFAULT))
+      .src(jsonTextTrack.optString(PROP_SRC))
+      .label(jsonTextTrack.optString(PROP_LABEL))
+      .kind(parseTextTrackKind(jsonTextTrack.optString(PROP_KIND)));
     return builder.build();
   }
 
@@ -263,10 +320,7 @@ public class SourceHelper {
   }
 
   /**
-   * Eliminate all the Readable* classes from the map
-   *
-   * @param readableMap
-   * @return
+   * Eliminate all the Readable* classes from the map.
    */
   protected static HashMap<String, Object> eliminateReadables(ReadableMap readableMap) {
     HashMap<String, Object> hashMap = readableMap.toHashMap();
@@ -285,10 +339,7 @@ public class SourceHelper {
   }
 
   /**
-   * Eliminate all the Readable* classes from the array
-   *
-   * @param readableArray
-   * @return
+   * Eliminate all the Readable* classes from the array.
    */
   protected static ArrayList<Object> eliminateReadables(ReadableArray readableArray) {
     ArrayList<Object> arrayList = readableArray.toArrayList();

package/android/src/main/java/com/theoplayer/VideoEventEmitter.java

@@ -21,6 +21,7 @@ import android.util.Log;
 import android.view.View;
 
 import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import androidx.annotation.StringDef;
 
 import com.facebook.react.bridge.Arguments;
@@ -28,12 +29,14 @@ import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.uimanager.events.RCTEventEmitter;
+import com.theoplayer.ads.AdEventAdapter;
 import com.theoplayer.android.api.error.THEOplayerException;
 import com.theoplayer.android.api.event.EventListener;
 import com.theoplayer.android.api.event.EventType;
 import com.theoplayer.android.api.event.player.DurationChangeEvent;
 import com.theoplayer.android.api.event.player.ErrorEvent;
 import com.theoplayer.android.api.event.player.LoadedMetadataEvent;
+import com.theoplayer.android.api.event.player.PauseEvent;
 import com.theoplayer.android.api.event.player.ReadyStateChangeEvent;
 import com.theoplayer.android.api.event.player.SeekedEvent;
 import com.theoplayer.android.api.event.player.SeekingEvent;
@@ -52,6 +55,7 @@ import com.theoplayer.android.api.player.track.mediatrack.quality.VideoQuality;
 import com.theoplayer.android.api.player.track.texttrack.TextTrack;
 import com.theoplayer.track.TextTrackCueEventType;
 import com.theoplayer.track.TrackEventType;
+import com.theoplayer.util.TypeUtils;
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
@@ -59,7 +63,8 @@ import java.util.Date;
 import java.util.HashMap;
 import java.util.Map;
 
-class VideoEventEmitter {
+@SuppressWarnings({"rawtypes", "unchecked"})
+public class VideoEventEmitter {
 
   private static final String EVENT_SOURCECHANGE = "onNativeSourceChange";
   private static final String EVENT_LOADSTART = "onNativeLoadStart";
@@ -79,6 +84,7 @@ class VideoEventEmitter {
   private static final String EVENT_SEGMENTNOTFOUND = "onNativeSegmentNotFound";
   private static final String EVENT_TEXTTRACK_LIST_EVENT = "onNativeTextTrackListEvent";
   private static final String EVENT_TEXTTRACK_EVENT = "onNativeTextTrackEvent";
+  private static final String EVENT_AD_EVENT = "onNativeAdEvent";
   private static final String EVENT_FULLSCREEN_WILL_PRESENT = "onNativeFullscreenPlayerWillPresent";
   private static final String EVENT_FULLSCREEN_DID_PRESENT = "onNativeFullscreenPlayerDidPresent";
   private static final String EVENT_FULLSCREEN_WILL_DISMISS = "onNativeFullscreenPlayerWillDismiss";
@@ -105,6 +111,7 @@ class VideoEventEmitter {
     EVENT_SEGMENTNOTFOUND,
     EVENT_TEXTTRACK_LIST_EVENT,
     EVENT_TEXTTRACK_EVENT,
+    EVENT_AD_EVENT,
     EVENT_FULLSCREEN_WILL_PRESENT,
     EVENT_FULLSCREEN_DID_PRESENT,
     EVENT_FULLSCREEN_WILL_DISMISS,
@@ -131,12 +138,13 @@ class VideoEventEmitter {
     EVENT_SEGMENTNOTFOUND,
     EVENT_TEXTTRACK_LIST_EVENT,
     EVENT_TEXTTRACK_EVENT,
+    EVENT_AD_EVENT,
     EVENT_FULLSCREEN_WILL_PRESENT,
     EVENT_FULLSCREEN_DID_PRESENT,
     EVENT_FULLSCREEN_WILL_DISMISS,
     EVENT_FULLSCREEN_DID_DISMISS
   })
-  @interface VideoEvents {
+  public @interface VideoEvents {
   }
 
   private static final String EVENT_PROP_CURRENT_TIME = "currentTime";
@@ -166,9 +174,9 @@ class VideoEventEmitter {
   private int viewId = View.NO_ID;
   private final HashMap<EventType, EventListener> playerListeners = new HashMap<>();
   private final HashMap<EventType, EventListener> textTrackListeners = new HashMap<>();
-
   private final ReactTHEOplayerView playerView;
 
+  private AdEventAdapter adEventAdapter;
   private long lastTimeUpdate = 0;
   private double lastCurrentTime = 0.0;
 
@@ -191,7 +199,7 @@ class VideoEventEmitter {
     playerListeners.put(PROGRESS, event -> onProgress());
     playerListeners.put(TIMEUPDATE, (EventListener<TimeUpdateEvent>) this::onTimeUpdate);
     playerListeners.put(DURATIONCHANGE, (EventListener<DurationChangeEvent>) this::onDurationChange);
-    playerListeners.put(PAUSE, event -> receiveEvent(EVENT_PAUSE, null));
+    playerListeners.put(PAUSE, (EventListener<PauseEvent>) this::onPause);
     playerListeners.put(SEGMENTNOTFOUND, (EventListener<SegmentNotFoundEvent>) this::onSegmentNotFound);
 
     textTrackListeners.put(TextTrackListEventTypes.ADDTRACK, (EventListener<AddTrackEvent>) this::onTextTrackAdd);
@@ -202,6 +210,19 @@ class VideoEventEmitter {
     this.viewId = viewId;
   }
 
+  public void emitError(@NonNull THEOplayerException exception) {
+    emitError(exception.getCode().name(), exception.getMessage());
+  }
+
+  public void emitError(@NonNull String code, @Nullable String message) {
+    WritableMap error = Arguments.createMap();
+    error.putString(EVENT_PROP_ERROR_CODE, code);
+    error.putString(EVENT_PROP_ERROR_MESSAGE, message != null ? message : "");
+    WritableMap payload = Arguments.createMap();
+    payload.putMap(EVENT_PROP_ERROR, error);
+    receiveEvent(EVENT_ERROR, payload);
+  }
+
   private void onLoadedMetadata(final LoadedMetadataEvent event) {
     WritableMap payload = Arguments.createMap();
     payload.putArray(EVENT_PROP_TEXT_TRACKS, playerView.getTextTrackInfo());
@@ -255,6 +276,14 @@ class VideoEventEmitter {
       (timeUpdateRate == TimeUpdateRate.LIMITED_THREE_HZ && dt < 333);
   }
 
+  private void onPause(@NonNull final PauseEvent event) {
+    Player player = playerView.getPlayer();
+    // Do not forward the pause event in case the content player is paused because the ad player starts.
+    if (player != null && !playerView.getAdsApi().isPlaying()) {
+      receiveEvent(EVENT_PAUSE, null);
+    }
+  }
+
   private void onTimeUpdate(@NonNull final TimeUpdateEvent event) {
     final long now = System.currentTimeMillis();
     final double currentTime = event.getCurrentTime();
@@ -283,18 +312,12 @@ class VideoEventEmitter {
 
   private void onDurationChange(final @NonNull DurationChangeEvent event) {
     WritableMap payload = Arguments.createMap();
-    payload.putDouble(EVENT_PROP_DURATION, 1e03 * event.getDuration());
+    payload.putDouble(EVENT_PROP_DURATION, TypeUtils.INSTANCE.encodeInfNan(1e03 * event.getDuration()));
     receiveEvent(EVENT_DURATIONCHANGE, payload);
   }
 
   private void onError(@NonNull final ErrorEvent event) {
-    WritableMap error = Arguments.createMap();
-    final THEOplayerException exception = event.getErrorObject();
-    error.putString(EVENT_PROP_ERROR_CODE, exception.getCode().name());
-    error.putString(EVENT_PROP_ERROR_MESSAGE, exception.getMessage());
-    WritableMap payload = Arguments.createMap();
-    payload.putMap(EVENT_PROP_ERROR, error);
-    receiveEvent(EVENT_ERROR, payload);
+    emitError(event.getErrorObject());
   }
 
   private void onProgress() {
@@ -394,6 +417,11 @@ class VideoEventEmitter {
     for (Map.Entry<EventType, EventListener> entry : textTrackListeners.entrySet()) {
       player.getTextTracks().addEventListener(entry.getKey(), entry.getValue());
     }
+
+    // Attach AdStateHolder
+    if (BuildConfig.EXTENSION_ADS) {
+      adEventAdapter = new AdEventAdapter(playerView.getAdsApi(), payload -> receiveEvent(EVENT_AD_EVENT, payload));
+    }
   }
 
   public void removeListeners(@NonNull Player player) {
@@ -406,5 +434,9 @@ class VideoEventEmitter {
     for (Map.Entry<EventType, EventListener> entry : textTrackListeners.entrySet()) {
       player.getTextTracks().removeEventListener(entry.getKey(), entry.getValue());
     }
+
+    if (adEventAdapter != null) {
+      adEventAdapter.destroy();
+    }
   }
 }

package/android/src/main/java/com/theoplayer/abr/ABRConfigurationAdapter.kt

@@ -0,0 +1,72 @@
+package com.theoplayer.abr
+
+import com.facebook.react.bridge.ReadableMap
+import com.theoplayer.android.api.abr.AbrStrategyConfiguration
+import com.theoplayer.android.api.abr.AbrStrategyMetadata
+import com.theoplayer.android.api.abr.AbrStrategyType
+import com.theoplayer.android.api.player.Player
+
+object ABRConfigurationAdapter {
+  private const val PROP_TARGET_BUFFER = "targetBuffer"
+  private const val PROP_STRATEGY = "strategy"
+  private const val PROP_METADATA = "metadata"
+  private const val PROP_TYPE = "type"
+  private const val PROP_BITRATE = "bitrate"
+
+  fun applyABRConfigurationFromProps(player: Player?, abrProps: ReadableMap?) {
+    if (abrProps == null || player == null) {
+      return
+    }
+    if (abrProps.hasKey(PROP_TARGET_BUFFER)) {
+      player.abr.targetBuffer = abrProps.getInt(PROP_TARGET_BUFFER)
+    }
+    // Strategy can be either a string or an object
+    try {
+      val abrStrategyPropsString = abrProps.getString(PROP_STRATEGY)
+      if (abrStrategyPropsString != null) {
+        AbrStrategyConfiguration.Builder().apply {
+          abrStrategyTypeFromString(abrStrategyPropsString)?.let { type ->
+            setType(type)
+          }
+          player.abr.abrStrategy = build()
+        }
+      }
+    } catch (_: Exception) {
+    }
+    try {
+      val abrStrategyPropsMap = abrProps.getMap(PROP_STRATEGY)
+      if (abrStrategyPropsMap != null) {
+        AbrStrategyConfiguration.Builder().apply {
+          abrMetadataFromProps(abrStrategyPropsMap.getMap(PROP_METADATA))?.let { metadata ->
+            setMetadata(metadata)
+          }
+          abrStrategyTypeFromString(abrStrategyPropsMap.getString(PROP_TYPE))?.let { type ->
+            setType(type)
+          }
+          player.abr.abrStrategy = build()
+        }
+      }
+    } catch (_: Exception) {
+    }
+  }
+
+  private fun abrMetadataFromProps(props: ReadableMap?): AbrStrategyMetadata? {
+    if (props == null) {
+      return null
+    }
+    val builder = AbrStrategyMetadata.Builder()
+    if (props.hasKey(PROP_BITRATE)) {
+      builder.setBitrate(props.getInt(PROP_BITRATE))
+    }
+    return builder.build()
+  }
+
+  private fun abrStrategyTypeFromString(type: String?): AbrStrategyType? {
+    return when (type) {
+      "performance" -> AbrStrategyType.PERFORMANCE
+      "quality" -> AbrStrategyType.QUALITY
+      "bandwidth" -> AbrStrategyType.BANDWIDTH
+      else -> return null
+    }
+  }
+}

package/android/src/main/java/com/theoplayer/ads/AdEventAdapter.java

@@ -0,0 +1,92 @@
+package com.theoplayer.ads;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+import com.theoplayer.android.api.ads.wrapper.AdEventListener;
+import com.theoplayer.android.api.ads.wrapper.AdsApiWrapper;
+import com.theoplayer.android.api.ads.Ad;
+import com.theoplayer.android.api.ads.AdBreak;
+import com.theoplayer.android.api.ads.ima.GoogleImaAdEventType;
+import com.theoplayer.android.api.event.EventType;
+import com.theoplayer.android.api.event.ads.AdEvent;
+
+public class AdEventAdapter {
+  private final AdsApiWrapper adsApi;
+  private final AdEventListener eventListener;
+
+  private static final String EVENT_PROP_AD = "ad";
+  private static final String EVENT_PROP_TYPE = "type";
+
+  private final static GoogleImaAdEventType[] ALL_AD_EVENTS = {
+    GoogleImaAdEventType.LOADED,
+    GoogleImaAdEventType.AD_BREAK_STARTED,
+    GoogleImaAdEventType.STARTED,
+    GoogleImaAdEventType.FIRST_QUARTILE,
+    GoogleImaAdEventType.MIDPOINT,
+    GoogleImaAdEventType.THIRD_QUARTILE,
+    GoogleImaAdEventType.COMPLETED,
+    GoogleImaAdEventType.AD_BREAK_ENDED,
+    GoogleImaAdEventType.SKIPPED,
+    GoogleImaAdEventType.AD_ERROR,
+    GoogleImaAdEventType.AD_BUFFERING,
+    GoogleImaAdEventType.AD_BREAK_FETCH_ERROR
+  };
+
+  public interface AdEventEmitter {
+    void emit(WritableMap payload);
+  }
+
+  public AdEventAdapter(AdsApiWrapper adsApi, AdEventEmitter eventEmitter) {
+    this.adsApi = adsApi;
+
+    eventListener = new AdEventListener() {
+      @Override
+      public <E extends AdEvent<?>> void onAdEvent(EventType<E> eventType, Ad ad) {
+        WritableMap payload = Arguments.createMap();
+        payload.putString(EVENT_PROP_TYPE, mapAdType(eventType));
+        if (ad != null) {
+          payload.putMap(EVENT_PROP_AD, AdInfo.fromAd(ad));
+        }
+        eventEmitter.emit(payload);
+      }
+
+      @Override
+      public <E extends AdEvent<?>> void onAdBreakEvent(EventType<E> eventType, AdBreak adBreak) {
+        WritableMap payload = Arguments.createMap();
+        payload.putString(EVENT_PROP_TYPE, mapAdType(eventType));
+        if (adBreak != null) {
+          payload.putMap(EVENT_PROP_AD, AdInfo.fromAdBreak(adBreak));
+        }
+        eventEmitter.emit(payload);
+      }
+    };
+
+    for (GoogleImaAdEventType eventType: ALL_AD_EVENTS) {
+      adsApi.addEventListener(eventType, eventListener);
+    }
+  }
+
+  private String mapAdType(EventType<?> eventType) {
+    switch ((GoogleImaAdEventType)eventType) {
+      case LOADED: return "adloaded";
+      case STARTED: return "adbegin";
+      case FIRST_QUARTILE: return "adfirstquartile";
+      case MIDPOINT: return "admidpoint";
+      case THIRD_QUARTILE: return "adthirdquartile";
+      case COMPLETED: return "adend";
+      case SKIPPED: return "adskip";
+      case AD_ERROR: return "aderror";
+      case AD_BUFFERING: return "adbuffering";
+      case AD_BREAK_STARTED: return "adbreakbegin";
+      case AD_BREAK_ENDED: return "adbreakend";
+      case AD_BREAK_FETCH_ERROR: return "aderror";
+      default: return eventType.getName().toLowerCase();
+    }
+  }
+
+  public void destroy() {
+    for (GoogleImaAdEventType eventType: ALL_AD_EVENTS) {
+      adsApi.removeEventListener(eventType, eventListener);
+    }
+  }
+}