Passer au contenu
Capgo

Démarrage Rapide

  1. Installer le package

    Fenêtre de terminal
    npm i @capgo/capacitor-wifi

  2. Synchroniser avec les projets natifs

    Fenêtre de terminal
    npx cap sync

  3. Configurer les permissions

    Android : Ajoutez à AndroidManifest.xml :

    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

    iOS : Ajoutez à Info.plist :

    <key>NSLocationWhenInUseUsageDescription</key>
    <string>Nous avons besoin d'accéder à la localisation pour scanner les réseaux WiFi</string>

Utilisation

Section titled “Utilisation”

Importez le plugin et gérez la connectivité WiFi :

import { CapacitorWifi } from '@capgo/capacitor-wifi';


// Obtenir les informations de la connexion WiFi actuelle
const getWifiInfo = async () => {
  const info = await CapacitorWifi.getWifiInfo();
  console.log('Connecté à :', info.ssid);
  console.log('Adresse IP :', info.ip);
};


// Scanner les réseaux disponibles
const scanNetworks = async () => {
  const { networks } = await CapacitorWifi.scan();
  networks.forEach(network => {
    console.log(`SSID : ${network.ssid}, Signal : ${network.level}`);
  });
};


// Se connecter à un réseau
const connectToWifi = async () => {
  await CapacitorWifi.connect({
    ssid: 'MonRéseau',
    password: 'monmotdepasse'
  });
};

Référence API

Section titled “Référence API”

getWifiInfo()

Section titled “getWifiInfo()”

Obtient les informations sur le réseau WiFi actuellement connecté.

interface WifiInfo {
  ssid: string;          // Nom du réseau
  bssid: string;         // Adresse MAC du point d'accès
  ip: string;            // Adresse IP de l'appareil
  frequency: number;     // Fréquence du réseau (MHz)
  linkSpeed: number;     // Vitesse de connexion (Mbps)
  signalStrength: number; // Force du signal (0-100)
}


const info = await CapacitorWifi.getWifiInfo();

scan()

Section titled “scan()”

Scanne les réseaux WiFi disponibles.

interface WifiNetwork {
  ssid: string;          // Nom du réseau
  bssid: string;         // Adresse MAC
  level: number;         // Niveau du signal (dBm)
  frequency: number;     // Fréquence du réseau
  capabilities: string;  // Capacités de sécurité
}


const { networks } = await CapacitorWifi.scan();

connect(options)

Section titled “connect(options)”

Se connecte à un réseau WiFi.

interface ConnectOptions {
  ssid: string;          // Nom du réseau
  password?: string;     // Mot de passe du réseau (si sécurisé)
  isHiddenSsid?: boolean; // Si le SSID est masqué
}


await CapacitorWifi.connect({
  ssid: 'MonRéseau',
  password: 'monmotdepasse'
});

disconnect()

Section titled “disconnect()”

Se déconnecte du réseau WiFi actuel.

await CapacitorWifi.disconnect();

getSSID()

Section titled “getSSID()”

Obtient le SSID du réseau actuellement connecté.

const { ssid } = await CapacitorWifi.getSSID();
console.log('Connecté à :', ssid);

getIP()

Section titled “getIP()”

Obtient l’adresse IP actuelle de l’appareil.

const { ip } = await CapacitorWifi.getIP();
console.log('Adresse IP :', ip);

Exemple Complet

Section titled “Exemple Complet”
import { CapacitorWifi } from '@capgo/capacitor-wifi';


export class WifiService {
  async getCurrentNetwork() {
    try {
      const info = await CapacitorWifi.getWifiInfo();
      return {
        name: info.ssid,
        strength: this.getSignalQuality(info.signalStrength),
        speed: `${info.linkSpeed} Mbps`,
        ip: info.ip
      };
    } catch (error) {
      console.error('Échec de l\'obtention des informations WiFi :', error);
      return null;
    }
  }


  async scanAndConnect(targetSsid: string, password: string) {
    try {
      // Scanner les réseaux
      const { networks } = await CapacitorWifi.scan();


      // Trouver le réseau cible
      const targetNetwork = networks.find(n => n.ssid === targetSsid);


      if (!targetNetwork) {
        throw new Error(`Réseau ${targetSsid} introuvable`);
      }


      console.log(`Réseau trouvé avec signal : ${targetNetwork.level} dBm`);


      // Se connecter au réseau
      await CapacitorWifi.connect({
        ssid: targetSsid,
        password: password
      });


      console.log('Connecté avec succès !');
      return true;
    } catch (error) {
      console.error('Échec de la connexion :', error);
      return false;
    }
  }


  async findBestNetwork(preferredNetworks: string[]) {
    const { networks } = await CapacitorWifi.scan();


    // Filtrer les réseaux préférés
    const available = networks.filter(n =>
      preferredNetworks.includes(n.ssid)
    );


    if (available.length === 0) {
      return null;
    }


    // Trier par force du signal
    available.sort((a, b) => b.level - a.level);


    return available[0];
  }


