migrate code

.gitignore

+/build
+*.iml
+.gradle
+/local.properties
+/.idea/workspace.xml
+/.idea/libraries
+.DS_Store
+/build
+/captures
+.externalNativeBuild
+
+# kdiff3 ignore
+*.orig
+
+# maven ignore
+target/
+
+# eclipse ignore
+.settings/
+.project
+.classpath
+
+# idea ignore
+.idea/
+*.ipr
+*.iml
+*.iws
+
+# temp ignore
+*.log
+*.cache
+*.diff
+*.patch
+*.tmp
+
+# system ignore
+.DS_Store
+Thumbs.db
+

build.gradle

+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion 28
+    buildToolsVersion "28.0.3"
+
+
+    defaultConfig {
+        applicationId "com.virjar.ratel.api.xposed"
+        minSdkVersion 21
+        targetSdkVersion 28
+        versionCode 1
+        versionName "1.0"
+    }
+
+    signingConfigs {
+        release {
+            storeFile rootProject.file('script/hermes_key')
+            storePassword "hermes"
+            keyAlias "hermes"
+            keyPassword "hermes"
+        }
+    }
+
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+            signingConfig signingConfigs.release
+        }
+    }
+
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+
+    implementation 'com.android.support:appcompat-v7:28.0.0'
+    compileOnly project(':base-lib-ratel-api')
+    compileOnly 'com.rover12421.AndroidHideApi:android:1.24'
+}

gradle.properties

+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# org.gradle.jvmargs=-Xmx1536m
+org.gradle.jvmargs=-Xmx1536m -DsocksProxyHost=proxy.corp.qunar.com -DsocksProxyPort=10080
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true

gradle/wrapper/gradle-wrapper.properties

+#Fri Oct 05 17:01:22 CST 2018
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.4.1-all.zip

gradlew

+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

gradlew.bat

+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

proguard-rules.pro

+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

src/main/AndroidManifest.xml

+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    package="com.virjar.ratel.api.xposed">
+
+    <application
+        android:allowBackup="true"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:roundIcon="@mipmap/ic_launcher_round"
+        android:supportsRtl="true"
+        android:theme="@style/AppTheme"
+        tools:ignore="GoogleAppIndexingWarning" />
+</manifest>

src/main/java/android/app/AndroidAppHelper.java

+package android.app;
+
+import android.content.SharedPreferences;
+import android.content.pm.ApplicationInfo;
+import android.content.res.CompatibilityInfo;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.os.Build;
+import android.os.IBinder;
+import android.view.Display;
+
+import java.lang.ref.WeakReference;
+import java.util.Map;
+
+import de.robv.android.xposed.XSharedPreferences;
+import de.robv.android.xposed.XposedBridge;
+
+import static de.robv.android.xposed.XposedHelpers.findClass;
+import static de.robv.android.xposed.XposedHelpers.findFieldIfExists;
+import static de.robv.android.xposed.XposedHelpers.findMethodExactIfExists;
+import static de.robv.android.xposed.XposedHelpers.getObjectField;
+import static de.robv.android.xposed.XposedHelpers.newInstance;
+import static de.robv.android.xposed.XposedHelpers.setFloatField;
+
+/**
+ * Contains various methods for information about the current app.
+ *
+ * <p>For historical reasons, this class is in the {@code android.app} package. It can't be moved
+ * without breaking compatibility with existing modules.
+ */
+public final class AndroidAppHelper {
+    private AndroidAppHelper() {}
+
+    private static final Class<?> CLASS_RESOURCES_KEY;
+    private static final boolean HAS_IS_THEMEABLE;
+    private static final boolean HAS_THEME_CONFIG_PARAMETER;
+
+    static {
+        CLASS_RESOURCES_KEY = (Build.VERSION.SDK_INT < 19) ?
+                findClass("android.app.ActivityThread$ResourcesKey", null)
+                : findClass("android.content.res.ResourcesKey", null);
+
+        HAS_IS_THEMEABLE = findFieldIfExists(CLASS_RESOURCES_KEY, "mIsThemeable") != null;
+        HAS_THEME_CONFIG_PARAMETER = HAS_IS_THEMEABLE && Build.VERSION.SDK_INT >= 21
+                && findMethodExactIfExists("android.app.ResourcesManager", null, "getThemeConfig") != null;
+    }
+
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    private static Map<Object, WeakReference> getResourcesMap(ActivityThread activityThread) {
+        if (Build.VERSION.SDK_INT >= 24) {
+            Object resourcesManager = getObjectField(activityThread, "mResourcesManager");
+            return (Map) getObjectField(resourcesManager, "mResourceImpls");
+        } else if (Build.VERSION.SDK_INT >= 19) {
+            Object resourcesManager = getObjectField(activityThread, "mResourcesManager");
+            return (Map) getObjectField(resourcesManager, "mActiveResources");
+        } else {
+            return (Map) getObjectField(activityThread, "mActiveResources");
+        }
+    }
+
+    /* For SDK 15 & 16 */
+    private static Object createResourcesKey(String resDir, float scale) {
+        try {
+            if (HAS_IS_THEMEABLE)
+                return newInstance(CLASS_RESOURCES_KEY, resDir, scale, false);
+            else
+                return newInstance(CLASS_RESOURCES_KEY, resDir, scale);
+        } catch (Throwable t) {
+            XposedBridge.log(t);
+            return null;
+        }
+    }
+
+    /* For SDK 17 & 18 & 23 */
+    private static Object createResourcesKey(String resDir, int displayId, Configuration overrideConfiguration, float scale) {
+        try {
+            if (HAS_THEME_CONFIG_PARAMETER)
+                return newInstance(CLASS_RESOURCES_KEY, resDir, displayId, overrideConfiguration, scale, false, null);
+            else if (HAS_IS_THEMEABLE)
+                return newInstance(CLASS_RESOURCES_KEY, resDir, displayId, overrideConfiguration, scale, false);
+            else
+                return newInstance(CLASS_RESOURCES_KEY, resDir, displayId, overrideConfiguration, scale);
+        } catch (Throwable t) {
+            XposedBridge.log(t);
+            return null;
+        }
+    }
+
+    /* For SDK 19 - 22 */
+    private static Object createResourcesKey(String resDir, int displayId, Configuration overrideConfiguration, float scale, IBinder token) {
+        try {
+            if (HAS_THEME_CONFIG_PARAMETER)
+                return newInstance(CLASS_RESOURCES_KEY, resDir, displayId, overrideConfiguration, scale, false, null, token);
+            else if (HAS_IS_THEMEABLE)
+                return newInstance(CLASS_RESOURCES_KEY, resDir, displayId, overrideConfiguration, scale, false, token);
+            else
+                return newInstance(CLASS_RESOURCES_KEY, resDir, displayId, overrideConfiguration, scale, token);
+        } catch (Throwable t) {
+            XposedBridge.log(t);
+            return null;
+        }
+    }
+
+    /* For SDK 24+ */
+    private static Object createResourcesKey(String resDir, String[] splitResDirs, String[] overlayDirs, String[] libDirs, int displayId, Configuration overrideConfiguration, CompatibilityInfo compatInfo) {
+        try {
+            return newInstance(CLASS_RESOURCES_KEY, resDir, splitResDirs, overlayDirs, libDirs, displayId, overrideConfiguration, compatInfo);
+        } catch (Throwable t) {
+            XposedBridge.log(t);
+            return null;
+        }
+    }
+
+    /** @hide */
+    public static void addActiveResource(String resDir, float scale, boolean isThemeable, Resources resources) {
+        addActiveResource(resDir, resources);
+    }
+
+    /** @hide */
+    public static void addActiveResource(String resDir, Resources resources) {
+        ActivityThread thread = ActivityThread.currentActivityThread();
+        if (thread == null) {
+            return;
+        }
+
+        Object resourcesKey;
+        if (Build.VERSION.SDK_INT >= 24) {
+            CompatibilityInfo compatInfo = (CompatibilityInfo) newInstance(CompatibilityInfo.class);
+            setFloatField(compatInfo, "applicationScale", resources.hashCode());
+            resourcesKey = createResourcesKey(resDir, null, null, null, Display.DEFAULT_DISPLAY, null, compatInfo);
+        } else if (Build.VERSION.SDK_INT == 23) {
+            resourcesKey = createResourcesKey(resDir, Display.DEFAULT_DISPLAY, null, resources.hashCode());
+        } else if (Build.VERSION.SDK_INT >= 19) {
+            resourcesKey = createResourcesKey(resDir, Display.DEFAULT_DISPLAY, null, resources.hashCode(), null);
+        } else if (Build.VERSION.SDK_INT >= 17) {
+            resourcesKey = createResourcesKey(resDir, Display.DEFAULT_DISPLAY, null, resources.hashCode());
+        } else {
+            resourcesKey = createResourcesKey(resDir, resources.hashCode());
+        }
+
+        if (resourcesKey != null) {
+            if (Build.VERSION.SDK_INT >= 24) {
+                Object resImpl = getObjectField(resources, "mResourcesImpl");
+                getResourcesMap(thread).put(resourcesKey, new WeakReference<>(resImpl));
+            } else {
+                getResourcesMap(thread).put(resourcesKey, new WeakReference<>(resources));
+            }
+        }
+    }
+
+    /**
+     * Returns the name of the current process. It's usually the same as the main package name.
+     */
+    public static String currentProcessName() {
+        String processName = ActivityThread.currentPackageName();
+        if (processName == null)
+            return "android";
+        return processName;
+    }
+
+    /**
+     * Returns information about the main application in the current process.
+     *
+     * <p>In a few cases, multiple apps might run in the same process, e.g. the SystemUI and the
+     * Keyguard which both have {@code android:process="com.android.systemui"} set in their
+     * manifest. In those cases, the first application that was initialized will be returned.
+     */
+    public static ApplicationInfo currentApplicationInfo() {
+        ActivityThread am = ActivityThread.currentActivityThread();
+        if (am == null)
+            return null;
+
+        Object boundApplication = getObjectField(am, "mBoundApplication");
+        if (boundApplication == null)
+            return null;
+
+        return (ApplicationInfo) getObjectField(boundApplication, "appInfo");
+    }
+
+    /**
+     * Returns the Android package name of the main application in the current process.
+     *
+     * <p>In a few cases, multiple apps might run in the same process, e.g. the SystemUI and the
+     * Keyguard which both have {@code android:process="com.android.systemui"} set in their
+     * manifest. In those cases, the first application that was initialized will be returned.
+     */
+    public static String currentPackageName() {
+        ApplicationInfo ai = currentApplicationInfo();
+        return (ai != null) ? ai.packageName : "android";
+    }
+
+    /**
+     * Returns the main {@link android.app.Application} object in the current process.
+     *
+     * <p>In a few cases, multiple apps might run in the same process, e.g. the SystemUI and the
+     * Keyguard which both have {@code android:process="com.android.systemui"} set in their
+     * manifest. In those cases, the first application that was initialized will be returned.
+     */
+    public static Application currentApplication() {
+        return ActivityThread.currentApplication();
+    }
+
+    /** @deprecated Use {@link XSharedPreferences} instead. */
+    @SuppressWarnings("UnusedParameters")
+    @Deprecated
+    public static SharedPreferences getSharedPreferencesForPackage(String packageName, String prefFileName, int mode) {
+        return new XSharedPreferences(packageName, prefFileName);
+    }
+
+    /** @deprecated Use {@link XSharedPreferences} instead. */
+    @Deprecated
+    public static SharedPreferences getDefaultSharedPreferencesForPackage(String packageName) {
+        return new XSharedPreferences(packageName);
+    }
+
+    /** @deprecated Use {@link XSharedPreferences#reload} instead. */
+    @Deprecated
+    public static void reloadSharedPreferencesIfNeeded(SharedPreferences pref) {
+        if (pref instanceof XSharedPreferences) {
+            ((XSharedPreferences) pref).reload();
+        }
+    }
+}
\ No newline at end of file

