If called from {@link MethodHook#beforeHookedMethod}, it prevents the call to the original method. 147 | */ 148 | public void setResult(Object result) { 149 | this.result = result; 150 | this.throwable = null; 151 | this.returnEarly = true; 152 | } 153 | 154 | /** 155 | * Returns the {@link Throwable} thrown by the method, or {@code null}. 156 | */ 157 | public Throwable getThrowable() { 158 | return throwable; 159 | } 160 | 161 | /** 162 | * Returns true if an exception was thrown by the method. 163 | */ 164 | public boolean hasThrowable() { 165 | return throwable != null; 166 | } 167 | 168 | /** 169 | * Modify the exception thrown of the method call. 170 | * 171 | *
If called from {@link MethodHook#beforeHookedMethod}, it prevents the call to the original method.
172 | */
173 | public void setThrowable(Throwable throwable) {
174 | this.throwable = throwable;
175 | this.result = null;
176 | this.returnEarly = true;
177 | }
178 |
179 | /**
180 | * Returns the result of the method call, or throws the Throwable caused by it.
181 | */
182 | public Object getResultOrThrowable() throws Throwable {
183 | if (throwable != null)
184 | throw throwable;
185 | return result;
186 | }
187 | }
188 | }
189 |
--------------------------------------------------------------------------------
/maple/src/main/java/me/fycz/maple/MapleUtils.java:
--------------------------------------------------------------------------------
1 | package me.fycz.maple;
2 |
3 | import android.content.res.AssetManager;
4 | import android.content.res.Resources;
5 | import android.os.Build;
6 | import android.util.Log;
7 |
8 | import androidx.annotation.NonNull;
9 | import androidx.annotation.Nullable;
10 | import androidx.annotation.RequiresApi;
11 |
12 | import org.apache.commons.lang3.ClassUtils;
13 | import org.apache.commons.lang3.reflect.MemberUtilsX;
14 |
15 | import java.io.ByteArrayOutputStream;
16 | import java.io.FileInputStream;
17 | import java.io.IOException;
18 | import java.io.InputStream;
19 | import java.lang.reflect.Constructor;
20 | import java.lang.reflect.Field;
21 | import java.lang.reflect.InvocationTargetException;
22 | import java.lang.reflect.Member;
23 | import java.lang.reflect.Method;
24 | import java.lang.reflect.Modifier;
25 | import java.math.BigInteger;
26 | import java.security.MessageDigest;
27 | import java.security.NoSuchAlgorithmException;
28 | import java.util.Arrays;
29 | import java.util.HashMap;
30 | import java.util.LinkedList;
31 | import java.util.List;
32 | import java.util.Objects;
33 | import java.util.Optional;
34 | import java.util.WeakHashMap;
35 | import java.util.concurrent.ConcurrentHashMap;
36 | import java.util.concurrent.atomic.AtomicInteger;
37 |
38 | /**
39 | * @author fengyue
40 | * @date 2022/3/28 14:57
41 | */
42 | public final class MapleUtils {
43 | static {
44 | try {
45 | System.loadLibrary("maple");
46 | } catch (Throwable e) {
47 | log(e);
48 | throw new RuntimeException("Load maple hook library failed!");
49 | }
50 | }
51 |
52 | private static final String TAG = "MapleUtils";
53 | /**
54 | * The system class loader which can be used to locate Android framework classes.
55 | * Application classes cannot be retrieved from it.
56 | *
57 | * @see ClassLoader#getSystemClassLoader
58 | */
59 | private static final ClassLoader BOOTCLASSLOADER = MapleUtils.class.getClassLoader();
60 |
61 | private static final ConcurrentHashMap
111 | * So in fact we only need to use the structural comparison results of the reflection object.
112 | *
113 | * @see benchmarks for ART
114 | * @see benchmarks for JVM
115 | */
116 | private abstract static class MemberCacheKey {
117 | private final int hash;
118 |
119 | protected MemberCacheKey(int hash) {
120 | this.hash = hash;
121 | }
122 |
123 | @Override
124 | public abstract boolean equals(@Nullable Object obj);
125 |
126 | @Override
127 | public final int hashCode() {
128 | return hash;
129 | }
130 |
131 | static final class Constructor extends MemberCacheKey {
132 | private final Class clazz;
133 | private final Class[] parameters;
134 | private final boolean isExact;
135 |
136 | public Constructor(Class clazz, Class[] parameters, boolean isExact) {
137 | super(31 * Objects.hash(clazz, isExact) + Arrays.hashCode(parameters));
138 | this.clazz = clazz;
139 | this.parameters = parameters;
140 | this.isExact = isExact;
141 | }
142 |
143 | @Override
144 | public boolean equals(Object o) {
145 | if (this == o) return true;
146 | if (!(o instanceof MemberCacheKey.Constructor)) return false;
147 | MemberCacheKey.Constructor that = (MemberCacheKey.Constructor) o;
148 | return isExact == that.isExact && Objects.equals(clazz, that.clazz) && Arrays.equals(parameters, that.parameters);
149 | }
150 |
151 | @NonNull
152 | @Override
153 | public String toString() {
154 | var str = clazz.getName() + getParametersString(parameters);
155 | if (isExact) {
156 | return str + "#exact";
157 | } else {
158 | return str;
159 | }
160 | }
161 | }
162 |
163 | static final class Field extends MemberCacheKey {
164 | private final Class clazz;
165 | private final String name;
166 |
167 | public Field(Class clazz, String name) {
168 | super(Objects.hash(clazz, name));
169 | this.clazz = clazz;
170 | this.name = name;
171 | }
172 |
173 | @Override
174 | public boolean equals(Object o) {
175 | if (this == o) return true;
176 | if (!(o instanceof MemberCacheKey.Field)) return false;
177 | MemberCacheKey.Field field = (MemberCacheKey.Field) o;
178 | return Objects.equals(clazz, field.clazz) && Objects.equals(name, field.name);
179 | }
180 |
181 | @NonNull
182 | @Override
183 | public String toString() {
184 | return clazz.getName() + "#" + name;
185 | }
186 | }
187 |
188 | static final class Method extends MemberCacheKey {
189 | private final Class clazz;
190 | private final String name;
191 | private final Class[] parameters;
192 | private final boolean isExact;
193 |
194 | public Method(Class clazz, String name, Class[] parameters, boolean isExact) {
195 | super(31 * Objects.hash(clazz, name, isExact) + Arrays.hashCode(parameters));
196 | this.clazz = clazz;
197 | this.name = name;
198 | this.parameters = parameters;
199 | this.isExact = isExact;
200 | }
201 |
202 | @Override
203 | public boolean equals(Object o) {
204 | if (this == o) return true;
205 | if (!(o instanceof MemberCacheKey.Method)) return false;
206 | MemberCacheKey.Method method = (MemberCacheKey.Method) o;
207 | return isExact == method.isExact && Objects.equals(clazz, method.clazz) && Objects.equals(name, method.name) && Arrays.equals(parameters, method.parameters);
208 | }
209 |
210 | @NonNull
211 | @Override
212 | public String toString() {
213 | var str = clazz.getName() + '#' + name + getParametersString(parameters);
214 | if (isExact) {
215 | return str + "#exact";
216 | } else {
217 | return str;
218 | }
219 | }
220 | }
221 | }
222 |
223 | /**
224 | * Look up a class with the specified class loader.
225 | *
226 | * There are various allowed syntaxes for the class name, but it's recommended to use one of
227 | * these:
228 | * This combines calls to {@link #findMethodExact(Class, String, Object...)} and
378 | * {@link MapleBridge#hookMethod}.
379 | *
380 | * The method must be declared or overridden in the given class, inherited
381 | * methods are not considered! That's because each method implementation exists only once in
382 | * the memory, and when classes inherit it, they just get another reference to the implementation.
383 | * Hooking a method therefore applies to all classes inheriting the same implementation. You
384 | * have to expect that the hook applies to subclasses (unless they override the method), but you
385 | * shouldn't have to worry about hooks applying to superclasses, hence this "limitation".
386 | * There could be undesired or even dangerous hooks otherwise, e.g. if you hook
387 | * {@code SomeClass.equals()} and that class doesn't override the {@code equals()} on some ROMs,
388 | * making you hook {@code Object.equals()} instead.
389 | *
390 | * There are two ways to specify the parameter types. If you already have a reference to the
391 | * {@link Class}, use that. For Android framework classes, you can often use something like
392 | * {@code String.class}. If you don't have the class reference, you can simply use the
393 | * full class name as a string, e.g. {@code java.lang.String} or {@code com.example.MyClass}.
394 | * It will be passed to {@link #findClass} with the same class loader that is used for the target
395 | * method, see its documentation for the allowed notations.
396 | *
397 | * Primitive types, such as {@code int}, can be specified using {@code int.class} (recommended)
398 | * or {@code Integer.TYPE}. Note that {@code Integer.class} doesn't refer to {@code int} but to
399 | * {@code Integer}, which is a normal class (boxed primitive). Therefore it must not be used when
400 | * the method expects an {@code int} parameter - it has to be used for {@code Integer} parameters
401 | * though, so check the method signature in detail.
402 | *
403 | * As last argument to this method (after the list of target method parameters), you need
404 | * to specify the callback that should be executed when the method is invoked. It's usually
405 | * an anonymous subclass of {@link MethodHook} or {@link MethodReplacement}.
406 | *
407 | * Example
408 | * See {@link #findAndHookMethod(String, ClassLoader, String, Object...)} for details about
494 | * the method and parameter type resolution.
495 | *
496 | * @param className The name of the class which implements the method.
497 | * @param classLoader The class loader for resolving the target and parameter classes.
498 | * @param methodName The target method name.
499 | * @param parameterTypes The parameter types of the target method.
500 | * @return A reference to the method.
501 | * @throws NoSuchMethodException In case the method was not found.
502 | * @throws ClassNotFoundException In case the target class or one of the parameter types couldn't be resolved.
503 | */
504 | public static Method findMethodExact(String className, ClassLoader classLoader, String methodName, Object... parameterTypes) throws ClassNotFoundException, NoSuchMethodException {
505 | return findMethodExact(findClass(className, classLoader), methodName, getParameterClasses(classLoader, parameterTypes));
506 | }
507 |
508 | /**
509 | * Look up and return a method if it exists.
510 | * Like {@link #findMethodExact(String, ClassLoader, String, Object...)}, but doesn't throw an
511 | * exception if the method doesn't exist.
512 | *
513 | * @param className The name of the class which implements the method.
514 | * @param classLoader The class loader for resolving the target and parameter classes.
515 | * @param methodName The target method name.
516 | * @param parameterTypes The parameter types of the target method.
517 | * @return A reference to the method, or {@code null} if it doesn't exist.
518 | */
519 | public static Method findMethodExactIfExists(String className, ClassLoader classLoader, String methodName, Object... parameterTypes) {
520 | try {
521 | return findMethodExact(className, classLoader, methodName, parameterTypes);
522 | } catch (ClassNotFoundException | NoSuchMethodException e) {
523 | return null;
524 | }
525 | }
526 |
527 | /**
528 | * Look up a method in a class and set it to accessible.
529 | * See {@link #findMethodExact(String, ClassLoader, String, Object...)} for details.
530 | *
531 | * This variant requires that you already have reference to all the parameter types.
532 | */
533 | public static Method findMethodExact(Class clazz, String methodName, Class... parameterTypes) throws NoSuchMethodException {
534 | var key = new MemberCacheKey.Method(clazz, methodName, parameterTypes, true);
535 |
536 | if (methodCache.containsKey(key)) {
537 | Method method = methodCache.get(key);
538 | if (method == getEmptyMethod())
539 | throw new NoSuchMethodException(key.toString());
540 | return method;
541 | }
542 | try {
543 | Method method = key.clazz.getDeclaredMethod(methodName, parameterTypes);
544 | method.setAccessible(true);
545 | methodCache.put(key, method);
546 | return method;
547 | } catch (NoSuchMethodException e) {
548 | methodCache.put(key, getEmptyMethod());
549 | throw new NoSuchMethodException(key.toString());
550 | }
551 | }
552 |
553 | /**
554 | * Returns an array of all methods declared/overridden in a class with the specified parameter types.
555 | *
556 | * The return type is optional, it will not be compared if it is {@code null}.
557 | * Use {@code void.class} if you want to search for methods returning nothing.
558 | *
559 | * @param clazz The class to look in.
560 | * @param returnType The return type, or {@code null} (see above).
561 | * @param parameterTypes The parameter types.
562 | * @return An array with matching methods, all set to accessible already.
563 | */
564 | public static Method[] findMethodsByExactParameters(Class clazz, Class returnType, Class... parameterTypes) {
565 | List This does'nt only look for exact matches, but for the best match. All considered candidates
595 | * must be compatible with the given parameter types, i.e. the parameters must be assignable
596 | * to the method's formal parameters. Inherited methods are considered here.
597 | *
598 | * @param clazz The class which declares, inherits or overrides the method.
599 | * @param methodName The method name.
600 | * @param parameterTypes The types of the method's parameters.
601 | * @return A reference to the best-matching method.
602 | * @throws NoSuchMethodException In case no suitable method was found.
603 | */
604 | public static Method findMethodBestMatch(Class clazz, String methodName, Class... parameterTypes) throws NoSuchMethodException {
605 | // then find the best match
606 | var key = new MemberCacheKey.Method(clazz, methodName, parameterTypes, false);
607 |
608 | if (methodCache.containsKey(key)) {
609 | Method method = methodCache.get(key);
610 | if (method == getEmptyMethod())
611 | throw new NoSuchMethodException(key.toString());
612 | return method;
613 | }
614 |
615 | try {
616 | Method method = findMethodExact(clazz, methodName, parameterTypes);
617 | methodCache.put(key, method);
618 | return method;
619 | } catch (NoSuchMethodException ignored) {}
620 |
621 | Method bestMatch = null;
622 | Class clz = key.clazz;
623 | boolean considerPrivateMethods = true;
624 | do {
625 | for (Method method : clz.getDeclaredMethods()) {
626 | // don't consider private methods of superclasses
627 | if (!considerPrivateMethods && Modifier.isPrivate(method.getModifiers()))
628 | continue;
629 |
630 | // compare name and parameters
631 | if (method.getName().equals(key.name) && ClassUtils.isAssignable(
632 | key.parameters,
633 | method.getParameterTypes(),
634 | true)) {
635 | // get accessible version of method
636 | if (bestMatch == null || MemberUtilsX.compareMethodFit(
637 | method,
638 | bestMatch,
639 | key.parameters) < 0) {
640 | bestMatch = method;
641 | }
642 | }
643 | }
644 | considerPrivateMethods = false;
645 | } while ((clz = clz.getSuperclass()) != null);
646 |
647 | if (bestMatch != null) {
648 | bestMatch.setAccessible(true);
649 | methodCache.put(key, bestMatch);
650 | return bestMatch;
651 | } else {
652 | NoSuchMethodException e = new NoSuchMethodException(key.toString());
653 | methodCache.put(key, getEmptyMethod());
654 | throw e;
655 | }
656 | }
657 |
658 | /**
659 | * Look up a method in a class and set it to accessible.
660 | *
661 | * See {@link #findMethodBestMatch(Class, String, Class...)} for details. This variant
662 | * determines the parameter types from the classes of the given objects.
663 | */
664 | public static Method findMethodBestMatch(Class clazz, String methodName, Object... args) throws NoSuchMethodException {
665 | return findMethodBestMatch(clazz, methodName, getParameterTypes(args));
666 | }
667 |
668 | /**
669 | * Look up a method in a class and set it to accessible.
670 | *
671 | * See {@link #findMethodBestMatch(Class, String, Class...)} for details. This variant
672 | * determines the parameter types from the classes of the given objects. For any item that is
673 | * {@code null}, the type is taken from {@code parameterTypes} instead.
674 | */
675 | public static Method findMethodBestMatch(Class clazz, String methodName, Class[] parameterTypes, Object[] args) throws NoSuchMethodException {
676 | Class[] argsClasses = null;
677 | for (int i = 0; i < parameterTypes.length; i++) {
678 | if (parameterTypes[i] != null)
679 | continue;
680 | if (argsClasses == null)
681 | argsClasses = getParameterTypes(args);
682 | parameterTypes[i] = argsClasses[i];
683 | }
684 | return findMethodBestMatch(clazz, methodName, parameterTypes);
685 | }
686 |
687 | /**
688 | * Returns an array with the classes of the given objects.
689 | */
690 | public static Class[] getParameterTypes(Object... args) {
691 | Class[] clazzes = new Class[args.length];
692 | for (int i = 0; i < args.length; i++) {
693 | clazzes[i] = (args[i] != null) ? args[i].getClass() : null;
694 | }
695 | return clazzes;
696 | }
697 |
698 | /**
699 | * Retrieve classes from an array, where each element might either be a Class
700 | * already, or a String with the full class name.
701 | */
702 | private static Class[] getParameterClasses(ClassLoader classLoader, Object[] parameterTypesAndCallback) throws ClassNotFoundException {
703 | Class[] parameterClasses = null;
704 | for (int i = parameterTypesAndCallback.length - 1; i >= 0; i--) {
705 | Object type = parameterTypesAndCallback[i];
706 | if (type == null)
707 | throw new ClassNotFoundException("parameter type must not be null", null);
708 |
709 | // ignore trailing callback
710 | if (type instanceof MethodHook)
711 | continue;
712 |
713 | if (parameterClasses == null)
714 | parameterClasses = new Class[i + 1];
715 |
716 | if (type instanceof Class)
717 | parameterClasses[i] = (Class) type;
718 | else if (type instanceof String)
719 | parameterClasses[i] = findClass((String) type, classLoader);
720 | else
721 | throw new ClassNotFoundException("parameter type must either be specified as Class or String", null);
722 | }
723 |
724 | // if there are no arguments for the method
725 | if (parameterClasses == null)
726 | parameterClasses = new Class[0];
727 |
728 | return parameterClasses;
729 | }
730 |
731 | /**
732 | * Returns an array of the given classes.
733 | */
734 | public static Class[] getClassesAsArray(Class... clazzes) {
735 | return clazzes;
736 | }
737 |
738 | private static String getParametersString(Class... clazzes) {
739 | StringBuilder sb = new StringBuilder("(");
740 | boolean first = true;
741 | for (Class clazz : clazzes) {
742 | if (first)
743 | first = false;
744 | else
745 | sb.append(",");
746 |
747 | if (clazz != null)
748 | sb.append(clazz.getCanonicalName());
749 | else
750 | sb.append("null");
751 | }
752 | sb.append(")");
753 | return sb.toString();
754 | }
755 |
756 | /**
757 | * Look up a constructor of a class and set it to accessible.
758 | * See {@link #findMethodExact(String, ClassLoader, String, Object...)} for details.
759 | */
760 | public static Constructor findConstructorExact(Class clazz, Object... parameterTypes) throws NoSuchMethodException, ClassNotFoundException {
761 | return findConstructorExact(clazz, getParameterClasses(clazz.getClassLoader(), parameterTypes));
762 | }
763 |
764 | /**
765 | * Look up and return a constructor if it exists.
766 | * See {@link #findMethodExactIfExists(String, ClassLoader, String, Object...)} for details.
767 | */
768 | public static Constructor findConstructorExactIfExists(Class clazz, Object... parameterTypes) {
769 | try {
770 | return findConstructorExact(clazz, parameterTypes);
771 | } catch (NoSuchMethodException | ClassNotFoundException e) {
772 | return null;
773 | }
774 | }
775 |
776 | /**
777 | * Look up a constructor of a class and set it to accessible.
778 | * See {@link #findMethodExact(String, ClassLoader, String, Object...)} for details.
779 | */
780 | public static Constructor findConstructorExact(String className, ClassLoader classLoader, Object... parameterTypes) throws NoSuchMethodException, ClassNotFoundException {
781 | return findConstructorExact(findClass(className, classLoader), getParameterClasses(classLoader, parameterTypes));
782 | }
783 |
784 | /**
785 | * Look up and return a constructor if it exists.
786 | * See {@link #findMethodExactIfExists(String, ClassLoader, String, Object...)} for details.
787 | */
788 | public static Constructor findConstructorExactIfExists(String className, ClassLoader classLoader, Object... parameterTypes) {
789 | try {
790 | return findConstructorExact(className, classLoader, parameterTypes);
791 | } catch (NoSuchMethodException | ClassNotFoundException e) {
792 | return null;
793 | }
794 | }
795 |
796 | /**
797 | * Look up a constructor of a class and set it to accessible.
798 | * See {@link #findMethodExact(String, ClassLoader, String, Object...)} for details.
799 | */
800 | public static Constructor findConstructorExact(Class clazz, Class... parameterTypes) throws NoSuchMethodException {
801 | var key = new MemberCacheKey.Constructor(clazz, parameterTypes, true);
802 |
803 | if (constructorCache.containsKey(key)) {
804 | Constructor constructor = constructorCache.get(key);
805 | if (constructor == getEmptyConstructor())
806 | throw new NoSuchMethodException(key.toString());
807 | return constructor;
808 | }
809 |
810 | try {
811 | Constructor constructor = key.clazz.getDeclaredConstructor(parameterTypes);
812 | constructor.setAccessible(true);
813 | constructorCache.put(key, constructor);
814 | return constructor;
815 | } catch (NoSuchMethodException e) {
816 | constructorCache.put(key, getEmptyConstructor());
817 | throw new NoSuchMethodException(key.toString());
818 | }
819 | }
820 |
821 | /**
822 | * Look up a constructor and hook it. See {@link #findAndHookMethod(String, ClassLoader, String, Object...)}
823 | * for details.
824 | */
825 | public static MapleBridge findAndHookConstructor(Class clazz, Object... parameterTypesAndCallback) throws NoSuchMethodException, ClassNotFoundException {
826 | if (parameterTypesAndCallback.length == 0 || !(parameterTypesAndCallback[parameterTypesAndCallback.length - 1] instanceof MethodHook))
827 | throw new IllegalArgumentException("no callback defined");
828 |
829 | MethodHook callback = (MethodHook) parameterTypesAndCallback[parameterTypesAndCallback.length - 1];
830 | Constructor m = findConstructorExact(clazz, getParameterClasses(clazz.getClassLoader(), parameterTypesAndCallback));
831 |
832 | return MapleBridge.hookMethod(m, callback);
833 | }
834 |
835 | /**
836 | * Look up a constructor and hook it. See {@link #findAndHookMethod(String, ClassLoader, String, Object...)}
837 | * for details.
838 | */
839 | public static MapleBridge findAndHookConstructor(String className, ClassLoader classLoader, Object... parameterTypesAndCallback) throws NoSuchMethodException, ClassNotFoundException {
840 | return findAndHookConstructor(findClass(className, classLoader), parameterTypesAndCallback);
841 | }
842 |
843 | /**
844 | * Look up a constructor in a class and set it to accessible.
845 | *
846 | * See {@link #findMethodBestMatch(Class, String, Class...)} for details.
847 | */
848 | public static Constructor findConstructorBestMatch(Class clazz, Class... parameterTypes) throws NoSuchMethodException {
849 | // then find the best match
850 | var key = new MemberCacheKey.Constructor(clazz, parameterTypes, false);
851 | if (constructorCache.containsKey(key)) {
852 | Constructor constructor = constructorCache.get(key);
853 | if (constructor == getEmptyConstructor())
854 | throw new NoSuchMethodException(key.toString());
855 | return constructor;
856 | }
857 |
858 | try {
859 | Constructor constructor = findConstructorExact(clazz, parameterTypes);
860 | constructorCache.put(key, constructor);
861 | return constructor;
862 | } catch (NoSuchMethodException ignored) { }
863 |
864 | Constructor bestMatch = null;
865 | Constructor[] constructors = key.clazz.getDeclaredConstructors();
866 | for (Constructor constructor : constructors) {
867 | // compare name and parameters
868 | if (ClassUtils.isAssignable(
869 | key.parameters,
870 | constructor.getParameterTypes(),
871 | true)) {
872 | // get accessible version of method
873 | if (bestMatch == null || MemberUtilsX.compareConstructorFit(
874 | constructor,
875 | bestMatch,
876 | key.parameters) < 0) {
877 | bestMatch = constructor;
878 | }
879 | }
880 | }
881 |
882 | if (bestMatch != null) {
883 | bestMatch.setAccessible(true);
884 | constructorCache.put(key, bestMatch);
885 | return bestMatch;
886 | } else {
887 | NoSuchMethodException e = new NoSuchMethodException(key.toString());
888 | constructorCache.put(key, getEmptyConstructor());
889 | throw e;
890 | }
891 | }
892 |
893 | /**
894 | * Look up a constructor in a class and set it to accessible.
895 | *
896 | * See {@link #findMethodBestMatch(Class, String, Class...)} for details. This variant
897 | * determines the parameter types from the classes of the given objects.
898 | */
899 | public static Constructor findConstructorBestMatch(Class clazz, Object... args) throws NoSuchMethodException {
900 | return findConstructorBestMatch(clazz, getParameterTypes(args));
901 | }
902 |
903 | /**
904 | * Look up a constructor in a class and set it to accessible.
905 | *
906 | * See {@link #findMethodBestMatch(Class, String, Class...)} for details. This variant
907 | * determines the parameter types from the classes of the given objects. For any item that is
908 | * {@code null}, the type is taken from {@code parameterTypes} instead.
909 | */
910 | public static Constructor findConstructorBestMatch(Class clazz, Class[] parameterTypes, Object[] args) throws NoSuchMethodException {
911 | Class[] argsClasses = null;
912 | for (int i = 0; i < parameterTypes.length; i++) {
913 | if (parameterTypes[i] != null)
914 | continue;
915 | if (argsClasses == null)
916 | argsClasses = getParameterTypes(args);
917 | parameterTypes[i] = argsClasses[i];
918 | }
919 | return findConstructorBestMatch(clazz, parameterTypes);
920 | }
921 |
922 |
923 | /**
924 | * Returns the index of the first parameter declared with the given type.
925 | *
926 | * @throws NoSuchFieldException() if there is no parameter with that type.
927 | * @hide
928 | */
929 | public static int getFirstParameterIndexByType(Member method, Class type) throws NoSuchFieldException {
930 | Class[] classes = (method instanceof Method) ?
931 | ((Method) method).getParameterTypes() : ((Constructor) method).getParameterTypes();
932 | for (int i = 0; i < classes.length; i++) {
933 | if (classes[i] == type) {
934 | return i;
935 | }
936 | }
937 | throw new NoSuchFieldException("No parameter of type " + type + " found in " + method);
938 | }
939 |
940 | /**
941 | * Returns the index of the parameter declared with the given type, ensuring that there is exactly one such parameter.
942 | *
943 | * @throws NoSuchFieldException() if there is no or more than one parameter with that type.
944 | * @hide
945 | */
946 | public static int getParameterIndexByType(Member method, Class type) throws NoSuchFieldException {
947 | Class[] classes = (method instanceof Method) ?
948 | ((Method) method).getParameterTypes() : ((Constructor) method).getParameterTypes();
949 | int idx = -1;
950 | for (int i = 0; i < classes.length; i++) {
951 | if (classes[i] == type) {
952 | if (idx == -1) {
953 | idx = i;
954 | } else {
955 | throw new NoSuchFieldException("More than one parameter of type " + type + " found in " + method);
956 | }
957 | }
958 | }
959 | if (idx != -1) {
960 | return idx;
961 | } else {
962 | throw new NoSuchFieldException("No parameter of type " + type + " found in " + method);
963 | }
964 | }
965 |
966 | //#################################################################################################
967 |
968 | /**
969 | * Sets the value of an object field in the given object instance. A class reference is not sufficient! See also {@link #findField}.
970 | */
971 | public static void setObjectField(Object obj, String fieldName, Object value) throws NoSuchFieldException, IllegalAccessException {
972 | try {
973 | findField(obj.getClass(), fieldName).set(obj, value);
974 | } catch (IllegalAccessException e) {
975 | // should not happen
976 | log(e);
977 | throw new IllegalAccessException(e.getMessage());
978 | } catch (IllegalArgumentException | NoSuchFieldException e) {
979 | throw e;
980 | }
981 | }
982 |
983 | /**
984 | * Sets the value of a {@code boolean} field in the given object instance. A class reference is not sufficient! See also {@link #findField}.
985 | */
986 | public static void setBooleanField(Object obj, String fieldName, boolean value) throws NoSuchFieldException, IllegalAccessException {
987 | try {
988 | findField(obj.getClass(), fieldName).setBoolean(obj, value);
989 | } catch (IllegalAccessException e) {
990 | // should not happen
991 | log(e);
992 | throw new IllegalAccessException(e.getMessage());
993 | } catch (IllegalArgumentException | NoSuchFieldException e) {
994 | throw e;
995 | }
996 | }
997 |
998 | /**
999 | * Sets the value of a {@code byte} field in the given object instance. A class reference is not sufficient! See also {@link #findField}.
1000 | */
1001 | public static void setByteField(Object obj, String fieldName, byte value) throws NoSuchFieldException, IllegalAccessException {
1002 | try {
1003 | findField(obj.getClass(), fieldName).setByte(obj, value);
1004 | } catch (IllegalAccessException e) {
1005 | // should not happen
1006 | log(e);
1007 | throw new IllegalAccessException(e.getMessage());
1008 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1009 | throw e;
1010 | }
1011 | }
1012 |
1013 | /**
1014 | * Sets the value of a {@code char} field in the given object instance. A class reference is not sufficient! See also {@link #findField}.
1015 | */
1016 | public static void setCharField(Object obj, String fieldName, char value) throws NoSuchFieldException, IllegalAccessException {
1017 | try {
1018 | findField(obj.getClass(), fieldName).setChar(obj, value);
1019 | } catch (IllegalAccessException e) {
1020 | // should not happen
1021 | log(e);
1022 | throw new IllegalAccessException(e.getMessage());
1023 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1024 | throw e;
1025 | }
1026 | }
1027 |
1028 | /**
1029 | * Sets the value of a {@code double} field in the given object instance. A class reference is not sufficient! See also {@link #findField}.
1030 | */
1031 | public static void setDoubleField(Object obj, String fieldName, double value) throws NoSuchFieldException, IllegalAccessException {
1032 | try {
1033 | findField(obj.getClass(), fieldName).setDouble(obj, value);
1034 | } catch (IllegalAccessException e) {
1035 | // should not happen
1036 | log(e);
1037 | throw new IllegalAccessException(e.getMessage());
1038 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1039 | throw e;
1040 | }
1041 | }
1042 |
1043 | /**
1044 | * Sets the value of a {@code float} field in the given object instance. A class reference is not sufficient! See also {@link #findField}.
1045 | */
1046 | public static void setFloatField(Object obj, String fieldName, float value) throws NoSuchFieldException, IllegalAccessException {
1047 | try {
1048 | findField(obj.getClass(), fieldName).setFloat(obj, value);
1049 | } catch (IllegalAccessException e) {
1050 | // should not happen
1051 | log(e);
1052 | throw new IllegalAccessException(e.getMessage());
1053 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1054 | throw e;
1055 | }
1056 | }
1057 |
1058 | /**
1059 | * Sets the value of an {@code int} field in the given object instance. A class reference is not sufficient! See also {@link #findField}.
1060 | */
1061 | public static void setIntField(Object obj, String fieldName, int value) throws NoSuchFieldException, IllegalAccessException {
1062 | try {
1063 | findField(obj.getClass(), fieldName).setInt(obj, value);
1064 | } catch (IllegalAccessException e) {
1065 | // should not happen
1066 | log(e);
1067 | throw new IllegalAccessException(e.getMessage());
1068 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1069 | throw e;
1070 | }
1071 | }
1072 |
1073 | /**
1074 | * Sets the value of a {@code long} field in the given object instance. A class reference is not sufficient! See also {@link #findField}.
1075 | */
1076 | public static void setLongField(Object obj, String fieldName, long value) throws NoSuchFieldException, IllegalAccessException {
1077 | try {
1078 | findField(obj.getClass(), fieldName).setLong(obj, value);
1079 | } catch (IllegalAccessException e) {
1080 | // should not happen
1081 | log(e);
1082 | throw new IllegalAccessException(e.getMessage());
1083 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1084 | throw e;
1085 | }
1086 | }
1087 |
1088 | /**
1089 | * Sets the value of a {@code short} field in the given object instance. A class reference is not sufficient! See also {@link #findField}.
1090 | */
1091 | public static void setShortField(Object obj, String fieldName, short value) throws NoSuchFieldException, IllegalAccessException {
1092 | try {
1093 | findField(obj.getClass(), fieldName).setShort(obj, value);
1094 | } catch (IllegalAccessException e) {
1095 | // should not happen
1096 | log(e);
1097 | throw new IllegalAccessException(e.getMessage());
1098 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1099 | throw e;
1100 | }
1101 | }
1102 |
1103 | //#################################################################################################
1104 |
1105 | /**
1106 | * Returns the value of an object field in the given object instance. A class reference is not sufficient! See also {@link #findField}.
1107 | */
1108 | public static Object getObjectField(Object obj, String fieldName) throws IllegalAccessException, NoSuchFieldException {
1109 | try {
1110 | return findField(obj.getClass(), fieldName).get(obj);
1111 | } catch (IllegalAccessException e) {
1112 | // should not happen
1113 | log(e);
1114 | throw new IllegalAccessException(e.getMessage());
1115 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1116 | throw e;
1117 | }
1118 | }
1119 |
1120 | /**
1121 | * For inner classes, returns the surrounding instance, i.e. the {@code this} reference of the surrounding class.
1122 | */
1123 | public static Object getSurroundingThis(Object obj) throws NoSuchFieldException, IllegalAccessException {
1124 | return getObjectField(obj, "this$0");
1125 | }
1126 |
1127 | /**
1128 | * Returns the value of a {@code boolean} field in the given object instance. A class reference is not sufficient! See also {@link #findField}.
1129 | */
1130 | @SuppressWarnings("BooleanMethodIsAlwaysInverted")
1131 | public static boolean getBooleanField(Object obj, String fieldName) throws IllegalAccessException, NoSuchFieldException {
1132 | try {
1133 | return findField(obj.getClass(), fieldName).getBoolean(obj);
1134 | } catch (IllegalAccessException e) {
1135 | // should not happen
1136 | log(e);
1137 | throw new IllegalAccessException(e.getMessage());
1138 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1139 | throw e;
1140 | }
1141 | }
1142 |
1143 | /**
1144 | * Returns the value of a {@code byte} field in the given object instance. A class reference is not sufficient! See also {@link #findField}.
1145 | */
1146 | public static byte getByteField(Object obj, String fieldName) throws IllegalAccessException, NoSuchFieldException {
1147 | try {
1148 | return findField(obj.getClass(), fieldName).getByte(obj);
1149 | } catch (IllegalAccessException e) {
1150 | // should not happen
1151 | log(e);
1152 | throw new IllegalAccessException(e.getMessage());
1153 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1154 | throw e;
1155 | }
1156 | }
1157 |
1158 | /**
1159 | * Returns the value of a {@code char} field in the given object instance. A class reference is not sufficient! See also {@link #findField}.
1160 | */
1161 | public static char getCharField(Object obj, String fieldName) throws NoSuchFieldException, IllegalAccessException {
1162 | try {
1163 | return findField(obj.getClass(), fieldName).getChar(obj);
1164 | } catch (IllegalAccessException e) {
1165 | // should not happen
1166 | log(e);
1167 | throw new IllegalAccessException(e.getMessage());
1168 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1169 | throw e;
1170 | }
1171 | }
1172 |
1173 | /**
1174 | * Returns the value of a {@code double} field in the given object instance. A class reference is not sufficient! See also {@link #findField}.
1175 | */
1176 | public static double getDoubleField(Object obj, String fieldName) throws IllegalAccessException, NoSuchFieldException {
1177 | try {
1178 | return findField(obj.getClass(), fieldName).getDouble(obj);
1179 | } catch (IllegalAccessException e) {
1180 | // should not happen
1181 | log(e);
1182 | throw new IllegalAccessException(e.getMessage());
1183 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1184 | throw e;
1185 | }
1186 | }
1187 |
1188 | /**
1189 | * Returns the value of a {@code float} field in the given object instance. A class reference is not sufficient! See also {@link #findField}.
1190 | */
1191 | public static float getFloatField(Object obj, String fieldName) throws NoSuchFieldException, IllegalAccessException {
1192 | try {
1193 | return findField(obj.getClass(), fieldName).getFloat(obj);
1194 | } catch (IllegalAccessException e) {
1195 | // should not happen
1196 | log(e);
1197 | throw new IllegalAccessException(e.getMessage());
1198 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1199 | throw e;
1200 | }
1201 | }
1202 |
1203 | /**
1204 | * Returns the value of an {@code int} field in the given object instance. A class reference is not sufficient! See also {@link #findField}.
1205 | */
1206 | public static int getIntField(Object obj, String fieldName) throws IllegalAccessException, NoSuchFieldException {
1207 | try {
1208 | return findField(obj.getClass(), fieldName).getInt(obj);
1209 | } catch (IllegalAccessException e) {
1210 | // should not happen
1211 | log(e);
1212 | throw new IllegalAccessException(e.getMessage());
1213 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1214 | throw e;
1215 | }
1216 | }
1217 |
1218 | /**
1219 | * Returns the value of a {@code long} field in the given object instance. A class reference is not sufficient! See also {@link #findField}.
1220 | */
1221 | public static long getLongField(Object obj, String fieldName) throws IllegalAccessException, NoSuchFieldException {
1222 | try {
1223 | return findField(obj.getClass(), fieldName).getLong(obj);
1224 | } catch (IllegalAccessException e) {
1225 | // should not happen
1226 | log(e);
1227 | throw new IllegalAccessException(e.getMessage());
1228 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1229 | throw e;
1230 | }
1231 | }
1232 |
1233 | /**
1234 | * Returns the value of a {@code short} field in the given object instance. A class reference is not sufficient! See also {@link #findField}.
1235 | */
1236 | public static short getShortField(Object obj, String fieldName) throws NoSuchFieldException, IllegalAccessException {
1237 | try {
1238 | return findField(obj.getClass(), fieldName).getShort(obj);
1239 | } catch (IllegalAccessException e) {
1240 | // should not happen
1241 | log(e);
1242 | throw new IllegalAccessException(e.getMessage());
1243 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1244 | throw e;
1245 | }
1246 | }
1247 |
1248 | //#################################################################################################
1249 |
1250 | /**
1251 | * Sets the value of a static object field in the given class. See also {@link #findField}.
1252 | */
1253 | public static void setStaticObjectField(Class clazz, String fieldName, Object value) throws NoSuchFieldException, IllegalAccessException {
1254 | try {
1255 | findField(clazz, fieldName).set(null, value);
1256 | } catch (IllegalAccessException e) {
1257 | // should not happen
1258 | log(e);
1259 | throw new IllegalAccessException(e.getMessage());
1260 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1261 | throw e;
1262 | }
1263 | }
1264 |
1265 | /**
1266 | * Sets the value of a static {@code boolean} field in the given class. See also {@link #findField}.
1267 | */
1268 | public static void setStaticBooleanField(Class clazz, String fieldName, boolean value) throws IllegalAccessException, NoSuchFieldException {
1269 | try {
1270 | findField(clazz, fieldName).setBoolean(null, value);
1271 | } catch (IllegalAccessException e) {
1272 | // should not happen
1273 | log(e);
1274 | throw new IllegalAccessException(e.getMessage());
1275 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1276 | throw e;
1277 | }
1278 | }
1279 |
1280 | /**
1281 | * Sets the value of a static {@code byte} field in the given class. See also {@link #findField}.
1282 | */
1283 | public static void setStaticByteField(Class clazz, String fieldName, byte value) throws NoSuchFieldException, IllegalAccessException {
1284 | try {
1285 | findField(clazz, fieldName).setByte(null, value);
1286 | } catch (IllegalAccessException e) {
1287 | // should not happen
1288 | log(e);
1289 | throw new IllegalAccessException(e.getMessage());
1290 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1291 | throw e;
1292 | }
1293 | }
1294 |
1295 | /**
1296 | * Sets the value of a static {@code char} field in the given class. See also {@link #findField}.
1297 | */
1298 | public static void setStaticCharField(Class clazz, String fieldName, char value) throws NoSuchFieldException, IllegalAccessException {
1299 | try {
1300 | findField(clazz, fieldName).setChar(null, value);
1301 | } catch (IllegalAccessException e) {
1302 | // should not happen
1303 | log(e);
1304 | throw new IllegalAccessException(e.getMessage());
1305 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1306 | throw e;
1307 | }
1308 | }
1309 |
1310 | /**
1311 | * Sets the value of a static {@code double} field in the given class. See also {@link #findField}.
1312 | */
1313 | public static void setStaticDoubleField(Class clazz, String fieldName, double value) throws NoSuchFieldException, IllegalAccessException {
1314 | try {
1315 | findField(clazz, fieldName).setDouble(null, value);
1316 | } catch (IllegalAccessException e) {
1317 | // should not happen
1318 | log(e);
1319 | throw new IllegalAccessException(e.getMessage());
1320 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1321 | throw e;
1322 | }
1323 | }
1324 |
1325 | /**
1326 | * Sets the value of a static {@code float} field in the given class. See also {@link #findField}.
1327 | */
1328 | public static void setStaticFloatField(Class clazz, String fieldName, float value) throws NoSuchFieldException, IllegalAccessException {
1329 | try {
1330 | findField(clazz, fieldName).setFloat(null, value);
1331 | } catch (IllegalAccessException e) {
1332 | // should not happen
1333 | log(e);
1334 | throw new IllegalAccessException(e.getMessage());
1335 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1336 | throw e;
1337 | }
1338 | }
1339 |
1340 | /**
1341 | * Sets the value of a static {@code int} field in the given class. See also {@link #findField}.
1342 | */
1343 | public static void setStaticIntField(Class clazz, String fieldName, int value) throws NoSuchFieldException, IllegalAccessException {
1344 | try {
1345 | findField(clazz, fieldName).setInt(null, value);
1346 | } catch (IllegalAccessException e) {
1347 | // should not happen
1348 | log(e);
1349 | throw new IllegalAccessException(e.getMessage());
1350 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1351 | throw e;
1352 | }
1353 | }
1354 |
1355 | /**
1356 | * Sets the value of a static {@code long} field in the given class. See also {@link #findField}.
1357 | */
1358 | public static void setStaticLongField(Class clazz, String fieldName, long value) throws IllegalAccessException, NoSuchFieldException {
1359 | try {
1360 | findField(clazz, fieldName).setLong(null, value);
1361 | } catch (IllegalAccessException e) {
1362 | // should not happen
1363 | log(e);
1364 | throw new IllegalAccessException(e.getMessage());
1365 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1366 | throw e;
1367 | }
1368 | }
1369 |
1370 | /**
1371 | * Sets the value of a static {@code short} field in the given class. See also {@link #findField}.
1372 | */
1373 | public static void setStaticShortField(Class clazz, String fieldName, short value) throws NoSuchFieldException, IllegalAccessException {
1374 | try {
1375 | findField(clazz, fieldName).setShort(null, value);
1376 | } catch (IllegalAccessException e) {
1377 | // should not happen
1378 | log(e);
1379 | throw new IllegalAccessException(e.getMessage());
1380 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1381 | throw e;
1382 | }
1383 | }
1384 |
1385 | //#################################################################################################
1386 |
1387 | /**
1388 | * Returns the value of a static object field in the given class. See also {@link #findField}.
1389 | */
1390 | public static Object getStaticObjectField(Class clazz, String fieldName) throws NoSuchFieldException, IllegalAccessException {
1391 | try {
1392 | return findField(clazz, fieldName).get(null);
1393 | } catch (IllegalAccessException e) {
1394 | // should not happen
1395 | log(e);
1396 | throw new IllegalAccessException(e.getMessage());
1397 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1398 | throw e;
1399 | }
1400 | }
1401 |
1402 | /**
1403 | * Returns the value of a static {@code boolean} field in the given class. See also {@link #findField}.
1404 | */
1405 | public static boolean getStaticBooleanField(Class clazz, String fieldName) throws NoSuchFieldException, IllegalAccessException {
1406 | try {
1407 | return findField(clazz, fieldName).getBoolean(null);
1408 | } catch (IllegalAccessException e) {
1409 | // should not happen
1410 | log(e);
1411 | throw new IllegalAccessException(e.getMessage());
1412 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1413 | throw e;
1414 | }
1415 | }
1416 |
1417 | /**
1418 | * Sets the value of a static {@code byte} field in the given class. See also {@link #findField}.
1419 | */
1420 | public static byte getStaticByteField(Class clazz, String fieldName) throws IllegalAccessException, NoSuchFieldException {
1421 | try {
1422 | return findField(clazz, fieldName).getByte(null);
1423 | } catch (IllegalAccessException e) {
1424 | // should not happen
1425 | log(e);
1426 | throw new IllegalAccessException(e.getMessage());
1427 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1428 | throw e;
1429 | }
1430 | }
1431 |
1432 | /**
1433 | * Sets the value of a static {@code char} field in the given class. See also {@link #findField}.
1434 | */
1435 | public static char getStaticCharField(Class clazz, String fieldName) throws IllegalAccessException, NoSuchFieldException {
1436 | try {
1437 | return findField(clazz, fieldName).getChar(null);
1438 | } catch (IllegalAccessException e) {
1439 | // should not happen
1440 | log(e);
1441 | throw new IllegalAccessException(e.getMessage());
1442 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1443 | throw e;
1444 | }
1445 | }
1446 |
1447 | /**
1448 | * Sets the value of a static {@code double} field in the given class. See also {@link #findField}.
1449 | */
1450 | public static double getStaticDoubleField(Class clazz, String fieldName) throws NoSuchFieldException, IllegalAccessException {
1451 | try {
1452 | return findField(clazz, fieldName).getDouble(null);
1453 | } catch (IllegalAccessException e) {
1454 | // should not happen
1455 | log(e);
1456 | throw new IllegalAccessException(e.getMessage());
1457 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1458 | throw e;
1459 | }
1460 | }
1461 |
1462 | /**
1463 | * Sets the value of a static {@code float} field in the given class. See also {@link #findField}.
1464 | */
1465 | public static float getStaticFloatField(Class clazz, String fieldName) throws IllegalAccessException, NoSuchFieldException {
1466 | try {
1467 | return findField(clazz, fieldName).getFloat(null);
1468 | } catch (IllegalAccessException e) {
1469 | // should not happen
1470 | log(e);
1471 | throw new IllegalAccessException(e.getMessage());
1472 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1473 | throw e;
1474 | }
1475 | }
1476 |
1477 | /**
1478 | * Sets the value of a static {@code int} field in the given class. See also {@link #findField}.
1479 | */
1480 | public static int getStaticIntField(Class clazz, String fieldName) throws IllegalAccessException, NoSuchFieldException {
1481 | try {
1482 | return findField(clazz, fieldName).getInt(null);
1483 | } catch (IllegalAccessException e) {
1484 | // should not happen
1485 | log(e);
1486 | throw new IllegalAccessException(e.getMessage());
1487 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1488 | throw e;
1489 | }
1490 | }
1491 |
1492 | /**
1493 | * Sets the value of a static {@code long} field in the given class. See also {@link #findField}.
1494 | */
1495 | public static long getStaticLongField(Class clazz, String fieldName) throws IllegalAccessException, NoSuchFieldException {
1496 | try {
1497 | return findField(clazz, fieldName).getLong(null);
1498 | } catch (IllegalAccessException e) {
1499 | // should not happen
1500 | log(e);
1501 | throw new IllegalAccessException(e.getMessage());
1502 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1503 | throw e;
1504 | }
1505 | }
1506 |
1507 | /**
1508 | * Sets the value of a static {@code short} field in the given class. See also {@link #findField}.
1509 | */
1510 | public static short getStaticShortField(Class clazz, String fieldName) throws IllegalAccessException, NoSuchFieldException {
1511 | try {
1512 | return findField(clazz, fieldName).getShort(null);
1513 | } catch (IllegalAccessException e) {
1514 | // should not happen
1515 | log(e);
1516 | throw new IllegalAccessException(e.getMessage());
1517 | } catch (IllegalArgumentException | NoSuchFieldException e) {
1518 | throw e;
1519 | }
1520 | }
1521 |
1522 | //#################################################################################################
1523 |
1524 | /**
1525 | * Calls an instance or static method of the given object.
1526 | * The method is resolved using {@link #findMethodBestMatch(Class, String, Object...)}.
1527 | *
1528 | * @param obj The object instance. A class reference is not sufficient!
1529 | * @param methodName The method name.
1530 | * @param args The arguments for the method call.
1531 | * @throws NoSuchMethodException In case no suitable method was found.
1532 | * @throws InvocationTargetException() In case an exception was thrown by the invoked method.
1533 | */
1534 | public static Object callMethod(Object obj, String methodName, Object... args) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
1535 | try {
1536 | return findMethodBestMatch(obj.getClass(), methodName, args).invoke(obj, args);
1537 | } catch (IllegalAccessException e) {
1538 | // should not happen
1539 | log(e);
1540 | throw new IllegalAccessException(e.getMessage());
1541 | } catch (IllegalArgumentException | InvocationTargetException | NoSuchMethodException e) {
1542 | throw e;
1543 | }
1544 | }
1545 |
1546 | /**
1547 | * Calls an instance or static method of the given object.
1548 | * See {@link #callMethod(Object, String, Object...)}.
1549 | *
1550 | * This variant allows you to specify parameter types, which can help in case there are multiple
1551 | * methods with the same name, especially if you call it with {@code null} parameters.
1552 | */
1553 | public static Object callMethod(Object obj, String methodName, Class[] parameterTypes, Object... args) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
1554 | try {
1555 | return findMethodBestMatch(obj.getClass(), methodName, parameterTypes, args).invoke(obj, args);
1556 | } catch (IllegalAccessException e) {
1557 | // should not happen
1558 | log(e);
1559 | throw new IllegalAccessException(e.getMessage());
1560 | } catch (IllegalArgumentException | InvocationTargetException | NoSuchMethodException e) {
1561 | throw e;
1562 | }
1563 | }
1564 |
1565 | /**
1566 | * Calls a static method of the given class.
1567 | * The method is resolved using {@link #findMethodBestMatch(Class, String, Object...)}.
1568 | *
1569 | * @param clazz The class reference.
1570 | * @param methodName The method name.
1571 | * @param args The arguments for the method call.
1572 | * @throws NoSuchMethodException In case no suitable method was found.
1573 | * @throws InvocationTargetException() In case an exception was thrown by the invoked method.
1574 | */
1575 | public static Object callStaticMethod(Class clazz, String methodName, Object... args) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
1576 | try {
1577 | return findMethodBestMatch(clazz, methodName, args).invoke(null, args);
1578 | } catch (IllegalAccessException e) {
1579 | // should not happen
1580 | log(e);
1581 | throw new IllegalAccessException(e.getMessage());
1582 | } catch (IllegalArgumentException | InvocationTargetException | NoSuchMethodException e) {
1583 | throw e;
1584 | }
1585 | }
1586 |
1587 | /**
1588 | * Calls a static method of the given class.
1589 | * See {@link #callStaticMethod(Class, String, Object...)}.
1590 | *
1591 | * This variant allows you to specify parameter types, which can help in case there are multiple
1592 | * methods with the same name, especially if you call it with {@code null} parameters.
1593 | */
1594 | public static Object callStaticMethod(Class clazz, String methodName, Class[] parameterTypes, Object... args) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
1595 | try {
1596 | return findMethodBestMatch(clazz, methodName, parameterTypes, args).invoke(null, args);
1597 | } catch (IllegalAccessException e) {
1598 | // should not happen
1599 | log(e);
1600 | throw new IllegalAccessException(e.getMessage());
1601 | } catch (IllegalArgumentException | InvocationTargetException | NoSuchMethodException e) {
1602 | throw e;
1603 | }
1604 | }
1605 |
1606 | //#################################################################################################
1607 |
1608 | /**
1609 | * Creates a new instance of the given class.
1610 | * The constructor is resolved using {@link #findConstructorBestMatch(Class, Object...)}.
1611 | *
1612 | * @param clazz The class reference.
1613 | * @param args The arguments for the constructor call.
1614 | * @throws NoSuchMethodException In case no suitable constructor was found.
1615 | * @throws java.lang.reflect.InvocationTargetException() In case an exception was thrown by the invoked method.
1616 | * @throws InstantiationError In case the class cannot be instantiated.
1617 | */
1618 | public static Object newInstance(Class clazz, Object... args) throws InstantiationException, InvocationTargetException, NoSuchMethodException, IllegalAccessException {
1619 | try {
1620 | return findConstructorBestMatch(clazz, args).newInstance(args);
1621 | } catch (IllegalAccessException e) {
1622 | // should not happen
1623 | log(e);
1624 | throw new IllegalAccessException(e.getMessage());
1625 | } catch (IllegalArgumentException | InvocationTargetException | InstantiationException | NoSuchMethodException e) {
1626 | throw e;
1627 | }
1628 | }
1629 |
1630 | /**
1631 | * Creates a new instance of the given class.
1632 | * See {@link #newInstance(Class, Object...)}.
1633 | *
1634 | * This variant allows you to specify parameter types, which can help in case there are multiple
1635 | * constructors with the same name, especially if you call it with {@code null} parameters.
1636 | */
1637 | public static Object newInstance(Class clazz, Class[] parameterTypes, Object... args) throws InvocationTargetException, InstantiationException, NoSuchMethodException, IllegalAccessException {
1638 | try {
1639 | return findConstructorBestMatch(clazz, parameterTypes, args).newInstance(args);
1640 | } catch (IllegalAccessException e) {
1641 | // should not happen
1642 | log(e);
1643 | throw new IllegalAccessException(e.getMessage());
1644 | } catch (IllegalArgumentException | InvocationTargetException | InstantiationException | NoSuchMethodException e) {
1645 | throw e;
1646 | }
1647 | }
1648 |
1649 | //#################################################################################################
1650 |
1651 | /**
1652 | * Attaches any value to an object instance. This simulates adding an instance field.
1653 | * The value can be retrieved again with {@link #getAdditionalInstanceField}.
1654 | *
1655 | * @param obj The object instance for which the value should be stored.
1656 | * @param key The key in the value map for this object instance.
1657 | * @param value The value to store.
1658 | * @return The previously stored value for this instance/key combination, or {@code null} if there was none.
1659 | */
1660 | public static Object setAdditionalInstanceField(Object obj, String key, Object value) {
1661 | if (obj == null)
1662 | throw new NullPointerException("object must not be null");
1663 | if (key == null)
1664 | throw new NullPointerException("key must not be null");
1665 |
1666 | HashMap The intention of the method depth counter is to keep track of the call depth for recursive
1825 | * methods, e.g. to override parameters only for the outer call. The Xposed framework uses this
1826 | * to load drawable replacements only once per call, even when multiple
1827 | * {@link Resources#getDrawable} variants call each other.
1828 | *
1829 | * @param method The method name. Should be prefixed with a unique, module-specific string.
1830 | * @return The updated depth.
1831 | */
1832 | public static int incrementMethodDepth(String method) {
1833 | return getMethodDepthCounter(method).get().incrementAndGet();
1834 | }
1835 |
1836 | /**
1837 | * Decrements the depth counter for the given method.
1838 | * See {@link #incrementMethodDepth} for details.
1839 | *
1840 | * @param method The method name. Should be prefixed with a unique, module-specific string.
1841 | * @return The updated depth.
1842 | */
1843 | public static int decrementMethodDepth(String method) {
1844 | return getMethodDepthCounter(method).get().decrementAndGet();
1845 | }
1846 |
1847 | /**
1848 | * Returns the current depth counter for the given method.
1849 | * See {@link #incrementMethodDepth} for details.
1850 | *
1851 | * @param method The method name. Should be prefixed with a unique, module-specific string.
1852 | * @return The updated depth.
1853 | */
1854 | public static int getMethodDepth(String method) {
1855 | return getMethodDepthCounter(method).get().get();
1856 | }
1857 |
1858 | private static ThreadLocal You can use {@link MapleBridge.MethodHookParam#setResult} and {@link MapleBridge.MethodHookParam#setThrowable}
13 | * to prevent the original method from being called.
14 | *
15 | * Note that implementations shouldn't call {@code super(param)}, it's not necessary.
16 | *
17 | * @param param Information about the method call.
18 | * @throws Throwable Everything the callback throws is caught and logged.
19 | */
20 | protected void beforeHookedMethod(MapleBridge.MethodHookParam param) throws Throwable {
21 | }
22 |
23 | /**
24 | * Called after the invocation of the method.
25 | *
26 | * You can use {@link MapleBridge.MethodHookParam#setResult} and {@link MapleBridge.MethodHookParam#setThrowable}
27 | * to modify the return value of the original method.
28 | *
29 | * Note that implementations shouldn't call {@code super(param)}, it's not necessary.
30 | *
31 | * @param param Information about the method call.
32 | * @throws Throwable Everything the callback throws is caught and logged.
33 | */
34 | protected void afterHookedMethod(MapleBridge.MethodHookParam param) throws Throwable {
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/maple/src/main/java/me/fycz/maple/MethodReplacement.java:
--------------------------------------------------------------------------------
1 | package me.fycz.maple;
2 |
3 |
4 | /**
5 | * A special case of {@link MethodHook} which completely replaces the original method.
6 | */
7 | public abstract class MethodReplacement extends MethodHook {
8 |
9 | /**
10 | * @hide
11 | */
12 | @Override
13 | protected final void beforeHookedMethod(MapleBridge.MethodHookParam param) throws Throwable {
14 | try {
15 | Object result = replaceHookedMethod(param);
16 | param.setResult(result);
17 | } catch (Throwable t) {
18 | MapleUtils.log(t);
19 | param.setThrowable(t);
20 | }
21 | }
22 |
23 | /**
24 | * @hide
25 | */
26 | @Override
27 | @SuppressWarnings("EmptyMethod")
28 | protected final void afterHookedMethod(MapleBridge.MethodHookParam param) throws Throwable {
29 | }
30 |
31 | /**
32 | * Shortcut for replacing a method completely. Whatever is returned/thrown here is taken
33 | * instead of the result of the original method (which will not be called).
34 | *
35 | * Note that implementations shouldn't call {@code super(param)}, it's not necessary.
36 | *
37 | * @param param Information about the method call.
38 | * @throws Throwable Anything that is thrown by the callback will be passed on to the original caller.
39 | */
40 | @SuppressWarnings("UnusedParameters")
41 | protected abstract Object replaceHookedMethod(MapleBridge.MethodHookParam param) throws Throwable;
42 |
43 | /**
44 | * Predefined callback that skips the method without replacements.
45 | */
46 | public static final MethodReplacement DO_NOTHING = new MethodReplacement() {
47 | @Override
48 | protected Object replaceHookedMethod(MapleBridge.MethodHookParam param) throws Throwable {
49 | return null;
50 | }
51 | };
52 |
53 | /**
54 | * Creates a callback which always returns a specific value.
55 | *
56 | * @param result The value that should be returned to callers of the hooked method.
57 | */
58 | public static MethodReplacement returnConstant(final Object result) {
59 | return new MethodReplacement() {
60 | @Override
61 | protected Object replaceHookedMethod(MapleBridge.MethodHookParam param) throws Throwable {
62 | return result;
63 | }
64 | };
65 | }
66 |
67 | }
68 |
--------------------------------------------------------------------------------
/maple/src/main/java/org/apache/commons/lang3/reflect/MemberUtilsX.java:
--------------------------------------------------------------------------------
1 | package org.apache.commons.lang3.reflect;
2 |
3 | import java.lang.reflect.Constructor;
4 | import java.lang.reflect.Method;
5 |
6 | /**
7 | * @author fengyue
8 | * @date 2022/3/28 16:16
9 | */
10 | public class MemberUtilsX {
11 | public static int compareConstructorFit(final Constructor left, final Constructor right, final Class[] actual) {
12 | return MemberUtils.compareConstructorFit(left, right, actual);
13 | }
14 |
15 | public static int compareMethodFit(final Method left, final Method right, final Class[] actual) {
16 | return MemberUtils.compareMethodFit(left, right, actual);
17 | }
18 | }
--------------------------------------------------------------------------------
/maple/src/main/jni/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | cmake_minimum_required(VERSION 3.18.1)
2 | project("Maple")
3 |
4 | set(CMAKE_CXX_STANDARD 20)
5 | set(CMAKE_CXX_STANDARD_REQUIRED ON)
6 |
7 | add_library(maple SHARED maple.cpp elf_util.cpp)
8 | find_package(dobby REQUIRED CONFIG)
9 | find_package(lsplant REQUIRED CONFIG)
10 | target_link_libraries(maple log dobby::dobby lsplant::lsplant)
11 |
--------------------------------------------------------------------------------
/maple/src/main/jni/elf_util.cpp:
--------------------------------------------------------------------------------
1 | #include
229 | *
234 | *
235 | * @param className The class name in one of the formats mentioned above.
236 | * @param classLoader The class loader, or {@code null} for the boot class loader.
237 | * @return A reference to the class.
238 | * @throws ClassNotFoundException In case the class was not found.
239 | */
240 | public static Class findClass(String className, ClassLoader classLoader) throws ClassNotFoundException {
241 | if (classLoader == null)
242 | classLoader = BOOTCLASSLOADER;
243 | try {
244 | return ClassUtils.getClass(classLoader, className, false);
245 | } catch (ClassNotFoundException e) {
246 | throw e;
247 | }
248 | }
249 | /**
250 | * Look up and return a class if it exists.
251 | * Like {@link #findClass}, but doesn't throw an exception if the class doesn't exist.
252 | *
253 | * @param className The class name.
254 | * @param classLoader The class loader, or {@code null} for the boot class loader.
255 | * @return A reference to the class, or {@code null} if it doesn't exist.
256 | */
257 | public static Class findClassIfExists(String className, ClassLoader classLoader) {
258 | try {
259 | return findClass(className, classLoader);
260 | } catch (ClassNotFoundException e) {
261 | return null;
262 | }
263 | }
264 |
265 | /**
266 | * Look up adn make a class inheritable.
267 | * It will make the class non-final and make all its private constructors protected.
268 | * @param className The class name.
269 | * @param classLoader The class loader, or {@code null} for the boot class loader.
270 | * @return Indicate whether the operation has succeed.
271 | */
272 | public static boolean findAndMakeClassInheritable(String className, ClassLoader classLoader) throws ClassNotFoundException {
273 | return MapleBridge.makeClassInheritable(findClass(className, classLoader));
274 | }
275 |
276 | /**
277 | * Look up a field in a class and set it to accessible.
278 | *
279 | * @param clazz The class which either declares or inherits the field.
280 | * @param fieldName The field name.
281 | * @return A reference to the field.
282 | * @throws NoSuchFieldException() In case the field was not found.
283 | */
284 | public static Field findField(Class clazz, String fieldName) throws NoSuchFieldException {
285 | var key = new MemberCacheKey.Field(clazz, fieldName);
286 | if (fieldCache.containsKey(key)) {
287 | Field field = fieldCache.get(key);
288 | if (field == getEmptyFiled())
289 | throw new NoSuchFieldException(key.toString());
290 | return field;
291 | }
292 | try {
293 | Field field = findFieldRecursiveImpl(key.clazz, key.name);
294 | field.setAccessible(true);
295 | fieldCache.put(key, field);
296 | return field;
297 | } catch (NoSuchFieldException e) {
298 | fieldCache.put(key, getEmptyFiled());
299 | throw new NoSuchFieldException(key.toString());
300 | }
301 | }
302 |
303 | /**
304 | * Look up and return a field if it exists.
305 | * Like {@link #findField}, but doesn't throw an exception if the field doesn't exist.
306 | *
307 | * @param clazz The class which either declares or inherits the field.
308 | * @param fieldName The field name.
309 | * @return A reference to the field, or {@code null} if it doesn't exist.
310 | */
311 | public static Field findFieldIfExists(Class clazz, String fieldName) {
312 | try {
313 | return findField(clazz, fieldName);
314 | } catch (NoSuchFieldException e) {
315 | return null;
316 | }
317 | }
318 |
319 | private static Field findFieldRecursiveImpl(Class clazz, String fieldName) throws NoSuchFieldException {
320 | try {
321 | return clazz.getDeclaredField(fieldName);
322 | } catch (NoSuchFieldException e) {
323 | while (true) {
324 | clazz = clazz.getSuperclass();
325 | if (clazz == null || clazz.equals(Object.class))
326 | break;
327 |
328 | try {
329 | return clazz.getDeclaredField(fieldName);
330 | } catch (NoSuchFieldException ignored) {
331 | }
332 | }
333 | throw e;
334 | }
335 | }
336 |
337 | /**
338 | * Returns the first field of the given type in a class.
339 | * Might be useful for Proguard'ed classes to identify fields with unique types.
340 | *
341 | * @param clazz The class which either declares or inherits the field.
342 | * @param type The type of the field.
343 | * @return A reference to the first field of the given type.
344 | * @throws NoSuchFieldException() In case no matching field was not found.
345 | */
346 | public static Field findFirstFieldByExactType(Class clazz, Class type) throws NoSuchFieldException {
347 | Class clz = clazz;
348 | do {
349 | for (Field field : clz.getDeclaredFields()) {
350 | if (field.getType() == type) {
351 | field.setAccessible(true);
352 | return field;
353 | }
354 | }
355 | } while ((clz = clz.getSuperclass()) != null);
356 |
357 | throw new NoSuchFieldException("Field of type " + type.getName() + " in class " + clazz.getName());
358 | }
359 |
360 | /**
361 | * Look up a method and hook it. See {@link #findAndHookMethod(String, ClassLoader, String, Object...)}
362 | * for details.
363 | */
364 | public static MapleBridge findAndHookMethod(Class clazz, String methodName, Object... parameterTypesAndCallback) throws ClassNotFoundException, NoSuchMethodException {
365 | if (parameterTypesAndCallback.length == 0 || !(parameterTypesAndCallback[parameterTypesAndCallback.length - 1] instanceof MethodHook))
366 | throw new IllegalArgumentException("no callback defined");
367 |
368 | MethodHook callback = (MethodHook) parameterTypesAndCallback[parameterTypesAndCallback.length - 1];
369 | Method m = findMethodExact(clazz, methodName, getParameterClasses(clazz.getClassLoader(), parameterTypesAndCallback));
370 |
371 | return MapleBridge.hookMethod(m, callback);
372 | }
373 |
374 | /**
375 | * Look up a method and hook it. The last argument must be the callback for the hook.
376 | *
377 | *
409 | * // In order to hook this method ...
410 | * package com.example;
411 | * public class SomeClass {
412 | * public int doSomething(String s, int i, MyClass m) {
413 | * ...
414 | * }
415 | * }
416 | *
417 | * // ... you can use this call:
418 | * findAndHookMethod("com.example.SomeClass", lpparam.classLoader, String.class, int.class, "com.example.MyClass", new MethodHook() {
419 | * @Override
420 | * protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
421 | * String oldText = (String) param.args[0];
422 | * Log.d("MyModule", oldText);
423 | *
424 | * param.args[0] = "test";
425 | * param.args[1] = 42; // auto-boxing is working here
426 | * setBooleanField(param.args[2], "great", true);
427 | *
428 | * // This would not work (as MyClass can't be resolved at compile time):
429 | * // MyClass myClass = (MyClass) param.args[2];
430 | * // myClass.great = true;
431 | * }
432 | * });
433 | *
434 | *
435 | * @param className The name of the class which implements the method.
436 | * @param classLoader The class loader for resolving the target and parameter classes.
437 | * @param methodName The target method name.
438 | * @param parameterTypesAndCallback The parameter types of the target method, plus the callback.
439 | * @return An object which can be used to remove the callback again.
440 | * @throws NoSuchMethodException In case the method was not found.
441 | * @throws ClassNotFoundException In case the target class or one of the parameter types couldn't be resolved.
442 | */
443 | public static MapleBridge findAndHookMethod(String className, ClassLoader classLoader, String methodName, Object... parameterTypesAndCallback) throws ClassNotFoundException, NoSuchMethodException {
444 | return findAndHookMethod(findClass(className, classLoader), methodName, parameterTypesAndCallback);
445 | }
446 |
447 | /**
448 | * Look up a method and judge it hooked whether or not. See {@link #findMethodIsHooked(String, ClassLoader, String, Object...)}
449 | * for details.
450 | */
451 | public static boolean findMethodIsHooked(Class clazz, String methodName, Object... parameterTypes) throws ClassNotFoundException, NoSuchMethodException {
452 | return MapleBridge.isHooked(findMethodExact(clazz, methodName, parameterTypes));
453 | }
454 |
455 | /**
456 | * Look up a method and judge it hooked whether or not.
457 | * @param className The name of the class which implements the method.
458 | * @param classLoader The class loader for resolving the target and parameter classes.
459 | * @param methodName The target method name.
460 | * @param parameterTypes The parameter types of the target method.
461 | * @return The method is hooked whether or not.
462 | * @throws NoSuchMethodException In case the method was not found.
463 | * @throws ClassNotFoundException In case the target class or one of the parameter types couldn't be resolved.
464 | */
465 | public static boolean findMethodIsHooked(String className, ClassLoader classLoader, String methodName, Object... parameterTypes) throws ClassNotFoundException, NoSuchMethodException {
466 | return MapleBridge.isHooked(findMethodExact(findClass(className, classLoader), methodName, parameterTypes));
467 | }
468 |
469 | /**
470 | * Look up a method in a class and set it to accessible.
471 | * See {@link #findMethodExact(String, ClassLoader, String, Object...)} for details.
472 | */
473 | public static Method findMethodExact(Class clazz, String methodName, Object... parameterTypes) throws ClassNotFoundException, NoSuchMethodException {
474 | return findMethodExact(clazz, methodName, getParameterClasses(clazz.getClassLoader(), parameterTypes));
475 | }
476 |
477 | /**
478 | * Look up and return a method if it exists.
479 | * See {@link #findMethodExactIfExists(String, ClassLoader, String, Object...)} for details.
480 | */
481 | public static Method findMethodExactIfExists(Class clazz, String methodName, Object... parameterTypes) {
482 | try {
483 | return findMethodExact(clazz, methodName, parameterTypes);
484 | } catch (ClassNotFoundException | NoSuchMethodException e) {
485 | return null;
486 | }
487 | }
488 |
489 | /**
490 | * Look up a method in a class and set it to accessible.
491 | * The method must be declared or overridden in the given class.
492 | *
493 | *