it-swarm.com.de

Android schaltet WiFi HotSpot programmgesteuert ein/aus

Gibt es eine API, um den WiFi-HotSpot unter Android programmgesteuert ein- oder auszuschalten?

Welche Methoden sollte ich aufrufen, um sie ein- oder auszuschalten?

AKTUALISIEREN:Es gibt diese Option, um den HotSpot zu aktivieren und das WLAN ein- oder auszuschalten. Dies ist jedoch keine gute Lösung für mich.

49
mxg

Verwenden Sie die nachstehende Klasse, um die Einstellung Wifi hotspot zu ändern/überprüfen:

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

Sie müssen die folgenden Berechtigungen zu Ihrem AndroidMainfest hinzufügen:

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

Verwenden Sie diese eigenständige ApManager-Klasse von überall aus wie folgt:

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

Hoffe das hilft jemandem

48
Ashish Sahu

Es gibt keine Methoden im Android SDK, die sich auf die WLAN-Hotspot-Funktion beziehen - sorry!

9
CommonsWare

Mit dem folgenden Code können Sie den WLAN-Direktstatus programmgesteuert aktivieren, deaktivieren und abfragen.

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

Für Android 8.0 gibt es eine neue API zur Handhabung von Hotspots. Soweit ich weiß, funktioniert der alte Weg mit Reflektion nicht mehr . Bitte beachten Sie:

Android Developers https://developer.Android.com/reference/Android/net/wifi/WifiManager.html#startLocalOnlyHotspot(Android.net.wifi.WifiManager.LocalOnlyHotspotCallback%20Android.os.Handler)

void startLocalOnlyHotspot (WifiManager.LocalOnlyHotspotCallback callback, 
                Handler handler)

Fordern Sie einen lokalen Hotspot an, mit dem eine Anwendung zwischen Geräten kommunizieren kann, die mit dem erstellten WLAN-Hotspot verbunden sind. Das mit dieser Methode erstellte Netzwerk hat keinen Internetzugang.

Paketüberfluss
Wifi-Hotspot unter Android 8.0 (Oreo) programmgesteuert ein ausschalten - /

die Methode onStarted (WifiManager.LocalOnlyHotspotReservation reservation) wird aufgerufen, wenn Hotspot aktiviert ist. Mit der WifiManager.LocalOnlyHotspotReservation-Referenz rufen Sie die close () -Methode auf, um die Hotspot zu deaktivieren.

2
Sócrates Costa

Am besten schauen Sie sich die WifiManager-Klasse an. Speziell die Funktion setWifiEnabled(bool).

Siehe die Dokumentation unter: http://developer.Android.com/reference/Android/net/wifi/WifiManager.html#setWifiEnabled(boolean)

Eine Anleitung zur Verwendung (einschließlich der erforderlichen Berechtigungen) finden Sie hier: http://www.tutorialforandroid.com/2009/10/turn-off-turn-on-wifi-in- Android-using.html

2
joshhendo

Gilt nur für Oreo + ...

Ich habe eine App mit Code hier auf GitHub - erstellt, die Reflection und DexMaker verwendet, um Oreos Tethering-Funktionalität zu erhalten, die sich jetzt in ConnectionManager befindet, anstatt WifiManager

Das Zeug in WifiManager ist nur für ein geschlossenes WLAN-Netzwerk geeignet (was das Closed-Bit in den Klassennamen erklärte!).

Weitere Erklärung https://stackoverflow.com/a/49356255/772333

1
Jon

Das funktioniert gut für mich:

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

Ich habe inoffizielle APIs für dasselbe veröffentlicht, es enthält mehr als nur Hotspot on/off. Verknüpfung

Für APIs DOC - link .

1

Hier ist die vollständige Lösung, wenn Sie die WLAN-Hotspot-Funktion programmgesteuert in Ihrer App Android implementieren möchten.

LÖSUNG FÜR API <26:

Für Geräte <API 26. Für diesen Zweck gibt es keine öffentliche API von Android. Um mit diesen APIs arbeiten zu können, müssen Sie über Reflection auf private APIs zugreifen. Es wird nicht empfohlen, aber wenn Sie keine anderen Optionen mehr haben, ist hier ein Trick.

Zunächst müssen Sie diese Erlaubnis in Ihrem Manifest haben,

  <uses-permission  
  Android:name="Android.permission.WRITE_SETTINGS"  
  tools:ignore="ProtectedPermissions"/>

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

So können Sie es zur Laufzeit abfragen:

 private boolean showWritePermissionSettings() {    
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M  
    && Build.VERSION.SDK_INT < Build.VERSION_CODES.O) { 
  if (!Settings.System.canWrite(this)) {    
    Log.v("DANG", " " + !Settings.System.canWrite(this));   
    Intent intent = new Intent(Android.provider.Settings.ACTION_MANAGE_WRITE_SETTINGS); 
    intent.setData(Uri.parse("package:" + this.getPackageName()));  
    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
    this.startActivity(intent); 
    return false;   
  } 
}   
return true; //Permission already given 
}

