Android网络编程实践之移动终端通信

最新推荐文章于 2022-08-05 20:43:35 发布
最新推荐文章于 2022-08-05 20:43:35 发布
阅读量179 收藏
点赞数
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40073459/article/details/106680715
版权

Server

MainActivity.java

// MainActivity.java
package com.example.server;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import android.annotation.SuppressLint;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {
    public static final String TAG = "MainActivity";

    private static final String str = "com.example.server.SERVER_SERVICE";
    private Button start, stop;
    public  TextView displayText;
    private Intent intent = null;
    MyServiceConn myServiceConn;
    ServerService.MyBinder binder = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        Log.d(TAG, "onCreate()");
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        start = (Button) findViewById(R.id.startBtn);
        stop = (Button) findViewById(R.id.stopBtn);
        displayText = (TextView) findViewById(R.id.displayText);
        myServiceConn = new MyServiceConn();

        intent = new Intent(this, ServerService.class);
        intent.setPackage(this.getPackageName());
        start.setOnClickListener(new View.OnClickListener(){
            public void onClick(View v) {
                startService(intent);
                bindService(intent, myServiceConn, Context.BIND_AUTO_CREATE);
                stop.setEnabled(true);
                start.setEnabled(false);
            }
        });

        stop.setOnClickListener(new View.OnClickListener(){
            public void onClick(View v) {
                if (binder != null) unbindService(myServiceConn);
                stopService(intent);
                start.setEnabled(true);
                stop.setEnabled(false);
            }
        });
    }

    class MyServiceConn implements ServiceConnection {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            binder = (ServerService.MyBinder) service;
            binder.getService().setDataCallback(new ServerService.DataCallback() {
                @Override
                public void dataChanged(String str) {
                    Message msg = new Message();
                    Bundle bundle = new Bundle();
                    bundle.putString("str", str);
                    msg.setData(bundle);
                    handler.sendMessage(msg);
                }
            });
        }
        @SuppressLint("HandlerLeak")
        Handler handler = new Handler() {
            @Override
            public void handleMessage(@NonNull Message msg) {
                Log.i(TAG, "returned msg = " + msg.getData().getString("str"));
                displayText.setText(msg.getData().getString("str"));
            }
        };

        @Override
        public void onServiceDisconnected(ComponentName name) {
            binder = null;
        }
    }
}

ServerService.java

// ServerService.java
package com.example.server;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;


public class ServerService extends Service {
    final static String TAG = "ServerService";
    public static Boolean mainThreadFlag;
    public static Boolean ioThreadFlag;
    ServerSocket serverSocket = null;
    final int SERVER_PORT = 8080;
    public static String data = null;


    @Override
    public void onCreate() {
        Log.i(TAG, "onCreate()");
        super.onCreate();
        mainThreadFlag = true;
        ioThreadFlag = true;
        new Thread() {
            public void run() {
                doListen();
            }
        }.start();
    }

