cordova-plugin-media3 1.1.0

package/src/android/Payload.java

@@ -0,0 +1,361 @@
+/*
+ The MIT License (MIT)
+
+ Copyright (c) 2017 Nedim Cholich
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+package co.frontyard.cordova.plugin.exoplayer;
+
+import android.util.Log;
+import android.view.*;
+import androidx.media3.common.*;
+import androidx.media3.exoplayer.*;
+import androidx.media3.exoplayer.trackselection.*;
+import androidx.media3.common.C;
+import androidx.media3.common.Format;
+import androidx.media3.common.Tracks;
+// import com.google.android.exoplayer2.video.*;
+import java.lang.*;
+import java.lang.Boolean;
+import java.lang.Integer;
+import java.lang.StackTraceElement;
+import java.lang.StringBuffer;
+import java.util.*;
+import org.json.*;
+
+public class Payload {
+
+    public static String playbackStateToString(int playbackState) {
+        String state = "UNKNOWN";
+        switch (playbackState) {
+            case Player.STATE_IDLE:
+                state = "STATE_IDLE";
+                break;
+            case Player.STATE_BUFFERING:
+                state = "STATE_BUFFERING";
+                break;
+            case Player.STATE_READY:
+                state = "STATE_READY";
+                break;
+            case Player.STATE_ENDED:
+                state = "STATE_ENDED";
+                break;
+        }
+        return state;
+    }
+
+    public static JSONObject startEvent(ExoPlayer player, String audioFocus) {
+        Map<String, String> map = new HashMap<String, String>();
+        map.put("eventType", "START_EVENT");
+        map.put("audioFocus", audioFocus);
+        addPlayerState(map, player);
+        return new JSONObject(map);
+    }
+
+    public static JSONObject stopEvent(ExoPlayer player) {
+        Map<String, String> map = new HashMap<String, String>();
+        map.put("eventType", "STOP_EVENT");
+        return new JSONObject(map);
+    }
+
+    public static JSONObject keyEvent(KeyEvent event) {
+        int eventAction = event.getAction();
+        Map<String, String> map = new HashMap<String, String>();
+        map.put("eventType", "KEY_EVENT");
+        map.put("eventAction", eventAction == KeyEvent.ACTION_DOWN ? "ACTION_DOWN" : eventAction == KeyEvent.ACTION_UP ? "ACTION_UP" : "" + eventAction);
+        map.put("eventKeycode", KeyEvent.keyCodeToString(event.getKeyCode()));
+        return new JSONObject(map);
+    }
+
+    public static JSONObject touchEvent(MotionEvent event) {
+        int eventAction = event.getAction();
+        Map<String, String> map = new HashMap<String, String>();
+        map.put("eventType", "TOUCH_EVENT");
+        map.put("eventAction", eventAction == MotionEvent.ACTION_DOWN ? "ACTION_DOWN" : eventAction == MotionEvent.ACTION_UP ? "ACTION_UP" : eventAction == MotionEvent.ACTION_MOVE ? "ACTION_MOVE" : "" + eventAction);
+        map.put("eventAxisX", Float.toString(event.getX()));
+        map.put("eventAxisY", Float.toString(event.getY()));
+        return new JSONObject(map);
+    }
+
+    public static JSONObject loadingEvent(ExoPlayer player, boolean loading) {
+        Map<String, String> map = new HashMap<String, String>();
+        map.put("eventType", "LOADING_EVENT");
+        map.put("loading", Boolean.toString(loading));
+        addPlayerState(map, player);
+        return new JSONObject(map);
+    }
+
+    public static JSONObject stateEvent(ExoPlayer player, int playbackState, boolean controllerVisible) {
+        Map<String, String> map = new HashMap<String, String>();
+        map.put("eventType", "STATE_CHANGED_EVENT");
+        addPlayerState(map, player);
+        addTracksInfo(map, player);
+        map.put("playbackState", playbackStateToString(playbackState));
+        map.put("controllerVisible", Boolean.toString(controllerVisible));
+
+        return new JSONObject(map);
+    }
+
+    public static JSONObject positionDiscontinuityEvent(ExoPlayer player, int reason) {
+        Map<String, String> map = new HashMap<String, String>();
+        map.put("eventType", "POSITION_DISCONTINUITY_EVENT");
+        map.put("reason", Integer.toString(reason));
+        addPlayerState(map, player);
+        return new JSONObject(map);
+    }
+
+    public static JSONObject seekEvent(ExoPlayer player, long offset) {
+        Map<String, String> map = new HashMap<String, String>();
+        map.put("eventType", "SEEK_EVENT");
+        map.put("offset", Long.toString(offset));
+        addPlayerState(map, player);
+        return new JSONObject(map);
+    }
+
+    public static JSONObject timelineChangedEvent(ExoPlayer player, Timeline timeline) {
+        Map<String, String> map = new HashMap<String, String>();
+        map.put("eventType", "TIMELINE_EVENT");
+        int periodCount = timeline.getPeriodCount();
+        for (int i = 0; i < periodCount; i++) {
+            Timeline.Period period = new Timeline.Period();
+            timeline.getPeriod(i, period);
+            map.put("periodDuration" + i, Long.toString(period.getDurationMs()));
+            map.put("periodWindowPosition" + i, Long.toString(period.getPositionInWindowMs()));
+        }
+        int firstWindow = timeline.getFirstWindowIndex(false);
+        if (firstWindow > -1) {
+            Timeline.Window window = new Timeline.Window();
+            timeline.getWindow(firstWindow, window);
+            map.put("positionInFirstPeriod", Long.toString(window.getPositionInFirstPeriodMs()));
+        }        
+        addPlayerState(map, player);
+        return new JSONObject(map);
+    }
+
+    public static JSONObject audioFocusEvent(ExoPlayer player, String state) {
+        Map<String, String> map = new HashMap<String, String>();
+        map.put("eventType", "AUDIO_FOCUS_EVENT");
+        map.put("audioFocus", state);
+        addPlayerState(map, player);
+        return new JSONObject(map);
+    }
+
+    public static JSONObject playerErrorEvent(ExoPlayer player, PlaybackException origin, String message) {
+        int type = 0;
+        Map<String, String> map = new HashMap<String, String>();
+        map.put("eventType", "PLAYER_ERROR_EVENT");
+
+        if (null != origin && origin instanceof ExoPlaybackException) {
+            Throwable error = (Throwable) origin;
+            ExoPlaybackException exoOrigin = (ExoPlaybackException) origin;
+
+            type = exoOrigin.type;
+            if (type == ExoPlaybackException.TYPE_RENDERER) {
+                error = exoOrigin.getRendererException();
+                map.put("errorType", "RENDERER");
+            }
+            else if (type == ExoPlaybackException.TYPE_SOURCE) {
+                error = exoOrigin.getSourceException();
+                map.put("errorType", "SOURCE");
+            }
+            else if (type == ExoPlaybackException.TYPE_UNEXPECTED) {
+                error = exoOrigin.getUnexpectedException();
+                map.put("errorType", "UNEXPECTED");
+            }
+            else {
+                map.put("errorType", "UNKNOWN");
+            }
+
+            while (null != error.getCause()) {
+                error = error.getCause();
+            }
+            error.fillInStackTrace();
+            StringBuffer stackTrace = new StringBuffer();
+            if (null != error) {
+                StackTraceElement[] st = error.getStackTrace();
+                if (null != st && st.length > 0) {
+                    for (int i = 0; i < st.length; i++) {
+                        StackTraceElement elem = st[i];
+                        stackTrace.append(elem.getClassName() + "#" + elem.getMethodName() + "@" + elem.getLineNumber() + (elem.isNativeMethod() ? " NATIVE" : "")).append("\n");
+                    }
+                }
+            }
+            map.put("stackTrace", stackTrace.toString());
+            map.put("errorMessage", error.getMessage());
+        }
+        if (null != message) {
+            map.put("customMessage", message);
+        }
+
+        return new JSONObject(map);
+    }
+
+    private static void addPlayerState(Map<String, String> map, ExoPlayer player) {
+        if (null != player) {
+            try {
+                map.put("duration", Long.toString(player.getDuration()));
+                map.put("position", Long.toString(player.getCurrentPosition()));
+                map.put("playWhenReady", Boolean.toString(player.getPlayWhenReady()));
+                map.put("playbackState", playbackStateToString(player.getPlaybackState()));
+                map.put("bufferPercentage", Integer.toString(player.getBufferedPercentage()));
+                map.put("videoWidth", Integer.toString(player.getVideoSize().width));
+                map.put("videoHeight", Integer.toString(player.getVideoSize().height));
+            }
+            catch(Exception ex) {
+                Log.e(Player.TAG, "Error adding player state", ex);
+            }
+        }
+    }
+
+    
+    public static JSONObject timeUpdateEvent(ExoPlayer player) {
+        Map<String, String> map = new HashMap<String, String>();
+        map.put("eventType", "TIMEUPDATE_EVENT");
+        map.put("message", "Timer running");
+        // map.put("playbackState", playbackStateToString(playbackState));
+        addPlayerState(map, player);
+        return new JSONObject(map);
+    }
+
+    public static JSONObject tracksChangedEvent(ExoPlayer player, Tracks tracks) {
+        Map<String, String> map = new HashMap<String, String>();
+        map.put("eventType", "TRACKS_CHANGED_EVENT");
+        addTracksInfo(map, player);
+        return new JSONObject(map);
+    }
+
+    public static void addTracksInfo(Map<String, String> map, ExoPlayer player) {
+        if (null != player && playbackStateToString(player.getPlaybackState()) == "STATE_READY") {
+            Tracks currentTracks = player.getCurrentTracks();
+            JSONObject result = new JSONObject();
+            JSONArray audioArray = new JSONArray();
+            JSONArray subtitleArray = new JSONArray();
+
+            if (currentTracks == null) {
+                try {
+                    result.put("audioTracks", audioArray);
+                    result.put("subtitleTracks", subtitleArray);
+                    map.put("tracks", result.toString());
+                } catch (JSONException e) {
+                    // e.printStackTrace();
+                    Log.e(Player.TAG, "Error adding tracks info", e);
+                }
+
+            } 
+            else {    
+                for (Tracks.Group group : currentTracks.getGroups()) {
+                    for (int i = 0; i < group.length; i++) {
+                        Format format = group.getTrackFormat(i);
+                        JSONObject trackObj = new JSONObject();
+                        try {
+                            trackObj.put("id", format.id != null ? format.id : JSONObject.NULL);
+                            trackObj.put("language", format.language != null ? format.language : JSONObject.NULL);
+                            trackObj.put("label", format.label != null ? format.label : JSONObject.NULL);
+                            trackObj.put("bitrate", format.bitrate);
+                            trackObj.put("codec", format.codecs);
+                            trackObj.put("selected", format.selectionFlags);
+                            trackObj.put("format", format.sampleMimeType);
+                        } catch (JSONException e) {
+                            // e.printStackTrace();
+                            Log.e(Player.TAG, "Error adding trackObj info", e);
+                        }
+        
+                        switch (group.getType()) {
+                            case C.TRACK_TYPE_AUDIO:
+                                audioArray.put(trackObj);
+                                break;
+                            case C.TRACK_TYPE_TEXT:
+                                if (format.sampleMimeType == "application/vobsub") {
+                                    continue;
+                                }
+                                
+                                if (format.language == null) {
+                                    continue;
+                                }
+
+                                subtitleArray.put(trackObj);
+                                break;
+                        }
+                    }
+                }
+
+                try {
+                    result.put("audioTracks", audioArray);
+                    result.put("subtitleTracks", subtitleArray);
+                } catch (JSONException e) {
+                    // e.printStackTrace();
+                    Log.e(Player.TAG, "Error adding tracks info", e);
+                }
+        
+                map.put("tracks", result.toString());            
+            }
+        }
+    }
+
+    // public static JSONObject audioTrackeEvent(ExoPlayer player) {
+    //     Map<String, String> map = new HashMap<String, String>();
+    //     Tracks currentTracks = player.getCurrentTracks();
+    //     JSONObject result = new JSONObject();
+    //     JSONArray audioArray = new JSONArray();
+    //     JSONArray subtitleArray = new JSONArray();
+
+    //     if (currentTracks == null) return result;
+
+    //     for (Tracks.Group group : currentTracks.getGroups()) {
+    //         int trackType = group.getType();
+        
+    //         if (trackType == C.TRACK_TYPE_AUDIO) {
+    //             for (int i = 0; i < group.length; i++) {
+    //                 Format format = group.getTrackFormat(i);
+    //                 Log.d("Tracks", "Audio: " + format.language + " | " + format.sampleRate + "Hz");
+    //                 map.put("Audios" + i, "Audio: " + format.language + " | " + format.sampleRate + "Hz");
+    //             }
+    //         }
+        
+    //         if (trackType == C.TRACK_TYPE_TEXT) {
+    //             for (int i = 0; i < group.length; i++) {
+    //                 Format format = group.getTrackFormat(i);
+    //                 Log.d("Tracks", "Subtitle: " + format.language + " | " + format.sampleMimeType);
+    //                 map.put("Subtitles" + i, "Subtitle: " + format.language + " | " + format.sampleMimeType);
+    //             }
+    //         }
+    //     }
+    //     map.put("eventType", "AUDIO_TRACK_EVENT");
+    //     // map.put("controllerVisible", Boolean.toString(controllerVisible));
+    //     return new JSONObject(map);
+    // }
+
+    // // public static JSONObject resolutionEvent(ExoPlayer player, int videoWidth, int videoHeight) {
+    //     Map<String, String> map = new HashMap<String, String>();
+    //     map.put("eventType", "RESOLUTION_EVENT");
+    //     map.put("width", Integer.toString(videoWidth));
+    //     map.put("height", Integer.toString(videoHeight));
+    //     return new JSONObject(map);
+    // }
+
+    // public static JSONObject videoSizeChangedEvent(ExoPlayer player, VideoSize videoSize) {
+    //     Map<String, String> map = new HashMap<String, String>();
+    //     map.put("eventType", "VIDEO_SIZE_CHANGED_EVENT");
+    //     map.put("width", Integer.toString(videoSize.width));
+    //     map.put("height", Integer.toString(videoSize.height));
+    //     // addPlayerState(map, player);
+    //     return new JSONObject(map);
+    // }
+}