web-dev-qa-db-fra.com

Android activer/désactiver WiFi HotSpot par programme

Existe-t-il une API pour activer/désactiver le HotSpot WiFi sous Android par programmation?

Quelles méthodes dois-je appeler pour l'activer/le désactiver?

METTRE À JOUR:Il y a cette option pour activer le HotSpot, et simplement activer/désactiver le WiFi, mais ce n'est pas une bonne solution pour moi.

49
mxg

Utilisez la classe ci-dessous pour modifier/vérifier le paramètre Wifi hotspot:

import Android.content.*;
import Android.net.wifi.*;
import Java.lang.reflect.*;

public class ApManager {

//check whether wifi hotspot on or off
public static boolean isApOn(Context context) {
    WifiManager wifimanager = (WifiManager) context.getSystemService(context.WIFI_SERVICE);     
    try {
        Method method = wifimanager.getClass().getDeclaredMethod("isWifiApEnabled");
        method.setAccessible(true);
        return (Boolean) method.invoke(wifimanager);
    }
    catch (Throwable ignored) {}
    return false;
}

// toggle wifi hotspot on or off
public static boolean configApState(Context context) {
    WifiManager wifimanager = (WifiManager) context.getSystemService(context.WIFI_SERVICE);
    WifiConfiguration wificonfiguration = null;
    try {  
        // if WiFi is on, turn it off
        if(isApOn(context)) {               
            wifimanager.setWifiEnabled(false);
        }               
        Method method = wifimanager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);                   
        method.invoke(wifimanager, wificonfiguration, !isApOn(context));
        return true;
    } 
    catch (Exception e) {
        e.printStackTrace();
    }       
    return false;
}
} // end of class

Vous devez ajouter les autorisations ci-dessous à votre AndroidMainfest:

<uses-permission Android:name="Android.permission.CHANGE_NETWORK_STATE" />
<uses-permission Android:name="Android.permission.CHANGE_WIFI_STATE" />
<uses-permission Android:name="Android.permission.ACCESS_WIFI_STATE" />

Utilisez cette classe ApManager autonome à partir de n'importe où, comme suit:

ApManager.isApOn(YourActivity.this); // check Ap state :boolean
ApManager.configApState(YourActivity.this); // change Ap state :boolean

J'espère que cela aidera quelqu'un

48
Ashish Sahu

Le SDK Android ne contient aucune méthode relative à la fonctionnalité de point d'accès WiFi - désolé!

9
CommonsWare

Vous pouvez utiliser le code suivant pour activer, désactiver et interroger par programme l'état direct wifi.

package com.kusmezer.androidhelper.networking;

import Java.lang.reflect.Method;
import com.google.common.base.Preconditions;
import Android.content.Context;
import Android.net.wifi.WifiConfiguration;
import Android.net.wifi.WifiManager;
import Android.util.Log;

public final class WifiApManager {
      private static final int WIFI_AP_STATE_FAILED = 4;
      private final WifiManager mWifiManager;
      private final String TAG = "Wifi Access Manager";
      private Method wifiControlMethod;
      private Method wifiApConfigurationMethod;
      private Method wifiApState;

      public WifiApManager(Context context) throws SecurityException, NoSuchMethodException {
       context = Preconditions.checkNotNull(context);
       mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
       wifiControlMethod = mWifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class,boolean.class);
       wifiApConfigurationMethod = mWifiManager.getClass().getMethod("getWifiApConfiguration",null);
       wifiApState = mWifiManager.getClass().getMethod("getWifiApState");
      }   
      public boolean setWifiApState(WifiConfiguration config, boolean enabled) {
       config = Preconditions.checkNotNull(config);
       try {
        if (enabled) {
            mWifiManager.setWifiEnabled(!enabled);
        }
        return (Boolean) wifiControlMethod.invoke(mWifiManager, config, enabled);
       } catch (Exception e) {
        Log.e(TAG, "", e);
        return false;
       }
      }
      public WifiConfiguration getWifiApConfiguration()
      {
          try{
              return (WifiConfiguration)wifiApConfigurationMethod.invoke(mWifiManager, null);
          }
          catch(Exception e)
          {
              return null;
          }
      }
      public int getWifiApState() {
       try {
            return (Integer)wifiApState.invoke(mWifiManager);
       } catch (Exception e) {
        Log.e(TAG, "", e);
            return WIFI_AP_STATE_FAILED;
       }
      }
}
4
Kerem Kusmezer

