2022厘米最新地址

企业开发 2018-05-29 10:22:36 阅读次数: 0

看片地址 https://www.2022cma.com

上代码
@Override
public Intent myRegisterReceiver(BroadcastReceiver receiver,
IntentFilter filter) {
// TODO Auto-generated method stub
MainActivity.this.registerReceiver(receiver, filter);
return null;
} 

                @Override  
                public void onNotifyWifiConnected() {  
                    // TODO Auto-generated method stub  
                    Log.v(TAG, "have connected success!");  
                    Log.v(TAG, "###############################");  
                }  

                @Override  
                public void onNotifyWifiConnectFailed() {  
                    // TODO Auto-generated method stub  
                    Log.v(TAG, "have connected failed!");  
                    Log.v(TAG, "###############################");  
                }  
            };  
            mWifiAdmin.openWifi();  
            mWifiAdmin.addNetwork(mWifiAdmin.createWifiInfo("YOU_WIFI", "MM123456", WifiAdmin.TYPE_WPA));  

        }  
    });  

    mBtn2.setOnClickListener(new Button.OnClickListener() {  

        @Override  
        public void onClick(View v) {  
            // TODO Auto-generated method stub  

            WifiApAdmin wifiAp = new WifiApAdmin(mContext);  
            wifiAp.startWifiAp("\"HotSpot\"", "hhhhhh123");  
        }  
    });  

}  

@Override  
public boolean onCreateOptionsMenu(Menu menu) {  
    // Inflate the menu; this adds items to the action bar if it is present.  
    getMenuInflater().inflate(R.menu.activity_main, menu);  
    return true;  
}  

 @Override  
    public void onResume() {  
        super.onResume();  

        Log.d("Rssi", "Registered");  
    }  

    @Override  
    public void onPause() {  
        super.onPause();  

        Log.d("Rssi", "Unregistered");  
    }

}

WifiAdmin.java

参考了：//http://blog.csdn.net/yuanbohx/article/details/8109042

[java] view plain copy
package com.widget.hotspot;

import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.NetworkInfo.DetailedState;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.net.wifi.WifiManager.WifiLock;
import android.util.Log;

public abstract class WifiAdmin { 

private static final String TAG = "WifiAdmin";  

private WifiManager mWifiManager;  
private WifiInfo mWifiInfo;  
// 扫描出的网络连接列表  
private List<ScanResult> mWifiList;  
private List<WifiConfiguration> mWifiConfiguration;  

private WifiLock mWifiLock;  

private String mPasswd = "";  
private String mSSID = "";  

private Context mContext = null;  

public WifiAdmin(Context context) {  

    mContext = context;  

    // 取得WifiManager对象  
    mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);  
    // 取得WifiInfo对象  
    mWifiInfo = mWifiManager.getConnectionInfo();  

    Log.v(TAG, "getIpAddress = " + mWifiInfo.getIpAddress());  
}  

// 打开WIFI  
public void openWifi() {  
    if (!mWifiManager.isWifiEnabled()) {  
        mWifiManager.setWifiEnabled(true);  
    }  
}  

// 关闭WIFI  
public void closeWifi() {  
    if (mWifiManager.isWifiEnabled()) {  
        mWifiManager.setWifiEnabled(false);  
    }  
}  

public abstract Intent myRegisterReceiver(BroadcastReceiver receiver, IntentFilter filter);  

public abstract void myUnregisterReceiver(BroadcastReceiver receiver);  

public abstract void onNotifyWifiConnected();  

public abstract void onNotifyWifiConnectFailed();  

// 添加一个网络并连接  
public void addNetwork(WifiConfiguration wcg) {  

    register();  

    WifiApAdmin.closeWifiAp(mContext);  

    int wcgID = mWifiManager.addNetwork(wcg);  
    boolean b = mWifiManager.enableNetwork(wcgID, true);  
}  

