| /* |
| * Copyright 2011 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| package com.google.gwt.media.client; |
| |
| import com.google.gwt.dom.client.Document; |
| import com.google.gwt.dom.client.MediaElement; |
| import com.google.gwt.dom.client.SourceElement; |
| import com.google.gwt.event.dom.client.CanPlayThroughEvent; |
| import com.google.gwt.event.dom.client.CanPlayThroughHandler; |
| import com.google.gwt.event.dom.client.EndedEvent; |
| import com.google.gwt.event.dom.client.EndedHandler; |
| import com.google.gwt.event.dom.client.HasAllMediaHandlers; |
| import com.google.gwt.event.dom.client.LoadedMetadataEvent; |
| import com.google.gwt.event.dom.client.LoadedMetadataHandler; |
| import com.google.gwt.event.dom.client.ProgressEvent; |
| import com.google.gwt.event.dom.client.ProgressHandler; |
| import com.google.gwt.event.shared.HandlerRegistration; |
| import com.google.gwt.media.dom.client.MediaError; |
| import com.google.gwt.media.dom.client.TimeRanges; |
| import com.google.gwt.user.client.ui.FocusWidget; |
| |
| /** |
| * <p> |
| * A widget representing a media element. |
| * |
| * <p> |
| * <span style="color:red">Experimental API: This API is still under development |
| * and is subject to change. </span> |
| * </p> |
| */ |
| public abstract class MediaBase extends FocusWidget |
| implements HasAllMediaHandlers { |
| |
| /** |
| * Protected constructor. |
| */ |
| protected MediaBase(MediaElement element) { |
| setElement(element); |
| } |
| |
| @Override |
| public HandlerRegistration addCanPlayThroughHandler( |
| CanPlayThroughHandler handler) { |
| return addBitlessDomHandler(handler, CanPlayThroughEvent.getType()); |
| } |
| |
| @Override |
| public HandlerRegistration addEndedHandler(EndedHandler handler) { |
| return addBitlessDomHandler(handler, EndedEvent.getType()); |
| } |
| |
| @Override |
| public HandlerRegistration addProgressHandler(ProgressHandler handler) { |
| return addBitlessDomHandler(handler, ProgressEvent.getType()); |
| } |
| |
| @Override |
| public HandlerRegistration addLoadedMetadataHandler(LoadedMetadataHandler handler) { |
| return addBitlessDomHandler(handler, LoadedMetadataEvent.getType()); |
| } |
| |
| /** |
| * Add a source element to this media. The browser will request source files |
| * from the server until it finds one it can play. |
| * |
| * <p> |
| * Only use this method if you do not know the type of the source file, as the |
| * browser cannot determine the format from the filename and must download |
| * each source until a compatible one is found. Instead, you should specify |
| * the type for the media using {@link #addSource(String, String)} so the |
| * browser can choose a source file without downloading the file. |
| * </p> |
| * |
| * @param url a String URL |
| * @see #addSource(String, String) |
| */ |
| public SourceElement addSource(String url) { |
| SourceElement elem = Document.get().createSourceElement(); |
| elem.setSrc(url); |
| getElement().appendChild(elem); |
| return elem; |
| } |
| |
| /** |
| * Add a source element to this media, specifying the type (format) of the |
| * media. The browser will choose a supported source file and download it. |
| * |
| * <p> |
| * The type is the format or encoding of the media represented by the source |
| * element. For example, the type of an |
| * {@link com.google.gwt.dom.client.AudioElement} could be one of |
| * {@value com.google.gwt.dom.client.AudioElement#TYPE_OGG}, |
| * {@link com.google.gwt.dom.client.AudioElement#TYPE_MP3}, or |
| * {@link com.google.gwt.dom.client.AudioElement#TYPE_WAV}. |
| * </p> |
| * |
| * <p> |
| * You can also add the codec information to the type, giving the browser even |
| * more information about whether or not it can play the file (Example: " |
| * <code>audio/ogg; codec=vorbis</code>"); |
| * </p> |
| * |
| * @param url a String URL |
| * @param type the type (format) of the media |
| * @see #getSrc() |
| */ |
| public SourceElement addSource(String url, String type) { |
| SourceElement elem = addSource(url); |
| elem.setType(type); |
| return elem; |
| } |
| |
| /** |
| * Returns {@code true} if the native player is capable of playing content of |
| * the given MIME type. |
| * |
| * @param type a String representing a MIME type |
| * @return one of {@link MediaElement#CAN_PLAY_PROBABLY}, |
| * {@link MediaElement#CAN_PLAY_MAYBE}, or |
| * {@link MediaElement#CANNOT_PLAY} |
| */ |
| public String canPlayType(String type) { |
| return getMediaElement().canPlayType(type); |
| } |
| |
| /** |
| * Returns a {@link TimeRanges} object indicating which portions of the source |
| * have been buffered locally. |
| * |
| * @return a {@link TimeRanges} instance, or {@code null}. |
| */ |
| public TimeRanges getBuffered() { |
| return getMediaElement().getBuffered(); |
| } |
| |
| /** |
| * Returns the URL of the current media source, or the empty String if no |
| * source is set. |
| * |
| * @return a String URL |
| */ |
| public String getCurrentSrc() { |
| return getMediaElement().getCurrentSrc(); |
| } |
| |
| /** |
| * Returns the current time within the source media stream. |
| * |
| * @return the time, in seconds, as a double |
| * |
| * @see #setCurrentTime(double) |
| */ |
| public double getCurrentTime() { |
| return getMediaElement().getCurrentTime(); |
| } |
| |
| /** |
| * Returns the default playback rate, where 1.0 corresponds to normal |
| * playback. If no rate has been set, 1.0 is returned. |
| * |
| * @return the current default playback rate, or 1.0 if it has not been set |
| * |
| * @see #setDefaultPlaybackRate(double) |
| */ |
| public double getDefaultPlaybackRate() { |
| return getMediaElement().getDefaultPlaybackRate(); |
| } |
| |
| /** |
| * Returns the duration of the source media stream, in seconds. If the |
| * duration is unknown, {@link Double#NaN} is returned. For unbounded media |
| * streams, {@link Double#POSITIVE_INFINITY} is returned. |
| * |
| * @return a positive duration in seconds, NaN, or Infinity |
| */ |
| public double getDuration() { |
| return getMediaElement().getDuration(); |
| } |
| |
| /** |
| * Returns the type of error that has occurred while attempting to load and |
| * play the media. If no error has occurred, {@code null} is returned. |
| * |
| * @return a {@link MediaError} instance, or {@code null} |
| */ |
| public MediaError getError() { |
| return getMediaElement().getError(); |
| } |
| |
| /** |
| * Returns the time to which the media stream was seeked at the time it was |
| * loaded, in seconds, or 0.0 if the position is unknown. |
| * |
| * @return the initial time, or 0.0 if unknown |
| */ |
| public double getInitialTime() { |
| return getMediaElement().getInitialTime(); |
| } |
| |
| /** |
| * Returns the attached Media Element. |
| * |
| * @return the Media Element |
| */ |
| public MediaElement getMediaElement() { |
| return this.getElement().cast(); |
| } |
| |
| /** |
| * Returns the network state, one of {@link MediaElement#NETWORK_EMPTY}, |
| * {@link MediaElement#NETWORK_IDLE}, {@link MediaElement#NETWORK_LOADING}, or |
| * {@link MediaElement#NETWORK_NO_SOURCE}. |
| * |
| * @return an integer constant indicating the network state |
| * |
| * @see MediaElement#NETWORK_EMPTY |
| * @see MediaElement#NETWORK_IDLE |
| * @see MediaElement#NETWORK_LOADING |
| * @see MediaElement#NETWORK_NO_SOURCE |
| */ |
| public int getNetworkState() { |
| return getMediaElement().getNetworkState(); |
| } |
| |
| /** |
| * Returns the playback rate, where 1.0 corresponds to normal playback. If the |
| * rate has not been set, 1.0 is returned. |
| * |
| * @return the playback rate, if known, otherwise 1.0 |
| * |
| * @see #setPlaybackRate(double) |
| */ |
| public double getPlaybackRate() { |
| return getMediaElement().getPlaybackRate(); |
| } |
| |
| /** |
| * Returns a {@link TimeRanges} object indicating which portions of the source |
| * have been played. |
| * |
| * @return a {@link TimeRanges} instance, or {@code null}. |
| */ |
| public TimeRanges getPlayed() { |
| return getMediaElement().getPlayed(); |
| } |
| |
| /** |
| * Returns the preload setting, one of {@link MediaElement#PRELOAD_AUTO}, |
| * {@link MediaElement#PRELOAD_METADATA}, or |
| * {@link MediaElement#PRELOAD_NONE}. |
| * |
| * @return the preload setting |
| * |
| * @see #setPreload(String) |
| * @see MediaElement#PRELOAD_AUTO |
| * @see MediaElement#PRELOAD_METADATA |
| * @see MediaElement#PRELOAD_NONE |
| */ |
| public String getPreload() { |
| return getMediaElement().getPreload(); |
| } |
| |
| /** |
| * Returns the current state of the media with respect to rendering the |
| * current playback position, as one of the constants |
| * {@link MediaElement#HAVE_CURRENT_DATA}, |
| * {@link MediaElement#HAVE_ENOUGH_DATA}, |
| * {@link MediaElement#HAVE_FUTURE_DATA}, {@link MediaElement#HAVE_METADATA}, |
| * or {@link MediaElement#HAVE_NOTHING} . |
| * |
| * @return an integer constant indicating the ready state |
| * |
| * @see MediaElement#HAVE_CURRENT_DATA |
| * @see MediaElement#HAVE_ENOUGH_DATA |
| * @see MediaElement#HAVE_FUTURE_DATA |
| * @see MediaElement#HAVE_METADATA |
| * @see MediaElement#HAVE_NOTHING |
| */ |
| public int getReadyState() { |
| return getMediaElement().getReadyState(); |
| } |
| |
| /** |
| * Returns a {@link TimeRanges} object indicating which portions of the source |
| * are seekable. |
| * |
| * @return a {@link TimeRanges} instance, or {@code null}. |
| */ |
| public TimeRanges getSeekable() { |
| return getMediaElement().getSeekable(); |
| } |
| |
| /** |
| * Returns the source URL for the media, or {@code null} if none is set. |
| * |
| * @return a String URL or {@code null} |
| * |
| * @see #setSrc(String) |
| */ |
| public String getSrc() { |
| return getMediaElement().getSrc(); |
| } |
| |
| /** |
| * Returns the time corresponding to the zero time in the media timeline, |
| * measured in seconds since midnight, January 1 1970 UTC, or |
| * {@link Double#NaN} if none is specified. |
| * |
| * @return the start time |
| */ |
| public double getStartOffsetTime() { |
| return getMediaElement().getStartOffsetTime(); |
| } |
| |
| /** |
| * Returns the current audio volume setting for the media, as a number between |
| * 0.0 and 1.0. |
| * |
| * @return a number between 0.0 (silent) and 1.0 (loudest) |
| * |
| * @see #setVolume(double) |
| */ |
| public double getVolume() { |
| return getMediaElement().getVolume(); |
| } |
| |
| /** |
| * Returns {@code true} if the media player should display interactive |
| * controls (for example, to control play/pause, seek position, and volume), |
| * {@code false} otherwise. |
| * |
| * @return whether controls should be displayed |
| * |
| * @see #setControls(boolean) |
| */ |
| public boolean hasControls() { |
| return getMediaElement().hasControls(); |
| } |
| |
| /** |
| * Returns {@code true} if playback has reached the end of the media, {@code |
| * false} otherwise. |
| * |
| * @return whether playback has ended |
| */ |
| public boolean hasEnded() { |
| return getMediaElement().hasEnded(); |
| } |
| |
| /** |
| * Returns {@code true} if autoplay is enabled, {@code false} otherwise. When |
| * autoplay is enabled, the user agent will begin playback automatically as |
| * soon as it can do so without stopping. |
| * |
| * @return the autoplay setting |
| * |
| * @see #setAutoplay(boolean) |
| */ |
| public boolean isAutoplay() { |
| return getMediaElement().isAutoplay(); |
| } |
| |
| /** |
| * Returns {@code true} if the user agent is to seek back to the start of the |
| * media once playing has ended, {@code false} otherwise. |
| * |
| * @return the loop setting |
| * |
| * @see #setLoop(boolean) |
| */ |
| public boolean isLoop() { |
| return getMediaElement().isLoop(); |
| } |
| |
| /** |
| * Returns {@code true} if the volume is to be muted (overriding the normal |
| * volume setting), {@code false} otherwise. |
| * |
| * @return the muting setting |
| * |
| * @see #setMuted(boolean) |
| * @see #getVolume() |
| * @see #setVolume(double) |
| */ |
| public boolean isMuted() { |
| return getMediaElement().isMuted(); |
| } |
| |
| /** |
| * Returns {@code true} if playback is paused, {@code false} otherwise. |
| * |
| * @return the paused setting |
| * |
| * @see #pause() |
| * @see #play() |
| */ |
| public boolean isPaused() { |
| return getMediaElement().isPaused(); |
| } |
| |
| /** |
| * Returns {@code true} if the playback position is in the process of changing |
| * discontinuously, e.g., by use of the interactive controls, {@code false} |
| * otherwise. |
| * |
| * @return the seeking status |
| * |
| * @see #setControls(boolean) |
| * @see #hasControls() |
| */ |
| public boolean isSeeking() { |
| return getMediaElement().isSeeking(); |
| } |
| |
| /** |
| * Causes the resource to be loaded. |
| */ |
| public void load() { |
| getMediaElement().load(); |
| } |
| |
| /** |
| * Causes playback of the resource to be paused. |
| */ |
| public void pause() { |
| getMediaElement().pause(); |
| } |
| |
| /** |
| * Causes playback of the resource to be started or resumed. |
| */ |
| public void play() { |
| getMediaElement().play(); |
| } |
| |
| /** |
| * Remove the specified {@link SourceElement} from this media. If the source |
| * element is not a child of this widget, it will not be removed. |
| * |
| * @param source the source element to remove |
| * @see #addSource(String, String) |
| */ |
| public void removeSource(SourceElement source) { |
| getElement().removeChild(source); |
| } |
| |
| /** |
| * Enables or disables autoplay of the resource. |
| * |
| * @param autoplay if {@code true}, enable autoplay |
| * |
| * @see #isAutoplay() |
| */ |
| public void setAutoplay(boolean autoplay) { |
| getMediaElement().setAutoplay(autoplay); |
| } |
| |
| /** |
| * Enables or disables interactive controls. |
| * |
| * @param controls if {@code true}, enable controls |
| * |
| * @see #hasControls() |
| */ |
| public void setControls(boolean controls) { |
| getMediaElement().setControls(controls); |
| } |
| |
| /** |
| * Sets the current playback time within the media stream, in seconds. |
| * |
| * @param time a number within the ranges given by {@link #getSeekable()} |
| * |
| * @see #getCurrentTime() |
| */ |
| public void setCurrentTime(double time) { |
| getMediaElement().setCurrentTime(time); |
| } |
| |
| /** |
| * Sets the default playback rate. |
| * |
| * @param rate a double value |
| * |
| * @see #getDefaultPlaybackRate() |
| */ |
| public void setDefaultPlaybackRate(double rate) { |
| getMediaElement().setDefaultPlaybackRate(rate); |
| } |
| |
| /** |
| * Enables or disables looping. |
| * |
| * @param loop if {@code true}, enable looping |
| * |
| * @see #isLoop() |
| */ |
| public final void setLoop(boolean loop) { |
| getMediaElement().setLoop(loop); |
| } |
| |
| /** |
| * Enables or disables muting. |
| * |
| * @param muted if {@code true}, enable muting |
| * |
| * @see #isMuted() |
| */ |
| public void setMuted(boolean muted) { |
| getMediaElement().setMuted(muted); |
| } |
| |
| /** |
| * Sets the playback rate. |
| * |
| * @param rate a double value |
| * |
| * @see #getPlaybackRate() |
| */ |
| public void setPlaybackRate(double rate) { |
| getMediaElement().setPlaybackRate(rate); |
| } |
| |
| /** |
| * Changes the preload setting to one of {@link MediaElement#PRELOAD_AUTO}, |
| * {@link MediaElement#PRELOAD_METADATA}, or |
| * {@link MediaElement#PRELOAD_NONE}. |
| * |
| * @param preload a String constants |
| * |
| * @see #getPreload() |
| * @see #setPreload(String) |
| * @see MediaElement#PRELOAD_AUTO |
| * @see MediaElement#PRELOAD_METADATA |
| * @see MediaElement#PRELOAD_NONE |
| */ |
| public void setPreload(String preload) { |
| getMediaElement().setPreload(preload); |
| } |
| |
| /** |
| * Sets the source URL for the media. |
| * |
| * <p> |
| * Support for different media types varies between browsers. Instead of using |
| * this method, you should encode your media in multiple formats and add all |
| * of them using {@link #addSource(String, String)} so the browser can choose |
| * a source that it supports. |
| * </p> |
| * |
| * @param url a String URL |
| * |
| * @see #getSrc() |
| * @see #addSource(String, String) |
| */ |
| public void setSrc(String url) { |
| getMediaElement().setSrc(url); |
| } |
| |
| /** |
| * Sets the playback volume. |
| * |
| * @param volume a value between 0.0 (silent) and 1.0 (loudest) |
| * |
| * @see #getVolume() |
| */ |
| public void setVolume(double volume) { |
| getMediaElement().setVolume(volume); |
| } |
| } |