源码分析 — Activity的清单注册校验及动态注入

最新推荐文章于 2022-05-30 23:20:43 发布
最新推荐文章于 2022-05-30 23:20:43 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： Android源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/love667767/article/details/79561671
版权

一、概述

一般情况下，Activity的启动都需要先在清单文件AndroidManifest.xml中注册后，才能使用。而目前流行的插件化则是通过在底座清单文件中提前占坑的方式来达到启动插件中Activity的目的。但是，插件中的Activity并没有在底座的清单文件中注册。那么，他们是如何达到这个目的的呢？

说明：本文是从插件化中剥离出来的一个知识点;

本文涉及到的技术点：
PackageManagerService(二)之resolveIntent()

二、示例

new TextView(context).setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        // MainActivity注册过，SecondActivity没有注册过；
        Intent intent = new Intent(MainActivity.this, SecondActivity.class);
        startActivity(intent);
    }
});

结果：

Process: com.example.demo, PID: 3773
android.content.ActivityNotFoundException:
Unable to find explicit activity class {com.example.demo/com.example.demo.SecondActivity};
have you declared this activity in your AndroidManifest.xml?
…略…

三、时序图

这里写图片描述

四、源码分析

// Activity.class
// 调用startActivity(intent)，经多次跳转后，最终调用此方法；
public void startActivityForResult(
            @RequiresPermission Intent intent, 
            int requestCode, @Nullable Bundle options) {

    options = transferSpringboardActivityOptions(options);
    // 注意：Instrumentation该类是Activity的实际操作类
    Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity(
            this, mMainThread.getApplicationThread(), mToken, this,
            intent, requestCode, options);

    // ...代码省略...
}

// Instrumentation.class
public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, Activity target,
        Intent intent, int requestCode, Bundle options) {
    // ...代码省略...
    try {
        intent.migrateExtraStreamToClipData();
        intent.prepareToLeaveProcess(who);

        // ActivityManagerNative涉及到IBinder通信机制 (看下面小结)
        // 结论：最终返回 result = = ActivityManager.START_CLASS_NOT_FOUND;
        int result = ActivityManagerNative.getDefault()
            .startActivity(whoThread, who.getBasePackageName(), intent,
                    intent.resolveTypeIfNeeded(who.getContentResolver()),
                    token, target != null ? target.mEmbeddedID : null,
                    requestCode, 0, null, options);

        // 校验：根据返回的result值校验当前Activity是否有异常；
        checkStartActivityResult(result, intent);

    } catch (RemoteException e) {
        throw new RuntimeException("Failure from system", e);
    }
    return null;
}

// Instrumentation.class
public static void checkStartActivityResult(int res, Object intent) {
    // 启动成功，就直接return
    if (res >= ActivityManager.START_SUCCESS) {
        return;
    }

    switch (res) {
        case ActivityManager.START_INTENT_NOT_RESOLVED:
        case ActivityManager.START_CLASS_NOT_FOUND:
            if (intent instanceof Intent && ((Intent)intent).getComponent() != null) {
                // 抛出这一行异常
                throw new ActivityNotFoundException(
                        "Unable to find explicit activity class "
                        + ((Intent)intent).getComponent().toShortString()
                        + "; have you declared this activity 
                        + in your AndroidManifest.xml?");
            }
        // ...代码省略...
    }
}

小结：

  1. 涉及三个类：ActivityManagerNative、ActivityManagerProxy、ActivityManagerService(AMS) ，这三个类都实现了IActivityManager接口；
  2. 记住：调用ActivityManagerNative.getDefault().startActivity()，最终会调用Service(AMS)端的startActivity()方法；
/*
 * 由上面的小结可知，ActivityManagerNative.getDefault().startActivity()最终调用了 
 * ActivityManagerService.startActivity()方法；
 */

// ActivityManagerService.class
public final int startActivity(IApplicationThread caller, String callingPackage,
     Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
     int startFlags, ProfilerInfo profilerInfo, Bundle options) {
        //调用startActivityAsUser方法
    return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
        resultWho, requestCode, startFlags, profilerInfo, options,
        UserHandle.getCallingUserId());
}