src/main/java/de/robv/android/xposed/DexCreator.java

+package de.robv.android.xposed;
+
+import android.os.Environment;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.security.DigestException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.zip.Adler32;
+
+import static de.robv.android.xposed.XposedHelpers.inputStreamToByteArray;
+
+/**
+ * Helper class which can create a very simple .dex file, containing only a class definition
+ * with a super class (no methods, fields, ...).
+ */
+/*package*/public class DexCreator {
+	public static File DALVIK_CACHE = new File(Environment.getDataDirectory(), "dalvik-cache");
+
+	/** Returns the default dex file name for the class. */
+	public static File getDefaultFile(String childClz) {
+		return new File(DALVIK_CACHE, "xposed_" + childClz.substring(childClz.lastIndexOf('.') + 1) + ".dex");
+	}
+
+	/**
+	 * Creates (or returns) the path to a dex file which defines the superclass of {@clz} as extending
+	 * {@code realSuperClz}, which by itself must extend {@code topClz}.
+	 */
+	public static File ensure(String clz, Class<?> realSuperClz, Class<?> topClz) throws IOException {
+		if (!topClz.isAssignableFrom(realSuperClz)) {
+			throw new ClassCastException("Cannot initialize " + clz + " because " + realSuperClz + " does not extend " + topClz);
+		}
+
+		try {
+			return ensure("xposed.dummy." + clz + "SuperClass", realSuperClz);
+		} catch (IOException e) {
+			throw new IOException("Failed to create a superclass for " + clz, e);
+		}
+	}
+
+	/** Like {@link #ensure(File, String, String)}, just for the default dex file name. */
+	public static File ensure(String childClz, Class<?> superClz) throws IOException {
+		return ensure(getDefaultFile(childClz), childClz, superClz.getName());
+	}
+
+	/**
+	 * Makes sure that the given file is a simple dex file containing the given classes.
+	 * Creates the file if that's not the case.
+	 */
+	public static File ensure(File file, String childClz, String superClz) throws IOException {
+		// First check if a valid file exists.
+		try {
+			byte[] dex = inputStreamToByteArray(new FileInputStream(file));
+			if (matches(dex, childClz, superClz)) {
+				return file;
+			} else {
+				file.delete();
+			}
+		} catch (IOException e) {
+			file.delete();
+		}
+
+		// If not, create a new dex file.
+		byte[] dex = create(childClz, superClz);
+		FileOutputStream fos = new FileOutputStream(file);
+		fos.write(dex);
+		fos.close();
+		return file;
+	}
+
+	/**
+	 * Checks whether the Dex file fits to the class names.
+	 * Assumes that the file has been created with this class.
+	 */
+	public static boolean matches(byte[] dex, String childClz, String superClz) throws IOException {
+		boolean childFirst = childClz.compareTo(superClz) < 0;
+		byte[] childBytes = stringToBytes("L" + childClz.replace('.', '/') + ";");
+		byte[] superBytes = stringToBytes("L" + superClz.replace('.', '/') + ";");
+
+		int pos = 0xa0;
+		if (pos + childBytes.length + superBytes.length >= dex.length) {
+			return false;
+		}
+
+		for (byte b : childFirst ? childBytes : superBytes) {
+			if (dex[pos++] != b) {
+				return false;
+			}
+		}
+
+		for (byte b : childFirst ? superBytes: childBytes) {
+			if (dex[pos++] != b) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/** Creates the byte array for the dex file. */
+	public static byte[] create(String childClz, String superClz) throws IOException {
+		boolean childFirst = childClz.compareTo(superClz) < 0;
+		byte[] childBytes = stringToBytes("L" + childClz.replace('.', '/') + ";");
+		byte[] superBytes = stringToBytes("L" + superClz.replace('.', '/') + ";");
+		int stringsSize = childBytes.length + superBytes.length;
+		int padding = -stringsSize & 3;
+		stringsSize += padding;
+
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+		// header
+		out.write("dex\n035\0".getBytes()); // magic
+		out.write(new byte[24]);            // placeholder for checksum and signature
+		writeInt(out, 0xfc + stringsSize);  // file size
+		writeInt(out, 0x70);                // header size
+		writeInt(out, 0x12345678);          // endian constant
+		writeInt(out, 0);                   // link size
+		writeInt(out, 0);                   // link offset
+		writeInt(out, 0xa4 + stringsSize);  // map offset
+		writeInt(out, 2);                   // strings count
+		writeInt(out, 0x70);                // strings offset
+		writeInt(out, 2);                   // types count
+		writeInt(out, 0x78);                // types offset
+		writeInt(out, 0);                   // prototypes count
+		writeInt(out, 0);                   // prototypes offset
+		writeInt(out, 0);                   // fields count
+		writeInt(out, 0);                   // fields offset
+		writeInt(out, 0);                   // methods count
+		writeInt(out, 0);                   // methods offset
+		writeInt(out, 1);                   // classes count
+		writeInt(out, 0x80);                // classes offset
+		writeInt(out, 0x5c + stringsSize);  // data size
+		writeInt(out, 0xa0);                // data offset
+
+		// string map
+		writeInt(out, 0xa0);
+		writeInt(out, 0xa0 + (childFirst ? childBytes.length : superBytes.length));
+
+		// types
+		writeInt(out, 0); // first type = first string
+		writeInt(out, 1); // second type = second string
+
+		// class definitions
+		writeInt(out, childFirst ? 0 : 1); // class to define = child type
+		writeInt(out, 1);                  // access flags = public
+		writeInt(out, childFirst ? 1 : 0); // super class = super type
+		writeInt(out, 0);                  // no interface
+		writeInt(out, -1);                 // no source file
+		writeInt(out, 0);                  // no annotations
+		writeInt(out, 0);                  // no class data
+		writeInt(out, 0);                  // no static values
+
+		// string data
+		out.write(childFirst ? childBytes : superBytes);
+		out.write(childFirst ? superBytes : childBytes);
+		out.write(new byte[padding]);
+
+		// annotations
+		writeInt(out, 0); // no items
+
+		// map
+		writeInt(out, 7);                                 // items count
+		writeMapItem(out, 0, 1, 0);                       // header
+		writeMapItem(out, 1, 2, 0x70);                    // strings
+		writeMapItem(out, 2, 2, 0x78);                    // types
+		writeMapItem(out, 6, 1, 0x80);                    // classes
+		writeMapItem(out, 0x2002, 2, 0xa0);               // string data
+		writeMapItem(out, 0x1003, 1, 0xa0 + stringsSize); // annotations
+		writeMapItem(out, 0x1000, 1, 0xa4 + stringsSize); // map list
+
+		byte[] buf = out.toByteArray();
+		updateSignature(buf);
+		updateChecksum(buf);
+		return buf;
+	}
+
+	private static void updateSignature(byte[] dex) {
+		// Update SHA-1 signature
+		try {
+			MessageDigest md = MessageDigest.getInstance("SHA-1");
+			md.update(dex, 32, dex.length - 32);
+			md.digest(dex, 12, 20);
+		} catch (NoSuchAlgorithmException | DigestException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	private static void updateChecksum(byte[] dex) {
+		// Update Adler32 checksum
+		Adler32 a32 = new Adler32();
+		a32.update(dex, 12, dex.length - 12);
+		int chksum = (int) a32.getValue();
+		dex[8] = (byte) (chksum & 0xff);
+		dex[9] = (byte) (chksum >> 8 & 0xff);
+		dex[10] = (byte) (chksum >> 16 & 0xff);
+		dex[11] = (byte) (chksum >> 24 & 0xff);
+	}
+
+	private static void writeUleb128(OutputStream out, int value) throws IOException {
+		while (value > 0x7f) {
+			out.write((value & 0x7f) | 0x80);
+			value >>>= 7;
+		}
+		out.write(value);
+	}
+
+	private static void writeInt(OutputStream out, int value) throws IOException {
+		out.write(value);
+		out.write(value >> 8);
+		out.write(value >> 16);
+		out.write(value >> 24);
+	}
+
+	private static void writeMapItem(OutputStream out, int type, int count, int offset) throws IOException {
+		writeInt(out, type);
+		writeInt(out, count);
+		writeInt(out, offset);
+	}
+
+	private static byte[] stringToBytes(String s) throws IOException {
+		ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+		writeUleb128(bytes, s.length());
+		// This isn't MUTF-8, but should be OK.
+		bytes.write(s.getBytes("UTF-8"));
+		bytes.write(0);
+		return bytes.toByteArray();
+	}
+
+	private DexCreator() {}
+}

src/main/java/de/robv/android/xposed/IXposedHookCmdInit.java

+package de.robv.android.xposed;
+
+
+/**
+ * Hook the initialization of Java-based command-line tools (like pm).
+ *
+ * @hide Xposed no longer hooks command-line tools, therefore this interface shouldn't be
+ * implemented anymore.
+ */
+public interface IXposedHookCmdInit extends IXposedMod {
+	/**
+	 * Called very early during startup of a command-line tool.
+	 * @param startupParam Details about the module itself and the started process.
+	 * @throws Throwable Everything is caught, but it will prevent further initialization of the module.
+	 */
+	void initCmdApp(StartupParam startupParam) throws Throwable;
+
+	/** Data holder for {@link #initCmdApp}. */
+	final class StartupParam {
+		/*package*/ StartupParam() {}
+
+		/** The path to the module's APK. */
+		public String modulePath;
+
+		/** The class name of the tools that the hook was invoked for. */
+		public String startClassName;
+	}
+}

src/main/java/de/robv/android/xposed/IXposedHookInitPackageResources.java

+package de.robv.android.xposed;
+
+import com.virjar.ratel.api.xposed.IRXposedHookInitPackageResources;
+
+import de.robv.android.xposed.callbacks.XC_InitPackageResources;
+import de.robv.android.xposed.callbacks.XC_InitPackageResources.InitPackageResourcesParam;
+
+/**
+ * Get notified when the resources for an app are initialized.
+ * In {@link #handleInitPackageResources}, resource replacements can be created.
+ * <p>
+ * <p>This interface should be implemented by the module's main class. Xposed will take care of
+ * registering it as a callback automatically.
+ */
+public interface IXposedHookInitPackageResources extends IXposedMod, IRXposedHookInitPackageResources {
+    /**
+     * This method is called when resources for an app are being initialized.
+     * Modules can call special methods of the  class in order to replace resources.
+     *
+     * @param resparam Information about the resources.
+     * @throws Throwable Everything the callback throws is caught and logged.
+     */
+    void handleInitPackageResources(InitPackageResourcesParam resparam) throws Throwable;
+
+    /**
+     * @hide
+     */
+    final class Wrapper extends XC_InitPackageResources {
+        private final IXposedHookInitPackageResources instance;
+
+        public Wrapper(IXposedHookInitPackageResources instance) {
+            this.instance = instance;
+        }
+
+        @Override
+        public void handleInitPackageResources(InitPackageResourcesParam resparam) throws Throwable {
+            instance.handleInitPackageResources(resparam);
+        }
+    }
+}

src/main/java/de/robv/android/xposed/IXposedHookLoadPackage.java

+package de.robv.android.xposed;
+
+import android.app.Application;
+
+import com.virjar.ratel.api.xposed.IRXposedHookLoadPackage;
+
+import de.robv.android.xposed.callbacks.XC_LoadPackage;
+import de.robv.android.xposed.callbacks.XC_LoadPackage.LoadPackageParam;
+
+/**
+ * Get notified when an app ("Android package") is loaded.
+ * This is especially useful to hook some app-specific methods.
+ *
+ * <p>This interface should be implemented by the module's main class. Xposed will take care of
+ * registering it as a callback automatically.
+ */
+public interface IXposedHookLoadPackage extends IXposedMod, IRXposedHookLoadPackage {
+    /**
+     * This method is called when an app is loaded. It's called very early, even before
+     * {@link Application#onCreate} is called.
+     * Modules can set up their app-specific hooks here.
+     *
+     * @param lpparam Information about the app.
+     * @throws Throwable Everything the callback throws is caught and logged.
+     */
+    void handleLoadPackage(LoadPackageParam lpparam) throws Throwable;
+
+    /**
+     * @hide
+     */
+    final class Wrapper extends XC_LoadPackage {
+        private final IXposedHookLoadPackage instance;
+
+        public Wrapper(IXposedHookLoadPackage instance) {
+            this.instance = instance;
+        }
+
+        @Override
+        public void handleLoadPackage(LoadPackageParam lpparam) throws Throwable {
+            instance.handleLoadPackage(lpparam);
+        }
+    }
+}

src/main/java/de/robv/android/xposed/IXposedHookZygoteInit.java

+package de.robv.android.xposed;
+
+import com.virjar.ratel.api.xposed.IRXposedHookZygoteInit;
+
+/**
+ * Hook the initialization of Zygote process(es), from which all the apps are forked.
+ *
+ * <p>Implement this interface in your module's main class in order to be notified when Android is
+ * starting up. In {@link IXposedHookZygoteInit}, you can modify objects and place hooks that should
+ * be applied for every app. Only the Android framework/system classes are available at that point
+ * in time. Use {@code null} as class loader for {@link XposedHelpers#findAndHookMethod(String, ClassLoader, String, Object...)}
+ * and its variants.
+ *
+ * <p>If you want to hook one/multiple specific apps, use {@link IXposedHookLoadPackage} instead.
+ */
+public interface IXposedHookZygoteInit extends IXposedMod, IRXposedHookZygoteInit {
+    /**
+     * Data holder for {@link #initZygote}.
+     */
+    class StartupParam extends IRXposedHookZygoteInit.StartupParam {
+        public StartupParam() {
+        }
+    }
+
+}

src/main/java/de/robv/android/xposed/IXposedMod.java

+package de.robv.android.xposed;
+
+import com.virjar.ratel.api.xposed.IRXposedMod;
+
+/**
+ * Marker interface for Xposed modules. Cannot be implemented directly.
+ */
+/* package */ public interface IXposedMod extends IRXposedMod {
+}

src/main/java/de/robv/android/xposed/XC2RC_MethodHook.java

+package de.robv.android.xposed;
+
+import com.virjar.ratel.api.rposed.RC_MethodHook;
+
+public class XC2RC_MethodHook extends RC_MethodHook {
+    private XC_MethodHook delegate;
+
+    XC2RC_MethodHook(XC_MethodHook delegate) {
+        super(delegate.priority);
+        this.delegate = delegate;
+    }
+
+
+    @Override
+    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
+        super.beforeHookedMethod(param);
+        XC_MethodHook.MethodHookParam methodHookParam = new XC_MethodHook.MethodHookParam();
+        methodHookParam.method = param.method;
+        methodHookParam.thisObject = param.thisObject;
+        methodHookParam.args = param.args;
+        XposedHelpers.setObjectField(methodHookParam, "result", param.getResult());
+        XposedHelpers.setObjectField(methodHookParam, "throwable", param.getThrowable());
+        XposedHelpers.setBooleanField(methodHookParam, "returnEarly",
+                XposedHelpers.getBooleanField(param, "returnEarly"));
+        delegate.callBeforeHookedMethod(methodHookParam);
+        param.args = methodHookParam.args;
+        XposedHelpers.setObjectField(param, "result", methodHookParam.getResult());
+        XposedHelpers.setObjectField(param, "throwable", methodHookParam.getThrowable());
+        XposedHelpers.setBooleanField(param, "returnEarly", XposedHelpers.getBooleanField(methodHookParam, "returnEarly"));
+
+    }
+
+    @Override
+    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
+        super.afterHookedMethod(param);
+        XC_MethodHook.MethodHookParam methodHookParam = new XC_MethodHook.MethodHookParam();
+        methodHookParam.method = param.method;
+        methodHookParam.thisObject = param.thisObject;
+        methodHookParam.args = param.args;
+        XposedHelpers.setObjectField(methodHookParam, "result", param.getResult());
+        XposedHelpers.setObjectField(methodHookParam, "throwable", param.getThrowable());
+        XposedHelpers.setBooleanField(methodHookParam, "returnEarly",
+                XposedHelpers.getBooleanField(param, "returnEarly"));
+        delegate.callAfterHookedMethod(methodHookParam);
+        param.args = methodHookParam.args;
+        XposedHelpers.setObjectField(param, "result", methodHookParam.getResult());
+        XposedHelpers.setObjectField(param, "throwable", methodHookParam.getThrowable());
+        XposedHelpers.setBooleanField(param, "returnEarly", XposedHelpers.getBooleanField(methodHookParam, "returnEarly"));
+
+    }
+
+    @Override
+    public String toString() {
+        return "XC2RC_MethodHook{" +
+                "delegate=" + delegate +
+                '}';
+    }
+}

src/main/java/de/robv/android/xposed/XC_MethodHook.java

+package de.robv.android.xposed;
+
+import java.lang.reflect.Member;
+
+import de.robv.android.xposed.callbacks.IXUnhook;
+import de.robv.android.xposed.callbacks.XCallback;
+
+/**
+ * Callback class for method hooks.
+ * <p>
+ * <p>Usually, anonymous subclasses of this class are created which override
+ * {@link #beforeHookedMethod} and/or {@link #afterHookedMethod}.
+ */
+public abstract class XC_MethodHook extends XCallback {
+    /**
+     * Creates a new callback with default priority.
+     */
+    @SuppressWarnings("deprecation")
+    public XC_MethodHook() {
+        super();
+    }
+
+    /**
+     * Creates a new callback with a specific priority.
+     * <p>
+     * <p class="note">Note that {@link #afterHookedMethod} will be called in reversed order, i.e.
+     * the callback with the highest priority will be called last. This way, the callback has the
+     * final control over the return value. {@link #beforeHookedMethod} is called as usual, i.e.
+     * highest priority first.
+     *
+     * @param priority See {@link XCallback#priority}.
+     */
+    public XC_MethodHook(int priority) {
+        super(priority);
+    }
+
+    /**
+     * Called before the invocation of the method.
+     * <p>
+     * <p>You can use {@link MethodHookParam#setResult} and {@link MethodHookParam#setThrowable}
+     * to prevent the original method from being called.
+     * <p>
+     * <p>Note that implementations shouldn't call {@code super(param)}, it's not necessary.
+     *
+     * @param param Information about the method call.
+     * @throws Throwable Everything the callback throws is caught and logged.
+     */
+    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
+    }
+
+    public void callBeforeHookedMethod(MethodHookParam param) throws Throwable {
+        beforeHookedMethod(param);
+    }
+
+    /**
+     * Called after the invocation of the method.
+     * <p>
+     * <p>You can use {@link MethodHookParam#setResult} and {@link MethodHookParam#setThrowable}
+     * to modify the return value of the original method.
+     * <p>
+     * <p>Note that implementations shouldn't call {@code super(param)}, it's not necessary.
+     *
+     * @param param Information about the method call.
+     * @throws Throwable Everything the callback throws is caught and logged.
+     */
+    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
+    }
+
+    public void callAfterHookedMethod(MethodHookParam param) throws Throwable {
+        afterHookedMethod(param);
+    }
+    /**
+     * Wraps information about the method call and allows to influence it.
+     */
+    public static class MethodHookParam extends XCallback.Param {
+        /**
+         * @hide
+         */
+        @SuppressWarnings("deprecation")
+        public MethodHookParam() {
+            super();
+        }
+
+        /**
+         * The hooked method/constructor.
+         */
+        public Member method;
+
+        /**
+         * The {@code this} reference for an instance method, or {@code null} for static methods.
+         */
+        public Object thisObject;
+
+        /**
+         * Arguments to the method call.
+         */
+        public Object[] args;
+
+        private Object result = null;
+        private Throwable throwable = null;
+        public boolean returnEarly = false;
+
+        /**
+         * Returns the result of the method call.
+         */
+        public Object getResult() {
+            return result;
+        }
+
+        /**
+         * Modify the result of the method call.
+         * <p>
+         * <p>If called from {@link #beforeHookedMethod}, it prevents the call to the original method.
+         */
+        public void setResult(Object result) {
+            this.result = result;
+            this.throwable = null;
+            this.returnEarly = true;
+        }
+
+        /**
+         * Returns the {@link Throwable} thrown by the method, or {@code null}.
+         */
+        public Throwable getThrowable() {
+            return throwable;
+        }
+
+        /**
+         * Returns true if an exception was thrown by the method.
+         */
+        public boolean hasThrowable() {
+            return throwable != null;
+        }
+
+        /**
+         * Modify the exception thrown of the method call.
+         * <p>
+         * <p>If called from {@link #beforeHookedMethod}, it prevents the call to the original method.
+         */
+        public void setThrowable(Throwable throwable) {
+            this.throwable = throwable;
+            this.result = null;
+            this.returnEarly = true;
+        }
+
+        /**
+         * Returns the result of the method call, or throws the Throwable caused by it.
+         */
+        public Object getResultOrThrowable() throws Throwable {
+            if (throwable != null)
+                throw throwable;
+            return result;
+        }
+    }
+
+    /**
+     * An object with which the method/constructor can be unhooked.
+     */
+    public class Unhook implements IXUnhook<XC_MethodHook> {
+        private final Member hookMethod;
+
+        /*package*/
+        public Unhook(Member hookMethod) {
+            this.hookMethod = hookMethod;
+        }
+
+        /**
+         * Returns the method/constructor that has been hooked.
+         */
+        public Member getHookedMethod() {
+            return hookMethod;
+        }
+
+        @Override
+        public XC_MethodHook getCallback() {
+            return XC_MethodHook.this;
+        }
+
+        @SuppressWarnings("deprecation")
+        @Override
+        public void unhook() {
+            XposedBridge.unhookMethod(hookMethod, XC_MethodHook.this);
+        }
+
+    }
+}

