安卓间通过Socket在局域网传输文件

最新推荐文章于 2022-07-22 10:47:07 发布
最新推荐文章于 2022-07-22 10:47:07 发布
阅读量1k 收藏 8
点赞数 1
分类专栏： Android学习总结 文章标签： 网络 android java 安卓
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/liusaisaiV1/article/details/107756929
版权
本文介绍了一种在安卓设备间及安卓PC间通过局域网进行文件传输的方法，涉及A2ATransferActivity.Java、SocketManager等组件，以及如何在manifest中配置权限。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

安卓间、安卓PC间通过局域网传输文件

声明：本文参考自网络资料，绝非首创，感谢以下，但不止于以下几篇博客：
https://www.cnblogs.com/yangfengwu/p/12543923.html
https://blog.youkuaiyun.com/cai13160674275/article/details/50152579
https://blog.youkuaiyun.com/feibafeibafeiba/article/details/53516574

1. A2ATransferActivity.Java

A2ATransferActivity.Java

public class A2ATransferActivity extends AppCompatActivity implements View.OnClickListener {
    private static final int FILE_CODE = 0;
    private static final int REQUEST_CODE = 1;
    private TextView tvMsg;
    private EditText txtIP, txtPort, txtEt;
    private Button btnSend;
    private Handler handler;
    private SocketManager socketManager;
    private final String[] PERMISSIONS_STORAGE = {
            "android.permission.READ_EXTERNAL_STORAGE",
            "android.permission.WRITE_EXTERNAL_STORAGE" };

    private final String TAG = A2ATransferActivity.this.getClass().getSimpleName();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_a2a_transfer);

        tvMsg = (TextView) findViewById(R.id.tvMsg);
        txtIP = (EditText) findViewById(R.id.txtIP);
        txtPort = (EditText) findViewById(R.id.txtPort);
        txtEt = (EditText) findViewById(R.id.et);
        btnSend = (Button) findViewById(R.id.btnSend);

        ActivityCompat.requestPermissions(A2ATransferActivity.this, PERMISSIONS_STORAGE, REQUEST_CODE);


        btnSend.setOnClickListener(this);

        handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case 0:
                        SimpleDateFormat format = new SimpleDateFormat("hh:mm:ss");
                        txtEt.append("\n[" + format.format(new Date()) + "]" + msg.obj.toString());
                        break;
                    case 1:
                        tvMsg.setText("本机IP：" + GetIpAddress() + " 监听端口:" + msg.obj.toString());
                        break;
                    case 2:
                        Toast.makeText(getApplicationContext(), msg.obj.toString(), Toast.LENGTH_SHORT).show();
                        break;
                    default:
                        break;
                }
            }
        };
            socketManager = new SocketManager(handler);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btnSend:
                Intent i = new Intent(A2ATransferActivity.this, FilePickerActivity.class);
                i.putExtra(FilePickerActivity.EXTRA_ALLOW_MULTIPLE, true);
                i.putExtra(FilePickerActivity.EXTRA_ALLOW_CREATE_DIR, false);
                i.putExtra(FilePickerActivity.EXTRA_MODE, FilePickerActivity.MODE_FILE);
                i.putExtra(FilePickerActivity.EXTRA_START_PATH, Environment.getExternalStorageDirectory().getPath());
                Log.i(TAG, "onClick: Environment.getExternalStorageDirectory().getPath()" + Environment.getExternalStorageDirectory().getPath());

                startActivityForResult(i, FILE_CODE);
                break;
            default:
                break;
        }
    }


    @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        Log.i(TAG, "onActivityResult: + resultCode" + resultCode);
        if (requestCode == FILE_CODE && resultCode == Activity.RESULT_OK) {
            final String ipAddress = txtIP.getText().toString();
            final int port = Integer.parseInt(txtPort.getText().toString());
            if (data.getBooleanExtra(FilePickerActivity.EXTRA_ALLOW_MULTIPLE, true)) {
                // For JellyBean and above
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
                    ClipData clip = data.getClipData();
                    final ArrayList<String> fileNames = new ArrayList<>();
                    final ArrayList<String> paths = new ArrayList<>();
                    if (clip != null) {
                        for (int i = 0; i < clip.getItemCount(); i++) {
                            Uri uri = clip.getItemAt(i).getUri();
                            paths.add(uri.getPath());
                            fileNames.add(uri.getLastPathSegment());
                        }
                        Message.obtain(handler, 0, "正在发送至" + ipAddress + ":" + port).sendToTarget();
                        Thread sendThread = new Thread(new Runnable() {
                            @Override
                            public void run() {
                                Log.i(TAG, "run:fileNames.size() =  " + fileNames.size());
                                socketManager.SendFile(fileNames, paths, ipAddress, port);
                            }
                        });
                        sendThread.start();
                    }
                } else {
                    final ArrayList<String> paths = data.getStringArrayListExtra
                            (FilePickerActivity.EXTRA_PATHS);
                    final ArrayList<String> fileNames = new ArrayList<>();
                    if (paths != null) {
                        for (String path : paths) {
                            Uri uri = Uri.parse(path);
                            paths.add(uri.getPath());
                            fileNames.add(uri.getLastPathSegment());
                            socketManager.SendFile(fileNames, paths, ipAddress, port);
                        }
                        Message.obtain(handler, 0, "正在发送至" + ipAddress + ":" + port).sendToTarget();
                        Thread sendThread = new Thread(new Runnable() {
                            @Override
                            public void run() {
                                socketManager.SendFile(fileNames, paths, ipAddress, port);
                            }
                        });
                        sendThread.start();
                    }
                }
            }
        }
        super.onActivityResult(requestCode, resultCode, data);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //System.exit(0);
    }

    public String GetIpAddress() {
        WifiManager wifiManager = (WifiManager) getApplicationContext().getSystemService(WIFI_SERVICE);
        WifiInfo wifiInfo = wifiManager.getConnectionInfo();
        int i = wifiInfo.getIpAddress();
        return (i & 0xFF) + "." +
                ((i >> 8) & 0xFF) + "." +
                ((i >> 16) & 0xFF) + "." +
                ((i >> 24) & 0xFF);
    }
}