Pour Android 8.0, il existe une nouvelle API permettant de gérer les hotspots. Autant que je sache, l'ancienne méthode utilisant la réflexion ne fonctionne plus . Veuillez vous référer à:

Développeurs Android https://developer.Android.com/reference/Android/net/wifi/WifiManager.html#startLocalOnlyHotspot(Android.net.wifi.WifiManager.LocalOnlyHotspotCallback,%20Android.Handler)

void startLocalOnlyHotspot (WifiManager.LocalOnlyHotspotCallback callback, 
                Handler handler)

Demandez un point d'accès local uniquement qu'une application peut utiliser pour communiquer entre des périphériques colocalisés connectés au point d'accès WiFi créé. Le réseau créé par cette méthode n'aura pas d'accès Internet.

Débordement de pile
Comment activer/désactiver le point d'accès wifi par programme dans Android 8.0 (Oreo)

la méthode onStarted (réservation WifiManager.LocalOnlyHotspotReservation) sera appelée si le hotspot est activé .. Utilisez la référence WifiManager.LocalOnlyHotspotReservation que vous appelez la méthode close () pour désactiver le hotspot.

2
Sócrates Costa

Votre meilleur pari sera de regarder la classe WifiManager. Plus précisément, la fonction setWifiEnabled(bool).

Voir la documentation à l'adresse suivante: http://developer.Android.com/reference/Android/net/wifi/WifiManager.html#setWifiEnabled(boolean)

Vous trouverez un didacticiel sur son utilisation (avec les autorisations dont vous avez besoin) à l'adresse suivante: http://www.tutorialforandroid.com/2009/10/turn-off-turn-on-wifi-in- Android-using.html

2
joshhendo

S'applique à Oreo + uniquement ...

J'ai créé une application avec le code ici sur GitHub qui utilise la réflexion et DexMaker pour "accéder à" la fonctionnalité d'attache de Oreo, qui est maintenant dans ConnectionManager, plutôt que WifiManager

Le contenu de WifiManager n'est utile que pour un réseau wifi fermé (ce qui explique le bit Closed dans les noms de classe!).

Plus d'explications https://stackoverflow.com/a/49356255/772333

1
Jon

Cela fonctionne bien pour moi:

WifiConfiguration apConfig = null;
Method method = wifimanager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, Boolean.TYPE);
method.invoke(wifimanager, apConfig, true);
1
Carlyle_Lee

J'ai publié des API non officielles pour la même chose, elle contient plus que le point chaud on/off. lien

Pour les API DOC - link .

1
mahendrakumar patel

** Pour Oreo & PIE ** j'ai trouvé ci-dessous chemin à travers ceci

private WifiManager.LocalOnlyHotspotReservation mReservation;
private boolean isHotspotEnabled = false;
private final int REQUEST_ENABLE_LOCATION_SYSTEM_SETTINGS = 101;

private boolean isLocationPermissionEnable() {
    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
        ActivityCompat.requestPermissions(this, new String[] {Manifest.permission.ACCESS_COARSE_LOCATION}, 2);
        return false;
    }
    return true;
}

@RequiresApi(api = Build.VERSION_CODES.O)
private void turnOnHotspot() {
    if (!isLocationPermissionEnable()) {
        return;
    }
    WifiManager manager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);

    if (manager != null) {
        // Don't start when it started (existed)
        manager.startLocalOnlyHotspot(new WifiManager.LocalOnlyHotspotCallback() {

            @Override
            public void onStarted(WifiManager.LocalOnlyHotspotReservation reservation) {
                super.onStarted(reservation);
                //Log.d(TAG, "Wifi Hotspot is on now");
                mReservation = reservation;
                isHotspotEnabled = true;
            }

            @Override
            public void onStopped() {
                super.onStopped();
                //Log.d(TAG, "onStopped: ");
                isHotspotEnabled = false;
            }

            @Override
            public void onFailed(int reason) {
                super.onFailed(reason);
                //Log.d(TAG, "onFailed: ");
                isHotspotEnabled = false;
            }
        }, new Handler());
    }
}

