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

最新推荐文章于 2024-06-13 15:36:47 发布
最新推荐文章于 2024-06-13 15:36:47 发布
阅读量949 收藏 8
点赞数 1
分类专栏： Android学习总结 文章标签： 网络 android java 安卓
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liusaisaiV1/article/details/107756929
版权

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

声明：本文参考自网络资料，绝非首创，感谢以下，但不止于以下几篇博客：
https://www.cnblogs.com/yangfengwu/p/12543923.html
https://blog.csdn.net/cai13160674275/article/details/50152579
https://blog.csdn.net/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. 如果可行，请给我赞把。笔芯

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

liusaisaiV1
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Android基于局域网socket通信
07-23
关于android基于局域网socket通信的完整demo，详细见https://blog.csdn.net/weixin_40998254/article/details/81163701
android socket局域网文件传输
11-11
"android socket局域网文件传输"这个主题涉及到的是如何在局域网环境下，通过Android设备与另一台设备（例如电脑）进行文件的发送和接收。在本文中，我们将深入探讨相关的知识点，包括Socket的基本概念、Android中的...
【小沐学Android】Android实现socket网络通信
爱看书的小沐
11-21 1万+
🍺SOCKET网络通信系列文章链接如下：🍺 🎈【小沐学python】（一）Python简介和安装🎈 🎈Python实现socket网络通信🎈 🎈C++实现socket网络通信（Windows）🎈 🎈Android实现socket网络通信🎈 🎈nodejs实现socket网络通信🎈 Android实现socket网络通信1、简介1.1 socket流程1.2 需要在子线程运行1.3 需要的权限2、环境配置2.1 Android Studio下载2.2 真机无线调试3、TCP方式3.1 服务端3.2 客户端3
如何轻松地将文件从Android传输到 PC | 7 种方法
最新发布
Coolmuster的博客
06-13 3117
本文介绍了7种将文件从Android设备传输到PC的方法，包括蓝牙传输、云服务共享、电子邮件发送、通过QQ或微信发送、Microsoft Phone Link、USB数据线传输，以及使用Coolmuster Android Assistant软件。每种方法都提供了详细的操作步骤，确保用户能够根据自己的需求选择最合适的传输方式。Coolmuster Android Assistant以其全面的数据管理和备份功能脱颖而出，为用户提供了一种简便、安全且高效的文件传输解决方案。
android Socket文件传输（readFully)
weixin_52263647的博客
09-02 1528
最近写的项目里要用到文件传输的功能，因此我查找了很多相关的博文，查找到的文章都大同小异。但是这些内容仅限于一些小文件，比如一个几百K到的txt文档，但是我们实际需要传输的数据量远大于这个数，解决不了实际问题。因此这篇博文将用readfully方法实现较大文件的传输，当然这个也有一定的局限性，只适用一些较大的文件，大约在100M以内，对于更大的文件，涉及断点续传的问题，本篇文章没有展现。
Android 使用socket实现两个真机之间的通信
热门推荐
广靓 的博客
10-18 1万+
1、使用Socket进行两个手机之间的通信需要安装两个不同的代码文件：服务端和客户端 分别进行安装 2、创建局域网：两个手机同时连一个WiFi或者两个手机进行热点和WLAN连接 3、客户端连接另一个手机IP时把另一个手机的IP改成静态IP（3的第二种方法做这个步骤） 下面上代码分客户端的和服务端的，布局文件textview、Editview、Button不上代码了，不懂socket通信原...
在Android上实现局域网络聊天功能
weixin_45233626的博客
03-10 534
1.onCreateViewHolder:这个方法就是用来创建出一个新的ViewHolder，可以根据需求的itemType，创建出多个ViewHolder。//返回此套接字连接的端点的地址，通过不同的端口区分这些链接。//accept函数返回的新socket其实指代的是本次创建的连接。new一个runable，重写run()，首先连接socket，包括本地ip地址和端口号。
Android和PC端通过局域网文件同步
08-27
这项技术主要应用于局域网环境中，通过Socket编程实现文件的传输和同步。 在Android端，使用Java语言编写了一个 SocketManager 类，负责与PC端建立连接，并实现文件的传输。该类中使用了ServerSocket对象来监听PC端...
android socket局域网文件传输131114
11-14
本项目"android socket局域网文件传输131114"是针对这一需求实现的一个示例，它利用了Socket、多线程以及ListView等Android核心组件，旨在提供一种高效、稳定、用户友好的文件共享解决方案。 首先，Socket作为TCP/...
android基于socket的局域网内服务器与客户端加密通信
08-30
本篇文章的核心是利用Socket编程实现数据的传输，并通过AES（Advanced Encryption Standard）加密算法确保数据在传输过程中的安全性。 首先，我们需要了解Socket的基本概念。Socket是网络通信的一种接口，它允许两...
Android利用TCP/IP、UDP、Http、Socket、多线程等实现局域网实时监控、文件快传、搜索设备等
Engineer-Jsp的专栏
04-01 3253
RT：Android利用TCP/IP、UDP、Http、Socket、多线程等实现局域网实时监控、文件快传、搜索设备等。首先介绍项目库文件主要实现在局域网(热点、WIFI)内的实时监控、文件浏览(类似云盘)、文件批量下载、文件删除、客户端操作服务端的Http指令、局域网内的设备IP搜索、消息推送等。接下来介绍各模块主要职能：TCP/IP-主要负责将服务端的预览视频画面实时传输到客户端，经过Andr...
Android向：实现同一局域网内两台手机之间的文件互传
weixin_40516558的博客
07-03 1万+
背景 最近要做一个demo，目的是实现局域网内的两台手机之间的文件互传。具体流程如下： 手机 A 从服务器上下载一个 apk 文件到本机上； 手机 A 在自己的某个端口上启动一个 Server 服务，供手机 B 对刚刚的 apk 进行下载； 手机 B 请求手机 A 的 ip 地址与端口，进行 apk 的下载； 实现过程 目前只是一个最简版的实现。 1. 首先因为是下载服务，就在 ...
android局域网怎么传文件,两手机同一局域网怎么传文件
weixin_32498069的博客
05-29 2123
如今很多家庭都有自己的局域网，安卓手机的文件管理器ES文件浏览器，当我们使用它来访问电脑上的共享文档时，常常出现很多问题而无法访问。下面是小编为大家整理的关于，一起来看看吧!首先确保你的环境满足以上2点要求，本经验主要侧重于设置pc，正确设置好了，用安卓设备访问pc的共享目录很简单设置pc按下win+r或者点选屏幕左下角的开始图标，在搜索框中输入“服务”，打开“服务”对话框，确保Server与Wi...
Android基于局域网的socket通信
小小9575的博客
07-23 7288
最近写了一个关于局域网socket通信的demo，代码和ui都很low，但是功能实现了，所以贴出来记录一下 主要流程如下 服务端：启动服务--&gt;显示ip--&gt;等待接收--&gt;显示消息--&gt;收到回复 客户端：录入ip--&gt;输入消息--&gt;发送消息--&gt;收到结果 如下图 选择服务端还是客户端 显示服务端ip 客户端输入ip发送消息 服务...
android 局域网socket,Android基于局域网socket通信
weixin_42347426的博客
05-28 253
【实例简介】关于android基于局域网socket通信的完整demo，详细见https://blog.csdn.net/weixin_40998254/article/details/81163701【实例截图】【核心代码】SocketApplication└── SocketApplication├── SocketApplication.iml├── app│ ├── app.iml│...
Android Socket使用详解
2401_84149855的博客
04-09 1227
即套接字，是一个对 TCP / IP协议进行封装 的编程调用接口（API）即通过Socket，我们才能在Andorid平台上通过TCP/IP协议进行开发Socket不是一种协议，而是一个编程调用接口（API），属于传输层（主要解决数据如何在网络中传输）成对出现，一对套接字：Socket ={(IP地址1:PORT端口号)，(IP地址2:PORT端口号)}
android 自动备份到局域网,Android和PC端通过局域网文件同步
weixin_39948824的博客
05-25 871
本文为大家分享了Android和PC端通过局域网文件同步的具体代码，供大家参考，具体内容如下public class FileOptions {public String name;public String path;public long size;}//Activitypublic class MainActivity extends Activity {private TextView t...
Android开发之Socket通信
weixin_30745553的博客
05-18 336
博客出自：http://blog.csdn.net/liuxian13183，转载注明出处！ All Rights Reserved !在项目开发过程中，不免要与后台进行交互，这时候我们就需要研究一下通信，做一个选择。Http通信采用UDP，传输过但可能会丢数据，一般我们用来传递字符串或者下载图片时采用，轻量级。Socket通信采用TCP，安全但慢，一般用来做大型项目中注册、定单信息的传输操...
Android通过Socket实现局域网通信例子
只有静静努力，才能默默躺平~
11-14 3468
最近工作上涉及比较多局域网连接和通信的业务需求，发现自己在这块一直是一个空缺，因此在网上找了一些资料，也在AS上试着验证，基本没有什么问题。 好了，不多说，直接上代码。 首先是Server端的代码实现： 1）MainActivity.java package com.example.socketserver; import androidx.appcompat.app.AppCompatActivity; import android.content.Context; import andro
android 使用TCP在局域网进行数据传输代码
03-14
在 Android 中，可以使用 Socket 类来实现 TCP 数据传输。以下是一个简单的示例代码： ``` try { // 创建 Socket 对象 Socket socket = new Socket("192.168.1.100", 8888); // 获取输出流，向服务器发送数据 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

liusaisaiV1

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

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

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

打赏作者

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

抵扣说明：

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

余额充值