// ActivityManagerService.class
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.
    // 调用ActivityStackSupervisor.startActivityMayWait()方法
    return mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent,
            resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
            profilerInfo, null, null, options, false, userId, null, null);
}

// ActivityStackSupervisor.class
final int startActivityMayWait(IApplicationThread caller, int callingUid,
        String callingPackage, Intent intent, String resolvedType,
        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
        IBinder resultTo, String resultWho, int requestCode, int startFlags,
        ProfilerInfo profilerInfo, WaitResult outResult, Configuration config,
        Bundle options, boolean ignoreTargetSecurity, int userId,
        IActivityContainer iContainer, TaskRecord inTask) {
    // ...代码省略...

    // Collect information about the target of the Intent.
    // 这一步是关键，去解析目标Activity的相关Intent信息;(由下面一部分的代码可知，aInfo=null)
    ActivityInfo aInfo = resolveActivity(intent, resolvedType, 
                                    startFlags, profilerInfo, userId);

    // ...代码省略...
    synchronized (mService) {     
        // ...省略一大段代码...

        // 将aInfo=null传入startActivityLocked()，最终返回 res = ActivityManager.START_CLASS_NOT_FOUND;
        int res = startActivityLocked(caller, intent, resolvedType, aInfo,
                voiceSession, voiceInteractor, resultTo, resultWho,
                requestCode, callingPid, callingUid, callingPackage,
                realCallingPid, realCallingUid, startFlags, options, ignoreTargetSecurity,
                componentSpecified, null, container, inTask);

        // ...省略一大段代码...

        return res; //res = ActivityManager.START_CLASS_NOT_FOUND
    }
}

// ActivityStackSupervisor.class
ActivityInfo resolveActivity(Intent intent, String resolvedType, int startFlags,
            ProfilerInfo profilerInfo, int userId) {
    // Collect information about the target of the Intent.
    ActivityInfo aInfo;
    try {
        /* 
         * 这里AppGlobals.getPackageManager()获取的是IPackageManager实例对象，
         * 真正的实现类是PackageManagerService;
         * 
         * 关于IPackageManager.resolveIntent()，
         * 请参考《PackageManagerService(二)之resolveIntent()》
         * http://blog.csdn.net/love667767/article/details/79585080
         */
        ResolveInfo rInfo = AppGlobals.getPackageManager()
                .resolveIntent(intent, resolvedType,
                        PackageManager.MATCH_DEFAULT_ONLY | ActivityManagerService.STOCK_PM_FLAGS,
                        userId);
        // 由于Activity没有在清单文件注册过，因此最终返回的aInfo=null
        aInfo = rInfo != null ? rInfo.activityInfo : null;
    } catch (RemoteException e) {
        aInfo = null;
    }
    // ...省略一大段代码...

    return aInfo;
}

// ActivityStackSupervisor.class
final int startActivityLocked(IApplicationThread caller,
        Intent intent, String resolvedType, ActivityInfo aInfo,
        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
        IBinder resultTo, String resultWho, int requestCode,
        int callingPid, int callingUid, String callingPackage,
        int realCallingPid, int realCallingUid, int startFlags, Bundle options,
        boolean ignoreTargetSecurity, boolean componentSpecified, ActivityRecord[] outActivity,
        ActivityContainer container, TaskRecord inTask) {

    // 初始状态是：START_SUCCESS
    int err = ActivityManager.START_SUCCESS;

    // ...省略一大段代码...

    // intent.getComponent()是有值的
    if (err == ActivityManager.START_SUCCESS && intent.getComponent() == null) {
        // We couldn't find a class that can handle the given Intent.
        // That's the end of that!
        err = ActivityManager.START_INTENT_NOT_RESOLVED;
    }
    // 在这里aInfo == null 满足条件，因此最终返回err = ActivityManager.START_CLASS_NOT_FOUND 
    if (err == ActivityManager.START_SUCCESS && aInfo == null) {
        // We couldn't find the specific class specified in the Intent.
        // Also the end of the line.
        err = ActivityManager.START_CLASS_NOT_FOUND;
    }

    err = startActivityUncheckedLocked(r, sourceRecord, voiceSession, voiceInteractor,
            startFlags, true, options, inTask);

    // 最终返回ActivityManager.START_CLASS_NOT_FOUND 
    return err;
}

