int result = ActivityManagerNative.getDefault()
            .startActivity(whoThread, who.getBasePackageName(), intent,
                    intent.resolveTypeIfNeeded(who.getContentResolver()),
                    token, target != null ? target.mEmbeddedID : null,
                    requestCode, 0, null, null, options);
        checkStartActivityResult(result, intent);

@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
        Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
        int startFlags, ProfilerInfo profilerInfo, Bundle options) {
    return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
        resultWho, requestCode, startFlags, profilerInfo, options,
        UserHandle.getCallingUserId());
}
@Override
public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
        Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
        int startFlags, ProfilerInfo profilerInfo, Bundle options, int userId) {
    enforceNotIsolatedCaller("startActivity");
    userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId,
            false, ALLOW_FULL_ONLY, "startActivity", null);
    // TODO: Switch to user app stacks here.
    return mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent,
            resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
            profilerInfo, null, null, options, userId, null, null);
}

    /**
     * Returns the top activity in any existing task matching the given
     * Intent.  Returns null if no such task is found.
     */
    ActivityRecord findTaskLocked(ActivityRecord target) {
        Intent intent = target.intent;
        ActivityInfo info = target.info;
        ComponentName cls = intent.getComponent();
        if (info.targetActivity != null) {
            cls = new ComponentName(info.packageName, info.targetActivity);
        }
        final int userId = UserHandle.getUserId(info.applicationInfo.uid);
        boolean isDocument = intent != null & intent.isDocument();
        // If documentData is non-null then it must match the existing task data.
        Uri documentData = isDocument ? intent.getData() : null;

        if (DEBUG_TASKS) Slog.d(TAG, "Looking for task of " + target + " in " + this);
        for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
            final TaskRecord task = mTaskHistory.get(taskNdx);
            if (task.voiceSession != null) {
                // We never match voice sessions; those always run independently.
                if (DEBUG_TASKS) Slog.d(TAG, "Skipping " + task + ": voice session");
                continue;
            }
            if (task.userId != userId) {
                // Looking for a different task.
                if (DEBUG_TASKS) Slog.d(TAG, "Skipping " + task + ": different user");
                continue;
            }
            final ActivityRecord r = task.getTopActivity();
            if (r == null || r.finishing || r.userId != userId ||
                    r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {
                if (DEBUG_TASKS) Slog.d(TAG, "Skipping " + task + ": mismatch root " + r);
                continue;
            }

            final Intent taskIntent = task.intent;
            final Intent affinityIntent = task.affinityIntent;
            final boolean taskIsDocument;
            final Uri taskDocumentData;
            if (taskIntent != null && taskIntent.isDocument()) {
                taskIsDocument = true;
                taskDocumentData = taskIntent.getData();
            } else if (affinityIntent != null && affinityIntent.isDocument()) {
                taskIsDocument = true;
                taskDocumentData = affinityIntent.getData();
            } else {
                taskIsDocument = false;
                taskDocumentData = null;
            }

            if (DEBUG_TASKS) Slog.d(TAG, "Comparing existing cls="
                    + taskIntent.getComponent().flattenToShortString()
                    + "/aff=" + r.task.rootAffinity + " to new cls="
                    + intent.getComponent().flattenToShortString() + "/aff=" + info.taskAffinity);
            if (!isDocument && !taskIsDocument && task.rootAffinity != null) {
                if (task.rootAffinity.equals(target.taskAffinity)) {
                    if (DEBUG_TASKS) Slog.d(TAG, "Found matching affinity!");
                    return r;
                }
            } else if (taskIntent != null && taskIntent.getComponent() != null &&
                    taskIntent.getComponent().compareTo(cls) == 0 &&
                    Objects.equals(documentData, taskDocumentData)) {
                if (DEBUG_TASKS) Slog.d(TAG, "Found matching class!");
                //dump();
                if (DEBUG_TASKS) Slog.d(TAG, "For Intent " + intent + " bringing to top: "
                        + r.intent);
                return r;
            } else if (affinityIntent != null && affinityIntent.getComponent() != null &&
                    affinityIntent.getComponent().compareTo(cls) == 0 &&
                    Objects.equals(documentData, taskDocumentData)) {
                if (DEBUG_TASKS) Slog.d(TAG, "Found matching class!");
                //dump();
                if (DEBUG_TASKS) Slog.d(TAG, "For Intent " + intent + " bringing to top: "
                        + r.intent);
                return r;
            } else if (DEBUG_TASKS) {
                Slog.d(TAG, "Not a match: " + task);
            }
        }
    return null;
}

