The Tor Browser: mobile/android/chrome/content/CastingApps.js@6474c204b198 (annotated)

mobile/android/chrome/content/CastingApps.js@6474c204b198 (annotated)

mobile/android/chrome/content/CastingApps.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* 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/. */
 "use strict";
 var CastingApps = {
   _castMenuId: -1,
   init: function ca_init() {
     if (!this.isEnabled()) {
       return;
     }
     // Register a service target
     SimpleServiceDiscovery.registerTarget("roku:ecp", function(aService, aApp) {
       Cu.import("resource://gre/modules/RokuApp.jsm");
       return new RokuApp(aService, "FirefoxTest");
     });
     // Search for devices continuously every 120 seconds
     SimpleServiceDiscovery.search(120 * 1000);
     this._castMenuId = NativeWindow.contextmenus.add(
       Strings.browser.GetStringFromName("contextmenu.castToScreen"),
       this.filterCast,
       this.openExternal.bind(this)
     );
     Services.obs.addObserver(this, "Casting:Play", false);
     Services.obs.addObserver(this, "Casting:Pause", false);
     Services.obs.addObserver(this, "Casting:Stop", false);
     BrowserApp.deck.addEventListener("TabSelect", this, true);
     BrowserApp.deck.addEventListener("pageshow", this, true);
     BrowserApp.deck.addEventListener("playing", this, true);
     BrowserApp.deck.addEventListener("ended", this, true);
   },
   uninit: function ca_uninit() {
     BrowserApp.deck.removeEventListener("TabSelect", this, true);
     BrowserApp.deck.removeEventListener("pageshow", this, true);
     BrowserApp.deck.removeEventListener("playing", this, true);
     BrowserApp.deck.removeEventListener("ended", this, true);
     Services.obs.removeObserver(this, "Casting:Play");
     Services.obs.removeObserver(this, "Casting:Pause");
     Services.obs.removeObserver(this, "Casting:Stop");
     NativeWindow.contextmenus.remove(this._castMenuId);
   },
   isEnabled: function isEnabled() {
     return Services.prefs.getBoolPref("browser.casting.enabled");
   },
   observe: function (aSubject, aTopic, aData) {
     switch (aTopic) {
       case "Casting:Play":
         if (this.session && this.session.remoteMedia.status == "paused") {
           this.session.remoteMedia.play();
         }
         break;
       case "Casting:Pause":
         if (this.session && this.session.remoteMedia.status == "started") {
           this.session.remoteMedia.pause();
         }
         break;
       case "Casting:Stop":
         if (this.session) {
           this.closeExternal();
         }
         break;
     }
   },
   handleEvent: function(aEvent) {
     switch (aEvent.type) {
       case "TabSelect": {
         let tab = BrowserApp.getTabForBrowser(aEvent.target);
         this._updatePageActionForTab(tab, aEvent);
         break;
       }
       case "pageshow": {
         let tab = BrowserApp.getTabForWindow(aEvent.originalTarget.defaultView);
         this._updatePageActionForTab(tab, aEvent);
         break;
       }
       case "playing":
       case "ended": {
         let video = aEvent.target;
         if (video instanceof HTMLVideoElement) {
           // If playing, send the <video>, but if ended we send nothing to shutdown the pageaction
           this._updatePageActionForVideo(aEvent.type === "playing" ? video : null);
         }
         break;
       }
     }
   },
   _sendEventToVideo: function _sendEventToVideo(aElement, aData) {
     let event = aElement.ownerDocument.createEvent("CustomEvent");
     event.initCustomEvent("media-videoCasting", false, true, JSON.stringify(aData));
     aElement.dispatchEvent(event);
   },
   handleVideoBindingAttached: function handleVideoBindingAttached(aTab, aEvent) {
     // Let's figure out if we have everything needed to cast a video. The binding
     // defaults to |false| so we only need to send an event if |true|.
     let video = aEvent.target;
     if (!video instanceof HTMLVideoElement) {
       return;
     }
     if (SimpleServiceDiscovery.services.length == 0) {
       return;
     }
     if (!this.getVideo(video, 0, 0)) {
       return;
     }
     // Let the binding know casting is allowed
     this._sendEventToVideo(video, { allow: true });
   },
   handleVideoBindingCast: function handleVideoBindingCast(aTab, aEvent) {
     // The binding wants to start a casting session
     let video = aEvent.target;
     if (!video instanceof HTMLVideoElement) {
       return;
     }
     // Close an existing session first. closeExternal has checks for an exsting
     // session and handles remote and video binding shutdown.
     this.closeExternal();
     // Start the new session
     this.openExternal(video, 0, 0);
   },
   makeURI: function makeURI(aURL, aOriginCharset, aBaseURI) {
     return Services.io.newURI(aURL, aOriginCharset, aBaseURI);
   },
   getVideo: function(aElement, aX, aY) {
     // Fast path: Is the given element a video element
     let video = this._getVideo(aElement);
     if (video) {
       return video;
     }
     // The context menu system will keep walking up the DOM giving us a chance
     // to find an element we match. When it hits <html> things can go BOOM.
     try {
       // Maybe this is an overlay, with the video element under it
       // Use the (x, y) location to guess at a <video> element
       let elements = aElement.ownerDocument.querySelectorAll("video");
       for (let element of elements) {
         // Look for a video element contained in the overlay bounds
         let rect = element.getBoundingClientRect();
         if (aY >= rect.top && aX >= rect.left && aY <= rect.bottom && aX <= rect.right) {
           video = this._getVideo(element);
           if (video) {
             break;
           }
         }
       }
     } catch(e) {}
     // Could be null
     return video;
   },
   _getVideo: function(aElement) {
     // Given the hardware support for H264, let's only look for 'mp4' sources
     if (!aElement instanceof HTMLVideoElement) {
       return null;
     }
     function allowableExtension(aURI) {
       if (aURI && aURI instanceof Ci.nsIURL) {
         return (aURI.fileExtension == "mp4");
       }
       return false;
     }
     // Grab the poster attribute from the <video>
     let posterURL = aElement.poster;
     // First, look to see if the <video> has a src attribute
     let sourceURL = aElement.src;
     // If empty, try the currentSrc
     if (!sourceURL) {
       sourceURL = aElement.currentSrc;
     }
     if (sourceURL) {
       // Use the file extension to guess the mime type
       let sourceURI = this.makeURI(sourceURL, null, this.makeURI(aElement.baseURI));
       if (allowableExtension(sourceURI)) {
         return { element: aElement, source: sourceURI.spec, poster: posterURL };
       }
     }
     // Next, look to see if there is a <source> child element that meets
     // our needs
     let sourceNodes = aElement.getElementsByTagName("source");
     for (let sourceNode of sourceNodes) {
       let sourceURI = this.makeURI(sourceNode.src, null, this.makeURI(sourceNode.baseURI));
       // Using the type attribute is our ideal way to guess the mime type. Otherwise,
       // fallback to using the file extension to guess the mime type
       if (sourceNode.type == "video/mp4" || allowableExtension(sourceURI)) {
         return { element: aElement, source: sourceURI.spec, poster: posterURL };
       }
     }
     return null;
   },
   filterCast: {
     matches: function(aElement, aX, aY) {
       if (SimpleServiceDiscovery.services.length == 0)
         return false;
       let video = CastingApps.getVideo(aElement, aX, aY);
       if (CastingApps.session) {
         return (video && CastingApps.session.data.source != video.source);
       }
       return (video != null);
     }
   },
   pageAction: {
     click: function() {
       // Since this is a pageaction, we use the selected browser
       let browser = BrowserApp.selectedBrowser;
       if (!browser) {
         return;
       }
       // Look for a castable <video> that is playing, and start casting it
       let videos = browser.contentDocument.querySelectorAll("video");
       for (let video of videos) {
         if (!video.paused && video.mozAllowCasting) {
           CastingApps.openExternal(video, 0, 0);
           return;
         }
       }
     }
   },
   _findCastableVideo: function _findCastableVideo(aBrowser) {
       // Scan for a <video> being actively cast. Also look for a castable <video>
       // on the page.
       let castableVideo = null;
       let videos = aBrowser.contentDocument.querySelectorAll("video");
       for (let video of videos) {
         if (video.mozIsCasting) {
           // This <video> is cast-active. Break out of loop.
           return video;
         }
         if (!video.paused && video.mozAllowCasting) {
           // This <video> is cast-ready. Keep looking so cast-active could be found.
           castableVideo = video;
         }
       }
       // Could be null
       return castableVideo;
   },
   _updatePageActionForTab: function _updatePageActionForTab(aTab, aEvent) {
     // We only care about events on the selected tab
     if (aTab != BrowserApp.selectedTab) {
       return;
     }
     // Update the page action, scanning for a castable <video>
     this._updatePageAction();
   },
   _updatePageActionForVideo: function _updatePageActionForVideo(aVideo) {
     this._updatePageAction(aVideo);
   },
   _updatePageAction: function _updatePageAction(aVideo) {
     // Remove any exising pageaction first, in case state changes or we don't have
     // a castable video
     if (this.pageAction.id) {
       NativeWindow.pageactions.remove(this.pageAction.id);
       delete this.pageAction.id;
     }
     if (!aVideo) {
       aVideo = this._findCastableVideo(BrowserApp.selectedBrowser);
       if (!aVideo) {
         return;
       }
     }
     // We only show pageactions if the <video> is from the selected tab
     if (BrowserApp.selectedTab != BrowserApp.getTabForWindow(aVideo.ownerDocument.defaultView.top)) {
       return;
     }
     // We check for two state here:
     // 1. The video is actively being cast
     // 2. The video is allowed to be cast and is currently playing
     // Both states have the same action: Show the cast page action
     if (aVideo.mozIsCasting) {
       this.pageAction.id = NativeWindow.pageactions.add({
         title: Strings.browser.GetStringFromName("contextmenu.castToScreen"),
         icon: "drawable://casting_active",
         clickCallback: this.pageAction.click,
         important: true
       });
     } else if (aVideo.mozAllowCasting) {
       this.pageAction.id = NativeWindow.pageactions.add({
         title: Strings.browser.GetStringFromName("contextmenu.castToScreen"),
         icon: "drawable://casting",
         clickCallback: this.pageAction.click,
         important: true
       });
     }
   },
   prompt: function(aCallback) {
     let items = [];
     SimpleServiceDiscovery.services.forEach(function(aService) {
       let item = {
         label: aService.friendlyName,
         selected: false
       };
       items.push(item);
     });
     let prompt = new Prompt({
       title: Strings.browser.GetStringFromName("casting.prompt")
     }).setSingleChoiceItems(items).show(function(data) {
       let selected = data.button;
       let service = selected == -1 ? null : SimpleServiceDiscovery.services[selected];
       if (aCallback)
         aCallback(service);
     });
   },
   openExternal: function(aElement, aX, aY) {
     // Start a second screen media service
     let video = this.getVideo(aElement, aX, aY);
     if (!video) {
       return;
     }
     this.prompt(function(aService) {
       if (!aService)
         return;
       // Make sure we have a player app for the given service
       let app = SimpleServiceDiscovery.findAppForService(aService, "video-sharing");
       if (!app)
         return;
       video.title = aElement.ownerDocument.defaultView.top.document.title;
       if (video.element) {
         // If the video is currently playing on the device, pause it
         if (!video.element.paused) {
           video.element.pause();
         }
       }
       app.stop(function() {
         app.start(function(aStarted) {
           if (!aStarted) {
             dump("CastingApps: Unable to start app");
             return;
           }
           app.remoteMedia(function(aRemoteMedia) {
             if (!aRemoteMedia) {
               dump("CastingApps: Failed to create remotemedia");
               return;
             }
             this.session = {
               service: aService,
               app: app,
               remoteMedia: aRemoteMedia,
               data: {
                 title: video.title,
                 source: video.source,
                 poster: video.poster
               },
               videoRef: Cu.getWeakReference(video.element)
             };
           }.bind(this), this);
         }.bind(this));
       }.bind(this));
     }.bind(this));
   },
   closeExternal: function() {
     if (!this.session) {
       return;
     }
     this.session.remoteMedia.shutdown();
     this.session.app.stop();
     let video = this.session.videoRef.get();
     if (video) {
       this._sendEventToVideo(video, { active: false });
       this._updatePageAction();
     }
     delete this.session;
   },
   // RemoteMedia callback API methods
   onRemoteMediaStart: function(aRemoteMedia) {
     if (!this.session) {
       return;
     }
     aRemoteMedia.load(this.session.data);
     sendMessageToJava({ type: "Casting:Started", device: this.session.service.friendlyName });
     let video = this.session.videoRef.get();
     if (video) {
       this._sendEventToVideo(video, { active: true });
       this._updatePageAction(video);
     }
   },
   onRemoteMediaStop: function(aRemoteMedia) {
     sendMessageToJava({ type: "Casting:Stopped" });
   },
   onRemoteMediaStatus: function(aRemoteMedia) {
     if (!this.session) {
       return;
     }
     let status = aRemoteMedia.status;
     if (status == "completed") {
       this.closeExternal();
     }
   }
 };