Android客制化------设置以太网静态IP

最新推荐文章于 2024-03-24 22:04:00 发布
最新推荐文章于 2024-03-24 22:04:00 发布
阅读量3.5k 收藏 2
点赞数
分类专栏： Android客制化 文章标签： android 以太网 静态ip
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baifaqingsi/article/details/78621237
版权

最近有个功能，机器连接以太网之后能够通过app获取ip地址，网关，子网掩码等信息，同时还能去手动设置静态的ip。在网上查阅了相关资料，这方面的API在Android都是被hide的，通过反射等方式去调用比较麻烦。而我们这边因为有Android整套源码，因此这些隐藏的API我们也还是能够调用的。
下面就贴出主要源码。

package com.xxx.ipinfo;

import android.app.Dialog;
import android.content.BroadcastReceiver;
import android.os.Bundle;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.LinkAddress;
import android.preference.CheckBoxPreference;
import android.preference.ListPreference;
import android.preference.Preference;
import android.preference.PreferenceActivity;
import android.preference.PreferenceScreen;
import android.preference.SwitchPreference;
import android.preference.Preference.OnPreferenceChangeListener;
import android.util.Log;
import android.os.SystemProperties;

import java.net.Inet4Address;
import java.net.InetAddress;
import java.util.regex.Pattern;
import java.util.ArrayList;

import android.net.EthernetManager;
import android.net.IpConfiguration;
import android.net.IpConfiguration.IpAssignment;
import android.net.IpConfiguration.ProxySettings;
import android.net.wifi.SupplicantState;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.net.StaticIpConfiguration;
import android.net.NetworkUtils;
import android.net.LinkAddress;
import android.net.LinkProperties;
import android.preference.ListPreference;

