xposed.cpp

/*
 * Xposed enables "god mode" for developers
 */

#define LOG_TAG "Xposed"

#include "xposed.h"
#include "dexspy.h"

#include <utils/Log.h>
#include <android_runtime/AndroidRuntime.h>

#define private public
#if PLATFORM_SDK_VERSION == 15
#include <utils/ResourceTypes.h>
#else
#include <androidfw/ResourceTypes.h>
#endif
#undef private

#include <stdio.h>
#include <sys/mman.h>
#include <cutils/properties.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <dlfcn.h>

#include "xposed_offsets.h"

extern int RUNNING_PLATFORM_SDK_VERSION;

namespace android {

////////////////////////////////////////////////////////////
// variables
////////////////////////////////////////////////////////////
bool keepLoadingXposed = false;
ClassObject* objectArrayClass = NULL;
jclass xposedClass = NULL;
Method* xposedHandleHookedMethod = NULL;
jclass xresourcesClass = NULL;
jmethodID xresourcesTranslateResId = NULL;
jmethodID xresourcesTranslateAttrId = NULL;
const char* startClassName = NULL;
void* PTR_gDvmJit = NULL;
size_t arrayContentsOffset = 0;

////////////////////////////////////////////////////////////
// called directoy by app_process
////////////////////////////////////////////////////////////

void xposedInfo() {
	char release[PROPERTY_VALUE_MAX];
	char sdk[PROPERTY_VALUE_MAX];
	char manufacturer[PROPERTY_VALUE_MAX];
	char model[PROPERTY_VALUE_MAX];
	char rom[PROPERTY_VALUE_MAX];
	char fingerprint[PROPERTY_VALUE_MAX];

	property_get("ro.build.version.release", release, "n/a");
	property_get("ro.build.version.sdk", sdk, "n/a");
	property_get("ro.product.manufacturer", manufacturer, "n/a");
	property_get("ro.product.model", model, "n/a");
	property_get("ro.build.display.id", rom, "n/a");
	property_get("ro.build.fingerprint", fingerprint, "n/a");

	ALOGD("Starting Xposed binary version %s, compiled for SDK %d\n",
			XPOSED_VERSION, PLATFORM_SDK_VERSION);
	ALOGD("Phone: %s (%s), Android version %s (SDK %s)\n", model, manufacturer,
			release, sdk);
	ALOGD("ROM: %s\n", rom);
	ALOGD("Build fingerprint: %s\n", fingerprint);
}

void xposedEnforceDalvik() {
	if (RUNNING_PLATFORM_SDK_VERSION < 19)
		return;

	char runtime[PROPERTY_VALUE_MAX];
	property_get("persist.sys.dalvik.vm.lib", runtime, "");
	if (strcmp(runtime, "libdvm.so") != 0) {
		ALOGE("Unsupported runtime library %s, setting to libdvm.so", runtime);
		property_set("persist.sys.dalvik.vm.lib", "libdvm.so");
	}
}

void disableXposed() {
	int fd;
	fd = open(XPOSED_LOAD_BLOCKER, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
	if (fd >= 0)
		close(fd);
}

bool isXposedDisabled() {
	// is the blocker file present?
	if (access(XPOSED_LOAD_BLOCKER, F_OK) == 0) {
		ALOGE("found %s, not loading Xposed\n", XPOSED_LOAD_BLOCKER);
		return true;
	}
	return false;
}

bool xposedSkipSafemodeDelay() {
	// is the flag file present?
	if (access(XPOSED_SAFEMODE_NODELAY, F_OK) == 0)
		return true;
	else
		return false;
}

bool xposedDisableSafemode() {
	// is the flag file present?
	if (access(XPOSED_SAFEMODE_DISABLE, F_OK) == 0)
		return true;
	else
		return false;
}

// ignore the broadcasts by various Superuser implementations to avoid spamming the Xposed log
bool xposedShouldIgnoreCommand(const char* className, int argc,
		const char* const argv[]) {
	if (className == NULL || argc < 4
			|| strcmp(className, "com.android.commands.am.Am") != 0)
		return false;

	if (strcmp(argv[2], "broadcast") != 0 && strcmp(argv[2], "start") != 0)
		return false;

	bool mightBeSuperuser = false;
	for (int i = 3; i < argc; i++) {
		if (strcmp(argv[i], "com.noshufou.android.su.RESULT") == 0
				|| strcmp(argv[i], "eu.chainfire.supersu.NativeAccess") == 0)
			return true;

		if (mightBeSuperuser && strcmp(argv[i], "--user") == 0)
			return true;

		char* lastComponent = strrchr(argv[i], '.');
		if (!lastComponent)
			continue;

		if (strcmp(lastComponent, ".RequestActivity") == 0
				|| strcmp(lastComponent, ".NotifyActivity") == 0
				|| strcmp(lastComponent, ".SuReceiver") == 0)
			mightBeSuperuser = true;
	}

	return false;
}

bool addXposedToClasspath(bool zygote) {
	ALOGI("-----------------\n");
	// do we have a new version and are (re)starting zygote? Then load it!
	if (zygote && access(XPOSED_JAR_NEWVERSION, R_OK) == 0) {
		ALOGI("Found new Xposed jar version, activating it\n");
		if (rename(XPOSED_JAR_NEWVERSION, XPOSED_JAR) != 0) {
			ALOGE("could not move %s to %s\n", XPOSED_JAR_NEWVERSION,
					XPOSED_JAR);
			return false;
		}
	}
	if (access(XPOSED_JAR, R_OK) == 0) {
		char* oldClassPath = getenv("CLASSPATH");
		if (oldClassPath == NULL) {
			setenv("CLASSPATH", XPOSED_JAR, 1);
		} else {
			char classPath[4096];
			int neededLength = snprintf(classPath, sizeof(classPath), "%s:%s",
					XPOSED_JAR, oldClassPath);
			if (neededLength >= (int) sizeof(classPath)) {
				ALOGE("ERROR: CLASSPATH would exceed %d characters",
						sizeof(classPath));
				return false;
			}
			setenv("CLASSPATH", classPath, 1);
		}
		ALOGI("Added Xposed (%s) to CLASSPATH.\n", XPOSED_JAR);
		return true;
	} else {
		ALOGE("ERROR: could not access Xposed jar '%s'\n", XPOSED_JAR);
		return false;
	}
}

bool xposedOnVmCreated(JNIEnv* env, const char* className) {
	startClassName = className;

	keepLoadingXposed = keepLoadingXposed && xposedInitMemberOffsets(env);
	if (!keepLoadingXposed)
		return false;

	// disable some access checks
	patchReturnTrue((uintptr_t) & dvmCheckClassAccess);
	patchReturnTrue((uintptr_t) & dvmCheckFieldAccess);
	patchReturnTrue((uintptr_t) & dvmInSamePackage);
	if (access(XPOSED_DIR "conf/do_not_hook_dvmCheckMethodAccess", F_OK) != 0)
		patchReturnTrue((uintptr_t) & dvmCheckMethodAccess);

	jclass miuiResourcesClass = env->FindClass(MIUI_RESOURCES_CLASS);
	if (miuiResourcesClass != NULL) {
		ClassObject* clazz = (ClassObject*) dvmDecodeIndirectRef(
				dvmThreadSelf(), miuiResourcesClass);
		if (dvmIsFinalClass(clazz)) {
			ALOGD("Removing final flag for class '%s'", MIUI_RESOURCES_CLASS);
			clazz->accessFlags &= ~ACC_FINAL;
		}
	}
	env->ExceptionClear();

	xposedClass = env->FindClass(XPOSED_CLASS);
	xposedClass = reinterpret_cast<jclass>(env->NewGlobalRef(xposedClass));

	if (xposedClass == NULL) {
		ALOGE("Error while loading Xposed class '%s':\n", XPOSED_CLASS);
		dvmLogExceptionStackTrace();
		env->ExceptionClear();
		return false;
	}

	ALOGI("Found Xposed class '%s', now initializing\n", XPOSED_CLASS);
	if (register_de_robv_android_xposed_XposedBridge(env) != JNI_OK) {
		ALOGE("Could not register natives for '%s'\n", XPOSED_CLASS);
		return false;
	}

	return true;
}

static bool xposedInitMemberOffsets(JNIEnv* env) {
	PTR_gDvmJit = dlsym(RTLD_DEFAULT, "gDvmJit");

	if (PTR_gDvmJit == NULL) {
		offsetMode = MEMBER_OFFSET_MODE_NO_JIT;
	} else {
		offsetMode = MEMBER_OFFSET_MODE_WITH_JIT;
	}
	ALOGD("Using structure member offsets for mode %s",
			xposedOffsetModesDesc[offsetMode]);

	MEMBER_OFFSET_COPY(DvmJitGlobals, codeCacheFull);

	// detect offset of ArrayObject->contents
	jintArray dummyArray = env->NewIntArray(1);
	if (dummyArray == NULL) {
		ALOGE("Could allocate int array for testing");
		dvmLogExceptionStackTrace();
		env->ExceptionClear();
		return false;
	}

	jint* dummyArrayElements = env->GetIntArrayElements(dummyArray, NULL);
	arrayContentsOffset = (size_t) dummyArrayElements
			- (size_t) dvmDecodeIndirectRef(dvmThreadSelf(), dummyArray);
	env->ReleaseIntArrayElements(dummyArray, dummyArrayElements, 0);
	env->DeleteLocalRef(dummyArray);

	if (arrayContentsOffset < 12 || arrayContentsOffset > 128) {
		ALOGE("Detected strange offset %d of ArrayObject->contents",
				arrayContentsOffset);
		return false;
	}

	return true;
}

static inline void xposedSetObjectArrayElement(const ArrayObject* obj,
		int index, Object* val) {
	uintptr_t arrayContents = (uintptr_t) obj + arrayContentsOffset;
	((Object **) arrayContents)[index] = val;
	dvmWriteBarrierArray(obj, index, index + 1);
}

////////////////////////////////////////////////////////////
// handling hooked methods / helpers
////////////////////////////////////////////////////////////

static void xposedCallHandler(const u4* args, JValue* pResult,
		const Method* method, ::Thread* self) {
	if (!xposedIsHooked(method)) {
		dvmThrowNoSuchMethodError(
				"could not find Xposed original method - how did you even get here?");
		return;
	}

	XposedHookInfo* hookInfo = (XposedHookInfo*) method->insns;
	Method* original = (Method*) hookInfo;
	Object* originalReflected = hookInfo->reflectedMethod;
	Object* additionalInfo = hookInfo->additionalInfo;

	// convert/box arguments
	const char* desc = &method->shorty[1]; // [0] is the return type.
	Object* thisObject = NULL;
	size_t srcIndex = 0;
	size_t dstIndex = 0;

	// for non-static methods determine the "this" pointer
	if (!dvmIsStaticMethod(original)) {
		thisObject = (Object*) args[0];
		srcIndex++;
	}

	ArrayObject* argsArray = dvmAllocArrayByClass(objectArrayClass,
			strlen(method->shorty) - 1, ALLOC_DEFAULT);
	if (argsArray == NULL) {
		return;
	}

	while (*desc != '\0') {
		char descChar = *(desc++);
		JValue value;
		Object* obj;

		switch (descChar) {
		case 'Z':
		case 'C':
		case 'F':
		case 'B':
		case 'S':
		case 'I':
			value.i = args[srcIndex++];
			obj = (Object*) dvmBoxPrimitive(value,
					dvmFindPrimitiveClass(descChar));
			dvmReleaseTrackedAlloc(obj, self);
			break;
		case 'D':
		case 'J':
			value.j = dvmGetArgLong(args, srcIndex);
			srcIndex += 2;
			obj = (Object*) dvmBoxPrimitive(value,
					dvmFindPrimitiveClass(descChar));
			dvmReleaseTrackedAlloc(obj, self);
			break;
		case '[':
		case 'L':
			obj = (Object*) args[srcIndex++];
			break;
		default:
			ALOGE("Unknown method signature description character: %c\n",
					descChar);
			obj = NULL;
			srcIndex++;
		}
		xposedSetObjectArrayElement(argsArray, dstIndex++, obj);
	}

	// call the Java handler function
	JValue result;
	dvmCallMethod(self, xposedHandleHookedMethod, NULL, &result,
			originalReflected, (int) original, additionalInfo, thisObject,
			argsArray);

	dvmReleaseTrackedAlloc(argsArray, self);

	// exceptions are thrown to the caller
	if (dvmCheckException(self)) {
		return;
	}

	// return result with proper type
	ClassObject* returnType = dvmGetBoxedReturnType(method);
	if (returnType->primitiveType == PRIM_VOID) {
		// ignored
	} else if (result.l == NULL) {
		if (dvmIsPrimitiveClass(returnType)) {
			dvmThrowNullPointerException("null result when primitive expected");
		}
		pResult->l = NULL;
	} else {
		if (!dvmUnboxPrimitive(result.l, returnType, pResult)) {
			dvmThrowClassCastException(result.l->clazz, returnType);
		}
	}
}

static void replaceAsm(uintptr_t function, unsigned const char* newCode,
		size_t len) {
#ifdef __arm__
	function = function & ~1;
#endif
	uintptr_t pageStart = function & ~(PAGESIZE - 1);
	size_t pageProtectSize = PAGESIZE;
	if (function + len > pageStart + pageProtectSize)
		pageProtectSize += PAGESIZE;

	mprotect((void*) pageStart, pageProtectSize,
			PROT_READ | PROT_WRITE | PROT_EXEC);
	memcpy((void*) function, newCode, len);
	mprotect((void*) pageStart, pageProtectSize, PROT_READ | PROT_EXEC);

	__clear_cache((void*) function, (void*) (function + len));
}

static void patchReturnTrue(uintptr_t function) {
#ifdef __arm__
	unsigned const char asmReturnTrueThumb[] = {0x01, 0x20, 0x70, 0x47};
	unsigned const char asmReturnTrueArm[] = {0x01, 0x00, 0xA0, 0xE3, 0x1E, 0xFF, 0x2F, 0xE1};
	if (function & 1)
	replaceAsm(function, asmReturnTrueThumb, sizeof(asmReturnTrueThumb));
	else
	replaceAsm(function, asmReturnTrueArm, sizeof(asmReturnTrueArm));
#else
	unsigned const char asmReturnTrueX86[] = { 0x31, 0xC0, 0x40, 0xC3 };
	replaceAsm(function, asmReturnTrueX86, sizeof(asmReturnTrueX86));
#endif
}

////////////////////////////////////////////////////////////
// JNI methods
////////////////////////////////////////////////////////////

static jboolean de_robv_android_xposed_XposedBridge_initNative(JNIEnv* env,
		jclass clazz) {
	if (!keepLoadingXposed) {
		ALOGE("Not initializing Xposed because of previous errors\n");
		return false;
	}

	::Thread* self = dvmThreadSelf();

	xposedHandleHookedMethod =
			(Method*) env->GetStaticMethodID(xposedClass, "handleHookedMethod",
					"(Ljava/lang/reflect/Member;ILjava/lang/Object;Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;");
	if (xposedHandleHookedMethod == NULL) {
		ALOGE(
				"ERROR: could not find method %s.handleHookedMethod(Member, int, Object, Object, Object[])\n",
				XPOSED_CLASS);
		dvmLogExceptionStackTrace();
		env->ExceptionClear();
		keepLoadingXposed = false;
		return false;
	}

	Method* xposedInvokeOriginalMethodNative =
			(Method*) env->GetStaticMethodID(xposedClass,
					"invokeOriginalMethodNative",
					"(Ljava/lang/reflect/Member;I[Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;");
	if (xposedInvokeOriginalMethodNative == NULL) {
		ALOGE(
				"ERROR: could not find method %s.invokeOriginalMethodNative(Member, int, Class[], Class, Object, Object[])\n",
				XPOSED_CLASS);
		dvmLogExceptionStackTrace();
		env->ExceptionClear();
		keepLoadingXposed = false;
		return false;
	}
	dvmSetNativeFunc(xposedInvokeOriginalMethodNative,
			de_robv_android_xposed_XposedBridge_invokeOriginalMethodNative,
			NULL);

	objectArrayClass = dvmFindArrayClass("[Ljava/lang/Object;", NULL);
	if (objectArrayClass == NULL) {
		ALOGE("Error while loading Object[] class");
		dvmLogExceptionStackTrace();
		env->ExceptionClear();
		keepLoadingXposed = false;
		return false;
	}

	//It's not found here?
	xresourcesClass = env->FindClass(XRESOURCES_CLASS);
	xresourcesClass = reinterpret_cast<jclass>(env->NewGlobalRef(
			xresourcesClass));
	if (xresourcesClass == NULL) {
		ALOGE("Error while loading XResources class '%s':\n", XRESOURCES_CLASS);
		dvmLogExceptionStackTrace();
		env->ExceptionClear();
		keepLoadingXposed = false;
		return false;
	}
	if (register_android_content_res_XResources(env) != JNI_OK) {
		ALOGE("Could not register natives for '%s'\n", XRESOURCES_CLASS);
		return false;
	}

	xresourcesTranslateResId =
			env->GetStaticMethodID(xresourcesClass, "translateResId",
					"(ILandroid/content/res/XResources;Landroid/content/res/Resources;)I");
	if (xresourcesTranslateResId == NULL) {
		ALOGE(
				"ERROR: could not find method %s.translateResId(int, Resources, Resources)\n",
				XRESOURCES_CLASS);
		dvmLogExceptionStackTrace();
		env->ExceptionClear();
		keepLoadingXposed = false;
		return false;
	}

	xresourcesTranslateAttrId = env->GetStaticMethodID(xresourcesClass,
			"translateAttrId",
			"(Ljava/lang/String;Landroid/content/res/XResources;)I");
	if (xresourcesTranslateAttrId == NULL) {
		ALOGE(
				"ERROR: could not find method %s.findAttrId(String, Resources, Resources)\n",
				XRESOURCES_CLASS);
		dvmLogExceptionStackTrace();
		env->ExceptionClear();
		keepLoadingXposed = false;
		return false;
	}

	return true;
}

static void de_robv_android_xposed_XposedBridge_hookMethodNative(JNIEnv* env,
		jclass clazz, jobject reflectedMethodIndirect,
		jobject declaredClassIndirect, jint slot,
		jobject additionalInfoIndirect) {
	// Usage errors?
	if (declaredClassIndirect == NULL || reflectedMethodIndirect == NULL) {
		dvmThrowIllegalArgumentException(
				"method and declaredClass must not be null");
		return;
	}

	// Find the internal representation of the method
	ClassObject* declaredClass = (ClassObject*) dvmDecodeIndirectRef(
			dvmThreadSelf(), declaredClassIndirect);
	Method* method = dvmSlotToMethod(declaredClass, slot);
	if (method == NULL) {
		dvmThrowNoSuchMethodError(
				"could not get internal representation for method");
		return;
	}


	if (xposedIsHooked(method)) {
		ALOGD("Hook: Ignored! [%s] [%s]\n", declaredClass->descriptor, method->name);
		// already hooked
		return;
	}
	else {
		ALOGD("Hook: [%s] [%s]\n", declaredClass->descriptor, method->name);
	}

	// Save a copy of the original method and other hook info
	XposedHookInfo* hookInfo = (XposedHookInfo*) calloc(1,
			sizeof(XposedHookInfo));
	memcpy(hookInfo, method, sizeof(hookInfo->originalMethodStruct));
	hookInfo->reflectedMethod = dvmDecodeIndirectRef(dvmThreadSelf(),
			env->NewGlobalRef(reflectedMethodIndirect));
	hookInfo->additionalInfo = dvmDecodeIndirectRef(dvmThreadSelf(),
			env->NewGlobalRef(additionalInfoIndirect));

	// Replace method with our own code
	SET_METHOD_FLAG(method, ACC_NATIVE);
	method->nativeFunc = &xposedCallHandler;
	method->insns = (const u2*) hookInfo;
	method->registersSize = method->insSize;
	method->outsSize = 0;

	if (PTR_gDvmJit != NULL) {
		// reset JIT cache
		MEMBER_VAL(PTR_gDvmJit, DvmJitGlobals, codeCacheFull) = true;
	}
}

static inline bool xposedIsHooked(const Method* method) {
	return (method->nativeFunc == &xposedCallHandler);
}

// simplified copy of Method.invokeNative, but calls the original (non-hooked) method and has no access checks
// used when a method has been hooked
static void de_robv_android_xposed_XposedBridge_invokeOriginalMethodNative(
		const u4* args, JValue* pResult, const Method* method, ::Thread* self) {
	Method* meth = (Method*) args[1];
	if (meth == NULL) {
		meth = dvmGetMethodFromReflectObj((Object*) args[0]);
		if (xposedIsHooked(meth)) {
			meth = (Method*) meth->insns;
		}
	}
	ArrayObject* params = (ArrayObject*) args[2];
	ClassObject* returnType = (ClassObject*) args[3];
	Object* thisObject = (Object*) args[4]; // null for static methods
	ArrayObject* argList = (ArrayObject*) args[5];

	// invoke the method
	pResult->l = dvmInvokeMethod(thisObject, meth, argList, params, returnType,
			true);

	return;
}

static void android_content_res_XResources_rewriteXmlReferencesNative(
		JNIEnv* env, jclass clazz, jint parserPtr, jobject origRes,
		jobject repRes) {

	ResXMLParser* parser = (ResXMLParser*) parserPtr;
	const ResXMLTree& mTree = parser->mTree;
	uint32_t* mResIds = (uint32_t*) mTree.mResIds;
	ResXMLTree_attrExt* tag;
	int attrCount;

	if (parser == NULL)
		return;

	do {
		switch (parser->next()) {
		case ResXMLParser::START_TAG:
			tag = (ResXMLTree_attrExt*) parser->mCurExt;
			attrCount = dtohs(tag->attributeCount);
			for (int idx = 0; idx < attrCount; idx++) {
				ResXMLTree_attribute* attr =
						(ResXMLTree_attribute*) (((const uint8_t*) tag)
								+ dtohs(tag->attributeStart)
								+ (dtohs(tag->attributeSize) * idx));

				// find resource IDs for attribute names
				int32_t attrNameID = parser->getAttributeNameID(idx);
				// only replace attribute name IDs for app packages
				if (attrNameID >= 0 && (size_t) attrNameID < mTree.mNumResIds
						&& dtohl(mResIds[attrNameID]) >= 0x7f000000) {
					size_t attNameLen;
					const char16_t* attrName = mTree.mStrings.stringAt(
							attrNameID, &attNameLen);
					jint attrResID = env->CallStaticIntMethod(xresourcesClass,
							xresourcesTranslateAttrId,
							env->NewString((const jchar*) attrName, attNameLen),
							origRes);
					if (env->ExceptionCheck())
						goto leave;

					mResIds[attrNameID] = htodl(attrResID);
				}

				// find original resource IDs for reference values (app packages only)
				if (attr->typedValue.dataType != Res_value::TYPE_REFERENCE)
					continue;

				jint oldValue = dtohl(attr->typedValue.data);
				if (oldValue < 0x7f000000)
					continue;

				jint newValue = env->CallStaticIntMethod(xresourcesClass,
						xresourcesTranslateResId, oldValue, origRes, repRes);
				if (env->ExceptionCheck())
					goto leave;

				if (newValue != oldValue)
					attr->typedValue.data = htodl(newValue);
			}
			continue;
		case ResXMLParser::END_DOCUMENT:
		case ResXMLParser::BAD_DOCUMENT:
			goto leave;
		default:
			continue;
		}
	} while (true);

	leave: parser->restart();
}

static jobject de_robv_android_xposed_XposedBridge_getStartClassName(
		JNIEnv* env, jclass clazz) {
	//Ugly hack... Start dexspy before xposed if necessary
	dexspyStartMain(env);
	return env->NewStringUTF(startClassName);
}

static const JNINativeMethod xposedMethods[] = { { "getStartClassName",
		"()Ljava/lang/String;",
		(void*) de_robv_android_xposed_XposedBridge_getStartClassName }, {
		"initNative", "()Z",
		(void*) de_robv_android_xposed_XposedBridge_initNative }, {
		"hookMethodNative",
		"(Ljava/lang/reflect/Member;Ljava/lang/Class;ILjava/lang/Object;)V",
		(void*) de_robv_android_xposed_XposedBridge_hookMethodNative }, };

static const JNINativeMethod xresourcesMethods[] = { {
		"rewriteXmlReferencesNative",
		"(ILandroid/content/res/XResources;Landroid/content/res/Resources;)V",
		(void*) android_content_res_XResources_rewriteXmlReferencesNative }, };

static int register_de_robv_android_xposed_XposedBridge(JNIEnv* env) {
	return env->RegisterNatives(xposedClass, xposedMethods,
			NELEM(xposedMethods));
}

static int register_android_content_res_XResources(JNIEnv* env) {
	return env->RegisterNatives(xresourcesClass, xresourcesMethods,
			NELEM(xresourcesMethods));
}

}