关于linux与android传输代码tcp -传文件

于 2022-11-10 16:28:11 发布
阅读量817 收藏 1
点赞数
分类专栏： c++ 文章标签： android tcp/ip linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hch977/article/details/127791489
版权

关于linux与android传输代码tcp -传文件

感谢原作者

Android(客户端)与Linux(服务器端)进行TCP数据通信__Programmer_的博客-CSDN博客_linux+安卓apptcp图传

原作者提供了linux与android 通过tcp连接 的代码

经过尝试，遇到一些bug，但最终解决，感谢作者的源代码！

本文主要将提取出传输部分，并改造成可以传输文件的代码

源代码（传输msg版）

默认是服务器先启动监听，然后客户端运行，建立连接，然后客户端发什么信息，服务端接受到会显示出来，并且重新发送给客户端。已经内置到自己的应用中，很成功。

服务端

采用的是8080端口

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>

#define PORT 8080            //服务器端监听端口号
#define MAX_BUFFER 1024         //数据缓冲区最大值

int main()
{
    struct sockaddr_in server_addr, client_addr;
    int server_sockfd, client_sockfd;
    int size, write_size;
    char buffer[MAX_BUFFER];

    if ((server_sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)    //创建Socket
    {
        perror("Socket Created Failed!\n");
        exit(1);
    }
    printf("Socket Create Success!\n");

    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(PORT);
    bzero(&(server_addr.sin_zero), 8);

    int opt = 1;
    int res = setsockopt(server_sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));    //设置地址复用
    if (res < 0)
    {
        perror("Server reuse address failed!\n");
        exit(1);
    }

    if (bind(server_sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1)  //绑定本地地址
    {
        perror("Socket Bind Failed!\n");
        exit(1);
    }
    printf("Socket Bind Success!\n");

    if (listen(server_sockfd, 5) == -1)                 //监听
    {
        perror("Listened Failed!\n");
        exit(1);
    }
    printf("Listening ....\n");

    socklen_t len = sizeof(client_addr);

    printf("waiting connection...\n");
    if ((client_sockfd = accept(server_sockfd, (struct sockaddr *)&client_addr, &len)) == -1)  //等待客户端连接
    {
        perror("Accepted Failed!\n");
        exit(1);
    }
    printf("connection established!\n");
    printf("waiting message...\n");

    while (1)
    {
        memset(buffer, 0, sizeof(buffer));                             //清空数据缓冲区

        if ((size = read(client_sockfd, buffer, MAX_BUFFER)) == -1)    //读取客户端的数据
        {
            perror("Recv Failed!\n");
            exit(1);
        }

        if (size != 0)                                               
        {
            buffer[size] = '\0';
            printf("Recv msg from client: %s\n", buffer);
            if ((write_size = write(client_sockfd, buffer, MAX_BUFFER)) > 0)   //把收到的数据回发给客户端
            {
                printf("Sent msg to client successfully!\n");
            }

        }
    }

    close(client_sockfd);   //关闭Socket
    close(server_sockfd);

    return 0;
}

编译出可执行文件

g++ con.cpp -o server

运行

./server
移动端

TcpClientConnector.java

package com.google.ar.core.examples.java.helloar;

import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class TcpClientConnector {

    private static TcpClientConnector mTcpClientConnector;
    private Socket mClient;
    private ConnectListener mListener;
    private Thread mConnectThread;

    public interface ConnectListener {
        void onReceiveData(String data);
    }

    public void setOnConnectListener(ConnectListener listener) {
        this.mListener = listener;
    }

    public static TcpClientConnector getInstance() {
        if (mTcpClientConnector == null)
            mTcpClientConnector = new TcpClientConnector();
        return mTcpClientConnector;
    }

    Handler mHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case 100:
                    if (mListener != null) {
                        mListener.onReceiveData(msg.getData().getString("data"));
                    }
                    break;
            }
        }
    };

    public void createConnect(final String mSerIP, final int mSerPort) {
        if (mConnectThread == null) {
            mConnectThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        connect(mSerIP, mSerPort);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
            mConnectThread.start();
        }
    }

    /**
     * 与服务端进行连接
     *
     * @throws IOException
     */
    private void connect(String mSerIP, int mSerPort) throws IOException {
        if (mClient == null) {
            mClient = new Socket(mSerIP, mSerPort);
        }
        InputStream inputStream = mClient.getInputStream();
        byte[] buffer = new byte[1024];
        int len = -1;
        while ((len = inputStream.read(buffer)) != -1) {
            String data = new String(buffer, 0, len);
            Message message = new Message();
            message.what = 100;
            Bundle bundle = new Bundle();
            bundle.putString("data", data);
            message.setData(bundle);
            mHandler.sendMessage(message);
        }
    }

    /**
     * 发送数据
     *
     * @param data 需要发送的内容
     */
    public void send(String data) throws IOException {
        if(mClient!=null)
        {
            Log.d("socket",mClient.toString());
            OutputStream outputStream = mClient.getOutputStream();
            outputStream.write(data.getBytes());
        }
    }

    /**
     * 断开连接
     *
     * @throws IOException
     */
    public void disconnect() throws IOException {
        if (mClient != null) {
            mClient.close();
            mClient = null;
        }
    }
}

