/*****************************************************************************
|
* MediaList.java
|
*****************************************************************************
|
* Copyright © 2013 VLC authors and VideoLAN
|
* Copyright © 2013 Edward Wang
|
*
|
* This program is free software; you can redistribute it and/or modify it
|
* under the terms of the GNU Lesser General Public License as published by
|
* the Free Software Foundation; either version 2.1 of the License, or
|
* (at your option) any later version.
|
*
|
* This program is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* GNU Lesser General Public License for more details.
|
*
|
* You should have received a copy of the GNU Lesser General Public License
|
* along with this program; if not, write to the Free Software Foundation,
|
* Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
|
*****************************************************************************/
|
package org.videolan.libvlc;
|
|
import java.util.ArrayList;
|
|
import android.os.Bundle;
|
|
/**
|
* Java/JNI wrapper for the libvlc_media_list_t structure.
|
*/
|
public class MediaList {
|
private static final String TAG = "VLC/LibVLC/MediaList";
|
|
/* Since the libvlc_media_t is not created until the media plays, we have
|
* to cache them here. */
|
private class MediaHolder {
|
Media m;
|
boolean noVideo; // default false
|
boolean noHardwareAcceleration; // default false
|
|
public MediaHolder(Media media) {
|
m = media; noVideo = false; noHardwareAcceleration = false;
|
}
|
public MediaHolder(Media m_, boolean noVideo_, boolean noHardwareAcceleration_) {
|
m = m_; noVideo = noVideo_; noHardwareAcceleration = noHardwareAcceleration_;
|
}
|
}
|
|
/* TODO: add locking */
|
private ArrayList<MediaHolder> mInternalList;
|
private LibVLC mLibVLC; // Used to create new objects that require a libvlc instance
|
private EventHandler mEventHandler;
|
|
public MediaList(LibVLC libVLC) {
|
mEventHandler = new EventHandler(); // used in init() below to fire events at the correct targets
|
mInternalList = new ArrayList<MediaHolder>();
|
mLibVLC = libVLC;
|
}
|
|
/**
|
* Adds a media URI to the media list.
|
*
|
* @param mrl
|
* The MRL to add. Must be a location and not a path.
|
* {@link LibVLC#PathToURI(String)} can be used to convert a path
|
* to a MRL.
|
*/
|
public void add(String mrl) {
|
add(new Media(mLibVLC, mrl));
|
}
|
public void add(Media media) {
|
add(media, false, false);
|
}
|
public void add(Media media, boolean noVideo) {
|
add(media, noVideo, false);
|
}
|
public void add(Media media, boolean noVideo, boolean noHardwareAcceleration) {
|
mInternalList.add(new MediaHolder(media, noVideo, noHardwareAcceleration));
|
signal_list_event(EventHandler.CustomMediaListItemAdded, mInternalList.size() - 1, media.getLocation());
|
}
|
|
/**
|
* Clear the media list. (remove all media)
|
*/
|
public void clear() {
|
// Signal to observers of media being deleted.
|
for(int i = 0; i < mInternalList.size(); i++) {
|
signal_list_event(EventHandler.CustomMediaListItemDeleted, i, mInternalList.get(i).m.getLocation());
|
}
|
mInternalList.clear();
|
}
|
|
private boolean isValid(int position) {
|
return position >= 0 && position < mInternalList.size();
|
}
|
|
/**
|
* This function checks the currently playing media for subitems at the given
|
* position, and if any exist, it will expand them at the same position
|
* and replace the current media.
|
*
|
* @param position The position to expand
|
* @return -1 if no subitems were found, 0 if subitems were expanded
|
*/
|
public int expandMedia(int position) {
|
ArrayList<String> children = new ArrayList<String>();
|
int ret = expandMedia(mLibVLC, position, children);
|
if(ret == 0) {
|
mEventHandler.callback(EventHandler.CustomMediaListExpanding, new Bundle());
|
this.remove(position);
|
for(String mrl : children) {
|
this.insert(position, mrl);
|
}
|
mEventHandler.callback(EventHandler.CustomMediaListExpandingEnd, new Bundle());
|
}
|
return ret;
|
}
|
private native int expandMedia(LibVLC libvlc_instance, int position, ArrayList<String> children);
|
|
public void loadPlaylist(String mrl) {
|
ArrayList<String> items = new ArrayList<String>();
|
loadPlaylist(mLibVLC, mrl, items);
|
this.clear();
|
for(String item : items) {
|
this.add(item);
|
}
|
}
|
private native void loadPlaylist(LibVLC libvlc_instance, String mrl, ArrayList<String> items);
|
|
public void insert(int position, String mrl) {
|
insert(position, new Media(mLibVLC, mrl));
|
}
|
public void insert(int position, Media media) {
|
mInternalList.add(position, new MediaHolder(media));
|
signal_list_event(EventHandler.CustomMediaListItemAdded, position, media.getLocation());
|
}
|
|
/**
|
* Move a media from one position to another
|
*
|
* @param startPosition start position
|
* @param endPosition end position
|
* @throws IndexOutOfBoundsException
|
*/
|
public void move(int startPosition, int endPosition) {
|
if (!(isValid(startPosition)
|
&& endPosition >= 0 && endPosition <= mInternalList.size()))
|
throw new IndexOutOfBoundsException("Indexes out of range");
|
|
MediaHolder toMove = mInternalList.get(startPosition);
|
mInternalList.remove(startPosition);
|
if (startPosition >= endPosition)
|
mInternalList.add(endPosition, toMove);
|
else
|
mInternalList.add(endPosition - 1, toMove);
|
Bundle b = new Bundle();
|
b.putInt("index_before", startPosition);
|
b.putInt("index_after", endPosition);
|
mEventHandler.callback(EventHandler.CustomMediaListItemMoved, b);
|
}
|
|
public void remove(int position) {
|
if (!isValid(position))
|
return;
|
String uri = mInternalList.get(position).m.getLocation();
|
mInternalList.remove(position);
|
signal_list_event(EventHandler.CustomMediaListItemDeleted, position, uri);
|
}
|
|
public int size() {
|
return mInternalList.size();
|
}
|
|
public Media getMedia(int position) {
|
if (!isValid(position))
|
return null;
|
return mInternalList.get(position).m;
|
}
|
|
/**
|
* @param position The index of the media in the list
|
* @return null if not found
|
*/
|
public String getMRL(int position) {
|
if (!isValid(position))
|
return null;
|
return mInternalList.get(position).m.getLocation();
|
}
|
|
public String[] getMediaOptions(int position) {
|
boolean noHardwareAcceleration = mLibVLC.getHardwareAcceleration() == 0;
|
boolean noVideo = false;
|
if (isValid(position))
|
{
|
if (!noHardwareAcceleration)
|
noHardwareAcceleration = mInternalList.get(position).noHardwareAcceleration;
|
noVideo = mInternalList.get(position).noVideo;
|
}
|
ArrayList<String> options = new ArrayList<String>();
|
|
if (!noHardwareAcceleration) {
|
/*
|
* Set higher caching values if using iomx decoding, since some omx
|
* decoders have a very high latency, and if the preroll data isn't
|
* enough to make the decoder output a frame, the playback timing gets
|
* started too soon, and every decoded frame appears to be too late.
|
* On Nexus One, the decoder latency seems to be 25 input packets
|
* for 320x170 H.264, a few packets less on higher resolutions.
|
* On Nexus S, the decoder latency seems to be about 7 packets.
|
*/
|
options.add(":file-caching=1500");
|
options.add(":network-caching=1500");
|
options.add(":codec=mediacodec,iomx,all");
|
}
|
if (noVideo)
|
options.add(":no-video");
|
|
return options.toArray(new String[options.size()]);
|
}
|
|
public EventHandler getEventHandler() {
|
return mEventHandler;
|
}
|
|
@Override
|
public String toString() {
|
StringBuilder sb = new StringBuilder();
|
sb.append("LibVLC Media List: {");
|
for(int i = 0; i < size(); i++) {
|
sb.append(((Integer)i).toString());
|
sb.append(": ");
|
sb.append(getMRL(i));
|
sb.append(", ");
|
}
|
sb.append("}");
|
return sb.toString();
|
}
|
|
private void signal_list_event(int event, int position, String uri) {
|
Bundle b = new Bundle();
|
b.putString("item_uri", uri);
|
b.putInt("item_index", position);
|
mEventHandler.callback(event, b);
|
}
|
}
|