2. SocketManager

SocketManager

public class SocketManager {
    private ServerSocket ss;
    private Handler handler = null;
    private final String TAG = SocketManager.this.getClass().getSimpleName();
    private final String regEx = "/root/";


    public SocketManager(Handler handler) {
        this.handler = handler;
        int port = 9999;
        while (port > 9000) {
            try {
                //1. 建立连接监听窗口；
                ss = new ServerSocket(port);

                Log.i(TAG, "server.getReuseAddress() = " + ss.getReuseAddress());
                if (!ss.getReuseAddress()) {
                    ss.setReuseAddress(true);
                }
                break;
            } catch (Exception e) {
                port--;
                Log.i(TAG, "SocketManager: e = " + e);
            }
        }
        SendMessage(1, port);
        Thread receiveFileThread = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    Log.i(TAG, "ReceiveFile  run:    被调用了！  ");
                    ReceiveFile();
                }
            }
        });
        receiveFileThread.start();
    }

    void SendMessage(int what, Object obj) {
        if (handler != null) {
            Message.obtain(handler, what, obj).sendToTarget();
        }
    }

    public void SendFile(ArrayList<String> fileName, ArrayList<String> path, String ipAddress, int port) {
        Log.i(TAG, "SendFile:fileName(0) =  " + fileName.get(0).toString());
        Log.i(TAG, "SendFile:path(0) =  " + path.get(0).toString());

        try {
            Socket name = new Socket(ipAddress, port);
            Log.i(TAG, "SendFile: Socketname =  " + name);
            for (int i = 0; i < fileName.size(); i++) {

                OutputStream outputName = name.getOutputStream();
                OutputStreamWriter outputWriter = new OutputStreamWriter(outputName);
                BufferedWriter bwName = new BufferedWriter(outputWriter);
                bwName.write(fileName.get(i));
                bwName.close();
                outputWriter.close();
                outputName.close();
                name.close();
                SendMessage(0, "正在发送" + fileName.get(i));

                Socket data = new Socket(ipAddress, port);
                Log.i(TAG, "SendFile: Socketdata =  " + data);
                OutputStream outputData = data.getOutputStream();
                Log.i(TAG, "outputData = " + outputData);

                Log.i(TAG, "path.get(i)  = " + path.get(i));

                //File file = new File(path.get(i));
                //以下这行爆出：文件不存在；原因在于默认得到的目录是 带有 /root/前缀的；故输入流无法创建成功；
                String tempPath = path.get(i).replaceAll(regEx, "");
                FileInputStream fileInput = new FileInputStream(tempPath);
                Log.i(TAG, "fileInput = " + fileInput);
                //判断是否读到文件末尾
                int size = -1;
                byte[] buffer = new byte[1024];
                Log.i(TAG, "SendFile: size =  " + size);
                while ((size = fileInput.read(buffer)) > 0) {
                    Log.i(TAG, "SendFile: While : size =  " + size);
                    outputData.write(buffer, 0, size);
                    outputData.flush();
                }
                //告诉服务端，文件已传输完毕
                //data.shutdownOutput();
                Log.i(TAG, "SendFile: While : 完成 " + size);

                outputData.close();
                fileInput.close();
                data.close();
                SendMessage(0, fileName.get(i) + "  发送完成");
                SendMessage(0, "所有文件发送完成");

            }


        } catch (Exception e) {
            Log.i(TAG, "发送错误   +   " + e.getMessage());
            SendMessage(0, "发送错误:\n" + e.getMessage());
        }
    }

    void ReceiveFile() {
        Log.i(TAG, "ReceiveFile:    被用调了！  ");
        try {
            //2. 连接客户端对象
            //阻塞式方法，只有客户端连接了才会继续往下运行
            while (true) {
                Socket name = ss.accept();
                Log.i(TAG, "ReceiveFile  Socket name =   " + name);
                //3.获取客户端发来的数据
                InputStream nameIPS = name.getInputStream();
                Log.i(TAG, "ReceiveFile  :nameIPS  =  " + nameIPS);
                InputStreamReader inputStreamReader = new InputStreamReader(nameIPS);
                Log.i(TAG, "ReceiveFile  inputStreamReader  =  " + inputStreamReader);
                //4.开始读取，获取输入信息
                BufferedReader br = new BufferedReader(inputStreamReader);

                String fileName = br.readLine();
                Log.i(TAG, "ReceiveFile  br  =  " + br + "  fileName = br.readLine() = " + br.readLine());

                br.close();
                inputStreamReader.close();
                nameIPS.close();
                name.close();
                SendMessage(0, "正在接收:" + fileName);

                Socket data = ss.accept();
                Log.i(TAG, "ReceiveFile  Socket data =   " + data);
                //3. 获取客户端发送过来的数据
                InputStream dataIPS = data.getInputStream();
                Log.i(TAG, "ReceiveFile:  dataIPS  =  " + dataIPS);
                //BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(dataIPS));

                String savePath = Environment.getExternalStorageDirectory().getPath() + "/DCIM/Screenshots/" + fileName;
                savePath = savePath.replaceAll(regEx, "");
                Log.i(TAG, "ReceiveFile  savePath  =  " + savePath);

                FileOutputStream fos = new FileOutputStream(savePath, false);
                Log.i(TAG, "ReceiveFile FileOutputStream fos   =  " + fos);
                //装载文件名的数组
                byte[] buffer = new byte[1024];
                int size;
                while ((size = dataIPS.read(buffer)) != -1) {
                    Log.i(TAG, "ReceiveFile size  ==  " + size);
                    fos.write(buffer, 0, size);
                    fos.flush();
                }
                fos.flush();
                fos.close();
                //告诉发送端我已经接收完毕
                //OutputStream outputStream = data.getOutputStream();
                fos.close();
                dataIPS.close();
                data.close();
                SendMessage(0, fileName + "接收完成");
            }
        } catch (Exception e) {
            SendMessage(0, "接收错误:\n" + e.getMessage());
        }
    }
}