src/main/java/de/robv/android/xposed/XC_MethodReplacement.java

+package de.robv.android.xposed;
+
+import de.robv.android.xposed.callbacks.XCallback;
+
+/**
+ * A special case of {@link XC_MethodHook} which completely replaces the original method.
+ */
+public abstract class XC_MethodReplacement extends XC_MethodHook {
+	/**
+	 * Creates a new callback with default priority.
+	 */
+	public XC_MethodReplacement() {
+		super();
+	}
+
+	/**
+	 * Creates a new callback with a specific priority.
+	 *
+	 * @param priority See {@link XCallback#priority}.
+	 */
+	public XC_MethodReplacement(int priority) {
+		super(priority);
+	}
+
+	/** @hide */
+	@Override
+	protected final void beforeHookedMethod(MethodHookParam param) throws Throwable {
+		try {
+			Object result = replaceHookedMethod(param);
+			param.setResult(result);
+		} catch (Throwable t) {
+			param.setThrowable(t);
+		}
+	}
+
+	/** @hide */
+	@Override
+	@SuppressWarnings("EmptyMethod")
+	protected final void afterHookedMethod(MethodHookParam param) throws Throwable {}
+
+	/**
+	 * Shortcut for replacing a method completely. Whatever is returned/thrown here is taken
+	 * instead of the result of the original method (which will not be called).
+	 *
+	 * <p>Note that implementations shouldn't call {@code super(param)}, it's not necessary.
+	 *
+	 * @param param Information about the method call.
+	 * @throws Throwable Anything that is thrown by the callback will be passed on to the original caller.
+	 */
+	@SuppressWarnings("UnusedParameters")
+	protected abstract Object replaceHookedMethod(MethodHookParam param) throws Throwable;
+
+	/**
+	 * Predefined callback that skips the method without replacements.
+	 */
+	public static final XC_MethodReplacement DO_NOTHING = new XC_MethodReplacement(PRIORITY_HIGHEST*2) {
+		@Override
+		protected Object replaceHookedMethod(MethodHookParam param) throws Throwable {
+			return null;
+		}
+	};
+
+	/**
+	 * Creates a callback which always returns a specific value.
+	 *
+	 * @param result The value that should be returned to callers of the hooked method.
+	 */
+	public static XC_MethodReplacement returnConstant(final Object result) {
+		return returnConstant(PRIORITY_DEFAULT, result);
+	}
+
+	/**
+	 * Like {@link #returnConstant(Object)}, but allows to specify a priority for the callback.
+	 *
+	 * @param priority See {@link XCallback#priority}.
+	 * @param result The value that should be returned to callers of the hooked method.
+	 */
+	public static XC_MethodReplacement returnConstant(int priority, final Object result) {
+		return new XC_MethodReplacement(priority) {
+			@Override
+			protected Object replaceHookedMethod(MethodHookParam param) throws Throwable {
+				return result;
+			}
+		};
+	}
+
+}