// If the caller has requested that the target task be
// reset, then do so.
if ((launchFlags&Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) {
    intentActivity = targetStack.resetTaskIfNeededLocked(intentActivity, r);
}
if ((startFlags&ActivityManager.START_FLAG_ONLY_IF_NEEDED) != 0) {
    // We don't need to start a new activity, and
    // the client said not to do anything if that
    // is the case, so this is it!  And for paranoia, make
    // sure we have correctly resumed the top activity.
    if (doResume) {
        resumeTopActivitiesLocked(targetStack, null, options);
    } else {
        ActivityOptions.abort(options);
    }
    return ActivityManager.START_RETURN_INTENT_TO_CALLER;
}
if ((launchFlags &
        (Intent.FLAG_ACTIVITY_NEW_TASK|Intent.FLAG_ACTIVITY_CLEAR_TASK))
        == (Intent.FLAG_ACTIVITY_NEW_TASK|Intent.FLAG_ACTIVITY_CLEAR_TASK)) {
    // The caller has requested to completely replace any
    // existing task with its new activity.  Well that should
    // not be too hard...
    reuseTask = intentActivity.task;
    reuseTask.performClearTaskLocked();
    reuseTask.setIntent(r);
} else if ((launchFlags&Intent.FLAG_ACTIVITY_CLEAR_TOP) != 0
        || launchSingleInstance || launchSingleTask) {
    // In this situation we want to remove all activities
    // from the task up to the one being started.  In most
    // cases this means we are resetting the task to its
    // initial state.
    ActivityRecord top =
            intentActivity.task.performClearTaskLocked(r, launchFlags);
    if (top != null) {
        if (top.frontOfTask) {
            // Activity aliases may mean we use different
            // intents for the top activity, so make sure
            // the task now has the identity of the new
            // intent.
            top.task.setIntent(r);
        }
        ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT,
                r, top.task);
        top.deliverNewIntentLocked(callingUid, r.intent);
    } else {
        // A special case: we need to
        // start the activity because it is not currently
        // running, and the caller has asked to clear the
        // current task to have this activity at the top.
        addingToTask = true;
        // Now pretend like this activity is being started
        // by the top of its task, so it is put in the
        // right place.
        sourceRecord = intentActivity;
    }
} else if (r.realActivity.equals(intentActivity.task.realActivity)) {
    // In this case the top activity on the task is the
    // same as the one being launched, so we take that
    // as a request to bring the task to the foreground.
    // If the top activity in the task is the root
    // activity, deliver this new intent to it if it
    // desires.
    if (((launchFlags&Intent.FLAG_ACTIVITY_SINGLE_TOP) != 0 || launchSingleTop)
            && intentActivity.realActivity.equals(r.realActivity)) {
        ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT, r,
                intentActivity.task);
        if (intentActivity.frontOfTask) {
            intentActivity.task.setIntent(r);
        }
        intentActivity.deliverNewIntentLocked(callingUid, r.intent);
    } else if (!r.intent.filterEquals(intentActivity.task.intent)) {
        // In this case we are launching the root activity
        // of the task, but with a different intent.  We
        // should start a new instance on top.
        addingToTask = true;
        sourceRecord = intentActivity;
    }
} else if ((launchFlags&Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) == 0) {
    // In this case an activity is being launched in to an
    // existing task, without resetting that task.  This
    // is typically the situation of launching an activity
    // from a notification or shortcut.  We want to place
    // the new activity on top of the current task.
    addingToTask = true;
    sourceRecord = intentActivity;
} else if (!intentActivity.task.rootWasReset) {
    // In this case we are launching in to an existing task
    // that has not yet been started from its front door.
    // The current task has been brought to the front.
    // Ideally, we'd probably like to place this new task
    // at the bottom of its stack, but that's a little hard
    // to do with the current organization of the code so
    // for now we'll just drop it.
    intentActivity.task.setIntent(r);
}
if (!addingToTask && reuseTask == null) {
    // We didn't do anything...  but it was needed (a.k.a., client
    // don't use that intent!)  And for paranoia, make
    // sure we have correctly resumed the top activity.
    if (doResume) {
        targetStack.resumeTopActivityLocked(null, options);
    } else {
        ActivityOptions.abort(options);
    }
    return ActivityManager.START_TASK_TO_FRONT;
}

