android wifi 热点、socket通讯

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();

    }

    }



}

 

你可能感兴趣的:(android)