X-Git-Url: https://git.zerfleddert.de/cgi-bin/gitweb.cgi/ms2-fixes/blobdiff_plain/40697a4790da441c869afbad82d994be85be6f9d..f2b5155d2d9182c8f84d481ca73702b0b6d9c3d9:/MS2Debounce/src/de/rmdir/ms2debounce/DebounceModuleHelper.java diff --git a/MS2Debounce/src/de/rmdir/ms2debounce/DebounceModuleHelper.java b/MS2Debounce/src/de/rmdir/ms2debounce/DebounceModuleHelper.java index 7a9f3de..56698dc 100644 --- a/MS2Debounce/src/de/rmdir/ms2debounce/DebounceModuleHelper.java +++ b/MS2Debounce/src/de/rmdir/ms2debounce/DebounceModuleHelper.java @@ -3,45 +3,416 @@ package de.rmdir.ms2debounce; import java.io.InputStream; import java.io.OutputStream; import java.io.File; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.DataOutputStream; import android.content.Context; +import android.content.SharedPreferences; +import android.util.Log; public class DebounceModuleHelper { private Context ctx; + public static final String PREFS_NAME = "DebounceCfg"; + final int SUPERUSER_REQUEST = 4223; + + private static final String TAG = "DebounceModuleHelper"; public DebounceModuleHelper(Context context) { ctx = context; } - public void loadModule() { - loadModule(10); + public void setAllValues() { + setDelay(getSavedDelay()); + setSettle(getSavedSettle()); + setPoll(getSavedPoll()); + setHwDebounce(getSavedHwDebounce()); + setHwDebounceTime(getSavedHwDebounceTime()); + //setDriveInactive(getSavedDriveInactive()); + setActiveHigh(getSavedActiveHigh()); } - public void loadModule(int delay) { - File debounce_ko = new File(ctx.getFilesDir() + "/debounce.ko"); + public boolean loadModule() throws NotRootedException,ShellException { + if (!_loadModule()) + return false; + + setAllValues(); + + return true; + } - extractModule(); + protected void runAsRoot(String command) throws NotRootedException,ShellException { + Process rootcmd; - // FIXME: Read settings from database... + Log.i(TAG, "Running as root: " + command); + try { + rootcmd = Runtime.getRuntime().exec(new String[]{"su","-c","sh"}); + } catch (java.io.IOException e) { + Log.e(TAG, "Got IOException: " + e.getMessage() + " (" + e.getCause() + ")"); + throw new NotRootedException(); + } + + try { + DataOutputStream sh = new DataOutputStream(rootcmd.getOutputStream()); + sh.writeBytes(command + "\n"); + sh.writeBytes("exit\n"); + sh.flush(); + sh.close(); + } catch (java.io.IOException e) { + Log.e(TAG, "Got IOException: " + e.getMessage() + " (" + e.getCause() + ")"); + throw new ShellException(); + } try { - Process insmod = Runtime.getRuntime().exec(new String[]{"su","-c","/system/bin/insmod " + debounce_ko + " debounce_delay=" + delay}); - insmod.waitFor(); + int r = rootcmd.waitFor(); + + if (r != 0) { + Log.e(TAG, "Process returned: " + r); + throw new ShellException(); + } + } catch (java.lang.InterruptedException e) { + Log.e(TAG, "Got InterruptedException: " + e.getMessage() + " (" + e.getCause() + ")"); + throw new ShellException(); + } + + Log.i(TAG, "Process executed successfully"); + } + + public synchronized boolean _loadModule() throws NotRootedException,ShellException { + Log.i(TAG, "Loading module"); + + if (isLoaded()) { + Log.i(TAG, "Module already loaded"); + return true; + } + + File insmod = new File("/system/bin/insmod"); + if (!insmod.exists()) { + insmod = new File("/system/xbin/insmod"); + if (!insmod.exists()) { + Log.e(TAG, "insmod not found"); + return false; + } + } + + File debounce_ko = new File("/system/lib/modules/debounce.ko"); + if (!debounce_ko.exists()) { + debounce_ko = new File(ctx.getFilesDir() + "/debounce.ko"); + + extractModule(); + } + + SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); + SharedPreferences.Editor editor = settings.edit(); + if (is_safe_to_load()) { + editor.putBoolean("safe_to_load", false); + editor.commit(); + } + + runAsRoot(insmod + " " + debounce_ko); + + int cnt = 10; + while ((!isLoaded()) && (cnt > 0)) { + try { + Thread.sleep(100); + } catch (Exception e) { + Log.e(TAG, "Got Exception: " + e.getMessage() + " (" + e.getCause() + ")"); + return false; + } + cnt--; + } + + if (!isLoaded()) { + Log.e(TAG, "Module doesn't appear to be correctly loaded"); + return false; + } + + if (getDelay() < 0) { + return false; + } + + /* Module was obviously loaded, so it is safe to load on boot */ + editor.putBoolean("safe_to_load", true); + editor.commit(); + + Log.i(TAG, "Module loaded successfully"); + return true; + } + + public synchronized void unloadModule() throws NotRootedException,ShellException { + Log.i(TAG, "Unloading module"); + + if (!isLoaded()) { + Log.i(TAG, "Module not loaded"); + return; + } + + File rmmod = new File("/system/bin/rmmod"); + + if (!rmmod.exists()) { + rmmod = new File("/system/xbin/rmmod"); + if (!rmmod.exists()) { + Log.e(TAG, "rmmod not found"); + return; + } + } + + runAsRoot(rmmod + " debounce"); + } + + public synchronized boolean isLoaded() { + boolean loaded = false; + + try { + String read; + + FileReader modules = new FileReader("/proc/modules"); + BufferedReader modules_buf = new BufferedReader(modules); + + while((read = modules_buf.readLine()) != null) { + if (read.regionMatches(0, "debounce", 0, 8)) { + File sysdir = new File("/sys/devices/debounce"); + if (sysdir.exists() && sysdir.isDirectory()) { + loaded = true; + break; + } + } + } + } catch (Exception e) { + loaded = false; + } + + return loaded; + } + + private synchronized int getValue(String parameter) { + int value = -1; + + try { + String read; + + FileReader fr = new FileReader("/sys/devices/debounce/" + parameter); + BufferedReader fbuf = new BufferedReader(fr); + + read = fbuf.readLine(); + if (read != null) { + value = Integer.parseInt(read.trim()); + } + + fbuf.close(); } catch (Exception e) {} + + return value; } - public void unloadModule() { + private synchronized void setValue(String parameter, int value) { + if (!isLoaded()) { + return; + } + try { - Process rmmod = Runtime.getRuntime().exec(new String[]{"su","-c","/system/bin/rmmod debounce"}); - rmmod.waitFor(); + FileWriter fw = new FileWriter("/sys/devices/debounce/" + parameter); + BufferedWriter fbuf = new BufferedWriter(fw); + + fbuf.write((new Integer(value)).toString()); + + fbuf.close(); } catch (Exception e) {} } - public boolean isLoaded() { + public synchronized int getDelay() { + return getValue("debounce_delay"); + } + + public synchronized void setDelay(int debounce_delay) { + setValue("debounce_delay", debounce_delay); + } + + public synchronized int getSettle() { + return getValue("settle_time"); + } + + public synchronized void setSettle(int settle_time) { + setValue("settle_time", settle_time); + } + + public synchronized int getPoll() { + return getValue("poll_time"); + } + + public synchronized void setPoll(int poll_time) { + setValue("poll_time", poll_time); + } + + public synchronized boolean getHwDebounce() { + if (getValue("hw_debounce") == 1) + return true; + return false; } + public synchronized void setHwDebounce(boolean enable) { + if (enable) + setValue("hw_debounce", 1); + else + setValue("hw_debounce", 0); + } + + public synchronized int getHwDebounceTime() { + return getValue("hw_debounce_time"); + } + + public synchronized void setHwDebounceTime(int time) { + setValue("hw_debounce_time", time); + } + + public synchronized boolean getDriveInactive() { + if (getValue("drive_inactive_flag") == 1) + return true; + + return false; + } + + public synchronized void setDriveInactive(boolean enable) { + if (enable) + setValue("drive_inactive_flag", 1); + else + setValue("drive_inactive_flag", 0); + } + + public synchronized boolean getActiveHigh() { + if (getValue("active_high_flag") == 1) + return true; + + return false; + } + + public synchronized void setActiveHigh(boolean enable) { + if (enable) + setValue("active_high_flag", 1); + else + setValue("active_high_flag", 0); + } + + public synchronized int getSavedDelay() { + SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); + + return settings.getInt("debounce_delay", 15); + } + + public synchronized void setSavedDelay(int delay) { + SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); + SharedPreferences.Editor editor = settings.edit(); + + editor.putInt("debounce_delay", delay); + editor.commit(); + } + + public synchronized int getSavedSettle() { + SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); + + return settings.getInt("settle_time", 40); + } + + public synchronized void setSavedSettle(int settle) { + SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); + SharedPreferences.Editor editor = settings.edit(); + + editor.putInt("settle_time", settle); + editor.commit(); + } + + public synchronized int getSavedPoll() { + SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); + + return settings.getInt("poll_time", 20); + } + + public synchronized void setSavedPoll(int poll) { + SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); + SharedPreferences.Editor editor = settings.edit(); + + editor.putInt("poll_time", poll); + editor.commit(); + } + + public synchronized boolean getSavedHwDebounce() { + SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); + + return settings.getBoolean("hw_debounce", false); + } + + public synchronized void setSavedHwDebounce(boolean enable) { + SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); + SharedPreferences.Editor editor = settings.edit(); + + editor.putBoolean("hw_debounce", enable); + editor.commit(); + } + + public synchronized int getSavedHwDebounceTime() { + SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); + + return settings.getInt("hw_debounce_time", 1); + } + + public synchronized void setSavedHwDebounceTime(int time) { + SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); + SharedPreferences.Editor editor = settings.edit(); + + editor.putInt("hw_debounce_time", time); + editor.commit(); + } + + public synchronized boolean getSavedDriveInactive() { + SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); + + return settings.getBoolean("drive_inactive", false); + } + + public synchronized void setSavedDriveInactive(boolean enable) { + SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); + SharedPreferences.Editor editor = settings.edit(); + + editor.putBoolean("drive_inactive", enable); + editor.commit(); + } + + public synchronized boolean getSavedActiveHigh() { + SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); + + return settings.getBoolean("active_high", false); + } + + public synchronized void setSavedActiveHigh(boolean enable) { + SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); + SharedPreferences.Editor editor = settings.edit(); + + editor.putBoolean("active_high", enable); + editor.commit(); + } + + public synchronized boolean is_safe_to_load() { + SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); + return settings.getBoolean("safe_to_load", false); + } + + public synchronized boolean get_on_boot() { + SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); + return settings.getBoolean("on_boot", false); + } + + public synchronized void set_on_boot(boolean on_boot) { + SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); + SharedPreferences.Editor editor = settings.edit(); + + editor.putBoolean("on_boot", on_boot); + editor.commit(); + } + private synchronized void extractModule() { File debounce_ko = new File(ctx.getFilesDir() + "/debounce.ko");