@tenkam/react-native-wifi-scanner 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Benito Tenkam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,133 @@
+# react-native-wifi-scanner
+
+Bibliothèque React Native pour scanner les réseaux Wi-Fi environnants sur Android.
+
+## Installation
+
+```bash
+npm install react-native-wifi-scanner
+```
+
+## Configuration Android (étape obligatoire)
+
+Ouvrez `android/app/src/main/java/com/VOTRE_APP/MainApplication.kt` et ajoutez une ligne :
+
+```kotlin
+import com.wifiscanner.RNWifiScannerPackage  // ← Ajouter cet import
+
+override fun getPackages(): List<ReactPackage> =
+    PackageList(this).packages.apply {
+        add(RNWifiScannerPackage())  // ← Ajouter cette ligne
+    }
+```
+
+Puis recompilez :
+
+```bash
+cd android && ./gradlew clean && cd ..
+npx react-native run-android
+```
+
+---
+
+## Utilisation — Hook (recommandé)
+
+```javascript
+import { useWifiScanner } from 'react-native-wifi-scanner';
+
+const MyComponent = () => {
+  const {
+    networks,       // tableau des réseaux détectés
+    isScanning,     // true pendant le scan
+    error,          // message d'erreur ou null
+    scan,           // lancer un scan manuel
+    stopAutoScan,   // arrêter l'auto-scan
+    startAutoScan,  // reprendre l'auto-scan
+  } = useWifiScanner({
+    autoScan: true,   // scan automatique toutes les 10s
+    interval: 10000,  // intervalle en millisecondes
+  });
+
+  return (
+    <View>
+      {isScanning && <Text>Scan en cours...</Text>}
+      {networks.map(net => (
+        <Text key={net.bssid}>{net.ssid} — {net.rssi} dBm</Text>
+      ))}
+      <Button title="Scanner" onPress={scan} />
+    </View>
+  );
+};
+```
+
+---
+
+## Utilisation — API directe
+
+```javascript
+import { WifiScanner } from 'react-native-wifi-scanner';
+
+// Vérifier si le Wi-Fi est activé
+const enabled = await WifiScanner.isWifiEnabled();
+
+// Lancer un scan et récupérer les résultats
+const networks = await WifiScanner.scanNetworks();
+
+// Chaque réseau contient :
+// {
+//   ssid:         string   — Nom du réseau
+//   bssid:        string   — Adresse MAC du routeur
+//   rssi:         number   — Signal en dBm (ex: -65)
+//   frequency:    number   — Fréquence en MHz (ex: 2437)
+//   capabilities: string   — Sécurité (ex: "[WPA2-PSK-CCMP][ESS]")
+// }
+```
+
+---
+
+## Fonctions utilitaires incluses
+
+```javascript
+import {
+  rssiToPercent,      // -65 dBm → 70%
+  rssiToLabel,        // -65 dBm → "Bon"
+  frequencyToBand,    // 5180 MHz → "5 GHz"
+  frequencyToChannel, // 2437 MHz → canal 6
+  rssiToDistance,     // -65 dBm → "~8 m"
+  parseSecurityType,  // "[WPA2-PSK]" → "WPA2"
+  sortNetworks,       // trier par signal/nom/fréquence/sécurité
+  filterNetworks,     // filtrer par SSID ou BSSID
+  computeStats,       // statistiques globales
+} from 'react-native-wifi-scanner';
+```
+
+---
+
+## Permissions
+
+Les permissions suivantes sont automatiquement ajoutées au Manifest de
+l'application lors du build (fusion automatique Android) :
+
+- `ACCESS_WIFI_STATE`
+- `CHANGE_WIFI_STATE`
+- `ACCESS_FINE_LOCATION` ← obligatoire pour voir les SSID sur Android 6+
+- `ACCESS_COARSE_LOCATION`
+- `ACCESS_NETWORK_STATE`
+
+La bibliothèque gère automatiquement la demande de permission runtime
+(dialog système) via le hook `useWifiScanner`.
+
+---
+
+## Compatibilité
+
+| Plateforme | Support |
+|-----------|---------|
+| Android   | ✅ API 23+ (Android 6.0+) |
+| iOS       | ❌ Non supporté (retourne des données de test) |
+
+---
+
+## Auteur
+
+Benito Tenkam — Licence MIT

package/android/build.gradle