main_activity.java

 // 连接
  private TcpClientConnector connector;
....
  @Override
  protected void onCreate(Bundle savedInstanceState) {
      ....
         // 创建 连接
          
           // 尝试连接
        connector = TcpClientConnector.getInstance();   //获取connector实例
        if(true){
          //连接Tcp服务器端
          connector.createConnect("10.112.146.228",8080);   //调试使用
          connector.setOnConnectListener(new TcpClientConnector.ConnectListener() {
            @Override
            public void onReceiveData(String data) {
              //Received Data,do somethings.
              System.out.println(data);
            }
          });
        }else{
          try{   //断开与服务器的连接
            connector.disconnect();
          }catch(IOException e){
            e.printStackTrace();
          }
        }
    .....
  }

把发送信息的函数，加到你想加的函数里。记得android7以后，tcp连接必须放在线程中

 new Thread(new Runnable(){
      @Override
      public void run() {
        try {
          
          connector.send("hello world");

        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }).start();

源代码（传输文件版）

需求：需要从服务器传输一个文件，到客户端，客户端接收到后，保存至手机中。

服务器需要传输多个文件，客户端需要对每个文件分别命名并进行保存

服务器首先发送启示符”START" 表明传输的开始

然后 下一个块 发送文件名

接下来所有的块都发送文件的块

发送完毕后 ，发送中止符 “END”

代表该文件的发送结束

传输一个文件版

tips

android 8以后禁止往外部存储写文件，使用openFileOutput 可以

自动在data/data/包…/files/…下自动写文件（经尝试，该方法在主线程下可以创建哦）

OutputStream os = openFileOutput("file.txt", Activity.MODE_PRIVATE);
String str1 = "abc";
os.write(str1.getBytes("utf-8"));

tips

bug，当服务器发送字节块，采用的是1024字节的byte数组

比如start只会占前5位，后面全填0

而客户端接受的会将整个字节数组转化为字符串，就变成这个样子

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3q63bnuL-1668068832148)(%E5%85%B3%E4%BA%8Elinux%E4%B8%8Eandroid%E4%BC%A0%E8%BE%93%E4%BB%A3%E7%A0%81tcp%20-%E4%BC%A0%E6%96%87%E4%BB%B6.assets/image-20221110102121564.png)]

解决这个bug有两个方向

一个是找到android端能够截取byte数组的函数

感谢作者[Java中去掉byte]中填充的0，并且转为String_银龙gg的博客-CSDN博客

但这样会有点担心，（因为平常的字节流为有0，会被提前中止）

经过探寻 该0为彼0（实际上传递的是0的assci码 48）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HF6EAdki-1668068832149)(%E5%85%B3%E4%BA%8Elinux%E4%B8%8Eandroid%E4%BC%A0%E8%BE%93%E4%BB%A3%E7%A0%81tcp%20-%E4%BC%A0%E6%96%87%E4%BB%B6.assets/image-20221110104956116.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m09BDfRH-1668068832150)(%E5%85%B3%E4%BA%8Elinux%E4%B8%8Eandroid%E4%BC%A0%E8%BE%93%E4%BB%A3%E7%A0%81tcp%20-%E4%BC%A0%E6%96%87%E4%BB%B6.assets/image-20221110105506360.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4EBQI8db-1668068832150)(%E5%85%B3%E4%BA%8Elinux%E4%B8%8Eandroid%E4%BC%A0%E8%BE%93%E4%BB%A3%E7%A0%81tcp%20-%E4%BC%A0%E6%96%87%E4%BB%B6.assets/image-20221110105515496.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-srDbWKnt-1668068832151)(%E5%85%B3%E4%BA%8Elinux%E4%B8%8Eandroid%E4%BC%A0%E8%BE%93%E4%BB%A3%E7%A0%81tcp%20-%E4%BC%A0%E6%96%87%E4%BB%B6.assets/image-20221110105555830.png)]