public static final int TYPE_NO_PASSWD = 0x11;  
public static final int TYPE_WEP = 0x12;  
public static final int TYPE_WPA = 0x13;  

public void addNetwork(String ssid, String passwd, int type) {  
    if (ssid == null || passwd == null || ssid.equals("")) {  
        Log.e(TAG, "addNetwork() ## nullpointer error!");  
        return;  
    }  

    if (type != TYPE_NO_PASSWD && type != TYPE_WEP && type != TYPE_WPA) {  
        Log.e(TAG, "addNetwork() ## unknown type = " + type);  
    }  

    stopTimer();  
    unRegister();  

    addNetwork(createWifiInfo(ssid, passwd, type));  
}  

private BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {  

    @Override  
    public void onReceive(Context context, Intent intent) {  
        // TODO Auto-generated method stub  
        if (intent.getAction().equals(WifiManager.RSSI_CHANGED_ACTION)) {  
            Log.d(TAG, "RSSI changed");  

            //有可能是正在获取，或者已经获取了  
            Log.d(TAG, " intent is " + WifiManager.RSSI_CHANGED_ACTION);  

            if (isWifiContected(mContext) == WIFI_CONNECTED) {  
                stopTimer();  
                onNotifyWifiConnected();  
                unRegister();  
            } else if (isWifiContected(mContext) == WIFI_CONNECT_FAILED) {  
                stopTimer();  
                closeWifi();  
                onNotifyWifiConnectFailed();  
                unRegister();  
            } else if (isWifiContected(mContext) == WIFI_CONNECTING) {  

            }  
        }  
    }  
};  

private final int STATE_REGISTRING = 0x01;  
private final int STATE_REGISTERED = 0x02;  
private final int STATE_UNREGISTERING = 0x03;  
private final int STATE_UNREGISTERED = 0x04;  

private int mHaveRegister = STATE_UNREGISTERED;  
private synchronized void register() {  
    Log.v(TAG, "register() ##mHaveRegister = " + mHaveRegister);  

    if (mHaveRegister == STATE_REGISTRING   
            || mHaveRegister == STATE_REGISTERED) {  
        return ;  
    }  

    mHaveRegister = STATE_REGISTRING;  
    myRegisterReceiver(mBroadcastReceiver, new IntentFilter(WifiManager.RSSI_CHANGED_ACTION));  
    mHaveRegister = STATE_REGISTERED;  

    startTimer();  
}  

private synchronized void unRegister() {  
    Log.v(TAG, "unRegister() ##mHaveRegister = " + mHaveRegister);  

    if (mHaveRegister == STATE_UNREGISTERED   
            || mHaveRegister == STATE_UNREGISTERING) {  
        return ;  
    }  

    mHaveRegister = STATE_UNREGISTERING;  
    myUnregisterReceiver(mBroadcastReceiver);  
    mHaveRegister = STATE_UNREGISTERED;  
}  

private Timer mTimer = null;  
private void startTimer() {  
    if (mTimer != null) {  
        stopTimer();  
    }  

    mTimer = new Timer(true);

// mTimer.schedule(mTimerTask, 0, 20 1000);// 20s
mTimer.schedule(mTimerTask, 30 1000);
} 

private TimerTask mTimerTask = new TimerTask() {  

    @Override  
    public void run() {  
        // TODO Auto-generated method stub  
        Log.e(TAG, "timer out!");  
        onNotifyWifiConnectFailed();  
        unRegister();  
    }  
};  

private void stopTimer() {  
    if (mTimer != null) {  
        mTimer.cancel();  
        mTimer = null;  
    }  
}  

@Override  
protected void finalize() {  
    try {  
        super.finalize();  
        unRegister();  
    } catch (Throwable e) {  
        // TODO Auto-generated catch block  
        e.printStackTrace();  
    }  
}  

