GVKun编程网logo

怎样开启热点wifi|wifi热点的详细设置(图文)（怎么开启热点wifi）

7

本文将带您了解关于怎样开启热点wifi|wifi热点的详细设置(图文)的新内容，同时我们还将为您解释怎么开启热点wifi的相关知识，另外，我们还将为您提供关于Android连接Wifi和创建Wifi热

本文将带您了解关于怎样开启热点wifi|wifi热点的详细设置(图文)的新内容，同时我们还将为您解释怎么开启热点wifi的相关知识，另外，我们还将为您提供关于Android 连接Wifi和创建Wifi热点的实例、android-使用“ setWifiApEnabled”启用wifi热点时无法设置“ WifiConfiguration”、APwifi（破解版）共享无线WIFI热点的使用方法、Mac怎么设置wifi热点，Mac做wifi热点的实用信息。

本文目录一览：

怎样开启热点wifi|wifi热点的详细设置(图文)（怎么开启热点wifi）

怎样开启热点wifi|wifi热点的详细设置(图文)（怎么开启热点wifi）

怎样开启热点wifi|wifi热点的详细设置(图文)

我们在使用winxp系统的过程中,经常需要对winxp系统wifi热点进行设置。对于winxp系统wifi热点有什么好的办法可以进行设置呢?其实winxp系统wifi热点的操作方法，我们只需要打开“移动热点”窗口。选择“开始”按钮，然后依次选择“设置”-“网络和 internet”-“移动热点”。选择想要共享的连接。在“从以下位置共享我的 internet 连接”的下列列表中，选择你想要共享的 internet 连接。;就可以解决了，针对此问题小编给大家收集整理winxp系统wifi热点具体的操作方法：

方法1:使用"设置"创建windows 10 wiFi热点

1：概述。如果您对计算机不太了解，这样一个简单的方法可以让您在windows 10中创建一个wiFi热点。只要windows的“设置”中一个开关就能将笔记本电脑或带wiFi的台式电脑转变为热点。

2：打开“移动热点”窗口。选择“开始”按钮，然后依次选择“设置”-“网络和 internet”-“移动热点”。

winxp系统wifi热点的详细办法

winxp系统wifi热点的详细办法

3：选择想要共享的连接。在“从以下位置共享我的 internet 连接”的下列列表中，选择你想要共享的 internet 连接。

winxp系统wifi热点的详细办法

4：输入网络名称和密码。选择 “编辑”，输入新的网络名称和密码，然后选择“保存”。

winxp系统wifi热点的详细办法

5：打开开关。将“与其他设备共享我的 internet 连接”的开关设置为开。

winxp系统wifi热点的详细办法

6：在其他设备上连接创建的这个热点。若要在其他设备上进行连接，请转到该设备的无线局域网中设置、查找并选择网络名称、输入密码，然后进行连接。 方法2：使用命令行创建windows 10 wiFi热点

1：概述。通过在命令提示符中键入几个命令行，这将启动“承载网络”功能，并允许您在windows 10中创建虚拟wiFi。提示：如果方法1不能成功创建热点，请用此方法。以下是它的操作步骤。

2：确保您的电脑支持此功能。

(1)使用快捷键win+x启动跳转列表，并选择命令提示符(管理员)。

(2)在命令提示符对话框中输入netsh wlan show drivers，然后按Enter(回车)。

(3)看看在屏幕上是否显示“支持的承载网络：是”。如果是这样，请继续看下面，并在windows 10中创建wiFi热点。

winxp系统wifi热点的详细办法

3：创建热点。键入命令：netsh wlan set hostednetwork mode = allow ssid =网络名称 key=网络密码，然后按Enter(回车)。注意：您可以在ssid之后命名您的wiFi，并将密码设置为至少8个字符作为密钥。

winxp系统wifi热点的详细办法

4：激活热点。键入命令netsh wlan start hostednetwork来激活它。当您看到屏幕显示“已启动承载网络”时，您就已经在windows 10中成功创建了wiFi热点。下面的步骤将共享wiFi热点给您的无线设备。

winxp系统wifi热点的详细办法

5：打开“网络连接”窗口。使用快捷键win+x启动跳转列表，选择“网络连接”，然后选择“更改适配器选项”。注意：在网络连接中，您可以看到“本地连接*+数字”，这是创建承载网络后出现的虚拟wiFi适配器。

winxp系统wifi热点的详细办法

6：打开网络适配器“属性”窗口。右键单击当前正在工作的网络适配器(以太网或wiFi)，然后选择“属性”。

winxp系统wifi热点的详细办法

7：共享连接。选择“共享”选项卡，并启用“允许其他网络用户通过此计算机的internet连接来连接”。 从家庭网络连接的下拉菜单中选择“本地连接*+数字”。单击确定。

winxp系统wifi热点的详细办法

8：完成。现在您就可以使用创建的热点上网了。

Android 连接Wifi和创建Wifi热点的实例

Android 连接Wifi和创建Wifi热点的实例

本文实例讲述了连接Wifi和创建Wifi热点的方法。分享给大家供大家参考，具体如下：