src/main/java/de/robv/android/xposed/XSharedPreferences.java

+package de.robv.android.xposed;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.Environment;
+import android.preference.PreferenceManager;
+
+import com.virjar.ratel.api.RatelToolKit;
+
+import java.io.File;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * 请注意，由于在Android较高版本上文件权限限制问题，XSharedPreferences可能无法使用。建议尽量避免使用XSharedPreferences，使用ContentProvider替代
+ */
+public class XSharedPreferences implements SharedPreferences {
+
+    private SharedPreferences sharedPreferences;
+    private File file;
+
+    /**
+     * Read settings from the specified file.
+     *
+     * @param prefFile The file to read the preferences from.
+     */
+    public XSharedPreferences(File prefFile) {
+        String fileName = "ratel_" + prefFile.getName() + "_preferences.xml";
+        sharedPreferences = RatelToolKit.sContext.getSharedPreferences(fileName, Context.MODE_PRIVATE);
+        file = new File(Environment.getDataDirectory(), "data/" + RatelToolKit.sContext.getPackageName() + "/shared_prefs/" + fileName);
+    }
+
+    /**
+     * Read settings from the default preferences for a package.
+     * These preferences are returned by {@link PreferenceManager#getDefaultSharedPreferences}.
+     *
+     * @param packageName The package name.
+     */
+    public XSharedPreferences(String packageName) {
+        this(packageName, packageName + "_preferences");
+    }
+
+    /**
+     * Read settings from a custom preferences file for a package.
+     * These preferences are returned by {@link Context#getSharedPreferences(String, int)}.
+     *
+     * @param packageName  The package name.
+     * @param prefFileName The file name without ".xml".
+     */
+    public XSharedPreferences(String packageName, String prefFileName) {
+        String fileName = "ratel_" + prefFileName + "_preferences.xml";
+        sharedPreferences = RatelToolKit.sContext.getSharedPreferences(fileName, Context.MODE_PRIVATE);
+        file = new File(Environment.getDataDirectory(), "data/" + RatelToolKit.sContext.getPackageName() + "/shared_prefs/" + fileName);
+    }
+
+    /**
+     * Tries to make the preferences file world-readable.
+     *
+     * <p><strong>Warning:</strong> This is only meant to work around permission "fix" functions that are part
+     * of some recoveries. It doesn't replace the need to open preferences with {@code MODE_WORLD_READABLE}
+     * in the module's UI code. Otherwise, Android will set stricter permissions again during the next save.
+     *
+     * <p>This will only work if executed as root (e.g. {@code initZygote()}) and only if SELinux is disabled.
+     *
+     * @return {@code true} in case the file could be made world-readable.
+     */
+    @SuppressLint("SetWorldReadable")
+    public boolean makeWorldReadable() {
+        return true;
+    }
+
+    /**
+     * Returns the file that is backing these preferences.
+     *
+     * <p><strong>Warning:</strong> The file might not be accessible directly.
+     */
+    public File getFile() {
+        return file;
+    }
+
+    /**
+     * Reload the settings from file if they have changed.
+     *
+     * <p><strong>Warning:</strong> With enforcing SELinux, this call might be quite expensive.
+     */
+    public synchronized void reload() {
+
+    }
+
+
+    @Override
+    public Map<String, ?> getAll() {
+        return sharedPreferences.getAll();
+    }
+
+    @Override
+    public String getString(String key, String defValue) {
+        return sharedPreferences.getString(key, defValue);
+    }
+
+    @Override
+    public Set<String> getStringSet(String key, Set<String> defValues) {
+        return sharedPreferences.getStringSet(key, defValues);
+    }
+
+    @Override
+    public int getInt(String key, int defValue) {
+        return sharedPreferences.getInt(key, defValue);
+    }
+
+    @Override
+    public long getLong(String key, long defValue) {
+        return sharedPreferences.getLong(key, defValue);
+    }
+
+    @Override
+    public float getFloat(String key, float defValue) {
+        return sharedPreferences.getFloat(key, defValue);
+    }
+
+    @Override
+    public boolean getBoolean(String key, boolean defValue) {
+        return sharedPreferences.getBoolean(key, defValue);
+    }
+
+    @Override
+    public boolean contains(String key) {
+        return sharedPreferences.contains(key);
+    }
+
+    @Override
+    public Editor edit() {
+        return sharedPreferences.edit();
+    }
+
+    @Override
+    public void registerOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener) {
+        sharedPreferences.registerOnSharedPreferenceChangeListener(listener);
+    }
+
+    @Override
+    public void unregisterOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener) {
+        sharedPreferences.unregisterOnSharedPreferenceChangeListener(listener);
+    }
+}