public WifiConfiguration createWifiInfo(String SSID, String password, int type) {  

    Log.v(TAG, "SSID = " + SSID + "## Password = " + password + "## Type = " + type);  

    WifiConfiguration config = new WifiConfiguration();  
    config.allowedAuthAlgorithms.clear();  
    config.allowedGroupCiphers.clear();  
    config.allowedKeyManagement.clear();  
    config.allowedPairwiseCiphers.clear();  
    config.allowedProtocols.clear();  
    config.SSID = "\"" + SSID + "\"";  

    WifiConfiguration tempConfig = this.IsExsits(SSID);  
    if (tempConfig != null) {  
        mWifiManager.removeNetwork(tempConfig.networkId);  
    }  

    // 分为三种情况：1没有密码2用wep加密3用wpa加密  
    if (type == TYPE_NO_PASSWD) {// WIFICIPHER_NOPASS  
        config.wepKeys[0] = "";  
        config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);  
        config.wepTxKeyIndex = 0;  

    } else if (type == TYPE_WEP) {  //  WIFICIPHER_WEP   
        config.hiddenSSID = true;  
        config.wepKeys[0] = "\"" + password + "\"";  
        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;  
    } else if (type == TYPE_WPA) {   // WIFICIPHER_WPA  
        config.preSharedKey = "\"" + password + "\"";  
        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;  
    }   

    return config;  
}  

public static final int WIFI_CONNECTED = 0x01;  
public static final int WIFI_CONNECT_FAILED = 0x02;  
public static final int WIFI_CONNECTING = 0x03;  
/** 
 * 判断wifi是否连接成功,不是network 
 *  
 * @param context 
 * @return 
 */  
public int isWifiContected(Context context) {  
    ConnectivityManager connectivityManager = (ConnectivityManager) context  
            .getSystemService(Context.CONNECTIVITY_SERVICE);  
    NetworkInfo wifiNetworkInfo = connectivityManager  
            .getNetworkInfo(ConnectivityManager.TYPE_WIFI);  

    Log.v(TAG, "isConnectedOrConnecting = " + wifiNetworkInfo.isConnectedOrConnecting());  
    Log.d(TAG, "wifiNetworkInfo.getDetailedState() = " + wifiNetworkInfo.getDetailedState());  
    if (wifiNetworkInfo.getDetailedState() == DetailedState.OBTAINING_IPADDR  
            || wifiNetworkInfo.getDetailedState() == DetailedState.CONNECTING) {  
        return WIFI_CONNECTING;  
    } else if (wifiNetworkInfo.getDetailedState() == DetailedState.CONNECTED) {  
        return WIFI_CONNECTED;  
    } else {  
        Log.d(TAG, "getDetailedState() == " + wifiNetworkInfo.getDetailedState());  
        return WIFI_CONNECT_FAILED;  
    }  
}  

private WifiConfiguration IsExsits(String SSID) {  
    List<WifiConfiguration> existingConfigs = mWifiManager.getConfiguredNetworks();  
    for (WifiConfiguration existingConfig : existingConfigs) {  
        if (existingConfig.SSID.equals("\"" + SSID + "\"") /*&& existingConfig.preSharedKey.equals("\"" + password + "\"")*/) {  
            return existingConfig;  
        }  
    }  
    return null;  
}  

// 断开指定ID的网络  
public void disconnectWifi(int netId) {  
    mWifiManager.disableNetwork(netId);  
    mWifiManager.disconnect();  
}  

// 检查当前WIFI状态  
public int checkState() {  
    return mWifiManager.getWifiState();  
}  

// 锁定WifiLock  
public void acquireWifiLock() {  
    mWifiLock.acquire();  
}  

// 解锁WifiLock  
public void releaseWifiLock() {  
    // 判断时候锁定  
    if (mWifiLock.isHeld()) {  
        mWifiLock.acquire();  
    }  
}  

// 创建一个WifiLock  
public void creatWifiLock() {  
    mWifiLock = mWifiManager.createWifiLock("Test");  
}  