@RequiresApi(api = Build.VERSION_CODES.O)
private void turnOffHotspot() {
    if (!isLocationPermissionEnable()) {
        return;
    }
    if (mReservation != null) {
        mReservation.close();
        isHotspotEnabled = false;
    }
}

@RequiresApi(api = Build.VERSION_CODES.O)
private void toggleHotspot() {
    if (!isHotspotEnabled) {
        turnOnHotspot();
    } else {
        turnOffHotspot();
    }
}

@RequiresApi(api = Build.VERSION_CODES.O)
private void enableLocationSettings() {
    LocationRequest mLocationRequest = new LocationRequest();
    /*mLocationRequest.setInterval(10);
    mLocationRequest.setSmallestDisplacement(10);
    mLocationRequest.setFastestInterval(10);
    mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);*/
    LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder();
    builder.addLocationRequest(mLocationRequest)
            .setAlwaysShow(false); // Show dialog

    Task<LocationSettingsResponse> task= LocationServices.getSettingsClient(this).checkLocationSettings(builder.build());

    task.addOnCompleteListener(task1 -> {
        try {
            LocationSettingsResponse response = task1.getResult(ApiException.class);
            // All location settings are satisfied. The client can initialize location
            // requests here.
            toggleHotspot();

        } catch (ApiException exception) {
            switch (exception.getStatusCode()) {
                case LocationSettingsStatusCodes.RESOLUTION_REQUIRED:
                    // Location settings are not satisfied. But could be fixed by showing the
                    // user a dialog.
                    try {
                        // Cast to a resolvable exception.
                        ResolvableApiException resolvable = (ResolvableApiException) exception;
                        // Show the dialog by calling startResolutionForResult(),
                        // and check the result in onActivityResult().
                        resolvable.startResolutionForResult(HotspotActivity.this, REQUEST_ENABLE_LOCATION_SYSTEM_SETTINGS);
                    } catch (IntentSender.SendIntentException e) {
                        // Ignore the error.
                    } catch (ClassCastException e) {
                        // Ignore, should be an impossible error.
                    }
                    break;
                case LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE:
                    // Location settings are not satisfied. However, we have no way to fix the
                    // settings so we won't show the dialog.
                    break;
            }
        }
    });
}

@RequiresApi(api = Build.VERSION_CODES.O)
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    final LocationSettingsStates states = LocationSettingsStates.fromIntent(data);
    switch (requestCode) {
        case REQUEST_ENABLE_LOCATION_SYSTEM_SETTINGS:
            switch (resultCode) {
                case Activity.RESULT_OK:
                    // All required changes were successfully made
                    toggleHotspot();
                    Toast.makeText(HotspotActivity.this,states.isLocationPresent()+"",Toast.LENGTH_SHORT).show();
                    break;
                case Activity.RESULT_CANCELED:
                    // The user was asked to change settings, but chose not to
                    Toast.makeText(HotspotActivity.this,"Canceled",Toast.LENGTH_SHORT).show();
                    break;
                default:
                    break;
            }
            break;
    }
}

Utilisation

btnHotspot.setOnClickListenr(view -> {
   if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        // Step 1: Enable the location settings use Google Location Service
        // Step 2: https://stackoverflow.com/questions/29801368/how-to-show-enable-location-dialog-like-google-maps/50796199#50796199
        // Step 3: If OK then check the location permission and enable hotspot
        // Step 4: https://stackoverflow.com/questions/46843271/how-to-turn-off-wifi-hotspot-programmatically-in-Android-8-0-oreo-setwifiapen
        enableLocationSettings();
        return;
    }
}

<uses-permission Android:name="Android.permission.ACCESS_COARSE_LOCATION" />

implementation 'com.google.Android.gms:play-services-location:15.0.1'
0
Xar E Ahmer

Nous pouvons activer et désactiver par programmation

setWifiApDisable.invoke(connectivityManager, TETHERING_WIFI);//Have to disable to enable
setwifiApEnabled.invoke(connectivityManager, TETHERING_WIFI, false, mSystemCallback,null);

À l'aide de la classe de rappel, pour activer par programme le point d'accès dans la tarte (9.0), vous devez désactiver et activer le programme.

0
akshay