src/main/java/de/robv/android/xposed/callbacks/IXUnhook.java

+package de.robv.android.xposed.callbacks;
+
+import de.robv.android.xposed.IXposedHookZygoteInit;
+
+/**
+ * Interface for objects that can be used to remove callbacks.
+ *
+ * <p class="warning">Just like hooking methods etc., unhooking applies only to the current process.
+ * In other process (or when the app is removed from memory and then restarted), the hook will still
+ * be active. The Zygote process (see {@link IXposedHookZygoteInit}) is an exception, the hook won't
+ * be inherited by any future processes forked from it in the future.
+ *
+ * @param <T> The class of the callback.
+ */
+public interface IXUnhook<T> {
+	/**
+	 * Returns the callback that has been registered.
+	 */
+	T getCallback();
+
+	/**
+	 * Removes the callback.
+	 */
+	void unhook();
+}

src/main/java/de/robv/android/xposed/callbacks/XC_InitPackageResources.java

+package de.robv.android.xposed.callbacks;
+
+
+import de.robv.android.xposed.IXposedHookInitPackageResources;
+import de.robv.android.xposed.XposedBridge.CopyOnWriteSortedSet;
+
+/**
+ * This class is only used for internal purposes, except for the {@link InitPackageResourcesParam}
+ * subclass.
+ */
+public abstract class XC_InitPackageResources extends XCallback implements IXposedHookInitPackageResources {
+	/**
+	 * Creates a new callback with default priority.
+	 * @hide
+	 */
+	@SuppressWarnings("deprecation")
+	public XC_InitPackageResources() {
+		super();
+	}
+
+	/**
+	 * Creates a new callback with a specific priority.
+	 *
+	 * @param priority See {@link XCallback#priority}.
+	 * @hide
+	 */
+	public XC_InitPackageResources(int priority) {
+		super(priority);
+	}
+
+	/**
+	 * Wraps information about the resources being initialized.
+	 */
+	public static final class InitPackageResourcesParam extends XCallback.Param {
+		/** @hide */
+		public InitPackageResourcesParam(CopyOnWriteSortedSet<XC_InitPackageResources> callbacks) {
+			super(callbacks);
+		}
+
+		/** The name of the package for which resources are being loaded. */
+		public String packageName;
+
+	}
+
+	/** @hide */
+	@Override
+	protected void call(Param param) throws Throwable {
+		if (param instanceof InitPackageResourcesParam)
+			handleInitPackageResources((InitPackageResourcesParam) param);
+	}
+}