// 得到配置好的网络  
public List<WifiConfiguration> getConfiguration() {  
    return mWifiConfiguration;  
}  

// 指定配置好的网络进行连接  
public void connectConfiguration(int index) {  
    // 索引大于配置好的网络索引返回  
    if (index > mWifiConfiguration.size()) {  
        return;  
    }  
    // 连接配置好的指定ID的网络  
    mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId,  
            true);  
}  

public void startScan() {  
    mWifiManager.startScan();  
    mWifiList = mWifiManager.getScanResults();  
    mWifiConfiguration = mWifiManager.getConfiguredNetworks();  
}  

// 得到网络列表  
public List<ScanResult> getWifiList() {  
    return mWifiList;  
}  

// 查看扫描结果  
public StringBuilder lookUpScan() {  
    StringBuilder stringBuilder = new StringBuilder();  
    for (int i = 0; i < mWifiList.size(); i++) {  
        stringBuilder  
                .append("Index_" + new Integer(i + 1).toString() + ":");  
        // 将ScanResult信息转换成一个字符串包  
        // 其中把包括：BSSID、SSID、capabilities、frequency、level  
        stringBuilder.append((mWifiList.get(i)).toString());  
        stringBuilder.append("/n");  
    }  
    return stringBuilder;  
}  

// 得到MAC地址  
public String getMacAddress() {  
    return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();  
}  

// 得到接入点的BSSID  
public String getBSSID() {  
    return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();  
}  

// 得到IP地址  
public int getIPAddress() {  
    return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();  
}  

// 得到连接的ID  
public int getNetworkId() {  
    return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();  
}  

// 得到WifiInfo的所有信息包  
public String getWifiInfo() {  
    return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();  
}

}

WifiApAdmin.java

参考了 http://blog.csdn.net/cxlmax/article/details/7827102

[java] view plain copy
package com.widget.hotspot;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Timer;
import java.util.TimerTask;

import android.content.Context;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.util.Log;

