mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-08 20:47:44 +00:00
232 lines
8.6 KiB
Java
232 lines
8.6 KiB
Java
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
* You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
package org.mozilla.gecko;
|
|
|
|
import org.mozilla.gecko.util.EventCallback;
|
|
import org.mozilla.gecko.util.NativeEventListener;
|
|
import org.mozilla.gecko.util.NativeJSObject;
|
|
|
|
import org.json.JSONArray;
|
|
import org.json.JSONObject;
|
|
import org.json.JSONException;
|
|
|
|
import android.content.Context;
|
|
import android.support.v7.media.MediaControlIntent;
|
|
import android.support.v7.media.MediaRouteSelector;
|
|
import android.support.v7.media.MediaRouter;
|
|
import android.support.v7.media.MediaRouter.RouteInfo;
|
|
import android.util.Log;
|
|
|
|
import java.util.HashMap;
|
|
|
|
/* Wraper for different MediaRouter types supproted by Android. i.e. Chromecast, Miracast, etc. */
|
|
interface GeckoMediaPlayer {
|
|
public JSONObject toJSON();
|
|
public void load(String title, String url, String type, EventCallback callback);
|
|
public void play(EventCallback callback);
|
|
public void pause(EventCallback callback);
|
|
public void stop(EventCallback callback);
|
|
public void start(EventCallback callback);
|
|
public void end(EventCallback callback);
|
|
}
|
|
|
|
/* Manages a list of GeckoMediaPlayers methods (i.e. Chromecast/Miracast). Routes messages
|
|
* from Gecko to the correct caster based on the id of the display
|
|
*/
|
|
class MediaPlayerManager implements NativeEventListener,
|
|
GeckoAppShell.AppStateListener {
|
|
private static final String LOGTAG = "GeckoMediaPlayerManager";
|
|
|
|
private static final boolean SHOW_DEBUG = false;
|
|
// Simplified debugging interfaces
|
|
private static void debug(String msg, Exception e) {
|
|
if (SHOW_DEBUG) {
|
|
Log.e(LOGTAG, msg, e);
|
|
}
|
|
}
|
|
|
|
private static void debug(String msg) {
|
|
if (SHOW_DEBUG) {
|
|
Log.d(LOGTAG, msg);
|
|
}
|
|
}
|
|
|
|
private final Context context;
|
|
private final MediaRouter mediaRouter;
|
|
private final HashMap<String, GeckoMediaPlayer> displays = new HashMap<String, GeckoMediaPlayer>();
|
|
private static MediaPlayerManager instance;
|
|
|
|
public static void init(Context context) {
|
|
if (instance != null) {
|
|
debug("MediaPlayerManager initialized twice");
|
|
}
|
|
|
|
instance = new MediaPlayerManager(context);
|
|
}
|
|
|
|
private MediaPlayerManager(Context context) {
|
|
this.context = context;
|
|
|
|
if (context instanceof GeckoApp) {
|
|
GeckoApp app = (GeckoApp) context;
|
|
app.addAppStateListener(this);
|
|
}
|
|
|
|
mediaRouter = MediaRouter.getInstance(context);
|
|
EventDispatcher.getInstance().registerGeckoThreadListener(this, "MediaPlayer:Load",
|
|
"MediaPlayer:Start",
|
|
"MediaPlayer:Stop",
|
|
"MediaPlayer:Play",
|
|
"MediaPlayer:Pause",
|
|
"MediaPlayer:Get",
|
|
"MediaPlayer:End");
|
|
}
|
|
|
|
public static void onDestroy() {
|
|
if (instance == null) {
|
|
return;
|
|
}
|
|
|
|
EventDispatcher.getInstance().unregisterGeckoThreadListener(instance, "MediaPlayer:Load",
|
|
"MediaPlayer:Start",
|
|
"MediaPlayer:Stop",
|
|
"MediaPlayer:Play",
|
|
"MediaPlayer:Pause",
|
|
"MediaPlayer:Get",
|
|
"MediaPlayer:End");
|
|
if (instance.context instanceof GeckoApp) {
|
|
GeckoApp app = (GeckoApp) instance.context;
|
|
app.removeAppStateListener(instance);
|
|
}
|
|
}
|
|
|
|
// GeckoEventListener implementation
|
|
@Override
|
|
public void handleMessage(String event, final NativeJSObject message, final EventCallback callback) {
|
|
debug(event);
|
|
|
|
if ("MediaPlayer:Get".equals(event)) {
|
|
final JSONObject result = new JSONObject();
|
|
final JSONArray disps = new JSONArray();
|
|
for (GeckoMediaPlayer disp : displays.values()) {
|
|
try {
|
|
disps.put(disp.toJSON());
|
|
} catch(Exception ex) {
|
|
// This may happen if the device isn't a real Chromecast,
|
|
// for example Firefly casting devices.
|
|
Log.e(LOGTAG, "Couldn't create JSON for display", ex);
|
|
}
|
|
}
|
|
|
|
try {
|
|
result.put("displays", disps);
|
|
} catch(JSONException ex) {
|
|
Log.i(LOGTAG, "Error sending displays", ex);
|
|
}
|
|
|
|
callback.sendSuccess(result);
|
|
return;
|
|
}
|
|
|
|
final GeckoMediaPlayer display = displays.get(message.getString("id"));
|
|
if (display == null) {
|
|
Log.e(LOGTAG, "Couldn't find a display for this id");
|
|
callback.sendError(null);
|
|
return;
|
|
}
|
|
|
|
if ("MediaPlayer:Play".equals(event)) {
|
|
display.play(callback);
|
|
} else if ("MediaPlayer:Start".equals(event)) {
|
|
display.start(callback);
|
|
} else if ("MediaPlayer:Stop".equals(event)) {
|
|
display.stop(callback);
|
|
} else if ("MediaPlayer:Pause".equals(event)) {
|
|
display.pause(callback);
|
|
} else if ("MediaPlayer:End".equals(event)) {
|
|
display.end(callback);
|
|
} else if ("MediaPlayer:Load".equals(event)) {
|
|
final String url = message.optString("source", "");
|
|
final String type = message.optString("type", "video/mp4");
|
|
final String title = message.optString("title", "");
|
|
display.load(title, url, type, callback);
|
|
}
|
|
}
|
|
|
|
private final MediaRouter.Callback callback = new MediaRouter.Callback() {
|
|
@Override
|
|
public void onRouteRemoved(MediaRouter router, RouteInfo route) {
|
|
debug("onRouteRemoved: route=" + route);
|
|
displays.remove(route.getId());
|
|
}
|
|
|
|
@SuppressWarnings("unused")
|
|
public void onRouteSelected(MediaRouter router, int type, MediaRouter.RouteInfo route) {
|
|
}
|
|
|
|
// These methods aren't used by the support version Media Router
|
|
@SuppressWarnings("unused")
|
|
public void onRouteUnselected(MediaRouter router, int type, RouteInfo route) {
|
|
}
|
|
|
|
@Override
|
|
public void onRoutePresentationDisplayChanged(MediaRouter router, RouteInfo route) {
|
|
}
|
|
|
|
@Override
|
|
public void onRouteVolumeChanged(MediaRouter router, RouteInfo route) {
|
|
}
|
|
|
|
@Override
|
|
public void onRouteAdded(MediaRouter router, MediaRouter.RouteInfo route) {
|
|
debug("onRouteAdded: route=" + route);
|
|
GeckoMediaPlayer display = getMediaPlayerForRoute(route);
|
|
if (display != null) {
|
|
displays.put(route.getId(), display);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onRouteChanged(MediaRouter router, MediaRouter.RouteInfo route) {
|
|
debug("onRouteChanged: route=" + route);
|
|
GeckoMediaPlayer display = displays.get(route.getId());
|
|
if (display != null) {
|
|
displays.put(route.getId(), display);
|
|
}
|
|
}
|
|
};
|
|
|
|
private GeckoMediaPlayer getMediaPlayerForRoute(MediaRouter.RouteInfo route) {
|
|
try {
|
|
if (route.supportsControlCategory(MediaControlIntent.CATEGORY_REMOTE_PLAYBACK)) {
|
|
return new ChromeCast(context, route);
|
|
}
|
|
} catch(Exception ex) {
|
|
debug("Error handling presentation", ex);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/* Implementing GeckoAppShell.AppStateListener */
|
|
@Override
|
|
public void onPause() {
|
|
mediaRouter.removeCallback(callback);
|
|
}
|
|
|
|
@Override
|
|
public void onResume() {
|
|
MediaRouteSelector selectorBuilder = new MediaRouteSelector.Builder()
|
|
.addControlCategory(MediaControlIntent.CATEGORY_LIVE_VIDEO)
|
|
.addControlCategory(MediaControlIntent.CATEGORY_REMOTE_PLAYBACK)
|
|
.build();
|
|
mediaRouter.addCallback(selectorBuilder, callback, MediaRouter.CALLBACK_FLAG_REQUEST_DISCOVERY);
|
|
}
|
|
|
|
@Override
|
|
public void onOrientationChanged() { }
|
|
|
|
}
|