@@ -0,0 +1,48 @@
+// android/build.gradle
+// Configuration Gradle du module Android de la bibliothèque.
+// Ce fichier indique à Gradle comment compiler le code Kotlin de la lib.
+
+buildscript {
+    ext.kotlin_version = '1.8.0'
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:7.4.2'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+apply plugin: 'com.android.library'      // C'est une BIBLIOTHÈQUE Android, pas une app
+apply plugin: 'kotlin-android'
+
+android {
+    compileSdkVersion 33
+    buildToolsVersion "33.0.0"
+
+    defaultConfig {
+        minSdkVersion 23          // Android 6.0 minimum (requis pour les permissions runtime)
+        targetSdkVersion 33
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_11
+        targetCompatibility JavaVersion.VERSION_11
+    }
+
+    kotlinOptions {
+        jvmTarget = '11'
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    // React Native est fourni par l'application hôte (peerDependency)
+    // On l'importe ici comme "provided" pour la compilation seulement
+    implementation 'com.facebook.react:react-android:+'
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  android/src/main/AndroidManifest.xml de la BIBLIOTHÈQUE
+
+  Ce Manifest déclare les permissions requises par la bibliothèque.
+  Lors du build de l'application consommatrice, Android Studio
+  FUSIONNE automatiquement ce Manifest avec celui de l'application.
+
+  L'application consommatrice n'a donc PAS BESOIN de re-déclarer
+  ces permissions dans son propre AndroidManifest.xml.
+  C'est l'un des avantages des bibliothèques Android modulaires.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.wifiscanner">
+
+    <!-- Permission de lire l'état Wi-Fi et les résultats de scan -->
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+
+    <!-- Permission de déclencher un scan Wi-Fi (startScan) -->
+    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
+
+    <!--
+        Permission OBLIGATOIRE depuis Android 6.0 pour accéder aux SSID/BSSID.
+        Google considère les réseaux Wi-Fi comme des données de localisation.
+        Sans cette permission, tous les SSID apparaissent comme "<unknown ssid>".
+    -->
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+
+    <!-- Permission pour lire l'état de la connexion réseau -->
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+
+</manifest>

package/android/src/main/java/com/wifiscanner/RNWifiScannerModule.kt

@@ -0,0 +1,203 @@
+// android/src/main/java/com/wifiscanner/RNWifiScannerModule.kt
+// Module natif Kotlin de la bibliothèque react-native-wifi-scanner
+// Ce fichier est packagé DANS la bibliothèque et copié dans le projet Android
+// lors de l'installation via npm install.
+
+package com.wifiscanner
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.net.wifi.WifiManager
+import android.os.Build
+import android.provider.Settings
+
+import com.facebook.react.bridge.*
+
+/**
+ * RNWifiScannerModule
+ *
+ * Module natif Android exposé à React Native sous le nom "RNWifiScanner".
+ * Ce nom correspond à celui utilisé dans WifiScanner.js :
+ *   const { RNWifiScanner } = NativeModules;
+ *
+ * Ce module est fourni par la bibliothèque react-native-wifi-scanner.
+ * Il sera automatiquement copié dans le projet Android de l'application
+ * consommatrice lors de l'installation via npm.
+ */
+class RNWifiScannerModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    // Accès au service Wi-Fi Android via lazy initialization
+    private val wifiManager: WifiManager? by lazy {
+        reactContext
+            .applicationContext
+            .getSystemService(Context.WIFI_SERVICE) as? WifiManager
+    }
+
+    /**
+     * Nom du module tel qu'il sera accessible côté JavaScript :
+     * NativeModules.RNWifiScanner
+     */
+    override fun getName(): String = "RNWifiScanner"
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // MÉTHODES EXPOSÉES À JAVASCRIPT
+    // Toutes annotées @ReactMethod pour être accessibles via le bridge RN
+    // ─────────────────────────────────────────────────────────────────────────
+
+    /**
+     * Vérifie si le Wi-Fi est activé sur l'appareil.
+     * @param promise Résout avec true (activé) ou false (désactivé)
+     */
+    @ReactMethod
+    fun isWifiEnabled(promise: Promise) {
+        try {
+            promise.resolve(wifiManager?.isWifiEnabled == true)
+        } catch (e: Exception) {
+            promise.reject("WIFI_STATE_ERROR", "Impossible de lire l'état Wi-Fi: ${e.message}")
+        }
+    }
+
+    /**
+     * Demande l'activation du Wi-Fi.
+     * Android 10+ : ouvre le panneau Paramètres Wi-Fi (Google bloque setWifiEnabled)
+     * Android 9-  : active directement via setWifiEnabled(true)
+     */
+    @ReactMethod
+    fun requestEnableWifi(promise: Promise) {
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                // Android 10+ : redirection vers les paramètres système
+                val intent = Intent(Settings.Panel.ACTION_WIFI).apply {
+                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                }
+                reactContext.startActivity(intent)
+            } else {
+                // Android 9 et inférieur : activation directe (dépréciée mais fonctionnelle)
+                @Suppress("DEPRECATION")
+                wifiManager?.isWifiEnabled = true
+            }
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("WIFI_ENABLE_ERROR", "Impossible d'activer le Wi-Fi: ${e.message}")
+        }
+    }
+
+    /**
+     * Lance un scan Wi-Fi et retourne les réseaux détectés.
+     *
+     * Fonctionnement asynchrone via BroadcastReceiver :
+     * 1. Enregistre un receiver sur SCAN_RESULTS_AVAILABLE_ACTION
+     * 2. Lance startScan() pour déclencher le scan matériel
+     * 3. Quand Android envoie l'événement → récupère getScanResults()
+     * 4. Convertit chaque ScanResult en objet JavaScript (WritableMap)
+     * 5. Résout la Promise avec le tableau de réseaux
+     * 6. Désenregistre le receiver pour éviter les fuites mémoire
+     *
+     * @param promise Résout avec Array<WifiNetwork> ou rejette en cas d'erreur
+     */
+    @ReactMethod
+    fun scanNetworks(promise: Promise) {
+        val wifi = wifiManager
+
+        // Vérifications préalables
+        if (wifi == null) {
+            promise.reject("WIFI_UNAVAILABLE", "WifiManager non disponible sur cet appareil.")
+            return
+        }
+        if (!wifi.isWifiEnabled) {
+            promise.reject("WIFI_DISABLED", "Le Wi-Fi est désactivé. Activez-le d'abord.")
+            return
+        }
+
+        // ── Récepteur temporaire ──────────────────────────────────────────────
+        // Android envoie SCAN_RESULTS_AVAILABLE_ACTION quand le scan est terminé.
+        // Ce receiver est créé une seule fois, utilisé une seule fois, puis supprimé.
+        val scanReceiver = object : BroadcastReceiver() {
+            override fun onReceive(context: Context, intent: Intent) {
+
+                // Désenregistrement IMMÉDIAT pour éviter les fuites mémoire
+                // et ne pas recevoir de futurs scans déclenchés par d'autres apps
+                try {
+                    reactContext.unregisterReceiver(this)
+                } catch (_: IllegalArgumentException) {
+                    // Déjà désenregistré, on ignore
+                }
+
+                // ── Conversion des résultats en objets JavaScript ─────────────
+                try {
+                    val results = wifi.scanResults      // Liste de ScanResult Android
+                    val networksArray = Arguments.createArray()
+
+                    for (scan in results) {
+                        val network = Arguments.createMap().apply {
+                            // ssid : nom du réseau. Vide si réseau caché.
+                            putString("ssid", scan.SSID ?: "")
+
+                            // bssid : adresse MAC du point d'accès (routeur)
+                            putString("bssid", scan.BSSID ?: "")
+
+                            // rssi : intensité du signal en dBm.
+                            // Valeur négative : -30 (excellent) à -100 (inexistant)
+                            putInt("rssi", scan.level)
+
+                            // frequency : fréquence en MHz
+                            // 2412-2484 = bande 2.4 GHz, 5180-5825 = bande 5 GHz
+                            putInt("frequency", scan.frequency)
+
+                            // capabilities : chaîne décrivant les protocoles de sécurité
+                            // Exemple : "[WPA2-PSK-CCMP][ESS]"
+                            putString("capabilities", scan.capabilities ?: "")
+                        }
+                        networksArray.pushMap(network)
+                    }
+
+                    // Résolution de la Promise → retour à JavaScript
+                    promise.resolve(networksArray)
+
+                } catch (e: Exception) {
+                    promise.reject("SCAN_PARSE_ERROR",
+                        "Erreur lors du traitement des résultats: ${e.message}")
+                }
+            }
+        }
+
+        // ── Enregistrement du receiver AVANT de lancer le scan ──────────────
+        // Important : enregistrer avant startScan() pour ne rater aucun événement
+        val filter = IntentFilter(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION)
+        reactContext.registerReceiver(scanReceiver, filter)
+
+        // ── Déclenchement du scan matériel ───────────────────────────────────
+        // Sur Android 9+, startScan() peut être throttlé (limité à 4 scans/2min).
+        // Si throttlé (started = false), on retourne quand même les derniers résultats en cache.
+        val started = wifi.startScan()
+
+        if (!started) {
+            // Scan throttlé ou impossible → utiliser les résultats en cache
+            try {
+                reactContext.unregisterReceiver(scanReceiver)
+            } catch (_: Exception) {}
+
+            try {
+                val results = wifi.scanResults
+                val networksArray = Arguments.createArray()
+                for (scan in results) {
+                    val network = Arguments.createMap().apply {
+                        putString("ssid", scan.SSID ?: "")
+                        putString("bssid", scan.BSSID ?: "")
+                        putInt("rssi", scan.level)
+                        putInt("frequency", scan.frequency)
+                        putString("capabilities", scan.capabilities ?: "")
+                    }
+                    networksArray.pushMap(network)
+                }
+                promise.resolve(networksArray)
+            } catch (e: Exception) {
+                promise.reject("SCAN_THROTTLED",
+                    "Scan Wi-Fi limité par Android. Réessayez dans quelques secondes.")
+            }
+        }
+    }
+}

