Este artigo demontsra como configurar e gerenciar um hotspot Wi-Fi em dispositivos Android usando código, além de como conectar-se a redes Wi-Fi existentes.

Criação de Hotspot Wi-Fi

O código a seguir permite criar um ponto de acesso Wi-Fi programaticamenet. É importante notar que a funcionalidade de hotspot e a conexão Wi-Fi padrão não podem estar ativas simultaneamente. Portanto, ao habilitar o hotspot, o Wi-Fi será desativado.

package com.example.android.hotspotmanager;

import android.app.Activity;
import android.content.Context;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import java.lang.reflect.Method;

public class HotspotActivity extends Activity {

    private WifiManager wifiManager;
    private Button toggleHotspotButton;
    private boolean isHotspotEnabled = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_hotspot); // Certifique-se que R.layout.activity_hotspot existe

        wifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);
        toggleHotspotButton = findViewById(R.id.button_toggle_hotspot); // Certifique-se que R.id.button_toggle_hotspot existe

        toggleHotspotButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                isHotspotEnabled = !isHotspotEnabled;
                if (setWifiApEnabled(isHotspotEnabled)) {
                    Toast.makeText(HotspotActivity.this, isHotspotEnabled ? "Hotspot ativado" : "Hotspot desativado", Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(HotspotActivity.this, "Falha ao " + (isHotspotEnabled ? "ativar" : "desativar") + " o hotspot", Toast.LENGTH_SHORT).show();
                }
            }
        });
    }

    /**
     * Habilita ou desabilita o hotspot Wi-Fi.
     * @param enabled true para habilitar, false para desabilitar.
     * @return true se a operação foi bem-sucedida, false caso contrário.
     */
    public boolean setWifiApEnabled(boolean enabled) {
        // Se estiver habilitando o hotspot, desabilita o Wi-Fi primeiro.
        if (enabled) {
            if (wifiManager.isWifiEnabled()) {
                wifiManager.setWifiEnabled(false);
            }
        }

        try {
            // Configuração do hotspot
            WifiConfiguration apConfig = new WifiConfiguration();
            apConfig.SSID = "\"MeuHotspot\""; // Nome da rede
            apConfig.preSharedKey = "\"senha123\""; // Senha do hotspot
            apConfig.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
            apConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            apConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            apConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
            apConfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
            apConfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
            apConfig.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
            apConfig.hiddenSSID = false; // Pode ser definido como true se desejar ocultar o SSID

            // Utiliza reflexão para chamar o método setWifiApEnabled, que não é público.
            Method method = wifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);
            boolean success = (Boolean) method.invoke(wifiManager, apConfig, enabled);
            return success;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
}

Conexão a Redes Wi-Fi

O processo de conexão a uma rede Wi-Fi envolve a busca por redes disponíveis, a verfiicação se a rede atende aos critérios desejados e, em seguida, o estabelecimento da conexão.

package com.example.android.wificonnector;

import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import java.util.ArrayList;
import java.util.List;

public class WifiScanActivity extends Activity {

    private List<scanresult> scanResults;
    private WifiManager wifiManager;
    private List<string> matchingNetworksSsid;
    private WifiScanReceiver wifiScanReceiver;
    private boolean isConnected = false;
    private Button scanButton;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_wifi_scan); // Certifique-se que R.layout.activity_wifi_scan existe

        initUI();
    }

    private void initUI() {
        scanButton = findViewById(R.id.button_scan_wifi); // Certifique-se que R.id.button_scan_wifi existe
        wifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);
        wifiScanReceiver = new WifiScanReceiver();

        scanButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (wifiManager.isWifiEnabled()) {
                    wifiManager.startScan();
                    Toast.makeText(WifiScanActivity.this, "Iniciando varredura...", Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(WifiScanActivity.this, "Wi-Fi está desativado.", Toast.LENGTH_SHORT).show();
                }
            }
        });
    }

    @Override
    protected void onResume() {
        super.onResume();
        IntentFilter intentFilter = new IntentFilter(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
        registerReceiver(wifiScanReceiver, intentFilter);
    }

    @Override
    protected void onPause() {
        super.onPause();
        unregisterReceiver(wifiScanReceiver);
    }

    private class WifiScanReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            scanResults = wifiManager.getScanResults();
            if (scanResults == null || scanResults.isEmpty() || isConnected) {
                return;
            }
            processScanResults(scanResults);
        }
    }

    private void processScanResults(List<scanresult> results) {
        matchingNetworksSsid = new ArrayList<>();
        for (ScanResult result : results) {
            System.out.println("Rede encontrada: " + result.SSID);
            // Filtra redes que contêm "MeuHotspot" no nome (SSID)
            if (result.SSID != null && result.SSID.contains("MeuHotspot")) {
                matchingNetworksSsid.add(result.SSID);
            }
        }
        
        // Tenta conectar se encontrar redes correspondentes
        if (!matchingNetworksSsid.isEmpty()) {
            connectToNetwork(matchingNetworksSsid.get(0));
        }
    }

    private void connectToNetwork(String ssid) {
        WifiConfiguration wifiConfig = createWifiConfiguration(ssid);
        if (wifiConfig != null) {
            int networkId = wifiManager.addNetwork(wifiConfig);
            if (networkId != -1) {
                boolean enabled = wifiManager.enableNetwork(networkId, true);
                isConnected = enabled;
                System.out.println("Conexão à rede " + ssid + " bem-sucedida? " + enabled);
                Toast.makeText(this, "Tentando conectar a " + ssid, Toast.LENGTH_SHORT).show();
            } else {
                 System.out.println("Falha ao adicionar rede " + ssid);
            }
        }
    }

    private WifiConfiguration createWifiConfiguration(String ssid) {
        WifiConfiguration wifiConfiguration = new WifiConfiguration();
        wifiConfiguration.SSID = String.format("\"%s\"", ssid); // SSID deve estar entre aspas
        wifiConfiguration.preSharedKey = String.format("\"%s\"", "senha123"); // Senha deve estar entre aspas
        wifiConfiguration.hiddenSSID = false; // Define se a rede está oculta
        wifiConfiguration.status = WifiConfiguration.Status.ENABLED;
        
        // Configurações de segurança WPA/WPA2 PSK
        wifiConfiguration.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
        wifiConfiguration.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
        wifiConfiguration.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
        wifiConfiguration.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
        wifiConfiguration.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
        wifiConfiguration.allowedProtocols.set(WifiConfiguration.Protocol.RSN); // Para WPA2
        
        return wifiConfiguration;
    }
}
</scanresult></string></scanresult>