annis.libgui.media.MediaControllerImpl.java Source code

Introduction

Here is the source code for annis.libgui.media.MediaControllerImpl.java

Source

/*
 * Copyright 2012 Corpuslinguistic working group Humboldt University Berlin.
 *
 * 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 annis.libgui.media;

import annis.libgui.VisualizationToggle;
import annis.libgui.media.MediaController;
import annis.libgui.media.MediaPlayer;
import annis.visualizers.LoadableVisualizer;
import com.vaadin.ui.Notification;
import java.io.Serializable;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * Default {@link MediaController} implementation
 * 
 * @author Thomas Krause <krauseto@hu-berlin.de>
 */
public class MediaControllerImpl implements MediaController, Serializable {

    /**
     * Map of all mediaplayers ordered by their result id.
     */
    private Map<String, List<MediaPlayer>> mediaPlayers;
    /**
     * Player that was last used by the user orderd by the result id.
     */
    private Map<String, MediaPlayer> lastUsedPlayer;
    private Map<MediaPlayer, VisualizationToggle> visToggle;

    /** Since everone can call us asynchronously we need a locking mechanism */
    private final ReadWriteLock lock = new ReentrantReadWriteLock();

    public MediaControllerImpl() {
        lock.writeLock().lock();
        try {
            mediaPlayers = new TreeMap<String, List<MediaPlayer>>();
            lastUsedPlayer = new TreeMap<String, MediaPlayer>();
            visToggle = new HashMap<MediaPlayer, VisualizationToggle>();
        } finally {
            lock.writeLock().unlock();
        }
    }

    private MediaPlayer getPlayerForResult(String resultID) {
        List<MediaPlayer> allPlayers = mediaPlayers.get(resultID);
        if (allPlayers != null && allPlayers.size() > 0) {
            MediaPlayer lastPlayer = lastUsedPlayer.get(resultID);
            MediaPlayer player;
            if (lastPlayer == null) {
                player = allPlayers.get(0);
            } else {
                player = lastPlayer;
            }
            return player;
        }

        return null;
    }

    @Override
    public void play(String resultID, double startTime) {
        boolean foundPlayer = false;

        lock.readLock().lock();
        try {
            MediaPlayer player = getPlayerForResult(resultID);

            if (player != null) {
                closeOtherPlayers(player);

                VisualizationToggle t = visToggle.get(player);
                if (t != null) {
                    foundPlayer = true;
                    t.toggleVisualizer(true, new CallbackImpl(player, startTime, null));
                }

            }
        } finally {
            lock.readLock().unlock();
        }
        if (!foundPlayer) {
            Notification.show("Could not play media.",
                    "If this is a match reference open the actual search interface by following the \"Show in ANNIS search interface\" link.",
                    Notification.Type.WARNING_MESSAGE);
        }
    }

    @Override
    public void play(String resultID, double startTime, double endTime) {

        boolean foundPlayer = false;
        lock.readLock().lock();
        try {
            MediaPlayer player = getPlayerForResult(resultID);

            if (player != null) {
                closeOtherPlayers(player);

                VisualizationToggle t = visToggle.get(player);
                if (t != null) {
                    foundPlayer = true;
                    t.toggleVisualizer(true, new CallbackImpl(player, startTime, endTime));
                }
            }
        } finally {
            lock.readLock().unlock();
        }
        if (!foundPlayer) {
            Notification.show("Could not play media.",
                    "If this is a match reference open the actual search interface by following the \"Show in ANNIS search interface\" link.",
                    Notification.Type.WARNING_MESSAGE);
        }
    }

    @Override
    public void closeOtherPlayers(MediaPlayer doNotCloseThisOne) {
        for (List<MediaPlayer> playersForID : mediaPlayers.values()) {
            for (MediaPlayer player : playersForID) {
                if (player != doNotCloseThisOne) {
                    VisualizationToggle t = visToggle.get(player);
                    if (t != null) {
                        t.toggleVisualizer(false, null);
                    }
                }
            }
        }
    }

    @Override
    public void addMediaPlayer(MediaPlayer player, String resultID, VisualizationToggle toggle) {
        // some sanity checks
        if (resultID == null) {
            return;
        }

        lock.writeLock().lock();
        try {
            // add new list if no player with this number yet
            if (mediaPlayers.get(resultID) == null) {
                mediaPlayers.put(resultID, new LinkedList<MediaPlayer>());
            }

            // actually adding (we do not check if the player is already in the list)
            List<MediaPlayer> playerList = mediaPlayers.get(resultID);
            playerList.add(player);

            visToggle.put(player, toggle);
        } finally {
            lock.writeLock().unlock();
        }
    }

    @Override
    public void clearMediaPlayers() {
        lock.writeLock().lock();
        try {
            mediaPlayers.clear();
            visToggle.clear();
            lastUsedPlayer.clear();
        } finally {
            lock.writeLock().unlock();
        }
    }

    public static class CallbackImpl implements LoadableVisualizer.Callback {

        private MediaPlayer player;
        private Double startTime;
        private Double endTime;

        public CallbackImpl(MediaPlayer player, Double startTime, Double endTime) {
            this.player = player;
            this.startTime = startTime;
            this.endTime = endTime;
        }

        @Override
        public void visualizerLoaded(LoadableVisualizer origin) {
            if (player != null && startTime != null) {
                if (endTime == null) {
                    player.play(startTime);
                } else {
                    player.play(startTime, endTime);
                }
            }
        }

    }
}