五、实践：如何绕过校验，动态注入Activity？

5.1 原理分析

由上面的源码分析可知：

  1. Activity的清单校验逻辑在Instrumentation.execStartActivity() 中进行的；
  2. Instrumentation 的实例在ActivityThread中；
  3. Activity 必须要在清单文件注册的；

方案：
占坑方案：既然Activity要注册过，那我们就在清单文件中预先注册一个占坑的Activity；
作用：在Activity校验的时候，将真正被启动的Activity替换成这个占坑的Activity，从而完成Activity校验的过程。
技术实现：利用清单文件合并的特点，预先在一个清单文件中写入占坑的Activity；

问题：
在校验之前，将被启动的Activity替换成占坑的Activity后，那真正启动的不就是占坑的Activity了吗？
如何启动我们真正需要的Activity呢？

分析：
其实，Activity的创建过程分为两部分：

  1. Activity的校验；(Instrumentation.execStartActivity() )
  2. Activity实例的创建；(Instrumentation.newActivity() )

方案：(Hook技术)

  1. 通过反射技术来替换 ActivityThread 中的 Instrumentation 实例对象，并重写其内部的 execStartActivity()、newActivity() 方法；
  2. 在重写的execStartActivity() 方法中将目标Activity替换成占坑的Activity，并调用系统自身的Instrumentation.execStartActivity()，从而完成Activity的校验过程；
  3. 在重写的newActivity() 方法中将占坑Activity的还原成目标Activity，并调用系统自身的Instrumentation.newActivity() ，最终完成目标Activity的创建；
5.2 实践

说明：

  1. MainActivity、PlaceHolderActivity 注册、SecondActivity未注册 ;
  2. PlaceHolderActivity 是占坑的Activity ;
  3. HookInstrumentation 继承Instrumentation，并重写execStartActivity()、newActivity() 方法；
  4. 在Application.attachBaseContext() 中将HookInstrumentation通过反射赋值给ActivityThread.mInstrumentation 字段 ;

代码实现：

public class VirtualApkApplication extends Application {

    @Override
    protected void attachBaseContext(Context base) {
        super.attachBaseContext(base);
        init();
    }