而ascci码为0的是字符null，根本不需要有这方面的担心（后续还是有bug）

/指定长度100
private byte[] bytes = new byte[100];

//此处省略获取数据  byte[]中的数据实际长度为30   剩余的70将会自动填充0
//直接转为String
String str = new String(bytes);
//str中前30位为正常字符  后70位为填充  直接页面展示会乱码
System.out.print(str);
//通过下面的方法去掉自动填充的0
String str1 = StringUtils.byteToStr(bytes);
System.out.print(str1); //正确数据 只有实际的30位  没有填充的乱码

 /**
     * 去掉byte[]中填充的0 转为String
     * @param buffer
     * @return
     */
    public static String byteToStr(byte[] buffer) {
        try {
            int length = 0;
            for (int i = 0; i < buffer.length; ++i) {
                if (buffer[i] == 0) {
                    length = i;
                    break;
                }
            }
            return new String(buffer, 0, length, "UTF-8");
        } catch (Exception e) {
            return "";
        }
    }

一个是增加服务端与客户端发送的逻辑（比如也发送字长，或者为每个块添加中止符什么的）

前面方法已经可以了，因此放弃该思路

bug1

把发送文件块的全部截取成0了…

通过增加逻辑，对于文件名，启示符，结束符进行截取

对于文件块进行不截取的方式，解决问题。

bug2

按说应该传完start和文件名，再传文件块

文件块传完毕后，会传送最后一个文件块，以END开头

但不知为什么，END的块，与最后一个文件包混到了一起

发送完文件块后，等待1s

服务端代码
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include<string>
#include<iostream>


