diff options
7 files changed, 739 insertions, 103 deletions
diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/QueuedWork.java b/vdrmanager/src/de/bjusystems/vdrmanager/QueuedWork.java new file mode 100644 index 0000000..09bb15b --- /dev/null +++ b/vdrmanager/src/de/bjusystems/vdrmanager/QueuedWork.java @@ -0,0 +1,101 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package de.bjusystems.vdrmanager; + +import java.util.concurrent.ConcurrentLinkedQueue; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +/** + * Internal utility class to keep track of process-global work that's + * outstanding and hasn't been finished yet. + * + * This was created for writing SharedPreference edits out + * asynchronously so we'd have a mechanism to wait for the writes in + * Activity.onPause and similar places, but we may use this mechanism + * for other things in the future. + * + * + */ +public class QueuedWork { + + // The set of Runnables that will finish or wait on any async + // activities started by the application. + private static final ConcurrentLinkedQueue<Runnable> sPendingWorkFinishers = + new ConcurrentLinkedQueue<Runnable>(); + + private static ExecutorService sSingleThreadExecutor = null; // lazy, guarded by class + + /** + * Returns a single-thread Executor shared by the entire process, + * creating it if necessary. + */ + public static ExecutorService singleThreadExecutor() { + synchronized (QueuedWork.class) { + if (sSingleThreadExecutor == null) { + // TODO: can we give this single thread a thread name? + sSingleThreadExecutor = Executors.newSingleThreadExecutor(); + } + return sSingleThreadExecutor; + } + } + + /** + * Add a runnable to finish (or wait for) a deferred operation + * started in this context earlier. Typically finished by e.g. + * an Activity#onPause. Used by SharedPreferences$Editor#startCommit(). + * + * Note that this doesn't actually start it running. This is just + * a scratch set for callers doing async work to keep updated with + * what's in-flight. In the common case, caller code + * (e.g. SharedPreferences) will pretty quickly call remove() + * after an add(). The only time these Runnables are run is from + * waitToFinish(), below. + */ + public static void add(Runnable finisher) { + sPendingWorkFinishers.add(finisher); + } + + public static void remove(Runnable finisher) { + sPendingWorkFinishers.remove(finisher); + } + + /** + * Finishes or waits for async operations to complete. + * (e.g. SharedPreferences$Editor#startCommit writes) + * + * Is called from the Activity base class's onPause(), after + * BroadcastReceiver's onReceive, after Service command handling, + * etc. (so async work is never lost) + */ + public static void waitToFinish() { + Runnable toFinish; + while ((toFinish = sPendingWorkFinishers.poll()) != null) { + toFinish.run(); + } + } + + /** + * Returns true if there is pending work to be done. Note that the + * result is out of data as soon as you receive it, so be careful how you + * use it. + */ + public static boolean hasPendingWork() { + return !sPendingWorkFinishers.isEmpty(); + } + +} diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/VdrSharedPreferencesImpl.java b/vdrmanager/src/de/bjusystems/vdrmanager/VdrSharedPreferencesImpl.java new file mode 100644 index 0000000..0eac4fb --- /dev/null +++ b/vdrmanager/src/de/bjusystems/vdrmanager/VdrSharedPreferencesImpl.java @@ -0,0 +1,527 @@ +/* + * Copyrigsht (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package de.bjusystems.vdrmanager; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.WeakHashMap; +import java.util.concurrent.CountDownLatch; + +import android.content.SharedPreferences; +import android.os.Looper; + +import com.j256.ormlite.dao.RuntimeExceptionDao; + +import de.bjusystems.vdrmanager.data.Vdr; + +public class VdrSharedPreferencesImpl implements SharedPreferences { + + private static final String TAG = "SharedPreferencesImpl"; + + private static final boolean DEBUG = false; + + // Lock ordering rules: + // - acquire SharedPreferencesImpl.this before EditorImpl.this + // - acquire mWritingToDiskLock before EditorImpl.this + + Vdr mVdr; + + + public Vdr getVdr(){ + return mVdr; + } + + RuntimeExceptionDao<Vdr, Integer> dao; + + private Map<String, Object> mMap; // guarded by 'this' + private int mDiskWritesInFlight = 0; // guarded by 'this' + private boolean mLoaded = false; // guarded by 'this' + + private final Object mWritingToDiskLock = new Object(); + private static final Object mContent = new Object(); + private final WeakHashMap<OnSharedPreferenceChangeListener, Object> mListeners = new WeakHashMap<OnSharedPreferenceChangeListener, Object>(); + + public VdrSharedPreferencesImpl(Vdr vdr, RuntimeExceptionDao<Vdr, Integer> dao) { + mVdr = vdr; + this.dao = dao; + mLoaded = false; + mMap = null; + startLoadFromDisk(); + } + + private void startLoadFromDisk() { + synchronized (this) { + mLoaded = false; + } + new Thread("SharedPreferencesImpl-load") { + public void run() { + synchronized (VdrSharedPreferencesImpl.this) { + loadFromDiskLocked(); + } + } + }.start(); + } + + private void loadFromDiskLocked() { + if (mLoaded) { + return; + } + + Map map = mVdr.toMap(); + //StructStat stat = null; + //try { + //stat = Libcore.os.stat(mFile.getPath()); + //if (mFile.canRead()) { + //BufferedInputStream str = null; + //try { + //str = new BufferedInputStream(new FileInputStream(mFile), + // 16 * 1024); + //map = XmlUtils.readMapXml(str); + //} catch (XmlPullParserException e) { +// Log.w(TAG, "getSharedPreferences", e); + // } catch (FileNotFoundException e) { + // Log.w(TAG, "getSharedPreferences", e); + // } catch (IOException e) { + // Log.w(TAG, "getSharedPreferences", e); + //} finally { + //IoUtils.closeQuietly(str); + //} + //} + //} catch (ErrnoException e) { + //} + mLoaded = true; + if (map != null) { + mMap = map; + } else { + mMap = new HashMap<String, Object>(); + } + notifyAll(); + } + + + + public void registerOnSharedPreferenceChangeListener( + OnSharedPreferenceChangeListener listener) { + synchronized (this) { + mListeners.put(listener, mContent); + } + } + + public void unregisterOnSharedPreferenceChangeListener( + OnSharedPreferenceChangeListener listener) { + synchronized (this) { + mListeners.remove(listener); + } + } + + private void awaitLoadedLocked() { + // if (!mLoaded) { + // // Raise an explicit StrictMode onReadFromDisk for this + // // thread, since the real read will be in a different + // // thread and otherwise ignored by StrictMode. + // BlockGuard.getThreadPolicy().onReadFromDisk(); + // } + while (!mLoaded) { + try { + wait(); + } catch (InterruptedException unused) { + } + } + } + + public Map<String, ?> getAll() { + synchronized (this) { + awaitLoadedLocked(); + // noinspection unchecked + return new HashMap<String, Object>(mMap); + } + } + + public String getString(String key, String defValue) { + synchronized (this) { + awaitLoadedLocked(); + String v = String.valueOf(mMap.get(key)); + return v != null ? v : defValue; + } + } + + public Set<String> getStringSet(String key, Set<String> defValues) { + synchronized (this) { + awaitLoadedLocked(); + Set<String> v = (Set<String>) mMap.get(key); + return v != null ? v : defValues; + } + } + + public int getInt(String key, int defValue) { + synchronized (this) { + awaitLoadedLocked(); + Integer v = (Integer) mMap.get(key); + return v != null ? v : defValue; + } + } + + public long getLong(String key, long defValue) { + synchronized (this) { + awaitLoadedLocked(); + Long v = (Long) mMap.get(key); + return v != null ? v : defValue; + } + } + + public float getFloat(String key, float defValue) { + synchronized (this) { + awaitLoadedLocked(); + Float v = (Float) mMap.get(key); + return v != null ? v : defValue; + } + } + + public boolean getBoolean(String key, boolean defValue) { + synchronized (this) { + awaitLoadedLocked(); + Boolean v = (Boolean) mMap.get(key); + return v != null ? v : defValue; + } + } + + public boolean contains(String key) { + synchronized (this) { + awaitLoadedLocked(); + return mMap.containsKey(key); + } + } + + public Editor edit() { + // TODO: remove the need to call awaitLoadedLocked() when + // requesting an editor. will require some work on the + // Editor, but then we should be able to do: + // + // context.getSharedPreferences(..).edit().putString(..).apply() + // + // ... all without blocking. + synchronized (this) { + awaitLoadedLocked(); + } + + return new EditorImpl(); + } + + // Return value from EditorImpl#commitToMemory() + private static class MemoryCommitResult { + public boolean changesMade; // any keys different? + public List<String> keysModified; // may be null + public Set<OnSharedPreferenceChangeListener> listeners; // may be null + public Map<String, Object> mapToWriteToDisk; + public final CountDownLatch writtenToDiskLatch = new CountDownLatch(1); + public volatile boolean writeToDiskResult = false; + + public void setDiskWriteResult(boolean result) { + writeToDiskResult = result; + writtenToDiskLatch.countDown(); + } + } + + public final class EditorImpl implements Editor { + + private final Map<String, Object> mModified = new HashMap<String, Object>(); + + private boolean mClear = false; + + public Editor putString(String key, String value) { + synchronized (this) { + mModified.put(key, value); + return this; + } + } + + public Editor putStringSet(String key, Set<String> values) { + synchronized (this) { + mModified.put(key, (values == null) ? null + : new HashSet<String>(values)); + return this; + } + } + + public Editor putInt(String key, int value) { + synchronized (this) { + mModified.put(key, value); + return this; + } + } + + public Editor putLong(String key, long value) { + synchronized (this) { + mModified.put(key, value); + return this; + } + } + + public Editor putFloat(String key, float value) { + synchronized (this) { + mModified.put(key, value); + return this; + } + } + + public Editor putBoolean(String key, boolean value) { + synchronized (this) { + mModified.put(key, value); + return this; + } + } + + public Editor remove(String key) { + synchronized (this) { + mModified.put(key, this); + return this; + } + } + + public Editor clear() { + synchronized (this) { + mClear = true; + return this; + } + } + + public void apply() { + final MemoryCommitResult mcr = commitToMemory(); + final Runnable awaitCommit = new Runnable() { + public void run() { + try { + mcr.writtenToDiskLatch.await(); + } catch (InterruptedException ignored) { + } + } + }; + + QueuedWork.add(awaitCommit); + + Runnable postWriteRunnable = new Runnable() { + public void run() { + awaitCommit.run(); + QueuedWork.remove(awaitCommit); + } + }; + + VdrSharedPreferencesImpl.this.enqueueDiskWrite(mcr, postWriteRunnable); + + // Okay to notify the listeners before it's hit disk + // because the listeners should always get the same + // SharedPreferences instance back, which has the + // changes reflected in memory. + notifyListeners(mcr); + } + + // Returns true if any changes were made + private MemoryCommitResult commitToMemory() { + MemoryCommitResult mcr = new MemoryCommitResult(); + synchronized (VdrSharedPreferencesImpl.this) { + // We optimistically don't make a deep copy until + // a memory commit comes in when we're already + // writing to disk. + if (mDiskWritesInFlight > 0) { + // We can't modify our mMap as a currently + // in-flight write owns it. Clone it before + // modifying it. + // noinspection unchecked + mMap = new HashMap<String, Object>(mMap); + } + mcr.mapToWriteToDisk = mMap; + mDiskWritesInFlight++; + + boolean hasListeners = mListeners.size() > 0; + if (hasListeners) { + mcr.keysModified = new ArrayList<String>(); + mcr.listeners = new HashSet<OnSharedPreferenceChangeListener>( + mListeners.keySet()); + } + + synchronized (this) { + if (mClear) { + if (!mMap.isEmpty()) { + mcr.changesMade = true; + mMap.clear(); + } + mClear = false; + } + + for (Map.Entry<String, Object> e : mModified.entrySet()) { + String k = e.getKey(); + Object v = e.getValue(); + if (v == this) { // magic value for a removal mutation + if (!mMap.containsKey(k)) { + continue; + } + mMap.remove(k); + } else { + boolean isSame = false; + if (mMap.containsKey(k)) { + Object existingValue = mMap.get(k); + if (existingValue != null + && existingValue.equals(v)) { + continue; + } + } + mMap.put(k, v); + } + + mcr.changesMade = true; + if (hasListeners) { + mcr.keysModified.add(k); + } + } + + mModified.clear(); + } + } + return mcr; + } + + public boolean commit() { + MemoryCommitResult mcr = commitToMemory(); + VdrSharedPreferencesImpl.this.enqueueDiskWrite(mcr, null /* + * sync write on + * this thread + * okay + */); + try { + mcr.writtenToDiskLatch.await(); + } catch (InterruptedException e) { + return false; + } + notifyListeners(mcr); + return mcr.writeToDiskResult; + } + + private void notifyListeners(final MemoryCommitResult mcr) { + if (mcr.listeners == null || mcr.keysModified == null + || mcr.keysModified.size() == 0) { + return; + } + //if (Looper.myLooper() == Looper.getMainLooper()) { + for (int i = mcr.keysModified.size() - 1; i >= 0; i--) { + final String key = mcr.keysModified.get(i); + for (OnSharedPreferenceChangeListener listener : mcr.listeners) { + if (listener != null) { + listener.onSharedPreferenceChanged( + VdrSharedPreferencesImpl.this, key); + } + } + } + //} else { + // Run this function on the main thread. + // VdrManagerApp.sMainThreadHandler.post(new Runnable() { + // public void run() { + // notifyListeners(mcr); + // } + // }); + //} + } + } + + /** + * Enqueue an already-committed-to-memory result to be written to disk. + * + * They will be written to disk one-at-a-time in the order that they're + * enqueued. + * + * @param postWriteRunnable + * if non-null, we're being called from apply() and this is the + * runnable to run after the write proceeds. if null (from a + * regular commit()), then we're allowed to do this disk write on + * the main thread (which in addition to reducing allocations and + * creating a background thread, this has the advantage that we + * catch them in userdebug StrictMode reports to convert them + * where possible to apply() ...) + */ + private void enqueueDiskWrite(final MemoryCommitResult mcr, + final Runnable postWriteRunnable) { + final Runnable writeToDiskRunnable = new Runnable() { + public void run() { + synchronized (mWritingToDiskLock) { + writeToFile(mcr); + } + synchronized (VdrSharedPreferencesImpl.this) { + mDiskWritesInFlight--; + } + if (postWriteRunnable != null) { + postWriteRunnable.run(); + } + } + }; + + final boolean isFromSyncCommit = (postWriteRunnable == null); + + // Typical #commit() path with fewer allocations, doing a write on + // the current thread. + if (isFromSyncCommit) { + boolean wasEmpty = false; + synchronized (VdrSharedPreferencesImpl.this) { + wasEmpty = mDiskWritesInFlight == 1; + } + if (wasEmpty) { + writeToDiskRunnable.run(); + return; + } + } + + QueuedWork.singleThreadExecutor().execute(writeToDiskRunnable); + } + + // Note: must hold mWritingToDiskLock + private void writeToFile(MemoryCommitResult mcr) { + // Rename the current file so it may be used as a backup during the next + // read + + // Attempt to write the file, delete the backup and return true as + // atomically as + // possible. If any exception occurs, delete the new file; next time we + // will restore + // from the backup. + // FileOutputStream str = createFileOutputStream(mFile); + // if (str == null) { + // mcr.setDiskWriteResult(false); + // return; + // } + // + // XmlUtils.writeMapXml(mcr.mapToWriteToDisk, str); + mVdr.set(mcr.mapToWriteToDisk); + dao.createOrUpdate(mVdr); + // FileUtils.sync(str); + // str.close(); + // ContextImpl.setFilePermissionsFromMode(mFile.getPath(), mMode, 0); + // try { + // final StructStat stat = Libcore.os.stat(mFile.getPath()); + // synchronized (this) { + // mStatTimestamp = stat.st_mtime; + // mStatSize = stat.st_size; + // } + // } catch (ErrnoException e) { + // // Do nothing + // } + // Writing was successful, delete the backup file if there is one. + mcr.setDiskWriteResult(true); + return; + + } +} diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/data/FetchEditTextPreference.java b/vdrmanager/src/de/bjusystems/vdrmanager/data/FetchEditTextPreference.java index 5e4022e..17a93b7 100644 --- a/vdrmanager/src/de/bjusystems/vdrmanager/data/FetchEditTextPreference.java +++ b/vdrmanager/src/de/bjusystems/vdrmanager/data/FetchEditTextPreference.java @@ -2,13 +2,13 @@ package de.bjusystems.vdrmanager.data; import android.content.Context; import android.content.DialogInterface; +import android.content.SharedPreferences.Editor; import android.preference.DialogPreference; import android.util.AttributeSet; import android.view.View; import android.widget.EditText; import android.widget.ImageButton; import de.bjusystems.vdrmanager.R; -import de.bjusystems.vdrmanager.data.VdrSharedPreferences.Editor; public class FetchEditTextPreference extends DialogPreference{ diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/data/Vdr.java b/vdrmanager/src/de/bjusystems/vdrmanager/data/Vdr.java index b34c5bd..761a11e 100644 --- a/vdrmanager/src/de/bjusystems/vdrmanager/data/Vdr.java +++ b/vdrmanager/src/de/bjusystems/vdrmanager/data/Vdr.java @@ -17,7 +17,7 @@ public class Vdr { private Integer id; @DatabaseField(columnName = "name") - private String name = "-"; + private String name = "VDR"; /** * Use secure channel @@ -27,15 +27,15 @@ public class Vdr { /** SVDRP host name or ip */ @DatabaseField - private String host = "0.0.0.0"; + private String host = "0.0.0.0"; /** SVDRP port */ @DatabaseField - private int port = 6420; + private Integer port = 6420; /** Password */ @DatabaseField - private String password; + private String password = ""; /** should channels be filtered? */ @DatabaseField @@ -51,15 +51,15 @@ public class Vdr { /** URL of the wakeup script */ @DatabaseField - private String wakeupUrl; + private String wakeupUrl = ""; /** User for wakeup */ @DatabaseField - private String wakeupUser; + private String wakeupUser = ""; /** Password for wakeup */ @DatabaseField - private String wakeupPassword; + private String wakeupPassword = ""; /** * vdr mac for wol @@ -67,7 +67,7 @@ public class Vdr { * @since 0.2 */ @DatabaseField - private String mac; + private String mac = ""; /** * which wakeup method to use @@ -84,7 +84,7 @@ public class Vdr { /** Intervall for alive test */ @DatabaseField - private int aliveCheckInterval; + private Integer aliveCheckInterval; /** Buffer before event */ @DatabaseField @@ -104,7 +104,7 @@ public class Vdr { /** user defined epg search times */ @DatabaseField - private String epgSearchTimes; + private String epgSearchTimes = ""; /** * Which port to use for streaming @@ -140,7 +140,7 @@ public class Vdr { * Remux command */ @DatabaseField - private String remuxCommand = "EXT"; + private String remuxCommand = "EXT"; /** * Remux command Parameter @@ -170,10 +170,10 @@ public class Vdr { private int timeout = 60; @DatabaseField - private String streamingUsername; + private String streamingUsername = ""; @DatabaseField - private String streamingPassword; + private String streamingPassword = ""; @DatabaseField private int livePort = 8008; @@ -184,8 +184,7 @@ public class Vdr { @DatabaseField private boolean enableRecStreaming = false; - - @DatabaseField(columnName="stz") + @DatabaseField(columnName = "stz") private String serverTimeZone = "Europe/Berlin"; public String getServerTimeZone() { @@ -489,10 +488,14 @@ public class Vdr { } private static <T> T get(Map<String, Object> map, String key, Object def) { - if(map.containsKey(key)){ + if (map.containsKey(key)) { return (T) map.get(key); } - return (T)def; + return (T) def; + } + + private static Integer getInteger(Map<String, Object> map, String key) { + return getInteger(map, key, 0); } private static Integer getInteger(Map<String, Object> map, String key, @@ -505,21 +508,26 @@ public class Vdr { if (obj instanceof Integer) { return (Integer) obj; } - return Integer.valueOf(String.valueOf(obj)); - } - private static Integer getInteger(Map<String, Object> map, String key) { - if (map.containsKey(key) == false) { - return Integer.valueOf(0); - } - - Object obj = get(map, key); - if (obj instanceof Integer) { - return (Integer) obj; + try { + return Integer.valueOf(String.valueOf(obj)); + } catch (NumberFormatException nfe) { + return def; } - return Integer.valueOf(String.valueOf(obj)); } + // private static Integer getInteger(Map<String, Object> map, String key) { + // if (map.containsKey(key) == false) { + // return Integer.valueOf(0); + // } + + // Object obj = get(map, key); + // if (obj instanceof Integer) { + // return (Integer) obj; + // } + // return Integer.valueOf(String.valueOf(obj)); + // } + private static Boolean getBoolean(Map<String, Object> map, String key) { return getBoolean(map, key, false); } @@ -580,58 +588,9 @@ public class Vdr { } public void set(Map<String, Object> map) { - name = get(map, "vdr_name", name); - host = get(map, "vdr_host", host); - port = getInteger(map, "vdr_port", port); - password = get(map, "vdr_password", password); - secure = getBoolean(map, "vdr_secure", secure); - - filterChannels = getBoolean(map, "limit_channels", filterChannels); - channelFilter = get(map, "last_channel", channelFilter); - - wakeupEnabled = getBoolean(map, "key_wakeup_enabled", wakeupEnabled); - wakeupUrl = get(map, "key_wakeup_url", wakeupUrl); - wakeupUser = get(map, "key_wakeup_user", wakeupUser); - wakeupPassword = get(map, "key_wakeup_password", wakeupPassword); - wakeupMethod = get(map, "key_wakeup_method", wakeupMethod); - wolCustomBroadcast = get(map, "key_wol_custom_broadcast", - wolCustomBroadcast); - mac = get(map, "key_wakeup_wol_mac", mac); - - connectionTimeout = getInteger(map, "key_conntimeout_key", - connectionTimeout); - readTimeout = getInteger(map, "key_vdr_readtimeout", readTimeout); - timeout = getInteger(map, "key_vdr_timeout", timeout); - - timerPreMargin = getInteger(map, "timer_pre_start_buffer", - timerPreMargin); - timerPostMargin = getInteger(map, "timer_post_end_buffer", - timerPostMargin); - timerDefaultPriority = getInteger(map, "timer_default_priority", - timerDefaultPriority); - timerDefaultLifetime = getInteger(map, "timer_default_lifetime", - timerDefaultLifetime); - - streamPort = getInteger(map, "streamingport", streamPort); - streamingPassword = get(map, "key_streaming_password", - streamingPassword); - streamingUsername = get(map, "key_streaming_username", - streamingUsername); - encoding = get(map, "key_vdr_encoding", encoding); - streamFormat = get(map, "livetv_streamformat", streamFormat); - remuxCommand = get(map, "remux_command", remuxCommand); - remuxParameter = get(map, "remux_parameter", remuxParameter); - enableRemux = getBoolean(map, "remux_enable", enableRemux); - - enableRecStreaming = getBoolean(map, "key_rec_stream_enable", - enableRecStreaming); - livePort = getInteger(map, "key_live_port", livePort); - recStreamMethod = get(map, "key_recstream_method", recStreamMethod); - - } - - public void init(Map<String, Object> map) { - name = get(map, "vdr_name", name); + init(map); +/* + name = get(map, "vdr_name"); host = get(map, "vdr_host"); port = getInteger(map, "vdr_port"); password = get(map, "vdr_password"); @@ -641,19 +600,20 @@ public class Vdr { channelFilter = get(map, "last_channel"); wakeupEnabled = getBoolean(map, "key_wakeup_enabled"); - wakeupUrl = get(map, "key_wakeup_url", "0.0.0.0"); - wakeupUser = get(map, "key_wakeup_user", ""); - wakeupPassword = get(map, "key_wakeup_password", ""); - wakeupMethod = get(map, "key_wakeup_method", "wol"); - wolCustomBroadcast = get(map, "key_wol_custom_broadcast", ""); - mac = get(map, "key_wakeup_wol_mac", ""); + wakeupUrl = get(map, "key_wakeup_url"); + wakeupUser = get(map, "key_wakeup_user"); + wakeupPassword = get(map, "key_wakeup_password"); + wakeupMethod = get(map, "key_wakeup_method"); + wolCustomBroadcast = get(map, "key_wol_custom_broadcast"); + mac = get(map, "key_wakeup_wol_mac"); connectionTimeout = getInteger(map, "key_conntimeout_key"); readTimeout = getInteger(map, "key_vdr_readtimeout"); timeout = getInteger(map, "key_vdr_timeout"); - timerPreMargin = getInteger(map, "timer_pre_start_buffer", 5); - timerPostMargin = getInteger(map, "timer_post_end_buffer", 30); + timerPreMargin = getInteger(map, "timer_pre_start_buffer" + ); + timerPostMargin = getInteger(map, "timer_post_end_buffer"); timerDefaultPriority = getInteger(map, "timer_default_priority"); timerDefaultLifetime = getInteger(map, "timer_default_lifetime"); @@ -669,8 +629,49 @@ public class Vdr { enableRecStreaming = getBoolean(map, "key_rec_stream_enable"); livePort = getInteger(map, "key_live_port"); recStreamMethod = get(map, "key_recstream_method"); - serverTimeZone = get(map, "key_imezone", TimeZone.getDefault()); + */ + } + public void init(Map<String, Object> map) { + name = get(map, "vdr_name", "VDR"); + host = get(map, "vdr_host", "0.0.0.0"); + port = getInteger(map, "vdr_port", 6420); + password = get(map, "vdr_password", ""); + secure = getBoolean(map, "vdr_secure"); + + filterChannels = getBoolean(map, "limit_channels", true); + channelFilter = get(map, "last_channel", ""); + + wakeupEnabled = getBoolean(map, "key_wakeup_enabled", false); + wakeupUrl = get(map, "key_wakeup_url", ""); + wakeupUser = get(map, "key_wakeup_user", ""); + wakeupPassword = get(map, "key_wakeup_password", ""); + wakeupMethod = get(map, "key_wakeup_method", "wol"); + wolCustomBroadcast = get(map, "key_wol_custom_broadcast", ""); + mac = get(map, "key_wakeup_wol_mac", ""); + + connectionTimeout = getInteger(map, "key_conntimeout_key", 10); + readTimeout = getInteger(map, "key_vdr_readtimeout", 10); + timeout = getInteger(map, "key_vdr_timeout", 60); + + timerPreMargin = getInteger(map, "timer_pre_start_buffer", 5); + timerPostMargin = getInteger(map, "timer_post_end_buffer", 30); + timerDefaultPriority = getInteger(map, "timer_default_priority", 50); + timerDefaultLifetime = getInteger(map, "timer_default_lifetime",99); + + streamPort = getInteger(map, "streamingport", 3000); + streamingPassword = get(map, "key_streaming_password", ""); + streamingUsername = get(map, "key_streaming_username", ""); + encoding = get(map, "key_vdr_encoding", "utf-8"); + streamFormat = get(map, "livetv_streamformat", "TS"); + remuxCommand = get(map, "remux_command", "EXT"); + remuxParameter = get(map, "remux_parameter", ""); + enableRemux = getBoolean(map, "remux_enable"); + + enableRecStreaming = getBoolean(map, "key_rec_stream_enable"); + livePort = getInteger(map, "key_live_port", 8008); + recStreamMethod = get(map, "key_recstream_method", "vdr-live"); + serverTimeZone = get(map, "key_imezone", TimeZone.getDefault().getID()); } } diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/data/VdrSharedPreferences.java b/vdrmanager/src/de/bjusystems/vdrmanager/data/VdrSharedPreferences.java index 8839fa0..bb0ad77 100644 --- a/vdrmanager/src/de/bjusystems/vdrmanager/data/VdrSharedPreferences.java +++ b/vdrmanager/src/de/bjusystems/vdrmanager/data/VdrSharedPreferences.java @@ -12,6 +12,7 @@ import android.content.SharedPreferences; import com.j256.ormlite.dao.Dao.CreateOrUpdateStatus; import com.j256.ormlite.dao.RuntimeExceptionDao; +@Deprecated public class VdrSharedPreferences implements SharedPreferences { private static final String EMPTY_STRING = ""; diff --git a/vdrmanager/src/de/bjusystems/vdrmanager/gui/VdrPreferencesActivity.java b/vdrmanager/src/de/bjusystems/vdrmanager/gui/VdrPreferencesActivity.java index 35798d2..6f9d47d 100644 --- a/vdrmanager/src/de/bjusystems/vdrmanager/gui/VdrPreferencesActivity.java +++ b/vdrmanager/src/de/bjusystems/vdrmanager/gui/VdrPreferencesActivity.java @@ -25,12 +25,12 @@ import android.preference.Preference; import android.preference.Preference.OnPreferenceClickListener; import android.view.View; import de.bjusystems.vdrmanager.R; +import de.bjusystems.vdrmanager.VdrSharedPreferencesImpl; import de.bjusystems.vdrmanager.ZonePicker; import de.bjusystems.vdrmanager.app.Intents; import de.bjusystems.vdrmanager.data.FetchEditTextPreference; import de.bjusystems.vdrmanager.data.Preferences; import de.bjusystems.vdrmanager.data.Vdr; -import de.bjusystems.vdrmanager.data.VdrSharedPreferences; import de.bjusystems.vdrmanager.data.db.DBAccess; import de.bjusystems.vdrmanager.tasks.VoidAsyncTask; @@ -41,7 +41,7 @@ public class VdrPreferencesActivity extends BasePreferencesActivity implements Vdr vdr; - VdrSharedPreferences pref; + VdrSharedPreferencesImpl pref; int id = -1; @@ -68,11 +68,16 @@ public class VdrPreferencesActivity extends BasePreferencesActivity implements super.updateSummary(ep); } + + private boolean isNew = false; + + private boolean hasChanged = false; + private void initVDRInstance() { id = getIntent().getIntExtra(Intents.VDR_ID, -1); if (id == -1) {// new vdr vdr = new Vdr(); - + isNew = true; } else {// edit Vdr v = DBAccess.get(this).getVdrDAO().queryForId(id); if (v != null) { @@ -80,9 +85,10 @@ public class VdrPreferencesActivity extends BasePreferencesActivity implements } else { vdr = new Vdr(); id = -1; + isNew = true; } } - pref.setInstance(vdr); + pref = new VdrSharedPreferencesImpl(vdr, DBAccess.get(this).getVdrDAO()); } public static String ARP_CACHE = "/proc/net/arp"; @@ -149,10 +155,6 @@ public class VdrPreferencesActivity extends BasePreferencesActivity implements super.onCreate(savedInstanceState); - pref = new VdrSharedPreferences(); - - pref.dao = DBAccess.get(this).getVdrDAO(); - initVDRInstance(); this.addPreferencesFromResource(R.xml.vdr_prefs); @@ -317,6 +319,7 @@ public class VdrPreferencesActivity extends BasePreferencesActivity implements } public void onSharedPreferenceChanged(SharedPreferences arg0, String key) { + hasChanged = true; updateChildPreferences(); Preference p = findPreference(key); updateSummary(p); @@ -437,8 +440,9 @@ public class VdrPreferencesActivity extends BasePreferencesActivity implements finish(); return; } - if (pref.commits < 2) {// user has not changed anything - DBAccess.get(this).getVdrDAO().delete(pref.getInstance()); + if(isNew == true && hasChanged == false) { + //if (pref.commits < 2) {// user has not changed anything + DBAccess.get(this).getVdrDAO().delete(pref.getVdr()); finish(); return; } diff --git a/vdrmanager/src/org/fueri/reeldroid/network/DeviceManager.java b/vdrmanager/src/org/fueri/reeldroid/network/DeviceManager.java index 59e9e3a..427ff35 100644 --- a/vdrmanager/src/org/fueri/reeldroid/network/DeviceManager.java +++ b/vdrmanager/src/org/fueri/reeldroid/network/DeviceManager.java @@ -61,10 +61,12 @@ public class DeviceManager { WifiManager wifiManager = (WifiManager) context .getSystemService(Context.WIFI_SERVICE); - boolean wifiStatus = (conMgr - .getNetworkInfo(ConnectivityManager.TYPE_WIFI)).isConnected(); + boolean netStatus = conMgr + .getNetworkInfo(ConnectivityManager.TYPE_WIFI).isConnected() + || conMgr.getNetworkInfo(ConnectivityManager.TYPE_ETHERNET) + .isConnected(); - if (wifiStatus == false) { + if (netStatus == false) { return list; } |