src/main/java/de/robv/android/xposed/callbacks/XC_LoadPackage.java

+package de.robv.android.xposed.callbacks;
+
+import android.content.pm.ApplicationInfo;
+
+import de.robv.android.xposed.IXposedHookLoadPackage;
+import de.robv.android.xposed.XposedBridge.CopyOnWriteSortedSet;
+
+/**
+ * This class is only used for internal purposes, except for the {@link LoadPackageParam}
+ * subclass.
+ */
+public abstract class XC_LoadPackage extends XCallback implements IXposedHookLoadPackage {
+	/**
+	 * Creates a new callback with default priority.
+	 * @hide
+	 */
+	@SuppressWarnings("deprecation")
+	public XC_LoadPackage() {
+		super();
+	}
+
+	/**
+	 * Creates a new callback with a specific priority.
+	 *
+	 * @param priority See {@link XCallback#priority}.
+	 * @hide
+	 */
+	public XC_LoadPackage(int priority) {
+		super(priority);
+	}
+
+	/**
+	 * Wraps information about the app being loaded.
+	 */
+	public static final class LoadPackageParam extends XCallback.Param {
+		/** @hide */
+		public LoadPackageParam(CopyOnWriteSortedSet<XC_LoadPackage> callbacks) {
+			super(callbacks);
+		}
+
+		/** The name of the package being loaded. */
+		public String packageName;
+
+		/** The process in which the package is executed. */
+		public String processName;
+
+		/** The ClassLoader used for this package. */
+		public ClassLoader classLoader;
+
+		/** More information about the application being loaded. */
+		public ApplicationInfo appInfo;
+
+		/** Set to {@code true} if this is the first (and main) application for this process. */
+		public boolean isFirstApplication;
+	}
+
+	/** @hide */
+	@Override
+	protected void call(Param param) throws Throwable {
+		if (param instanceof LoadPackageParam)
+			handleLoadPackage((LoadPackageParam) param);
+	}
+}

src/main/java/de/robv/android/xposed/callbacks/XCallback.java

+package de.robv.android.xposed.callbacks;
+
+import android.os.Bundle;
+
+import java.io.Serializable;
+
+import de.robv.android.xposed.XposedBridge;
+import de.robv.android.xposed.XposedBridge.CopyOnWriteSortedSet;
+
+/**
+ * Base class for Xposed callbacks.
+ *
+ * This class only keeps a priority for ordering multiple callbacks.
+ * The actual (abstract) callback methods are added by subclasses.
+ */
+public abstract class XCallback implements Comparable<XCallback> {
+	/**
+	 * Callback priority, higher number means earlier execution.
+	 *
+	 * <p>This is usually set to {@link #PRIORITY_DEFAULT}. However, in case a certain callback should
+	 * be executed earlier or later a value between {@link #PRIORITY_HIGHEST} and {@link #PRIORITY_LOWEST}
+	 * can be set instead. The values are just for orientation though, Xposed doesn't enforce any
+	 * boundaries on the priority values.
+	 */
+	public final int priority;
+
+	/** @deprecated This constructor can't be hidden for technical reasons. Nevertheless, don't use it! */
+	@Deprecated
+	public XCallback() {
+		this.priority = PRIORITY_DEFAULT;
+	}
+
+	/** @hide */
+	public XCallback(int priority) {
+		this.priority = priority;
+	}
+
+	/**
+	 * Base class for Xposed callback parameters.
+	 */
+	public static abstract class Param {
+		/** @hide */
+		public  Object[] callbacks;
+		public Bundle extra;
+
+		/** @deprecated This constructor can't be hidden for technical reasons. Nevertheless, don't use it! */
+		@Deprecated
+		protected Param() {
+			callbacks = null;
+		}
+
+		/** @hide */
+		protected Param(CopyOnWriteSortedSet<? extends XCallback> callbacks) {
+			this.callbacks = callbacks.getSnapshot();
+		}
+
+		/**
+		 * This can be used to store any data for the scope of the callback.
+		 *
+		 * <p>Use this instead of instance variables, as it has a clear reference to e.g. each
+		 * separate call to a method, even when the same method is called recursively.
+		 *
+		 * @see #setObjectExtra
+		 * @see #getObjectExtra
+		 */
+		public synchronized Bundle getExtra() {
+			if (extra == null)
+				extra = new Bundle();
+			return extra;
+		}
+
+		/**
+		 * Returns an object stored with {@link #setObjectExtra}.
+		 */
+		public Object getObjectExtra(String key) {
+			Serializable o = getExtra().getSerializable(key);
+			if (o instanceof SerializeWrapper)
+				return ((SerializeWrapper) o).object;
+			return null;
+		}
+
+		/**
+		 * Stores any object for the scope of the callback. For data types that support it, use
+		 * the {@link Bundle} returned by {@link #getExtra} instead.
+		 */
+		public void setObjectExtra(String key, Object o) {
+			getExtra().putSerializable(key, new SerializeWrapper(o));
+		}
+
+		private static class SerializeWrapper implements Serializable {
+			private static final long serialVersionUID = 1L;
+			private final Object object;
+			public SerializeWrapper(Object o) {
+				object = o;
+			}
+		}
+	}
+
+	/** @hide */
+	public static void callAll(Param param) {
+		if (param.callbacks == null)
+			throw new IllegalStateException("This object was not created for use with callAll");
+
+		for (int i = 0; i < param.callbacks.length; i++) {
+			try {
+				((XCallback) param.callbacks[i]).call(param);
+			} catch (Throwable t) { XposedBridge.log(t); }
+		}
+	}
+
+	/** @hide */
+	protected void call(Param param) throws Throwable {}
+
+	/** @hide */
+	@Override
+	public int compareTo(XCallback other) {
+		if (this == other)
+			return 0;
+
+		// order descending by priority
+		if (other.priority != this.priority)
+			return other.priority - this.priority;
+		// then randomly
+		else if (System.identityHashCode(this) < System.identityHashCode(other))
+			return -1;
+		else
+			return 1;
+	}
+
+	/** The default priority, see {@link #priority}. */
+	public static final int PRIORITY_DEFAULT = 50;
+
+	 /** Execute this callback late, see {@link #priority}. */
+	public static final int PRIORITY_LOWEST = -10000;
+
+	/** Execute this callback early, see {@link #priority}. */
+	public static final int PRIORITY_HIGHEST = 10000;
+}

src/main/java/de/robv/android/xposed/callbacks/package-info.java

+/**
+ * Contains the base classes for callbacks.
+ *
+ * <p>For historical reasons, {@link de.robv.android.xposed.XC_MethodHook} and
+ * {@link de.robv.android.xposed.XC_MethodReplacement} are directly in the
+ * {@code de.robv.android.xposed} package.
+ */
+package de.robv.android.xposed.callbacks;

src/main/java/de/robv/android/xposed/package-info.java

+/**
+ * Contains the main classes of the Xposed framework.
+ */
+package de.robv.android.xposed;

src/main/java/de/robv/android/xposed/services/BaseService.java

