/*
* Copyright 2010 Busa Blade 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.
*
* This work is a derivative work based on copyrighted library javampd by Bill Findeisen
* The underlying mechanisms for talking to the MPD server is wholly derived from
* the javampd library and has been imported and modified to work better in an Android
* environment.
*
* @author Bill Findeisen
* @author busa[dot]blade[at]gmail[dot]com
* @version 1.0
*/
package com.client.daemon.player.music.androidmpd.services;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.TimerTask;
import android.util.Log;
import com.client.daemon.player.music.AndroidMPC;
import com.client.daemon.player.music.androidmpd.MPD;
import com.client.daemon.player.music.androidmpd.MPDPlayer;
import com.client.daemon.player.music.androidmpd.MPDPlaylist;
import com.client.daemon.player.music.androidmpd.events.AnalogChangeEvent;
import com.client.daemon.player.music.androidmpd.events.AudioChangeEvent;
import com.client.daemon.player.music.androidmpd.events.ConnectionChangeEvent;
import com.client.daemon.player.music.androidmpd.events.CurrentlyPlayingSongChangeEvent;
import com.client.daemon.player.music.androidmpd.events.MPDChangeEvent;
import com.client.daemon.player.music.androidmpd.events.MPDErrorEvent;
import com.client.daemon.player.music.androidmpd.events.PlayerChangeEvent;
import com.client.daemon.player.music.androidmpd.events.PlayerStateChangeEvent;
import com.client.daemon.player.music.androidmpd.events.PlaylistChangeEvent;
import com.client.daemon.player.music.androidmpd.exception.MPDConnectionException;
import com.client.daemon.player.music.androidmpd.exception.MPDPlaylistException;
import com.client.daemon.player.music.androidmpd.exception.MPDResponseException;
import com.client.daemon.player.music.androidmpd.listeners.AnalogChangeListener;
import com.client.daemon.player.music.androidmpd.listeners.AudioChangeListener;
import com.client.daemon.player.music.androidmpd.listeners.ConnectionChangeListener;
import com.client.daemon.player.music.androidmpd.listeners.CurrentlyPlayingSongChangeListener;
import com.client.daemon.player.music.androidmpd.listeners.MPDChangeListener;
import com.client.daemon.player.music.androidmpd.listeners.MPDErrorListener;
import com.client.daemon.player.music.androidmpd.listeners.PlayerChangeListener;
import com.client.daemon.player.music.androidmpd.listeners.PlayerStateChangeListener;
import com.client.daemon.player.music.androidmpd.listeners.PlaylistChangeListener;
import com.client.daemon.player.music.androidmpd.objects.MPDSong;
public abstract class MPDEventMonitor extends TimerTask
{
protected MPD mpd;
private boolean connectedState = true;
private int checkConnCount = 0;
private boolean cacheing;
private Calendar lastCacheDate;
private long cacheMillis = 0l;
private Object cacheLock = null;
private Object initialization_lock = null;
private volatile boolean initialized = false;
private volatile Hashtable <String, String> cachedStatus = null;
private ArrayList<ConnectionChangeListener> connectionChangeListeners;
private ArrayList<CurrentlyPlayingSongChangeListener> currentlyPlayingSongChangeListeners;
private ArrayList<MPDChangeListener> mpdChangeListeners;
private ArrayList<MPDErrorListener> mpdErrorListeners;
private ArrayList<PlayerChangeListener> playerChangeListeners;
private ArrayList<PlayerStateChangeListener> playerStateChangeListeners;
private ArrayList<PlaylistChangeListener> playlistChangeListeners;
private ArrayList<AnalogChangeListener> analogChangeListeners;
private ArrayList<AudioChangeListener> audioChangeListeners;
private final static int BIT_LOCATION = 0;
private final static int CHANNEL_LOCATION = 1;
private final static int SAMPLERATE_LOCATION = 2;
private final static int POS_LOCATION = 0;
private final static int LENGTH_LOCATION = 1;
/**
* Only contructor for this abstract base class.
*
* @param mpd
* a connection to a MPD
*/
public MPDEventMonitor(MPD mpd)
{
this.mpd = mpd;
connectionChangeListeners = new ArrayList<ConnectionChangeListener>();
currentlyPlayingSongChangeListeners = new ArrayList<CurrentlyPlayingSongChangeListener>();
mpdChangeListeners = new ArrayList<MPDChangeListener>();
mpdErrorListeners = new ArrayList<MPDErrorListener>();
playerChangeListeners = new ArrayList<PlayerChangeListener>();
playlistChangeListeners = new ArrayList<PlaylistChangeListener>();
analogChangeListeners = new ArrayList<AnalogChangeListener>();
audioChangeListeners = new ArrayList<AudioChangeListener>();
playerStateChangeListeners = new ArrayList<PlayerStateChangeListener>();
cacheLock = new Object();
initialization_lock = new Object();
}
/**
* Adds a {@link ConnectionChangeListener} to this object to receive
* {@link ConnectionChangeEvent}s.
*
* @param ccl
* the ConnectionChangeListerner to add
*/
public void addConnectionChangeListener(ConnectionChangeListener ccl)
{
synchronized (connectionChangeListeners)
{
connectionChangeListeners.add(ccl);
}
}
/**
* Removes a {@link ConnectionChangeListener} from this object.
*
* @param ccl
* the ConnectionChangeListener to remove
*/
public void removeConnectionChangeListener(ConnectionChangeListener ccl)
{
synchronized (connectionChangeListeners)
{
connectionChangeListeners.remove(ccl);
}
}
public void addPlayerStateChangeListener(PlayerStateChangeListener pscl)
{
synchronized (playerStateChangeListeners)
{
playerStateChangeListeners.add(pscl);
}
}
/**
* Removes a {@link ConnectionChangeListener} from this object.
*
* @param ccl
* the ConnectionChangeListener to remove
*/
public void removePlayerStateChangeListener(PlayerStateChangeListener pscl)
{
synchronized (playerStateChangeListeners)
{
playerStateChangeListeners.remove(pscl);
}
}
public void addAudioChangeListener(AudioChangeListener acl)
{
synchronized (audioChangeListeners)
{
audioChangeListeners.add(acl);
}
}
/**
* Removes a {@link ConnectionChangeListener} from this object.
*
* @param ccl
* the ConnectionChangeListener to remove
*/
public void removeAudioChangeListener(AudioChangeListener acl)
{
synchronized (audioChangeListeners)
{
audioChangeListeners.remove(acl);
}
}
public void addCurrentlyPlayingSongChangeListener(CurrentlyPlayingSongChangeListener cpscl)
{
synchronized (currentlyPlayingSongChangeListeners)
{
currentlyPlayingSongChangeListeners.add(cpscl);
}
}
/**
* Removes a {@link ConnectionChangeListener} from this object.
*
* @param ccl
* the ConnectionChangeListener to remove
*/
public void removeCurrentlyPlayingSongChangeListener(CurrentlyPlayingSongChangeListener cpscl)
{
synchronized (currentlyPlayingSongChangeListeners)
{
currentlyPlayingSongChangeListeners.remove(cpscl);
}
}
public void addMPDChangeListener(MPDChangeListener mcl)
{
synchronized (mpdChangeListeners)
{
mpdChangeListeners.add(mcl);
}
}
/**
* Removes a {@link ConnectionChangeListener} from this object.
*
* @param ccl
* the ConnectionChangeListener to remove
*/
public void removeMPDChangeListener(MPDChangeListener mcl)
{
synchronized (mpdChangeListeners)
{
mpdChangeListeners.remove(mcl);
}
}
public void addMPDErrorListener(MPDErrorListener mel)
{
synchronized (mpdErrorListeners)
{
mpdErrorListeners.add(mel);
}
}
/**
* Removes a {@link ConnectionChangeListener} from this object.
*
* @param ccl
* the ConnectionChangeListener to remove
*/
public void removeMPDErrorListener(MPDErrorListener mel)
{
synchronized (mpdErrorListeners)
{
mpdErrorListeners.remove(mel);
}
}
public void addPlayerChangeListener(PlayerChangeListener pcl)
{
synchronized (playerChangeListeners)
{
playerChangeListeners.add(pcl);
}
}
/**
* Removes a {@link ConnectionChangeListener} from this object.
*
* @param ccl
* the ConnectionChangeListener to remove
*/
public void removePlayerChangeListener(PlayerChangeListener pcl)
{
synchronized (playerChangeListeners)
{
playerChangeListeners.remove(pcl);
}
}
public void addPlaylistChangeListener(PlaylistChangeListener pcl)
{
synchronized (playlistChangeListeners)
{
playlistChangeListeners.add(pcl);
}
}
/**
* Removes a {@link ConnectionChangeListener} from this object.
*
* @param ccl
* the ConnectionChangeListener to remove
*/
public void removePlaylistChangeListener(PlaylistChangeListener pcl)
{
synchronized (playlistChangeListeners)
{
playlistChangeListeners.remove(pcl);
}
}
public void addAnalogChangeListener(AnalogChangeListener acl)
{
synchronized (analogChangeListeners)
{
analogChangeListeners.add(acl);
}
}
/**
* Removes a {@link ConnectionChangeListener} from this object.
*
* @param ccl
* the ConnectionChangeListener to remove
*/
public void removeAnalogChangeListener(AnalogChangeListener acl)
{
synchronized (analogChangeListeners)
{
analogChangeListeners.remove(acl);
}
}
/**
* Sends the appropriate {@link ConnectionChangeEvent} to all registered
* {@link ConnectionChangeListener}s.
*
* @param isConnected
* the connection status
*/
protected synchronized void fireConnectionChangeEvent(ConnectionChangeEvent cce)
{
Log.d(AndroidMPC.TAG, "Firing ConnectionChangeEvent");
Iterator <ConnectionChangeListener> listener_iter = null;
synchronized (connectionChangeListeners)
{
if (!connectionChangeListeners.isEmpty())
{
listener_iter = connectionChangeListeners.iterator();
while (listener_iter.hasNext())
{
listener_iter.next().onConnectionChanged(cce);
}
}
}
}
protected synchronized void firePlayerStateChangeEvent(PlayerStateChangeEvent psce)
{
Log.d(AndroidMPC.TAG, "Firing PlayerStateChangeEvent");
Iterator <PlayerStateChangeListener> listener_iter = null;
synchronized (playerStateChangeListeners)
{
if (!playerStateChangeListeners.isEmpty())
{
listener_iter = playerStateChangeListeners.iterator();
switch (psce.getId())
{
case PlayerStateChangeEvent.PAUSED:
while (listener_iter.hasNext())
{
listener_iter.next().onPlayerPaused(psce);
}
break;
case PlayerStateChangeEvent.PLAYING:
while (listener_iter.hasNext())
{
listener_iter.next().onPlayerPlaying(psce);
}
break;
case PlayerStateChangeEvent.STOPPED:
while (listener_iter.hasNext())
{
listener_iter.next().onPlayerStopped(psce);
}
break;
}
}
}
}
protected synchronized void fireAnalogChangeEvent(AnalogChangeEvent ace)
{
Log.d(AndroidMPC.TAG, "Firing AnalogChangeEvent");
Iterator <AnalogChangeListener> listener_iter = null;
synchronized (analogChangeListeners)
{
if (!analogChangeListeners.isEmpty())
{
listener_iter = analogChangeListeners.iterator();
while (listener_iter.hasNext())
{
listener_iter.next().onValueChanged(ace);
}
}
}
}
protected synchronized void fireCurrentlyPlayingSongChangeEvent(CurrentlyPlayingSongChangeEvent cpsce)
{
Log.d(AndroidMPC.TAG, "Firing CurrentlyPlayingSongChangeEvent");
Iterator <CurrentlyPlayingSongChangeListener> listener_iter = null;
synchronized (currentlyPlayingSongChangeListeners)
{
if (!currentlyPlayingSongChangeListeners.isEmpty())
{
listener_iter = currentlyPlayingSongChangeListeners.iterator();
while (listener_iter.hasNext())
{
listener_iter.next().onCurrentlyPlayingSongChanged(cpsce);
}
}
}
Log.d(AndroidMPC.TAG, "Fired CurrentlyPlayingChangeEvent");
}
protected synchronized void fireMPDChangeEvent(MPDChangeEvent mce)
{
Log.d(AndroidMPC.TAG, "Firing MPDChangeEvent");
Iterator <MPDChangeListener> listener_iter = null;
synchronized (mpdChangeListeners)
{
if (!mpdChangeListeners.isEmpty())
{
listener_iter = mpdChangeListeners.iterator();
switch (mce.getId())
{
case MPDChangeEvent.MPD_KILLED:
while (listener_iter.hasNext())
{
listener_iter.next().onMPDKilled(mce);
}
break;
case MPDChangeEvent.MPD_REFRESHED:
while (listener_iter.hasNext())
{
listener_iter.next().onMPDRefreshed(mce);
}
break;
default:
}
}
}
}
protected synchronized void fireMPDErrorEvent(MPDErrorEvent mce)
{
Log.d(AndroidMPC.TAG, "Firing MPDErrorChangeEvent");
Iterator <MPDErrorListener> listener_iter = null;
synchronized (mpdErrorListeners)
{
if (!mpdErrorListeners.isEmpty())
{
listener_iter = mpdErrorListeners.iterator();
while (listener_iter.hasNext())
{
listener_iter.next().onErrorEventReceived(mce);
}
}
}
}
protected synchronized void firePlayerChangeEvent(PlayerChangeEvent pce)
{
Log.d(AndroidMPC.TAG, "Firing PlayerChangeEvent");
Iterator <PlayerChangeListener> listener_iter = null;
synchronized (playerChangeListeners)
{
if (!playerChangeListeners.isEmpty())
{
listener_iter = playerChangeListeners.iterator();
switch (pce.getId())
{
case PlayerChangeEvent.PLAYER_MUTED:
while (listener_iter.hasNext())
{
listener_iter.next().onPlayerMuted(pce);
}
break;
case PlayerChangeEvent.PLAYER_NEXT:
while (listener_iter.hasNext())
{
listener_iter.next().onPlayerNext(pce);
}
break;
case PlayerChangeEvent.PLAYER_PREVIOUS:
while (listener_iter.hasNext())
{
listener_iter.next().onPlayerPrevious(pce);
}
break;
case PlayerChangeEvent.PLAYER_SEEKING:
while (listener_iter.hasNext())
{
listener_iter.next().onPlayerSeeking(pce);
}
break;
case PlayerChangeEvent.PLAYER_SONG_SET:
while (listener_iter.hasNext())
{
listener_iter.next().onPlayerSongSet(pce);
}
break;
case PlayerChangeEvent.PLAYER_UNMUTED:
while (listener_iter.hasNext())
{
listener_iter.next().onPlayerUnmuted(pce);
}
break;
case PlayerChangeEvent.PLAYER_RANDOM_ON:
while (listener_iter.hasNext())
{
listener_iter.next().onPlayerRandomOn(pce);
}
break;
case PlayerChangeEvent.PLAYER_RANDOM_OFF:
while (listener_iter.hasNext())
{
listener_iter.next().onPlayerRandomOff(pce);
}
break;
case PlayerChangeEvent.PLAYER_REPEAT_ON:
while (listener_iter.hasNext())
{
listener_iter.next().onPlayerRepeatOn(pce);
}
break;
case PlayerChangeEvent.PLAYER_REPEAT_OFF:
while (listener_iter.hasNext())
{
listener_iter.next().onPlayerRepeatOff(pce);
}
break;
case PlayerChangeEvent.PLAYER_CONSUME_MODE_ON:
while (listener_iter.hasNext())
{
listener_iter.next().onPlayerConsumeModeOn(pce);
}
break;
case PlayerChangeEvent.PLAYER_CONSUME_MODE_OFF:
while (listener_iter.hasNext())
{
listener_iter.next().onPlayerConsumeModeOff(pce);
}
break;
case PlayerChangeEvent.PLAYER_SINGLE_MODE_ON:
while (listener_iter.hasNext())
{
listener_iter.next().onPlayerSingleModeOn(pce);
}
break;
case PlayerChangeEvent.PLAYER_SINGLE_MODE_OFF:
while (listener_iter.hasNext())
{
listener_iter.next().onPlayerSingleModeOff(pce);
}
break;
}
}
}
}
protected synchronized void fireAudioChangeEvent(AudioChangeEvent ace)
{
Log.d(AndroidMPC.TAG, "Firing AudioChangeEvent");
Iterator <AudioChangeListener> listener_iter = null;
synchronized (audioChangeListeners)
{
if (!audioChangeListeners.isEmpty())
{
listener_iter = audioChangeListeners.iterator();
switch (ace.getId())
{
case AudioChangeEvent.BITS:
while (listener_iter.hasNext())
{
listener_iter.next().onBitsChanged(ace);
}
break;
case AudioChangeEvent.CHANNELS:
while (listener_iter.hasNext())
{
listener_iter.next().onChannelsChanged(ace);
}
break;
case AudioChangeEvent.SAMPLERATE:
while (listener_iter.hasNext())
{
listener_iter.next().onSampleRateChanged(ace);
}
break;
default:
}
}
}
}
protected synchronized void firePlaylistChangeEvent(PlaylistChangeEvent pce)
{
Log.d(AndroidMPC.TAG, "Firing ConnectionChangeEvent");
Iterator <PlaylistChangeListener> listener_iter = null;
synchronized (playlistChangeListeners)
{
if (!playlistChangeListeners.isEmpty())
{
listener_iter = playlistChangeListeners.iterator();
switch (pce.getId())
{
case PlaylistChangeEvent.ALBUM_ADDED:
while (listener_iter.hasNext())
{
listener_iter.next().onAlbumAdded(pce);
}
break;
case PlaylistChangeEvent.ARTIST_ADDED:
while (listener_iter.hasNext())
{
listener_iter.next().onArtistAdded(pce);
}
break;
case PlaylistChangeEvent.FILE_ADDED:
while (listener_iter.hasNext())
{
listener_iter.next().onFileAdded(pce);
}
break;
case PlaylistChangeEvent.GENRE_ADDED:
while (listener_iter.hasNext())
{
listener_iter.next().onGenreAdded(pce);
}
break;
case PlaylistChangeEvent.MULTIPLE_SONGS_ADDED:
while (listener_iter.hasNext())
{
listener_iter.next().onMultipleSongsAdded(pce);
}
break;
case PlaylistChangeEvent.PLAYLIST_ADDED:
while (listener_iter.hasNext())
{
listener_iter.next().onPlaylistAdded(pce);
}
break;
case PlaylistChangeEvent.PLAYLIST_CHANGED:
while (listener_iter.hasNext())
{
listener_iter.next().onPlaylistChanged(pce);
}
break;
case PlaylistChangeEvent.PLAYLIST_CLEARED:
while (listener_iter.hasNext())
{
listener_iter.next().onPlaylistCleared(pce);
}
break;
case PlaylistChangeEvent.PLAYLIST_DELETED:
while (listener_iter.hasNext())
{
listener_iter.next().onPlaylistDeleted(pce);
}
break;
case PlaylistChangeEvent.PLAYLIST_LOADED:
while (listener_iter.hasNext())
{
listener_iter.next().onPlaylistLoaded(pce);
}
break;
case PlaylistChangeEvent.PLAYLIST_SAVED:
while (listener_iter.hasNext())
{
listener_iter.next().onPlaylistSaved(pce);
}
break;
case PlaylistChangeEvent.SONG_ADDED:
while (listener_iter.hasNext())
{
listener_iter.next().onSongAdded(pce);
}
break;
case PlaylistChangeEvent.SONG_DELETED:
while (listener_iter.hasNext())
{
listener_iter.next().onSongDeleted(pce);
}
break;
case PlaylistChangeEvent.SONG_SELECTED:
while (listener_iter.hasNext())
{
listener_iter.next().onSongSelected(pce);
}
break;
case PlaylistChangeEvent.YEAR_ADDED:
while (listener_iter.hasNext())
{
listener_iter.next().onYearAdded(pce);
}
break;
default:
}
}
}
}
/**
* Checks the connection status of the MPD. Fires a
* {@link ConnectionChangeEvent} if the connection status changes.
*/
protected final void analyzeConnection()
{
boolean conn = false;
ConnectionChangeEvent cce = null;
if (checkConnCount == 3)
{
checkConnCount = 0;
synchronized (mpd)
{
conn = mpd.isConnected();
}
if (connectedState != conn)
{
connectedState = conn;
cce = new ConnectionChangeEvent(this, conn, "Connection Changed");
fireConnectionChangeEvent(cce);
}
}
else
{
++checkConnCount;
}
}
/**
* Returns the connected state of the connection to the MPD server.
*
* @return the connected state
*/
protected boolean isConnectedState()
{
return this.connectedState;
}
protected final void analyzeServerStatus() throws MPDConnectionException, MPDResponseException
{
Calendar nowdate = null;
Hashtable <String, String > oldstatus = null;
Iterator <String>status_iter = null;
String oldstatus_name = null;
String oldstatus_value = null;
String newstatus_value = null;
String [] oldtemparray = null;
String [] newtemparray = null;
MPDSong oldsong = null;
MPDSong newsong = null;
if (!initialized)
{
initialize();
}
synchronized (cacheLock)
{
if ((cacheing) && (lastCacheDate != null) && (cachedStatus != null))
{
nowdate = Calendar.getInstance();
if ((nowdate.getTimeInMillis() - lastCacheDate.getTimeInMillis()) <= cacheMillis)
{
Log.d(AndroidMPC.TAG, "Returning cached version of status");
return;
}
}
oldstatus = cachedStatus;
lastCacheDate = Calendar.getInstance();
cachedStatus = mpd.getStatus();
}
Log.d(AndroidMPC.TAG, "Comparing old status to new status for changes");
status_iter = oldstatus.keySet().iterator();
while (status_iter.hasNext())
{
oldstatus_name = status_iter.next();
oldstatus_value = oldstatus.get(oldstatus_name);
newstatus_value = cachedStatus.get(oldstatus_name);
if (newstatus_value == null)
{
continue;
}
oldstatus_name = oldstatus_name.trim();
oldstatus_value = oldstatus_value.trim();
newstatus_value = newstatus_value.trim();
if (oldstatus_value.compareTo(newstatus_value) != 0)
{
//we need to check and fire off a changeEvent
if (oldstatus_name.compareTo(MPD.STATUS_VOLUME) == 0)
{
fireAnalogChangeEvent(new AnalogChangeEvent(this, AnalogChangeEvent.VOLUME_TYPE,Integer.decode(newstatus_value).longValue()));
}
else if (oldstatus_name.compareTo(MPD.STATUS_REPEAT) == 0)
{
if (newstatus_value.compareTo(MPD.MPD_ON) == 0)
{
firePlayerChangeEvent(new PlayerChangeEvent(this, PlayerChangeEvent.PLAYER_REPEAT_ON));
}
else
{
firePlayerChangeEvent(new PlayerChangeEvent(this, PlayerChangeEvent.PLAYER_REPEAT_OFF));
}
}
else if (oldstatus_name.compareTo(MPD.STATUS_RANDOM) == 0)
{
if (newstatus_value.compareTo(MPD.MPD_ON) == 0)
{
firePlayerChangeEvent(new PlayerChangeEvent(this, PlayerChangeEvent.PLAYER_RANDOM_ON));
}
else
{
firePlayerChangeEvent(new PlayerChangeEvent(this, PlayerChangeEvent.PLAYER_RANDOM_OFF));
}
}
else if (oldstatus_name.compareTo(MPD.STATUS_PLAYLIST_VERSION) == 0)
{
}
else if (oldstatus_name.compareTo(MPD.STATUS_PLAYLIST_LENGTH) == 0)
{
}
else if (oldstatus_name.compareTo(MPD.STATUS_XFADE) == 0)
{
fireAnalogChangeEvent(new AnalogChangeEvent(this, AnalogChangeEvent.XFADE_TYPE, Integer.decode(newstatus_value).longValue()));
}
else if (oldstatus_name.compareTo(MPD.STATUS_STATE) == 0)
{
if (oldstatus_value.compareTo(MPDPlayer.PLAYSTATE_PAUSED) == 0)
{
if (newstatus_value.compareTo(MPDPlayer.PLAYSTATE_PLAYING) == 0)
{
firePlayerStateChangeEvent(new PlayerStateChangeEvent(this, PlayerStateChangeEvent.PLAYING, PlayerStateChangeEvent.PAUSED));
}
else if (newstatus_value.compareTo(MPDPlayer.PLAYSTATE_STOPPED) == 0)
{
firePlayerStateChangeEvent(new PlayerStateChangeEvent(this, PlayerStateChangeEvent.STOPPED, PlayerStateChangeEvent.PAUSED));
}
}
else if (oldstatus_value.compareTo(MPDPlayer.PLAYSTATE_STOPPED) == 0)
{
if (newstatus_value.compareTo(MPDPlayer.PLAYSTATE_PLAYING) == 0)
{
firePlayerStateChangeEvent(new PlayerStateChangeEvent(this, PlayerStateChangeEvent.PLAYING, PlayerStateChangeEvent.STOPPED));
}
else if (newstatus_value.compareTo(MPDPlayer.PLAYSTATE_PAUSED) == 0)
{
firePlayerStateChangeEvent(new PlayerStateChangeEvent(this, PlayerStateChangeEvent.PAUSED, PlayerStateChangeEvent.STOPPED));
}
}
else if (oldstatus_value.compareTo(MPDPlayer.PLAYSTATE_PLAYING) == 0)
{
if (newstatus_value.compareTo(MPDPlayer.PLAYSTATE_STOPPED) == 0)
{
firePlayerStateChangeEvent(new PlayerStateChangeEvent(this, PlayerStateChangeEvent.STOPPED, PlayerStateChangeEvent.PLAYING));
}
else if (newstatus_value.compareTo(MPDPlayer.PLAYSTATE_PAUSED) == 0)
{
firePlayerStateChangeEvent(new PlayerStateChangeEvent(this, PlayerStateChangeEvent.PAUSED, PlayerStateChangeEvent.PLAYING));
}
}
}
else if (oldstatus_name.compareTo(MPD.STATUS_SONG) == 0)
{
try
{
if ((oldstatus_value != null) && (oldstatus_value.length() > 0))
{
synchronized (mpd)
{
oldsong = mpd.getMPDPlaylist().getSong(oldstatus_value);
}
}
if ((newstatus_value != null) && (newstatus_value.length() > 0))
{
synchronized (mpd)
{
newsong = mpd.getMPDPlaylist().getSong(newstatus_value);
}
}
}
catch (MPDPlaylistException ex)
{
Log.e(AndroidMPC.TAG, ex.getMessage(), ex);
}
if (newsong != null)
{
fireCurrentlyPlayingSongChangeEvent(new CurrentlyPlayingSongChangeEvent(this, newsong, oldsong));
}
}
else if (oldstatus_name.compareTo(MPD.STATUS_TIME) == 0)
{
if (oldstatus_value.split(":")[POS_LOCATION].compareTo(newstatus_value.split(":")[POS_LOCATION]) != 0)
{
fireAnalogChangeEvent(new AnalogChangeEvent(this, AnalogChangeEvent.TRACK_POSITION_TYPE, Integer.decode((newstatus_value.split(":")[POS_LOCATION]).trim()).longValue()));
}
if (oldstatus_value.split(":")[LENGTH_LOCATION].compareTo(newstatus_value.split(":")[LENGTH_LOCATION]) != 0)
{
fireAnalogChangeEvent(new AnalogChangeEvent(this, AnalogChangeEvent.TRACK_LENGTH_TYPE, Integer.decode((newstatus_value.split(":")[LENGTH_LOCATION]).trim()).longValue()));
}
}
else if (oldstatus_name.compareTo(MPD.STATUS_BITRATE) == 0)
{
fireAnalogChangeEvent(new AnalogChangeEvent(this, AnalogChangeEvent.BITRATE_TYPE, Integer.decode(newstatus_value).longValue()));
}
else if (oldstatus_name.compareTo(MPD.STATUS_AUDIO) == 0)
{
oldtemparray = oldstatus_value.split(":");
newtemparray = newstatus_value.split(":");
if ((oldtemparray == null) && (newtemparray != null))
{
if (newtemparray.length <= SAMPLERATE_LOCATION)
{
continue;
}
fireAudioChangeEvent(new AudioChangeEvent(this, AudioChangeEvent.BITS, new AnalogChangeEvent(this, AnalogChangeEvent.GENERIC_TYPE, Integer.decode((newtemparray[BIT_LOCATION].trim())).longValue())));
fireAudioChangeEvent(new AudioChangeEvent(this, AudioChangeEvent.CHANNELS, new AnalogChangeEvent(this, AnalogChangeEvent.GENERIC_TYPE, Integer.decode(newtemparray[CHANNEL_LOCATION].trim()).longValue())));
fireAudioChangeEvent(new AudioChangeEvent(this, AudioChangeEvent.SAMPLERATE, new AnalogChangeEvent(this, AnalogChangeEvent.GENERIC_TYPE, Integer.decode(newtemparray[SAMPLERATE_LOCATION].trim()).longValue())));
}
else if ((oldtemparray != null) && (newtemparray == null))
{
fireAudioChangeEvent(new AudioChangeEvent(this, AudioChangeEvent.BITS, new AnalogChangeEvent(this, AnalogChangeEvent.GENERIC_TYPE, 0l)));
fireAudioChangeEvent(new AudioChangeEvent(this, AudioChangeEvent.CHANNELS, new AnalogChangeEvent(this, AnalogChangeEvent.GENERIC_TYPE, 0l)));
fireAudioChangeEvent(new AudioChangeEvent(this, AudioChangeEvent.SAMPLERATE, new AnalogChangeEvent(this, AnalogChangeEvent.GENERIC_TYPE, 0l)));
}
else
{
if ((newtemparray.length <= SAMPLERATE_LOCATION) || (oldtemparray.length <= SAMPLERATE_LOCATION))
{
continue;
}
if (newtemparray[BIT_LOCATION].compareTo(oldtemparray[BIT_LOCATION]) != 0)
{
fireAudioChangeEvent(new AudioChangeEvent(this, AudioChangeEvent.BITS, new AnalogChangeEvent(this, AnalogChangeEvent.GENERIC_TYPE, Integer.decode((newtemparray[BIT_LOCATION].trim())).longValue())));
}
if (newtemparray[CHANNEL_LOCATION].compareTo(oldtemparray[CHANNEL_LOCATION]) != 0)
{
fireAudioChangeEvent(new AudioChangeEvent(this, AudioChangeEvent.CHANNELS, new AnalogChangeEvent(this, AnalogChangeEvent.GENERIC_TYPE, Integer.decode(newtemparray[CHANNEL_LOCATION].trim()).longValue())));
}
if (newtemparray[SAMPLERATE_LOCATION].compareTo(oldtemparray[SAMPLERATE_LOCATION]) != 0)
{
fireAudioChangeEvent(new AudioChangeEvent(this, AudioChangeEvent.SAMPLERATE, new AnalogChangeEvent(this, AnalogChangeEvent.GENERIC_TYPE, Integer.decode(newtemparray[SAMPLERATE_LOCATION].trim()).longValue())));
}
}
}
else if (oldstatus_name.compareTo(MPD.STATUS_UPDATING_DB) == 0)
{
fireMPDChangeEvent(new MPDChangeEvent(this, MPDChangeEvent.MPD_REFRESHED));
}
else if (oldstatus_name.compareTo(MPD.STATUS_ERROR) == 0)
{
if ((newstatus_value != null) && (newstatus_value.length() > 0))
{
fireMPDErrorEvent(new MPDErrorEvent(this, newstatus_value));
}
}
else if (oldstatus_name.compareTo(MPD.STATUS_NEXTSONG) == 0)
{
}
else if (oldstatus_name.compareTo(MPD.STATUS_NEXTSONGID) == 0)
{
}
else if (oldstatus_name.compareTo(MPD.STATUS_CONSUME_MODE) == 0)
{
if (newstatus_value.compareTo(MPD.MPD_ON) == 0)
{
firePlayerChangeEvent(new PlayerChangeEvent(this, PlayerChangeEvent.PLAYER_CONSUME_MODE_ON));
}
else
{
firePlayerChangeEvent(new PlayerChangeEvent(this, PlayerChangeEvent.PLAYER_CONSUME_MODE_OFF));
}
}
else if (oldstatus_name.compareTo(MPD.STATUS_SINGLE_MODE) == 0)
{
if (newstatus_value.compareTo(MPD.MPD_ON) == 0)
{
firePlayerChangeEvent(new PlayerChangeEvent(this, PlayerChangeEvent.PLAYER_SINGLE_MODE_ON));
}
else
{
firePlayerChangeEvent(new PlayerChangeEvent(this, PlayerChangeEvent.PLAYER_SINGLE_MODE_OFF));
}
}
}
}
}
protected final void initialize() throws MPDConnectionException, MPDResponseException
{
Iterator <String>status_iter = null;
String oldstatus_name = null;
String newstatus_value = null;
String [] newtemparray = null;
MPDSong newsong = null;
synchronized (cacheLock)
{
cachedStatus = mpd.getStatus();
}
Log.d(AndroidMPC.TAG, "Assuming that this is the first time checking for status since connection. Gonna fire all events");
status_iter = cachedStatus.keySet().iterator();
while (status_iter.hasNext())
{
oldstatus_name = status_iter.next();
newstatus_value = cachedStatus.get(oldstatus_name);
if (newstatus_value == null)
{
continue;
}
oldstatus_name = oldstatus_name.trim();
newstatus_value = newstatus_value.trim();
if (oldstatus_name.compareTo(MPD.STATUS_VOLUME) == 0)
{
fireAnalogChangeEvent(new AnalogChangeEvent(this, AnalogChangeEvent.VOLUME_TYPE,Integer.decode(newstatus_value).longValue()));
}
else if (oldstatus_name.compareTo(MPD.STATUS_REPEAT) == 0)
{
if (newstatus_value.compareTo(MPD.MPD_ON) == 0)
{
firePlayerChangeEvent(new PlayerChangeEvent(this, PlayerChangeEvent.PLAYER_REPEAT_ON));
}
else
{
firePlayerChangeEvent(new PlayerChangeEvent(this, PlayerChangeEvent.PLAYER_REPEAT_OFF));
}
}
else if (oldstatus_name.compareTo(MPD.STATUS_RANDOM) == 0)
{
if (newstatus_value.compareTo(MPD.MPD_ON) == 0)
{
firePlayerChangeEvent(new PlayerChangeEvent(this, PlayerChangeEvent.PLAYER_RANDOM_ON));
}
else
{
firePlayerChangeEvent(new PlayerChangeEvent(this, PlayerChangeEvent.PLAYER_RANDOM_OFF));
}
}
else if (oldstatus_name.compareTo(MPD.STATUS_PLAYLIST_VERSION) == 0)
{
}
else if (oldstatus_name.compareTo(MPD.STATUS_PLAYLIST_LENGTH) == 0)
{
}
else if (oldstatus_name.compareTo(MPD.STATUS_XFADE) == 0)
{
fireAnalogChangeEvent(new AnalogChangeEvent(this, AnalogChangeEvent.XFADE_TYPE, Integer.decode(newstatus_value).longValue()));
}
else if (oldstatus_name.compareTo(MPD.STATUS_STATE) == 0)
{
if (newstatus_value.compareTo(MPDPlayer.PLAYSTATE_PLAYING) == 0)
{
firePlayerStateChangeEvent(new PlayerStateChangeEvent(this, PlayerStateChangeEvent.PLAYING));
try
{
synchronized (mpd)
{
newsong = mpd.getMPDPlaylist().getCurrentSong();
}
}
catch (MPDPlaylistException ex)
{
Log.e(AndroidMPC.TAG, ex.getMessage(), ex);
}
if (newsong != null)
{
Log.d(AndroidMPC.TAG, "Firing CurrentlyPlayingSongChangeEvent for song: " + newsong.getName());
fireCurrentlyPlayingSongChangeEvent(new CurrentlyPlayingSongChangeEvent(this, newsong, null));
}
else
{
Log.e(AndroidMPC.TAG, "We could not the current song playing");
}
}
else if (newstatus_value.compareTo(MPDPlayer.PLAYSTATE_STOPPED) == 0)
{
firePlayerStateChangeEvent(new PlayerStateChangeEvent(this, PlayerStateChangeEvent.STOPPED));
}
else if (newstatus_value.compareTo(MPDPlayer.PLAYSTATE_PAUSED) == 0)
{
firePlayerStateChangeEvent(new PlayerStateChangeEvent(this, PlayerStateChangeEvent.PAUSED));
try
{
synchronized (mpd)
{
newsong = mpd.getMPDPlaylist().getCurrentSong();
}
}
catch (MPDPlaylistException ex)
{
Log.e(AndroidMPC.TAG, ex.getMessage(), ex);
}
if (newsong != null)
{
Log.d(AndroidMPC.TAG, "Firing CurrentlyPlayingSongChangeEvent for song: " + newsong.getName());
fireCurrentlyPlayingSongChangeEvent(new CurrentlyPlayingSongChangeEvent(this, newsong, null));
}
else
{
Log.e(AndroidMPC.TAG, "We could not the current song playing");
}
}
}
else if (oldstatus_name.compareTo(MPD.STATUS_SONG) == 0)
{
if ((newstatus_value != null) && (newstatus_value.length() > 0))
{
try
{
synchronized (mpd)
{
newsong = mpd.getMPDPlaylist().getCurrentSong();
}
}
catch (MPDPlaylistException ex)
{
Log.e(AndroidMPC.TAG, ex.getMessage(), ex);
}
}
if (newsong != null)
{
Log.d(AndroidMPC.TAG, "Firing CurrentlyPlayingSongChangeEvent for song: " + newsong.getName());
fireCurrentlyPlayingSongChangeEvent(new CurrentlyPlayingSongChangeEvent(this, newsong, null));
}
else
{
Log.e(AndroidMPC.TAG, "We could not the current song playing");
}
}
else if (oldstatus_name.compareTo(MPD.STATUS_TIME) == 0)
{
fireAnalogChangeEvent(new AnalogChangeEvent(this, AnalogChangeEvent.TRACK_POSITION_TYPE, Integer.decode((newstatus_value.split(":")[POS_LOCATION]).trim()).longValue()));
fireAnalogChangeEvent(new AnalogChangeEvent(this, AnalogChangeEvent.TRACK_LENGTH_TYPE, Integer.decode((newstatus_value.split(":")[LENGTH_LOCATION]).trim()).longValue()));
}
else if (oldstatus_name.compareTo(MPD.STATUS_BITRATE) == 0)
{
fireAnalogChangeEvent(new AnalogChangeEvent(this, AnalogChangeEvent.BITRATE_TYPE, Integer.decode(newstatus_value).longValue()));
}
else if (oldstatus_name.compareTo(MPD.STATUS_AUDIO) == 0)
{
newtemparray = newstatus_value.split(":");
if (newtemparray != null)
{
if (newtemparray.length <= SAMPLERATE_LOCATION)
{
continue;
}
fireAudioChangeEvent(new AudioChangeEvent(this, AudioChangeEvent.BITS, new AnalogChangeEvent(this, AnalogChangeEvent.GENERIC_TYPE, Integer.decode((newtemparray[BIT_LOCATION].trim())).longValue())));
fireAudioChangeEvent(new AudioChangeEvent(this, AudioChangeEvent.CHANNELS, new AnalogChangeEvent(this, AnalogChangeEvent.GENERIC_TYPE, Integer.decode(newtemparray[CHANNEL_LOCATION].trim()).longValue())));
fireAudioChangeEvent(new AudioChangeEvent(this, AudioChangeEvent.SAMPLERATE, new AnalogChangeEvent(this, AnalogChangeEvent.GENERIC_TYPE, Integer.decode(newtemparray[SAMPLERATE_LOCATION].trim()).longValue())));
}
}
else if ((oldstatus_name.compareTo(MPD.STATUS_UPDATING_DB) == 0) && (newstatus_value.compareTo("0") != 0))
{
fireMPDChangeEvent(new MPDChangeEvent(this, MPDChangeEvent.MPD_REFRESHED));
}
else if (oldstatus_name.compareTo(MPD.STATUS_ERROR) == 0)
{
if ((newstatus_value != null) && (newstatus_value.length() > 0))
{
fireMPDErrorEvent(new MPDErrorEvent(this, newstatus_value));
}
}
else if (oldstatus_name.compareTo(MPD.STATUS_CONSUME_MODE) == 0)
{
if (newstatus_value.compareTo(MPD.MPD_ON) == 0)
{
firePlayerChangeEvent(new PlayerChangeEvent(this, PlayerChangeEvent.PLAYER_CONSUME_MODE_ON));
}
else
{
firePlayerChangeEvent(new PlayerChangeEvent(this, PlayerChangeEvent.PLAYER_CONSUME_MODE_OFF));
}
}
else if (oldstatus_name.compareTo(MPD.STATUS_SINGLE_MODE) == 0)
{
if (newstatus_value.compareTo(MPD.MPD_ON) == 0)
{
firePlayerChangeEvent(new PlayerChangeEvent(this, PlayerChangeEvent.PLAYER_SINGLE_MODE_ON));
}
else
{
firePlayerChangeEvent(new PlayerChangeEvent(this, PlayerChangeEvent.PLAYER_SINGLE_MODE_OFF));
}
}
}
synchronized(initialization_lock)
{
initialized = true;
}
}
}
|