@jwplayer/jwplayer-react-native 1.0.0

package/android/src/main/java/com/jwplayer/rnjwplayer/RNJWPlayer.java

@@ -0,0 +1,76 @@
+package com.jwplayer.rnjwplayer;
+
+
+import android.content.Context;
+import android.content.res.Configuration;
+import android.view.KeyEvent;
+
+import com.jwplayer.pub.view.JWPlayerView;
+
+public class RNJWPlayer extends JWPlayerView {
+    public Boolean fullScreenOnLandscape = false;
+    public Boolean exitFullScreenOnPortrait = false;
+
+    public RNJWPlayer(Context var1) {
+        super(var1);
+    }
+
+    @Override
+    public boolean dispatchKeyEvent(KeyEvent event) {
+        // Exit fullscreen or perform the action requested
+        if (event.getKeyCode() == KeyEvent.KEYCODE_BACK && this.getPlayer().getFullscreen()) {
+            if (event.getAction() == KeyEvent.ACTION_UP) {
+                this.getPlayer().setFullscreen(false,false);
+            }
+            return true;
+        }
+        return super.dispatchKeyEvent(event);
+    }
+
+    @Override
+    public void requestLayout() {
+        super.requestLayout();
+
+        // The spinner relies on a measure + layout pass happening after it calls requestLayout().
+        // Without this, the widget never actually changes the selection and doesn't call the
+        // appropriate listeners. Since we override onLayout in our ViewGroups, a layout pass never
+        // happens after a call to requestLayout, so we simulate one here.
+        post(measureAndLayout);
+    }
+
+
+    private final Runnable measureAndLayout = new Runnable() {
+        @Override
+        public void run() {
+            measure(
+                    MeasureSpec.makeMeasureSpec(getWidth(), MeasureSpec.EXACTLY),
+                    MeasureSpec.makeMeasureSpec(getHeight(), MeasureSpec.EXACTLY));
+            layout(getLeft(), getTop(), getRight(), getBottom());
+        }
+    };
+
+    @Override
+    protected void onConfigurationChanged(Configuration newConfig) {
+        super.onConfigurationChanged(newConfig);
+
+        if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {
+            if (fullScreenOnLandscape) {
+                this.getPlayer().setFullscreen(true,true);
+            }
+        } else if (newConfig.orientation==Configuration.ORIENTATION_PORTRAIT) {
+            if (exitFullScreenOnPortrait) {
+                this.getPlayer().setFullscreen(false,false);
+            }
+        }
+    }
+
+    @Override
+    public boolean onKeyDown(int keyCode, KeyEvent event) {
+        if (keyCode == KeyEvent.KEYCODE_BACK && this.getPlayer().getFullscreen()) {
+            this.getPlayer().setFullscreen(false,false);
+            return true;
+        }
+
+        return super.onKeyDown(keyCode, event);
+    }
+}

package/android/src/main/java/com/jwplayer/rnjwplayer/RNJWPlayerAds.java

