首先，描述下功能，两个手机，其中一个手机开热点，另外一个手机连接热点，2个手机间数据通信（不需要流量）。简述一下原理：开热点的手机相当于路由器，连接的手机作为客户端，获取路由器的IP建立Socket 连接，开始双方通信。
一、服务器端：
开热点的作为服务器端
初始化数据：
public static final int DEVICE_CONNECTING = 1;//有设备正在连接热点
public static final int DEVICE_CONNECTED = 2;//有设备连上热点
public static final int SEND_MSG_SUCCSEE = 3;//发送消息成功
public static final int SEND_MSG_ERROR = 4;//发送消息失败
public static final int GET_MSG = 6;//获取新消息
private TextView text_state;
private WifiManager wifiManager;
/**
* 连接线程
*/
private ConnectThread connectThread;
/**
* 监听线程
*/
private ListenerThread listenerThread;
/**
* 热点名称
*/
private static final String WIFI_HOTSPOT_SSID = "TEST";
/**
* 端口号
*/
private static final int PORT = 54321;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
findViewById(R.id.create_wifi).setOnClickListener(this);
findViewById(R.id.close_wifi).setOnClickListener(this);
findViewById(R.id.send).setOnClickListener(this);
text_state = (TextView) findViewById(R.id.receive);
wifiManager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
/**
* 先开启监听线程，在开启连接
*/
listenerThread = new ListenerThread(PORT, handler);
listenerThread.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 开启连接线程
new Thread(new Runnable() {
@Override
public void run() {
try {
Log.i("ip", "getWifiApIpAddress()" + getWifiApIpAddress());
//本地路由开启通信
String ip = getWifiApIpAddress();
if (ip != null) {
} else {
ip = "192.168.43.1";
}
Socket socket = new Socket(ip, PORT);
connectThread = new ConnectThread(MainActivity.this, socket, handler);
connectThread.start();
} catch (IOException e) {
e.printStackTrace();
runOnUiThread(new Runnable() {
@Override
public void run() {
text_state.setText("创建通信失败");
}
});
}
}
}).start();
}
创建wifi 热点，之后开启Socket 监听线程
/**
* 创建Wifi热点
*/
private void createWifiHotspot() {
if (wifiManager.isWifiEnabled()) {
//如果wifi处于打开状态，则关闭wifi,
wifiManager.setWifiEnabled(false);
}
final WifiConfiguration config = new WifiConfiguration();
config.SSID = WIFI_HOTSPOT_SSID;
config.preSharedKey = "123456789";
config.hiddenSSID = false;
config.allowedAuthAlgorithms
.set(WifiConfiguration.AuthAlgorithm.OPEN);//开放系统认证
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
config.allowedPairwiseCiphers
.set(WifiConfiguration.PairwiseCipher.TKIP);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
config.allowedPairwiseCiphers
.set(WifiConfiguration.PairwiseCipher.CCMP);
config.status = WifiConfiguration.Status.ENABLED;
//通过反射调用设置热点
//192.168.43.59
// Log.i("ip", "getWifiApIpAddress()" + getWifiApIpAddress() +
// "\n");
try {
Method method = wifiManager.getClass().getMethod(
"setWifiApEnabled", WifiConfiguration.class, Boolean.TYPE);
boolean enable = (Boolean) method.invoke(wifiManager, config, true);
if (enable) {
text_state.setText("热点已开启 SSID:" + WIFI_HOTSPOT_SSID + " password:123456789");
// 开启连接线程
new Thread(new Runnable() {
@Override
public void run() {
try {
Log.i("ip", "getWifiApIpAddress()" + getWifiApIpAddress()
);
String ip = getWifiApIpAddress();
if (ip != null) {
} else {
//一般Android手机默认路由是
ip = "192.168.43.1";
}
//本地路由开启通信
Socket socket = new Socket(ip, PORT);
connectThread = new ConnectThread(MainActivity.this, socket, handler);
connectThread.start();
} catch (IOException e) {
e.printStackTrace();
runOnUiThread(new Runnable() {
@Override
public void run() {
text_state.setText("创建通信失败");
}
});
}
}
}).start();
Thread.sleep(1000);
// listenerThread = new ListenerThread(PORT, handler);
// listenerThread.start();
} else {
text_state.setText("创建热点失败");
}
} catch (Exception e) {
e.printStackTrace();
text_state.setText("创建热点失败");
}
}
服务器端获取本地路由：
public String getWifiApIpAddress() {
try {
for (Enumeration<NetworkInterface> en = NetworkInterface
.getNetworkInterfaces(); en.hasMoreElements(); ) {
NetworkInterface intf = en.nextElement();
if (intf.getName().contains("wlan")) {
for (Enumeration<InetAddress> enumIpAddr = intf
.getInetAddresses(); enumIpAddr.hasMoreElements(); ) {
InetAddress inetAddress = enumIpAddr.nextElement();
if (!inetAddress.isLoopbackAddress()
&& (inetAddress.getAddress().length == 4)) {
Log.d("Main", inetAddress.getHostAddress());
return inetAddress.getHostAddress();
}
}
}
}
} catch (SocketException ex) {
Log.e("Main", ex.toString());
}
return null;
}
关闭热点
/**
* 关闭WiFi热点
*/
public void closeWifiHotspot() {
try {
Method method = wifiManager.getClass().getMethod("getWifiApConfiguration");
method.setAccessible(true);
WifiConfiguration config = (WifiConfiguration) method.invoke(wifiManager);
Method method2 = wifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);
method2.invoke(wifiManager, config, false);
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
text_state.setText("热点已关闭");
}
ListenerThread 监听线程
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import com.example.syhuang.wifiserver.MainActivity;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 监听线程
* Created by syh on 2018/4/3
*/
public class ListenerThread extends Thread {
private ServerSocket serverSocket = null;
private Handler handler;
private int port;
private Socket socket;
public ListenerThread(int port, Handler handler) {
setName("ListenerThread");
this.port = port;
this.handler = handler;
try {
serverSocket = new ServerSocket(port);//监听本机的12345端口
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void run() {
while (true) {
try {
Log.i("ListennerThread", "阻塞");
//阻塞，等待设备连接
if (serverSocket != null)
socket = serverSocket.accept();
Message message = Message.obtain();
message.what = MainActivity.DEVICE_CONNECTING;
handler.sendMessage(message);
} catch (IOException e) {
Log.i("ListennerThread", "error:" + e.getMessage());
e.printStackTrace();
}
}
}
public Socket getSocket() {
return socket;
}
}
ConnectThread 连接线程
package com.example.syhuang.wifiserver.thread;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import com.example.syhuang.wifiserver.MainActivity;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.text.DecimalFormat;
/**
* 连接线程
* Created by syhuang on 2018/4/3
*/
public class ConnectThread extends Thread {
private final Socket socket;
private Handler handler;
private InputStream inputStream;
private OutputStream outputStream;
Context context;
public ConnectThread(Context context, Socket socket, Handler handler) {
setName("ConnectThread");
Log.i("ConnectThread", "ConnectThread");
this.socket = socket;
this.handler = handler;
this.context = context;
}
@Override
public void run() {
/* if(activeConnect){
// socket.c
}*/
if (socket == null) {
return;
}
handler.sendEmptyMessage(MainActivity.DEVICE_CONNECTED);
try {
//获取数据流
inputStream = socket.getInputStream();
outputStream = socket.getOutputStream();
byte[] buffer = new byte[1024];
int bytes;
while (true) {
//读取数据
bytes = inputStream.read(buffer);
if (bytes > 0) {
final byte[] data = new byte[bytes];
System.arraycopy(buffer, 0, data, 0, bytes);
Message message = Message.obtain();
message.what = MainActivity.GET_MSG;
Bundle bundle = new Bundle();
bundle.putString("MSG", new String(data));
message.setData(bundle);
handler.sendMessage(message);
}
// DataInputStream dis = null;
// FileOutputStream fos = null;
// try {
// dis = new DataInputStream(inputStream);
//
// // 文件名和长度
// String fileName = dis.readUTF();
// if (!fileName.equals("")) {
// long fileLength = dis.readLong();
// Log.i("ConnectThread", "======== 文件接收 [File Name：" + fileName + "] " +
// "[Size：" + getFormatFileSize(fileLength) + "] ========");
// File directory = new File(Environment.getExternalStorageDirectory() + "/");
// if (!directory.exists()) {
// directory.mkdir();
// } else {
// }
// File file = new File(directory.getAbsolutePath() + File.separatorChar + fileName);
// fos = new FileOutputStream(file);
//
// // 开始接收文件
// byte[] bytesA = new byte[1024];
// int length = 0;
// int progress = 0;
// while ((length = dis.read(bytesA, 0, bytesA.length)) != -1) {
// Log.i("ConnectThread", length + "...");
// fos.write(bytesA, 0, length);
// fos.flush();
// progress += length;
// Log.i("ConnectThread", "| " + (100 * progress / file.length()) + "% |");
// }
// Log.i("ConnectThread", "文件传输完成");
//
// Message message = Message.obtain();
// message.what = MainActivity.GET_MSG;
// Bundle bundle = new Bundle();
// bundle.putString("MSG", new String("接收到文件：" + file.getAbsolutePath()));
// message.setData(bundle);
// handler.sendMessage(message);
// } else {
// //读取数据
// bytes = inputStream.read(buffer);
// if (bytes > 0) {
// final byte[] data = new byte[bytes];
// System.arraycopy(buffer, 0, data, 0, bytes);
//
//
// Message message = Message.obtain();
// message.what = MainActivity.GET_MSG;
// Bundle bundle = new Bundle();
// bundle.putString("MSG", new String(data));
// message.setData(bundle);
// handler.sendMessage(message);
//
// Log.i("ConnectThread", "读取到数据:" + new String(data));
// }
// }
}
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 格式化文件大小
*
* @param length
* @return
*/
private String getFormatFileSize(long length) {
DecimalFormat df = new DecimalFormat("#0.0");
double size = ((double) length) / (1 << 30);
if (size >= 1) {
return df.format(size) + "GB";
}
size = ((double) length) / (1 << 20);
if (size >= 1) {
return df.format(size) + "MB";
}
size = ((double) length) / (1 << 10);
if (size >= 1) {
return df.format(size) + "KB";
}
return length + "B";
}
public static boolean copyFile(InputStream inputStream, OutputStream out) {
byte buf[] = new byte[1024];
int len;
try {
while ((len = inputStream.read(buf)) != -1) {
out.write(buf, 0, len);
}
out.close();
// inputStream.close();
} catch (IOException e) {
return false;
}
return true;
}
/**
* 发送数据
*/
public void sendData(String msg) {
Log.i("ConnectThread", "发送数据:" + (outputStream == null));
if (outputStream != null) {
try {
outputStream.write(msg.getBytes());
Log.i("ConnectThread", "发送消息：" + msg);
Message message = Message.obtain();
message.what = MainActivity.SEND_MSG_SUCCSEE;
Bundle bundle = new Bundle();
bundle.putString("MSG", new String(msg));
message.setData(bundle);
handler.sendMessage(message);
} catch (IOException e) {
e.printStackTrace();
Message message = Message.obtain();
message.what = MainActivity.SEND_MSG_ERROR;
Bundle bundle = new Bundle();
bundle.putString("MSG", new String(msg));
message.setData(bundle);
handler.sendMessage(message);
}
}
}
}
二、客户端
客户端连接到热点,代码差不多，初始化数据部分顺序不一样，先开启连接线程，在开启监听线程，获取路由器IP 地址有差别。其他基本一样。
wifi获取 已连接网络路由 路由ip地址
/**
* wifi获取 已连接网络路由 路由ip地址
* @param context
* @return
*/
private static String getWifiRouteIPAddress(Context context) {
WifiManager wifi_service = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
DhcpInfo dhcpInfo = wifi_service.getDhcpInfo();
// WifiInfo wifiinfo = wifi_service.getConnectionInfo();
// System.out.println("Wifi info----->" + wifiinfo.getIpAddress());
// System.out.println("DHCP info gateway----->" + Formatter.formatIpAddress(dhcpInfo.gateway));
// System.out.println("DHCP info netmask----->" + Formatter.formatIpAddress(dhcpInfo.netmask));
//DhcpInfo中的ipAddress是一个int型的变量，通过Formatter将其转化为字符串IP地址
String routeIp = Formatter.formatIpAddress(dhcpInfo.gateway);
Log.i("route ip", "wifi route ip：" + routeIp);
return routeIp;
}
初始化
public static final int DEVICE_CONNECTING = 1;//有设备正在连接热点
public static final int DEVICE_CONNECTED = 2;//有设备连上热点
public static final int SEND_MSG_SUCCSEE = 3;//发送消息成功
public static final int SEND_MSG_ERROR = 4;//发送消息失败
public static final int GET_MSG = 6;//获取新消息
private TextView text_state;
/**
* 连接线程
*/
private ConnectThread connectThread;
/**
* 监听线程
*/
private ListenerThread listenerThread;
/**
* 热点名称
*/
private static final String WIFI_HOTSPOT_SSID = "TEST";
/**
* 端口号
*/
private static final int PORT = 54321;
private WifiManager wifiManager;
private TextView status_init;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
findViewById(R.id.send).setOnClickListener(this);
findViewById(R.id.connect).setOnClickListener(this);
findViewById(R.id.fileButton).setOnClickListener(this);
wifiManager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
//检查Wifi状态
if (!wifiManager.isWifiEnabled())
wifiManager.setWifiEnabled(true);
text_state = (TextView) findViewById(R.id.status_info);
status_init = (TextView) findViewById(R.id.status_init);
status_init.setText("已连接到：" + wifiManager.getConnectionInfo().getSSID() +
"\nIP:" + getIp()
+ "\n路由：" + getWifiRouteIPAddress(MainActivity.this));
// initBroadcastReceiver();
// 开启连接线程
new Thread(new Runnable() {
@Override
public void run() {
try {
Socket socket = new Socket(getWifiRouteIPAddress(MainActivity.this), PORT);
connectThread = new ConnectThread(socket, handler);
connectThread.start();
} catch (IOException e) {
e.printStackTrace();
runOnUiThread(new Runnable() {
@Override
public void run() {
text_state.setText("通信连接失败");
}
});
}
}
}).start();
listenerThread = new ListenerThread(PORT, handler);
listenerThread.start();
}
服务器和客户端Handler处理一样
private Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case DEVICE_CONNECTING:
connectThread = new ConnectThread(listenerThread.getSocket(), handler);
connectThread.start();
break;
case DEVICE_CONNECTED:
text_state.setText("设备连接成功");
break;
case SEND_MSG_SUCCSEE:
text_state.setText("发送消息成功:" + msg.getData().getString("MSG"));
break;
case SEND_MSG_ERROR:
text_state.setText("发送消息失败:" + msg.getData().getString("MSG"));
break;
case GET_MSG:
text_state.setText("收到消息:" + msg.getData().getString("MSG"));
break;
}
}
};
参考文章：
Android 连接Wifi和创建Wifi热点 demo - CSDN博客
Android WiFi开发 （一）扫描、连接、信息 - CSDN博客
Android/安卓开发之WIFI的基本应用 - CSDN博客
Android设备之间通过Wifi通信 - sowhat4999 - 博客园
Android WiFi开发教程（三）——WiFi热点数据传输 - CSDN博客
【Android】Android手机通过wifi进行数据传输 - CSDN博客
android wifi 点对点传输 - 简书
android WIFI Socket 文件传输 - Android移动开发技术文章_手机开发 - 红黑联盟
Android 实现无网络传输文件用户5207283611新浪博客
wifi direct—深入理解Wi-Fi P2P - CSDN博客
(高效开发)Android手机间使用socket进行文件互传实例 - CSDN博客
Android仿茄子快传-实现面对面快传功能 - CSDN博客
安卓手机wifi面对面快传的实现 - CSDN博客