package/android/src/main/java/com/wifiscanner/RNWifiScannerPackage.kt

@@ -0,0 +1,40 @@
+// android/src/main/java/com/wifiscanner/RNWifiScannerPackage.kt
+// Package React Native de la bibliothèque.
+// Enregistre RNWifiScannerModule auprès du système React Native.
+// L'application consommatrice doit ajouter ce package dans son MainApplication.kt.
+
+package com.wifiscanner
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * RNWifiScannerPackage
+ *
+ * Ce package est fourni par la bibliothèque react-native-wifi-scanner.
+ * Il doit être déclaré dans le MainApplication.kt de l'application consommatrice :
+ *
+ *   override fun getPackages(): List<ReactPackage> =
+ *       PackageList(this).packages.apply {
+ *           add(RNWifiScannerPackage())  // ← Ajouter cette ligne
+ *       }
+ */
+class RNWifiScannerPackage : ReactPackage {
+
+    /**
+     * Retourne la liste des modules natifs fournis par cette bibliothèque.
+     * Un seul module : RNWifiScannerModule.
+     */
+    override fun createNativeModules(
+        reactContext: ReactApplicationContext
+    ): List<NativeModule> = listOf(RNWifiScannerModule(reactContext))
+
+    /**
+     * Aucun composant UI natif dans cette bibliothèque.
+     */
+    override fun createViewManagers(
+        reactContext: ReactApplicationContext
+    ): List<ViewManager<*, *>> = emptyList()
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@tenkam/react-native-wifi-scanner",
+  "version": "1.0.0",
+  "description": "Bibliotheque React Native pour scanner les reseaux Wi-Fi environnants sur Android",
+  "main": "src/index.js",
+  "files": [
+    "src/",
+    "android/",
+    "README.md"
+  ],
+  "keywords": [
+    "react-native",
+    "android",
+    "wifi",
+    "scanner",
+    "network",
+    "rssi",
+    "wifi-scan"
+  ],
+  "author": "Benito Tenkam",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tenkam/react-native-wifi-scanner"
+  },
+  "peerDependencies": {
+    "react": ">=17.0.0",
+    "react-native": ">=0.65.0"
+  },
+  "devDependencies": {
+    "react": "18.2.0",
+    "react-native": "0.73.4"
+  }
+}