public class EthernetActivity extends PreferenceActivity 
    implements DialogInterface.OnClickListener ,OnPreferenceChangeListener{

    private static final String TAG = "xxx";

    private static final String KEY_ETH_IP_ADDRESS = "ethernet_ip_addr";
    private static final String KEY_ETH_HW_ADDRESS = "ethernet_hw_addr";
    private static final String KEY_ETH_NET_MASK = "ethernet_netmask";
    private static final String KEY_ETH_GATEWAY = "ethernet_gateway";
    private static final String KEY_ETH_DNS1 = "ethernet_dns1";
    private static final String KEY_ETH_DNS2 = "ethernet_dns2";
    private static final String KEY_ETH_MODE= "ethernet_mode_select";


    private  static String mEthHwAddress = null;
    private  static String mEthIpAddress = null;
    private  static String mEthNetmask = null;
    private  static String mEthGateway = null;
    private  static String mEthdns1 = null;
    private  static String mEthdns2 = null;
    private final static String nullIpInfo = "0.0.0.0";

    private ListPreference mkeyEthMode;
    private SwitchPreference mEthCheckBox;
    private CheckBoxPreference staticEthernet;

    private final IntentFilter mIntentFilter;
    IpConfiguration mIpConfiguration;
    EthernetManager mEthManager;
    StaticIpConfiguration mStaticIpConfiguration;
    Context mContext;
    private EtherentStaticIpDialog mDialog;
    private static final int SHOW_RENAME_DIALOG = 0;



    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            log("Action "+action);
            if(EthernetManager.ETHERNET_STATE_CHANGED_ACTION.equals(action)) {
                    /*接收到以太网状态改变的广播*/
                int EtherState=intent.getIntExtra(EthernetManager.EXTRA_ETHERNET_STATE, -1);
                handleEtherStateChange(EtherState);
            }
        }
    };
    public EthernetActivity() {
        mIntentFilter = new IntentFilter(EthernetManager.ETHERNET_STATE_CHANGED_ACTION);
    }
    /*
     *
    */
    private void handleEtherStateChange(int EtherState ) {
        log("curEtherState"+ EtherState);

        switch(EtherState) {
            case EthernetManager.ETHER_STATE_DISCONNECTED:
                mEthHwAddress = nullIpInfo;
                mEthIpAddress = nullIpInfo;
                mEthNetmask = nullIpInfo;
                mEthGateway = nullIpInfo;
                mEthdns1 = nullIpInfo;
                mEthdns2 = nullIpInfo;
                break;
            case EthernetManager.ETHER_STATE_CONNECTING:
                String mStatusString = this.getResources().getString(R.string.ethernet_info_getting);
                mEthHwAddress = mStatusString;
                mEthIpAddress = mStatusString;
                mEthNetmask = mStatusString;
                mEthGateway = mStatusString;
                mEthdns1 = mStatusString;
                mEthdns2 = mStatusString;
                break;
            case EthernetManager.ETHER_STATE_CONNECTED:
                getEthInfo();
                break;
        }

        refreshUI();
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.xml.ethernet_settings);

        mEthManager = (EthernetManager) getSystemService(Context.ETHERNET_SERVICE);

        if (mEthManager == null) {
            Log.e(TAG, "get ethernet manager failed");
            return;
        }
        mContext=this.getApplicationContext();
    }

    private Inet4Address getIPv4Address(String text) {
        try {
            return (Inet4Address) NetworkUtils.numericToInetAddress(text);
        } catch (IllegalArgumentException|ClassCastException e) {
            return null;
        }
    }

    @Override
    public void onResume() {
        super.onResume();
        if(mkeyEthMode==null) {
            mkeyEthMode=(ListPreference)findPreference(KEY_ETH_MODE);
            mkeyEthMode.setOnPreferenceChangeListener(this);
        }

        if (mEthCheckBox== null) {
            mEthCheckBox =  (SwitchPreference) findPreference("ethernet");
        }
        handleEtherStateChange(mEthManager.getEthernetConnectState());
        refreshUI();
        log("resume");
        mContext.registerReceiver(mReceiver, mIntentFilter);
    }

    @Override
    public void onPause() {
        super.onPause();
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        log("destory");
    }
    @Override
    public void onStop(){
        super.onStop();
        log("stop");

        mContext.unregisterReceiver(mReceiver);
    }

    private void setStringSummary(String preference, String value) {
        try {
            findPreference(preference).setSummary(value);
        } catch (RuntimeException e) {
            findPreference(preference).setSummary("");
            log("can't find "+preference);
        }
    }
    private String getStringFromPref(String preference) {
        try {
            return findPreference(preference).getSummary().toString();
        } catch (RuntimeException e) {
            return null;
        }
    }
    private void refreshUI ( ) {

        //    setStringSummary(KEY_ETH_HW_ADDRESS,mEthHwAddress);

        setStringSummary(KEY_ETH_IP_ADDRESS, mEthIpAddress);
        setStringSummary(KEY_ETH_NET_MASK, mEthNetmask);
        setStringSummary(KEY_ETH_GATEWAY, mEthGateway);
        setStringSummary(KEY_ETH_DNS1, mEthdns1);
        setStringSummary(KEY_ETH_DNS2, mEthdns2);
        updateCheckbox();
    }

    private void updateCheckbox(){  //add by ljh for adding a checkbox switch

        if(mEthManager==null){
            mkeyEthMode.setSummary("null");
        } else {
            boolean useDhcp=(mEthManager.getConfiguration().ipAssignment == IpAssignment.DHCP) ? true : false;
            if(useDhcp){
                mkeyEthMode.setValue("DHCP");
                mkeyEthMode.setSummary(R.string.usedhcp);
            }else {
                mkeyEthMode.setValue("StaticIP");
                mkeyEthMode.setSummary(R.string.usestatic);
            }
            int isEnable = mEthManager.getEthernetIfaceState();
            if(isEnable == EthernetManager.ETHER_IFACE_STATE_UP) {
                mEthCheckBox.setChecked(true);
            }else mEthCheckBox.setChecked(false);
        }
    }
    @Override
    public boolean onPreferenceChange(Preference preference, Object newValue) {
        //   log("onPreferenceTreeclick");
        if(preference==mkeyEthMode) {
            String value=(String)newValue;
            if(value.equals("DHCP")){
                mEthManager.setConfiguration(new IpConfiguration(IpAssignment.DHCP, ProxySettings.NONE,null,null));
                log("switch to dhcp");
            }else if(value.equals("StaticIP")){
                log("static editor");
                this.showDialog(SHOW_RENAME_DIALOG);
            }

        }
        return true;
    }
    @Override
    public boolean onPreferenceTreeClick(PreferenceScreen screen, Preference preference) {

        if (preference == mEthCheckBox) {
            boolean newState = mEthCheckBox.isChecked();
            if(newState) {
                log("turn on Ethernet");
                mEthManager.setEthernetEnabled(true);
            } else {
                log("turn off Ethernet");
                mEthManager.setEthernetEnabled(false);
            }
            //log("IpAssignment: "+mEthManager.getConfiguration().toString());
        }
        return super.onPreferenceTreeClick(screen, preference);
    }

    //将子网掩码转换成ip子网掩码形式，比如输入32输出为255.255.255.255
    public  String interMask2String(int prefixLength) {
        String netMask = null;
        int inetMask = prefixLength;

        int part = inetMask / 8;
        int remainder = inetMask % 8;
        int sum = 0;

        for (int i = 8; i > 8 - remainder; i--) {
            sum = sum + (int) Math.pow(2, i - 1);
        }

        if (part == 0) {
            netMask = sum + ".0.0.0";
        } else if (part == 1) {
            netMask = "255." + sum + ".0.0";
        } else if (part == 2) {
            netMask = "255.255." + sum + ".0";
        } else if (part == 3) {
            netMask = "255.255.255." + sum;
        } else if (part == 4) {
            netMask = "255.255.255.255";
        }

        return netMask;
    }

    /*
     * convert subMask string to prefix length
     */
    private int maskStr2InetMask(String maskStr) {
        StringBuffer sb ;
        String str;
        int inetmask = 0;
        int count = 0;
        /*
         * check the subMask format
         */
        Pattern pattern = Pattern.compile("(^((\\d|[01]?\\d\\d|2[0-4]\\d|25[0-5])\\.){3}(\\d|[01]?\\d\\d|2[0-4]\\d|25[0-5])$)|^(\\d|[1-2]\\d|3[0-2])$");
        if (pattern.matcher(maskStr).matches() == false) {
            return 0;
        }

        String[] ipSegment = maskStr.split("\\.");
        for(int n =0; n<ipSegment.length;n++) {
            sb = new StringBuffer(Integer.toBinaryString(Integer.parseInt(ipSegment[n])));
            str = sb.reverse().toString();
            count=0;
            for(int i=0; i<str.length();i++) {
                i=str.indexOf("1",i);
                if(i==-1)
                    break;
                count++;
            }
            inetmask+=count;
        }
        return inetmask;
    }

    private boolean setStaticIpConfiguration() {

        mStaticIpConfiguration =new StaticIpConfiguration();
         /*
          * get ip address, netmask,dns ,gw etc.
          */
        Inet4Address inetAddr = getIPv4Address(this.mEthIpAddress);
        int prefixLength = maskStr2InetMask(this.mEthNetmask);
        InetAddress gatewayAddr =getIPv4Address(this.mEthGateway);
        InetAddress dnsAddr = getIPv4Address(this.mEthdns1);

        if (inetAddr.getAddress().toString().isEmpty() || prefixLength ==0 || gatewayAddr.toString().isEmpty()
                || dnsAddr.toString().isEmpty()) {
            log("ip,mask or dnsAddr is wrong");
            return false;
        }

        String dnsStr2=this.mEthdns2;
        mStaticIpConfiguration.ipAddress = new LinkAddress(inetAddr, prefixLength);
        mStaticIpConfiguration.gateway=gatewayAddr;
        mStaticIpConfiguration.dnsServers.add(dnsAddr);

        if (!dnsStr2.isEmpty()) {
            mStaticIpConfiguration.dnsServers.add(getIPv4Address(dnsStr2));
        }
        mIpConfiguration=new IpConfiguration(IpAssignment.STATIC, ProxySettings.NONE,mStaticIpConfiguration,null);
        return true;
    }

    public void getEthInfoFromDhcp(){
        String tempIpInfo;
        String iface = "eth0";

        tempIpInfo = SystemProperties.get("dhcp."+ iface +".ipaddress");

        if ((tempIpInfo != null) && (!tempIpInfo.equals("")) ){
            mEthIpAddress = tempIpInfo;
        } else {
            mEthIpAddress = nullIpInfo;
        }

        tempIpInfo = SystemProperties.get("dhcp."+ iface +".mask");
        if ((tempIpInfo != null) && (!tempIpInfo.equals("")) ){
            mEthNetmask = tempIpInfo;
        } else {
            mEthNetmask = nullIpInfo;
        }

        tempIpInfo = SystemProperties.get("dhcp."+ iface +".gateway");
        if ((tempIpInfo != null) && (!tempIpInfo.equals(""))){
            mEthGateway = tempIpInfo;
        } else {
            mEthGateway = nullIpInfo;
        }

        tempIpInfo = SystemProperties.get("dhcp."+ iface +".dns1");
        if ((tempIpInfo != null) && (!tempIpInfo.equals(""))){
            mEthdns1 = tempIpInfo;
        } else {
            mEthdns1 = nullIpInfo;
        }

        tempIpInfo = SystemProperties.get("dhcp."+ iface +".dns2");
        if ((tempIpInfo != null) && (!tempIpInfo.equals(""))){
            mEthdns2 = tempIpInfo;
        } else {
            mEthdns2 = nullIpInfo;
        }
    }

    public void getEthInfoFromStaticIp() {
        StaticIpConfiguration staticIpConfiguration=mEthManager.getConfiguration().getStaticIpConfiguration();

        if(staticIpConfiguration == null) {
            return ;
        }
        LinkAddress ipAddress = staticIpConfiguration.ipAddress;
        InetAddress gateway   = staticIpConfiguration.gateway;
        ArrayList<InetAddress> dnsServers=staticIpConfiguration.dnsServers;

        if( ipAddress !=null) {
            mEthIpAddress=ipAddress.getAddress().getHostAddress();
            mEthNetmask=interMask2String(ipAddress.getPrefixLength());
        }
        if(gateway !=null) {
            mEthGateway=gateway.getHostAddress();
        }
        mEthdns1=dnsServers.get(0).getHostAddress();

        if(dnsServers.size() > 1) { /* 只保留两个*/
            mEthdns2=dnsServers.get(1).getHostAddress();
        }
    }
    /*
     * TODO:
     */
    public void getEthInfo(){
        /*
        mEthHwAddress = mEthManager.getEthernetHwaddr(mEthManager.getEthernetIfaceName());
        if (mEthHwAddress == null) mEthHwAddress = nullIpInfo;
        */
        IpAssignment mode =mEthManager.getConfiguration().getIpAssignment();


        if ( mode== IpAssignment.DHCP) {
       /*
        * getEth from dhcp
       */
            getEthInfoFromDhcp();
        } else if(mode == IpAssignment.STATIC) {
       /*
        * TODO: get static IP
       */
            getEthInfoFromStaticIp();
        }
    }

    /*
     * tools
    */
    private void log(String s) {
        Log.d(TAG, "EthernertAv  " + s);
    }

    @Override
    public void onClick(DialogInterface dialogInterface, int button) {
        if(button==EtherentStaticIpDialog.BUTTON_SUBMIT) {
            mDialog.saveIpSettingInfo(); //从Dialog获取静态数据
            if(setStaticIpConfiguration()) {
                mEthManager.setConfiguration(mIpConfiguration);
            } else {
                Log.e(TAG, mIpConfiguration.toString());
            }
        }
        updateCheckbox();
    }

    @Override
    public Dialog onCreateDialog(int dialogId) {
        log("onCreateDialog "+dialogId);
        switch(dialogId) {
            case SHOW_RENAME_DIALOG:

                mDialog = new EtherentStaticIpDialog(EthernetActivity.this, false, this,mGetStaticIpInfo);
                return mDialog;
        }
        return super.onCreateDialog(dialogId);
    }
    /*interface*/

    public GetStaticIpInfo mGetStaticIpInfo =new GetStaticIpInfo() {

        public boolean getStaticIp(String ipAddr) {
            mEthIpAddress = ipAddr;

            log("ipAddr: "+ipAddr);
            return true;
        }
        public boolean getStaticNetMask(String netMask) {
            mEthNetmask =netMask ;

            log("netMask: "+netMask);
            return true;
        }
        public boolean getStaticGateway(String gateway) {
            mEthGateway=gateway;

            log("gateway: "+gateway);
            return true;
        }
        public boolean getStaticDns1(String dns1) {
            mEthdns1=dns1;

            log("dns1: "+dns1);
            return true;
        }
        public boolean getStaticDns2(String dns2) {
            mEthdns2=dns2;

            log("dns2: "+dns2);
            return true;
        }
    };  
}