  async monitorConnection(callback: (info: WifiInfo | null) => void) {
    const checkConnection = async () => {
      try {
        const info = await CapacitorWifi.getWifiInfo();
        callback(info);
      } catch (error) {
        callback(null);
      }
    };


    // Vérifier toutes les 5 secondes
    const interval = setInterval(checkConnection, 5000);


    // Vérification initiale
    await checkConnection();


    // Retourner la fonction de nettoyage
    return () => clearInterval(interval);
  }


  private getSignalQuality(strength: number): string {
    if (strength >= 80) return 'Excellent';
    if (strength >= 60) return 'Bon';
    if (strength >= 40) return 'Moyen';
    return 'Faible';
  }


  async getNetworkSecurity(ssid: string): Promise<string> {
    const { networks } = await CapacitorWifi.scan();
    const network = networks.find(n => n.ssid === ssid);


    if (!network) {
      return 'Inconnu';
    }


    const caps = network.capabilities.toLowerCase();


    if (caps.includes('wpa3')) return 'WPA3';
    if (caps.includes('wpa2')) return 'WPA2';
    if (caps.includes('wpa')) return 'WPA';
    if (caps.includes('wep')) return 'WEP';


    return 'Ouvert';
  }
}

Utilisation Avancée

Section titled “Utilisation Avancée”

Évaluation de la Qualité du Réseau

Section titled “Évaluation de la Qualité du Réseau”
const assessNetworkQuality = async () => {
  const info = await CapacitorWifi.getWifiInfo();


  const quality = {
    signal: info.signalStrength >= 70 ? 'Excellent' :
            info.signalStrength >= 50 ? 'Bon' :
            info.signalStrength >= 30 ? 'Moyen' : 'Faible',
    speed: info.linkSpeed >= 100 ? 'Rapide' :
           info.linkSpeed >= 50 ? 'Moyen' : 'Lent',
    frequency: info.frequency >= 5000 ? '5GHz' : '2.4GHz'
  };


  console.log('Qualité du réseau :', quality);
  return quality;
};

Connexion Automatique aux Réseaux Préférés

Section titled “Connexion Automatique aux Réseaux Préférés”
const autoConnect = async (preferredNetworks: Array<{ ssid: string, password: string }>) => {
  const { networks } = await CapacitorWifi.scan();


  for (const preferred of preferredNetworks) {
    const found = networks.find(n => n.ssid === preferred.ssid);


    if (found) {
      try {
        await CapacitorWifi.connect({
          ssid: preferred.ssid,
          password: preferred.password
        });
        console.log(`Connecté à ${preferred.ssid}`);
        return true;
      } catch (error) {
        console.error(`Échec de connexion à ${preferred.ssid}`);
      }
    }
  }


  return false;
};

Détection des Changements de Réseau

Section titled “Détection des Changements de Réseau”
class NetworkMonitor {
  private currentSsid: string | null = null;
  private listeners: Array<(ssid: string | null) => void> = [];


  async start() {
    setInterval(async () => {
      try {
        const { ssid } = await CapacitorWifi.getSSID();


        if (ssid !== this.currentSsid) {
          this.currentSsid = ssid;
          this.notifyListeners(ssid);
        }
      } catch (error) {
        if (this.currentSsid !== null) {
          this.currentSsid = null;
          this.notifyListeners(null);
        }
      }
    }, 3000);
  }


  onNetworkChange(callback: (ssid: string | null) => void) {
    this.listeners.push(callback);
  }


  private notifyListeners(ssid: string | null) {
    this.listeners.forEach(listener => listener(ssid));
  }
}

Bonnes Pratiques

Section titled “Bonnes Pratiques”
  1. Permissions : Demandez les permissions de localisation avant de scanner les réseaux
  2. Gestion des Erreurs : Enveloppez toujours les opérations WiFi dans des blocs try-catch
  3. Retour Utilisateur : Affichez des indicateurs de chargement pendant les opérations réseau
  4. Sécurité : Ne stockez jamais les mots de passe WiFi en texte clair
  5. Tests : Testez sur de vrais appareils car les APIs WiFi peuvent ne pas fonctionner dans les émulateurs

Différences entre Plateformes

Section titled “Différences entre Plateformes”

iOS

Section titled “iOS”
  • Nécessite des permissions de localisation pour scanner les réseaux
  • Ne peut pas se connecter aux réseaux par programmation (ouvre les Réglages)
  • Accès limité aux détails du réseau

Android

Section titled “Android”
  • Contrôle WiFi complet par programmation
  • Nécessite des permissions de localisation pour le scan de réseaux
  • Peut se connecter/déconnecter par programmation

Dépannage

Section titled “Dépannage”

Problèmes Courants

Section titled “Problèmes Courants”

Le scan retourne vide : Vérifiez que les permissions de localisation sont accordées Impossible de se connecter au réseau : Vérifiez que le mot de passe est correct et que le réseau est à portée getWifiInfo échoue : Assurez-vous que l’appareil est connecté à un réseau WiFi Permission refusée : Ajoutez les permissions requises aux fichiers de configuration de la plateforme