    private void doListen() {
        Log.i(TAG, "doListen()");
        serverSocket = null;
        try {
            serverSocket = new ServerSocket(SERVER_PORT);
            while (mainThreadFlag) {
                Log.i(TAG, "inside while loop");
                Socket client = serverSocket.accept();
                new Thread(new handlerWithClient(client)).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i(TAG, "onStartCommand()");
        //data = intent.getStringExtra("data");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        Log.i(TAG, "onDestroy()");
        mainThreadFlag = false;
        ioThreadFlag = false;

        try {
            serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    @Override
    public IBinder onBind(Intent intent) {
        Log.i(TAG, "onBind()");
        return new MyBinder();
    }

    @Override
    public boolean onUnbind(Intent intent) {
        Log.i(TAG, "onUnbind");
        return super.onUnbind(intent);
    }

    public class MyBinder extends Binder {
        ServerService getService() {
            return ServerService.this;
        }

        public void setData(String data) {
            Log.i(TAG, "setData()");
            ServerService.this.data = data;
        }
    }

    public static DataCallback dataCallback = null;

    public DataCallback getDataCallback() {
        Log.i(TAG, "getDataCallback()");
        return dataCallback;
    }

    public void setDataCallback(DataCallback dataCallback) {
        Log.i(TAG, "setDataCallback()");
        this.dataCallback = dataCallback;
    }

    public interface DataCallback {
        void dataChanged(String str);
    }
}

handlerWithClient.java

// handlerWithClient.java
package com.example.server;

import android.util.Log;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
import static com.example.server.ServerService.data;
import static com.example.server.ServerService.dataCallback;

public class handlerWithClient implements Runnable {
    public final static String TAG = "handlerWithClient";
    private Socket client;
    final static int MAX_BYTES = 1024 * 4;

    public handlerWithClient(Socket client) {
        this.client = client;
    }
    @Override
    public void run() {
        BufferedInputStream in;
        try {
            in = new BufferedInputStream(client.getInputStream());
            ServerService.ioThreadFlag = true;
            while (ServerService.ioThreadFlag) {
                if (!client.isConnected()) {
                    break;
                }
                data = readFromSocket(in);
                Log.i(TAG, "ServerService.data=" + data);
                if (dataCallback != null && data != null) {
                    dataCallback.dataChanged(data);
                }
            }
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (client != null) {
                try {
                    client.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private String readFromSocket(InputStream in) {
        Log.i(TAG, "readFromSocket()");
        String msg = null;
        byte[] buffer = new byte[MAX_BYTES];
        try {
            int readBytes = 0;
            if ((readBytes = in.read(buffer, 0, MAX_BYTES)) >= 0) {
                Log.i(TAG, "read bytes = " + readBytes);
                msg = new String(buffer, 0, readBytes, "utf-8");
                Log.i(TAG, "msg=" + msg);
                buffer = null;
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
        return msg;
    }
}

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.server">
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <service
            android:name=".ServerService"
            android:enabled="true"
            android:exported="true">
            <intent-filter>
            <action android:name="com.example.server.SERVER_SERVICE"/>
            </intent-filter>
        </service>

        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        tools:layout_editor_absoluteX="1dp"
        tools:layout_editor_absoluteY="1dp"
        tools:ignore="MissingConstraints">
        <Button
            android:id="@+id/startBtn"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/start_service"
            android:textAllCaps="false"
            />

        <Button
            android:id="@+id/stopBtn"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/stop_service"
            android:textAllCaps="false"
            android:enabled="false"
            />

        <TextView
            android:id="@+id/textView"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/tip_message"
            android:textSize="20dp"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            tools:ignore="MissingConstraints"
            tools:layout_editor_absoluteY="49dp" />

        <TextView
            android:id="@+id/displayText"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/display_received"
            android:background="@drawable/back"
            android:textAllCaps="false"
            tools:ignore="MissingConstraints" />
    </LinearLayout>
</androidx.constraintlayout.widget.ConstraintLayout>

运行如下：
server

Client

MainActivity.java

package com.example.client;

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class MainActivity extends AppCompatActivity {
    final static String TAG = "MainActivity";
    private Button btn1, btn2;
    private EditText et1, et2;
    private static final int SERVER_PORT = 8080;
    private Socket server = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.i(TAG, "onCreate()");
        init();
    }

    private void init() {
        Log.i(TAG, "init()");
        et1 = (EditText) findViewById(R.id.connEdit);
        btn1 = (Button) findViewById(R.id.connectButton);

        btn1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                final String s = et1.getText().toString();
                new Thread() {
                    public void run() {
                        try {
                            server = connectToServer(s);
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }.start();
            }
        });

        et2 = (EditText) findViewById(R.id.editText);
        btn2 = (Button) findViewById(R.id.sendButton);

        btn2.setOnClickListener(new View.OnClickListener(){
            @Override
            public void onClick(View v) {
                final String s = et2.getText().toString();
                new Thread() {
                    public void run() {
                        try {
                            sendMessage(server, s);
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }.start();
            }
        });
    }

    private Socket connectToServer(String ip) throws IOException {
        Log.i(TAG, "connectToServer()");
        Socket server = null;
        try {
             server = new Socket(ip, SERVER_PORT);
        } catch (UnknownHostException e) {
            e.printStackTrace();
            Toast.makeText(getApplicationContext(), "Connection Fail!",
                            Toast.LENGTH_LONG).show();
        }

        if (server != null) {
            et1.setText("Connected to " + ip);
        }
        return server;
    }

    private void sendMessage(Socket server, String s) throws IOException {
        Log.i(TAG, "sendMessage()");
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(server.getOutputStream()));
        writer.write(s);
        writer.flush();
    }
}

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.client">
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout 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"
    tools:context=".MainActivity">


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

        <LinearLayout
            android:id="@+id/linearLayout1"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal">

            <EditText
                android:id="@+id/connEdit"
                android:layout_width="fill_parent"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:text="@string/ip_address"
                android:textAllCaps="false" />

            <Button
                android:id="@+id/connectButton"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/connect_server"
                android:textAllCaps="false" />
        </LinearLayout>

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_below="@id/linearLayout1"
            android:orientation="horizontal">

            <EditText
                android:id="@+id/editText"
                android:layout_width="fill_parent"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:inputType="textLongMessage"
                android:text="@string/input_message" />

            <Button
                android:id="@+id/sendButton"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/send_button"
                android:textAllCaps="false" />
        </LinearLayout>
    </RelativeLayout>
</androidx.constraintlayout.widget.ConstraintLayout>

运行如下：
client

注意事项

实践过程中的坑

  1. android.os.NetworkOnMainThreadException
  2. java.net.SocketException: socket failed: EPERM (Operation not permitted)

关于网络编程的提示

Android官方说明：Connect to the network

wy471x
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
移动通信技术Android手机开发
04-13
该文档详细的介绍了安卓的开发流程，是一个非常实用的教程
android移动通信推送技术
04-15
移动推送技术介绍。欢迎需要的朋友前来下载。
网络编程，终端通讯
hfuslvbSDK的博客
04-19 146
tcp 传输控制协议（TCP，Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793 定义。 TCP旨在适应支持多网络应用的分层协议层次结构。 连接到不同但互连的计算机通信网络的主计算机中的成对进程之间依靠TCP提供可靠的通信服务。TCP假设它可以从较低级别的协议获得简单的，可能不可靠的数据报服务。 原则上，TCP应该能够在从硬线连接到分组交换或电路交换网络的各种通信系统之上操作。 终端通讯 接收端相关代码：
网络编程
qq_41934990的博客
05-20 575
网络编程1.网络体系：（1）七层架构 七层结构：物理层：主要包含一些物理设备，主要包含，中继器，集线器，双绞线，等。数据链路层：负责在相邻两个节点之间的线路上无差错的传送以帧为单位的数据，并进行流量控制。主要设备有交换机和网桥。网络层：为传送实体提供端到端的交换网络数据传送功能，主要设备有路由器。传输层:为会话层提供透明.可靠的数据传输服务，保证端到端的数据完整性。会话层:建立和维护应用之间通信的...
Android 网络编程
weixin_33953384的博客
11-12 74
待填坑 转载于:https://www.cnblogs.com/zhangxia/p/4958920.html
基于SIP协议Android视频通信终端系统.pdf
06-23
【基于SIP协议Android视频通信终端系统】 在当今多媒体技术广泛应用的时代，VoIP（Voice over Internet Protocol）技术已经成为通信领域的主流，特别是在中国市场，由于运营商不断提升宽带速度和增加WiFi热点，VoIP...
移动终端开发软件.zip
06-15
本压缩包“移动终端开发软件.zip”很可能包含了相关的学习资料、工具软件以及实例代码，帮助学生深入理解和实践移动应用开发。 首先，移动终端开发主要基于两大操作系统平台：Android和iOS。Android是谷歌主导的...
EX_adscanuitest.zip_网络编程_Java_
08-11
3. **移动设备API**：为了扫描移动终端上的所有已安装应用，开发者通常需要访问设备的Android或iOS系统API。在Android中，这可以通过使用`PackageManager`类获取安装的应用列表；在iOS中，可以使用`UIApplication`和...
weex版跨Android和IOS终端
08-10
在"weex版跨Android和iOS终端"的项目中，我们将深入探讨Weex的核心特性和其在混合移动开发中的应用。 1. **JavaScript开发**：Weex使用JavaScript作为主要编程语言，这使得前端开发者可以轻松上手，利用他们熟悉的...
【课程记录】:移动终端开发课程概要
阳光心态，健康人生的博客
05-25 814
这门课是一个叫做唐好选的老师上的，具体是啥我也没咋听过课。但是具体到要做东西的层面，把相关的环境搭配好这是必须的，因此我这里记录了他上课讲课的内容他讲课大概包括了这些方面 基础知识扯淡 android平台和IOS平台 界面开发技术 游戏开发技术 数据存储技术 网络和通信技术 传感器技术 相关的底层服务 NDK编程 相关的项目实践 简单的做个笔记
网络编程&移动端适配&笔记总结
JontyLi的博客
11-15 274
网络编程&移动端适配&笔记总结01. 媒体查询作用：语法:CSS样式：引用资源：(了解)例子:02. remrem适配愿理03. rem 应用04. 实际应用UI设计稿 :1rem背后代表的值 :具体如何做？05. less的使用安装变量嵌套运算06. 解决方案方案1 ：rem+媒体查询+less 方案方案2（推荐!!!） ：rem+flexible.js+lessflexible.js1rem背后代表的值步骤！！！方案对比 01. 媒体查询 作用： 感受到屏幕的变化；可以根据屏幕不同的宽，
移动终端开发详解总结（二）（kotlin版）| CSDN创作打卡
m0_46579394的博客
02-07 2099
kotlin移动终端开发详解（二），学习快乐起来！妈妈再也不用担心孩子编程学不会了！（哈哈.jpg）
Android终端硬件通讯总结（串口通讯、Usb Com、Usb、蓝牙、Wifi）
最新发布
Kelly
08-05 3629
Android上位机与外设通讯连接库
Android网络编程常用的三种方法
fluency_love的博客
11-26 5331
首先android常用的有三种网络通信方式，socket编程、HttpClient、HttpURLConnection。
Android BLE与终端通信（四）——实现服务器与客户端即时通讯功能
weixin_34377919的博客
01-27 419
Android BLE与终端通信（四）——实现服务器与客户端即时通讯功能 前面几篇一直在讲一些基础，其实说实话，蓝牙主要为多的还是一些概念性的东西，当你把概念都熟悉了之后，你会很简单的就可以实现一些逻辑，主要是Socket和I/O流的操作，今天就来一起做一个聊天的小程序，我们都知道，我们实现蓝牙连接，蓝牙是有主从关系的，所以有...
Android App 安全登录认证解决方案
赵小贱的博客
03-07 2万+
       基于Android App 安全登录认证解决方案近几年移动互联网的高速发展，智能手机的使用用户呈现爆炸性增长，手机终端上的App 种类繁多，大多数App 都需要与后台系统进行交互，交互的第一步需要进行登录认证，过于简单的认证方式可能被破解从而造成用户信息的泄露甚至威胁着用户的财产安全。为此基于Android 系统，对比现有几种常见的App 登录认证方式，并提出一种采用RSA 非对称加...
Android的三种网络通信方式
热门推荐
YUZHIBOYI的专栏
07-13 9万+
Android平台有三种网络接口可以使用，他们分别是：java.net.*(标准Java接口)、Org.apache接口和Android.net.*(Android网络接口)。下面分别介绍这些接口的功能和作用。 1.标准Java接口 java.net.*提供与联网有关的类，包括流、数据包套接字(socket)、Internet协议、常见Http处理等。比如：创建URL，以及URLConnect
基于Android移动终端的巡查管理系统的研究.pdf
06-23
"基于Android移动终端的巡查管理系统研究旨在通过应用移动技术和移动设备，使企业的巡查管理工作在每个环节实现精确有效的控制，满足企业运营和管理的需求。系统采用面向对象的编程方法，服务器端使用J2EE标准技术，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值