static jobject Class_getDeclaredMethodInternal(JNIEnv* env, jobject javaThis,jstring name, jobjectArray args) {ScopedFastNativeObjectAccess soa(env);StackHandleScope<1> hs(soa.Self());DCHECK_EQ(Runtime::Current()->GetClassLinker()->GetImagePointerSize(), kRuntimePointerSize);DCHECK(!Runtime::Current()->IsActiveTransaction());Handle<mirror::Method> result = hs.NewHandle(mirror::Class::GetDeclaredMethodInternal<kRuntimePointerSize, false>(soa.Self(),DecodeClass(soa, javaThis),soa.Decode<mirror::String>(name),soa.Decode<mirror::ObjectArray<mirror::Class>>(args)));if (result == nullptr || ShouldBlockAccessToMember(result->GetArtMethod(), soa.Self())) {return nullptr;}return soa.AddLocalReference<jobject>(result.Get());
}

ALWAYS_INLINE static bool ShouldBlockAccessToMember(T* member, Thread* self)REQUIRES_SHARED(Locks::mutator_lock_) {hiddenapi::Action action = hiddenapi::GetMemberAction(member, self, IsCallerTrusted, hiddenapi::kReflection);if (action != hiddenapi::kAllow) {hiddenapi::NotifyHiddenApiListener(member);}return action == hiddenapi::kDeny;
}

template<typename T>
inline Action GetMemberAction(T* member,Thread* self,std::function<bool(Thread*)> fn_caller_is_trusted,AccessMethod access_method)REQUIRES_SHARED(Locks::mutator_lock_) {DCHECK(member != nullptr);// Decode hidden API access flags.// NB Multiple threads might try to access (and overwrite) these simultaneously,// causing a race. We only do that if access has not been denied, so the race// cannot change Java semantics. We should, however, decode the access flags// once and use it throughout this function, otherwise we may get inconsistent// results, e.g. print whitelist warnings (b/78327881).HiddenApiAccessFlags::ApiList api_list = member->GetHiddenApiAccessFlags();Action action = GetActionFromAccessFlags(member->GetHiddenApiAccessFlags());if (action == kAllow) {// Nothing to do.return action;}// Member is hidden. Invoke `fn_caller_in_platform` and find the origin of the access.// This can be *very* expensive. Save it for last.if (fn_caller_is_trusted(self)) {// Caller is trusted. Exit.return kAllow;}// Member is hidden and caller is not in the platform.return detail::GetMemberActionImpl(member, api_list, action, access_method);
}

inline Action GetActionFromAccessFlags(HiddenApiAccessFlags::ApiList api_list) {if (api_list == HiddenApiAccessFlags::kWhitelist) {return kAllow;}EnforcementPolicy policy = Runtime::Current()->GetHiddenApiEnforcementPolicy();if (policy == EnforcementPolicy::kNoChecks) {// Exit early. Nothing to enforce.return kAllow;}// if policy is "just warn", always warn. We returned above for whitelist APIs.if (policy == EnforcementPolicy::kJustWarn) {return kAllowButWarn;}// 略。。。
}

hiddenapi::EnforcementPolicy GetHiddenApiEnforcementPolicy() const {return hidden_api_policy_;
}

JavaVM *javaVM;
env->GetJavaVM(&javaVM);
JavaVMExt *javaVMExt = (JavaVMExt *) javaVM;
void *runtime = javaVMExt->runtime;

struct Runtime {// 64 bit so that we can share the same asm offsets for both 32 and 64 bits.uint64_t callee_save_methods_[kCalleeSaveSize];// Pre-allocated exceptions (see Runtime::Init).GcRoot<mirror::Throwable> pre_allocated_OutOfMemoryError_when_throwing_exception_;GcRoot<mirror::Throwable> pre_allocated_OutOfMemoryError_when_throwing_oome_;GcRoot<mirror::Throwable> pre_allocated_OutOfMemoryError_when_handling_stack_overflow_;GcRoot<mirror::Throwable> pre_allocated_NoClassDefFoundError_;// ... （省略大量成员)  std::unique_ptr<JavaVMExt> java_vm_;// ... （省略大量成员)// Specifies target SDK version to allow workarounds for certain API levels.int32_t target_sdk_version_;// ... （省略大量成员)bool is_low_memory_mode_;// Whether or not we use MADV_RANDOM on files that are thought to have random access patterns.// This is beneficial for low RAM devices since it reduces page cache thrashing.bool madvise_random_access_;// Whether the application should run in safe mode, that is, interpreter only.bool safe_mode_;// ... （省略大量成员)
}

int unseal(JNIEnv *env, jint targetSdkVersion) {JavaVM *javaVM;env->GetJavaVM(&javaVM);JavaVMExt *javaVMExt = (JavaVMExt *) javaVM;void *runtime = javaVMExt->runtime;const int MAX = 1000;int offsetOfVmExt = findOffset(runtime, 0, MAX, (size_t) javaVMExt);int targetSdkVersionOffset = findOffset(runtime, offsetOfVmExt, MAX, targetSdkVersion);PartialRuntime *partialRuntime = (PartialRuntime *) ((char *) runtime + targetSdkVersionOffset);EnforcementPolicy policy = partialRuntime->hidden_api_policy_;partialRuntime->hidden_api_policy_ = EnforcementPolicy::kNoChecks;return 0;
}

public final class Class<T> implements java.io.Serializable,GenericDeclaration,Type,AnnotatedElement {/** defining class loader, or null for the "bootstrap" system loader. */private transient ClassLoader classLoader;// 略
}

public class Object {private transient Class<?> shadow$_klass_;private transient int shadow$_monitor_;}

struct Class {Class<?> shadow$_klass_;int shadow$_monitor_;ClassLoader classLoader;
}

if (shouldWarn || action == kDeny) {if (member_signature.IsExempted(runtime->GetHiddenApiExemptions())) {action = kAllow;// Avoid re-examining the exemption list next time.// Note this results in no warning for the member, which seems like what one would expect.// Exemptions effectively adds new members to the whitelist.MaybeWhitelistMember(runtime, member);return kAllow;}// 略
}