+package de.robv.android.xposed.services;
+
+import java.io.ByteArrayInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * General definition of a file access service provided by the Xposed framework.
+ *
+ * <p>References to a concrete subclass should generally be retrieved from {@link SELinuxHelper}.
+ */
+public abstract class BaseService {
+	/** Flag for {@link #checkFileAccess}: Read access. */
+	public static final int R_OK = 4;
+	/** Flag for {@link #checkFileAccess}: Write access. */
+	public static final int W_OK = 2;
+	/** Flag for {@link #checkFileAccess}: Executable access. */
+	public static final int X_OK = 1;
+	/** Flag for {@link #checkFileAccess}: File/directory exists. */
+	public static final int F_OK = 0;
+
+	/**
+	 * Checks whether the services accesses files directly (instead of using IPC).
+	 *
+	 * @return {@code true} in case direct access is possible.
+	 */
+	public boolean hasDirectFileAccess() {
+		return false;
+	}
+
+	/**
+	 * Check whether a file is accessible. SELinux might enforce stricter checks.
+	 *
+	 * @param filename The absolute path of the file to check.
+	 * @param mode The mode for POSIX's {@code access()} function.
+	 * @return The result of the {@code access()} function.
+	 */
+	public abstract boolean checkFileAccess(String filename, int mode);
+
+	/**
+	 * Check whether a file exists.
+	 *
+	 * @param filename The absolute path of the file to check.
+	 * @return The result of the {@code access()} function.
+	 */
+	@SuppressWarnings("BooleanMethodIsAlwaysInverted")
+	public boolean checkFileExists(String filename) {
+		return checkFileAccess(filename, F_OK);
+	}
+
+	/**
+	 * Determine the size and modification time of a file.
+	 *
+	 * @param filename The absolute path of the file to check.
+	 * @return A {@link FileResult} object holding the result.
+	 * @throws IOException In case an error occurred while retrieving the information.
+	 */
+	public abstract FileResult statFile(String filename) throws IOException;
+
+	/**
+	 * Determine the size time of a file.
+	 *
+	 * @param filename The absolute path of the file to check.
+	 * @return The file size.
+	 * @throws IOException In case an error occurred while retrieving the information.
+	 */
+	public long getFileSize(String filename) throws IOException {
+		return statFile(filename).size;
+	}
+
+	/**
+	 * Determine the size time of a file.
+	 *
+	 * @param filename The absolute path of the file to check.
+	 * @return The file modification time.
+	 * @throws IOException In case an error occurred while retrieving the information.
+	 */
+	public long getFileModificationTime(String filename) throws IOException {
+		return statFile(filename).mtime;
+	}
+
+	/**
+	 * Read a file into memory.
+	 *
+	 * @param filename The absolute path of the file to read.
+	 * @return A {@code byte} array with the file content.
+	 * @throws IOException In case an error occurred while reading the file.
+	 */
+	public abstract byte[] readFile(String filename) throws IOException;
+
+	/**
+	 * Read a file into memory, but only if it has changed since the last time.
+	 *
+	 * @param filename The absolute path of the file to read.
+	 * @param previousSize File size of last read.
+	 * @param previousTime File modification time of last read.
+	 * @return A {@link FileResult} object holding the result.
+	 *         <p>The {@link FileResult#content} field might be {@code null} if the file
+	 *         is unmodified ({@code previousSize} and {@code previousTime} are still valid).
+	 * @throws IOException In case an error occurred while reading the file.
+	 */
+	public abstract FileResult readFile(String filename, long previousSize, long previousTime) throws IOException;
+
+	/**
+	 * Read a file into memory, optionally only if it has changed since the last time.
+	 *
+	 * @param filename The absolute path of the file to read.
+	 * @param offset Number of bytes to skip at the beginning of the file.
+	 * @param length Number of bytes to read (0 means read to end of file).
+	 * @param previousSize Optional: File size of last read.
+	 * @param previousTime Optional: File modification time of last read.
+	 * @return A {@link FileResult} object holding the result.
+	 *         <p>The {@link FileResult#content} field might be {@code null} if the file
+	 *         is unmodified ({@code previousSize} and {@code previousTime} are still valid).
+	 * @throws IOException In case an error occurred while reading the file.
+	 */
+	public abstract FileResult readFile(String filename, int offset, int length,
+			long previousSize, long previousTime) throws IOException;
+
+	/**
+	 * Get a stream to the file content.
+	 * Depending on the service, it may or may not be read completely into memory.
+	 *
+	 * @param filename The absolute path of the file to read.
+	 * @return An {@link InputStream} to the file content.
+	 * @throws IOException In case an error occurred while reading the file.
+	 */
+	public InputStream getFileInputStream(String filename) throws IOException {
+		return new ByteArrayInputStream(readFile(filename));
+	}
+
+	/**
+	 * Get a stream to the file content, but only if it has changed since the last time.
+	 * Depending on the service, it may or may not be read completely into memory.
+	 *
+	 * @param filename The absolute path of the file to read.
+	 * @param previousSize Optional: File size of last read.
+	 * @param previousTime Optional: File modification time of last read.
+	 * @return A {@link FileResult} object holding the result.
+	 *         <p>The {@link FileResult#stream} field might be {@code null} if the file
+	 *         is unmodified ({@code previousSize} and {@code previousTime} are still valid).
+	 * @throws IOException In case an error occurred while reading the file.
+	 */
+	public FileResult getFileInputStream(String filename, long previousSize, long previousTime) throws IOException {
+		FileResult result = readFile(filename, previousSize, previousTime);
+		if (result.content == null)
+			return result;
+		return new FileResult(new ByteArrayInputStream(result.content), result.size, result.mtime);
+	}
+
+
+	// ----------------------------------------------------------------------------
+	/*package*/ BaseService() {}
+
+	/*package*/ static void ensureAbsolutePath(String filename) {
+		if (!filename.startsWith("/")) {
+			throw new IllegalArgumentException("Only absolute filenames are allowed: " + filename);
+		}
+	}
+
+	/*package*/ static void throwCommonIOException(int errno, String errorMsg, String filename, String defaultText) throws IOException {
+		switch (errno) {
+			case 1: // EPERM
+			case 13: // EACCES
+				throw new FileNotFoundException(errorMsg != null ? errorMsg : "Permission denied: " + filename);
+			case 2: // ENOENT
+				throw new FileNotFoundException(errorMsg != null ? errorMsg : "No such file or directory: " + filename);
+			case 12: // ENOMEM
+				throw new OutOfMemoryError(errorMsg);
+			case 21: // EISDIR
+				throw new FileNotFoundException(errorMsg != null ? errorMsg : "Is a directory: " + filename);
+			default:
+				throw new IOException(errorMsg != null ? errorMsg : "Error " + errno + defaultText + filename);
+		}
+	}
+}

src/main/java/de/robv/android/xposed/services/DirectAccessService.java

+package de.robv.android.xposed.services;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/** @hide */
+public final class DirectAccessService extends BaseService {
+	@Override
+	public boolean hasDirectFileAccess() {
+		return true;
+	}
+
+	@SuppressWarnings("RedundantIfStatement")
+	@Override
+	public boolean checkFileAccess(String filename, int mode) {
+		File file = new File(filename);
+		if (mode == F_OK && !file.exists()) return false;
+		if ((mode & R_OK) != 0 && !file.canRead()) return false;
+		if ((mode & W_OK) != 0 && !file.canWrite()) return false;
+		if ((mode & X_OK) != 0 && !file.canExecute()) return false;
+		return true;
+	}
+
+	@Override
+	public boolean checkFileExists(String filename) {
+		return new File(filename).exists();
+	}
+
+	@Override
+	public FileResult statFile(String filename) throws IOException {
+		File file = new File(filename);
+		return new FileResult(file.length(), file.lastModified());
+	}
+
+	@Override
+	public byte[] readFile(String filename) throws IOException {
+		File file = new File(filename);
+		byte content[] = new byte[(int)file.length()];
+		FileInputStream fis = new FileInputStream(file);
+		fis.read(content);
+		fis.close();
+		return content;
+	}
+
+	@Override
+	public FileResult readFile(String filename, long previousSize, long previousTime) throws IOException {
+		File file = new File(filename);
+		long size = file.length();
+		long time = file.lastModified();
+		if (previousSize == size && previousTime == time)
+			return new FileResult(size, time);
+		return new FileResult(readFile(filename), size, time);
+	}
+
+	@Override
+	public FileResult readFile(String filename, int offset, int length, long previousSize, long previousTime) throws IOException {
+		File file = new File(filename);
+		long size = file.length();
+		long time = file.lastModified();
+		if (previousSize == size && previousTime == time)
+			return new FileResult(size, time);
+
+		// Shortcut for the simple case
+		if (offset <= 0 && length <= 0)
+			return new FileResult(readFile(filename), size, time);
+
+		// Check range
+		if (offset > 0 && offset >= size) {
+			throw new IllegalArgumentException("Offset " + offset + " is out of range for " + filename);
+		} else if (offset < 0) {
+			offset = 0;
+		}
+
+		if (length > 0 && (offset + length) > size) {
+			throw new IllegalArgumentException("Length " + length + " is out of range for " + filename);
+		} else if (length <= 0) {
+			length = (int) (size - offset);
+		}
+
+		byte content[] = new byte[length];
+		FileInputStream fis = new FileInputStream(file);
+		fis.skip(offset);
+		fis.read(content);
+		fis.close();
+		return new FileResult(content, size, time);
+	}
+
+	/**
+	 * {@inheritDoc}
+	 * <p>This implementation returns a BufferedInputStream instead of loading the file into memory.
+	 */
+	@Override
+	public InputStream getFileInputStream(String filename) throws IOException {
+		return new BufferedInputStream(new FileInputStream(filename), 16*1024);
+	}
+
+	/**
+	 * {@inheritDoc}
+	 * <p>This implementation returns a BufferedInputStream instead of loading the file into memory.
+	 */
+	@Override
+	public FileResult getFileInputStream(String filename, long previousSize, long previousTime) throws IOException {
+		File file = new File(filename);
+		long size = file.length();
+		long time = file.lastModified();
+		if (previousSize == size && previousTime == time)
+			return new FileResult(size, time);
+		return new FileResult(new BufferedInputStream(new FileInputStream(filename), 16*1024), size, time);
+	}
+}

