cvs.zerfleddert.de Git - ms2-fixes/blob - MS2Debounce/src/de/rmdir/ms2debounce/DebounceModuleHelper.java

   1 package de.rmdir.ms2debounce;
   2
   3 import java.io.InputStream;
   4 import java.io.OutputStream;
   5 import java.io.File;
   6 import java.io.FileReader;
   7 import java.io.FileWriter;
   8 import java.io.BufferedReader;
   9 import java.io.BufferedWriter;
  10 import java.io.DataOutputStream;
  11
  12 import android.content.Context;
  13 import android.content.SharedPreferences;
  14
  15 public class DebounceModuleHelper
  16 {
  17         private Context ctx;
  18         public static final String PREFS_NAME = "DebounceCfg";
  19         final int SUPERUSER_REQUEST = 4223;
  20
  21         public DebounceModuleHelper(Context context) {
  22                 ctx = context;
  23         }
  24
  25         public void setAllValues() {
  26                 setDelay(getSavedDelay());
  27                 setSettle(getSavedSettle());
  28                 setPoll(getSavedPoll());
  29                 setHwDebounce(getSavedHwDebounce());
  30                 setHwDebounceTime(getSavedHwDebounceTime());
  31                 //setDriveInactive(getSavedDriveInactive());
  32                 setActiveHigh(getSavedActiveHigh());
  33         }
  34
  35         public boolean loadModule() throws NotRootedException,ShellException {
  36                 if (!_loadModule())
  37                         return false;
  38
  39                 setAllValues();
  40
  41                 return true;
  42         }
  43
  44         protected void runAsRoot(String command) throws NotRootedException,ShellException {
  45                 Process rootcmd;
  46
  47                 try {
  48                         rootcmd = Runtime.getRuntime().exec(new String[]{"su","-c","sh"});
  49                 } catch (java.io.IOException e) {
  50                         throw new NotRootedException();
  51                 }
  52
  53                 try {
  54                         DataOutputStream sh = new DataOutputStream(rootcmd.getOutputStream());
  55                         sh.writeBytes(command + "\n");
  56                         sh.writeBytes("exit\n");
  57                         sh.flush();
  58                         sh.close();
  59                 } catch (java.io.IOException e) {
  60                         throw new ShellException();
  61                 }
  62
  63                 try {
  64                         if (rootcmd.waitFor() != 0)
  65                                 throw new ShellException();
  66                 } catch (java.lang.InterruptedException e) {
  67                         throw new ShellException();
  68                 }
  69         }
  70
  71         public synchronized boolean _loadModule() throws NotRootedException,ShellException {
  72                 File insmod = new File("/system/bin/insmod");
  73                 if (!insmod.exists()) {
  74                         insmod = new File("/system/xbin/insmod");
  75                         if (!insmod.exists()) {
  76                                 return false;
  77                         }
  78                 }
  79
  80                 File debounce_ko = new File("/system/lib/modules/debounce.ko");
  81                 if (!debounce_ko.exists()) {
  82                         debounce_ko = new File(ctx.getFilesDir() + "/debounce.ko");
  83
  84                         extractModule();
  85                 }
  86
  87                 SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
  88                 SharedPreferences.Editor editor = settings.edit();
  89                 if (is_safe_to_load()) {
  90                         editor.putBoolean("safe_to_load", false);
  91                         editor.commit();
  92                 }
  93
  94                 runAsRoot(insmod + " " + debounce_ko);
  95
  96                 int cnt = 10;
  97                 while ((!isLoaded()) && (cnt > 0)) {
  98                         try {
  99                                 Thread.sleep(100);
 100                         } catch (Exception e) {
 101                                 return false;
 102                         }
 103                         cnt--;
 104                 }
 105
 106                 if (!isLoaded()) {
 107                         return false;
 108                 }
 109
 110                 if (getDelay() < 0) {
 111                         return false;
 112                 }
 113
 114                 /* Module was obviously loaded, so it is safe to load on boot */
 115                 editor.putBoolean("safe_to_load", true);
 116                 editor.commit();
 117
 118                 return true;
 119         }
 120
 121         public synchronized void unloadModule() throws NotRootedException,ShellException {
 122                 File rmmod = new File("/system/bin/rmmod");
 123
 124                 if (!rmmod.exists()) {
 125                         rmmod = new File("/system/xbin/rmmod");
 126                         if (!rmmod.exists()) {
 127                                 return;
 128                         }
 129                 }
 130
 131                 runAsRoot(rmmod + " debounce");
 132         }
 133
 134         public synchronized boolean isLoaded() {
 135                 boolean loaded = false;
 136
 137                 try {
 138                         String read;
 139
 140                         FileReader modules = new FileReader("/proc/modules");
 141                         BufferedReader modules_buf = new BufferedReader(modules);
 142
 143                         while((read = modules_buf.readLine()) != null) {
 144                                 if (read.regionMatches(0, "debounce", 0, 8)) {
 145                                         File sysdir = new File("/sys/devices/debounce");
 146                                         if (sysdir.exists() && sysdir.isDirectory()) {
 147                                                 loaded = true;
 148                                                 break;
 149                                         }
 150                                 }
 151                         }
 152                 } catch (Exception e) {
 153                         loaded = false;
 154                 }
 155
 156                 return loaded;
 157         }
 158
 159         private synchronized int getValue(String parameter) {
 160                 int value = -1;
 161
 162                 try {
 163                         String read;
 164
 165                         FileReader fr = new FileReader("/sys/devices/debounce/" + parameter);
 166                         BufferedReader fbuf = new BufferedReader(fr);
 167
 168                         read = fbuf.readLine();
 169                         if (read != null) {
 170                                 value = Integer.parseInt(read.trim());
 171                         }
 172
 173                         fbuf.close();
 174                 } catch (Exception e) {}
 175
 176                 return value;
 177         }
 178
 179         private synchronized void setValue(String parameter, int value) {
 180                 if (!isLoaded()) {
 181                         return;
 182                 }
 183
 184                 try {
 185                         FileWriter fw = new FileWriter("/sys/devices/debounce/" + parameter);
 186                         BufferedWriter fbuf = new BufferedWriter(fw);
 187
 188                         fbuf.write((new Integer(value)).toString());
 189
 190                         fbuf.close();
 191                 } catch (Exception e) {}
 192         }
 193
 194         public synchronized int getDelay() {
 195                 return getValue("debounce_delay");
 196         }
 197
 198         public synchronized void setDelay(int debounce_delay) {
 199                 setValue("debounce_delay", debounce_delay);
 200         }
 201
 202         public synchronized int getSettle() {
 203                 return getValue("settle_time");
 204         }
 205
 206         public synchronized void setSettle(int settle_time) {
 207                 setValue("settle_time", settle_time);
 208         }
 209
 210         public synchronized int getPoll() {
 211                 return getValue("poll_time");
 212         }
 213
 214         public synchronized void setPoll(int poll_time) {
 215                 setValue("poll_time", poll_time);
 216         }
 217
 218         public synchronized boolean getHwDebounce() {
 219                 if (getValue("hw_debounce") == 1)
 220                         return true;
 221
 222                 return false;
 223         }
 224
 225         public synchronized void setHwDebounce(boolean enable) {
 226                 if (enable)
 227                         setValue("hw_debounce", 1);
 228                 else
 229                         setValue("hw_debounce", 0);
 230         }
 231
 232         public synchronized int getHwDebounceTime() {
 233                 return getValue("hw_debounce_time");
 234         }
 235
 236         public synchronized void setHwDebounceTime(int time) {
 237                 setValue("hw_debounce_time", time);
 238         }
 239
 240         public synchronized boolean getDriveInactive() {
 241                 if (getValue("drive_inactive_flag") == 1)
 242                         return true;
 243
 244                 return false;
 245         }
 246
 247         public synchronized void setDriveInactive(boolean enable) {
 248                 if (enable)
 249                         setValue("drive_inactive_flag", 1);
 250                 else
 251                         setValue("drive_inactive_flag", 0);
 252         }
 253
 254         public synchronized boolean getActiveHigh() {
 255                 if (getValue("active_high_flag") == 1)
 256                         return true;
 257
 258                 return false;
 259         }
 260
 261         public synchronized void setActiveHigh(boolean enable) {
 262                 if (enable)
 263                         setValue("active_high_flag", 1);
 264                 else
 265                         setValue("active_high_flag", 0);
 266         }
 267
 268         public synchronized int getSavedDelay() {
 269                 SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
 270
 271                 return settings.getInt("debounce_delay", 15);
 272         }
 273
 274         public synchronized void setSavedDelay(int delay) {
 275                 SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
 276                 SharedPreferences.Editor editor = settings.edit();
 277
 278                 editor.putInt("debounce_delay", delay);
 279                 editor.commit();
 280         }
 281
 282         public synchronized int getSavedSettle() {
 283                 SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
 284
 285                 return settings.getInt("settle_time", 40);
 286         }
 287
 288         public synchronized void setSavedSettle(int settle) {
 289                 SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
 290                 SharedPreferences.Editor editor = settings.edit();
 291
 292                 editor.putInt("settle_time", settle);
 293                 editor.commit();
 294         }
 295
 296         public synchronized int getSavedPoll() {
 297                 SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
 298
 299                 return settings.getInt("poll_time", 20);
 300         }
 301
 302         public synchronized void setSavedPoll(int poll) {
 303                 SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
 304                 SharedPreferences.Editor editor = settings.edit();
 305
 306                 editor.putInt("poll_time", poll);
 307                 editor.commit();
 308         }
 309
 310         public synchronized boolean getSavedHwDebounce() {
 311                 SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
 312
 313                 return settings.getBoolean("hw_debounce", false);
 314         }
 315
 316         public synchronized void setSavedHwDebounce(boolean enable) {
 317                 SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
 318                 SharedPreferences.Editor editor = settings.edit();
 319
 320                 editor.putBoolean("hw_debounce", enable);
 321                 editor.commit();
 322         }
 323
 324         public synchronized int getSavedHwDebounceTime() {
 325                 SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
 326
 327                 return settings.getInt("hw_debounce_time", 1);
 328         }
 329
 330         public synchronized void setSavedHwDebounceTime(int time) {
 331                 SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
 332                 SharedPreferences.Editor editor = settings.edit();
 333
 334                 editor.putInt("hw_debounce_time", time);
 335                 editor.commit();
 336         }
 337
 338         public synchronized boolean getSavedDriveInactive() {
 339                 SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
 340
 341                 return settings.getBoolean("drive_inactive", false);
 342         }
 343
 344         public synchronized void setSavedDriveInactive(boolean enable) {
 345                 SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
 346                 SharedPreferences.Editor editor = settings.edit();
 347
 348                 editor.putBoolean("drive_inactive", enable);
 349                 editor.commit();
 350         }
 351
 352         public synchronized boolean getSavedActiveHigh() {
 353                 SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
 354
 355                 return settings.getBoolean("active_high", false);
 356         }
 357
 358         public synchronized void setSavedActiveHigh(boolean enable) {
 359                 SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
 360                 SharedPreferences.Editor editor = settings.edit();
 361
 362                 editor.putBoolean("active_high", enable);
 363                 editor.commit();
 364         }
 365
 366         public synchronized boolean is_safe_to_load() {
 367                 SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
 368                 return settings.getBoolean("safe_to_load", false);
 369         }
 370
 371         public synchronized boolean get_on_boot() {
 372                 SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
 373                 return settings.getBoolean("on_boot", false);
 374         }
 375
 376         public synchronized void set_on_boot(boolean on_boot) {
 377                 SharedPreferences settings = ctx.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
 378                 SharedPreferences.Editor editor = settings.edit();
 379
 380                 editor.putBoolean("on_boot", on_boot);
 381                 editor.commit();
 382         }
 383
 384         private synchronized void extractModule() {
 385                 File debounce_ko = new File(ctx.getFilesDir() + "/debounce.ko");
 386
 387                 if (debounce_ko.exists()) {
 388                         return;
 389                 }
 390
 391                 try {
 392                         InputStream apk = ctx.getAssets().open("debounce.ko");
 393                         OutputStream mod = ctx.openFileOutput("debounce.ko.tmp", 0);
 394
 395                         //I assume a page is 4k...
 396                         byte buf[] = new byte[4096];
 397                         int bytes;
 398
 399                         while((bytes = apk.read(buf)) != -1) {
 400                                 mod.write(buf, 0, bytes);
 401                         }
 402
 403                         apk.close();
 404                         mod.close();
 405
 406                         File tmpfile = new File(debounce_ko + ".tmp");
 407                         tmpfile.renameTo(debounce_ko);
 408                 } catch (Exception e) {}
 409         }
 410 }