@@ -0,0 +1,239 @@
+package com.jwplayer.rnjwplayer;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.google.ads.interactivemedia.v3.api.FriendlyObstruction;
+import com.google.ads.interactivemedia.v3.api.ImaSdkFactory;
+import com.google.ads.interactivemedia.v3.api.ImaSdkSettings;
+import com.jwplayer.pub.api.configuration.ads.AdRules;
+import com.jwplayer.pub.api.configuration.ads.AdvertisingConfig;
+import com.jwplayer.pub.api.configuration.ads.VastAdvertisingConfig;
+import com.jwplayer.pub.api.configuration.ads.dai.ImaDaiAdvertisingConfig;
+import com.jwplayer.pub.api.configuration.ads.ima.ImaAdvertisingConfig;
+import com.jwplayer.pub.api.media.ads.AdBreak;
+import com.jwplayer.pub.api.media.ads.dai.ImaDaiSettings;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+public class RNJWPlayerAds {
+
+    // Get advertising config based on the ad client type
+    public static AdvertisingConfig getAdvertisingConfig(ReadableMap ads) {
+        if (ads == null) {
+            return null;
+        }
+
+        String adClientType = ads.getString("adClient");
+        switch (adClientType) {
+            case "ima":
+                try {
+                    return configureImaAdvertising(ads);
+                } catch (Exception e) {
+                    throw new RuntimeException(e);
+                }
+            case "ima_dai":
+                try {
+                    return configureImaDaiAdvertising(ads);
+                } catch (Exception e) {
+                    throw new RuntimeException(e);
+                }
+            default: // Defaulting to VAST
+                return configureVastAdvertising(ads);
+        }
+    }
+
+    // Configure IMA Advertising
+    private static ImaAdvertisingConfig configureImaAdvertising(ReadableMap ads) throws Exception {
+        if (!BuildConfig.USE_IMA) {
+            throw new Exception("Error: Google ads services is not installed. Add RNJWPlayerUseGoogleIMA = true to your app/build.gradle ext {}");
+        }
+
+        ImaAdvertisingConfig.Builder builder = new ImaAdvertisingConfig.Builder();
+
+        List<AdBreak> adScheduleList = getAdSchedule(ads);
+        builder.schedule(adScheduleList);
+
+        if (ads.hasKey("imaSettings")) {
+            builder.imaSdkSettings(getImaSettings(Objects.requireNonNull(ads.getMap("imaSettings"))));
+        }
+
+        // companionSlots
+
+        return builder.build();
+    }
+
+    // Configure IMA DAI Advertising
+    private static ImaDaiAdvertisingConfig configureImaDaiAdvertising(ReadableMap ads) throws Exception {
+        if (!BuildConfig.USE_IMA) {
+            throw new Exception("Error: Google ads services is not installed. Add RNJWPlayerUseGoogleIMA = true to your app/build.gradle ext {}");
+        }
+
+        ImaDaiAdvertisingConfig.Builder builder = new ImaDaiAdvertisingConfig.Builder();
+
+        if (ads.hasKey("imaSettings")) {
+            builder.imaSdkSettings(getImaSettings(Objects.requireNonNull(ads.getMap("imaSettings"))));
+        }
+
+        if (ads.hasKey("imaDaiSettings")) {
+            builder.imaDaiSettings(getImaDaiSettings(Objects.requireNonNull(ads.getMap("imaDaiSettings"))));
+        }
+
+        return builder.build();
+    }
+
+    // You'll need to implement this method based on how you pass ImaDaiSettings from React Native
+    private static ImaDaiSettings getImaDaiSettings(ReadableMap imaDaiSettingsMap) {
+        String videoId = imaDaiSettingsMap.hasKey("videoId") ? imaDaiSettingsMap.getString("videoId") : null;
+        String cmsId = imaDaiSettingsMap.hasKey("cmsId") ? imaDaiSettingsMap.getString("cmsId") : null;
+        String assetKey = imaDaiSettingsMap.hasKey("assetKey") ? imaDaiSettingsMap.getString("assetKey") : null;
+        String apiKey = imaDaiSettingsMap.hasKey("apiKey") ? imaDaiSettingsMap.getString("apiKey") : null;
+
+        // Extracting adTagParameters from imaDaiSettingsMap if present
+        Map<String, String> adTagParameters = null;
+        if (imaDaiSettingsMap.hasKey("adTagParameters") && imaDaiSettingsMap.getMap("adTagParameters") != null) {
+            adTagParameters = new HashMap<>();
+            ReadableMap adTagParamsMap = imaDaiSettingsMap.getMap("adTagParameters");
+            for (Map.Entry<String, Object> entry : adTagParamsMap.toHashMap().entrySet()) {
+                if (entry.getValue() instanceof String) {
+                    adTagParameters.put(entry.getKey(), (String) entry.getValue());
+                }
+            }
+        }
+
+        // Handling streamType
+        ImaDaiSettings.StreamType streamType = ImaDaiSettings.StreamType.HLS; // Default to HLS
+        if (imaDaiSettingsMap.hasKey("streamType")) {
+            String streamTypeStr = imaDaiSettingsMap.getString("streamType");
+            if ("DASH".equalsIgnoreCase(streamTypeStr)) {
+                streamType = ImaDaiSettings.StreamType.DASH;
+            }
+        }
+        // Create ImaDaiSettings based on the provided values
+        ImaDaiSettings imaDaiSettings = (assetKey != null) ?
+                new ImaDaiSettings(assetKey, streamType, apiKey) :
+                new ImaDaiSettings(videoId, cmsId, streamType, apiKey);
+
+        if (adTagParameters != null) {
+            imaDaiSettings.setAdTagParameters(adTagParameters);
+        }
+
+        return imaDaiSettings;
+    }
+
+    // Configure VAST Advertising
+    private static VastAdvertisingConfig configureVastAdvertising(ReadableMap ads) {
+        VastAdvertisingConfig.Builder builder = new VastAdvertisingConfig.Builder();
+
+        List<AdBreak> adScheduleList = getAdSchedule(ads);
+        builder.schedule(adScheduleList);
+
+        if (ads.hasKey("skipText")) {
+            builder.skipText(ads.getString("skipText"));
+        }
+        if (ads.hasKey("skipMessage")) {
+            builder.skipMessage(ads.getString("skipMessage"));
+        }
+        // ... Add other VAST specific settings from ads ReadableMap
+
+        // Example: Handling VPAID controls
+        if (ads.hasKey("vpaidControls")) {
+            builder.vpaidControls(ads.getBoolean("vpaidControls"));
+        }
+
+        if (ads.hasKey("adRules")) {
+            AdRules adRules = getAdRules(Objects.requireNonNull(ads.getMap("adRules")));
+            builder.adRules(adRules);
+        }
+
+        return builder.build();
+    }
+
+    private static List<AdBreak> getAdSchedule(ReadableMap ads) {
+        List<AdBreak> adScheduleList = new ArrayList<>();
+        ReadableArray adSchedule = ads.getArray("adSchedule");
+        for (int i = 0; i < adSchedule.size(); i++) {
+            ReadableMap adBreakProp = adSchedule.getMap(i);
+            String offset = adBreakProp.hasKey("offset") ? adBreakProp.getString("offset") : "pre";
+            if (adBreakProp.hasKey("tag")) {
+                AdBreak adBreak = new AdBreak.Builder()
+                        .offset(offset)
+                        .tag(adBreakProp.getString("tag"))
+                        .build();
+                adScheduleList.add(adBreak);
+            }
+        }
+        return adScheduleList;
+    }
+
+    public static AdRules getAdRules(ReadableMap adRulesMap) {
+        AdRules.Builder builder = new AdRules.Builder();
+
+        if (adRulesMap.hasKey("startOn")) {
+            Integer startOn = adRulesMap.getInt("startOn");
+            builder.startOn(startOn);
+        }
+        if (adRulesMap.hasKey("frequency")) {
+            Integer frequency = adRulesMap.getInt("frequency");
+            builder.frequency(frequency);
+        }
+        if (adRulesMap.hasKey("timeBetweenAds")) {
+            Integer timeBetweenAds = adRulesMap.getInt("timeBetweenAds");
+            builder.timeBetweenAds(timeBetweenAds);
+        }
+        if (adRulesMap.hasKey("startOnSeek")) {
+            String startOnSeek = adRulesMap.getString("startOnSeek");
+            // Mapping the string to the corresponding constant in AdRules
+            String mappedStartOnSeek = mapStartOnSeek(startOnSeek);
+            builder.startOnSeek(mappedStartOnSeek);
+        }
+
+        return builder.build();
+    }
+
+    private static String mapStartOnSeek(String startOnSeek) {
+        if ("pre".equals(startOnSeek)) {
+            return AdRules.RULES_START_ON_SEEK_PRE;
+        }
+        // Default to "none" if not "pre"
+        return AdRules.RULES_START_ON_SEEK_NONE;
+    }
+
+//    public static List<FriendlyObstruction> getFriendlyObstructions(ReadableArray obstructionsArray) {
+//        List<FriendlyObstruction> obstructions = new ArrayList<>();
+//        // Example: Parse and create FriendlyObstruction objects from obstructionsArray
+//        return obstructions;
+//    }
+
+    public static ImaSdkSettings getImaSettings(ReadableMap imaSettingsMap) {
+        ImaSdkSettings settings = ImaSdkFactory.getInstance().createImaSdkSettings();
+
+        if (imaSettingsMap.hasKey("maxRedirects")) {
+            settings.setMaxRedirects(imaSettingsMap.getInt("maxRedirects"));
+        }
+        if (imaSettingsMap.hasKey("language")) {
+            settings.setLanguage(imaSettingsMap.getString("language"));
+        }
+        if (imaSettingsMap.hasKey("ppid")) {
+            settings.setPpid(imaSettingsMap.getString("ppid"));
+        }
+        if (imaSettingsMap.hasKey("playerType")) {
+            settings.setPlayerType(imaSettingsMap.getString("playerType"));
+        }
+        if (imaSettingsMap.hasKey("playerVersion")) {
+            settings.setPlayerVersion(imaSettingsMap.getString("playerVersion"));
+        }
+        if (imaSettingsMap.hasKey("sessionId")) {
+            settings.setSessionId(imaSettingsMap.getString("sessionId"));
+        }
+        if (imaSettingsMap.hasKey("debugMode")) {
+            settings.setDebugMode(imaSettingsMap.getBoolean("debugMode"));
+        }
+        // Add other settings as needed
+
+        return settings;
+    }
+}