/**
    * Perform clear operation as requested by
    * {@link Intent#FLAG_ACTIVITY_CLEAR_TOP}: search from the top of the
    * stack to the given task, then look for
    * an instance of that activity in the stack and, if found, finish all
    * activities on top of it and return the instance.
    *
    * @param newR Description of the new activity being started.
    * @return Returns the old activity that should be continued to be used,
    * or null if none was found.
    */
   final ActivityRecord performClearTaskLocked(ActivityRecord newR, int launchFlags) {
       int numActivities = mActivities.size();
       for (int activityNdx = numActivities - 1; activityNdx >= 0; --activityNdx) {
           ActivityRecord r = mActivities.get(activityNdx);
           if (r.finishing) {
               continue;
           }
           if (r.realActivity.equals(newR.realActivity)) {
               // Here it is!  Now finish everything in front...
               final ActivityRecord ret = r;

               for (++activityNdx; activityNdx < numActivities; ++activityNdx) {
                   r = mActivities.get(activityNdx);
                   if (r.finishing) {
                       continue;
                   }
                   ActivityOptions opts = r.takeOptionsLocked();
                   if (opts != null) {
                       ret.updateOptionsLocked(opts);
                   }
                   if (stack.finishActivityLocked(r, Activity.RESULT_CANCELED, null, "clear",
                           false)) {
                       --activityNdx;
                       --numActivities;
                   }
               }

               // Finally, if this is a normal launch mode (that is, not
               // expecting onNewIntent()), then we will finish the current
               // instance of the activity so a new fresh one can be started.
               if (ret.launchMode == ActivityInfo.LAUNCH_MULTIPLE
                       && (launchFlags & Intent.FLAG_ACTIVITY_SINGLE_TOP) == 0) {
                   if (!ret.finishing) {
                       stack.finishActivityLocked(ret, Activity.RESULT_CANCELED, null,
                               "clear", false);
                       return null;
                   }
               }

               return ret;
           }
       }

       return null;
   }

