android wifi 热点、socket通讯

network

　　WiFi管理工具类



package com.wyf.app.common;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.List;
import android.content.Context;
import android.net.DhcpInfo;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
public class WifiManageUtils
{
private static WifiManager wifiManager;
private static WifiInfo wifiInfo;
private static List<ScanResult> wifiScanlist;
private static List<WifiConfiguration> wifiConfigurationlist;
private static DhcpInfo wifiDhcpInfo;
public WifiManageUtils(Context context)
{
// 取得WifiManager对象
wifiManager = (WifiManager) context
.getSystemService(Context.WIFI_SERVICE);
}
public WifiInfo getWifiConnectInfo()
{
wifiInfo = wifiManager.getConnectionInfo();
return wifiInfo;
}
public List<ScanResult> getScanResult()
{
wifiScanlist = wifiManager.getScanResults();
return wifiScanlist;
}
public List<WifiConfiguration> getConfiguration()
{
wifiConfigurationlist = wifiManager.getConfiguredNetworks();
return wifiConfigurationlist;
}
public DhcpInfo getDhcpInfo()
{
wifiDhcpInfo = wifiManager.getDhcpInfo();
return wifiDhcpInfo;
}
/**
* 开启热点作为服务端的配置
*
* @param ssid
* @param passwd
* @param type
* @return
*/
public WifiConfiguration getCustomeWifiConfiguration(String ssid,
String passwd, int type)
{
WifiConfiguration config = new WifiConfiguration();
config.allowedAuthAlgorithms.clear();
config.allowedGroupCiphers.clear();
config.allowedKeyManagement.clear();
config.allowedPairwiseCiphers.clear();
config.allowedProtocols.clear();
config.SSID = ssid;
if (type == 1) // NOPASS
    {
config.wepKeys[0] = "";
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
config.wepTxKeyIndex = 0;
}
if (type == 2) // WEP
    {
config.hiddenSSID = true;
config.wepKeys[0] = passwd;
config.allowedAuthAlgorithms
.set(WifiConfiguration.AuthAlgorithm.SHARED);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
config.allowedGroupCiphers
.set(WifiConfiguration.GroupCipher.WEP104);
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
config.wepTxKeyIndex = 0;
}
if (type == 3) // WPA
    {
config.preSharedKey = passwd;
config.hiddenSSID = true;
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.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
        config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
config.allowedPairwiseCiphers
.set(WifiConfiguration.PairwiseCipher.CCMP);
config.status = WifiConfiguration.Status.ENABLED;
}
if (type == 4) // WPA2psk test
    {
config.preSharedKey = passwd;
config.hiddenSSID = true;
config.status = WifiConfiguration.Status.ENABLED;
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
config.allowedPairwiseCiphers
.set(WifiConfiguration.PairwiseCipher.TKIP);
config.allowedPairwiseCiphers
.set(WifiConfiguration.PairwiseCipher.CCMP);
config.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
}
return config;
}
/**
* 客户端添加配置，作为连接认证配置
* ssid、passwd 配置前后必须加上双引号“
* @param ssid
* @param passwd
* @param type
* @return
*/
public WifiConfiguration getCustomeWifiClientConfiguration(String ssid,
String passwd, int type)
{
WifiConfiguration config = new WifiConfiguration();
config.allowedAuthAlgorithms.clear();
config.allowedGroupCiphers.clear();
config.allowedKeyManagement.clear();
config.allowedPairwiseCiphers.clear();
config.allowedProtocols.clear();
//双引号必须
config.SSID = "\"" + ssid + "\"";
if (type == 1) // WIFICIPHER_NOPASS
    {
config.wepKeys[0] = "";
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
config.wepTxKeyIndex = 0;
}
if (type == 2) // WIFICIPHER_WEP
    {
config.hiddenSSID = true;
config.wepKeys[0] = "\"" + passwd + "\"";
config.allowedAuthAlgorithms
.set(WifiConfiguration.AuthAlgorithm.SHARED);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
config.allowedGroupCiphers
.set(WifiConfiguration.GroupCipher.WEP104);
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
config.wepTxKeyIndex = 0;
}
if (type == 3) // WIFICIPHER_WPA
    {
config.preSharedKey = "\"" + passwd + "\"";
config.hiddenSSID = true;
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.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
        config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
config.allowedPairwiseCiphers
.set(WifiConfiguration.PairwiseCipher.CCMP);
config.status = WifiConfiguration.Status.ENABLED;
}
if (type == 4) // WPA2psk test
    {
config.preSharedKey = "\"" + passwd + "\"";
config.hiddenSSID = true;
config.status = WifiConfiguration.Status.ENABLED;
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
config.allowedPairwiseCiphers
.set(WifiConfiguration.PairwiseCipher.TKIP);
config.allowedPairwiseCiphers
.set(WifiConfiguration.PairwiseCipher.CCMP);
config.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
}
return config;
}
public Boolean stratWifiAp(String ssid, String psd, int type)
{
Method method1 = null;
try
{
method1 = wifiManager.getClass().getMethod("setWifiApEnabled",
WifiConfiguration.class, boolean.class);
WifiConfiguration netConfig = getCustomeWifiConfiguration(ssid,
psd, type);
method1.invoke(wifiManager, netConfig, true);
return true;
}
catch (Exception e)
{
e.printStackTrace();
return false;
}
}
public void closeWifiAp()
{
if (isWifiApEnabled())
{
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();
}
}
}
public boolean isWifiApEnabled()
{
try
{
Method method = wifiManager.getClass().getMethod("isWifiApEnabled");
method.setAccessible(true);
return (Boolean) method.invoke(wifiManager);
}
catch (NoSuchMethodException e)
{
e.printStackTrace();
}
catch (Exception e)
{
e.printStackTrace();
}
return false;
}
}
　　开启热点服务端部分代码



    public void startWifiHot()
{
btnServer.setEnabled(false);
if (wifiManager.isWifiEnabled())
{
wifiManager.setWifiEnabled(false);
}
Boolean b = wifimanageutils.stratWifiAp(mSSID, mPasswd,3);
if (b)
{
serverThread = new WifiServerThread(context, testh);
Toast.makeText(context, "server 端启动", 3000).show();
serverThread.start();
}
else
{
btnServer.setEnabled(true);
Toast.makeText(context, "server 端失败，请重试", 3000).show();
}
}
　　WifiServerThread服务端线程