3. activity_a2a_transfer.xml

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingLeft="16dp"
    android:paddingTop="16dp"
    android:paddingRight="16dp"
    android:paddingBottom="16dp">

    <ScrollView
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <RelativeLayout
            android:layout_width="match_parent"
            android:layout_height="match_parent">

            <TextView
                android:id="@+id/tvMsg"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_alignParentTop="true"
                android:focusable="false"
                android:focusableInTouchMode="false"
                android:text="TextView"
                android:textColor="#AAA" />

            <EditText
                android:id="@+id/txtIP"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_below="@+id/tvMsg"
                android:layout_centerVertical="true"
                android:contentDescription="目标IP地址"
                android:ems="10"
                android:text="192.168.1.10" />

            <EditText
                android:id="@+id/txtPort"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_below="@+id/txtIP"
                android:layout_alignLeft="@+id/txtIP"
                android:ems="10"
                android:text="9999" />

            <EditText
                android:id="@+id/et"
                android:layout_width="match_parent"
                android:layout_height="300dp"
                android:layout_below="@+id/txtPort"
                android:layout_alignLeft="@+id/txtIP"
                android:clickable="false"
                android:editable="false"
                android:ems="10"
                android:focusable="false"
                android:focusableInTouchMode="false"
                android:gravity="center_vertical|left|top"
                android:inputType="textMultiLine"
                android:longClickable="false"
                android:scrollbarAlwaysDrawVerticalTrack="true"
                android:scrollbarStyle="insideInset"
                android:scrollbars="vertical"
                android:textSize="15dp">

                <requestFocus />
            </EditText>

            <Button
                android:id="@+id/btnSend"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_below="@+id/et"
                android:layout_alignLeft="@+id/txtPort"
                android:text="选择文件并发送" />



            <TextView
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:textColor="#090909"
                android:textSize="16sp"
                android:text="注意：\n本机IP应在WIFI设置中设置为静态！\n文件默认保存在手机截图的默认保存位置\n输入框输入接收对象的IP；"
                android:layout_below="@+id/btnSend"/>


        </RelativeLayout>
    </ScrollView>

