Android P输入法框架系统--view如何触发绑定

最新推荐文章于 2024-04-10 22:35:12 发布
最新推荐文章于 2024-04-10 22:35:12 发布
阅读量1.1k 收藏 9
点赞数 2
分类专栏： Android android 输入法框架分析 文章标签： Android 输入法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/marshal_zsx/article/details/88779337
版权

    在PC时代，输入法的原始输入来自实体键盘，鼠标，然后输入法将这些事件对应的ASCII码转换为俄文，中文，当然如果是英文是不需要转换，直接发送即可。而在Android系统里，由于输入法dialog永远没法成为焦点window,所以输入法永远没法获取到按键事件，也就是说输入法的输入数据只能来自触摸事件，输入法显示出键盘(大家称之为软键盘)，用户点击键盘UI, 然后输入法将触摸事件所在位置的字符当做原始字符输入，最后组装成更为丰富的字符（多个字符组成拼音，然后转化为中文），然后就是发送到对应的程序。

1、输入法整体框架图

在这里插入图片描述
输入法系统的整个框架如下：
InputMethodManagerService（下文也称IMMS）负责管理系统的所有输入法，包括输入法service(InputMethodService简称IMS)加载及切换。程序获得焦点时，就会通过InputMethodManager向InputMethodManagerService通知自己获得焦点并请求绑定自己到当前输入法上。同时，当程序的某个需要输入法的view比如EditorView获得焦点时就会通过InputMethodManager向InputMethodManagerService请求显示输入法，而这时InputMethodManagerService收到请求后，会将请求的EditText的数据通信接口发送给当前输入法，并请求显输入法。输入法收到请求后，就显示自己的UI dialog,同时保存目标view的数据结构，当用户实现输入后，直接通过view的数据通信接口将字符传递到对应的View。接下来就来分析这些过程。

2、InputMethodManager创建

每个应用APP程序有一个InputMethodManager实例，这个是应用APP程序和InputMethodManagerService通信的接口，该实例在ViewRootImpl初始化的时候创建。

//frameworks/base/core/java/android/view/ViewRootImpl.java
public ViewRootImpl(Context context, Display display) {  
    mContext = context;  
    mWindowSession = WindowManagerGlobal.getWindowSession();  
}  

//frameworks/base/core/java/android/view/WindowManagerGlobal.java
public static IWindowSession getWindowSession() {  
    synchronized (WindowManagerGlobal.class) {  
        if (sWindowSession == null) {  
            try {  
                //这个进程的InputMethodManager实例就生成了  
                InputMethodManager imm = InputMethodManager.getInstance();  
                IWindowManager windowManager = getWindowManagerService();  
            } catch (RemoteException e) {  
                Log.e(TAG, "Failed to open window session", e);  
            }  
        }  
        return sWindowSession;  
    }  
}  
  
public static InputMethodManager getInstance() {  
    synchronized (InputMethodManager.class) {  
        if (sInstance == null) {  
            // InputMethodManager其实就是一个Binder service的proxy  
            IBinder b = ServiceManager.getService(Context.INPUT_METHOD_SERVICE);  
            IInputMethodManager service = IInputMethodManager.Stub.asInterface(b);  
            sInstance = new InputMethodManager(service, Looper.getMainLooper());  
        }  
        return sInstance;  
    }  
}

3、APP程序的Window获得焦点