if (r.packageName != null) {
    // If the activity being launched is the same as the one currently
    // at the top, then we need to check if it should only be launched
    // once.
    ActivityStack topStack = getFocusedStack();
    ActivityRecord top = topStack.topRunningNonDelayedActivityLocked(notTop);
    if (top != null && r.resultTo == null) {
        if (top.realActivity.equals(r.realActivity) && top.userId == r.userId) {
            if (top.app != null && top.app.thread != null) {
                if ((launchFlags & Intent.FLAG_ACTIVITY_SINGLE_TOP) != 0
                    || launchSingleTop || launchSingleTask) {
                    ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT, top,
                            top.task);
                    // For paranoia, make sure we have correctly
                    // resumed the top activity.
                    topStack.mLastPausedActivity = null;
                    if (doResume) {
                        resumeTopActivitiesLocked();
                    }
                    ActivityOptions.abort(options);
                    if ((startFlags&ActivityManager.START_FLAG_ONLY_IF_NEEDED) != 0) {
                        // We don't need to start a new activity, and
                        // the client said not to do anything if that
                        // is the case, so this is it!
                        return ActivityManager.START_RETURN_INTENT_TO_CALLER;
                    }
                    top.deliverNewIntentLocked(callingUid, r.intent);
                    return ActivityManager.START_DELIVERED_TO_TOP;
                }
            }
        }
    }

} else {
    if (r.resultTo != null) {
        r.resultTo.task.stack.sendActivityResultLocked(-1, r.resultTo, r.resultWho,
                r.requestCode, Activity.RESULT_CANCELED, null);
    }
    ActivityOptions.abort(options);
    return ActivityManager.START_CLASS_NOT_FOUND;
}

    boolean newTask = false;
    boolean keepCurTransition = false;

    TaskRecord taskToAffiliate = launchTaskBehind && sourceRecord != null ?
            sourceRecord.task : null;

    // Should this be considered a new task?
    if (r.resultTo == null && inTask == null && !addingToTask
            && (launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {
        if (isLockTaskModeViolation(reuseTask)) {
            Slog.e(TAG, "Attempted Lock Task Mode violation r=" + r);
            return ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION;
        }
        newTask = true;
        targetStack = adjustStackFocus(r, newTask);
        if (!launchTaskBehind) {
            targetStack.moveToFront();
        }
        if (reuseTask == null) {
            r.setTask(targetStack.createTaskRecord(getNextTaskId(),
                    newTaskInfo != null ? newTaskInfo : r.info,
                    newTaskIntent != null ? newTaskIntent : intent,
                    voiceSession, voiceInteractor, !launchTaskBehind /* toTop */),
                    taskToAffiliate);
            if (DEBUG_TASKS) Slog.v(TAG, "Starting new activity " + r + " in new task " +
                    r.task);
        } else {
            r.setTask(reuseTask, taskToAffiliate);
        }
        if (!movedHome) {
            if ((launchFlags &
                    (Intent.FLAG_ACTIVITY_NEW_TASK|Intent.FLAG_ACTIVITY_TASK_ON_HOME))
                    == (Intent.FLAG_ACTIVITY_NEW_TASK|Intent.FLAG_ACTIVITY_TASK_ON_HOME)) {
                // Caller wants to appear on home activity, so before starting
                // their own activity we will bring home to the front.
                r.task.setTaskToReturnTo(HOME_ACTIVITY_TYPE);
            }
        }
    } else if (sourceRecord != null) {
        final TaskRecord sourceTask = sourceRecord.task;
        if (isLockTaskModeViolation(sourceTask)) {
            Slog.e(TAG, "Attempted Lock Task Mode violation r=" + r);
            return ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION;
        }
        targetStack = sourceTask.stack;
        targetStack.moveToFront();
        final TaskRecord topTask = targetStack.topTask();
        if (topTask != sourceTask) {
            targetStack.moveTaskToFrontLocked(sourceTask, r, options);
        } else {
            mWindowManager.moveTaskToTop(topTask.taskId);
        }
        if (!addingToTask && (launchFlags&Intent.FLAG_ACTIVITY_CLEAR_TOP) != 0) {
            // In this case, we are adding the activity to an existing
            // task, but the caller has asked to clear that task if the
            // activity is already running.
            ActivityRecord top = sourceTask.performClearTaskLocked(r, launchFlags);
            keepCurTransition = true;
            if (top != null) {
                ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT, r, top.task);
                top.deliverNewIntentLocked(callingUid, r.intent);
                // For paranoia, make sure we have correctly
                // resumed the top activity.
                targetStack.mLastPausedActivity = null;
                if (doResume) {
                    targetStack.resumeTopActivityLocked(null);
                }
                ActivityOptions.abort(options);
                return ActivityManager.START_DELIVERED_TO_TOP;
            }
        } else if (!addingToTask &&
                (launchFlags&Intent.FLAG_ACTIVITY_REORDER_TO_FRONT) != 0) {
            // In this case, we are launching an activity in our own task
            // that may already be running somewhere in the history, and
            // we want to shuffle it to the front of the stack if so.
            final ActivityRecord top = sourceTask.findActivityInHistoryLocked(r);
            if (top != null) {
                final TaskRecord task = top.task;
                task.moveActivityToFrontLocked(top);
                ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT, r, task);
                top.updateOptionsLocked(options);
                top.deliverNewIntentLocked(callingUid, r.intent);
                targetStack.mLastPausedActivity = null;
                if (doResume) {
                    targetStack.resumeTopActivityLocked(null);
                }
                return ActivityManager.START_DELIVERED_TO_TOP;
            }
        }
        // An existing activity is starting this new activity, so we want
        // to keep the new one in the same task as the one that is starting
        // it.
        r.setTask(sourceTask, null);
        if (DEBUG_TASKS) Slog.v(TAG, "Starting new activity " + r
                + " in existing task " + r.task + " from source " + sourceRecord);

    } else if (inTask != null) {
        // The calling is asking that the new activity be started in an explicit
        // task it has provided to us.
        if (isLockTaskModeViolation(inTask)) {
            Slog.e(TAG, "Attempted Lock Task Mode violation r=" + r);
            return ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION;
        }
        targetStack = inTask.stack;
        targetStack.moveTaskToFrontLocked(inTask, r, options);
        targetStack.moveToFront();
        mWindowManager.moveTaskToTop(inTask.taskId);

        // Check whether we should actually launch the new activity in to the task,
        // or just reuse the current activity on top.
        ActivityRecord top = inTask.getTopActivity();
        if (top != null && top.realActivity.equals(r.realActivity) && top.userId == r.userId) {
            if ((launchFlags & Intent.FLAG_ACTIVITY_SINGLE_TOP) != 0
                    || launchSingleTop || launchSingleTask) {
                ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT, top, top.task);
                if ((startFlags&ActivityManager.START_FLAG_ONLY_IF_NEEDED) != 0) {
                    // We don't need to start a new activity, and
                    // the client said not to do anything if that
                    // is the case, so this is it!
                    return ActivityManager.START_RETURN_INTENT_TO_CALLER;
                }
                top.deliverNewIntentLocked(callingUid, r.intent);
                return ActivityManager.START_DELIVERED_TO_TOP;
            }
        }

        if (!addingToTask) {
            // We don't actually want to have this activity added to the task, so just
            // stop here but still tell the caller that we consumed the intent.
            ActivityOptions.abort(options);
            return ActivityManager.START_TASK_TO_FRONT;
        }

        r.setTask(inTask, null);
        if (DEBUG_TASKS) Slog.v(TAG, "Starting new activity " + r
                + " in explicit task " + r.task);

    } else {
        // This not being started from an existing activity, and not part
        // of a new task...  just put it in the top task, though these days
        // this case should never happen.
        targetStack = adjustStackFocus(r, newTask);
        targetStack.moveToFront();
        ActivityRecord prev = targetStack.topActivity();
        r.setTask(prev != null ? prev.task : targetStack.createTaskRecord(getNextTaskId(),
                        r.info, intent, null, null, true), null);
        mWindowManager.moveTaskToTop(r.task.taskId);
        if (DEBUG_TASKS) Slog.v(TAG, "Starting new activity " + r
                + " in new guessed " + r.task);
    }

    mService.grantUriPermissionFromIntentLocked(callingUid, r.packageName,
            intent, r.getUriPermissionsLocked(), r.userId);

    if (sourceRecord != null && sourceRecord.isRecentsActivity()) {
        r.task.setTaskToReturnTo(RECENTS_ACTIVITY_TYPE);
    }
    if (newTask) {
        EventLog.writeEvent(EventLogTags.AM_CREATE_TASK, r.userId, r.task.taskId);
    }
    ActivityStack.logStartActivity(EventLogTags.AM_CREATE_ACTIVITY, r, r.task);
    targetStack.mLastPausedActivity = null;
    targetStack.startActivityLocked(r, newTask, doResume, keepCurTransition, options);
    if (!launchTaskBehind) {
        // Don't set focus on an activity that's going to the back.
        mService.setFocusedActivityLocked(r);
    }
    return ActivityManager.START_SUCCESS;
}