Sie können dann durch Reflektion auf die Methode setWifiEnabled zugreifen. Dies gibt true zurück, wenn die angeforderte Aktion korrekt ausgeführt wird, d. H. Hotspot aktivieren/deaktivieren.

     public boolean setWifiEnabled(WifiConfiguration wifiConfig, boolean enabled) { 
 WifiManager wifiManager;
try {   
  if (enabled) { //disables wifi hotspot if it's already enabled    
    wifiManager.setWifiEnabled(false);  
  } 

   Method method = wifiManager.getClass()   
      .getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);   
  return (Boolean) method.invoke(wifiManager, wifiConfig, enabled); 
} catch (Exception e) { 
  Log.e(this.getClass().toString(), "", e); 
  return false; 
}   
}

Sie können die Konfiguration Ihres Hotspots auch durch Reflektion ermitteln. Ich habe beantwortet diese Methode für diese Frage auf StackOverflow.

P.S: Wenn Sie den Hotspot nicht programmgesteuert aktivieren möchten, können Sie dies starten Absicht und den Bildschirm mit den WLAN-Einstellungen öffnen, damit der Benutzer ihn manuell einschalten kann.

LÖSUNG FÜR API> = 26:

Schließlich veröffentlichte Android eine offizielle API für Versionen> = Oreo. Sie können einfach die öffentlich zugängliche API von Android verwenden, d. H. startLocalOnlyHotspot

Es wird ein lokaler Hotspot ohne Internetzugang aktiviert. Mit denen kann man also einen Server hosten oder Dateien übertragen.

Es erfordert die Berechtigungen Manifest.permission.CHANGE_WIFI_STATE Und ACCESS_FINE_LOCATION.

Hier ist ein einfaches Beispiel, wie Sie Hotspot mit dieser API aktivieren können.

private WifiManager wifiManager;
WifiConfiguration currentConfig;
WifiManager.LocalOnlyHotspotReservation hotspotReservation;

Die Methode zum Aktivieren des Hotspots:

@RequiresApi(api = Build.VERSION_CODES.O)
public void turnOnHotspot() {

      wifiManager.startLocalOnlyHotspot(new WifiManager.LocalOnlyHotspotCallback() {

        @Override
        public void onStarted(WifiManager.LocalOnlyHotspotReservation reservation) {
          super.onStarted(reservation);
          hotspotReservation = reservation;
          currentConfig = hotspotReservation.getWifiConfiguration();

          Log.v("DANG", "THE PASSWORD IS: "
              + currentConfig.preSharedKey
              + " \n SSID is : "
              + currentConfig.SSID);

          hotspotDetailsDialog();

        }

        @Override
        public void onStopped() {
          super.onStopped();
          Log.v("DANG", "Local Hotspot Stopped");
        }

        @Override
        public void onFailed(int reason) {
          super.onFailed(reason);
          Log.v("DANG", "Local Hotspot failed to start");
        }
      }, new Handler());
    }
`

So erhalten Sie Details zum lokal erstellten Hotspot

private void hotspotDetaisDialog()
{

    Log.v(TAG, context.getString(R.string.hotspot_details_message) + "\n" + context.getString(
              R.string.hotspot_ssid_label) + " " + currentConfig.SSID + "\n" + context.getString(
              R.string.hotspot_pass_label) + " " + currentConfig.preSharedKey);

}

Wenn eine Sicherheitsausnahme ausgelöst wird, obwohl Sie die erforderlichen Berechtigungen erteilt haben, sollten Sie versuchen, Ihren Standort mithilfe von GPS zu aktivieren. Hier ist die Lösung .

Vor kurzem habe ich eine Demo-App namens Spotserve entwickelt. Damit wird der WLAN-Hotspot für alle Geräte mit API> = 15 aktiviert und ein Demo-Server auf diesem Hotspot gehostet. Sie können dies für weitere Details überprüfen. Hoffe das hilft!

0
Adeel Zafar

** Für Oreo & PIE ** fand ich unten durch diese

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

UseAge

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

Wir können programmgesteuert ein- und ausschalten

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

Verwenden Sie die Callback-Klasse, um Hotspot in pie (9.0) programmgesteuert zu aktivieren. Sie müssen programmgesteuert deaktivieren und den Schalter einschalten.

0
akshay

Sie können die Konsole und den Dienst für diese Option verwenden.

Ich denke damit kannst du das lösen. Ich habe einen Test direkt in der Konsole durchgeführt und Hotspot aktiviert

Ich fand dies in diesem Artikel Ist es möglich, ein Android Gerät mit ADB über das Terminal zu verbinden?

Und nachdem wir die Schnittstelle gelesen haben, können wir die gleichen 24 verwenden, benötigen aber mehr Parameter

service call connectivity 24 i32 0 i32 1 i32 0 s16 zufällig

0
Eduardo Rotundo