程序的window获得焦点的时序图如下
在这里插入图片描述
哪个程序获得焦点是由系统决定的，是由WindowManagerService决定的，当系统的window状态发生变化时(比如window新增，删除）就会调用函数updateFocusedWindowLocked来更新焦点window。

//frameworks/base/services/core/java/com/android/server/wm/WindowManagerService.java
private boolean updateFocusedWindowLocked(int mode, boolean updateInputWindows) {  
    //计算焦点window  ----见3.1
    WindowState newFocus = computeFocusedWindowLocked();  
    if (mCurrentFocus != newFocus) {  
        //焦点window发生变化，post一个message来通知程序焦点发生变化了  
        mH.removeMessages(H.REPORT_FOCUS_CHANGE);  
        mH.sendEmptyMessage(H.REPORT_FOCUS_CHANGE); //见3.2
        //省略.....
        return true;  
    }  
    return false;  
}

3.1 焦点window计算

//frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java  
WindowState computeFocusedWindow() {
    // While the keyguard is showing, we must focus anything besides the main display.
    // Otherwise we risk input not going to the keyguard when the user expects it to.
    final boolean forceDefaultDisplay = mService.isKeyguardShowingAndNotOccluded();

    for (int i = mChildren.size() - 1; i >= 0; i--) {
        final DisplayContent dc = mChildren.get(i);
        final WindowState win = dc.findFocusedWindow();
        if (win != null) {
            if (forceDefaultDisplay && !dc.isDefaultDisplay) {
                EventLog.writeEvent(0x534e4554, "71786287", win.mOwnerUid, "");
                continue;
            }
            return win;
        }
    }
    return null;
}

//frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java
WindowState findFocusedWindow() {
       mTmpWindow = null;

       forAllWindows(mFindFocusedWindow, true /* traverseTopToBottom */);

       if (mTmpWindow == null) {
           if (DEBUG_FOCUS_LIGHT) Slog.v(TAG_WM, "findFocusedWindow: No focusable windows.");
           return null;
       }
       return mTmpWindow;
}  

//frameworks/base/services/core/java/com/android/server/wm/WindowState.java
@Override
boolean forAllWindows(ToBooleanFunction<WindowState> callback, boolean traverseTopToBottom) {
    if (mChildren.isEmpty()) {
        // The window has no children so we just return it.
        return applyInOrderWithImeWindows(callback, traverseTopToBottom);
    }

    if (traverseTopToBottom) {//因为traverseTopToBottom为true,故走这个分支
        return forAllWindowTopToBottom(callback);
    } else {
        return forAllWindowBottomToTop(callback);
    }
}

private boolean applyInOrderWithImeWindows(ToBooleanFunction<WindowState> callback,
       boolean traverseTopToBottom) {
   if (traverseTopToBottom) {
  //此处的callback实际上是传入的mFindFocusedWindow，故callback.apply(this)为回调
       if (applyImeWindowsIfNeeded(callback, traverseTopToBottom)
               || callback.apply(this)) {
           return true;
       }
   } else {
       if (callback.apply(this)
               || applyImeWindowsIfNeeded(callback, traverseTopToBottom)) {
           return true;
       }
   }
   return false;
}

//callback.apply(this)为回调函数实现
//frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java
private final ToBooleanFunction<WindowState> mFindFocusedWindow = w -> {
    final AppWindowToken focusedApp = mService.mFocusedApp;
    if (DEBUG_FOCUS) Slog.v(TAG_WM, "Looking for focus: " + w
            + ", flags=" + w.mAttrs.flags + ", canReceive=" + w.canReceiveKeys());

    if (!w.canReceiveKeys()) {
        return false;
    }

    final AppWindowToken wtoken = w.mAppToken;

    // If this window's application has been removed, just skip it.
    if (wtoken != null && (wtoken.removed || wtoken.sendingToBottom)) {
        if (DEBUG_FOCUS) Slog.v(TAG_WM, "Skipping " + wtoken + " because "
                + (wtoken.removed ? "removed" : "sendingToBottom"));
        return false;
    }

    if (focusedApp == null) {
        if (DEBUG_FOCUS_LIGHT) Slog.v(TAG_WM, "findFocusedWindow: focusedApp=null"
                + " using new focus @ " + w);
        mTmpWindow = w;
        return true;
    }

    if (!focusedApp.windowsAreFocusable()) {
        // Current focused app windows aren't focusable...
        if (DEBUG_FOCUS_LIGHT) Slog.v(TAG_WM, "findFocusedWindow: focusedApp windows not"
                + " focusable using new focus @ " + w);
        mTmpWindow = w;
        return true;
    }

    // Descend through all of the app tokens and find the first that either matches
    // win.mAppToken (return win) or mFocusedApp (return null).
    if (wtoken != null && w.mAttrs.type != TYPE_APPLICATION_STARTING) {
        if (focusedApp.compareTo(wtoken) > 0) {
            // App stack below focused app stack. No focus for you!!!
            if (DEBUG_FOCUS_LIGHT) Slog.v(TAG_WM,
                    "findFocusedWindow: Reached focused app=" + focusedApp);
            mTmpWindow = null;
            return true;
        }
    }

    if (DEBUG_FOCUS_LIGHT) Slog.v(TAG_WM, "findFocusedWindow: Found new focus @ " + w);
    mTmpWindow = w;
    return true;
};

3.2 焦点window切换

//frameworks/base/services/core/java/com/android/server/wm/WindowManagerService.java
//接下来系统开始通知程序端哪个window获得了焦点。    
final class H extends Handler {  
    @Override  
    public void handleMessage(Message msg) {  
        switch (msg.what) {  
            case REPORT_FOCUS_CHANGE: {  
                WindowState lastFocus;  
                WindowState newFocus;  
  
				//省略。。。
                if (newFocus != null) {  
                    //通知新的焦点程序其获得了焦点  
                    newFocus.reportFocusChangedSerialized(true, mInTouchMode);  
                    notifyFocusChanged();  
                }  
  
                if (lastFocus != null) {  
                    //通知老的焦点程序其获得了焦点  
                    lastFocus.reportFocusChangedSerialized(false, mInTouchMode);  
                }  
            } break;  
 }  
  
//frameworks/base/services/core/java/com/android/server/wm/WindowState.java  
 public void reportFocusChangedSerialized(boolean focused, boolean inTouchMode) {  
    try {  
        //这个就是通过Binder告知client其获得或失去了焦点  
        //mClient.windowFocusChanged会调回到ViewRootImpl中的W实例
        mClient.windowFocusChanged(focused, inTouchMode);  
    } catch (RemoteException e) {  
    }
    //省略。。。
}

通知应用APP程序获得焦点改变事件

//ViewRootImpl.java  
static class W extends IWindow.Stub {  
    @Override  
    public void windowFocusChanged(boolean hasFocus, boolean inTouchMode) {  
        final ViewRootImpl viewAncestor = mViewAncestor.get();  
        if (viewAncestor != null) {  
            viewAncestor.windowFocusChanged(hasFocus, inTouchMode);  
        }  
    }  
  
//ViewRootImpl.java  
public void windowFocusChanged(boolean hasFocus, boolean inTouchMode) {  
    Message msg = Message.obtain();  
    msg.what = MSG_WINDOW_FOCUS_CHANGED;  
    msg.arg1 = hasFocus ? 1 : 0;  
    msg.arg2 = inTouchMode ? 1 : 0;  
    mHandler.sendMessage(msg);  
}  
  
//ViewRootImpl.java  
//程序获得焦点会通过调用mView.dispatchWindowFocusChanged和  
//imm.onWindowFocus来通知IMMS焦点信息发生改变，需要更新输入法了  
final class ViewRootHandler extends Handler {  
    @Override  
    public void handleMessage(Message msg) {  
        switch (msg.what) {  
        case MSG_WINDOW_FOCUS_CHANGED: {  
            handleWindowFocusChanged();
        } break;  
}  
private void handleWindowFocusChanged() {
	//省略...
        if (mView != null) {
            mAttachInfo.mKeyDispatchState.reset();
			//调用根view的dispatchWindowFocusChanged函数通知view  
            //程序获得焦点  
            mView.dispatchWindowFocusChanged(hasWindowFocus);
            mAttachInfo.mTreeObserver.dispatchOnWindowFocusChange(hasWindowFocus);

            if (mAttachInfo.mTooltipHost != null) {
                mAttachInfo.mTooltipHost.hideTooltip();
            }
        }

        // Note: must be done after the focus change callbacks,
        // so all of the view state is set up correctly.
        if (hasWindowFocus) {
            if (imm != null && mLastWasImTarget && !isInLocalFocusMode()) {
				//通知imm该window获得焦点
                imm.onPostWindowFocus(mView, mView.findFocus(),
                        mWindowAttributes.softInputMode,
                        !mHasHadWindowFocus, mWindowAttributes.flags);
            }
			//省略...
        }
	//省略...
}
   
//上面的根view就是DecorView，它只是调用父类ViewGroup  
//的dispatchWindowFocusChanged  
//ViewGroup.java  
@Override  
public void dispatchWindowFocusChanged(boolean hasFocus) {  
    super.dispatchWindowFocusChanged(hasFocus);  
    final int count = mChildrenCount;  
    final View[] children = mChildren;  
    //让每个子view处理window焦点改变时间  
    //但是只有获得焦点的view才会处理这个时间  
    for (int i = 0; i < count; i++) {  
        children[i].dispatchWindowFocusChanged(hasFocus);  
    }  
}  
 
//View.java 
public void dispatchWindowFocusChanged(boolean hasFocus) {
     onWindowFocusChanged(hasFocus);
 } 
 
public void onWindowFocusChanged(boolean hasWindowFocus) {  
    InputMethodManager imm = InputMethodManager.peekInstance();  
    if (!hasWindowFocus) {  
    } else if (imm != null && (mPrivateFlags & PFLAG_FOCUSED) != 0) {  
        //获得焦点的view通过 InputMethodManager向service通知自己获得焦点  
        imm.focusIn(this);  
    }  
}

4、焦点View向IMMS请求绑定输入法

焦点view请求绑定输入法是通过调用InputMethodManager. focusIn实现的

//frameworks/base/core/java/android/view/inputmethod/InputMethodManager.java
public void focusIn(View view) {  
    synchronized (mH) {  
        focusInLocked(view);  
    }  
}  
  
void focusInLocked(View view) {   
    //保存焦点view变量  
    mNextServedView = view;  
    scheduleCheckFocusLocked(view);  
}  
  
static void scheduleCheckFocusLocked(View view) {  
    ViewRootImpl viewRootImpl = view.getViewRootImpl();  
    if (viewRootImpl != null) {  
        viewRootImpl.dispatchCheckFocus();  
    }  
}  

//frameworks/base/core/java/android/view/ViewRootImpl.java
public void dispatchCheckFocus() {  
    if (!mHandler.hasMessages(MSG_CHECK_FOCUS)) {  
        // This will result in a call to checkFocus() below.  
        mHandler.sendEmptyMessage(MSG_CHECK_FOCUS);  
    }  
}  

public void handleMessage(Message msg) {
    switch (msg.what) {
    //省略。。。
        case MSG_CHECK_FOCUS: {  
            InputMethodManager imm = InputMethodManager.peekInstance();  
            if (imm != null) {  
                imm.checkFocus();  
            }  
        } break;  
    //省略。。。
}

//frameworks/base/core/java/android/view/inputmethod/InputMethodManager.java  
public void checkFocus() {  
    if (checkFocusNoStartInput(false)) {  
        startInputInner(InputMethodClient.START_INPUT_REASON_CHECK_FOCUS, null, 0, 0, 0);
    }  
}  
  
//frameworks/base/core/java/android/view/inputmethod/InputMethodManager.java
boolean startInputInner(@InputMethodClient.StartInputReason final int startInputReason,
        IBinder windowGainingFocus, int controlFlags, int softInputMode,
        int windowFlags) {
    final View view;
    synchronized (mH) {
		//获得上面的焦点view
        view = mServedView;
    }

	//省略。。。

	//创建数据通信连接接口，这个会传送到InputMethodService  
    //InputMethodService后面就通过这个connection将输入法的字符传递给该view  
    InputConnection ic = view.onCreateInputConnection(tba);
    if (DEBUG) Log.v(TAG, "Starting input: tba=" + tba + " ic=" + ic);

    synchronized (mH) {
        //省略。。。
        ControlledInputConnectionWrapper servedContext;
        final int missingMethodFlags;
        if (ic != null) {
            mCursorSelStart = tba.initialSelStart;
            mCursorSelEnd = tba.initialSelEnd;
            mCursorCandStart = -1;
            mCursorCandEnd = -1;
            mCursorRect.setEmpty();
            mCursorAnchorInfo = null;
            final Handler icHandler;
            missingMethodFlags = InputConnectionInspector.getMissingMethodFlags(ic);
            if ((missingMethodFlags & InputConnectionInspector.MissingMethodFlags.GET_HANDLER)
                    != 0) {
                // InputConnection#getHandler() is not implemented.
                icHandler = null;
            } else {
                icHandler = ic.getHandler();
            }
			//将InputConnection封装为binder对象，这个是真正可以实现跨进程通  
            //信的封装类  
            servedContext = new ControlledInputConnectionWrapper(
                    icHandler != null ? icHandler.getLooper() : vh.getLooper(), ic, this);
        } else {
            servedContext = null;
            missingMethodFlags = 0;
        }
        mServedInputConnectionWrapper = servedContext;

        try {
             //通知IMMS处理view绑定输入法事件
            final InputBindResult res = mService.startInputOrWindowGainedFocus(
                    startInputReason, mClient, windowGainingFocus, controlFlags, softInputMode,
                    windowFlags, tba, servedContext, missingMethodFlags,
                    view.getContext().getApplicationInfo().targetSdkVersion);
				//省略。。。
        } catch (RemoteException e) {
            Log.w(TAG, "IME died: " + mCurId, e);
        }
    }

    return true;
}

到此view是如何获取焦点，并通知IMMS去绑定输入法的流程已经分析完成了。下一步将分析IMMS是如何处理view绑定输入法事件。未完待续。。。

时光如刀
关注
专栏目录
android 自定义输入法布局,Android InputMethodService|KeyboardView 自定义输入法和键盘 01...
weixin_33220360的博客
05-25 1226
如何自定义 安卓输入法 和 键盘1.首先有几个关键类1.InputMethodService 2.Keyboard 3.KeyboardView1.1 InputMethodService看下这个类的介绍图片.pngInputMethodService provides a standard implementation of an InputMethod作用 提供一个标准键盘实现 bal...
Android P输入法框架系统--view绑定输入法过程
marshal_zsx的博客
03-31 989
1、概述      IMMS如何处理view绑定输入法事件呢？为了讲解整个绑定过程，我们假设此时输入法service还没启动，这个情况下的输入法绑定是最长的，整个过程经历过如下过程： 启动输入法service 绑定输入法window的token 请求输入法为焦点程序创建一个连接会话 将输入法的接口传递回程序client端 绑定输入法和焦点view      1-4是和程序相关的，而5是和vie...
在键盘上动态添加View
YushiCloud的博客
04-10 924
如何在键盘动态添加View呢？Android手机中的键盘有很多，因此不可能一一匹配在键盘所在的Window上添加，所以需要在键盘上方的容器中添加View，这个时候只需要动态获取键盘的高，作监听，就可以在上方容器中动态添加View啦。 以下提供对键盘的监听的方法。这里只提供解决方案，不提供详细讲解，具体API的使用可参考文档。 效果如下图 public class KeyboardCh...
android输入法02：openwnn源码解析02—Keyboard和KeyboardView
编程资料大全
05-06 211
本文主要介绍openwnn对Keyboard和KeyboardView的处理。 这一部分主要涉及三个类：InputViewManager.java，DefaultSoftKeyboard.java，DefaultSoftKeyboardJAJP.java。其中InputViewManager是与键盘相关的对外接口，DefaultSoftKeyboard是通用类，DefaultSo...
键盘控件KeyboardView的使用
u010746364的博客
08-02 3292
（转载）http://blog.csdn.net/dreamInTheWorld/article/details/50917055 关于编写键盘，部分为了安全而APP自带键盘，比如手机银行； 效果为： 1 布局中增加 KeyboardView 控件； 2 设置 KeyboardView 监听键盘事件修改EditText 全部代码： src/cn.
Android9.0输入法框架(1)
Gordon的博客
07-14 2305
系统输入法框架分析
Android 技术专题系列之七 - 输入法 框架.doc
12-09
在Android系统中，输入法框架是一个复杂而关键的组成...总的来说，Android输入法框架的复杂性源于其多进程通信、服务管理和接口设计。对这些概念的深入理解有助于开发者构建更强大、更符合用户需求的输入法解决方案。
Android系统输入法框架
Android framework
04-08 347
android 系统 输入法框架
Android 输入法框架 （2）- 输入法显示和隐藏
Justwen26的博客
03-06 2062
通常显示或者隐藏输入法有以下三个场景 当一个窗口焦点改变的时候，会根据Window属性控制输入法的显示 App主动调用imm::showSoftInput或者imm::hideSoftinputFromWindow 输入法自己调用ims:requestShowSelf或者ims:requestHideSelf Window焦点改变 当window获得焦点时会调用imm::onPostWin...
Android 输入法框架
最新发布
04-10 371
输入法属于输入系统的一部分，区别于输入系统只能向系统产生时间，输入法能向系统输入具体的内容，下面来认识输入法的大体框架，以下内容参考清华大学出版社出版的《Android图形显示系统》。它的主要功能是为应用进程和输入法进程建立输入法会话。(3)InputMethodManager（IMM）：输入法管理，应用进程通过它请求显示输入法，接收到输入内容后传给输入框。(2)InputMethodService（IMS）：输入法服务，负责显示输入法界面，并把输入的内容传给应用进程。
android log分析及异常关键字分析 启动或退出APP执行过程 与过滤"ActivityManager |WindowManager" 标签
蚁人日记
04-24 3294
private static final boolean IS_DEBUG_BUILD = Build.TYPE.equals("eng") || Build.TYPE.equals("userdebug"); 分析异常时往往需要关注的重要目录： /data/anr/traces.txt /data/tombstones/tombstone_X /data/system/dropbox/ ...
WindowManager当前焦点窗口管理，及多用户下当前焦点window错乱问题
02-12 6971
android中窗口是由WindowManagerService管理的，其中有一个成员变量mCurrentFocus，记录的是当前的焦点窗口，用于将实时input event传递给这个window处理，比如back键。当然在activity切换的时候，这个mCurrentFocus的值会实时变化成当前activity所在的window.这个原生逻辑本来是没有问题的，但是在引入多用户之后，情况却变的
Android 输入法框架简介
穷人小水滴的博客
02-23 1347
每种平台都有自己的输入法框架. GNU/Linux 桌面环境有多种输入法框架, 比如 ibus, fcitx 等. 但是 Android 操作系统只有一种, 是统一提供的输入法框架.
no focused window ANR
一杯咖啡的专栏
09-17 9567
R项目上面的出现了no focused window的ANR 09-09 17:49:58.482 1164 1347 W InputDispatcher: Waiting because no window has focus but ActivityRecord{94be3e0 u0 com.android.settings/.SubSettings t50} may eventually add a window when it finishes starting up. Will wait f.
【Android】Android Framework系列---输入法服务
林多
10-21 1418
车载项目需要定制输入法，也有一些POC演示的项目使用原生比如LatinIME（源码路径为/packages/inputmethods/LatinIME），关于输入法可能会遇到以下一些问题输入法进程启动崩溃输入法画面被其他应用遮挡输入法输入内容显示到错误的编辑框内多屏情况下输入法显示异常输入法未弹出或输入法未隐藏定制多屏多客户端输入法上面举了一些常见例子，实际开发过程中也会有定制输入法服务这类需求。
Android InputMethodManager输入法简介
09-02
InputMethodManager是输入法框架的核心API，它作为一个系统服务，负责在应用程序之间调度和管理当前的输入法。InputMethodManager主要涉及到以下三个组成部分： 1. 输入法管理器（InputMethodManager）：作为客户端...
Android输入法框架分析(1)－三大组件
weixin_30649859的博客
02-20 258
Android输入法框架（Input Method Framework，IMF）是Android中非常重要的模块，它分布于三个部分（确切的说，是三个进程）， 包含编辑框的客户（Client）app，表示普通的使用输入法的app进程。当点击编辑框时，会切换出当前选中的输入法；当用户在输入法输入字符，提交候选词，则会更新到编辑框中。为了完成这些行为，它需要跟下面的两个输入法相关服务进行交互。对于...
Android-S ANR
OneSea的专栏
05-10 2110
本文重点分析Android-S中的ANR原理和实现。
让按钮在输入法之上显示，实现一个优雅的登陆界面
技术笔记
10-13 601
在做登录界面时，“登录”按钮总是会被输入法挡住，要点击登录需要先收起输入法才能点击，这么多余的操作身为一个有强迫症的程序猿怎么能忍。 在做这个之前，首先想到的肯定是设置android:windowSoftInputMode属性，然而并不能达想要的效果，果断放弃。解决办法是给rootView设置一个OnGlobalLayoutListener的监听事件，当布局发生改变时改变控件位置的方式来实现。实
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值