</RelativeLayout>

4. 依赖

//使用指南：https://github.com/spacecowboy/NoNonsense-FilePicker
implementation 'com.nononsenseapps:filepicker:4.1.0'

5. manifest

  1. 权限

    <uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission
        android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"
        tools:ignore="ProtectedPermissions" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />

  2. 在 application 中添加如下：

    <activity
    android:name="com.nononsenseapps.filepicker.FilePickerActivity"
    android:label="选择文件"
    android:theme="@style/FilePickerTheme">
    <intent-filter>
        <action android:name="android.intent.action.GET_CONTENT" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>
<provider
    android:name="androidx.core.content.FileProvider"
    android:authorities="${applicationId}.provider"
    android:exported="false"
    android:grantUriPermissions="true">
    <meta-data
        android:name="android.support.FILE_PROVIDER_PATHS"
        android:resource="@xml/nnf_provider_paths" />
</provider>

6. 注意

  1. 本文没有进行权限处理，打开应用，默认请求存储权限，如果选择禁止并没有做处理；
  2. 本文接收文件默认保存的目录在：安卓系统截图的保存位置：DCIM/Scrennshots ，可以自行调试；
  3. 使用时将安卓端 IP 设置为静态 IP；
  4. 推荐不错的项目：https://www.imooc.com/article/296288；这不是我的文章，不过文中两个项目十分不错，可以借鉴。
  5. 如果可行，请给我赞把。笔芯

声明：本文整理自网络，如有侵权请联系我。

