Renamed from AndroVDR to VDR-Manager

48 files changed, 4375 insertions, 0 deletions

diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/app/VdrManagerApp.java b/vdrmanager/src/de/bjusystems/vdrmanager/app/VdrManagerApp.java
new file mode 100644
index 0000000..e60d396
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/app/VdrManagerApp.java
@@ -0,0 +1,134 @@
+package de.bjusystems.vdrmanager.app;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import android.app.Activity;
+import android.app.Application;
+import de.bjusystems.vdrmanager.data.Channel;
+import de.bjusystems.vdrmanager.data.Epg;
+import de.bjusystems.vdrmanager.data.EpgSearchParams;
+import de.bjusystems.vdrmanager.data.Timer;
+
+public class VdrManagerApp extends Application {
+
+	public enum EpgListState {
+		EPG_TIME,
+		EPG_CHANNEL,
+		EPG_SEARCH
+	}
+
+	private EpgListState epgListState;
+	private Epg currentEvent;
+	private Timer currentTimer;
+	private Channel currentChannel;
+	private List<Channel> channels;
+	private EpgSearchParams currentSearch;
+	private Class<? extends Activity> nextActivity;
+	private final List<Activity> activitiesToFinish = new ArrayList<Activity>();
+	private boolean reload;
+
+	@Override
+	public void onCreate() {
+		super.onCreate();
+	}
+
+	public void clear() {
+		this.currentEvent = null;
+		this.currentTimer = null;
+		this.currentChannel = null;
+		this.currentSearch = null;
+
+		this.epgListState = EpgListState.EPG_TIME;
+	}
+
+	public Epg getCurrentEvent() {
+		return currentEvent;
+	}
+
+	public void setCurrentEvent(final Epg currentEvent) {
+		clear();
+		this.currentEvent = currentEvent;
+		if (currentEvent.getTimer() != null) {
+			this.currentTimer = currentEvent.getTimer();
+		} else {
+			this.currentTimer = new Timer(currentEvent);
+		}
+	}
+
+	public Timer getCurrentTimer() {
+		return currentTimer;
+	}
+
+	public void setCurrentTimer(final Timer currentTimer) {
+		clear();
+		this.currentTimer = currentTimer;
+	}
+
+	public Channel getCurrentChannel() {
+		return currentChannel;
+	}
+
+	public void setCurrentChannel(final Channel currentChannel) {
+		clear();
+		this.currentChannel = currentChannel;
+		this.epgListState = EpgListState.EPG_CHANNEL;
+	}
+
+	public List<Channel> getChannels() {
+		return channels;
+	}
+
+	public void setChannels(final List<Channel> channels) {
+		this.channels = channels;
+	}
+
+	public EpgSearchParams getCurrentSearch() {
+		return currentSearch;
+	}
+
+	public void setCurrentSearch(final EpgSearchParams currentSearch) {
+		clear();
+		this.currentSearch = currentSearch;
+		this.epgListState = EpgListState.EPG_SEARCH;
+	}
+
+	public EpgListState getEpgListState() {
+		return epgListState;
+	}
+
+	public Class<? extends Activity> getNextActivity() {
+		return nextActivity;
+	}
+
+	public void setNextActivity(final Class<? extends Activity> nextActivity) {
+		this.nextActivity = nextActivity;
+	}
+
+	public List<Activity> getActivitiesToFinish() {
+		return activitiesToFinish;
+	}
+
+	public void clearActivitiesToFinish() {
+		activitiesToFinish.clear();
+	}
+
+	public void addActivityToFinish(final Activity activityToFinish) {
+		activitiesToFinish.add(activityToFinish);
+	}
+
+	public void finishActivities() {
+		for(final Activity activity : activitiesToFinish) {
+			activity.finish();
+		}
+		activitiesToFinish.clear();
+	}
+
+	public boolean isReload() {
+		return reload;
+	}
+
+	public void setReload(final boolean reload) {
+		this.reload = reload;
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/data/AliveState.java b/vdrmanager/src/de/bjusystems/vdrmanager/data/AliveState.java
new file mode 100644
index 0000000..cf96efa
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/data/AliveState.java
@@ -0,0 +1,36 @@
+package de.bjusystems.vdrmanager.data;
+
+public class AliveState {
+
+	public static AliveState ALIVE = new AliveState(0);
+	public static AliveState DEAD = new AliveState(1);
+	public static AliveState UNKNOWN = new AliveState(2);
+
+	private final int value;
+	private static AliveState state;
+
+	private AliveState(final int value) {
+		this.value = value;
+	}
+
+	public static AliveState getState() {
+		return state;
+	}
+
+	public static void setState(final AliveState state) {
+		AliveState.state = state;
+	}
+
+	@Override
+	public boolean equals(final Object o) {
+		if (!(o instanceof AliveState)) {
+			return false;
+		}
+		return this.value == ((AliveState)o).value;
+	}
+
+	@Override
+	public int hashCode() {
+		return Integer.valueOf(value).hashCode();
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/data/Channel.java b/vdrmanager/src/de/bjusystems/vdrmanager/data/Channel.java
new file mode 100644
index 0000000..bb9e0a7
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/data/Channel.java
@@ -0,0 +1,41 @@
+package de.bjusystems.vdrmanager.data;
+
+
+public class Channel {
+
+	private final int number;
+	private final String name;
+
+	public Channel(final String channelData) {
+
+		final String[] words = channelData.split(":");
+		this.number = Integer.valueOf(words[0].substring(1));
+		this.name = words[1];
+	}
+
+	public Channel() {
+		this.number = 0;
+		this.name = "Unknown";
+	}
+
+	public boolean isGroupSeparator() {
+		return number == 0;
+	}
+
+	public int getNumber() {
+		return number;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	@Override
+	public String toString() {
+		final StringBuilder text = new StringBuilder();
+		text.append(number);
+		text.append(" - ");
+		text.append(name);
+		return text.toString();
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/data/Epg.java b/vdrmanager/src/de/bjusystems/vdrmanager/data/Epg.java
new file mode 100644
index 0000000..e228565
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/data/Epg.java
@@ -0,0 +1,65 @@
+package de.bjusystems.vdrmanager.data;
+
+import java.util.Date;
+
+/**
+ * Class for EPG events
+ * @author bju
+ */
+public class Epg implements Event {
+
+	private final String channelNumber;
+	private final String channelName;
+	private final String title;
+	private final String description;
+	private final Date start;
+	private final Date stop;
+	private Timer timer;
+
+	public Epg(final String line) {
+
+		final String[] words = line.split(":");
+
+		channelNumber = words[0].substring(1);
+		channelName = words[1];
+		start = new Date(Long.parseLong(words[2])*1000);
+		stop = new Date(Long.parseLong(words[3])*1000);
+		title = words[4];
+		description = words.length > 5 ? words[5] : "";
+	}
+
+	public String getChannelNumber() {
+		return channelNumber;
+	}
+	public String getChannelName() {
+		return channelName;
+	}
+	public String getTitle() {
+		return title;
+	}
+	public String getDescription() {
+		return description;
+	}
+	public Date getStart() {
+		return start;
+	}
+	public Date getStop() {
+		return stop;
+	}
+
+	public Timer getTimer() {
+		return timer;
+	}
+
+	public void setTimer(final Timer timer) {
+		this.timer = timer;
+	}
+
+	public TimerState getTimerState() {
+		if (timer == null) {
+			return TimerState.None;
+		} else {
+			return timer.getTimerState();
+		}
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/data/EpgSearchParams.java b/vdrmanager/src/de/bjusystems/vdrmanager/data/EpgSearchParams.java
new file mode 100644
index 0000000..62ca4e2
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/data/EpgSearchParams.java
@@ -0,0 +1,43 @@
+package de.bjusystems.vdrmanager.data;
+
+import java.util.Date;
+
+/**
+ * Class for EPG events
+ * @author bju
+ */
+public class EpgSearchParams {
+
+	private String channelNumber;
+	private String title;
+	private Date start;
+	private Date end;
+
+	public String getChannelNumber() {
+		return channelNumber;
+	}
+	public void setChannelNumber(final String channelNumber) {
+		this.channelNumber = channelNumber;
+	}
+	public String getTitle() {
+		return title;
+	}
+	public void setTitle(final String title) {
+		this.title = title;
+	}
+	public Date getStart() {
+		return start;
+	}
+	public void setStart(final Date start) {
+		this.start = start;
+	}
+	public Date getEnd() {
+		return end;
+	}
+	public void setEnd(final Date end) {
+		this.end = end;
+	}
+	public String toCommandLine() {
+		return title;
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/data/EpgSearchTimeValue.java b/vdrmanager/src/de/bjusystems/vdrmanager/data/EpgSearchTimeValue.java
new file mode 100644
index 0000000..281b020
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/data/EpgSearchTimeValue.java
@@ -0,0 +1,49 @@
+package de.bjusystems.vdrmanager.data;
+
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+
+public class EpgSearchTimeValue {
+
+	private final int index;
+	private final String text;
+
+	public EpgSearchTimeValue(final int index, final String text) {
+		this.index = index;
+		this.text = text;
+	}
+
+	public EpgSearchTimeValue() {
+		this.index = 0;
+		this.text = "";
+	}
+
+	public String getValue() {
+		switch (index) {
+		case 0:
+			return "now";
+		case 1:
+			return "next";
+		default:
+			final String[] values = text.split(":");
+			final Calendar cal = new GregorianCalendar();
+			cal.set(Calendar.HOUR_OF_DAY, Integer.parseInt(values[0]));
+			cal.set(Calendar.MINUTE, Integer.parseInt(values[1]));
+			cal.set(Calendar.SECOND, 0);
+			cal.set(Calendar.MILLISECOND, 0);
+
+			// next day?
+			final Calendar now = new GregorianCalendar();
+			if (now.after(cal)) {
+				cal.add(Calendar.DAY_OF_MONTH, 1);
+			}
+
+			return String.format("%d", cal.getTimeInMillis() / 1000);
+		}
+	}
+
+	@Override
+	public String toString() {
+		return text;
+	}
+}
\ No newline at end of file
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/data/EpgSearchTimeValues.java b/vdrmanager/src/de/bjusystems/vdrmanager/data/EpgSearchTimeValues.java
new file mode 100644
index 0000000..6fba7ba
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/data/EpgSearchTimeValues.java
@@ -0,0 +1,62 @@
+package de.bjusystems.vdrmanager.data;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import android.content.Context;
+import de.bjusystems.vdrmanager.R;
+
+public class EpgSearchTimeValues {
+
+	private final List<EpgSearchTimeValue> values = new ArrayList<EpgSearchTimeValue>();
+	private final Context context;
+
+	public EpgSearchTimeValues(final Context context) {
+
+		this.context = context;
+	}
+
+	public List<EpgSearchTimeValue> getValues() {
+
+		final Preferences prefs = Preferences.getPreferences();
+
+		// fixed values for now and next
+		values.add(new EpgSearchTimeValue(0, context.getString(R.string.epg_list_time_now)));
+		values.add(new EpgSearchTimeValue(1, context.getString(R.string.epg_list_time_next)));
+
+		// get user defined values
+		final String userValueString = prefs.getEpgSearchTimes();
+
+		final String[] userValues = userValueString.split(",");
+
+		Arrays.sort(userValues);
+
+		for(final String userValue : userValues) {
+			if (userValue.contains(":")) {
+				values.add(new EpgSearchTimeValue(values.size(), userValue));
+			}
+		}
+
+		return values;
+	}
+
+	public void saveValues(final List<EpgSearchTimeValue> values) {
+
+		// get old values
+		final Preferences prefs = Preferences.getPreferences();
+
+		// add value
+		String newValues = "";
+		for(int i = 2; i < values.size(); i++) {
+			final EpgSearchTimeValue value = values.get(i);
+			if (newValues.length() > 0) {
+				newValues += ",";
+			}
+			newValues += value.toString();
+		}
+
+		// save new values
+		prefs.setEpgSearchTimes(context, newValues);
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/data/Event.java b/vdrmanager/src/de/bjusystems/vdrmanager/data/Event.java
new file mode 100644
index 0000000..6fa192d
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/data/Event.java
@@ -0,0 +1,21 @@
+package de.bjusystems.vdrmanager.data;
+
+import java.util.Date;
+
+public interface Event {
+
+	public enum TimerState {
+		None,
+		Active,
+		Inactive,
+		Recording
+	}
+
+	String getChannelNumber();
+	String getChannelName();
+	String getTitle();
+	String getDescription();
+	Date getStart();
+	Date getStop();
+	TimerState getTimerState();
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/data/EventFormatter.java b/vdrmanager/src/de/bjusystems/vdrmanager/data/EventFormatter.java
new file mode 100644
index 0000000..430bca4
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/data/EventFormatter.java
@@ -0,0 +1,43 @@
+package de.bjusystems.vdrmanager.data;
+
+import de.bjusystems.vdrmanager.utils.date.DateFormatter;
+
+public class EventFormatter {
+
+	private String time;
+	private final String date;
+	private final String longDate;
+	private final String title;
+	private final String description;
+
+	public EventFormatter(final Event event) {
+		DateFormatter formatter = new DateFormatter(event.getStart());
+		this.date = formatter.getDateString();
+		this.longDate = formatter.getDailyHeader();
+		this.time = formatter.getTimeString();
+		formatter = new DateFormatter(event.getStop());
+		this.time += " - " + formatter.getTimeString();
+		this.title = event.getTitle().replace("|##", ":").replace("||#", "\n");
+		this.description = event.getDescription().replace("|##", ":").replace("||#", "\n");
+	}
+
+	public String getTime() {
+		return time;
+	}
+
+	public String getDate() {
+		return date;
+	}
+
+	public String getLongDate() {
+		return longDate;
+	}
+
+	public String getTitle() {
+		return title;
+	}
+
+	public String getDescription() {
+		return description;
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/data/EventListItem.java b/vdrmanager/src/de/bjusystems/vdrmanager/data/EventListItem.java
new file mode 100644
index 0000000..b9370a1
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/data/EventListItem.java
@@ -0,0 +1,100 @@
+package de.bjusystems.vdrmanager.data;
+
+import java.util.Date;
+
+
+public class EventListItem implements Event {
+
+	private final Timer timer;
+	private final Epg epg;
+	private final String header;
+	private final Event event;
+
+	public EventListItem(final Timer timer) {
+		this.header = null;
+		this.timer = timer;
+		this.epg = null;
+		this.event = timer;
+	}
+
+	public EventListItem(final Epg epg) {
+		this.header = null;
+		this.timer = null;
+		this.epg = epg;
+		this.event = epg;
+	}
+
+	public EventListItem(final String header) {
+		this.header = header;
+		this.timer = null;
+		this.epg = null;
+		this.event = null;
+	}
+
+	public boolean isHeader() {
+		return header != null;
+	}
+
+	public boolean isTimer() {
+		return timer != null;
+	}
+
+	public Date getStart() {
+		return event != null ? event.getStart() : null;
+	}
+
+	public Date getStop() {
+		return event != null ? event.getStop() : null;
+	}
+
+	public String getChannelNumber() {
+		return event != null ? event.getChannelNumber() : null;
+	}
+
+	public String getChannelName() {
+		return event != null ? event.getChannelName() : null;
+	}
+
+	public String getTitle() {
+		return event != null ? event.getTitle() : null;
+	}
+
+	public String getDescription() {
+		return event != null ? event.getDescription() : null;
+	}
+
+	public String getHeader() {
+		return header;
+	}
+
+	public TimerState getTimerState() {
+		return event != null ? event.getTimerState() : TimerState.None;
+	}
+
+	public Timer getTimer() {
+		return timer;
+	}
+
+	public Epg getEpg() {
+		return epg;
+	}
+
+	public Event getEvent() {
+		return event;
+	}
+
+	@Override
+	public String toString() {
+		if (isHeader()) {
+			return "Header: " + header;
+		}
+
+		final EventFormatter formatter = new EventFormatter(event);
+		final StringBuilder text = new StringBuilder();
+		text.append(isTimer() ? "Timer: " : "Event: ");
+		text.append("Channel: ").append(event.getChannelNumber());
+		text.append(" (").append(event.getChannelName()).append("), ");
+		text.append("Zeit: ").append(formatter.getDate()).append(" ").append(formatter.getTime());
+		return text.toString();
+	}
+}
\ No newline at end of file
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/data/MenuActionHandler.java b/vdrmanager/src/de/bjusystems/vdrmanager/data/MenuActionHandler.java
new file mode 100644
index 0000000..b1f1d2e
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/data/MenuActionHandler.java
@@ -0,0 +1,16 @@
+package de.bjusystems.vdrmanager.data;
+
+import android.content.Context;
+
+
+/**
+ * Handler for menu actions
+ * @author bju
+ */
+public interface MenuActionHandler {
+
+	/**
+	 * Execute the action
+	 */
+	void executeAction(Context context);
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/data/Preferences.java b/vdrmanager/src/de/bjusystems/vdrmanager/data/Preferences.java
new file mode 100644
index 0000000..3e1fc8a
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/data/Preferences.java
@@ -0,0 +1,301 @@
+package de.bjusystems.vdrmanager.data;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import de.bjusystems.vdrmanager.R;
+
+/**
+ * Class for all preferences
+ * @author bju
+ */
+public class Preferences {
+
+	private boolean ssl;
+	/** SVDRP host name or ip */
+	private String svdrpHost;
+	/** SVDRP port */
+	private int svdrpPort;
+	/** Password */
+	private String password;
+	/** should channels be filtered? */
+	private boolean filterChannels;
+	/** last channel to retrieve */
+	private String channels;
+	/** Enable remote wakeup */
+	private boolean wakeupEnabled;
+	/** URL of the wakeup script */
+	private String wakeupUrl;
+	/** User for wakeup */
+	private String wakeupUser;
+	/** Password for wakeup */
+	private String wakeupPassword;
+	/** Check for running VDR is enabled */
+	private boolean aliveCheckEnabled;
+	/** Intervall for alive test */
+	private int aliveCheckInterval;
+	/** Buffer before event */
+	private int timerPreMargin;
+	/** Buffer after event */
+	private int timerPostMargin;
+	/** Default priority */
+	private int timerDefaultPriority;
+	/** Default lifetime */
+	private int timerDefaultLifetime;
+	/** user defined epg search times */
+	private String epgSearchTimes;
+
+	/** Properties singleton */
+	private static Preferences thePrefs;
+
+	/**
+	 * Checks for connect using SSL
+	 * @return true, if use SSL connections
+	 */
+	public boolean isSSL() {
+		return ssl;
+	}
+
+	/**
+	 * Retrieves the channel filtering mode
+	 * @return true, if channels will be filtered
+	 */
+	public boolean isFilterChannels() {
+		return filterChannels;
+	}
+
+	/**
+	 * Last channel to receive
+	 * @return channel number
+	 */
+	public String getChannels() {
+		return filterChannels ? channels : "";
+	}
+
+	/**
+	 * Gets the SVDRP host or IP address
+	 * @return SVDRP host
+	 */
+	public String getSvdrpHost() {
+		return svdrpHost;
+	}
+
+	/**
+	 * Gets the SVDRP port
+	 * @return SVDRP port
+	 */
+	public int getSvdrpPort() {
+		return svdrpPort;
+	}
+
+	/**
+	 * Gets the SVDRP password
+	 * @return SVDRO password
+	 */
+	public String getPassword() {
+		return password;
+	}
+
+	/**
+	 * Checks for enables remote wakeup
+	 * @return true, if remote wakeup is enabled
+	 */
+	public boolean isWakeupEnabled() {
+		return wakeupEnabled;
+	}
+
+	/**
+	 * Gets the URL for the wakeup request
+	 * @return wakeup url
+	 */
+	public String getWakeupUrl() {
+		return wakeupUrl;
+	}
+
+	/**
+	 * Gets the user for the wakeup url
+	 * @return user name
+	 */
+	public String getWakeupUser() {
+		return wakeupUser;
+	}
+
+	/**
+	 * Gets the password for the wakeup url
+	 * @return password
+	 */
+	public String getWakeupPassword() {
+		return wakeupPassword;
+	}
+
+	/**
+	 * Checks for enabled alive check
+	 * @return true, if enabled
+	 */
+	public boolean isAliveCheckEnabled() {
+		return aliveCheckEnabled;
+	}
+
+	/**
+	 * Gets the time between alive checks
+	 * @return time in seconds
+	 */
+	public int getAliveCheckInterval() {
+		return aliveCheckInterval;
+	}
+
+	/**
+	 * Gets the buffer before the event start
+	 * @return pre event buffer
+	 */
+	public int getTimerPreMargin() {
+		return timerPreMargin;
+	}
+
+	/**
+	 * Gets the buffer after the event stop
+	 * @return post event buffer
+	 */
+	public int getTimerPostMargin() {
+		return timerPostMargin;
+	}
+
+	/**
+	 * Gets the default priority
+	 * @return default priority
+	 */
+	public int getTimerDefaultPriority() {
+		return timerDefaultPriority;
+	}
+
+	/**
+	 * Gets the default lifetime
+	 * @return default lifetime
+	 */
+	public int getTimerDefaultLifetime() {
+		return timerDefaultLifetime;
+	}
+
+	/**
+	 * Gets the time values for the epg search
+	 * @return
+	 */
+	public String getEpgSearchTimes() {
+			return epgSearchTimes;
+	}
+
+	/**
+	 * Sets the time values for the epg search
+	 * @param epgSearchTimes new time values
+	 */
+	public void setEpgSearchTimes(final Context context, final String epgSearchTimes) {
+
+		final SharedPreferences prefs = getSharedPreferences(context);
+		final SharedPreferences.Editor editor = prefs.edit();
+		editor.putString(context.getString(R.string.epg_search_times_key), epgSearchTimes);
+		editor.commit();
+
+		// reload
+		loadPreferences(context);
+	}
+
+	/**
+	 * Gets the name for the file which preferences will be saved into
+	 * @param context Context
+	 * @return filename
+	 */
+	public static String getPreferenceFile(final Context context) {
+		return context.getString(R.string.app_name);
+	}
+
+	/**
+	 * Gets the previous loaded preferences
+	 * @return preferences
+	 */
+	public static Preferences getPreferences() {
+		return thePrefs;
+	}
+
+	/**
+	 * Loads all preferences
+	 * @param context Context
+	 * @return Preferences
+	 */
+	public static void loadPreferences(final Context context) {
+
+		final SharedPreferences sharedPrefs = getSharedPreferences(context);
+
+		final Preferences prefs = new Preferences();
+
+		prefs.svdrpHost = getString(context, sharedPrefs, R.string.vdr_host_key, "10.0.2.2");
+		prefs.svdrpPort = getInt(context, sharedPrefs, R.string.vdr_port_key, 6419);
+		prefs.password = getString(context, sharedPrefs, R.string.vdr_password_key, "");
+		prefs.ssl = getBoolean(context, sharedPrefs, R.string.vdr_ssl_key, false);
+
+		prefs.aliveCheckEnabled = getBoolean(context, sharedPrefs, R.string.alive_check_enabled_key, false);
+		prefs.aliveCheckInterval = getInt(context, sharedPrefs, R.string.alive_check_interval_key, 60);
+
+		prefs.channels = getString(context, sharedPrefs, R.string.channel_filter_last_key, "").replace(" ", "");
+		prefs.filterChannels = getBoolean(context, sharedPrefs, R.string.channel_filter_filter_key, false);
+
+		prefs.wakeupEnabled = getBoolean(context, sharedPrefs, R.string.wakeup_enabled_key, false);
+		prefs.wakeupUrl = getString(context, sharedPrefs, R.string.wakeup_url_key, "");
+		prefs.wakeupUser = getString(context, sharedPrefs, R.string.wakeup_user_key, "");
+		prefs.wakeupPassword = getString(context, sharedPrefs, R.string.wakeup_password_key, "");
+
+		prefs.timerPreMargin = getInt(context, sharedPrefs, R.string.timer_pre_start_buffer_key, 5);
+		prefs.timerPostMargin = getInt(context, sharedPrefs, R.string.timer_post_end_buffer_key, 30);
+		prefs.timerDefaultPriority = getInt(context, sharedPrefs, R.string.timer_default_priority_key, 99);
+		prefs.timerDefaultLifetime = getInt(context, sharedPrefs, R.string.timer_default_lifetime_key, 99);
+
+		prefs.epgSearchTimes = getString(context, sharedPrefs, R.string.epg_search_times_key, "");
+
+		thePrefs = prefs;
+	}
+
+	/**
+	 * Gets the persistent preferences
+	 * @param context Context
+	 * @return preferences
+	 */
+	private static SharedPreferences getSharedPreferences(final Context context) {
+
+		return context.getSharedPreferences(getPreferenceFile(context), Context.MODE_PRIVATE);
+	}
+
+	/**
+	 * Helper for retrieving integer values from preferences
+	 * @param context Context
+	 * @param sharedPrefs Object for the preference file
+	 * @param resId ressource id of the preferences name
+	 * @param defValue default value
+	 * @return value or the default value if not defined
+	 */
+	private static int getInt(final Context context, final SharedPreferences sharedPrefs, final int resId, final int defValue) {
+		final String value = getString(context, sharedPrefs, resId, String.valueOf(defValue));
+		return Integer.parseInt(value);
+	}
+
+	/**
+	 * Helper for retrieving boolean values from preferences
+	 * @param context Context
+	 * @param sharedPrefs Object for the preference file
+	 * @param resId ressource id of the preferences name
+	 * @param defValue default value
+	 * @return value or the default value if not defined
+	 */
+	private static boolean getBoolean(final Context context, final SharedPreferences sharedPrefs, final int resId, final boolean defValue) {
+		return sharedPrefs.getBoolean(context.getString(resId), defValue);
+	}
+
+	/**
+	 * Helper for retrieving string values from preferences
+	 * @param context Context
+	 * @param sharedPrefs Object for the preference file
+	 * @param resId ressource id of the preferences name
+	 * @param defValue default value
+	 * @return value or the default value if not defined
+	 */
+	private static String getString(final Context context, final SharedPreferences sharedPrefs, final int resId, final String defValue) {
+		return sharedPrefs.getString(context.getString(resId), defValue);
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/data/Timer.java b/vdrmanager/src/de/bjusystems/vdrmanager/data/Timer.java
new file mode 100644
index 0000000..8ce34d5
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/data/Timer.java
@@ -0,0 +1,186 @@
+package de.bjusystems.vdrmanager.data;
+
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+
+/**
+ * Class for timer data
+ * @author bju
+ */
+public class Timer implements Event {
+
+	private static final int ENABLED = 1;
+	private static final int INSTANT = 2;
+	private static final int VPS = 4;
+	private static final int RECORDING = 8;
+
+	private final int number;
+	private int flags;
+	private String title;
+	private String description;
+	private Date start;
+	private Date stop;
+	private final String channelNumber;
+	private final String channelName;
+	private final int priority;
+	private final int lifetime;
+
+
+	/**
+	 * Constructs a timer from SvdrpHelper result line
+	 * @param timerData result line
+	 * @param channels list of channels
+	 */
+	public Timer(final String timerData) {
+
+		final String[] values = timerData.split(":");
+
+		// number
+		this.number = Integer.valueOf(values[0].substring(1));
+
+		// flags, channel number and channel name
+		this.flags = Integer.valueOf(values[1]);
+		this.channelNumber = values[2];
+		this.channelName = values[3];
+
+		// get start and stop
+		this.start = new Date(Long.parseLong(values[4]) * 1000);
+		this.stop = new Date(Long.parseLong(values[5]) * 1000);
+
+		// priority and lifetime
+		this.priority = Integer.valueOf(values[6]);
+		this.lifetime = Integer.valueOf(values[7]);
+
+		// title and description
+		this.title = values[8];
+		this.description = values.length > 9 ? values[9] : "";
+	}
+
+	public Timer(final Epg event) {
+
+		final Preferences prefs = Preferences.getPreferences();
+
+		this.number = 0;
+		this.flags = ENABLED;
+		this.channelNumber = event.getChannelNumber();
+		this.channelName = event.getChannelName();
+		this.priority = prefs.getTimerDefaultPriority();
+		this.lifetime = prefs.getTimerDefaultLifetime();
+
+		this.start = new Date(event.getStart().getTime() - prefs.getTimerPreMargin() * 60000);
+		this.stop = new Date(event.getStop().getTime() + prefs.getTimerPostMargin() * 60000);
+
+		this.title = event.getTitle();
+		this.description = event.getDescription();
+	}
+
+	public String toCommandLine() {
+
+		final StringBuilder line = new StringBuilder();
+
+		line.append(number).append(":");
+		line.append(flags).append(":");
+		line.append(channelNumber).append(":");
+
+		final Calendar cal = new GregorianCalendar();
+		cal.setTime(start);
+		line.append(String.format("%04d-%02d-%02d:", cal.get(Calendar.YEAR), cal.get(Calendar.MONTH)+1, cal.get(Calendar.DAY_OF_MONTH)));
+		line.append(String.format("%02d%02d:", cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE)));
+
+		cal.setTime(stop);
+		line.append(String.format("%02d%02d:", cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE)));
+
+		line.append(priority).append(":");
+		line.append(lifetime).append(":");
+		line.append(title).append(":");
+		line.append(description);
+
+		return line.toString();
+	}
+
+	public String getDescription() {
+		return description;
+	}
+
+	public void setDescription(final String description) {
+		this.description = description;
+	}
+
+	public int getNumber() {
+		return number;
+	}
+
+	public Date getStart() {
+		return start;
+	}
+
+	public Date getStop() {
+		return stop;
+	}
+
+	public String getTitle() {
+		return title;
+	}
+
+	public void setTitle(final String title) {
+		this.title = title;
+	}
+
+	public String getChannelNumber() {
+		return channelNumber;
+	}
+
+	public String getChannelName() {
+		return channelName;
+	}
+
+	public int getPriority() {
+		return priority;
+	}
+
+	public int getLifetime() {
+		return lifetime;
+	}
+
+	public TimerState getTimerState() {
+		if (isEnabled()) {
+			if (isRecording()) {
+				return TimerState.Recording;
+			}
+			return TimerState.Active;
+		}
+		return TimerState.Inactive;
+	}
+
+	public boolean isEnabled() {
+		return (flags & ENABLED) == ENABLED;
+	}
+
+	public boolean isInstant() {
+		return (flags & INSTANT) == INSTANT;
+	}
+
+	public boolean isVps() {
+		return (flags & VPS) == VPS;
+	}
+	public boolean isRecording() {
+		return (flags & RECORDING) == RECORDING;
+	}
+
+	public void setStart(final Date start) {
+		this.start = start;
+	}
+
+	public void setStop(final Date stop) {
+		this.stop = stop;
+	}
+
+	public void setEnabled(final boolean enabled) {
+		if (enabled) {
+			flags = flags | ENABLED;
+		} else {
+			flags = flags & ~ENABLED;
+		}
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/data/WakeupState.java b/vdrmanager/src/de/bjusystems/vdrmanager/data/WakeupState.java
new file mode 100644
index 0000000..f7917d8
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/data/WakeupState.java
@@ -0,0 +1,36 @@
+package de.bjusystems.vdrmanager.data;
+
+public class WakeupState {
+
+	public static WakeupState OK = new WakeupState(0);
+	public static WakeupState FAILED = new WakeupState(1);
+	public static WakeupState ERROR = new WakeupState(2);
+
+	private final int value;
+	private static WakeupState state;
+
+	private WakeupState(final int value) {
+		this.value = value;
+	}
+
+	public static WakeupState getState() {
+		return state;
+	}
+
+	public static void setState(final WakeupState state) {
+		WakeupState.state = state;
+	}
+
+	@Override
+	public boolean equals(final Object o) {
+		if (!(o instanceof WakeupState)) {
+			return false;
+		}
+		return this.value == ((WakeupState)o).value;
+	}
+
+	@Override
+	public int hashCode() {
+		return Integer.valueOf(value).hashCode();
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/gui/ChannelAdapter.java b/vdrmanager/src/de/bjusystems/vdrmanager/gui/ChannelAdapter.java
new file mode 100644
index 0000000..c609813
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/gui/ChannelAdapter.java
@@ -0,0 +1,75 @@
+package de.bjusystems.vdrmanager.gui;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ArrayAdapter;
+import android.widget.ImageView;
+import android.widget.TextView;
+import de.bjusystems.vdrmanager.R;
+import de.bjusystems.vdrmanager.data.Channel;
+
+class ChannelAdapter extends ArrayAdapter<Channel> {
+
+	private final LayoutInflater inflater;
+	private final List<Channel> items;
+
+	public ChannelAdapter(final Context context) {
+		super(context, R.layout.channel_item);
+		inflater = LayoutInflater.from(context);
+		items = new ArrayList<Channel>();
+	}
+
+	@Override
+	public View getView(final int position, final View convertView, final ViewGroup parent) {
+
+		ChannelHolder itemHolder = new ChannelHolder();
+
+		// recycle view?
+		View view = convertView;
+		if (view == null) {
+			view = inflater.inflate(R.layout.channel_item, null);
+			itemHolder = new ChannelHolder();
+
+			itemHolder.name = (TextView) view.findViewById(R.id.channel_name);
+			itemHolder.type = (ImageView) view.findViewById(R.id.channel_type);
+
+			view.setTag(itemHolder);
+		} else {
+			itemHolder = (ChannelHolder) view.getTag();
+		}
+
+		// get item
+		final Channel item = getItem(position);
+
+		// fill item
+		if (item.isGroupSeparator()) {
+			view.setPadding(view.getPaddingLeft(), 0, view.getPaddingRight(), 0);
+			view.setBackgroundColor(Color.DKGRAY);
+			itemHolder.type.setVisibility(View.GONE);
+			itemHolder.name.setVisibility(View.VISIBLE);
+			itemHolder.name.setText(item.getName());
+			itemHolder.name.setPadding(0, 0, 0, 0);
+		} else {
+			view.setBackgroundColor(Color.BLACK);
+			itemHolder.type.setVisibility(View.VISIBLE);
+			itemHolder.type.setVisibility(View.VISIBLE);
+			itemHolder.name.setText(item.toString());
+		}
+
+		return view;
+	}
+
+	public void addItem(final Channel channel) {
+		items.add(channel);
+	}
+
+	public void clearItems() {
+		items.clear();
+	}
+}
\ No newline at end of file
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/gui/ChannelHolder.java b/vdrmanager/src/de/bjusystems/vdrmanager/gui/ChannelHolder.java
new file mode 100644
index 0000000..ef09410
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/gui/ChannelHolder.java
@@ -0,0 +1,9 @@
+package de.bjusystems.vdrmanager.gui;
+
+import android.widget.ImageView;
+import android.widget.TextView;
+
+class ChannelHolder {
+	public ImageView type;
+	public TextView name;
+}
\ No newline at end of file
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/gui/ChannelListActivity.java b/vdrmanager/src/de/bjusystems/vdrmanager/gui/ChannelListActivity.java
new file mode 100644
index 0000000..ac12efd
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/gui/ChannelListActivity.java
@@ -0,0 +1,187 @@
+package de.bjusystems.vdrmanager.gui;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.AdapterView;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.ListView;
+import de.bjusystems.vdrmanager.R;
+import de.bjusystems.vdrmanager.app.VdrManagerApp;
+import de.bjusystems.vdrmanager.data.Channel;
+import de.bjusystems.vdrmanager.data.Preferences;
+import de.bjusystems.vdrmanager.utils.svdrp.ChannelClient;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpAsyncListener;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpAsyncTask;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpClient;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpEvent;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpException;
+
+/**
+ * This class is used for showing what's
+ * current running on all channels
+ * @author bju
+ */
+public class ChannelListActivity extends Activity
+															   implements OnItemClickListener, SvdrpAsyncListener<Channel> {
+
+	ChannelClient channelClient;
+	ChannelAdapter adapter;
+	Preferences prefs;
+	List<Channel> channels;
+	SvdrpProgressDialog progress;
+
+	@Override
+	protected void onCreate(final Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		// Attach view
+		setContentView(R.layout.channel_list);
+
+		// Create adapter for ListView
+		adapter = new ChannelAdapter(this);
+		final ListView listView = (ListView) findViewById(R.id.channel_list);
+		listView.setAdapter(adapter);
+		// register context menu
+		registerForContextMenu(listView);
+
+
+		// create channel list
+		channels = new ArrayList<Channel>();
+
+		listView.setOnItemClickListener(this);
+	}
+
+	public void onItemClick(final AdapterView<?> parent, final View view, final int position, final long id) {
+
+		// find and remember item
+		final Channel channel =  (Channel) parent.getAdapter().getItem(position);
+		final VdrManagerApp app = (VdrManagerApp) getApplication();
+		app.setCurrentChannel(channel);
+		app.setChannels(channels);
+
+		// show details
+		final Intent intent = new Intent();
+		intent.setClass(this, EpgListActivity.class);
+		startActivity(intent);
+	}
+
+
+
+	@Override
+	protected void onResume() {
+		super.onResume();
+		startChannelQuery();
+	}
+
+	@Override
+	protected void onPause() {
+		super.onPause();
+		if (channelClient != null) {
+			channelClient.abort();
+		}
+		if (progress != null) {
+			progress.dismiss();
+			progress = null;
+		}
+	}
+
+	private void startChannelQuery() {
+
+		// get channel task
+		channelClient = new ChannelClient();
+
+		// create background task
+		final SvdrpAsyncTask<Channel, SvdrpClient<Channel>> task = new SvdrpAsyncTask<Channel, SvdrpClient<Channel>>(channelClient);
+
+		// create progress
+		progress = new SvdrpProgressDialog(this, channelClient);
+
+		// attach listener
+		task.addListener(this);
+
+		// start task
+		task.run();
+	}
+
+	public void svdrpEvent(final SvdrpEvent event, final Channel result) {
+
+		if (progress != null) {
+			progress.svdrpEvent(event);
+		}
+
+		switch (event) {
+		case CONNECTING:
+			adapter.clear();
+			channels.clear();
+			break;
+		case LOGIN_ERROR:
+			this.finish();
+			break;
+		case FINISHED:
+			channels.addAll(channelClient.getResults());
+			for(final Channel channel : channels) {
+				adapter.add(channel);
+			}
+			progress = null;
+		}
+	}
+
+	public void svdrpException(final SvdrpException exception) {
+		if (progress != null) {
+			progress.svdrpException(exception);
+		}
+	}
+
+	@Override
+	public void onCreateContextMenu(final ContextMenu menu, final View v, final ContextMenuInfo menuInfo) {
+		super.onCreateContextMenu(menu, v, menuInfo);
+
+		if (v.getId() == R.id.channel_list) {
+	    final MenuInflater inflater = getMenuInflater();
+	    final AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo)menuInfo;
+
+	    // set menu title
+	    final Channel item = adapter.getItem(info.position);
+	    menu.setHeaderTitle(item.getName());
+
+	    inflater.inflate(R.menu.channel_list_item_menu, menu);
+		}
+	}
+
+
+
+	@Override
+	public boolean onContextItemSelected(final MenuItem item) {
+
+    final AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo)item.getMenuInfo();
+    final Channel channel = adapter.getItem(info.position);
+
+    switch (item.getItemId()) {
+    case R.id.channel_item_menu_epg:
+    	onItemClick(null, null, info.position, 0);
+    	break;
+    case R.id.channel_item_menu_stream:
+    	// show live stream
+    	showStream(channel);
+    	break;
+		}
+
+		return true;
+	}
+
+	private void showStream(final Channel channel) {
+  	// show stream
+		final Intent intent = new Intent();
+		intent.setClass(this, VideoActivity.class);
+		startActivity(intent);
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/gui/EpgDetailsActivity.java b/vdrmanager/src/de/bjusystems/vdrmanager/gui/EpgDetailsActivity.java
new file mode 100644
index 0000000..7932e86
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/gui/EpgDetailsActivity.java
@@ -0,0 +1,91 @@
+package de.bjusystems.vdrmanager.gui;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.util.TypedValue;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.TextView;
+import de.bjusystems.vdrmanager.R;
+import de.bjusystems.vdrmanager.app.VdrManagerApp;
+import de.bjusystems.vdrmanager.data.Epg;
+import de.bjusystems.vdrmanager.data.EventFormatter;
+import de.bjusystems.vdrmanager.data.Preferences;
+
+/**
+ * This class is used for showing what's
+ * current running on all channels
+ * @author bju
+ */
+public class EpgDetailsActivity extends Activity
+				implements OnClickListener {
+
+	Preferences prefs;
+
+	@Override
+	protected void onCreate(final Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		// Attach view
+		setContentView(R.layout.epg_detail);
+
+
+    // current event
+		final VdrManagerApp app = (VdrManagerApp) getApplication();
+    final Epg event = app.getCurrentEvent();
+    final EventFormatter formatter = new EventFormatter(event);
+
+    final TextView title = (TextView)findViewById(R.id.epg_detail_title);
+    title.setText(formatter.getTitle());
+    title.setTextSize(TypedValue.COMPLEX_UNIT_PX, title.getTextSize()*(float)1.3);
+
+    ((TextView) findViewById(R.id.epg_detail_time)).setText(formatter.getTime());
+    ((TextView)findViewById(R.id.epg_detail_channel)).setText(event.getChannelName());
+    ((TextView)findViewById(R.id.epg_detail_date)).setText(formatter.getLongDate());
+    final TextView textView = (TextView)findViewById(R.id.epg_detail_description);
+    textView.setText(formatter.getDescription());
+
+    // copy color for separator lines
+    final int color = textView.getTextColors().getDefaultColor();
+    ((TextView)findViewById(R.id.epg_detail_separator_1)).setBackgroundColor(color);
+    ((TextView)findViewById(R.id.epg_detail_separator_2)).setBackgroundColor(color);
+
+    // register button handler
+    final Button timeButton = (Button) findViewById(R.id.epg_event_create_timer);
+    timeButton.setOnClickListener(this);
+
+    // set button text
+    if (event.getTimer() == null) {
+    	timeButton.setText(R.string.epg_event_create_timer_text);
+    } else {
+    	timeButton.setText(R.string.epg_event_modify_timer_text);
+    }
+
+    // clear list of activities to finish
+    app.clearActivitiesToFinish();
+	}
+
+	@Override
+	protected void onResume() {
+		super.onResume();
+	}
+
+	@Override
+	protected void onPause() {
+		super.onPause();
+	}
+
+	public void onClick(final View v) {
+
+		// after timer creation/modification return to the epg list
+		final VdrManagerApp app = (VdrManagerApp) getApplication();
+		app.addActivityToFinish(this);
+
+		// show timer details
+		final Intent intent = new Intent();
+		intent.setClass(this, TimerDetailsActivity.class);
+		startActivity(intent);
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/gui/EpgListActivity.java b/vdrmanager/src/de/bjusystems/vdrmanager/gui/EpgListActivity.java
new file mode 100644
index 0000000..34ec06a
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/gui/EpgListActivity.java
@@ -0,0 +1,408 @@
+package de.bjusystems.vdrmanager.gui;
+
+import java.util.List;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.AdapterView;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.AdapterView.OnItemSelectedListener;
+import android.widget.ArrayAdapter;
+import android.widget.LinearLayout;
+import android.widget.ListView;
+import android.widget.Spinner;
+import android.widget.TextView;
+import de.bjusystems.vdrmanager.R;
+import de.bjusystems.vdrmanager.app.VdrManagerApp;
+import de.bjusystems.vdrmanager.data.Channel;
+import de.bjusystems.vdrmanager.data.Epg;
+import de.bjusystems.vdrmanager.data.EpgSearchParams;
+import de.bjusystems.vdrmanager.data.EpgSearchTimeValue;
+import de.bjusystems.vdrmanager.data.EpgSearchTimeValues;
+import de.bjusystems.vdrmanager.data.EventFormatter;
+import de.bjusystems.vdrmanager.data.EventListItem;
+import de.bjusystems.vdrmanager.data.Preferences;
+import de.bjusystems.vdrmanager.tasks.DeleteTimerTask;
+import de.bjusystems.vdrmanager.tasks.ToggleTimerTask;
+import de.bjusystems.vdrmanager.utils.svdrp.EpgClient;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpAsyncListener;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpAsyncTask;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpClient;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpEvent;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpException;
+
+/**
+ * This class is used for showing what's
+ * current running on all channels
+ * @author bju
+ */
+public class EpgListActivity extends Activity
+				implements OnItemClickListener, OnItemSelectedListener, SvdrpAsyncListener<Epg> {
+
+	EpgClient epgClient;
+	EventAdapter adapter;
+	Preferences prefs;
+	Spinner timeSpinner;
+	Spinner channelSpinner;
+	ArrayAdapter<EpgSearchTimeValue> timeSpinnerAdapter;
+	ListView listView;
+	SvdrpProgressDialog progress;
+
+	@Override
+	protected void onCreate(final Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		// application object
+		final VdrManagerApp app = (VdrManagerApp)getApplication();
+		// get state
+		final Channel channel = ((VdrManagerApp) getApplication()).getCurrentChannel();
+		final List<Channel> channels = ((VdrManagerApp) getApplication()).getChannels();
+
+		// Attach view
+		setContentView(R.layout.epg_list);
+
+		// create adapter for time spinner
+		timeSpinnerAdapter = new ArrayAdapter<EpgSearchTimeValue>(this, android.R.layout.simple_spinner_item);
+		timeSpinnerAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
+		timeSpinner = (Spinner) findViewById(R.id.epg_list_time_spinner);
+		timeSpinner.setAdapter(timeSpinnerAdapter);
+
+		// create adapter for channel spinner
+		final ArrayAdapter<Channel> channelSpinnerAdapter = new ArrayAdapter<Channel>(this, android.R.layout.simple_spinner_item);
+		channelSpinnerAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
+		channelSpinner = (Spinner) findViewById(R.id.epg_list_channel_spinner);
+		channelSpinner.setAdapter(channelSpinnerAdapter);
+
+		// get search label
+		final TextView searchLabel = (TextView) findViewById(R.id.epg_list_search_label);
+
+		// fill spinners
+		if (channels != null) {
+			// add dummy timer
+			timeSpinnerAdapter.add(new EpgSearchTimeValue());
+			// add channel values
+			for(final Channel c : channels) {
+				channelSpinnerAdapter.add(c);
+			}
+		} else {
+			// add dummy channel
+			channelSpinnerAdapter.add(new Channel());
+			// add time values
+			fillTimeSpinnerValues();
+		}
+
+    // show needed items
+    final LinearLayout timeLayout = (LinearLayout) findViewById(R.id.whatson_time);
+
+    // update gui
+    switch (app.getEpgListState()) {
+    case EPG_TIME:
+  		adapter = new EventAdapter(this, false);
+			timeLayout.setVisibility(View.VISIBLE);
+			channelSpinner.setVisibility(View.GONE);
+			searchLabel.setVisibility(View.GONE);
+			timeSpinner.setOnItemSelectedListener(this);
+			timeSpinner.setSelection(0);
+			break;
+    case EPG_CHANNEL:
+  		adapter = new EventAdapter(this, true);
+			timeLayout.setVisibility(View.GONE);
+			channelSpinner.setVisibility(View.VISIBLE);
+			searchLabel.setVisibility(View.GONE);
+    	channelSpinner.setOnItemSelectedListener(this);
+    	channelSpinner.setSelection(channel.getNumber() - 1);
+			break;
+    case EPG_SEARCH:
+  		adapter = new EventAdapter(this, true);
+			timeLayout.setVisibility(View.GONE);
+			channelSpinner.setVisibility(View.GONE);
+			searchLabel.setVisibility(View.VISIBLE);
+			startSearchEpgQuery(app.getCurrentSearch());
+			break;
+    }
+
+		// Create adapter for EPG list
+		listView = (ListView) findViewById(R.id.whatson_list);
+		listView.setAdapter(adapter);
+		registerForContextMenu(listView);
+
+    // register EPG item click
+    listView.setOnItemClickListener(this);
+
+	}
+
+	@Override
+	protected void onResume() {
+		super.onResume();
+		fillTimeSpinnerValues();
+
+		reloadIfNeeded();
+	}
+
+	private void reloadIfNeeded() {
+
+		final VdrManagerApp app = (VdrManagerApp) getApplication();
+		if (app.isReload()) {
+			app.setReload(false);
+			startEpgQuery(epgClient);
+		}
+	}
+
+	@Override
+	protected void onPause() {
+		super.onPause();
+		if (epgClient != null) {
+			epgClient.abort();
+		}
+		if (progress != null) {
+			progress.dismiss();
+			progress = null;
+		}
+	}
+
+	public void onItemClick(final AdapterView<?> parent, final View view, final int position, final long id) {
+
+		// find and remember item
+		final EventListItem item =  adapter.getItem(position);
+
+		// prepare timer if we want to program
+		prepareTimer(item);
+
+		// show details
+		final Intent intent = new Intent();
+		intent.setClass(this, EpgDetailsActivity.class);
+		startActivity(intent);
+	}
+
+	public void onItemSelected(final AdapterView<?> parent, final View view, final int position, final long id) {
+
+		if (parent == timeSpinner) {
+			// get spinner value
+			final EpgSearchTimeValue selection = (EpgSearchTimeValue) timeSpinner.getSelectedItem();
+			// update search
+			startTimeEpgQuery(selection.getValue());
+		} else {
+			// get spinner value
+			final Channel channel = (Channel) channelSpinner.getSelectedItem();
+			// update search
+			startChannelEpgQuery(channel);
+		}
+	}
+
+	@Override
+	public boolean onCreateOptionsMenu(final Menu menu) {
+		super.onCreateOptionsMenu(menu);
+
+    final MenuInflater inflater = getMenuInflater();
+    inflater.inflate(R.menu.epg_list_menu, menu);
+    return true;
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(final MenuItem item) {
+
+		Intent intent;
+
+		switch (item.getItemId())
+		{
+		case R.id.epg_menu_search:
+			intent = new Intent();
+			intent.setClass(this, EpgSearchActivity.class);
+			startActivity(intent);
+			break;
+		case R.id.epg_menu_times:
+			intent = new Intent();
+			intent.setClass(this, EpgSearchTimesListActivity.class);
+			startActivity(intent);
+			break;
+		}
+		return true;
+	}
+
+	@Override
+	public void onCreateContextMenu(final ContextMenu menu, final View v, final ContextMenuInfo menuInfo) {
+		super.onCreateContextMenu(menu, v, menuInfo);
+
+		if (v.getId() == R.id.whatson_list) {
+	    final MenuInflater inflater = getMenuInflater();
+	    final AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo)menuInfo;
+
+	    // set menu title
+	    final EventListItem item = adapter.getItem(info.position);
+	    final EventFormatter formatter = new EventFormatter(item);
+	    menu.setHeaderTitle(formatter.getTitle());
+
+	    inflater.inflate(R.menu.epg_list_item_menu, menu);
+
+	    // remove unneeded menu items
+	    if (item.getEpg().getTimer() != null) {
+	    	menu.findItem(R.id.epg_item_menu_timer_add).setVisible(false);
+	    	final MenuItem enableMenuItem = menu.findItem(R.id.epg_item_menu_timer_toggle);
+	    	enableMenuItem.setTitle(item.getEpg().getTimer().isEnabled() ? R.string.epg_item_menu_timer_disable : R.string.epg_item_menu_timer_enable);
+	    } else {
+	    	menu.findItem(R.id.epg_item_menu_timer_modify).setVisible(false);
+	    	menu.findItem(R.id.epg_item_menu_timer_delete).setVisible(false);
+	    }
+		}
+	}
+
+
+
+	@Override
+	public boolean onContextItemSelected(final MenuItem item) {
+
+    final AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo)item.getMenuInfo();
+    final EventListItem event = adapter.getItem(info.position);
+
+    switch (item.getItemId()) {
+    case R.id.epg_item_menu_timer_add:
+    case R.id.epg_item_menu_timer_modify:
+    {
+    	prepareTimer(event);
+
+    	final Intent intent = new Intent();
+    	intent.setClass(this, TimerDetailsActivity.class);
+    	startActivity(intent);
+    	break;
+    }
+    case R.id.epg_item_menu_timer_delete:
+    {
+    	deleteTimer(event);
+    	break;
+    }
+    case R.id.epg_item_menu_timer_toggle:
+    {
+    	toggleTimer(event);
+    }
+		}
+
+		return true;
+	}
+
+	public void onNothingSelected(final AdapterView<?> arg0) {
+		//startTimeEpgQuery(((EpgTimeSpinnerValue)timeSpinner.getAdapter().getItem(0)).getValue());
+	}
+
+	private void startSearchEpgQuery(final EpgSearchParams search) {
+
+		epgClient = new EpgClient(search);
+		startEpgQuery(epgClient);
+	}
+
+	private void startTimeEpgQuery(final String time) {
+
+		epgClient = new EpgClient(time);
+		startEpgQuery(epgClient);
+	}
+
+	private void startChannelEpgQuery(final Channel channel) {
+
+		epgClient = new EpgClient(channel);
+		startEpgQuery(epgClient);
+	}
+
+	private void startEpgQuery(final EpgClient epgClient) {
+
+		// remove old listeners
+		epgClient.clearSvdrpListener();
+
+		// create background task
+		final SvdrpAsyncTask<Epg, SvdrpClient<Epg>> task = new SvdrpAsyncTask<Epg, SvdrpClient<Epg>>(epgClient);
+
+		// create progress
+		progress = new SvdrpProgressDialog(this, epgClient);
+
+		// attach listener
+		task.addListener(this);
+
+		// start task
+		task.run();
+	}
+
+	public void svdrpEvent(final SvdrpEvent event, final Epg result) {
+
+		if (progress != null) {
+			progress.svdrpEvent(event);
+		}
+
+		switch (event) {
+		case CONNECTING:
+			adapter.clearItems();
+			break;
+		case LOGIN_ERROR:
+			this.finish();
+			break;
+		case FINISHED:
+			epgClient.clearSvdrpListener();
+			for(final Epg epg : epgClient.getResults()) {
+				adapter.addItem(new EventListItem(epg));
+			}
+			adapter.sortItems();
+			listView.setSelectionAfterHeaderView();
+			progress = null;
+			break;
+		}
+	}
+
+	public void svdrpException(final SvdrpException exception) {
+		if (progress != null) {
+			progress.svdrpException(exception);
+		}
+	}
+
+	private void prepareTimer(final EventListItem item) {
+
+		final VdrManagerApp app = (VdrManagerApp) getApplication();
+
+		// remember event for details view and timer things
+		app.setCurrentEvent(item.getEpg());
+
+		// if we create or modify the attached timer we will return to a new epg list
+		app.clearActivitiesToFinish();
+		app.addActivityToFinish(this);
+		app.setNextActivity(EpgListActivity.class);
+	}
+
+	private void deleteTimer(final EventListItem item) {
+
+		final DeleteTimerTask task = new DeleteTimerTask(this, item.getEpg().getTimer()) {
+			@Override
+			public void finished() {
+				// refresh epg list after return
+				final VdrManagerApp app = (VdrManagerApp) getApplication();
+				app.setReload(true);
+				reloadIfNeeded();
+			}
+		};
+		task.start();
+	}
+
+	private void toggleTimer(final EventListItem item) {
+
+		final ToggleTimerTask task = new ToggleTimerTask(this, item.getEpg().getTimer()) {
+			@Override
+			public void finished() {
+				// refresh epg list after return
+				final VdrManagerApp app = (VdrManagerApp) getApplication();
+				app.setReload(true);
+				reloadIfNeeded();
+			}
+		};
+		task.start();
+	}
+
+	private void fillTimeSpinnerValues() {
+		final EpgSearchTimeValues values = new EpgSearchTimeValues(this);
+		timeSpinnerAdapter.clear();
+		for(final EpgSearchTimeValue value : values.getValues()) {
+			timeSpinnerAdapter.add(value);
+		}
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/gui/EpgSearchActivity.java b/vdrmanager/src/de/bjusystems/vdrmanager/gui/EpgSearchActivity.java
new file mode 100644
index 0000000..90e8c00
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/gui/EpgSearchActivity.java
@@ -0,0 +1,63 @@
+package de.bjusystems.vdrmanager.gui;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.TextView;
+import de.bjusystems.vdrmanager.R;
+import de.bjusystems.vdrmanager.app.VdrManagerApp;
+import de.bjusystems.vdrmanager.data.EpgSearchParams;
+import de.bjusystems.vdrmanager.data.Preferences;
+
+/**
+ * This class is used for showing what's
+ * current running on all channels
+ * @author bju
+ */
+public class EpgSearchActivity extends Activity
+				implements OnClickListener {
+
+	Preferences prefs;
+	TextView text;
+
+	@Override
+	protected void onCreate(final Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		// Attach view
+		setContentView(R.layout.epg_search);
+
+		// save fields
+		text = (TextView) findViewById(R.id.epg_search_text);
+
+    // register button
+    final Button button = (Button) findViewById(R.id.epg_search_button);
+    button.setOnClickListener(this);
+	}
+
+	@Override
+	protected void onResume() {
+		super.onResume();
+	}
+
+	@Override
+	protected void onPause() {
+		super.onPause();
+	}
+
+	public void onClick(final View v) {
+
+		// Save search parameters
+		final EpgSearchParams search = new EpgSearchParams();
+		search.setTitle(text.getText().toString());
+		((VdrManagerApp)getApplication()).setCurrentSearch(search);
+
+		// show timer details
+		final Intent intent = new Intent();
+		intent.setClass(this, EpgListActivity.class);
+		startActivity(intent);
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/gui/EpgSearchTimesListActivity.java b/vdrmanager/src/de/bjusystems/vdrmanager/gui/EpgSearchTimesListActivity.java
new file mode 100644
index 0000000..891babf
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/gui/EpgSearchTimesListActivity.java
@@ -0,0 +1,130 @@
+package de.bjusystems.vdrmanager.gui;
+
+import java.util.List;
+
+import android.app.Activity;
+import android.app.TimePickerDialog;
+import android.app.TimePickerDialog.OnTimeSetListener;
+import android.os.Bundle;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.Button;
+import android.widget.ListView;
+import android.widget.TimePicker;
+import de.bjusystems.vdrmanager.R;
+import de.bjusystems.vdrmanager.data.EpgSearchTimeValue;
+import de.bjusystems.vdrmanager.data.EpgSearchTimeValues;
+import de.bjusystems.vdrmanager.data.Preferences;
+
+/**
+ * This class is used for showing what's
+ * current running on all channels
+ * @author bju
+ */
+public class EpgSearchTimesListActivity extends Activity
+				implements OnClickListener, OnTimeSetListener {
+
+	ArrayAdapter<EpgSearchTimeValue> adapter;
+	List<EpgSearchTimeValue> values;
+	Preferences prefs;
+
+	@Override
+	protected void onCreate(final Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		// Attach view
+		setContentView(R.layout.epg_search_times_list);
+
+		// Create adapter for ListView
+		adapter = new ArrayAdapter<EpgSearchTimeValue>(this, R.layout.epg_search_times_item);
+		final ListView listView = (ListView) findViewById(R.id.epg_search_times_list);
+		listView.setAdapter(adapter);
+		registerForContextMenu(listView);
+
+		// create channel list
+		updateList();
+
+		// button handler
+		final Button addButton = (Button) findViewById(R.id.epg_search_times_add);
+		addButton.setOnClickListener(this);
+	}
+
+	public void onClick(final View v) {
+
+		// show time selection
+		final TimePickerDialog dialog = new TimePickerDialog(this, this, 0, 0, true);
+		dialog.show();
+	}
+
+	public void onTimeSet(final TimePicker view, final int hourOfDay, final int minute) {
+
+		final EpgSearchTimeValue time = new EpgSearchTimeValue(values.size(), String.format("%02d:%02d", hourOfDay, minute));
+		values.add(time);
+		adapter.add(time);
+
+		save();
+
+		updateList();
+	}
+
+	@Override
+	protected void onResume() {
+		super.onResume();
+	}
+
+	@Override
+	protected void onPause() {
+		super.onPause();
+	}
+
+	@Override
+	public void onCreateContextMenu(final ContextMenu menu, final View v, final ContextMenuInfo menuInfo) {
+		super.onCreateContextMenu(menu, v, menuInfo);
+
+		if (v.getId() == R.id.epg_search_times_list) {
+	    final MenuInflater inflater = getMenuInflater();
+	    final AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo)menuInfo;
+	    menu.setHeaderTitle(values.get(info.position+2).toString());
+
+	    inflater.inflate(R.menu.epg_search_time_item_menu, menu);
+		}
+	}
+
+
+
+	@Override
+	public boolean onContextItemSelected(final MenuItem item) {
+
+    final AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo)item.getMenuInfo();
+		final EpgSearchTimeValue time = values.get(info.position+2);
+
+		if (item.getItemId() == R.id.epg_search_time_delete) {
+			values.remove(time);
+			adapter.remove(time);
+
+			save();
+		}
+
+		return true;
+	}
+
+	private void updateList() {
+
+		// get values
+		values = new EpgSearchTimeValues(this).getValues();
+		adapter.clear();
+		for(int i = 2; i < values.size(); i++) {
+			adapter.add(values.get(i));
+		}
+	}
+
+	private void save() {
+		new EpgSearchTimeValues(this).saveValues(values);
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/gui/EventAdapter.java b/vdrmanager/src/de/bjusystems/vdrmanager/gui/EventAdapter.java
new file mode 100644
index 0000000..0a97576
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/gui/EventAdapter.java
@@ -0,0 +1,171 @@
+package de.bjusystems.vdrmanager.gui;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Comparator;
+import java.util.GregorianCalendar;
+import java.util.List;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ArrayAdapter;
+import android.widget.ImageView;
+import android.widget.TextView;
+import de.bjusystems.vdrmanager.R;
+import de.bjusystems.vdrmanager.data.EventFormatter;
+import de.bjusystems.vdrmanager.data.EventListItem;
+import de.bjusystems.vdrmanager.utils.date.DateFormatter;
+
+class EventAdapter extends ArrayAdapter<EventListItem> {
+
+	private final LayoutInflater inflater;
+	private final List<EventListItem> items;
+	private final boolean sortByTime;
+
+	public EventAdapter(final Context context, final boolean sortByTime) {
+		super(context, R.layout.event_item);
+		inflater = LayoutInflater.from(context);
+		items = new ArrayList<EventListItem>();
+		this.sortByTime = sortByTime;
+	}
+
+	@Override
+	public View getView(final int position, final View convertView, final ViewGroup parent) {
+
+		EventListItemHolder itemHolder = new EventListItemHolder();
+
+		// recycle view?
+		View view = convertView;
+		if (view == null) {
+			view = inflater.inflate(R.layout.event_item, null);
+			itemHolder = new EventListItemHolder();
+
+			itemHolder.state = (ImageView) view.findViewById(R.id.timer_item_state);
+			itemHolder.time = (TextView) view.findViewById(R.id.timer_item_time);
+			itemHolder.channel = (TextView) view.findViewById(R.id.timer_item_channel);
+			itemHolder.title = (TextView) view.findViewById(R.id.timer_item_title);
+
+			view.setTag(itemHolder);
+		} else {
+			itemHolder = (EventListItemHolder) view.getTag();
+		}
+
+		// get item
+		final EventListItem item = getItem(position);
+
+		// fill item
+		if (item.isHeader()) {
+			view.setPadding(view.getPaddingLeft(), 0, view.getPaddingRight(), 0);
+			view.setBackgroundColor(Color.DKGRAY);
+			itemHolder.state.setVisibility(View.GONE);
+			itemHolder.channel.setVisibility(View.GONE);
+			itemHolder.title.setVisibility(View.GONE);
+			itemHolder.time.setText(item.getHeader());
+		} else {
+			view.setBackgroundColor(Color.BLACK);
+			itemHolder.channel.setVisibility(View.VISIBLE);
+			itemHolder.title.setVisibility(View.VISIBLE);
+			itemHolder.state.setVisibility(View.VISIBLE);
+			switch (item.getTimerState()) {
+			case Active:
+				itemHolder.state.setImageResource(R.drawable.timer_active);
+				break;
+			case Inactive:
+				itemHolder.state.setImageResource(R.drawable.timer_inactive);
+				break;
+			case Recording:
+				itemHolder.state.setImageResource(R.drawable.timer_recording);
+				break;
+			case None:
+				itemHolder.state.setImageResource(R.drawable.timer_none);
+				break;
+			}
+			final EventFormatter formatter = new EventFormatter(item.getEvent());
+			itemHolder.time.setText(formatter.getTime());
+			itemHolder.channel.setText(item.getChannelName());
+			itemHolder.title.setText(formatter.getTitle());
+		}
+
+		return view;
+	}
+
+	public void addItem(final EventListItem item) {
+		items.add(item);
+	}
+
+	public void sortItems() {
+		if (sortByTime) {
+			sortItemsByTime();
+		} else {
+			sortItemsByChannel();
+		}
+	}
+
+	private void sortItemsByTime() {
+
+		// sort by start time
+		final EventListItem[] unsortedItems = items.toArray(new EventListItem[0]);
+		final Comparator<EventListItem> comparator = new Comparator<EventListItem>() {
+
+			public int compare(final EventListItem item1, final EventListItem item2) {
+				return item1.getStart().compareTo(item2.getStart());
+			}
+		};
+		Arrays.sort(unsortedItems, comparator);
+
+		// insert daily headers
+		final List<EventListItem> sortedItems = new ArrayList<EventListItem>();
+		final GregorianCalendar itemCal = new GregorianCalendar();
+		final GregorianCalendar lastHeaderCal = new GregorianCalendar();
+		lastHeaderCal.set(Calendar.YEAR, 1970);
+
+		for(final EventListItem item : unsortedItems) {
+			itemCal.setTime(item.getStart());
+
+			if (itemCal.get(Calendar.DAY_OF_YEAR) != lastHeaderCal.get(Calendar.DAY_OF_YEAR) ||
+					itemCal.get(Calendar.YEAR) != lastHeaderCal.get(Calendar.YEAR)) {
+				lastHeaderCal.setTimeInMillis(itemCal.getTimeInMillis());
+				final DateFormatter dateFormatter = new DateFormatter(lastHeaderCal);
+				sortedItems.add(new EventListItem(dateFormatter.getDailyHeader()));
+			}
+
+			sortedItems.add(item);
+		}
+
+		// fill adapter
+		clear();
+		for(final EventListItem item : sortedItems) {
+			add(item);
+		}
+	}
+
+	private void sortItemsByChannel() {
+
+		final EventListItem[] sortedItems = items.toArray(new EventListItem[0]);
+		final Comparator<EventListItem> comparator = new Comparator<EventListItem>() {
+
+			public int compare(final EventListItem item1, final EventListItem item2) {
+				return Integer.valueOf(item1.getChannelNumber()).compareTo(Integer.valueOf(item2.getChannelNumber()));
+			}
+		};
+		Arrays.sort(sortedItems, comparator);
+
+		// fill adapter
+		clear();
+		if (sortedItems.length > 0) {
+			add(new EventListItem(new DateFormatter(sortedItems[0].getStart()).getDailyHeader()));
+		}
+		for(final EventListItem item : sortedItems) {
+			add(item);
+		}
+
+	}
+
+	public void clearItems() {
+		items.clear();
+	}
+}
\ No newline at end of file
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/gui/EventListItemHolder.java b/vdrmanager/src/de/bjusystems/vdrmanager/gui/EventListItemHolder.java
new file mode 100644
index 0000000..bac6ebb
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/gui/EventListItemHolder.java
@@ -0,0 +1,12 @@
+package de.bjusystems.vdrmanager.gui;
+
+import android.widget.ImageView;
+import android.widget.TextView;
+
+class EventListItemHolder {
+	public ImageView state;
+	public TextView title;
+	public TextView date;
+	public TextView time;
+	public TextView channel;
+}
\ No newline at end of file
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/gui/PreferencesActivity.java b/vdrmanager/src/de/bjusystems/vdrmanager/gui/PreferencesActivity.java
new file mode 100644
index 0000000..cb6e4d1
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/gui/PreferencesActivity.java
@@ -0,0 +1,34 @@
+package de.bjusystems.vdrmanager.gui;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.preference.PreferenceActivity;
+import de.bjusystems.vdrmanager.R;
+import de.bjusystems.vdrmanager.app.VdrManagerApp;
+import de.bjusystems.vdrmanager.data.Preferences;
+
+public class PreferencesActivity extends PreferenceActivity {
+
+	@Override
+	protected void onCreate(final Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		this.getPreferenceManager().setSharedPreferencesName(Preferences.getPreferenceFile(this));
+		this.addPreferencesFromResource(R.xml.preferences);
+	}
+
+	@Override
+	public void onBackPressed() {
+
+		// finish this activity
+		final VdrManagerApp app = (VdrManagerApp) getApplication();
+		app.addActivityToFinish(this);
+		app.finishActivities();
+
+		// restart main activity because
+		// the buttons needs refreshing
+		final Intent intent = new Intent();
+		intent.setClass(this, VdrManagerActivity.class);
+		startActivity(intent);
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/gui/SvdrpProgressDialog.java b/vdrmanager/src/de/bjusystems/vdrmanager/gui/SvdrpProgressDialog.java
new file mode 100644
index 0000000..e630ff9
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/gui/SvdrpProgressDialog.java
@@ -0,0 +1,72 @@
+package de.bjusystems.vdrmanager.gui;
+
+import android.app.Activity;
+import android.app.ProgressDialog;
+import android.widget.Toast;
+import de.bjusystems.vdrmanager.R;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpClient;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpEvent;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpException;
+
+public class SvdrpProgressDialog extends ProgressDialog {
+
+	ProgressDialog progress;
+	Activity activity;
+	SvdrpClient<? extends Object> client;
+
+	public SvdrpProgressDialog(final Activity activity, final SvdrpClient<? extends Object> client) {
+		super(activity);
+		this.activity = activity;
+		this.client = client;
+	}
+
+	public void svdrpEvent(final SvdrpEvent event) {
+
+		switch (event) {
+		case CONNECTING:
+			progress = new ProgressDialog(activity);
+			progress.setProgressStyle(ProgressDialog.STYLE_SPINNER);
+			setMessage(R.string.progress_connect);
+			progress.show();
+			break;
+		case LOGGED_IN:
+			setMessage(R.string.progress_login);
+			break;
+		case LOGIN_ERROR:
+			progress.dismiss();
+			showToast(R.string.progress_login_error);
+			break;
+		case COMMAND_SENT:
+			setMessage(client.getProgressTextId());
+			break;
+		case RESULT_RECEIVED:
+			break;
+		case DISCONNECTING:
+			setMessage(R.string.progress_disconnect);
+			break;
+		case DISCONNECTED:
+			break;
+		case FINISHED:
+			progress.dismiss();
+			break;
+		}
+	}
+
+	public void svdrpException(final SvdrpException exception) {
+		showToast(R.string.vdr_error_text);
+	}
+
+	private void setMessage(final int resId) {
+		progress.setMessage(activity.getText(resId));
+	}
+
+	private void showToast(final int resId) {
+		progress.dismiss();
+
+		final CharSequence text = activity.getText(resId);
+		final int duration = Toast.LENGTH_LONG;
+		final Toast toast = Toast.makeText(activity, text, duration);
+		toast.show();
+	}
+}
+
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/gui/TimerDetailsActivity.java b/vdrmanager/src/de/bjusystems/vdrmanager/gui/TimerDetailsActivity.java
new file mode 100644
index 0000000..60db80c
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/gui/TimerDetailsActivity.java
@@ -0,0 +1,232 @@
+package de.bjusystems.vdrmanager.gui;
+
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+
+import android.app.Activity;
+import android.app.DatePickerDialog;
+import android.app.DatePickerDialog.OnDateSetListener;
+import android.app.TimePickerDialog;
+import android.app.TimePickerDialog.OnTimeSetListener;
+import android.os.Bundle;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.DatePicker;
+import android.widget.TextView;
+import android.widget.TimePicker;
+import de.bjusystems.vdrmanager.R;
+import de.bjusystems.vdrmanager.app.VdrManagerApp;
+import de.bjusystems.vdrmanager.data.Preferences;
+import de.bjusystems.vdrmanager.data.Timer;
+import de.bjusystems.vdrmanager.utils.date.DateFormatter;
+import de.bjusystems.vdrmanager.utils.svdrp.SetTimerClient;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpAsyncListener;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpAsyncTask;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpClient;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpEvent;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpException;
+
+/**
+ * This class is used for showing what's
+ * current running on all channels
+ * @author bju
+ */
+public class TimerDetailsActivity extends Activity
+				implements OnClickListener, OnDateSetListener, OnTimeSetListener, SvdrpAsyncListener<Timer> {
+
+	Preferences prefs;
+	TextView dateField;
+	TextView startField;
+	TextView endField;
+	boolean editStart;
+	Timer timer;
+	SvdrpProgressDialog progress;
+	SetTimerClient setTimerClient;
+
+	@Override
+	protected void onCreate(final Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		// Attach view
+		setContentView(R.layout.timer_detail);
+
+    // timer
+    timer = ((VdrManagerApp)getApplication()).getCurrentTimer();
+
+    // update display
+    updateDisplay();
+
+    // register buttons
+    final Button saveButton = (Button) findViewById(R.id.timer_details_save);
+    saveButton.setOnClickListener(this);
+    if (timer.getNumber() > 0) {
+    	saveButton.setText(R.string.timer_details_save_title);
+    } else {
+    	saveButton.setText(R.string.timer_details_create_title);
+    }
+
+    // register text fields for editing
+    dateField.setOnClickListener(this);
+    startField.setOnClickListener(this);
+    endField.setOnClickListener(this);
+	}
+
+	@Override
+	protected void onResume() {
+		super.onResume();
+	}
+
+	@Override
+	protected void onPause() {
+		super.onPause();
+	}
+
+	public void onClick(final View view) {
+		switch (view.getId()) {
+		case R.id.timer_detail_day:
+		{
+			final Calendar cal = new GregorianCalendar();
+			cal.setTime(timer.getStart());
+			final DatePickerDialog dialog = new DatePickerDialog(this, this, cal.get(Calendar.YEAR),
+																									cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH));
+			dialog.show();
+			break;
+		}
+		case R.id.timer_detail_start:
+		{
+			final Calendar cal = new GregorianCalendar();
+			cal.setTime(timer.getStart());
+			editStart = true;
+			final TimePickerDialog dialog = new TimePickerDialog(this, this, cal.get(Calendar.HOUR_OF_DAY),
+																									cal.get(Calendar.MINUTE), true);
+			dialog.show();
+			break;
+		}
+		case R.id.timer_detail_end:
+		{
+			final Calendar cal = new GregorianCalendar();
+			cal.setTime(timer.getStop());
+			editStart = false;
+			final TimePickerDialog dialog = new TimePickerDialog(this, this, cal.get(Calendar.HOUR_OF_DAY),
+																									cal.get(Calendar.MINUTE), true);
+			dialog.show();
+			break;
+		}
+		case R.id.timer_details_save:
+		{
+			// collect values
+	    timer.setTitle(((TextView)findViewById(R.id.timer_detail_title)).getText().toString());
+
+			// create client for saving the timer
+			setTimerClient = new SetTimerClient(timer, false);
+
+			// create backgound task
+			final SvdrpAsyncTask<Timer, SvdrpClient<Timer>> task = new SvdrpAsyncTask<Timer, SvdrpClient<Timer>>(setTimerClient);
+
+			// create progress
+			progress = new SvdrpProgressDialog(this, setTimerClient);
+
+			// attach listener
+			task.addListener(this);
+
+			// start task
+			task.run();
+		}
+		}
+	}
+
+	public void onTimeSet(final TimePicker view, final int hourOfDay, final int minute) {
+		if (editStart) {
+			timer.setStart(calculateTime(timer.getStart(), hourOfDay, minute, null));
+		} else {
+			timer.setStop(calculateTime(timer.getStop(), hourOfDay, minute, timer.getStart()));
+		}
+		updateDisplay();
+	}
+
+	public void onDateSet(final DatePicker view, final int year, final int monthOfYear, final int dayOfMonth) {
+		timer.setStart(calculateDate(timer.getStart(), year, monthOfYear, dayOfMonth));
+		updateDisplay();
+	}
+
+	private Date calculateDate(final Date oldDate, final int year, final int monthOfYear, final int dayOfMonth) {
+
+		final Calendar cal = new GregorianCalendar();
+		cal.setTime(oldDate);
+		cal.set(Calendar.YEAR, year);
+		cal.set(Calendar.MONTH, monthOfYear);
+		cal.set(Calendar.DAY_OF_MONTH, dayOfMonth);
+
+		return cal.getTime();
+	}
+
+	private Date calculateTime(final Date oldTime, final int hourOfDay, final int minute, final Date startTime) {
+
+		// set hour and minute
+		final Calendar cal = new GregorianCalendar();
+		cal.setTime(oldTime);
+		cal.set(Calendar.HOUR_OF_DAY, hourOfDay);
+		cal.set(Calendar.MINUTE, minute);
+
+		// go to the next day if end time before start time
+		if (startTime != null) {
+			if (cal.getTime().before(startTime)) {
+				cal.add(Calendar.DAY_OF_MONTH, 1);
+			}
+		}
+
+		return cal.getTime();
+
+	}
+
+	private void updateDisplay() {
+
+    ((TextView)findViewById(R.id.timer_detail_title)).setText(timer.getTitle());
+    ((TextView)findViewById(R.id.timer_detail_channel)).setText(timer.getChannelName());
+    dateField = (TextView)findViewById(R.id.timer_detail_day);
+    final DateFormatter dateFormatter = new DateFormatter(timer.getStart());
+    dateField.setText(dateFormatter.getDateString());
+    startField = (TextView)findViewById(R.id.timer_detail_start);
+    startField.setText(dateFormatter.getTimeString());
+    endField = (TextView)findViewById(R.id.timer_detail_end);
+    endField.setText(new DateFormatter(timer.getStop()).getTimeString());
+
+    final Button button = (Button) findViewById(R.id.timer_details_save);
+    if (timer.getNumber() > 0) {
+    	// existing timer
+    	button.setText(R.string.timer_details_save_title);
+    } else {
+    	// new timer
+    	button.setText(R.string.timer_details_create_title);
+    }
+	}
+
+	public void svdrpEvent(final SvdrpEvent event, final Timer result) {
+
+		progress.svdrpEvent(event);
+
+		switch (event) {
+		case FINISHED:
+			// remove this activity from stack
+			finish();
+
+			// finish previous activities
+			final VdrManagerApp app = (VdrManagerApp) getApplication();
+			app.finishActivities();
+
+			// refresh last view
+			app.setReload(true);
+
+			// free progress dialog
+			progress = null;
+
+			break;
+		}
+	}
+
+	public void svdrpException(final SvdrpException exception) {
+		progress.svdrpException(exception);
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/gui/TimerListActivity.java b/vdrmanager/src/de/bjusystems/vdrmanager/gui/TimerListActivity.java
new file mode 100644
index 0000000..52fa1e0
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/gui/TimerListActivity.java
@@ -0,0 +1,238 @@
+package de.bjusystems.vdrmanager.gui;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.AdapterView;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.ListView;
+import de.bjusystems.vdrmanager.R;
+import de.bjusystems.vdrmanager.app.VdrManagerApp;
+import de.bjusystems.vdrmanager.data.EventFormatter;
+import de.bjusystems.vdrmanager.data.EventListItem;
+import de.bjusystems.vdrmanager.data.Timer;
+import de.bjusystems.vdrmanager.tasks.DeleteTimerTask;
+import de.bjusystems.vdrmanager.tasks.ToggleTimerTask;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpAsyncListener;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpAsyncTask;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpClient;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpEvent;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpException;
+import de.bjusystems.vdrmanager.utils.svdrp.TimerClient;
+
+/**
+ * This class is used for showing what's
+ * current running on all channels
+ * @author bju
+ */
+public class TimerListActivity extends Activity
+															 implements OnItemClickListener, SvdrpAsyncListener<Timer> {
+
+	TimerClient timerClient;
+	EventAdapter adapter;
+	SvdrpProgressDialog progress;
+
+	@Override
+	protected void onCreate(final Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		// Attach view
+		setContentView(R.layout.timer_list);
+
+		// create an adapter
+		adapter = new EventAdapter(this, true);
+
+		// attach adapter to ListView
+		final ListView listView = (ListView) findViewById(R.id.timer_list);
+		listView.setAdapter(adapter);
+
+		// set click listener
+		listView.setOnItemClickListener(this);
+
+		// context menu wanted
+		registerForContextMenu(listView);
+
+		// start query
+		startTimerQuery();
+  }
+
+	@Override
+	protected void onResume() {
+		super.onResume();
+		reloadIfNeeded();
+	}
+
+	private void reloadIfNeeded() {
+
+		final VdrManagerApp app = (VdrManagerApp) getApplication();
+		if (app.isReload()) {
+			app.setReload(false);
+			startTimerQuery();
+		}
+	}
+
+	@Override
+	protected void onPause() {
+		super.onPause();
+		if (timerClient != null) {
+			timerClient.abort();
+		}
+		if (progress != null) {
+			progress.dismiss();
+			progress = null;
+		}
+	}
+
+	@Override
+	public void onCreateContextMenu(final ContextMenu menu, final View v, final ContextMenuInfo menuInfo) {
+		super.onCreateContextMenu(menu, v, menuInfo);
+
+		if (v.getId() == R.id.timer_list) {
+	    final MenuInflater inflater = getMenuInflater();
+	    final AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo)menuInfo;
+
+	    // set menu title
+	    final EventListItem item = adapter.getItem(info.position);
+	    final EventFormatter formatter = new EventFormatter(item);
+	    menu.setHeaderTitle(formatter.getTitle());
+
+	    inflater.inflate(R.menu.epg_list_item_menu, menu);
+
+	    // remove unneeded menu items
+    	menu.findItem(R.id.epg_item_menu_timer_add).setVisible(false);
+    	final MenuItem enableMenuItem = menu.findItem(R.id.epg_item_menu_timer_toggle);
+    	enableMenuItem.setTitle(item.getTimer().isEnabled() ? R.string.epg_item_menu_timer_disable : R.string.epg_item_menu_timer_enable);
+		}
+	}
+
+
+
+	@Override
+	public boolean onContextItemSelected(final MenuItem item) {
+
+    final AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo)item.getMenuInfo();
+    final EventListItem event = adapter.getItem(info.position);
+
+    switch (item.getItemId()) {
+    case R.id.epg_item_menu_timer_modify:
+    {
+    	onItemClick(null, null, info.position, 0);
+    	break;
+    }
+    case R.id.epg_item_menu_timer_delete:
+    {
+    	deleteTimer(event);
+    	break;
+    }
+    case R.id.epg_item_menu_timer_toggle:
+    {
+    	toggleTimer(event);
+    }
+		}
+
+		return true;
+	}
+
+	public void onItemClick(final AdapterView<?> parent, final View view, final int position, final long id) {
+
+		// save selected item
+		final Timer timer = adapter.getItem(position).getTimer();
+		if (timer == null) {
+			// header click
+			return;
+		}
+
+		final VdrManagerApp app = (VdrManagerApp) getApplication();
+		app.setCurrentTimer(timer);
+
+		// after timer editing return to the timer list
+		app.setNextActivity(TimerListActivity.class);
+		app.clearActivitiesToFinish();
+
+		// show timer details
+		final Intent intent = new Intent();
+		intent.setClass(this, TimerDetailsActivity.class);
+		startActivity(intent);
+	}
+
+	private void startTimerQuery() {
+
+		// get timer client
+		timerClient = new TimerClient();
+
+		// create backgound task
+		final SvdrpAsyncTask<Timer, SvdrpClient<Timer>> task = new SvdrpAsyncTask<Timer, SvdrpClient<Timer>>(timerClient);
+
+		// create progress dialog
+		progress = new SvdrpProgressDialog(this, timerClient);
+
+		// attach listener
+		task.addListener(this);
+
+		// start task
+		task.run();
+	}
+
+	public void svdrpEvent(final SvdrpEvent event, final Timer result) {
+
+		if (progress != null) {
+			progress.svdrpEvent(event);
+		}
+
+		switch (event) {
+		case CONNECTING:
+			adapter.clearItems();
+			break;
+		case LOGIN_ERROR:
+			this.finish();
+			break;
+		case FINISHED:
+			for(final Timer timer : timerClient.getResults()) {
+				adapter.addItem(new EventListItem(timer));
+			}
+			adapter.sortItems();
+			progress = null;
+			break;
+		}
+	}
+
+	public void svdrpException(final SvdrpException exception) {
+		if (progress != null) {
+			progress.svdrpException(exception);
+		}
+	}
+
+	private void deleteTimer(final EventListItem item) {
+
+		final DeleteTimerTask task = new DeleteTimerTask(this, item.getTimer()) {
+			@Override
+			public void finished() {
+				// refresh epg list after return
+				final VdrManagerApp app = (VdrManagerApp) getApplication();
+				app.setReload(true);
+				reloadIfNeeded();
+			}
+		};
+		task.start();
+	}
+
+	private void toggleTimer(final EventListItem item) {
+
+		final ToggleTimerTask task = new ToggleTimerTask(this, item.getTimer()) {
+			@Override
+			public void finished() {
+				// refresh epg list after return
+				final VdrManagerApp app = (VdrManagerApp) getApplication();
+				app.setReload(true);
+				reloadIfNeeded();
+			}
+		};
+		task.start();
+	}
+
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/gui/VdrManagerActivity.java b/vdrmanager/src/de/bjusystems/vdrmanager/gui/VdrManagerActivity.java
new file mode 100644
index 0000000..7543ad7
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/gui/VdrManagerActivity.java
@@ -0,0 +1,228 @@
+package de.bjusystems.vdrmanager.gui;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.content.res.Configuration;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup;
+import android.widget.AbsListView;
+import android.widget.ArrayAdapter;
+import android.widget.GridView;
+import android.widget.ImageButton;
+import android.widget.TextView;
+import de.bjusystems.vdrmanager.R;
+import de.bjusystems.vdrmanager.app.VdrManagerApp;
+import de.bjusystems.vdrmanager.data.MenuActionHandler;
+import de.bjusystems.vdrmanager.data.Preferences;
+import de.bjusystems.vdrmanager.utils.wakeup.AsyncWakeupTask;
+
+public class VdrManagerActivity extends Activity {
+
+	static class WakeupAction implements MenuActionHandler {
+		public void executeAction(final Context context) {
+			// create AsyncTask
+			final AsyncWakeupTask wakeupTask = new AsyncWakeupTask(context);
+			wakeupTask.execute();
+		}
+	}
+
+	@SuppressWarnings("rawtypes")
+	static class MenuActivity {
+		int iconId;
+		int textId;
+		Class handler;
+		boolean enabled;
+
+		public int getIconId() {
+			return iconId;
+		}
+		public int getTextId() {
+			return textId;
+		}
+
+		public Class getHandler() {
+			return handler;
+		}
+
+		public boolean isEnabled() {
+			return enabled;
+		}
+
+		public MenuActivity(final int iconId, final int textId, final Class handler) {
+			this.iconId = iconId;
+			this.textId = textId;
+			this.handler = handler;
+			this.enabled = true;
+		}
+
+		public void setEnabled(final boolean enabled) {
+			this.enabled = enabled;
+		}
+	}
+
+	class MenuAdapter extends ArrayAdapter<MenuActivity> implements OnClickListener {
+
+		private final LayoutInflater inflater;
+
+		public MenuAdapter(final Context context, final int viewId) {
+			super(context, viewId);
+			inflater = LayoutInflater.from(context);
+		}
+
+		@SuppressWarnings("unchecked")
+		@Override
+		public View getView(final int position, final View convertView, final ViewGroup parent) {
+
+			View view = convertView;
+			View itemView;
+			if (view == null) {
+				view = inflater.inflate(R.layout.vdrmanager_menu_item, null);
+				itemView = view.findViewById(R.id.vdrmanager_menu_item);
+				view.setTag(itemView);
+
+				// attach click listener
+				itemView.setOnClickListener(this);
+
+			} else {
+				itemView = (View) view.getTag();
+			}
+
+			// attach menu item
+			final MenuActivity menuItem = getItem(position);
+			if (itemView instanceof TextView) {
+				final TextView textView = (TextView) itemView;
+				textView.setText(menuItem.getTextId());
+			} else {
+				final ImageButton imageButton = (ImageButton) itemView;
+				imageButton.setImageResource(menuItem.getIconId());
+			}
+			itemView.setOnClickListener(this);
+			menuActivityMap.put(itemView, menuItem.getHandler());
+
+			return view;
+		}
+
+		@SuppressWarnings({ "unchecked", "rawtypes" })
+		public void onClick(final View v) {
+
+			// refresh preferences
+			Preferences.loadPreferences(getContext());
+
+			// clear state
+			((VdrManagerApp) getApplication()).clear();
+
+			// start activity
+			final Class actionClass = menuActivityMap.get(v);
+			if (Activity.class.isAssignableFrom(actionClass)) {
+				final Intent intent = new Intent();
+				intent.setClass(getContext(), actionClass);
+				startActivity(intent);
+			} else if (MenuActionHandler.class.isAssignableFrom(actionClass)) {
+				final Class<? extends MenuActionHandler> handlerClass = actionClass;
+				try {
+					final MenuActionHandler handler = handlerClass.newInstance();
+					handler.executeAction(getContext());
+				} catch (final InstantiationException e) {
+
+				} catch (final IllegalAccessException e) {
+
+				}
+			}
+		}
+	}
+
+	MenuActivity[] menuItems = new MenuActivity[] {
+		new MenuActivity(R.drawable.whatson, R.string.action_menu_epg, EpgListActivity.class),
+		new MenuActivity(0, R.string.action_menu_search, EpgSearchActivity.class),
+		new MenuActivity(R.drawable.timers, R.string.action_menu_timers, TimerListActivity.class),
+		new MenuActivity(R.drawable.channels, R.string.action_menu_channels, ChannelListActivity.class),
+		new MenuActivity(0, R.string.action_menu_wakeup, WakeupAction.class),
+	};
+	Map<View, Class<? extends Activity>> menuActivityMap = new HashMap<View, Class<? extends Activity>>();
+
+	@Override
+	protected void onCreate(final Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		// attach view
+		setContentView(R.layout.vdrmanager);
+
+		// add and register buttons
+		createButtons();
+	}
+
+	// add main menu buttons
+	private void createButtons() {
+
+		// refresh preferences
+		Preferences.loadPreferences(this);
+		final Preferences prefs = Preferences.getPreferences();
+
+		// get list
+		final AbsListView listView = (AbsListView) findViewById(R.id.vdrmanager_menu);
+		final MenuAdapter adapter =	new MenuAdapter(this, R.layout.vdrmanager_menu_item);
+		listView.setAdapter(adapter);
+
+		// add menu items
+		for(final MenuActivity menuItem : menuItems) {
+			if (menuItem.getTextId() != R.string.action_menu_wakeup || prefs.isWakeupEnabled()) {
+				adapter.add(menuItem);
+			}
+		}
+
+		// set grid layout dimensions
+		if (listView instanceof GridView) {
+			final GridView grid = (GridView)listView;
+			if (getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT) {
+				grid.setNumColumns(2);
+			} else {
+				grid.setNumColumns(menuItems.length);
+			}
+		}
+	}
+
+	@Override
+	public boolean onCreateOptionsMenu(final Menu menu) {
+		super.onCreateOptionsMenu(menu);
+
+    final MenuInflater inflater = getMenuInflater();
+    inflater.inflate(R.menu.main_menu, menu);
+    return true;
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(final MenuItem item) {
+
+		switch (item.getItemId())
+		{
+		case R.id.main_menu_preferences:
+			// remember activity for finishing
+			final VdrManagerApp app = (VdrManagerApp) getApplication();
+			app.clearActivitiesToFinish();
+			app.addActivityToFinish(this);
+
+			final Intent intent = new Intent();
+			intent.setClass(this, PreferencesActivity.class);
+			startActivity(intent);
+			break;
+		case R.id.main_menu_exit:
+			finish();
+			break;
+		}
+		return true;
+	}
+
+	@Override
+	public void onBackPressed() {
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/gui/VideoActivity.java b/vdrmanager/src/de/bjusystems/vdrmanager/gui/VideoActivity.java
new file mode 100644
index 0000000..6e17d15
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/gui/VideoActivity.java
@@ -0,0 +1,67 @@
+package de.bjusystems.vdrmanager.gui;
+
+import android.app.Activity;
+import android.net.Uri;
+import android.os.Bundle;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.MediaController;
+import android.widget.VideoView;
+import de.bjusystems.vdrmanager.R;
+import de.bjusystems.vdrmanager.data.Preferences;
+
+/**
+ * This class is used for showing what's
+ * current running on all channels
+ * @author bju
+ */
+public class VideoActivity extends Activity
+				implements OnClickListener {
+
+	Preferences prefs;
+
+	@Override
+	protected void onCreate(final Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		// Attach view
+		setContentView(R.layout.video);
+
+		// set stream
+		final VideoView videoView = (VideoView) findViewById(R.id.video_video);
+		final MediaController mediaController = new MediaController(this);
+		mediaController.setAnchorView(videoView);
+		final Uri video = Uri.parse("http://192.168.178.20:3000/1");
+		videoView.setMediaController(mediaController);
+		videoView.setVideoURI(video);
+		videoView.start();
+
+    // register button
+    final Button button = (Button) findViewById(R.id.video_button);
+    button.setOnClickListener(this);
+	}
+
+	@Override
+	protected void onResume() {
+		super.onResume();
+	}
+
+	@Override
+	protected void onPause() {
+		super.onPause();
+	}
+
+	public void onClick(final View v) {
+
+		// Save search parameters
+//		final EpgSearchParams search = new EpgSearchParams();
+//		search.setTitle(text.getText().toString());
+//		((VdrManagerApp)getApplication()).setCurrentSearch(search);
+
+		// show timer details
+//		final Intent intent = new Intent();
+//		intent.setClass(this, VdrManagerActivity.class);
+//		startActivity(intent);
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/tasks/AsyncProgressTask.java b/vdrmanager/src/de/bjusystems/vdrmanager/tasks/AsyncProgressTask.java
new file mode 100644
index 0000000..edd1367
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/tasks/AsyncProgressTask.java
@@ -0,0 +1,55 @@
+package de.bjusystems.vdrmanager.tasks;
+
+import android.app.Activity;
+import de.bjusystems.vdrmanager.gui.SvdrpProgressDialog;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpAsyncListener;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpAsyncTask;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpClient;
+import de.bjusystems.vdrmanager.utils.svdrp.SvdrpEvent;
+
+public abstract class AsyncProgressTask<Result> {
+
+	class AsyncProgress extends SvdrpProgressDialog implements SvdrpAsyncListener<Result> {
+
+		public AsyncProgress(final Activity activity, final SvdrpClient<Result> client) {
+			super(activity, client);
+		}
+
+		public void svdrpEvent(final SvdrpEvent event, final Object result) {
+			svdrpEvent(event);
+
+			switch (event) {
+			case FINISHED:
+				AsyncProgressTask.this.finished();
+				break;
+			}
+		}
+	}
+
+	Activity activity;
+	SvdrpClient<Result> client;
+
+	public AsyncProgressTask(final Activity activity, final SvdrpClient<Result> client) {
+		this.activity = activity;
+		this.client = client;
+	}
+
+	public void start() {
+
+		// delete timer
+/*
+		final SetTimerClient client = new SetTimerClient(timer, true) {
+			@Override
+			public int getProgressTextId() {
+				return R.string.progress_timer_delete;
+			}
+		};
+*/
+		final SvdrpAsyncTask<Result, SvdrpClient<Result>> task = new SvdrpAsyncTask<Result, SvdrpClient<Result>>(client);
+		final AsyncProgress progress = new AsyncProgress(activity, client);
+		task.addListener(progress);
+		task.run();
+	}
+
+	public abstract void finished();
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/tasks/DeleteTimerTask.java b/vdrmanager/src/de/bjusystems/vdrmanager/tasks/DeleteTimerTask.java
new file mode 100644
index 0000000..48cdd23
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/tasks/DeleteTimerTask.java
@@ -0,0 +1,18 @@
+package de.bjusystems.vdrmanager.tasks;
+
+import android.app.Activity;
+import de.bjusystems.vdrmanager.R;
+import de.bjusystems.vdrmanager.data.Timer;
+import de.bjusystems.vdrmanager.utils.svdrp.SetTimerClient;
+
+public abstract class DeleteTimerTask extends AsyncProgressTask<Timer> {
+
+	public DeleteTimerTask(final Activity activity, final Timer timer) {
+		super(activity, new SetTimerClient(timer, true) {
+			@Override
+			public int getProgressTextId() {
+				return R.string.progress_timer_delete;
+			}
+		});
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/tasks/ToggleTimerTask.java b/vdrmanager/src/de/bjusystems/vdrmanager/tasks/ToggleTimerTask.java
new file mode 100644
index 0000000..ee146e5
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/tasks/ToggleTimerTask.java
@@ -0,0 +1,25 @@
+package de.bjusystems.vdrmanager.tasks;
+
+import android.app.Activity;
+import de.bjusystems.vdrmanager.R;
+import de.bjusystems.vdrmanager.data.Timer;
+import de.bjusystems.vdrmanager.utils.svdrp.SetTimerClient;
+
+public abstract class ToggleTimerTask extends AsyncProgressTask<Timer> {
+
+	public ToggleTimerTask(final Activity activity, final Timer timer) {
+		super(activity, new SetTimerClient(timer, false) {
+			boolean enabled = timer.isEnabled();
+
+			@Override
+			public int getProgressTextId() {
+				if (enabled) {
+					return R.string.progress_timer_disable;
+				} else {
+					return R.string.progress_timer_enable;
+				}
+			}
+		});
+		timer.setEnabled(!timer.isEnabled());
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/utils/date/DateFormatter.java b/vdrmanager/src/de/bjusystems/vdrmanager/utils/date/DateFormatter.java
new file mode 100644
index 0000000..30fd047
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/utils/date/DateFormatter.java
@@ -0,0 +1,43 @@
+package de.bjusystems.vdrmanager.utils.date;
+
+import java.text.DateFormat;
+import java.util.Calendar;
+import java.util.Date;
+
+/**
+ * Class for formatting date and time values
+ * @author bju
+ *
+ */
+public class DateFormatter {
+
+	private final String timeString;
+	private final String dateString;
+	private final String dailyHeader;
+
+	public DateFormatter(final Date date) {
+		timeString = DateFormat.getTimeInstance(DateFormat.SHORT).format(date);
+		dateString = DateFormat.getDateInstance(DateFormat.SHORT).format(date);
+		dailyHeader = DateFormat.getDateInstance(DateFormat.FULL).format(date);
+	}
+
+	public DateFormatter(final long seconds) {
+		this(new Date(seconds * 1000));
+	}
+
+	public DateFormatter(final Calendar cal) {
+		this(cal.getTime());
+	}
+
+	public String getDateString() {
+		return dateString;
+	}
+
+	public String getTimeString() {
+		return timeString;
+	}
+
+	public String getDailyHeader() {
+		return dailyHeader;
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/utils/http/HttpHelper.java b/vdrmanager/src/de/bjusystems/vdrmanager/utils/http/HttpHelper.java
new file mode 100644
index 0000000..0812f73
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/utils/http/HttpHelper.java
@@ -0,0 +1,263 @@
+package de.bjusystems.vdrmanager.utils.http;
+
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.zip.GZIPInputStream;
+
+import org.apache.http.Header;
+import org.apache.http.HeaderElement;
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpException;
+import org.apache.http.HttpRequest;
+import org.apache.http.HttpRequestInterceptor;
+import org.apache.http.HttpResponse;
+import org.apache.http.HttpResponseInterceptor;
+import org.apache.http.HttpVersion;
+import org.apache.http.NameValuePair;
+import org.apache.http.auth.AuthScope;
+import org.apache.http.auth.UsernamePasswordCredentials;
+import org.apache.http.client.ClientProtocolException;
+import org.apache.http.client.ResponseHandler;
+import org.apache.http.client.entity.UrlEncodedFormEntity;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.client.methods.HttpRequestBase;
+import org.apache.http.conn.scheme.PlainSocketFactory;
+import org.apache.http.conn.scheme.Scheme;
+import org.apache.http.conn.scheme.SchemeRegistry;
+import org.apache.http.conn.ssl.SSLSocketFactory;
+import org.apache.http.entity.HttpEntityWrapper;
+import org.apache.http.impl.client.BasicResponseHandler;
+import org.apache.http.impl.client.DefaultHttpClient;
+import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
+import org.apache.http.message.BasicNameValuePair;
+import org.apache.http.params.BasicHttpParams;
+import org.apache.http.params.CoreConnectionPNames;
+import org.apache.http.params.CoreProtocolPNames;
+import org.apache.http.params.HttpParams;
+import org.apache.http.protocol.HTTP;
+import org.apache.http.protocol.HttpContext;
+
+/**
+ * Apache HttpClient helper class for performing HTTP requests.
+ *
+ * This class is intentionally *not* bound to any Android classes so that it is easier
+ * to develop and test. Use calls to this class inside Android AsyncTask implementations
+ * (or manual Thread-Handlers) to make HTTP requests asynchronous and not block the UI Thread.
+ *
+ * TODO cookies
+ * TODO multi-part binary data
+ * TODO follow 302s?
+ * TODO shutdown connection mgr? - client.getConnectionManager().shutdown();
+ *
+ * @author ccollins
+ *
+ */
+public class HttpHelper {
+
+   private static final String CONTENT_TYPE = "Content-Type";
+   private static final int POST_TYPE = 1;
+   private static final int GET_TYPE = 2;
+   private static final String GZIP = "gzip";
+   private static final String ACCEPT_ENCODING = "Accept-Encoding";
+
+   public static final String MIME_FORM_ENCODED = "application/x-www-form-urlencoded";
+   public static final String MIME_TEXT_PLAIN = "text/plain";
+   public static final String HTTP_RESPONSE = "HTTP_RESPONSE";
+   public static final String HTTP_RESPONSE_ERROR = "HTTP_RESPONSE_ERROR";
+
+   private final DefaultHttpClient client;
+   private final ResponseHandler<String> responseHandler;
+
+   /**
+    * Constructor.
+    *
+    */
+   public HttpHelper() {
+
+     final HttpParams params = new BasicHttpParams();
+     params.setParameter(CoreProtocolPNames.PROTOCOL_VERSION, HttpVersion.HTTP_1_1);
+     params.setParameter(CoreProtocolPNames.HTTP_CONTENT_CHARSET, HTTP.UTF_8);
+     params.setParameter(CoreProtocolPNames.USER_AGENT, "Apache-HttpClient/Android");
+     params.setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 15000);
+     params.setParameter(CoreConnectionPNames.STALE_CONNECTION_CHECK, false);
+     final SchemeRegistry schemeRegistry = new SchemeRegistry();
+     schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
+     schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
+     final ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(params, schemeRegistry);
+     client = new DefaultHttpClient(cm, params);
+
+     // add gzip decompressor to handle gzipped content in responses
+     // (default we *do* always send accept encoding gzip header in request)
+     client.addResponseInterceptor(new HttpResponseInterceptor() {
+        public void process(final HttpResponse response, final HttpContext context) throws HttpException, IOException {
+           final HttpEntity entity = response.getEntity();
+           final Header contentEncodingHeader = entity.getContentEncoding();
+           if (contentEncodingHeader != null) {
+              final HeaderElement[] codecs = contentEncodingHeader.getElements();
+              for (int i = 0; i < codecs.length; i++) {
+                 if (codecs[i].getName().equalsIgnoreCase(HttpHelper.GZIP)) {
+                    response.setEntity(new GzipDecompressingEntity(response.getEntity()));
+                    return;
+                 }
+              }
+           }
+        }
+     });
+
+  	 responseHandler = new BasicResponseHandler();
+   }
+
+   /**
+    * Perform a simple HTTP GET operation.
+    *
+    */
+   public String performGet(final String url) {
+      return performRequest(null, url, null, null, null, null, HttpHelper.GET_TYPE);
+   }
+
+   /**
+    * Perform an HTTP GET operation with user/pass and headers.
+    *
+    */
+   public String performGet(final String url, final String user, final String pass,
+            final Map<String, String> additionalHeaders) {
+      return performRequest(null, url, user, pass, additionalHeaders, null, HttpHelper.GET_TYPE);
+   }
+
+   /**
+    * Perform a simplified HTTP POST operation.
+    *
+    */
+   public String performPost(final String url, final Map<String, String> params) {
+      return performRequest(HttpHelper.MIME_FORM_ENCODED, url, null, null, null, params, HttpHelper.POST_TYPE);
+   }
+
+   /**
+    * Perform an HTTP POST operation with user/pass, headers, request
+   parameters,
+    * and a default content-type of "application/x-www-form-urlencoded."
+    *
+    */
+   public String performPost(final String url, final String user, final String pass,
+            final Map<String, String> additionalHeaders, final Map<String, String> params) {
+      return performRequest(HttpHelper.MIME_FORM_ENCODED, url, user, pass, additionalHeaders, params,
+               HttpHelper.POST_TYPE);
+   }
+
+   /**
+    * Perform an HTTP POST operation with flexible parameters (the
+   complicated/flexible version of the method).
+    *
+    */
+   public String performPost(final String contentType, final String url, final String user, final String pass,
+            final Map<String, String> additionalHeaders, final Map<String, String> params) {
+      return performRequest(contentType, url, user, pass, additionalHeaders, params, HttpHelper.POST_TYPE);
+   }
+
+   //
+   // private methods
+   //
+   private String performRequest(final String contentType, final String url, final String user, final String pass,
+            final Map<String, String> headers, final Map<String, String> params, final int requestType) {
+
+      // add user and pass to client credentials if present
+      if ((user != null) && (pass != null)) {
+         client.getCredentialsProvider().setCredentials(AuthScope.ANY,
+                  new UsernamePasswordCredentials(user, pass));
+      }
+
+      // process headers using request interceptor
+      final Map<String, String> sendHeaders = new HashMap<String, String>();
+      // add encoding header for gzip if not present
+      if (!sendHeaders.containsKey(HttpHelper.ACCEPT_ENCODING)) {
+         sendHeaders.put(HttpHelper.ACCEPT_ENCODING, HttpHelper.GZIP);
+      }
+      if ((headers != null) && (headers.size() > 0)) {
+         sendHeaders.putAll(headers);
+      }
+      if (requestType == HttpHelper.POST_TYPE) {
+         sendHeaders.put(HttpHelper.CONTENT_TYPE, contentType);
+      }
+      if (sendHeaders.size() > 0) {
+         client.addRequestInterceptor(new HttpRequestInterceptor() {
+            public void process(final HttpRequest request, final HttpContext context) throws HttpException, IOException {
+               for (final String key : sendHeaders.keySet()) {
+                  if (!request.containsHeader(key)) {
+                     request.addHeader(key, sendHeaders.get(key));
+                  }
+               }
+            }
+         });
+      }
+
+      // handle POST or GET request respectively
+      HttpRequestBase method = null;
+      if (requestType == HttpHelper.POST_TYPE) {
+         method = new HttpPost(url);
+         // data - name/value params
+         List<NameValuePair> nvps = null;
+         if ((params != null) && (params.size() > 0)) {
+            nvps = new ArrayList<NameValuePair>();
+            for (final Map.Entry<String, String> entry : params.entrySet()) {
+               nvps.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
+            }
+         }
+         if (nvps != null) {
+            try {
+               final HttpPost methodPost = (HttpPost) method;
+               methodPost.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8));
+            } catch (final UnsupportedEncodingException e) {
+               throw new RuntimeException("Error peforming HTTP request: " + e.getMessage(), e);
+            }
+         }
+      } else if (requestType == HttpHelper.GET_TYPE) {
+         method = new HttpGet(url);
+      }
+
+
+      // execute request
+      return execute(method);
+   }
+
+   private synchronized String execute(final HttpRequestBase method) {
+      String response = null;
+      // execute method returns?!? (rather than async) - do it here sync, and wrap async elsewhere
+      try {
+         response = client.execute(method, responseHandler);
+      } catch (final ClientProtocolException e) {
+         response = HttpHelper.HTTP_RESPONSE_ERROR + " - " + e.getClass().getSimpleName() + " " + e.getMessage();
+         //e.printStackTrace();
+      } catch (final IOException e) {
+         response = HttpHelper.HTTP_RESPONSE_ERROR + " - " + e.getClass().getSimpleName() + " " + e.getMessage();
+         //e.printStackTrace();
+      }
+      return response;
+   }
+
+   static class GzipDecompressingEntity extends HttpEntityWrapper {
+      public GzipDecompressingEntity(final HttpEntity entity) {
+         super(entity);
+      }
+
+      @Override
+      public InputStream getContent() throws IOException, IllegalStateException {
+         // the wrapped entity's getContent() decides about repeatability
+         final InputStream wrappedin = wrappedEntity.getContent();
+         return new GZIPInputStream(wrappedin);
+      }
+
+      @Override
+      public long getContentLength() {
+         // length of ungzipped content is not known
+         return -1;
+      }
+   }
+}
+
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/AliveClient.java b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/AliveClient.java
new file mode 100644
index 0000000..f8372e9
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/AliveClient.java
@@ -0,0 +1,49 @@
+package de.bjusystems.vdrmanager.utils.svdrp;
+
+import de.bjusystems.vdrmanager.data.AliveState;
+
+/**
+ * Class for retrieving informations about the running program
+ * @author bju
+ *
+ */
+public class AliveClient extends SvdrpClient<AliveState> {
+
+	/**
+	 * Constructor
+	 * @param host host
+	 * @param port port
+	 * @param ssl use ssl
+	 */
+	public AliveClient() {
+		super();
+	}
+
+	/**
+	 * Starts the EPG request
+	 * @param parameter parameter for lste
+	 */
+	@Override
+	public void run() throws SvdrpException {
+		runCommand("aliv");
+	}
+
+	@Override
+	public AliveState parseAnswer(final String line) {
+
+		if (line.startsWith("200")) {
+			return AliveState.ALIVE;
+		}
+		if (line.startsWith("400")) {
+			return AliveState.DEAD;
+		}
+		return AliveState.UNKNOWN;
+	}
+
+	@Override
+	public int getProgressTextId() {
+		return 0;
+	}
+
+
+}
\ No newline at end of file
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/ChannelClient.java b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/ChannelClient.java
new file mode 100644
index 0000000..c087358
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/ChannelClient.java
@@ -0,0 +1,44 @@
+package de.bjusystems.vdrmanager.utils.svdrp;
+
+import de.bjusystems.vdrmanager.R;
+import de.bjusystems.vdrmanager.data.Channel;
+import de.bjusystems.vdrmanager.data.Preferences;
+
+/**
+ * Class for retrieving informations about the running program
+ * @author bju
+ *
+ */
+public class ChannelClient extends SvdrpClient<Channel> {
+
+	/**
+	 * Constructor
+	 * @param host host
+	 * @param port port
+	 * @param ssl use ssl
+	 */
+	public ChannelClient() {
+		super();
+	}
+
+	/**
+	 * Starts the EPG request
+	 * @param parameter parameter for lste
+	 */
+	@Override
+	public void run() throws SvdrpException {
+		runCommand("channels " + Preferences.getPreferences().getChannels());
+	}
+
+	@Override
+	public Channel parseAnswer(final String line) {
+		return new Channel(line);
+	}
+
+	@Override
+	public int getProgressTextId() {
+		return R.string.progress_channels_loading;
+	}
+
+
+}
\ No newline at end of file
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/EpgClient.java b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/EpgClient.java
new file mode 100644
index 0000000..df30055
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/EpgClient.java
@@ -0,0 +1,91 @@
+package de.bjusystems.vdrmanager.utils.svdrp;
+
+import de.bjusystems.vdrmanager.R;
+import de.bjusystems.vdrmanager.data.Channel;
+import de.bjusystems.vdrmanager.data.Epg;
+import de.bjusystems.vdrmanager.data.EpgSearchParams;
+import de.bjusystems.vdrmanager.data.Preferences;
+import de.bjusystems.vdrmanager.data.Timer;
+
+/**
+ * Class for retrieving informations about the running program
+ * @author bju
+ *
+ */
+public class EpgClient extends SvdrpClient<Epg> {
+
+	/** Time to retrieve EPG for */
+	private String time;
+	/** Channel to retrieve EPG for */
+	private Channel channel;
+	/** Search parameters to retrieve EPG for */
+	private EpgSearchParams search;
+	/** Last read EPG */
+	private Epg lastEpg;
+
+	/**
+	 * Constructor
+	 */
+	private EpgClient() {
+		super();
+		this.time = null;
+		this.channel = null;
+		this.search = null;
+	}
+
+	/**
+	 * Constructor
+	 * @param time time to search for epg events
+	 */
+	public EpgClient(final String time) {
+		this();
+		this.time = time;
+	}
+
+	/**
+	 * Constructor
+	 * @param channel channel to search for epg events
+	 */
+	public EpgClient(final Channel channel) {
+		this();
+		this.channel = channel;
+	}
+
+	public EpgClient(final EpgSearchParams search) {
+		this();
+		this.search = search;
+	}
+
+	/**
+	 * Starts the EPG request
+	 * @param parameter parameter for lste
+	 */
+	@Override
+	public void run() throws SvdrpException {
+		if (time != null) {
+			runCommand(String.format("tevents %s %s", time, Preferences.getPreferences().getChannels()));
+		} else if (channel != null) {
+			runCommand(String.format("cevents %s", channel.getNumber()));
+		} else if (search != null) {
+			runCommand(String.format("search %s %s", Preferences.getPreferences().getChannels(), search.toCommandLine()));
+		}
+	}
+
+	@Override
+	public Epg parseAnswer(final String line) {
+
+		if (line.startsWith("E")) {
+			lastEpg = new Epg(line);
+			return lastEpg;
+		} else if (line.startsWith("T")) {
+			lastEpg.setTimer(new Timer(line));
+		}
+		return null;
+	}
+
+	@Override
+	public int getProgressTextId() {
+		return R.string.progress_whatson_loading;
+	}
+}
+
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SetTimerClient.java b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SetTimerClient.java
new file mode 100644
index 0000000..0863c6d
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SetTimerClient.java
@@ -0,0 +1,59 @@
+package de.bjusystems.vdrmanager.utils.svdrp;
+
+import de.bjusystems.vdrmanager.R;
+import de.bjusystems.vdrmanager.data.Timer;
+
+/**
+ * Class for retrieving informations about the running program
+ * @author bju
+ *
+ */
+public class SetTimerClient extends SvdrpClient<Timer> {
+
+	/** channel names for timer */
+	Timer timer;
+	/** timer should be deleted */
+	boolean deleteTimer;
+
+	/**
+	 * Constructor
+	 * @param host host
+	 * @param port port
+	 * @param ssl use ssl
+	 */
+	public SetTimerClient(final Timer timer, final boolean deleteTimer) {
+		super();
+		this.timer = timer;
+		this.deleteTimer = deleteTimer;
+	}
+
+	/**
+	 * Starts the request
+	 */
+	@Override
+	public void run() throws SvdrpException {
+
+		final StringBuilder command = new StringBuilder();
+
+		command.append("timer ");
+		if (deleteTimer) {
+			command.append("-");
+		}
+		command.append(timer.getNumber());
+		command.append(" ");
+		command.append(timer.toCommandLine());
+
+		runCommand(command.toString());
+	}
+
+	@Override
+	public Timer parseAnswer(final String line) {
+		return new Timer(line);
+	}
+
+	@Override
+	public int getProgressTextId() {
+		return R.string.progress_timer_save;
+	}
+}
+
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SvdrpAsyncListener.java b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SvdrpAsyncListener.java
new file mode 100644
index 0000000..fc388bf
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SvdrpAsyncListener.java
@@ -0,0 +1,7 @@
+package de.bjusystems.vdrmanager.utils.svdrp;
+
+public interface SvdrpAsyncListener<Result> extends SvdrpListener<Result> {
+
+	void svdrpException(SvdrpException exception);
+
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SvdrpAsyncTask.java b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SvdrpAsyncTask.java
new file mode 100644
index 0000000..7dc0097
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SvdrpAsyncTask.java
@@ -0,0 +1,61 @@
+package de.bjusystems.vdrmanager.utils.svdrp;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import android.os.AsyncTask;
+
+public class SvdrpAsyncTask<Result, Client extends SvdrpClient<Result>>
+										extends AsyncTask<Void, Object, Void>
+										implements SvdrpListener<Result> {
+
+	Client client;
+	List<SvdrpAsyncListener<Result>> listeners = new ArrayList<SvdrpAsyncListener<Result>>();
+
+	public SvdrpAsyncTask(final Client client) {
+		this.client = client;
+		client.addSvdrpListener(this);
+	}
+
+	public void addListener(final SvdrpAsyncListener<Result> listener) {
+		listeners.add(listener);
+	}
+
+	public void removeListener(final SvdrpAsyncListener<Result> listener) {
+		listeners.remove(listener);
+	}
+
+	public void run() {
+		execute();
+	}
+
+	@Override
+	protected Void doInBackground(final Void... params) {
+		try {
+			client.run();
+		} catch (final SvdrpException e) {
+			publishProgress(null, null, e);
+		}
+		return null;
+	}
+
+	public void svdrpEvent(final SvdrpEvent event, final Result result) {
+		publishProgress(event, result, null);
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	protected void onProgressUpdate(final Object... values) {
+		super.onProgressUpdate(values);
+
+		if (values[2] == null) {
+			for(final SvdrpAsyncListener<Result> listener : listeners) {
+				listener.svdrpEvent((SvdrpEvent)values[0], (Result)values[1]);
+			}
+		} else {
+			for(final SvdrpAsyncListener<Result> listener : listeners) {
+				listener.svdrpException((SvdrpException)values[2]);
+			}
+		}
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SvdrpClient.java b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SvdrpClient.java
new file mode 100644
index 0000000..ffb8b7b
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SvdrpClient.java
@@ -0,0 +1,271 @@
+package de.bjusystems.vdrmanager.utils.svdrp;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.Socket;
+import java.util.ArrayList;
+import java.util.List;
+
+import de.bjusystems.vdrmanager.data.Preferences;
+
+
+/**
+ * Class for SVDRP communication
+ * @author bju
+ *
+ */
+public abstract class SvdrpClient<Result> {
+
+	/** Socket for connection to SVDRP */
+	private Socket socket;
+	/** Output stream for sending commands */
+	private OutputStream outputStream;
+	/** Input stream for reading answer lines */
+	private InputStream inputStream;
+	/** flag for stopping the current request */
+	private boolean abort;
+	/** listener */
+	private final List<SvdrpListener<Result>> listeners = new ArrayList<SvdrpListener<Result>>();
+	/** list of results */
+	private final List<Result> results = new ArrayList<Result>();
+	/** should the listener be informed about each received result */
+	private boolean resultInfoEnabled = false;
+
+	/**
+	 * Parse received answer line
+	 * @param line line
+	 * @return received data object or null if not completed yet
+	 */
+	protected abstract Result parseAnswer(String line);
+
+	public abstract int getProgressTextId();
+
+	public abstract void run() throws SvdrpException;
+
+	/**
+	 * Constructor
+	 * @param prefs Preferences
+	 */
+	protected SvdrpClient() {
+		results.clear();
+	}
+
+	/**
+	 * Remove all listeners
+	 */
+	public void clearSvdrpListener() {
+		listeners.clear();
+	}
+
+	/**
+	 * Adds the listener to the list of listeners
+	 * @param listener listener
+	 */
+	public void addSvdrpListener(final SvdrpListener<Result> listener) {
+		listeners.add(listener);
+	}
+
+	/**
+	 * Removes the listener from the list of listeners
+	 * @param listener listener
+	 */
+	public void removeSvdrpListener(final SvdrpListener<Result> listener) {
+		listeners.remove(listener);
+	}
+
+	/**
+	 * Cancel the current request
+	 */
+	public void abort() {
+		abort = true;
+	}
+
+	/**
+	 * Gets the list of results
+	 * @return results
+	 */
+	public List<Result> getResults() {
+		return results;
+	}
+
+	/**
+	 * Connect to SVDRP
+	 * @param host host
+	 * @param port port
+	 * @param ssl use SSL
+	 * @throws IOException on errors
+	 */
+	protected boolean connect() throws IOException {
+
+		final Preferences prefs = Preferences.getPreferences();
+
+		try {
+			// connect
+			informListener(SvdrpEvent.CONNECTING, null);
+			socket = new Socket(prefs.getSvdrpHost(), prefs.getSvdrpPort());
+			informListener(SvdrpEvent.CONNECTED, null);
+		} catch (final IOException e) {
+			informListener(SvdrpEvent.CONNECT_ERROR, null);
+			return false;
+		}
+
+		// create streams
+		outputStream = socket.getOutputStream();
+		inputStream = socket.getInputStream();
+
+		// password needed?
+		informListener(SvdrpEvent.LOGIN, null);
+		writeLine("passwd " + prefs.getPassword());
+		if (!readLine().startsWith("!OK")) {
+			informListener(SvdrpEvent.LOGIN_ERROR, null);
+			disconnect();
+			return false;
+		} else {
+			informListener(SvdrpEvent.LOGGED_IN, null);
+		}
+
+		return true;
+	}
+
+	/**
+	 * Disconnect from SVDRP if connected
+	 * @throws IOException on errors
+	 */
+	protected void disconnect() throws IOException {
+		informListener(SvdrpEvent.DISCONNECTING, null);
+		if (socket != null && socket.isConnected()) {
+			socket.close();
+			socket = null;
+		}
+		informListener(SvdrpEvent.DISCONNECTED, null);
+	}
+
+	/**
+	 * Sends one line to SVDRP
+	 * @param line line of text
+	 * @throws IOException on errors
+	 */
+	protected void writeLine(final String line) throws IOException {
+
+		final String command = line + "\r\n";
+		final byte[] bytes = command.getBytes();
+		outputStream.write(bytes);
+		outputStream.flush();
+	}
+
+	/**
+	 * Reads one line from SVDRP
+	 * @return line read
+	 * @throws IOException on errors
+	 */
+	protected String readLine() throws IOException {
+
+		// handle not gzipped input
+		final ByteArrayOutputStream lineBytes = new ByteArrayOutputStream();
+
+		for(;;) {
+
+			// read next char
+			final int d = inputStream.read();
+			if (d < 0) {
+				break;
+			}
+			final char c = (char)d;
+
+			// skip '\r'
+			if (c == '\r') {
+				continue;
+			}
+
+			// with '\n' the line is completed
+			if (c == '\n') {
+				break;
+			}
+
+			// remember char
+			lineBytes.write(c);
+		}
+
+		return lineBytes.toString();
+	}
+
+	public void runCommand(final String command) throws SvdrpException {
+
+		try {
+
+			// reset cancel flag
+			abort = false;
+
+			// clear results
+			results.clear();
+
+			// connect
+			final boolean connected = connect();
+			if (!connected) {
+				return;
+			}
+
+			// send command
+			informListener(SvdrpEvent.COMMAND_SENDING, null);
+			writeLine(command);
+			informListener(SvdrpEvent.COMMAND_SENT, null);
+
+			// read first line
+			String line = readLine();
+			if (!line.startsWith("START")) {
+				throw new IOException("Answer not wellformed");
+			}
+
+			// read answer lines
+			for(;!abort;) {
+
+				// get next line
+				line = readLine();
+				if (line.length() == 0) {
+					break;
+				}
+
+				// last line?
+				if (line.startsWith("END")) {
+					break;
+				}
+
+				// error?
+				if (line.startsWith("!ERROR")) {
+					informListener(SvdrpEvent.ERROR, null);
+					break;
+				}
+
+				// delegate analysis
+				final Result result = parseAnswer(line);
+				if (result != null) {
+					results.add(result);
+					if (resultInfoEnabled) {
+						informListener(SvdrpEvent.RESULT_RECEIVED, result);
+					}
+				}
+
+			}
+
+			// disconnect
+			disconnect();
+
+		} catch (final IOException e) {
+			throw new SvdrpException(e);
+		} finally {
+			informListener(SvdrpEvent.FINISHED, null);
+		}
+	}
+
+	public void setResultInfoEnabled(final boolean resultInfoEnabled) {
+		this.resultInfoEnabled = resultInfoEnabled;
+	}
+
+	private void informListener(final SvdrpEvent event, final Result result) {
+		for(final SvdrpListener<Result> listener : listeners) {
+			listener.svdrpEvent(event, result);
+		}
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SvdrpEvent.java b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SvdrpEvent.java
new file mode 100644
index 0000000..a807659
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SvdrpEvent.java
@@ -0,0 +1,17 @@
+package de.bjusystems.vdrmanager.utils.svdrp;
+
+public enum SvdrpEvent {
+	CONNECTING,
+	CONNECTED,
+	CONNECT_ERROR,
+	LOGIN,
+	LOGGED_IN,
+	LOGIN_ERROR,
+	COMMAND_SENDING,
+	COMMAND_SENT,
+	RESULT_RECEIVED,
+	DISCONNECTING,
+	DISCONNECTED,
+	FINISHED,
+	ERROR
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SvdrpException.java b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SvdrpException.java
new file mode 100644
index 0000000..9c6d5e0
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SvdrpException.java
@@ -0,0 +1,22 @@
+package de.bjusystems.vdrmanager.utils.svdrp;
+
+/**
+ * Class for exception caused by SVDRP errors
+ * @author bju
+ *
+ */
+@SuppressWarnings("serial")
+public class SvdrpException extends Exception {
+
+	public SvdrpException(String text) {
+		super(text);
+	}
+	
+	public SvdrpException(String text, Throwable cause) {
+		super(text, cause);
+	}
+	
+	public SvdrpException(Throwable cause) {
+		super(cause);
+	}
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SvdrpListener.java b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SvdrpListener.java
new file mode 100644
index 0000000..df8762b
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/SvdrpListener.java
@@ -0,0 +1,7 @@
+package de.bjusystems.vdrmanager.utils.svdrp;
+
+
+public interface SvdrpListener<Result>{
+
+	void svdrpEvent(SvdrpEvent event, Result result);
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/TimerClient.java b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/TimerClient.java
new file mode 100644
index 0000000..9d75421
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/TimerClient.java
@@ -0,0 +1,50 @@
+package de.bjusystems.vdrmanager.utils.svdrp;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import de.bjusystems.vdrmanager.R;
+import de.bjusystems.vdrmanager.data.Channel;
+import de.bjusystems.vdrmanager.data.Timer;
+
+/**
+ * Class for retrieving informations about the running program
+ * @author bju
+ *
+ */
+public class TimerClient extends SvdrpClient<Timer> {
+
+	/** channel names for timer */
+	Map<String, Channel> channels;
+
+	/**
+	 * Constructor
+	 * @param host host
+	 * @param port port
+	 * @param ssl use ssl
+	 */
+	public TimerClient() {
+		super();
+		this.channels = new HashMap<String, Channel>();
+	}
+
+	/**
+	 * Starts the EPG request
+	 * @param parameter parameter for lste
+	 */
+	@Override
+	public void run() throws SvdrpException {
+		runCommand("timers");
+	}
+
+	@Override
+	public Timer parseAnswer(final String line) {
+		return new Timer(line);
+	}
+
+	@Override
+	public int getProgressTextId() {
+		return R.string.progress_timers_loading;
+	}
+}
+
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/WakeupClient.java b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/WakeupClient.java
new file mode 100644
index 0000000..072861c
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/utils/svdrp/WakeupClient.java
@@ -0,0 +1,51 @@
+package de.bjusystems.vdrmanager.utils.svdrp;
+
+import de.bjusystems.vdrmanager.data.WakeupState;
+
+/**
+ * Class for retrieving informations about the running program
+ * @author bju
+ *
+ */
+public class WakeupClient extends SvdrpClient<WakeupState> {
+
+	private WakeupState state;
+
+	/**
+	 * Constructor
+	 */
+	public WakeupClient() {
+		super();
+	}
+
+	/**
+	 * Starts the wakeup request
+	 */
+	@Override
+	public void run() throws SvdrpException {
+		runCommand("wake");
+	}
+
+	@Override
+	public WakeupState parseAnswer(final String line) {
+
+		if (line.startsWith("200")) {
+			state = WakeupState.OK;
+		} else if (line.startsWith("400")) {
+			state = WakeupState.FAILED;
+		} else {
+			state = WakeupState.ERROR;
+		}
+		return state;
+	}
+
+	@Override
+	public int getProgressTextId() {
+		return 0;
+	}
+
+	public WakeupState getState() {
+		return state;
+	}
+
+}
\ No newline at end of file
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/utils/wakeup/AsyncWakeupTask.java b/vdrmanager/src/de/bjusystems/vdrmanager/utils/wakeup/AsyncWakeupTask.java
new file mode 100644
index 0000000..2586b5c
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/utils/wakeup/AsyncWakeupTask.java
@@ -0,0 +1,84 @@
+package de.bjusystems.vdrmanager.utils.wakeup;
+
+import android.app.ProgressDialog;
+import android.content.Context;
+import android.os.AsyncTask;
+import android.widget.Toast;
+import de.bjusystems.vdrmanager.R;
+import de.bjusystems.vdrmanager.data.Preferences;
+import de.bjusystems.vdrmanager.utils.http.HttpHelper;
+
+public class AsyncWakeupTask extends AsyncTask<Object, WakeupProgress, Void> {
+
+	/** Context */
+	private final Context context;
+	/** Progress dialog */
+	private ProgressDialog progressDialog;
+
+	public AsyncWakeupTask(final Context context) {
+		this.context = context;
+	}
+
+	@Override
+	protected Void doInBackground(final Object... params) {
+
+		// open progress dialog
+		publishProgress(WakeupProgress.WAKEUP_STARTED);
+
+		// Preferences
+		final Preferences prefs = Preferences.getPreferences();
+
+		boolean ok = false;
+		try {
+
+			// wakeup by http request
+			final HttpHelper httpHelper = new HttpHelper();
+			httpHelper.performGet(prefs.getWakeupUrl(), prefs.getWakeupUser(), prefs.getWakeupPassword(), null);
+			// request sent
+			ok = true;
+
+		} catch (final Exception e) {
+		}
+
+		// close progress
+		publishProgress(WakeupProgress.WAKEUP_FINISHED);
+
+		if (ok) {
+			publishProgress(WakeupProgress.WAKEUP_OK);
+		} else {
+			publishProgress(WakeupProgress.WAKEUP_ERROR);
+		}
+
+		return null;
+	}
+
+	@Override
+	protected void onProgressUpdate(final WakeupProgress... values) {
+		super.onProgressUpdate(values);
+
+		switch (values[0]) {
+		case WAKEUP_STARTED:
+			final CharSequence message = context.getText(R.string.progress_wakeup_sending);
+			progressDialog = ProgressDialog.show(context, "", message);
+			break;
+		case WAKEUP_FINISHED:
+			progressDialog.dismiss();
+			break;
+		case WAKEUP_OK:
+			showToast(R.string.progress_wakeup_sent);
+			break;
+		case WAKEUP_ERROR:
+			showToast(R.string.progress_wakeup_error);
+			break;
+		}
+	}
+
+	private void showToast(final int textId) {
+
+		final CharSequence text = context.getText(textId);
+		final int duration = Toast.LENGTH_SHORT;
+		final Toast toast = Toast.makeText(context, text, duration);
+		toast.show();
+	}
+
+}
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/utils/wakeup/WakeupProgress.java b/vdrmanager/src/de/bjusystems/vdrmanager/utils/wakeup/WakeupProgress.java
new file mode 100644
index 0000000..46838dc
--- /dev/null
+++ b/vdrmanager/src/de/bjusystems/vdrmanager/utils/wakeup/WakeupProgress.java
@@ -0,0 +1,8 @@
+package de.bjusystems.vdrmanager.utils.wakeup;
+
+public enum WakeupProgress {
+	WAKEUP_STARTED,
+	WAKEUP_OK,
+	WAKEUP_ERROR,
+	WAKEUP_FINISHED
+}