    /**
     * 1.反射获取ActivityThread对象;
     * 2.反射获取ActivityThread对象中的mInstrumentation对象;
     * 3.创建自定义的HookInstrumentation对象，
     *   并通过反射将自定义的HookInstrumentation对象赋值给ActivityThread.mInstrumentation;
     */
    private void init() {
        try {
            Class<?> activityThreadClazz = Class.forName("android.app.ActivityThread");
            Object activityThread = ReflectUtil.getField(activityThreadClazz, 
                                                null, "sCurrentActivityThread");

            Instrumentation sInstrumentation = (Instrumentation) invoke(
                                                activityThread.getClass(), 
                                                activityThread, 
                                                "getInstrumentation");

            final HookInstrumentation instrumentation = new HookInstrumentation(sInstrumentation);
            ReflectUtil.setField(activityThread.getClass(), activityThread, 
                                                "mInstrumentation", instrumentation);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Object invoke(Class clazz, Object target, String name, Object... args)
            throws Exception {
        Class[] parameterTypes = null;
        if (args != null) {
            parameterTypes = new Class[args.length];
            for (int i = 0; i < args.length; i++) {
                parameterTypes[i] = args[i].getClass();
            }
        }
        Method method = clazz.getDeclaredMethod(name, parameterTypes);
        method.setAccessible(true);
        return method.invoke(target, args);
    }
}
public class HookInstrumentation extends Instrumentation {

    private static final String PACKAGE_NAME = "package_name";
    private static final String CLASS_NAME = "class_name";

    Instrumentation mBase;

    public HookInstrumentation(Instrumentation base) {
        this.mBase = base;
    }

    // 这个方法被隐藏了
    public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {

        if (intent.getComponent() != null) {
            intent.putExtra(PACKAGE_NAME, intent.getComponent().getPackageName());
            intent.putExtra(CLASS_NAME, intent.getComponent().getClassName());
            // 将目标Activity替换成占位Activity;
            intent.setClassName(intent.getComponent().getPackageName(), 
                                    PlaceHolderActivity.class.getName());
        }

        ActivityResult result = null;
        try {
            Class[] parameterTypes = {Context.class, IBinder.class, IBinder.class, Activity.class, Intent.class,
                    int.class, Bundle.class};

            result = (ActivityResult) invoke(Instrumentation.class, mBase,
                    "execStartActivity", parameterTypes,
                    who, contextThread, token, target, intent, requestCode, options);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }


    @Override
    public Activity newActivity(ClassLoader cl, String className, Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {

        String targetClassName = intent.getStringExtra(CLASS_NAME);
        if (!TextUtils.isEmpty(targetClassName)) {
            // 打开目标Activity
            Activity activity = mBase.newActivity(cl, targetClassName, intent);
            activity.setIntent(intent);
            return activity;
        }
        return mBase.newActivity(cl, className, intent);
    }

    public static Object invoke(Class clazz, Object target, String name, Class[] parameterTypes, Object... args)
            throws Exception {
        Method method = clazz.getDeclaredMethod(name, parameterTypes);
        method.setAccessible(true);
        return method.invoke(target, args);
    }
}
Elson_6
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
注册界面(Activity的应用和数据传递)
09-07
Activity间的数据传递：这里面讲了一个App（注册界面实例）一般都是又多个Activity构成的，这就涉及到了多个Activity间数据传递的问题了。
Activity的注册流程、Menu菜单、使用Intent在Activity间切换以及传递数据、Activity的声明周期
u010551181的专栏
04-14 736
Activity的注册流程 1.创建layout的xml文件、Activity的Java类，类继承Activity或ActionBarActivity类 2.在Activity的Java类中重写OnCreate方法，将layout的xml文件引入进去   setContentView(R.layout.Xxx); 3.在AndroidManifest.xml清单文件中注册这个Activit
Activity
Teolih的博客
07-15 326
Activity Activity,直译过来就是“活动”。安卓设想移动应用由于常常涉及到应用程序间的交互，所以不应该以一个APP为原子单位，而是以Activity为单位，这样会更加高效、便捷，使得不同APP间的交互可以通过调用其Activity，而不是通过启动一个APP。通常，在安卓应用中，一个屏幕（界面）既为一个Activity，如启动广告界面、程序主界面等等，其中，那个主要的Activity（main Activity）是APP启动后第一个运行的Activity。 文章目录Activity1. Acti
注册界面及Acticity
共享时代
01-07 525
布局文件 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:l
动态创建ACTIVITY模式
{丸の子}
06-23 116
还记得我们在代理Activity模式里谈到启动插件APK里的Activity的两个难题吗，由于插件里的Activity没在主项目的Manifest里面注册，所以无法经历系统Framework层级的一系列初始化过程，最终导致获得的Activity实例并没有生命周期和无法使用res资源。 使用代理Activity能够解决这两个问题，但是有一些限制： [list] [*]实际运行的Activi...
关于Activity和intent事件的注册
jinguangyang的专栏
03-09 886
在AndroidManifest.xml文件中的元素中有这么两句：           你知道中间的两句话都是什么含义么？ www.2cto.com 当写好的应用发布到手机上之后，当双击该应用的图标时，系统会将这个点击时间包装成一个Intent，该Intent包含两个参数，如上所述的两个参数被传递给应用之后，在应用的功能清单文件中寻找与该意图匹配的意图过滤器，如果匹配成功，找到相匹配的意图过滤
动态加载Activity
08-30
使用反射机制来动态加载Activity,能够制作很完美的插件功能
插件占坑，四大组件动态注册前奏（一） 系统Activity的启动流程
欢迎关注公众号：【码农突围】，公号后台回复9999，可以获取一份500页的LeetCode刷题笔记。
08-12 4059
转载请注明出处：http://blog.csdn.net/hejjunlin/article/details/52190050前言：为什么要了解系统Activity，Service,,BroadCastReceiver,ContentProvider的启动流程，这是一个对于即将理解插件中的四大组件动态注册，占坑的前提，如果不了解的话，那么很难了解插件hook哪此东西，又是如何骗过AMS来启动Acti
ARouter 源码分析
薛瑄的博客
09-05 1047
一、前言 在开始分析ARouter的源码之前，我假定你已经知道ARouter 的用途，并且会熟练使用。下面我在官方demo的基础上，来分析每项功能的流程。 ARouter Github地址 demo 中的 三个 Module app demo项目的 主module module-java demo项目的 子module module-kotlin demo项目的 子module 下面三个Module 提供了核心功能 arouter-annotation 使用到的注解相关信息,例如：@Route,
动态加载Activity1
08-30
使用代理的方式实现动态加载Activity,可以很好的使用开发插件
Activity的事件分发源码分析
01-03
首先我们在Activity中重写dispatchTouchEvent方法，然后点击super.dispatchTouchEvent(ev)进入系统源码，就是Activity的dispatchTouchEvent(MotionEvent ev)方法，来看一下它的一个分发的流程。 这一部分的内容就是...
[图解]Android源码分析——Activity的启动过程
01-03
Activity的启动过程一.Launcher进程请求AMSLauncher.java的startActivitySafely方法的执行过程：Activity.java中startActivity方法的执行过程：startActivityForResult方法的执行过程：Instrumentation.java中...
Activity动态背景源码
10-15
使用一个指定的视屏文件作为Activity的动态背景的简单实现源码
Android 10 startActivity 源码分析
01-03
Activity 首先会通过 Instrumentation 去调用，Instrumentation 中包含 callActivityOnCreate、callActivityOnPause、callApplicationOnCreate 等调用，具有强大的跟踪 Activity 及 Application 生命周期的功能，...
路由方案之ARouter源码分析
handy周
04-15 1204
目录 前言 利用Intent跳转 利用scheme完成跳转 正式开始ARouter的探索 小结 前言 去年底公司内部作技术分享的时候，笔者分享过一次ARouter源码的分析，最近在整理草稿箱里的内容，顺便将它分享出来，记录一下。 利用Intent跳转 我们平常开发过程中，会有各个页面的跳转情况，比如LoginActivity跳转到 HomeActivity的时候，我们最常见的使...
Glide源码分析
01-03
文章目录Glide的用法一、with二、load三、into3.1 buildImageViewTarget3.2 return的into方法3.2.1 将Request和View进行绑定，并保存到tag3.2.2 track当前请求 Glide的用法 Glide.with(this) // 返回RequestManager...
Android用户注册
qq_51558437的博客
05-30 852
简单的Android开发登录注册，这个是没有连数据库的 首先，新建项目，新建一个登录页面LoginActivity和注册页面RegisterActivity。 下面是登录页面的代码:activity_login.xml 上面的代码是LoginActivity.java中的代码，其实要添加的只有一句，其他都写出来是为了让读者能看懂，具体写在哪里。这段代码的作用是： 使标题栏那边显示的文字是登录/注册，而不是一串默认的英文 下面两张图片，左边是未添加代码的效果，右边是添加代码后的效果 <?xml vers
Window系列 (一) — WindowManager 详解
Elson的博客
04-26 5301
WindowManager 详解一、概述二、WindowManager 体系1. 类图2. 源码分析2.1 `ViewManager` 的结构2.2 PhoneWindow 对象何时创建？2.3 WindowManagerImpl 类三、Window 的属性 (类型和显示次序)四、Window 的操作1. Window 的添加过程2. Window 的更新过程3. Window 的删除过程4. I...
activity启动模式 源码分析
最新发布
05-15
Activity启动模式是Android应用程序中非常重要的概念，它决定了Activity的启动方式和生命周期的管理方式。在Android中，Activity启动模式主要有以下几种： 1. standard：标准模式。默认情况下，每次启动Activity时都会创建一个新实例，并放入任务栈中。如果该Activity已经存在任务栈中，则会将该Activity放到栈顶，并重新调用其onCreate()方法。 2. singleTop：栈顶复用模式。如果新启动的Activity已经存在任务栈的栈顶，则不会创建新实例，而是将已有的实例作为当前任务的Activity，并调用其onNewIntent()方法。如果新启动的Activity不在栈顶，则会创建新实例，并将其放到任务栈的栈顶。 3. singleTask：栈内复用模式。如果新启动的Activity已经存在任务栈中，则不会创建新实例，而是将已有的实例作为当前任务的Activity，并将其上面的Activity全部出栈，调用其onNewIntent()方法。如果新启动的Activity不存在任务栈中，则会创建新实例，并放到任务栈的栈顶。 4. singleInstance：单例模式。在一个新的任务栈中创建Activity，并且该任务栈中只有该Activity实例。如果该Activity已经存在于其他任务栈中，则会将该任务栈中的该Activity实例移动到新的任务栈中。 下面是Activity的源码分析： 1. standard模式 在Activity的源码中，标准模式是默认的启动模式。当我们使用startActivity()方法启动一个Activity时，会调用ActivityStackSupervisor类中的startActivityLocked()方法。在该方法中，会通过ActivityStack类的findTaskLocked()方法查找是否存在当前Activity所在的任务栈。如果存在，则会将当前Activity放到该任务栈的栈顶，并调用其onCreate()方法。如果不存在，则会创建一个新的任务栈，并将当前Activity放到该任务栈的栈顶。 2. singleTop模式 当我们在Manifest文件中设置Activity的启动模式为singleTop时，会在ActivityInfo中保存该信息。在ActivityStackSupervisor类的startActivityLocked()方法中，会通过ActivityStack类的findTaskLocked()方法查找是否存在当前Activity所在的任务栈，并判断当前Activity是否在栈顶。如果在栈顶，则会调用其onNewIntent()方法。如果不在栈顶，则会创建一个新的实例，并放到该任务栈的栈顶。 3. singleTask模式 当我们在Manifest文件中设置Activity的启动模式为singleTask时，会在ActivityInfo中保存该信息。在ActivityStackSupervisor类的startActivityLocked()方法中，会通过ActivityStack类的findTaskLocked()方法查找是否存在当前Activity所在的任务栈。如果存在，则会找到该任务栈中的栈顶Activity，并将其上面的所有Activity出栈。然后将当前Activity放到该任务栈的栈顶，并调用其onNewIntent()方法。如果不存在，则会创建一个新的任务栈，并将当前Activity放到该任务栈的栈顶。 4. singleInstance模式 当我们在Manifest文件中设置Activity的启动模式为singleInstance时，会在ActivityInfo中保存该信息。在ActivityStackSupervisor类的startActivityLocked()方法中，会创建一个新的任务栈，并将当前Activity放到该任务栈的栈顶。如果该Activity已经存在于其他任务栈中，则会将该任务栈中的该Activity实例移动到新的任务栈中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值