src/main/java/de/robv/android/xposed/services/FileResult.java

+package de.robv.android.xposed.services;
+
+import java.io.InputStream;
+
+/**
+ * Holder for the result of a {@link BaseService#readFile} or  {@link BaseService#statFile} call.
+ */
+public final class FileResult {
+	/** File content, might be {@code null} if the file wasn't read. */
+	public final byte[] content;
+	/** File input stream, might be {@code null} if the file wasn't read. */
+	public final InputStream stream;
+	/** File size. */
+	public final long size;
+	/** File last modification time. */
+	public final long mtime;
+
+	/*package*/ FileResult(long size, long mtime) {
+		this.content = null;
+		this.stream = null;
+		this.size = size;
+		this.mtime = mtime;
+	}
+
+	/*package*/ FileResult(byte[] content, long size, long mtime) {
+		this.content = content;
+		this.stream = null;
+		this.size = size;
+		this.mtime = mtime;
+	}
+
+	/*package*/ FileResult(InputStream stream, long size, long mtime) {
+		this.content = null;
+		this.stream = stream;
+		this.size = size;
+		this.mtime = mtime;
+	}
+
+	/** @hide */
+	@Override
+	public String toString() {
+		StringBuilder sb = new StringBuilder("{");
+		if (content != null) {
+			sb.append("content.length: ");
+			sb.append(content.length);
+			sb.append(", ");
+		}
+		if (stream != null) {
+			sb.append("stream: ");
+			sb.append(stream.toString());
+			sb.append(", ");
+		}
+		sb.append("size: ");
+		sb.append(size);
+		sb.append(", mtime: ");
+		sb.append(mtime);
+		sb.append("}");
+		return sb.toString();
+	}
+}

src/main/java/de/robv/android/xposed/services/ZygoteService.java

+package de.robv.android.xposed.services;
+
+import java.io.IOException;
+import java.util.Arrays;
+
+/** @hide */
+@SuppressWarnings("JniMissingFunction")
+public final class ZygoteService extends BaseService {
+	@Override
+	public native boolean checkFileAccess(String filename, int mode);
+
+	@Override
+	public native FileResult statFile(String filename) throws IOException;
+
+	@Override
+	public native byte[] readFile(String filename) throws IOException;
+
+	@Override
+	// Just for completeness, we don't expect this to be called often in Zygote.
+	public FileResult readFile(String filename, long previousSize, long previousTime) throws IOException {
+		FileResult stat = statFile(filename);
+		if (previousSize == stat.size && previousTime == stat.mtime)
+			return stat;
+		return new FileResult(readFile(filename), stat.size, stat.mtime);
+	}
+
+	@Override
+	// Just for completeness, we don't expect this to be called often in Zygote.
+	public FileResult readFile(String filename, int offset, int length, long previousSize, long previousTime) throws IOException {
+		FileResult stat = statFile(filename);
+		if (previousSize == stat.size && previousTime == stat.mtime)
+			return stat;
+
+		// Shortcut for the simple case
+		if (offset <= 0 && length <= 0)
+			return new FileResult(readFile(filename), stat.size, stat.mtime);
+
+		// Check range
+		if (offset > 0 && offset >= stat.size) {
+			throw new IllegalArgumentException("offset " + offset + " >= size " + stat.size + " for " + filename);
+		} else if (offset < 0) {
+			offset = 0;
+		}
+
+		if (length > 0 && (offset + length) > stat.size) {
+			throw new IllegalArgumentException("offset " + offset + " + length " + length + " > size " + stat.size + " for " + filename);
+		} else if (length <= 0) {
+			length = (int) (stat.size - offset);
+		}
+
+		byte[] content = readFile(filename);
+		return new FileResult(Arrays.copyOfRange(content, offset, offset + length), stat.size, stat.mtime);
+	}
+}

src/main/java/de/robv/android/xposed/services/package-info.java

+/**
+ * Contains file access services provided by the Xposed framework.
+ */
+package de.robv.android.xposed.services;

src/main/res/drawable-v24/ic_launcher_foreground.xml

+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:aapt="http://schemas.android.com/aapt"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+    <path
+        android:fillType="evenOdd"
+        android:pathData="M32,64C32,64 38.39,52.99 44.13,50.95C51.37,48.37 70.14,49.57 70.14,49.57L108.26,87.69L108,109.01L75.97,107.97L32,64Z"
+        android:strokeWidth="1"
+        android:strokeColor="#00000000">
+        <aapt:attr name="android:fillColor">
+            <gradient
+                android:endX="78.5885"
+                android:endY="90.9159"
+                android:startX="48.7653"
+                android:startY="61.0927"
+                android:type="linear">
+                <item
+                    android:color="#44000000"
+                    android:offset="0.0" />
+                <item
+                    android:color="#00000000"
+                    android:offset="1.0" />
+            </gradient>
+        </aapt:attr>
+    </path>
+    <path
+        android:fillColor="#FFFFFF"
+        android:fillType="nonZero"
+        android:pathData="M66.94,46.02L66.94,46.02C72.44,50.07 76,56.61 76,64L32,64C32,56.61 35.56,50.11 40.98,46.06L36.18,41.19C35.45,40.45 35.45,39.3 36.18,38.56C36.91,37.81 38.05,37.81 38.78,38.56L44.25,44.05C47.18,42.57 50.48,41.71 54,41.71C57.48,41.71 60.78,42.57 63.68,44.05L69.11,38.56C69.84,37.81 70.98,37.81 71.71,38.56C72.44,39.3 72.44,40.45 71.71,41.19L66.94,46.02ZM62.94,56.92C64.08,56.92 65,56.01 65,54.88C65,53.76 64.08,52.85 62.94,52.85C61.8,52.85 60.88,53.76 60.88,54.88C60.88,56.01 61.8,56.92 62.94,56.92ZM45.06,56.92C46.2,56.92 47.13,56.01 47.13,54.88C47.13,53.76 46.2,52.85 45.06,52.85C43.92,52.85 43,53.76 43,54.88C43,56.01 43.92,56.92 45.06,56.92Z"
+        android:strokeWidth="1"
+        android:strokeColor="#00000000" />
+</vector>

src/main/res/drawable/ic_launcher_background.xml

+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+    <path
+        android:fillColor="#008577"
+        android:pathData="M0,0h108v108h-108z" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M9,0L9,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,0L19,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M29,0L29,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M39,0L39,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M49,0L49,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M59,0L59,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M69,0L69,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M79,0L79,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M89,0L89,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M99,0L99,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,9L108,9"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,19L108,19"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,29L108,29"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,39L108,39"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,49L108,49"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,59L108,59"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,69L108,69"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,79L108,79"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,89L108,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,99L108,99"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,29L89,29"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,39L89,39"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,49L89,49"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,59L89,59"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,69L89,69"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,79L89,79"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M29,19L29,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M39,19L39,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M49,19L49,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M59,19L59,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M69,19L69,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M79,19L79,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+</vector>

src/main/res/mipmap-anydpi-v26/ic_launcher.xml

+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@drawable/ic_launcher_background" />
+    <foreground android:drawable="@drawable/ic_launcher_foreground" />
+</adaptive-icon>
\ No newline at end of file

src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml

+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@drawable/ic_launcher_background" />
+    <foreground android:drawable="@drawable/ic_launcher_foreground" />
+</adaptive-icon>
\ No newline at end of file

src/main/res/values/colors.xml

+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="colorPrimary">#008577</color>
+    <color name="colorPrimaryDark">#00574B</color>
+    <color name="colorAccent">#D81B60</color>
+</resources>

src/main/res/values/strings.xml

+<resources>
+    <string name="app_name">XposedBridge</string>
+</resources>

src/main/res/values/styles.xml

+<resources>
+
+    <!-- Base application theme. -->
+    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
+        <!-- Customize your theme here. -->
+        <item name="colorPrimary">@color/colorPrimary</item>
+        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
+        <item name="colorAccent">@color/colorAccent</item>
+    </style>
+
+</resources>