public class WifiServerThread extends Thread
{
public ServerSocket mserverSocket;
public Socket socket;
public Context context;
public static final int SERVERPORT = 8191;
public Boolean isrun = true;
public Handler handler;
public WifiServerThread(Context context, Handler handler)
{
this.context = context;
this.handler = handler;
}
public void run()
{
try
{
mserverSocket = new ServerSocket(SERVERPORT);
while (isrun)
{
socket = mserverSocket.accept();
new Thread(new Runnable()
{
@Override
public void run()
{
byte[] buffer = new byte[1024];
int bytes;
InputStream mmInStream = null;
try
{
mmInStream = socket.getInputStream();
}
catch (IOException e1)
{
e1.printStackTrace();
}
System.out.println("server");
try
{
InputStream in = socket.getInputStream();
OutputStream os = socket.getOutputStream();
byte[] data = new byte[1024];
while (in.available() <= 0)
;// 同步
int len = in.read(data);
String[] str = new String(data, 0, len, "utf-8")
.split(";");
String path = Environment
.getExternalStorageDirectory()
.getAbsolutePath()
+ "/CHFS/000000000000" + "/";
if (len != -1)
{
path += "socket_" + str[0];// str[0]是文件名加类型
                }
handler.obtainMessage(10, (Object) str[0])
.sendToTarget();
System.out.println(path);
os.write("start".getBytes());
os.flush();
File file = new File(path);
DataOutputStream out = new DataOutputStream(
new FileOutputStream(file));
System.out.println("开始接收.....");
int countSize = 0;
while ((len = in.read(data)) != -1)
{
out.write(data, 0, len);
countSize += len;
}
os.close();
out.flush();
out.close();
in.close();
}
catch (IOException e)
{
e.printStackTrace();
}
finally
{
try
{
socket.close();
System.out.println("关闭....");
}
catch (Exception e)
{
e.printStackTrace();
}
handler.obtainMessage(10, (Object) "接受 完成")
.sendToTarget();
}
}
}).start();
}
if (mserverSocket != null)
{
try
{
mserverSocket.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
　　开启客户端部分代码



btnClient.setOnClickListener(new OnClickListener()
{
@Override
public void onClick(View v)
{
WifiConfiguration netConfig = wifimanageutils
.getCustomeWifiClientConfiguration(mSSID, mPasswd,3);
int wcgID = wifiManager.addNetwork(netConfig);
boolean b = wifiManager.enableNetwork(wcgID, true);
Boolean iptoready = false;
if (!b)
{
Toast.makeText(context, "wifi 连接配置不可用", 3000).show();
return;
}
while (!iptoready)
{
try
{
// 为了避免程序一直while循环，让它睡个100毫秒在检测……
            Thread.currentThread();
Thread.sleep(100);
}
catch (InterruptedException ie)
{
}
DhcpInfo dhcp = new WifiManageUtils(context).getDhcpInfo();
int ipInt = dhcp.gateway;
if (ipInt != 0)
{
iptoready = true;
}
}
wifiLock.acquire();
clientThread = new WifiClientThread(context);
clientThread.start();
}
});
　　WifiClientThread客户端线程



public class WifiClientThread extends Thread
{
public Socket socket;
public Context context;
public Boolean isrun = true;
public static final int SERVERPORT = 8191;
public OutputStream os;
public InputStream in;
public WifiClientThread(Context context)
{
this.context = context;
}
public void run()
{
try
{
DhcpInfo dhcp = new WifiManageUtils(context).getDhcpInfo();
int ipInt = dhcp.gateway;
String serverip = String.valueOf(new StringBuilder()
.append((ipInt & 0xff)).append('.').append((ipInt >> 8) & 0xff)
.append('.').append((ipInt >> 16) & 0xff).append('.')
.append(((ipInt >> 24) & 0xff)).toString()
);
socket = new Socket(serverip, SERVERPORT);
new Thread(new Runnable()
{
@Override
public void run()
{
if (socket == null)
{
return;
}
System.out.println("client connect");
try
{
String path = Environment.getExternalStorageDirectory()
.getAbsolutePath() + "/CHFS/000000000000";
if (android.os.Build.MODEL.contains("8812"))
{
path += "/camera/" + "camera_temp_name.jpg";
}
else
{
//                path += "/camera/" + "camera_temp_name.mp4";
path+="/ARChon-v1.1-x86_64.zip";
}
DataInputStream read = new DataInputStream(
new FileInputStream(new File(path)));
System.out.println(read.available());
String fileName = path.substring(path.lastIndexOf("/") + 1);// 获得文件名加类型

System.out.println(fileName);
os = socket.getOutputStream();
in = socket.getInputStream();
os.write((fileName + ";" + read.available())
.getBytes("utf-8"));// 将文件名和文件大小传给接收端
            os.flush();
byte[] data = new byte[1024];
int len = in.read(data);
String start = new String(data, 0, len);
int sendCountLen = 0;
if (start.equals("start"))
{
while ((len = read.read(data)) != -1)
{
os.write(data, 0, len);
sendCountLen += len;
}
os.flush();
os.close();
read.close();
}
}
catch (Exception e)
{
e.printStackTrace();
}
finally
{
try
{
socket.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
}).start();
}
catch (IOException e)
// catch (Exception e)
    {
e.printStackTrace();
}
}
}