/**

  • 创建热点

  • */
    public class WifiApAdmin {
    public static final String TAG = "WifiApAdmin";

    public static void closeWifiAp(Context context) {
    WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
    closeWifiAp(wifiManager);
    }

    private WifiManager mWifiManager = null;

    private Context mContext = null;
    public WifiApAdmin(Context context) {
    mContext = context; 

    mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);    

closeWifiAp(mWifiManager);

    }

    private String mSSID = "";
    private String mPasswd = "";
    public void startWifiAp(String ssid, String passwd) {
    mSSID = ssid;
    mPasswd = passwd; 

    if (mWifiManager.isWifiEnabled()) {  
    mWifiManager.setWifiEnabled(false);  
}   

stratWifiAp();  

MyTimerCheck timerCheck = new MyTimerCheck() {  

    @Override  
    public void doTimerCheckWork() {  
        // TODO Auto-generated method stub  

        if (isWifiApEnabled(mWifiManager)) {  
            Log.v(TAG, "Wifi enabled success!");  
            this.exit();  
        } else {  
            Log.v(TAG, "Wifi enabled failed!");  
        }  
    }  

    @Override  
    public void doTimeOutWork() {  
        // TODO Auto-generated method stub  
        this.exit();  
    }  
};  
timerCheck.start(15, 1000);

    }

    public void stratWifiAp() {
    Method method1 = null;
    try {
    method1 = mWifiManager.getClass().getMethod("setWifiApEnabled",
    WifiConfiguration.class, boolean.class);
    WifiConfiguration netConfig = new WifiConfiguration(); 

        netConfig.SSID = mSSID;  
    netConfig.preSharedKey = mPasswd;  

    netConfig.allowedAuthAlgorithms  
            .set(WifiConfiguration.AuthAlgorithm.OPEN);  
    netConfig.allowedProtocols.set(WifiConfiguration.Protocol.RSN);  
    netConfig.allowedProtocols.set(WifiConfiguration.Protocol.WPA);  
    netConfig.allowedKeyManagement  
            .set(WifiConfiguration.KeyMgmt.WPA_PSK);  
    netConfig.allowedPairwiseCiphers  
            .set(WifiConfiguration.PairwiseCipher.CCMP);  
    netConfig.allowedPairwiseCiphers  
            .set(WifiConfiguration.PairwiseCipher.TKIP);  
    netConfig.allowedGroupCiphers  
            .set(WifiConfiguration.GroupCipher.CCMP);  
    netConfig.allowedGroupCiphers  
            .set(WifiConfiguration.GroupCipher.TKIP);  

    method1.invoke(mWifiManager, netConfig, true);  

} catch (IllegalArgumentException e) {  
    // TODO Auto-generated catch block  
    e.printStackTrace();  
} catch (IllegalAccessException e) {  
    // TODO Auto-generated catch block  
    e.printStackTrace();  
} catch (InvocationTargetException e) {  
    // TODO Auto-generated catch block  
    e.printStackTrace();  
} catch (SecurityException e) {  
    // TODO Auto-generated catch block  
    e.printStackTrace();  
} catch (NoSuchMethodException e) {  
    // TODO Auto-generated catch block  
    e.printStackTrace();  
}

    }

    private static void closeWifiAp(WifiManager wifiManager) {
    if (isWifiApEnabled(wifiManager)) {
    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) {  
        // TODO Auto-generated catch block  
        e.printStackTrace();  
    } catch (IllegalArgumentException e) {  
        // TODO Auto-generated catch block  
        e.printStackTrace();  
    } catch (IllegalAccessException e) {  
        // TODO Auto-generated catch block  
        e.printStackTrace();  
    } catch (InvocationTargetException e) {  
        // TODO Auto-generated catch block  
        e.printStackTrace();  
    }  
}

    }

    private static boolean isWifiApEnabled(WifiManager wifiManager) {
    try {
    Method method = wifiManager.getClass().getMethod("isWifiApEnabled");
    method.setAccessible(true);
    return (Boolean) method.invoke(wifiManager); 

    } catch (NoSuchMethodException e) {  
    // TODO Auto-generated catch block  
    e.printStackTrace();  
} catch (Exception e) {  
    e.printStackTrace();  
}  

return false;

    }

}

MyTimeCheck.java

[java] view plain copy
package com.widget.hotspot;

public abstract class MyTimerCheck {
private int mCount = 0;
private int mTimeOutCount = 1;
private int mSleepTime = 1000; // 1s
private boolean mExitFlag = false;
private Thread mThread = null; 

/** 
 * Do not process UI work in this. 
 */  
public abstract void doTimerCheckWork();  

public abstract void doTimeOutWork();  

public MyTimerCheck() {  
    mThread = new Thread(new Runnable() {  

        @Override  
        public void run() {  
            // TODO Auto-generated method stub  
            while (!mExitFlag) {  
                mCount++;  
                if (mCount < mTimeOutCount) {  
                    doTimerCheckWork();  
                    try {  
                        mThread.sleep(mSleepTime);  
                    } catch (InterruptedException e) {  
                        // TODO Auto-generated catch block  
                        e.printStackTrace();  
                        exit();  
                    }  
                } else {  
                    doTimeOutWork();  
                }  
            }  
        }  
    });  
}  

/** 
 * start 
 * @param times  How many times will check? 
 * @param sleepTime ms, Every check sleep time. 
 */  
public void start(int timeOutCount, int sleepTime) {  
    mTimeOutCount = timeOutCount;  
    mSleepTime = sleepTime;  

    mThread.start();  
}  

public void exit() {  
    mExitFlag = true;  
}

}

xml布局简单不上了，
效果自己试试看打印就知道了

猜你喜欢

转载自blog.51cto.com/13771765/2121400
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022