android socket局域网文件传输
11-11
android socket局域网文件传输 代码 可以在局域网内接收文件 发送文件等 配合 “C#socket局域网文件传输电脑端” 可使电脑和安卓手机之间在局域网内传输文件
Android代码-安卓版的局域网文件传输
08-06
描述 开发此app最初的目的用于解决手机和Linux相互分享文件, 因此同时用python开发了桌面版(包含Windows和Linux), 桌面版下载 注意：安装应用程序后，安卓用户如发现程序无法访问文件系统，请检查手机的权限设置，确保给了程序相应的权限，程序以系统设置的默认存储位置根目录为路径访问起点 程序在以下情况均可工作: 手机-手机(WiFi) 手机-笔记本(WiFi) 手机-路由器-笔记本 手机-路由器-手机 台式机-路由器-台式机 笔记本-路由器-台式机 笔记本-笔记本(WiFi) 豌豆荚下载地址 主界面 发送 接收
android局域网通信（传文件）
02-26
android局域网通信（传文件）
电脑-Android手机之间TCP协议局域网文件传送
08-29
一个还好的Android手机无线（WIFI）连接无线路由实现局域网 连接电脑后，进行文件传送的Socket/TCP实例。 需要手机WIFI连接局域网，并设定IP地址，地址可在程序文件找到，或者自行对应修改，需要统一。
Android基于局域网的socket通信
小小9575的博客
07-23 7454
最近写了一个关于局域网socket通信的demo，代码和ui都很low，但是功能实现了，所以贴出来记录一下 主要流程如下 服务端：启动服务--&gt;显示ip--&gt;等待接收--&gt;显示消息--&gt;收到回复 客户端：录入ip--&gt;输入消息--&gt;发送消息--&gt;收到结果 如下图 选择服务端还是客户端 显示服务端ip 客户端输入ip发送消息 服务...
Android基于局域网socket通信
07-23
在Android平台上，实现基于局域网的Socket通信是一项常见的任务，尤其在开发涉及设备间通信的应用时。Socket通信允许两台设备通过网络连接直接交换数据，而无需中间服务器。在这个项目中，我们关注的是Android设备...
android socket局域网文件传输131114
11-14
本项目"android socket局域网文件传输131114"是针对这一需求实现的一个示例，它利用了Socket、多线程以及ListView等Android核心组件，旨在提供一种高效、稳定、用户友好的文件共享解决方案。 首先，Socket作为TCP/...
Android和PC端通过局域网文件同步
08-27
这项技术主要应用于局域网环境中，通过Socket编程实现文件的传输和同步。 在Android端，使用Java语言编写了一个 SocketManager 类，负责与PC端建立连接，并实现文件的传输。该类中使用了ServerSocket对象来监听PC端...
Android与PC间局域网文件传输的socket实现
根据给定文件信息，以下是关于“Android socket局域网文件传输”的详细知识点： ### 知识点一：Socket通信基础 Socket（套接字）是计算机网络数据传输的一种方法，为网络通信提供了端点。在Android开发中，使用...
Android基于wifi模块的局域网聊天以及文件传输app
05-28
一款基于wifi模块的局域网实时聊天以及文件互传的安卓app，能实现热点创建，热点连接，文件传输，实时通讯等功能。
安卓局域网文件传输
11-10
一个类似飞鸽传书安卓版的局域网文件传输项目源码，可以实现视频或者照片的传输。
Android手机间使用socket进行文件互传
08-01
Android socket 文件互传 Android系统间使用socket进行文件互传
Android网络编程只局域网传输文件
chench
04-27 883
Android网络编程只局域网传输文件 首先创建一个socket管理类，该类是传输文件的核心类，主要用来发送文件和接收文件 具体代码如下： ```java 1 package com.jiao.filesend; 2 3 import java.io.BufferedReader; 4 import java.io.BufferedWriter; 5 import java.io.FileInputStream; 6 import java.io.FileOutputStream
实现Android手机之间在局域网下传输任意文件
毕业作品网站
07-22 7170
相比于通过WiifDirect进行文件传输，通过Wifi热点进行设备配对更加方便，逻辑也更为直接，传输一个1G左右的压缩包用了5分钟左右的时间，平均传输速率有3.5M/S左右。此外，相对于上个版本，新版本除了提供传输进度外，还提供了传输速率、预估完成时间、文件传输前后的MD5码等数据。实现的效果如下所示开启Ap热点接收文件连接Wiif热点发送文件文件传输完成后校验文件完整性。...
android局域网怎么传文件,两手机同一局域网怎么传文件
weixin_32498069的博客
05-29 2320
如今很多家庭都有自己的局域网，安卓手机的文件管理器ES文件浏览器，当我们使用它来访问电脑上的共享文档时，常常出现很多问题而无法访问。下面是小编为大家整理的关于，一起来看看吧!首先确保你的环境满足以上2点要求，本经验主要侧重于设置pc，正确设置好了，用安卓设备访问pc的共享目录很简单设置pc按下win+r或者点选屏幕左下角的开始图标，在搜索框中输入“服务”，打开“服务”对话框，确保Server与Wi...
android 局域网socket,Android基于局域网socket通信
weixin_42347426的博客
05-28 280
【实例简介】关于android基于局域网socket通信的完整demo，详细见https://blog.youkuaiyun.com/weixin_40998254/article/details/81163701【实例截图】【核心代码】SocketApplication└── SocketApplication├── SocketApplication.iml├── app│ ├── app.iml│...
android 之间用socket进行局域网传输文件
红色与青色
06-12 5025
公司要求搞个手机控制电视盒子的功能，涉及到文件传输和控制指令，网上有很多例子，简单的总结一下，使用一个socket线程来进行文件传输和指令传输server端WifiFileServers.javapublic class WifiFileServers { private ServerSocket serverSocket = null; private String serve...
Android通过Socket实现局域网通信例子
只有静静努力，才能默默躺平~
11-14 3626
最近工作上涉及比较多局域网连接和通信的业务需求，发现自己在这块一直是一个空缺，因此在网上找了一些资料，也在AS上试着验证，基本没有什么问题。 好了，不多说，直接上代码。 首先是Server端的代码实现： 1）MainActivity.java package com.example.socketserver; import androidx.appcompat.app.AppCompatActivity; import android.content.Context; import andro
socket 局域网通信-Android
被拱了的白菜
03-30 341
Android socket 局域网通信1.客户端ACG（服务端类似）1.1.创建程序，编写界面代码（fragment_acg.xml）1.2.编写界面交互代码（AcgFragment.class）1.3.添加访问网络权限1.4.项目源码 1.客户端ACG（服务端类似） 本来是想仿照手机软件的，没成功，这个app有过渡界面（SplashActivity）还有主界面（HomeActivity）,主界...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

liusaisaiV1

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值