package/src/WifiScanner.js

@@ -0,0 +1,124 @@
+// src/WifiScanner.js
+// Classe principale de la bibliothèque.
+// Elle fait le pont entre JavaScript et le module natif Android.
+
+import { NativeModules, Platform } from 'react-native';
+
+// Récupération du module natif enregistré sous le nom "RNWifiScanner"
+const { RNWifiScanner } = NativeModules;
+
+/**
+ * Vérifie que le module natif est bien disponible.
+ * Si l'application consommatrice n'a pas correctement lié la bibliothèque,
+ * on lève une erreur explicative.
+ */
+function assertNativeModule() {
+  if (Platform.OS === 'android' && !RNWifiScanner) {
+    throw new Error(
+      '[react-native-wifi-scanner] Le module natif RNWifiScanner est introuvable.\n' +
+      'Vérifiez que :\n' +
+      '1. La bibliothèque est correctement installée (npm install react-native-wifi-scanner)\n' +
+      '2. Le projet Android a été recompilé (npx react-native run-android)\n' +
+      '3. RNWifiScannerPackage est bien déclaré dans MainApplication.kt'
+    );
+  }
+}
+
+/**
+ * WifiScanner — Interface JavaScript principale de la bibliothèque
+ *
+ * Utilisation dans une application React Native :
+ *
+ *   import { WifiScanner } from 'react-native-wifi-scanner';
+ *
+ *   const networks = await WifiScanner.scanNetworks();
+ *   const enabled  = await WifiScanner.isWifiEnabled();
+ */
+const WifiScanner = {
+
+  /**
+   * Lance un scan Wi-Fi et retourne la liste des réseaux détectés.
+   *
+   * @returns {Promise<Array<WifiNetwork>>} Tableau de réseaux Wi-Fi
+   *
+   * Chaque objet WifiNetwork contient :
+   *   - ssid         {string}  Nom du réseau (SSID)
+   *   - bssid        {string}  Adresse MAC du point d'accès
+   *   - rssi         {number}  Intensité du signal en dBm (ex: -65)
+   *   - frequency    {number}  Fréquence en MHz (ex: 2437 ou 5180)
+   *   - capabilities {string}  Protocoles de sécurité (ex: "[WPA2-PSK-CCMP]")
+   *
+   * @example
+   *   const networks = await WifiScanner.scanNetworks();
+   *   console.log(networks[0].ssid); // "MonReseau"
+   */
+  async scanNetworks() {
+    // Sur iOS ou simulateur : retourner des données de test
+    if (Platform.OS !== 'android') {
+      return _getMockNetworks();
+    }
+    assertNativeModule();
+    try {
+      const results = await RNWifiScanner.scanNetworks();
+      return results || [];
+    } catch (error) {
+      throw new Error(`[WifiScanner.scanNetworks] ${error.message}`);
+    }
+  },
+
+  /**
+   * Vérifie si le Wi-Fi est activé sur l'appareil.
+   *
+   * @returns {Promise<boolean>} true si le Wi-Fi est activé
+   *
+   * @example
+   *   const enabled = await WifiScanner.isWifiEnabled();
+   *   if (!enabled) alert('Activez le Wi-Fi !');
+   */
+  async isWifiEnabled() {
+    if (Platform.OS !== 'android') return true;
+    assertNativeModule();
+    try {
+      return await RNWifiScanner.isWifiEnabled();
+    } catch {
+      return false;
+    }
+  },
+
+  /**
+   * Demande l'activation du Wi-Fi.
+   * - Android 9 et inférieur : active directement
+   * - Android 10 et supérieur : ouvre le panneau paramètres Wi-Fi
+   *
+   * @returns {Promise<void>}
+   */
+  async requestEnableWifi() {
+    if (Platform.OS !== 'android') return;
+    assertNativeModule();
+    try {
+      await RNWifiScanner.requestEnableWifi();
+    } catch (error) {
+      console.warn('[WifiScanner.requestEnableWifi]', error.message);
+    }
+  },
+};
+
+/**
+ * Données fictives pour le développement sur iOS / simulateur Android.
+ * Représente 8 réseaux avec différents niveaux de signal, bandes et sécurités.
+ * @private
+ */
+function _getMockNetworks() {
+  return [
+    { ssid: 'Livebox-Premium',  bssid: 'A4:BE:2B:11:22:33', rssi: -42, frequency: 5180, capabilities: '[WPA2-PSK-CCMP][ESS]' },
+    { ssid: 'SFR_WiFi5G',       bssid: 'C8:D7:19:44:55:66', rssi: -55, frequency: 5220, capabilities: '[WPA3-SAE][ESS]' },
+    { ssid: 'FreeWifi',         bssid: '00:24:D4:77:88:99', rssi: -67, frequency: 2437, capabilities: '[WPA2-PSK][ESS]' },
+    { ssid: 'Orange-Fibre',     bssid: 'B8:EE:65:AA:BB:CC', rssi: -71, frequency: 2412, capabilities: '[WPA2-PSK-CCMP][ESS]' },
+    { ssid: '',                 bssid: 'F0:1D:BC:DD:EE:FF', rssi: -79, frequency: 2462, capabilities: '[WPA-PSK][ESS]' },
+    { ssid: 'TP-Link_Gaming',   bssid: '50:C7:BF:12:34:56', rssi: -83, frequency: 5745, capabilities: '[WPA2-PSK][ESS]' },
+    { ssid: 'Bbox-Voisin',      bssid: 'EC:AD:B8:78:90:AB', rssi: -88, frequency: 2452, capabilities: '[WEP][ESS]' },
+    { ssid: 'Hotspot_Public',   bssid: '3C:37:86:CD:EF:01', rssi: -92, frequency: 2427, capabilities: '[ESS]' },
+  ];
+}
+
+export default WifiScanner;