//代码

//

//代码略

String strJson = Utils.readZipFileString(dexFile.getAbsolutePath(), "assets/plugin_config.json");

if (strJson == null || TextUtils.isEmpty(strJson)) {
    return;
}

JSONObject jobject = new JSONObject(strJson.replaceAll("\r|\n", ""));
JSONArray jsonArray = jobject.getJSONArray("plugins");
for(int i = 0;i< jsonArray.length(); i++) {
    JSONObject jsonObject = (JSONObject) jsonArray.get(i);
    UPFApplication.pluginServices.put(
        jsonObject.optString("PluginService"),
        jsonObject.optString("StubService"));
}

//即 Hook AMN 的 gDefault，它是一个Singleton 对象，之后创建它的代理对象 MockClass1 ，然后替换这个字段

//之后，再Hook 到 Handler 类型的 H 类的 mCallback 字段，替换为 MockClass2

private void handleCreateService (CreateServiceData data) { 
    LoadedApk packageinfo = getPackageinfoNoCheck(data.info.applicationinfo, data.compatInfo);
    Service service = null; 
    java.lang.ClassLoader cl= packageinfo.getClassLoader(); 
    service = (Service) cl.loadClass(data.info.name).newinstance(); 
    //省略无关代码
    service . onCreate ();

else if (”bindService”.equals(method . getName())) { 
    //找到参数里面的第一个 Intent 对象
    int index = 0; 
    for (inti= 0; i < args . length ; i++) { 
        if (args [i) instanceof Intent) { 
            index = i ; 
            break; 
        }
    }

    Intent rawintent = (Intent) args[index); 
    String rawServiceName = rawintent.getComponent().getClassName(); 
    String stubServiceName = UPFApplication.pluginServces.get(rawServiceName)
    //替换 Plugin Service of StubService 
    ComponentName componentName =new ComponentName(stubPackage, stubServiceName); 
    Intent newintent = new Intent(); 
    newintent.setComponet(componentName);
    //替换 Intent ，欺骗 AMS
    args[index] = newintent ; 
    Log.d(TAG, ” hook success "); 
    return method.invoke(mBase , args);
}

//unbind
btnBind.setOnClickListener(new View.OnclickListener(){
    @Override
    public void onClick(View v) {
        final Intent = new Intent();
        intent.setComponent(new ComponentName("jianqiang.com.testservice1"), "jianqiang.com.testservice1.MyService2");
        bindService(intent, conn, Service.BIND_AUTO_CREATE);
    }
});

//unbind
btnUnbind.setOnClickListener(new View.OnclickListener(){
    @Override
    public void onClick(View v) {
        unbindService(conn);
    }
});

//代码可以参见： https://github.com/BaoBaoJianqiang/ActivityHook1

//代码参见： https://github.com/BaoBaoJianqiang/ZeusStudy1.3

//代码可以参考上面的链接

//代码参考： https://github.com/BaoBaoJianqiang/ZeusStudy1.0

public final class BaseDexClassLoaderHookHelper {
    public static void patchClassLoder(ClassLoader cl,File apkFile,File optDexFile){
        //获取BaseDexClassLoder: pathList
        Object pathListObj = RefInvoke.getFiledObject(DexClassLoader.class.getSuperclass(), cl, "pathList");

        //获取PathList: Element[] dexElements
        Object[] dexElements = (Object[])RefInvoke.getFieldObject(pathListObj.getClass(), pathListObj, "dexElements");

        ...//手敲太难了，到时候复制下
    }
}

Intent intent = new Intent();
String serviceName = "jianqiang.com.plugin1.TestService1";
intent.setClassName(this, serviceName);
startService(intent);

//代码参考：  https://github.com/BaoBaoJianqiang/ZeusStudy1.1

Resources resources = getResources();
AssetManager am = getResources().getAssets();
InputStream is = getResources().getAssets().open("filename");

File extractFile = this.getFileStreamPath(apkName);
dexPath = extractFile.getPath();

fileRelease = getDir("dex", 0);//0代表Context.MODE_PRIVATE
classLoder = newDexClassLoader(dexPath, fileRelease.getAbsolutePath(), null, getClassLoder());

//整个章节的示例代码可以参考： https://github.com/BaoBaoJianqiang/Dynamic2

//示例代码可以参考： https://github.com/BaoBaoJianqiang/Dynamic3.2

//示例代码参见： https://github.com/BaoBaoJianqiang/ZeusStudy1.8