精华内容
下载资源
问答
  • 手机连接电脑传输文件(手机usb连接电脑只充电)
    千次阅读
    2021-07-28 03:37:47

    边肖最近用WIN10专业版重新安装了他的华硕笔记本,然后准备用u盘把他的魅族E3手机连接到笔记本上。我发现插在笔记本上的手机没有出现在我的电脑上,我找不到驱动器号或移动磁盘标志。边肖自己的手机魅族E3就是一个例子。

    通过数据线连接我的手机和笔记本电脑,我发现我的电脑里根本没有移动磁盘。

    然后,您可以尝试右键单击桌面上的“我的电脑”图标,找到“管理”,然后进入“电脑管理”。在系统工具下,有一个设备管理器。点击进入后,右边显示的顶部是ANDROID DEVICE。

    在这个ANDROID设备下,你可以看到有一个ANDROID通用串行总线调试。我们可以双击这个ANDROID USB调试进入它的属性窗口。进入属性窗口后,顶部菜单栏中的第二项是驱动程序。在我们点击它之后,下面有一个更新的驱动程序。

    我们单击更新驱动程序,弹出一个对话框。我们选择第二个:浏览电脑找到驱动程序(手动找到并安装驱动程序)。

    浏览完计算机上的驱动程序文件后,我们选择以下选项:从计算机上的设备驱动程序列表中选择。

    然后输入以选择要为此硬件安装的设备驱动程序。该型号下有一个MTP通用串行总线设备。双击MTP通用串行总线设备开始自动安装驱动程序软件。等待一段时间后,系统会提示您已成功安装MTP通用串行总线设备驱动程序文件。

    这时,我们又去了设备管理器,找到了一个便携式设备。我的手机型号魅族E3如下图所示。当我们再次打开我的电脑时,我们可以看到我的魅族E3手机磁盘已经显示,这样每个人都可以正常传输手机文件。

    来源:灯塔,欢迎分享这篇文章!

    更多相关内容
  • PC与Android设备进行USB文件传输

    热门讨论 2014-10-17 16:22:44
    上位机c#源代码:在PC上实现与Android设备的数据传输,完美使用ADB命令 功能包括: 1.上传文件 2.上传文件夹 3.下载文件 4.下载文件夹 5.删除Android文件 6.删除Android文件夹 7.创建Android文件夹
  • 如果我们要将安卓手机连接到电脑上,从而传输文件、下载应用或ROOT等,都需要打开手机USB调试模式。安卓系统的版本有很多,它们的打开方法也各不相同,下面给大家介绍各版本安卓手机打开USB调试模式的方法。步骤...

    如果我们要将安卓手机连接到电脑上,从而传输文件、下载应用或ROOT等,都需要打开手机的USB调试模式。安卓系统的版本有很多,它们的打开方法也各不相同,下面给大家介绍各版本安卓手机打开USB调试模式的方法。

    步骤方法:

    一、2.1—2.3.7 系统打开方法

    1、点击手机-Menu键(菜单键),在弹出的菜单中选择设置(Setting),或在应用程序中找到设置程序点击进入;

    2、进入设置界面的应用程序即可打开USB调试模式。

    114781910_1_20171029030534604

    二、4.0 —4.1.2 系统打开方法

    1、点击手机Menu键(菜单键),在弹出的菜单中选择设置(Setting),或在应用程序中找到设置程序点击进入;

    2、进入设置界面的开发人员选项即可打开USB调试模式。

    114781910_2_20171029030534745

    三、4.2、4.3、4.4 系统打开方法

    1、点击手机Menu键(菜单键),在弹出的菜单中选择设置(Setting),或在应用程序中找到设置程序点击进入;

    2、点击关于手机;

    114781910_3_20171029030544135

    3、连续点击七次版本号;

    4、再返回设置菜单界面选择开发者者选项;

    114781910_4_20171029030544260

    展开全文
  • 摆脱MTP ,实现PC与Android之间的文件传输,海量存储比MTP更兼容。 使用手机替换物理USB闪存驱动器。 使用现有的iso或pe映像进行PC系统维护,无需刻录磁盘。 UMSInterface APP不再维护。 如果您仍要使用此APP,...
  • 因为老板认为wifi连接的方式传输数据太慢,想通过USB传输来实现与硬件的连接,所以通过android客户端作为主设备,终端硬件作为从设备。其中收到数据的处理和 下发设置帧的生成与wifi连接的方式都相同,就不赘述。本...

    因为老板认为wifi连接的方式传输数据太慢,想通过USB传输来实现与硬件的连接,所以通过android客户端作为主设备,终端硬件作为从设备。其中收到数据的处理和 下发设置帧的生成与wifi连接的方式都相同,就不赘述。本篇主要谈 usb的数据传输。

    数据传输流程:需要软件、硬件、驱动程序的共同配合

    硬件部分:USB主控制芯片 (集成在计算机主板上,负责USB主机的功能实现)

    USB HUB芯片   (集成在计算机主板上,或者可以由外设USB HUB来实现,负责扩展USB接口数量)

    USB功能设备芯片  (集成在USB设备中, 完成传输的核心器件)

    软件部分:USB主机程序 (用户可以直接操作,常常具有人机交互页面,标准USB鼠标和标准USB键盘除外)

    USB总线驱动程序 (负责USB主机程序的请求响应)

    USB主控制器驱动程序(负责数据传输的事务处理)

    USB功能设备程序(负责USB设备的核心功能实现)

    USB下发数据

    1)USB主机程序准备好待下发的数据,并将数据保存在USB发送断点的数据缓冲区,然后向USB总线驱动程序发送IO请求包(IRP),也就是数据传输请求。

    2)USB总线驱动程序响应USB主机程序的数据传输IO请求包(IRP),将其中数据转化为相应的USB事务处理格式,然后将该数据处理向下传递给USB主控制器驱动程序

    3) USB的主控制器驱动程序对每个接收到的事物进行处理,转化为一系列的事务处理队列

    4) USB主控制器将帧或者小帧为单位的事务处理队列以信息包的形式向外发送。按照规定的传输方式(块传输,控制传输,中断传输,同步传输)在USB总线上 传输

    5)外设USB芯片接收到总线的信息。通过SIE引擎自动解码出信息包,将其保存在指定USB端点的数据缓冲区,供USB设备处理

    USB上传数据 与下发类似,整个流程正好反过来。

    四种传输方式

    8ed57ce1d8cf42d13f9d476d33269c58.png

    中断传输 一般用于传输少量或中量数据,常应用于USB鼠标 USB键盘需要进行及时的人机交互,要求设备响应快,有固定的事务处理周期,对数据的需求低,不适用于本次项目。

    同步传输 适合于传输大量的,速率恒定的对服务周期有要求的数据,对正确性没有严格要求。常用于音视频设备,对数据正确性有一定容忍

    控制传输适合于传输少量,严格要求传输正确性,对传输时间、传输速率和实时性均无要求,

    块传输

    适合于传输大量的数据,要求传输的正确性,对传输时间速率实时性无要求。

    该项目中 主要待传输的数据有:

    硬件设置/查询帧(host to device):数据量小,要求实时性高,不定期发送,属于控制信息,准备采用控制传输的方式

    硬件查询响应回复帧 (device to host):数据量小,要求实时性高,收到查询帧后需要立即回复,准备采用控制传输的方式

    功率谱帧 POA帧 TDOA帧 录音帧 IQ帧 (device tohost):,数据量大有一定的正确性,采用块传输的方式

    展开全文
  • Android使用usb线传输文件笔记

    千次阅读 2019-04-21 00:54:46
    使用usb线传输文件 参考资料: 使用USB数据线连接PC端和Android端进行数据的交互 安卓设备通过USB接口实现与pc端的简单数据通信 Socket TCP/IP协议数据传输过程中的粘包和分包问题 【Android学习】socket长连接,...

    使用usb线传输大文件

    参考资料:

    1. 使用USB数据线连接PC端和Android端进行数据的交互
    2. 安卓设备通过USB接口实现与pc端的简单数据通信
    3. Socket TCP/IP协议数据传输过程中的粘包和分包问题
    4. 【Android学习】socket长连接,数据粘包问题

      由于客户应用使用的场景比较特殊。明确要求不能使用网络进行数据交互,所以不得不研究了一下使用usb通信这方面。原理就是当连上usb线后,通过socket进行数据通信。只不过android设备作为socket服务端,pc作为socket的客户端。pc端在与服务端建立连接之前需要使用adb命令设置转发端口(具体可参考参考资料1和参考资料2)。
      端口这玩意随便填,不跟别人冲突就行。

    adb shell am broadcast -a NotifyServiceStop
    adb forward tcp:9999 tcp:9000
    adb shell am broadcast -a NotifyServiceStart

    ##使用代码调用命令行
      如果想要完善android通过usb先进行数据交互,这里应该有不少的命令能用到,这里先记录一下调用命令的基本使用。

    import java.io.BufferedReader
    import java.io.InputStreamReader
    
    fun main() {
    
      //读取连接设备
      val process = Runtime.getRuntime().exec("adb devices")
      val devices = BufferedReader(InputStreamReader(process.inputStream))
      val stringBuilder = StringBuilder()
      var line: String? = null
      while (devices.readLine().apply { line = this } != null) {
        stringBuilder.append("$line\n")
      }
      println(stringBuilder.toString())
    
      //读取安装的应用
      val process2 = Runtime.getRuntime().exec("adb shell pm list packages")
      val packages = BufferedReader(InputStreamReader(process2.inputStream))
      val sb = StringBuilder()
      var line2: String? = null
      while (packages.readLine().apply { line2 = this } != null) {
        sb.append("$line2\n")
      }
      println(sb.toString())
    
    }
    

      打印结果如下图所示:
    在这里插入图片描述
      上面运行结果不错就是代码量有点多,用python简化一下就清晰不少。

    import subprocess
    
    if __name__ == '__main__':
        # 读取连接设备
        subprocess.call("adb devices", shell=True)
        # 读取安装的应用
        subprocess.call("adb shell pm list packages", shell=True)
    
    

    Android端

      Android端作为Socket的服务端,用来接收文件。为了防止分包的问题这里我定义了一个封包和解包方式。
    在这里插入图片描述
      在文件传输的时候,数据的收发都会以这种结构去发送或者接收。(实际情况下肯定跟这个不一样,我这为了方便携带参数用的就是json格式的数据)。理论上就是每次读取的字节大小都在携带信息中。如果在循环读取中有一次没有读满,那就把它应当读取的字节都读取出来,再循环下一次数据读取,省着出现粘包的现象。(byte也别设太大,要不内存溢出)

    package com.lyan.usbtestphone
    
    import android.annotation.SuppressLint
    import android.support.v7.app.AppCompatActivity
    import android.os.Bundle
    import android.os.Environment
    import android.os.Handler
    import com.blankj.utilcode.constant.PermissionConstants
    import com.blankj.utilcode.util.GsonUtils
    import com.blankj.utilcode.util.LogUtils
    import com.blankj.utilcode.util.PermissionUtils
    import com.blankj.utilcode.util.ToastUtils
    import kotlinx.android.synthetic.main.activity_main.*
    import java.io.*
    import java.net.ServerSocket
    import java.net.Socket
    
    class MainActivity : AppCompatActivity() {
    
        @SuppressLint("SetTextI18n")
        private val handler = Handler(Handler.Callback {
            when (it.what) {
                1 -> progressTv.text = "${it.obj}%"
            }
            false
        })
    
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_main)
    
            testBtn.setOnClickListener {
                startSocketServer { LogUtils.i("${Thread.currentThread().name} : $it") }
            }
        }
    
        private fun startSocketServer(callback: (name: Socket) -> Unit) = Thread {
            val file = File(Environment.getExternalStorageDirectory(), "copy.db3")
            if (file.exists()) {
                if (file.delete()) {
                    file.createNewFile()
                }
            } else {
                file.createNewFile()
            }
            ServerSocket(9000).apply {
                logI("移动服务端等待客户端的连接...")
                val client = this.accept()
                callback.invoke(client)
                val bufferedOutputStream = BufferedOutputStream(DataOutputStream(FileOutputStream(file)))
                val bufferedInputStream = BufferedInputStream(DataInputStream(client.getInputStream()))
                val tagBytes = ByteArray(6)
                val infoBytes = ByteArray(4)
                var hTag: String//标记头
                var fTag: String//标记尾
                var infoSize: Int//携带数据的一些信息
                var jsonBytes: ByteArray//携带数据的byte数组
                var sendInfoData: SendInfoData//解析后的携带信息
                var readBytes: ByteArray//真正传输的数据的byte数组
                var readSize: Int//真正传输的数据的byte长度
                while (true) {
    
                    val len = bufferedInputStream.read(tagBytes)
                    if (len == -1) {
                        break
                    }
                    hTag = String(tagBytes, 0, len)//标记头
                    //读取进度信息
                    infoSize = bufferedInputStream.read(infoBytes).run { bytesToInt(infoBytes) }
                    jsonBytes = ByteArray(infoSize)
                    sendInfoData = bufferedInputStream.read(jsonBytes).run {
                        val infoJson = when (infoSize) {
                            this -> {//读取数据完整
                                LogUtils.i("读取数据完整")
                                String(jsonBytes, 0, this)
                            }
                            else -> {//读取数据不完整(此处只要将分包处理后、粘包的问题自然就不会出现了)
                                LogUtils.i("读取数据不完整")
                                bufferedInputStream.read(jsonBytes, this, infoSize - this).run {
                                    String(jsonBytes, 0, infoSize)
                                }
                            }
                        }
                        LogUtils.i("其他信息 ------> $infoJson")
                        GsonUtils.getGson().fromJson(infoJson, SendInfoData::class.java)
                    }
                    handler.obtainMessage(1, sendInfoData.percent).sendToTarget()
                    //读取数据信息 传输数据大小 解析数据长度
                    readBytes = ByteArray(sendInfoData.sendSize)
                    readSize = bufferedInputStream.read(readBytes)//已读数据大小
                    LogUtils.i("读流的长度:$readSize")
                    if (readSize < sendInfoData.sendSize) {
                        LogUtils.w("读取数据不完整!已读数据少于应读取数据的大小……",
                                "应读:${sendInfoData.sendSize}", "实读:$readSize")
                        bufferedInputStream.read(readBytes, readSize, sendInfoData.sendSize - readSize)
                    }
                    fTag = bufferedInputStream.read(tagBytes).run { String(tagBytes, 0, this) }
                    LogUtils.w("header:$hTag", "携带信息的字节数:$infoSize", "携带信息内容:$sendInfoData",
                            "每次应读取的数据字节数量:${sendInfoData.sendSize}", "footer:$fTag")
                    bufferedOutputStream.write(readBytes)
                    bufferedOutputStream.flush()
                }
            }
        }.start()
    
        //请求权限(文件读写权限)
        override fun onResume() {
            super.onResume()
            PermissionUtils.permission(PermissionConstants.STORAGE).callback(object : PermissionUtils.SimpleCallback {
                override fun onGranted() {
                    ToastUtils.showShort("获取文件读写权限成功!")
                }
    
                override fun onDenied() {
                }
            }).request()
        }
    
        private fun bytesToInt(bytes: ByteArray): Int {
            return (0 until bytes.size).sumBy { (bytes[it].toInt() and 0xFF) shl it * 8 }
        }
    
        //每次接收数据的信息 进度 和 要保存的数据字节大小
        data class SendInfoData(val percent: String, val sendSize: Int)
    }
    
    

    pc端(正常应该是后台)

      在这种情况下后台就成客户端了。这里为了减少socket客户端的代码量,所以使用ptyhon来写:

    import subprocess
    import socket
    import time
    import copy
    import json
    import os
    
    
    class SendInfoData(object):
    
        def __init__(self, percent="", sendSize=0):
            self.__percent = percent
            self.__sendSize = sendSize
    
        def toJson(self):
            return json.dumps({
                "percent": self.__percent,
                "sendSize": self.__sendSize,
            })
    
    
    # int转byte数组
    def intToBytes(intNumber=0): return intNumber.to_bytes(4, "little")
    
    
    # str转utf-8 byte数组
    def strToUtf8Bytes(value): return bytes(value, encoding="utf-8")
    
    
    if __name__ == '__main__':
    
        subprocess.call("adb shell am broadcast -a NotifyServiceStop", shell=True)
        subprocess.call("adb forward tcp:9999 tcp:9000", shell=True)
        subprocess.call("adb shell am broadcast -a NotifyServiceStart", shell=True)
    
        client = socket.socket()
        result = client.connect(("127.0.0.1", 9999))
    
        # 文件路径
        filePath = "/Users/apple/Downloads/base.db3"
    
        # 文件大小
        allSize = os.path.getsize(filePath)
        fileSize = copy.deepcopy(allSize)
        print("%s\n" % fileSize)
        defaultReadSize = 1024 * 10
        progress = 0
    
        h = time.time()
        # 读取 文件
        with open(filePath, mode="rb") as readFile:
            while True:
                if fileSize <= 0: break
                readSize = defaultReadSize if fileSize > defaultReadSize else fileSize
                progress += readSize
                percent = '{: .2f}'.format(progress * 1.0 / allSize * 100)
                print("进度:%s" % percent)
                # 读取内容
                readBytes = readFile.read(readSize)
                if not readBytes: break
                tagH = strToUtf8Bytes("@tag:h")
                tagF = strToUtf8Bytes("@tag:f")
                # 携带信息
                infoJson = SendInfoData(percent, readSize).toJson()
                print("json:%s\n" % infoJson)
                infoBytes = strToUtf8Bytes(infoJson)
                infoSize = intToBytes(len(infoBytes))
                # 包裹传输数据
                client.send(tagH)  # 标记开头
                client.send(infoSize)  # 携带参数byte数据长度
                client.send(infoBytes)  # 携带参数内容
                client.send(readBytes)  # 真实传输的内容
                client.send(tagF)  # 标记结尾
                fileSize -= readSize
    
        client.close()
    
        f = time.time()
        print("用时:{: .0f}s".format((f - h)))
    
    

      这个例子的界面比较简单,就一个按钮和一个文本。手上测试的文件是一个900多兆的文件,在单位的时候试过一个4个多G的sqlite文件。而且文件在传输后一样可以正常使用。说明这个方式还是可行的。(当然在实际项目中这个例子仅仅是证明这个方式可行而已,具体优化部分肯定不带少的)
    在这里插入图片描述
    在这里插入图片描述

    笔记:byte[]未写满,补全的方式

      目的是验证,这里以读取文件的内容为例,文件是txt格式的这里放了一段字符串“一二三四五六七八九十”。一共是10字符(一个字符2个字节,也就是20个字节)。定义一个byte数组长度为20。先读一半,然后再读剩下的一半。

    import java.io.File
    import java.io.FileInputStream
    import java.nio.charset.Charset
    
    fun main() {
    
        val path = "/Users/apple/Downloads/O.txt"
        val file = File(path)
        val inputStream = FileInputStream(file)
        //available()这个方法本质的意义是 剩余未被读取的字节数量
        println("文件的字节总数:${inputStream.available()}")
    
        val byte = ByteArray(20)
    
        val read1 = inputStream.read(byte, 0, 10)
        println(read1)
        println("read1后剩余字节数量:${inputStream.available()}")
        val read1Msg = String(byte, 0, read1, Charset.forName("GBk"))
        println(read1Msg)
    
        inputStream.read(byte, 10, 20 - read1)
        println("read2后剩余字节数量:${inputStream.available()}")
        val read2Msg = String(byte, 0, byte.size, Charset.forName("GBk"))
        println(read2Msg)
    
    }
    

      这块结合Android端那段代码看正好(一旦索引那想不明白,真不如运行代码来的实在),运行结果如下。
    在这里插入图片描述

    展开全文
  • 1、监听UsbManager.ACTION_USB_STATE public class UsbManager { private static final String TAG = "UsbManager"; /** * Broadcast Action: A sticky broadcast for USB state change events when in device ...
  • android手机如何通过USB和pc互相传输文件啊,使用代码传输,比如在pc上的web浏览器点击某个按钮导入数据至sd卡,或者点击手机app上的某个按钮将文件传到pc硬盘上
  • Android 使用USB进行数据传输

    万次阅读 2019-07-15 01:56:20
    1.Android通过两种模式支持各种USB设备 USB host 和USB accessory (Android3.1 API 12以上) USB Host Mode 主机模式:Android设备充当主设备,并为总线供电 USB Accessory Mode 附件模式:外部硬件充当USB主...
  • usb的四种传输模式对应的场景: 1.批量传输 USB协议提供批量传输类型是为了支持在某些不确定的时间内进行大量的数据通信,如打印机、扫描仪、硬盘、光盘等设备 2.控制传输 USB协议引用控制传输有两方面的原因,...
  • 而不会将线程绑定到其上,那么我认为您需要考虑使用DeviceConnection.getFilehandle()方法来返回一个标准文件句柄,理论上可以这样处理使用它就像是任何其他文件类型的资源.不过我会注意到我没有尝试过. 如果这两个都...
  • 无线传输文件步骤: 1.先通过usb连接电脑,AndroidStudio命令窗口输入 adb tcpip 555 2.adb connect [手机局域网地址(172.168.xx.xx)]:5555 3.adb push [pc端文件] copy local [手机端存放地址] 示例:adb push D:...
  • 三星手机连接电脑传输文件教程打开手机主屏幕,在手机桌面中找到“设定”图标。看到有“设定”的图标以后,点击打开。打开“设定”以后,找到第一个“无线和网络”选项。找到“无线与网络”以后,点击打开。打开后,...
  • android pc传送Mounting your Android phone to transfer files is fast and efficient, but nothing beats the convenience of a wireless file transfer. Today, we’ll show you how to transfer files between ...
  • 关于public int controlTransfer (int requestType, int request, int value, int index, byte[] buffer, int...关于android做为主设备与HID设备的通信,这主要想讲解的就是关于controlTransfer (int requestType, in...
  • android usb host实现串口传输数据

    热门讨论 2012-07-03 20:13:12
    3.1版本之后支持的usb host API。可以通过usb接口让安卓设备作为主设备来接收来自usb的数据,比如平板上插个单片机,就可以接收单片机的数据了。该程序封装了多个包,实现了该功能。
  • 自己写的一个小Dome,不是项目,主要是使用USB数据线来连接PC端和Android端进行一个数据的交互。一个PC端的客户端类,和Android端的服务端代码。
  • Android Studio开发的代码,可以通过USB往U盘传输数据,经过测试,可以使用。
  • 通过设置系统属性(System Property)[persist.sys.usb.config]即可实现关闭或打开USB调试和文件传输功能,其中mtp表示文件传输,adb表示adb调试,none表示都不启用。以下为在程序中实现的代码:public class Usb...
  • 第2部分。使用dr.fone将Android数据传输到Macdr.fone(Mac) - 转移(Android)是一个功能强大,高效且易于使用的工具,可以通过一系列简单的步骤帮助将各种...在Android和计算机之间传输文件,包括联系人,照片,音乐,...
  • 英特尔Android安卓设备USB驱动是英特尔专为安卓手机打造的一款驱动程序,安装驱动后可将手机连接电脑,进行文件传输、共享、下载等功能,欢迎下载!英特尔安卓usb驱动简介英特尔AtomZ2460处理器是英特尔公司首款针对...
  • 材料准备 Mac Book Pro 数据线(USB/雷电都可以) 安卓手机 适用安卓系所有品牌的手机 下载Android File Transfer ... 下载完成后安装,然后双击打开,就可以在访达里面传输文件了 ...
  • 这篇文章还可以通过USB传输文件,但是更容易无线地完成任务。发生这种情况的唯一先决条件是两个设备必须连接到同一个网络。有几种方法来实现这个功能;然而,我们已经将该过程缩小到称为Wi-Fi文件传输的一个应用程序...
  • android 文件传输The “Send to” menuhas been around since Windows 95; so long a lot of users might have forgotten about it. You may not know it, but you can use “Send to” to smartlytransfer files to...
  • pc与android通过usb socket实现手机通信Demo

    千次下载 热门讨论 2013-08-01 20:02:06
    a.PC客户端与Android服务端的Socket同步通信(USB) b.操作步骤如下: ----------------------------------------------------------- 1.请将测试数据文件夹中的ucliulanqi.apk copy到c:\下进行测试 2. 将android...
  • 如何将音视频文件传输安卓设备中万兴优转与Android设备完全兼容,并且可以通过几个鼠标剪辑轻松地将媒体文件传输Android智能手机或平板电脑上。你所需要做的就是,在你的电脑上获取视频,将你的设备连接到电脑上...
  • 一:文件传输android开发中,有时候需要将文件从pc端传递至android,或者将软件运行的日志,从...2:设备连接后,将pc文件传输android设备 adb -s xxxx push C:/advert /sdcard/ 3:将android设备文件传递至pc电脑 a

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,828
精华内容 3,931
关键字:

安卓手机usb传输文件