源码下载请点我

baifaqingsi
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android 11.0 wifi设置静态ip功能实现
安卓兼职framework和app工程师的博客
07-23 419
在11.0的系统rom定制化开发中，在某些功能开发中，在wifi模块中，有产品需要要求设置wifi静态ip功能，而系统中wifi连接 后ip是动态的，每次开机后连接wifi的ip就是不固定的，所以产品需要采用固定ip，就需要实现静态ip功能
Android 10.0 以太网设置默认静态ip地址
安卓兼职framework和app工程师的博客
02-13 1194
在进行以太网产品开发的过程中，有功能要求设置默认静态ip地址的功能，不使用动态ip,方便ip地址管理 所以就需要熟悉以太网的ip设置流程，然后设置对应的ip地址就可以了
Android5.0-7.0开机使用静态IP方法(1).txt
08-01
android rk3399平台出现系统出现动态IP获取失败，因此通过修改framework改为静态IP.
android 以太网设置静态ip
有酒有故事
04-26 5461
先是查到了以下的方法，发现是设置Wi-Fi的。 public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); ContentResolver cr = this.getContentResolver(); tr...
Android中设置Ethernet为默认网络类型
热门推荐
Android/Linux的专栏
11-07 3万+
要求Ethernet网和WiFi要像PC机上那样能共存，且以Ethernet优先。其实这个问题说来简单，牵扯的东西很多，然后根据现象一点一点解决： 现象1：先连接Ethernet网后连接WiFi的时候会将Ethernet断开 现象2：先连接WiFi后，Ethernet连接不上 现象3：Ethernet在硬件断开后再插入的时候不能自动连接 今天只解决现象1.
android app 设置以太网静态Ip
gddw1954的专栏
07-21 1万+
写文目的 公司是做工控和楼宇智能方面产品，使用的设备有rk和全志平台，运行的是android操作系统，部分场景需要设置有线网络的静态Ip。所以针对这一需求做了如下工作，并以此文作为总结。 遇到的问题 工作前也有百度过相关方案，但大部分使用的是busybox ifconfig来设置，而这种方式有很多弊端，如设置的app必须拥有root权限、不能实时切换static和dhcp、重启后设置的就不生效、不能通过系统的settings参看设置的状态。经过一番折腾后发现为了解决这些问题必须从android的系统应
Android Ethernet以太网使用静态IP，经典实战教程
最新发布
weixin_58134620的博客
03-24 1195
给大家送上我成功跳槽复习中所整理的资料，由于文章篇幅有限，所以只是把题目列出来了，我自己手头上整理的资料均和上面的答案可免费分享，需要这些资料和答案的朋友，可以点击这里免费领取。只是把题目列出来了，我自己手头上整理的资料均和上面的答案可免费分享，需要这些资料和答案的朋友，可以点击这里免费领取。[外链图片转存中…(img-zniSF7cy-1711289029302)][外链图片转存中…(img-9FOmi339-1711289029303)]
flow-3D客制化流程
12-20
比较客制化后的结果与默认设置下的结果，以确认改动是否有效并符合预期。如果结果不理想，可能需要回溯并调整源代码，然后重复编译和验证的过程。 总的来说，Flow-3D的客制化流程涉及了编程、编译和软件集成等多个...
E169F客制化总结 --- 201510191
08-08
E169F型号的设备客制化主要包括项目配置、资源定制、网络设置以及系统功能的调整等多个方面。 1、项目配置： 项目配置是客制化的基础，涉及到设备的硬件适配、软件版本选择、安全策略设定等。这部分工作通常由开发...
T651W 客制化总结 --- 08261
08-08
综上所述，T651W的客制化工作涵盖了从基本的项目配置到用户界面的细节优化，再到网络连接和服务的个性化设置。这样的客制化过程确保了产品不仅能适应不同市场的需求，还能够提供独特的用户体验。在实际操作中，...
Android客制化adb shell进去后显示shell@xxx的标识
08-26
总的来说，Android客制化adb shell标识涉及到对Android系统的深入理解，包括其启动过程、环境变量的设置以及源代码的修改。这种定制可以提高开发者的工作效率，但也要求开发者具备一定的技术背景和谨慎操作。通过这...
android设置静态IP
08-06
适应3.0一下，和3.0以上静态Ip设置。
Android5.1以太网开关控制以及动静态IP设置
03-21
通过调用安卓隐藏api来对以太网开关以及静动态IP进行设置，在某些定制的开发板上以及某些不提供点击界面的地方可以用到！
Android 7.0 增加Ethernet设置(DHCP与Static ip)
10-31
Android 7.0 增加Ethernet设置(DHCP与Static ip) 静态IP设置选项有： IP 地址 子网掩码 默认网关 首选DNS服务器 备用DNS服务器 参考文章：http://blog.csdn.net/hclydao/article/details/50972932 感谢 hclydao
ffmpeg-android-maker:包含一个为Android组装FFmpeg库的脚本
04-30
ffmpeg-android-maker 这是一个脚本，可下载库的源代码并将其汇编为Android。 该脚本生成共享库（* .so文件）以及头文件（* .h文件）。 输出结构在图像中表示。 该脚本还生成ffmpeg和ffprobe可执行文件， ffprobe...
Android Ethernet以太网使用静态IP，Android学习路线
m0_64603743的博客
12-20 1609
checkStaticIP .setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() { @Override public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { android.provider.Settings.System.putInt( contentResolver, ETHERNET_USE_STATIC_IP
Android13 原生以太网实现设置静态IP
CGTAIHYQ的博客
10-19 6013
首先需要实现android13设置静态IP的功能，就要对android13以太网架构变化大致理解，谷歌把以太网相关的功能进行模块化，提取到packages/modules/Connectivity/目录，导致之前的实现需要调整，本文主要从2大块进行阐述，分别为framework与原生Settings。 本文涉及功能点主要有如下几点： 1.设置IP的方式分为DHCP和静态两种 2.IP地址的设置 3.子网掩码设置 4.DNS设置 5.网关设置 6.代理设置
Android 7.0 增加以太网设置DHCP和静态IP
zhouyuanjing的专栏
11-01 1万+
Android 7.0 自带EthernetService，默认开机就会启动，默认ip获取方式是动态分配（DHCP），有时候公司路由器DNS设置有问题，导致无法上网（能ping通局域网，无法上外网），手动设置静态IP就派上用场了。 废话不多说了，上图 修改记录： alps/device/xxxxx/xxx6737t_35g_n/device.mk alps/frameworks/b
android5.1 以太网启动已经修改为静态IP
huankong258的博客
04-27 4921
参考http://blog.csdn.net/tankai19880619/article/details/44559419，它这个是5.0但是启动流程大同小异 参考http://blog.csdn.net/moyu123456789/article/details/50002099，它是修改的整个流程 1、启动服务 frameworks/base/services/Java/com/Andr
客制化eM-Plant教程：启动与对象加载操作详解
6. 工具选项：包括随机数生成、模型加密解密、个性化设置以及查询帮助文档，提供全面的功能定制和辅助。 7. 学习与支持：Help功能是用户学习和解决问题的重要资源，提供了详细的功能说明和对象使用指南，以及索引和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值