android的热点功能不可见，用了反射的技术搞定之外。 

Eclipse设置语言为utf-8才能查看中文注释

上代码：

MainActivity.java

package com.widget.hotspot; 
import android.os.Bundle; 
import android.app.Activity; 
import android.content.broadcastReceiver; 
import android.content.Context; 
import android.content.Intent; 
import android.content.IntentFilter; 
import android.util.Log; 
import android.view.Menu; 
import android.view.View; 
import android.widget.Button; 
 
public class MainActivity extends Activity { 
 
  public static final String TAG = "MainActivity"; 
   
  private Button mBtn1,mBtn2; 
   
  private WifiAdmin mWifiAdmin; 
   
  private Context mContext = null; 
  @Override 
  protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
     
    mContext = this; 
     
    setContentView(R.layout.activity_main); 
     
    mBtn1 = (Button)findViewById(R.id.button1); 
    mBtn2 = (Button)findViewById(R.id.button2); 
    mBtn1.setText("点击连接Wifi"); 
    mBtn2.setText("点击创建Wifi热点"); 
    mBtn1.setonClickListener(new Button.OnClickListener() { 
       
      @Override 
      public void onClick(View v) { 
        // Todo Auto-generated method stub 
 
        mWifiAdmin = new WifiAdmin(mContext) { 
           
          @Override 
          public void myUnregisterReceiver(broadcastReceiver receiver) { 
            // Todo Auto-generated method stub 
            MainActivity.this.unregisterReceiver(receiver); 
          } 
           
          @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

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,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

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",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

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; 
  } 
   
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持编程小技巧。

android-使用“ setWifiApEnabled”启用wifi热点时无法设置“ WifiConfiguration”

android-使用“ setWifiApEnabled”启用wifi热点时无法设置“ WifiConfiguration”

我正在尝试使用之前在这里看到的代码将Android设备设置为访问点：

WifiManager wifi = (WifiManager) getSystemService(Context.WIFI_SERVICE);

WifiConfiguration netConfig = new WifiConfiguration();
netConfig.SSID = "MyAccesspoint";

Method method = wifi.getClass().getmethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);
method.invoke(wifi, netConfig, true);

现在,我设法将其打开,但没有在WifiConfiguration中设置的SSID.

这真让我抓狂.

任何人？

解决方法:

看看我是如何在Android 2.3 wifi hotspot API上工作的.

APwifi（破解版）共享无线WIFI热点的使用方法

APwifi（破解版）共享无线WIFI热点的使用方法

本文将分享APwifi在XP与Win7之间共享无线网络的设置。

相关推荐：APwifi破解版免费下载

以前用APwifi总是连上了无线却不能上网，偶尔运气好可以上网，真是汗颜，以为无线软路由共享WIFI不好弄，很头疼。

直到今晚想起了某些细节，修改过后立马可以用了。

如果使用APwifi共享的WIFI连接后却不能上网，去电脑的TCP/IP筛选设置看下，是否全部选择为“全部允许”，默认好像就是这样的。如果不是请设置成全部允许。

本文将分享使用APwifi破解版在XP与win7之间共享无线WIFI的实战经验。

经过多次调试，XP给XP共享，XP给Win7共享，Win7给XP共享都是一个道理。

步骤如下：

1、共享的主机[发射端]如果是通过宽带连接，给本地连接手动分配IP
IP地址：192.168.x.1（x可以是2-255之间任何数字，只要不是0或者1）
子网掩码：255.255.255.0

如果是直接连接不用拨号可以或略这一步。

2、在共享的主机开启APwifi设置好账号信息（建议加密方式选择WEP，模式选择当前的系统，勾选“自动唤醒”，无线网卡就选择你的无线网卡，互联网连接如果是不用拨号就选本地连接，如果是宽带就选择“宽带连接”~）点击开启。

3、共享Wifi后，在另一台电脑[接收端]找到你共享的无线网络，输入WEP密码连接，等一小会自动分配IP后，应该就能上网了~

使用APwifi可以忽略的步骤：


免去手动在宽带链接或本地连接给无线网卡共享权限的步骤。

接收的电脑设置成自动获取IP就好了，只需打开APwifi点击开启即可（通过DHCP自动分配IP）共享上网。

如果不能上网请看


在使用Win7做主机的时候，另一台电脑连接上了无线却不能上网， 在“网络共享中心”查看完整映射，无线网卡提示，当前是公用网络，要改成家庭或工作网络，于是我把无线网卡改成了“工作网络”，接收WIFI的电脑就能上网了。

再改回去改成“公用网络”重新连接WIFI，还能上网，具体原因未知。

原文出自：使用APwifi共享无线WIFI热点实战经验

Mac怎么设置wifi热点，Mac做wifi热点

Mac怎么设置wifi热点，Mac做wifi热点

Mac怎么设置wifi热点，Mac做wifi热点

听语音

  •  
  • |
  • 浏览：52226
  • |
  • 更新：2015-01-09 22:55
  • |
  • 标签：wifi 

  • Mac怎么设置wifi热点，Mac做wifi热点1

  • Mac怎么设置wifi热点，Mac做wifi热点2

  • Mac怎么设置wifi热点，Mac做wifi热点3

  • Mac怎么设置wifi热点，Mac做wifi热点4

  • Mac怎么设置wifi热点，Mac做wifi热点5

  • Mac怎么设置wifi热点，Mac做wifi热点6

  • Mac怎么设置wifi热点，Mac做wifi热点7

分步阅读

一键约师傅

百度师傅高质屏和好师傅，屏碎肾不疼

苹果 Mac 系统中要把无线当作 Wifi 热点来用的话，需要电脑有其它网络接入才可以，也就是说它需要一个可以用于上网的网络，比如有线网络。尤其是对于使用 MacBook Pro 或 MacBook Air 的小伙伴，有时候出门在外时需要为手机共享无线 Wifi 网络。这里简单介绍下怎么在 Mac 下设置 Wifi 热点的操作方法。

Mac怎么设置wifi热点，Mac做wifi热点

工具/原料

  • Mac 电脑

方法/步骤

  1. 1

    由于我用的 MacBook Pro 只有一个无线网络接口，所在我需要在电脑上加装一个外接网线的网卡，如图所示

    Mac怎么设置wifi热点，Mac做wifi热点

  2. 2

    我接下来做的便是把这根有线网络用 Mac 电脑上的无线 Wifi 把它共享给其它设备使用。接着请点击打开“系统偏好设置”应用，如图所示

    Mac怎么设置wifi热点，Mac做wifi热点

  3. 3

    随后请在系统偏好设置窗口中点击打开“共享”功能，如图所示

    Mac怎么设置wifi热点，Mac做wifi热点

  4. 4

    接下来在共享窗口中，点击左侧列表中的“互联网共享”选项，如图所示

    Mac怎么设置wifi热点，Mac做wifi热点

  5. 5

    随后请点击共享以下来源的连接的下拉列表，选择我们想要共享出去的网络接口。我当前是想要共享的是 Thunderbolt 以太网有线网，如图所示

    注：如果你的Mac是用有线拨号上网的话，请选择PPOE作为共享源。

    Mac怎么设置wifi热点，Mac做wifi热点

  6. 接着在用以下端口共享给电脑的列表中，请选择 Wi-Fi 选项，如图所示

    Mac怎么设置wifi热点，Mac做wifi热点

  7. 用于共享的网络接口选择好之后，接下来请点击右下方的“Wi-Fi选项”按钮。

    Mac怎么设置wifi热点，Mac做wifi热点

  8. 随后在这里可以配置无线网络的安全设置：

    网络名称：即是无线网络的名字；

    频段：请保持默认就好；

    安全性：请设置 WPA2 个人级；

    密码：设置一个8位字符的密码；

     

    Mac怎么设置wifi热点，Mac做wifi热点

  9. 接下来请在共享窗口中点击左侧的“互联网共享”选项，再点击“启动”按钮，如图所示

    Mac怎么设置wifi热点，Mac做wifi热点

  10. 随后在共享窗口中可以看到当前的绿灯已经亮起，说明无线 Wi-Fi 已经设置生效。

    Mac怎么设置wifi热点，Mac做wifi热点

  11. 此时可以在屏幕顶部的菜单栏中看到原来的无线图标已经变样了，点击之后可以看到当前无线wifi热点的信息。

    Mac怎么设置wifi热点，Mac做wifi热点

  12. 接下来我们用其它设备来尝试用 Mac 共享的 Wifi 热点，这里以 iPhone 为例，在无线列表中可以看到 Mac 设置的无线热点，那个以大写 B 开头的无线就是。

    Mac怎么设置wifi热点，Mac做wifi热点

  13. 点击此无线，输入之前我们在 Mac 设置无线热点时的密码，进行连接。

    Mac怎么设置wifi热点，Mac做wifi热点

  14. 此时已经显示与 Mac 上的无线wifi热点连接成功，如图所示

    Mac怎么设置wifi热点，Mac做wifi热点

  15. 随后我们在 iPhone 上的 Safari 浏览器打开一个网页，可以正常打开，说明此时 Mac 上的无线wifi热点工作正常。

    Mac怎么设置wifi热点，Mac做wifi热点步骤阅读

今天关于怎样开启热点wifi|wifi热点的详细设置(图文)和怎么开启热点wifi的介绍到此结束，谢谢您的阅读，有关Android 连接Wifi和创建Wifi热点的实例、android-使用“ setWifiApEnabled”启用wifi热点时无法设置“ WifiConfiguration”、APwifi（破解版）共享无线WIFI热点的使用方法、Mac怎么设置wifi热点，Mac做wifi热点等更多相关知识的信息可以在本站进行查询。

本文标签：

上一篇怎么蹭网wifi?不知道密码怎么蹭网（怎么蹭网wifi?不知道密码怎么蹭网呢）

下一篇修改wifi密码|怎样修改wifi密码（修改wifi密码怎么改?）

相关文章