package/src/index.js

@@ -0,0 +1,7 @@
+// src/index.js
+// Point d'entrée principal de la bibliothèque react-native-wifi-scanner
+// Ce fichier exporte tout ce que l'application consommatrice peut utiliser
+
+export { default as WifiScanner } from './WifiScanner';
+export { default as useWifiScanner } from './useWifiScanner';
+export * from './utils';

package/src/useWifiScanner.js

@@ -0,0 +1,202 @@
+// src/useWifiScanner.js
+// Hook React personnalisé fourni par la bibliothèque.
+// Encapsule toute la logique de scan (état, permissions, auto-refresh).
+// L'application consommatrice n'a qu'à appeler ce hook pour tout avoir.
+
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { Platform, PermissionsAndroid, AppState, Linking } from 'react-native';
+import WifiScanner from './WifiScanner';
+
+/**
+ * useWifiScanner — Hook React principal de la bibliothèque
+ *
+ * Utilisation dans une application React Native :
+ *
+ *   import { useWifiScanner } from 'react-native-wifi-scanner';
+ *
+ *   const {
+ *     networks,      // tableau des réseaux détectés
+ *     isScanning,    // booléen : scan en cours ?
+ *     error,         // message d'erreur ou null
+ *     scan,          // fonction : lancer un scan manuel
+ *     stopAutoScan,  // fonction : arrêter l'auto-scan
+ *     startAutoScan, // fonction : démarrer l'auto-scan
+ *   } = useWifiScanner({ autoScan: true, interval: 10000 });
+ *
+ * @param {Object} options - Options de configuration
+ * @param {boolean} options.autoScan   - Activer le scan automatique (défaut: true)
+ * @param {number}  options.interval   - Intervalle en ms entre les scans (défaut: 10000)
+ * @param {boolean} options.requestPermission - Demander la permission au démarrage (défaut: true)
+ *
+ * @returns {Object} État et fonctions du scanner
+ */
+function useWifiScanner(options = {}) {
+  const {
+    autoScan = true,
+    interval = 10000,
+    requestPermission = true,
+  } = options;
+
+  // ── États exposés à l'application consommatrice ──────────────────────────
+  const [networks, setNetworks]         = useState([]);
+  const [isScanning, setIsScanning]     = useState(false);
+  const [error, setError]               = useState(null);
+  const [hasPermission, setHasPermission] = useState(false);
+  const [isAutoScanning, setIsAutoScanning] = useState(autoScan);
+  const [lastScanTime, setLastScanTime] = useState(null);
+
+  const intervalRef    = useRef(null);
+  const appStateRef    = useRef(AppState.currentState);
+
+  // ── Vérification silencieuse de la permission ────────────────────────────
+  const checkPermission = useCallback(async () => {
+    if (Platform.OS !== 'android') {
+      setHasPermission(true);
+      return true;
+    }
+    try {
+      const granted = await PermissionsAndroid.check(
+        PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION
+      );
+      setHasPermission(granted);
+      return granted;
+    } catch {
+      return false;
+    }
+  }, []);
+
+  // ── Demande de permission avec dialog système ────────────────────────────
+  const askPermission = useCallback(async () => {
+    if (Platform.OS !== 'android') {
+      setHasPermission(true);
+      return true;
+    }
+    try {
+      // Vérifie si déjà accordée
+      const already = await PermissionsAndroid.check(
+        PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION
+      );
+      if (already) {
+        setHasPermission(true);
+        return true;
+      }
+
+      // Demande au système Android d'afficher le dialog
+      const result = await PermissionsAndroid.request(
+        PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
+        {
+          title: 'Permission Wi-Fi requise',
+          message:
+            "Cette application a besoin d'accéder à votre localisation " +
+            'pour scanner les réseaux Wi-Fi environnants.',
+          buttonNeutral: 'Plus tard',
+          buttonNegative: 'Refuser',
+          buttonPositive: 'Autoriser',
+        }
+      );
+
+      const granted = result === PermissionsAndroid.RESULTS.GRANTED;
+      setHasPermission(granted);
+
+      // Si bloquée définitivement, proposer d'ouvrir les paramètres
+      if (result === PermissionsAndroid.RESULTS.NEVER_ASK_AGAIN) {
+        setError(
+          'Permission bloquée. Ouvrez les Paramètres > Applications > ' +
+          'votre app > Autorisations > Localisation.'
+        );
+        Linking.openSettings().catch(() => {});
+      }
+
+      return granted;
+    } catch (err) {
+      setError(`Erreur permission: ${err.message}`);
+      return false;
+    }
+  }, []);
+
+  // ── Scan effectif (sans gestion de permission) ───────────────────────────
+  const _doScan = useCallback(async () => {
+    if (isScanning) return;
+    setIsScanning(true);
+    setError(null);
+    try {
+      const wifiOn = await WifiScanner.isWifiEnabled();
+      if (!wifiOn) {
+        setError('Wi-Fi désactivé. Activez le Wi-Fi pour scanner.');
+        return;
+      }
+      const results = await WifiScanner.scanNetworks();
+      setNetworks(results || []);
+      setLastScanTime(new Date());
+    } catch (err) {
+      setError(`Erreur scan: ${err.message}`);
+    } finally {
+      setIsScanning(false);
+    }
+  }, [isScanning]);
+
+  // ── Scan public : vérifie la permission puis scanne ──────────────────────
+  const scan = useCallback(async () => {
+    const permitted = requestPermission
+      ? await askPermission()
+      : await checkPermission();
+    if (permitted) {
+      await _doScan();
+    }
+  }, [askPermission, checkPermission, _doScan, requestPermission]);
+
+  // ── Contrôle de l'auto-scan ──────────────────────────────────────────────
+  const startAutoScan = useCallback(() => setIsAutoScanning(true), []);
+  const stopAutoScan  = useCallback(() => setIsAutoScanning(false), []);
+
+  // ── Scan initial au montage du hook ─────────────────────────────────────
+  useEffect(() => {
+    scan();
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  // ── Gestion de l'auto-scan par intervalle ────────────────────────────────
+  useEffect(() => {
+    if (isAutoScanning) {
+      intervalRef.current = setInterval(async () => {
+        const ok = await checkPermission();
+        if (ok) _doScan();
+      }, interval);
+    } else {
+      clearInterval(intervalRef.current);
+    }
+    // Cleanup : supprime l'intervalle quand le composant est démonté
+    return () => clearInterval(intervalRef.current);
+  }, [isAutoScanning, interval, checkPermission, _doScan]);
+
+  // ── Écoute AppState : relance scan quand l'app revient au premier plan ───
+  useEffect(() => {
+    const sub = AppState.addEventListener('change', async nextState => {
+      const wasInBackground =
+        appStateRef.current === 'background' ||
+        appStateRef.current === 'inactive';
+      if (wasInBackground && nextState === 'active') {
+        const ok = await checkPermission();
+        if (ok) _doScan();
+      }
+      appStateRef.current = nextState;
+    });
+    return () => sub.remove();
+  }, [checkPermission, _doScan]);
+
+  // ── Valeurs retournées au consommateur ───────────────────────────────────
+  return {
+    networks,       // Array<WifiNetwork> — liste des réseaux détectés
+    isScanning,     // boolean — true pendant le scan
+    error,          // string|null — message d'erreur
+    hasPermission,  // boolean — permission de localisation accordée
+    isAutoScanning, // boolean — auto-scan actif
+    lastScanTime,   // Date|null — heure du dernier scan réussi
+    scan,           // () => Promise<void> — lancer un scan manuel
+    startAutoScan,  // () => void — activer l'auto-scan
+    stopAutoScan,   // () => void — désactiver l'auto-scan
+    askPermission,  // () => Promise<boolean> — demander la permission
+  };
+}
+
+export default useWifiScanner;

package/src/utils.js

@@ -0,0 +1,159 @@
+// src/utils.js
+// Fonctions utilitaires exportées par la bibliothèque.
+// L'application consommatrice peut les importer pour traiter les données Wi-Fi.
+
+/**
+ * Convertit le RSSI (dBm) en pourcentage de qualité (0–100%)
+ * Formule : ((rssi + 100) / 50) * 100
+ * @param {number} rssi - Valeur RSSI en dBm (ex: -65)
+ * @returns {number} Pourcentage entre 0 et 100
+ */
+export function rssiToPercent(rssi) {
+  if (rssi >= -50) return 100;
+  if (rssi <= -100) return 0;
+  return Math.round(((rssi + 100) / 50) * 100);
+}
+
+/**
+ * Retourne un label qualitatif selon le RSSI
+ * @param {number} rssi
+ * @returns {string} 'Excellent' | 'Bon' | 'Moyen' | 'Faible' | 'Très faible'
+ */
+export function rssiToLabel(rssi) {
+  if (rssi >= -50) return 'Excellent';
+  if (rssi >= -65) return 'Bon';
+  if (rssi >= -75) return 'Moyen';
+  if (rssi >= -85) return 'Faible';
+  return 'Très faible';
+}
+
+/**
+ * Détermine la bande Wi-Fi à partir de la fréquence en MHz
+ * @param {number} frequency - Fréquence en MHz
+ * @returns {string} '2.4 GHz' | '5 GHz' | '6 GHz' | 'Inconnu'
+ */
+export function frequencyToBand(frequency) {
+  if (frequency >= 2400 && frequency < 2500) return '2.4 GHz';
+  if (frequency >= 4900 && frequency < 5900) return '5 GHz';
+  if (frequency >= 5900 && frequency < 7200) return '6 GHz';
+  return 'Inconnu';
+}
+
+/**
+ * Calcule le canal Wi-Fi à partir de la fréquence en MHz
+ * @param {number} frequency
+ * @returns {number|string} Numéro de canal ou '?'
+ */
+export function frequencyToChannel(frequency) {
+  if (frequency === 2484) return 14;
+  if (frequency >= 2412 && frequency <= 2472) {
+    return Math.round((frequency - 2407) / 5);
+  }
+  if (frequency >= 5180 && frequency <= 5825) {
+    return Math.round((frequency - 5000) / 5);
+  }
+  return '?';
+}
+
+/**
+ * Estime la distance en mètres à partir du RSSI
+ * Utilise le modèle Free Space Path Loss
+ * @param {number} rssi
+ * @returns {string} Distance formatée (ex: '~5 m', '< 1 m', '> 100 m')
+ */
+export function rssiToDistance(rssi) {
+  const txPower = -59;
+  const n = 2.7;
+  const distance = Math.pow(10, (txPower - rssi) / (10 * n));
+  if (distance < 1) return '< 1 m';
+  if (distance > 100) return '> 100 m';
+  return `~${Math.round(distance)} m`;
+}
+
+/**
+ * Détermine le type de sécurité depuis la chaîne capabilities Android
+ * @param {string} capabilities - Ex: '[WPA2-PSK-CCMP][ESS]'
+ * @returns {string} 'WPA3' | 'WPA2' | 'WPA' | 'WEP' | 'Ouvert'
+ */
+export function parseSecurityType(capabilities) {
+  if (!capabilities) return 'Ouvert';
+  const cap = capabilities.toUpperCase();
+  if (cap.includes('WPA3')) return 'WPA3';
+  if (cap.includes('WPA2')) return 'WPA2';
+  if (cap.includes('WPA')) return 'WPA';
+  if (cap.includes('WEP')) return 'WEP';
+  return 'Ouvert';
+}
+
+/**
+ * Normalise le SSID (réseau caché → label lisible)
+ * @param {string} ssid
+ * @returns {string}
+ */
+export function formatSSID(ssid) {
+  if (!ssid || ssid.trim() === '') return '(Réseau caché)';
+  return ssid;
+}
+
+/**
+ * Formate le BSSID en majuscules
+ * @param {string} bssid
+ * @returns {string}
+ */
+export function formatBSSID(bssid) {
+  if (!bssid) return 'N/A';
+  return bssid.toUpperCase();
+}
+
+/**
+ * Trie un tableau de réseaux selon le critère choisi
+ * @param {Array} networks
+ * @param {'signal'|'name'|'frequency'|'security'} sortBy
+ * @returns {Array}
+ */
+export function sortNetworks(networks, sortBy) {
+  const copy = [...networks];
+  switch (sortBy) {
+    case 'signal':    return copy.sort((a, b) => b.rssi - a.rssi);
+    case 'name':      return copy.sort((a, b) => formatSSID(a.ssid).localeCompare(formatSSID(b.ssid)));
+    case 'frequency': return copy.sort((a, b) => b.frequency - a.frequency);
+    case 'security':  return copy.sort((a, b) => parseSecurityType(a.capabilities).localeCompare(parseSecurityType(b.capabilities)));
+    default:          return copy;
+  }
+}
+
+/**
+ * Filtre les réseaux par SSID ou BSSID
+ * @param {Array} networks
+ * @param {string} query
+ * @returns {Array}
+ */
+export function filterNetworks(networks, query) {
+  if (!query || query.trim() === '') return networks;
+  const q = query.toLowerCase();
+  return networks.filter(
+    n =>
+      (n.ssid && n.ssid.toLowerCase().includes(q)) ||
+      (n.bssid && n.bssid.toLowerCase().includes(q))
+  );
+}
+
+/**
+ * Calcule les statistiques globales de la liste de réseaux
+ * @param {Array} networks
+ * @returns {Object} { total, strongest, weakest, band24, band5, band6 }
+ */
+export function computeStats(networks) {
+  if (!networks || networks.length === 0) {
+    return { total: 0, strongest: null, weakest: null, band24: 0, band5: 0, band6: 0 };
+  }
+  const sorted = [...networks].sort((a, b) => b.rssi - a.rssi);
+  return {
+    total:    networks.length,
+    strongest: sorted[0],
+    weakest:   sorted[sorted.length - 1],
+    band24:   networks.filter(n => frequencyToBand(n.frequency) === '2.4 GHz').length,
+    band5:    networks.filter(n => frequencyToBand(n.frequency) === '5 GHz').length,
+    band6:    networks.filter(n => frequencyToBand(n.frequency) === '6 GHz').length,
+  };
+}