#define PORT 8080            //服务器端监听端口号
#define MAX_BUFFER 1024         //数据缓冲区最大值
using namespace std;
int main()
{
    struct sockaddr_in server_addr, client_addr;
    int server_sockfd, client_sockfd;
    int size, write_size;
    char buffer[MAX_BUFFER];

    if ((server_sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)    //创建Socket
    {
        perror("Socket Created Failed!\n");
        exit(1);
    }
    printf("Socket Create Success!\n");

    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(PORT);
    bzero(&(server_addr.sin_zero), 8);

    int opt = 1;
    int res = setsockopt(server_sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));    //设置地址复用
    if (res < 0)
    {
        perror("Server reuse address failed!\n");
        exit(1);
    }

    if (bind(server_sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1)  //绑定本地地址
    {
        perror("Socket Bind Failed!\n");
        exit(1);
    }
    printf("Socket Bind Success!\n");

    if (listen(server_sockfd, 5) == -1)                 //监听
    {
        perror("Listened Failed!\n");
        exit(1);
    }
    printf("Listening ....\n");

    socklen_t len = sizeof(client_addr);

    printf("waiting connection...\n");
    if ((client_sockfd = accept(server_sockfd, (struct sockaddr *)&client_addr, &len)) == -1)  //等待客户端连接
    {
        perror("Accepted Failed!\n");
        exit(1);
    }
    printf("connection established!\n");

    // 开始传文件
    //发送一个文件名
    //bytes[]

    
    string start="START";
    char buf[1024] = { 0 };
    strcpy(buf, start.c_str());
    write(client_sockfd,buf,MAX_BUFFER);
    memset(buf, 0, sizeof(buf)); 


    string name ="1.txt";
    strcpy(buf, name.c_str());
    write(client_sockfd,buf,MAX_BUFFER);
    memset(buf, 0, sizeof(buf)); 
    int bytes;
    FILE* fp = fopen("test1.txt", "rb");

    while ((bytes = fread(buf, 1, 1024, fp) )> 0)//读取文件内容，每次一个1024字节
    {
        cout<<bytes<<endl;
        // for(auto byte:buf)
        // {
        //     cout<<byte<<" ";
        // }
        // cout<<endl;
        write(client_sockfd,buf,MAX_BUFFER);//把buf里存的东西send给服务端
        memset(buf, 0, sizeof(buf)); 
    }

    sleep(1);
    string end="END";
    strcpy(buf, end.c_str());
    for(auto byte:buf)
        {
            cout<<byte<<" ";
        }
        cout<<endl;
    write(client_sockfd,buf,MAX_BUFFER);
    memset(buf, 0, sizeof(buf)); 
    


    // printf("waiting message...\n");

    // while (1)
    // {
    //     memset(buffer, 0, sizeof(buffer));                             //清空数据缓冲区

    //     if ((size = read(client_sockfd, buffer, MAX_BUFFER)) == -1)    //读取客户端的数据
    //     {
    //         perror("Recv Failed!\n");
    //         exit(1);
    //     }

    //     if (size != 0)                                               
    //     {
    //         buffer[size] = '\0';
    //         printf("Recv msg from client: %s\n", buffer);
    //         if ((write_size = write(client_sockfd, buffer, MAX_BUFFER)) > 0)   //把收到的数据回发给客户端
    //         {
    //             printf("Sent msg to client successfully!\n");
    //         }
    //     }
    // }

    close(client_sockfd);   //关闭Socket
    close(server_sockfd);

    return 0;
}
客户端代码

on create中创建连接

 // 尝试连接
    connector = TcpClientConnector.getInstance();   //获取connector实例
    if(true){
      //连接Tcp服务器端
      connector.createConnect("10.112.146.228",8080);   //调试使用
      connector.setOnConnectListener(new TcpClientConnector.ConnectListener() {
        @Override
        public void onReceiveData(String data) {

          //Received Data,do somethings.
          Log.i("received", String.valueOf(data.length()));
          Log.i("received",data);


          if(receive_state==0 && data.equals("START")) //准备接受文件名
          {
            Log.i("file1","文件传输开始，准备接受文件名噢");
            os = null;
            receive_state=1;
          }
          else if (receive_state==1)//接受文件名
          {

            file_name=byteToStr(data.getBytes());
            Log.i("file1","接受到文件名:"+file_name);
            try {
              os = openFileOutput(file_name, Context.MODE_PRIVATE);
            } catch (IOException e) {
              e.printStackTrace();
            }
            receive_state=2;
          }
          else if(receive_state==2 && !data.equals("END") && data.length()!=0) //接受文件块
          {
            Log.i("file1","正在写入块:"+data.getBytes().length);
            try {
              os.write(data.getBytes());
            } catch (IOException e) {
              e.printStackTrace();
            }
          }
          else if(data.equals("END")) //该文件传输结束
          {
            Log.i("file1","文件写入结束");
            try {
              os.close();
            } catch (IOException e) {
              e.printStackTrace();
            }
            os=null;
            receive_state=0;
            file_name=null;
          }
        }
      });
    }else{
      try{   //断开与服务器的连接
        connector.disconnect();
      }catch(IOException e){
        e.printStackTrace();
      }
    }

截取函数

 public String byteToStr(byte[] buffer) {
    try {
      int length = 0;
      for (int i = 0; i < buffer.length; ++i) {
        if (buffer[i] == 0) {
          length = i;
          break;
        }
      }
      return new String(buffer, 0, length, "UTF-8");
    } catch (Exception e) {
      return "";
    }
  }

TcpClientConnector

package com.google.ar.core.examples.java.helloar;

import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;


import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;


public class TcpClientConnector {

    private static TcpClientConnector mTcpClientConnector;
    private Socket mClient;
    private ConnectListener mListener;
    private Thread mConnectThread;
    private BufferedOutputStream bos= null;

    public interface ConnectListener {
        void onReceiveData(String data);
    }

    public void setOnConnectListener(ConnectListener listener) {
        this.mListener = listener;
    }

    public static TcpClientConnector getInstance() {
        if (mTcpClientConnector == null)
            mTcpClientConnector = new TcpClientConnector();
        return mTcpClientConnector;
    }

    Handler mHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case 100:
                    if (mListener != null) {
                        mListener.onReceiveData(msg.getData().getString("data"));
                    }
                    break;
            }
        }
    };

    public void createConnect(final String mSerIP, final int mSerPort) {
        if (mConnectThread == null) {
            mConnectThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        connect(mSerIP, mSerPort);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
            mConnectThread.start();
        }
    }
    /**
     * 去掉byte[]中填充的0 转为String
     * @param buffer
     * @return
     */
    public static String byteToStr(byte[] buffer) {
        try {
            int length = 0;
            for (int i = 0; i < buffer.length; ++i) {
                if (buffer[i] == 0) {
                    length = i;
                    break;
                }
            }
            return new String(buffer, 0, length, "UTF-8");
        } catch (Exception e) {
            return "";
        }
    }
    /**
     * 与服务端进行连接
     *
     * @throws IOException
     */
    private void connect(String mSerIP, int mSerPort) throws IOException {
        if (mClient == null) {
            mClient = new Socket(mSerIP, mSerPort);
        }
        InputStream inputStream = mClient.getInputStream();
        byte[] buffer = new byte[1024];
        int len = -1;


        while ((len = inputStream.read(buffer)) != -1) {
//            String data = new String(buffer, 0, len);
            Log.i("real_string", String.valueOf(len));//len_byte能看出接受到的块大小
            String real_data=new String(buffer,0,len);

            // 如果是start,end 就放截取后的
            // 其他 放未截取的 文件名则主线程截取
            String data =byteToStr(buffer);
            Message message = new Message();
            message.what = 100;
            Bundle bundle = new Bundle();
            Log.i("real_string","一块：");
            Log.i("real_string",real_data);//real_string表明实际接收到的数据
            if (data.equals("START") || data.equals("END"))
            {
                bundle.putString("data", data);
            }
            else
            {
                bundle.putString("data", real_data);
            }
            message.setData(bundle);
            mHandler.sendMessage(message);
        }
        if (bos!=null){
            bos.close();
        }

    }

    /**
     * 发送数据
     *
     * @param data 需要发送的内容
     */
    public void send(String data) throws IOException {
        if(mClient!=null)
        {
            Log.d("socket",mClient.toString());
            OutputStream outputStream = mClient.getOutputStream();
            outputStream.write(data.getBytes());
        }
    }

    /**
     * 断开连接
     *
     * @throws IOException
     */
    public void disconnect() throws IOException {

        if (mClient != null) {
            mClient.close();
            mClient = null;
        }
    }
}
传输多个文件版
云霞川
关注
专栏目录
Linux下基于TCP的文件传输
Darren's Thought
10-30 1万+
服务器： #include #include #include #include #include #include #include #define SERVER_PORT 6666 #define LISTEN_QUEUE 20 #define BUFFER_SIZE 1024 int main(int argc,char **argv) { struct socka
linux下adb传输文件,android studio 使用adb命令传递文件到android设备
weixin_42332131的博客
05-03 883
一：文件传输在android开发中，有时候需要将文件从pc端传递至android,或者将软件运行的日志，从android设备传递到pc进行分析，我们可以使用windows的cmd窗口，或者android studio的terminal窗口来传递文件。1:连接android设备此处默认是android设备，已打开usb调试模式，并且数据线已经和电脑连接。我们先使用adb devices指令，查询一下...
android应用中文件的tcp发送和接收
08-06
android应用中，通过tcp发送和接收文件，根据自己的需求修改代码可用！
android udp tcp传输文件,Android使用Socket(Tcp/Udp)協議進行數據傳輸(傳輸大文件)
weixin_39637920的博客
05-26 156
Socket是什么：所謂Socket 通常也稱作”套接字”，用於描述IP地址和端口，是一個通信鏈的句柄。應用程序通常通過”套接字”向網絡發出請求或者應答網絡請求。Socket內部又有兩種協議(Tcp/Udp),我們來說說其各自的特點。先來說說網絡編程的三要素1.IP地址：網絡中計算機的唯一標識2.端口3.協議：通信的規則Tcp/Udp特點一、 TCP(協議):建立連接，形成傳輸數據的通道在連接中進...
Android使用Socket(Tcp/Udp)协议进行数据传输(传输大文件)
碎火流荧的博客
10-30 2961
Socket是什么：所谓Socket 通常也称作”套接字”，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过”套接字”向网络发出请求或者应答网络请求。Socket内部又有两种协议（Tcp/Udp）,我们来说说其各自的特点。 先来说说网络编程的三要素 1.IP地址：网络中计算机的唯一标识 2.端口 3.协议：通信的规则 Tcp/Udp特点 一、 TCP（协议）: 建立连接，形成传输数据的通道 在连接中进行大数据量传输 通过三次握手完成连接，是可靠协议 必须建立连接，效率稍微低点
电脑-Android手机之间TCP协议局域网文件传送
08-29
一个还好的Android手机无线（WIFI）连接无线路由实现局域网 连接电脑后，进行文件传送的Socket/TCP实例。 需要手机WIFI连接局域网，并设定IP地址，地址可在程序文件找到，或者自行对应修改，需要统一。
Android 客户端tcp传输demo
06-28
Android tcp客户端传输数据及上传、下载文件的demo，功能简单，仅供参考
基于TCP模拟文件传输系统
07-23
"在linux上编写文件上传下载的客户端和服务器，使用TCP协议。 1.可随时查看上传下载进度，可随时添加和删除上传下载任务，可随时停止或者继续上传下载； 2. 确保上传下载的文件的正确性和完整性； 3. 多客户端同时...
Android-利用tcp或蓝牙将android通知l加密到同步inux桌面
08-13
标题 "Android-利用tcp或蓝牙将android通知l加密到同步inux桌面" 提示我们这个项目是关于在Android设备上捕获通知，然后通过TCP或蓝牙协议将其加密并发送到Linux桌面进行同步。这个过程涉及到了Android的通知管理、...
Python-AN2Linux通过tcp或蓝牙将android通知加密同步到linux桌面
08-10
Python-AN2Linux项目是一个创新的解决方案，它允许Android设备上的通知通过TCP协议或蓝牙技术安全地加密同步到Linux桌面系统。这个系统的核心是利用Python的网络编程能力，实现跨平台的信息传递，确保用户能够在不同...
android tcp 传输图片
05-24
将图片信息通过电脑发送到 这个APP 点击按钮 自动合成 图片 包含合成图片代码 等 全部代码
Android 通过TCP协议上传指定目录文件
01-21
为了方便客户抓取Log，现通过TCP协议连接指定服务器，传输指定内容，定义指定目录，IP，PORT字段接收参数。直接上代码   public static void uploadLog(final String dirPath, final String IP, final int port ) { JSONArray fileList = new JSONArray(); final JSONArray allFiles = getAllFiles(fileList,dirPath); if(allFiles==null)return;
Android程序员必知必会的网络通信传输层协议——UDP和TCP
qq_52703909的博客
03-25 1746
在本篇文章里，会为大家讲述作为Android程序员对于网络通信传输层协议UDP、TCP的理解，希望能给你带来启发。
Linux下opencv和opencv_contrib安装
weixin_47060826的博客
10-23 1128
文章目录前言一、简单说下cmake和make？二、使用步骤1.下载文件并解压2.编译总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、简单说下cmake和make？ cmake和make都是编译大型编译时使用，cmake运行时，需要CMakeLists.txt文件，make需要的是Makefile文件。cmake中的CMake.
android+tcp传输,android TCP/IP传输（客户端）
weixin_30662937的博客
05-26 465
整了好久，查了好多文件才整的有点明白package com.bn.tcp;import java.io.BufferedReader;import java.io.InputStream;import java.io.InputStreamReader;import java.io.PrintWriter;import java.net.Socket;import java.util.Arrays...
Android 中 Socket 基于TCP 传输大文件
Mars Huang
12-09 6537
Android 客户端: 1. 创建Socket对象 Socket socket = new Socket();   2.创建连接到指定的主机、端口 socket.connect(new InetSocketAddress("10.10.10.100", 980));   3.创建File对像,并指定要传输的文件绝对路径 File f=new File("/sdcard2/AppM
Android中实现TCP和UDP传输的方法
06-05 834
TCP和UDP在网络传输中非常重要，在Android开发中同样重要。 　　首先我们来看一下什么是TCP和UDP。 　　什么是TCP？ 　　TCP：Transmission Control Protocol 传输控制协议TCP是一种面向连接（连接导向）的、可靠的、基于字节流的运输层（Transport layer）通信协议，由IETF的RFC 793说明（specified）。在简
Android应用安全：网络端口监听的风险与漏洞分析
由于Linux内核的传统设计，开放此类端口的应用往往缺乏对调用者的身份验证和权限检查，使得攻击者可能利用这一弱点绕过Android的安全沙箱机制，以应用自身的权限执行恶意代码，从而可能导致拒绝服务攻击、权限提升...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值