munim-wifi 0.1.0

package/android/build.gradle

@@ -0,0 +1,148 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.8.0"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: 'org.jetbrains.kotlin.android'
+apply from: '../nitrogen/generated/android/MunimWifi+autolinking.gradle'
+apply from: "./fix-prefab.gradle"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["MunimWifi_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["MunimWifi_" + name]).toInteger()
+}
+
+android {
+  namespace "com.munimwifi"
+
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+        "META-INF",
+        "META-INF/**",
+        "**/libc++_shared.so",
+        "**/libfbjni.so",
+        "**/libjsi.so",
+        "**/libfolly_json.so",
+        "**/libfolly_runtime.so",
+        "**/libglog.so",
+        "**/libhermes.so",
+        "**/libhermes-executor-debug.so",
+        "**/libhermes_executor.so",
+        "**/libreactnative.so",
+        "**/libreactnativejni.so",
+        "**/libturbomodulejsijni.so",
+        "**/libreact_nativemodule_core.so",
+        "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += [
+          // React Codegen files
+          "${project.buildDir}/generated/source/codegen/java"
+        ]
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+
+  // Add a dependency on NitroModules
+  implementation project(":react-native-nitro-modules")
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "MunimWifi"
+    codegenJavaPackageName = "com.munimwifi"
+  }
+}

package/android/fix-prefab.gradle

@@ -0,0 +1,51 @@
+tasks.configureEach { task ->
+  // Make sure that we generate our prefab publication file only after having built the native library
+  // so that not a header publication file, but a full configuration publication will be generated, which
+  // will include the .so file
+
+  def prefabConfigurePattern = ~/^prefab(.+)ConfigurePackage$/
+  def matcher = task.name =~ prefabConfigurePattern
+  if (matcher.matches()) {
+    def variantName = matcher[0][1]
+    task.outputs.upToDateWhen { false }
+    task.dependsOn("externalNativeBuild${variantName}")
+  }
+}
+
+afterEvaluate {
+  def abis = reactNativeArchitectures()
+  rootProject.allprojects.each { proj ->
+    if (proj === rootProject) return
+
+    def dependsOnThisLib = proj.configurations.findAll { it.canBeResolved }.any { config ->
+      config.dependencies.any { dep ->
+        dep.group == project.group && dep.name == project.name
+      }
+    }
+    if (!dependsOnThisLib && proj != project) return
+
+    if (!proj.plugins.hasPlugin('com.android.application') && !proj.plugins.hasPlugin('com.android.library')) {
+      return
+    }
+
+    def variants = proj.android.hasProperty('applicationVariants') ? proj.android.applicationVariants : proj.android.libraryVariants
+    // Touch the prefab_config.json files to ensure that in ExternalNativeJsonGenerator.kt we will re-trigger the prefab CLI to
+    // generate a libnameConfig.cmake file that will contain our native library (.so).
+    // See this condition: https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:build-system/gradle-core/src/main/java/com/android/build/gradle/tasks/ExternalNativeJsonGenerator.kt;l=207-219?q=createPrefabBuildSystemGlue
+    variants.all { variant ->
+      def variantName = variant.name
+      abis.each { abi ->
+        def searchDir = new File(proj.projectDir, ".cxx/${variantName}")
+        if (!searchDir.exists()) return
+        def matches = []
+        searchDir.eachDir { randomDir ->
+          def prefabFile = new File(randomDir, "${abi}/prefab_config.json")
+          if (prefabFile.exists()) matches << prefabFile
+        }
+        matches.each { prefabConfig ->
+          prefabConfig.setLastModified(System.currentTimeMillis())
+        }
+      }
+    }
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+MunimWifi_kotlinVersion=2.1.20
+MunimWifi_minSdkVersion=23
+MunimWifi_targetSdkVersion=35
+MunimWifi_compileSdkVersion=34
+MunimWifi_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,6 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <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" />
+</manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,6 @@
+#include <jni.h>
+#include "MunimWifiOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::munimwifi::initialize(vm);
+}

package/android/src/main/java/com/munimwifi/HybridMunimWifi.kt

@@ -0,0 +1,283 @@
+package com.munimwifi
+
+import android.Manifest
+import android.content.Context
+import android.content.pm.PackageManager
+import android.net.wifi.ScanResult
+import android.net.wifi.WifiManager
+import android.os.Build
+import android.util.Log
+import androidx.core.app.ActivityCompat
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.munimwifi.HybridMunimWifiSpec
+import java.util.concurrent.ConcurrentHashMap
+
+class HybridMunimWifi : HybridMunimWifiSpec() {
+    private val TAG = "HybridMunimWifi"
+    private var wifiManager: WifiManager? = null
+    private val scanResults = ConcurrentHashMap<String, ScanResult>()
+    private var isScanning = false
+
+    private fun getWifiManager(): WifiManager? {
+        if (wifiManager == null) {
+            val context = NitroModules.applicationContext ?: return null
+            wifiManager = context.getSystemService(Context.WIFI_SERVICE) as? WifiManager
+        }
+        return wifiManager
+    }
+
+    private fun hasPermission(permission: String): Boolean {
+        val context = NitroModules.applicationContext ?: return false
+        return ActivityCompat.checkSelfPermission(
+            context,
+            permission
+        ) == PackageManager.PERMISSION_GRANTED
+    }
+
+    private fun checkLocationPermission(): Boolean {
+        return hasPermission(Manifest.permission.ACCESS_FINE_LOCATION) ||
+            hasPermission(Manifest.permission.ACCESS_COARSE_LOCATION)
+    }
+
+    private fun getFrequencyChannel(frequency: Int): Int {
+        return when {
+            frequency in 2412..2484 -> ((frequency - 2412) / 5) + 1 // 2.4 GHz channels 1-14
+            frequency in 5170..5825 -> ((frequency - 5170) / 5) + 36 // 5 GHz channels
+            else -> 0
+        }
+    }
+
+    private fun convertScanResult(scanResult: ScanResult): com.margelo.nitro.munimwifi.WifiNetwork {
+        val channel = getFrequencyChannel(scanResult.frequency)
+        val isSecure = scanResult.capabilities.contains("WPA") ||
+            scanResult.capabilities.contains("WEP") ||
+            scanResult.capabilities.contains("EAP")
+
+        return com.margelo.nitro.munimwifi.WifiNetwork(
+            ssid = scanResult.SSID ?: "",
+            bssid = scanResult.BSSID ?: "",
+            rssi = scanResult.level,
+            frequency = scanResult.frequency,
+            channel = channel,
+            capabilities = scanResult.capabilities,
+            isSecure = isSecure,
+            timestamp = System.currentTimeMillis()
+        )
+    }
+
+    override fun isWifiEnabled(): Boolean {
+        return getWifiManager()?.isWifiEnabled ?: false
+    }
+
+    override fun requestWifiPermission(): Boolean {
+        return checkLocationPermission()
+    }
+
+    override fun scanNetworks(
+        maxResults: Double?,
+        timeout: Double?
+    ): List<com.margelo.nitro.munimwifi.WifiNetwork> {
+        val manager = getWifiManager() ?: return emptyList()
+
+        if (!checkLocationPermission()) {
+            Log.w("MunimWifi", "Location permission not granted")
+            return emptyList()
+        }
+
+        if (!manager.isWifiEnabled) {
+            Log.w("MunimWifi", "Wi-Fi is not enabled")
+            return emptyList()
+        }
+
+        try {
+            val success = manager.startScan()
+            if (!success) {
+                Log.w("MunimWifi", "Failed to start Wi-Fi scan")
+                return emptyList()
+            }
+
+            // Wait for scan to complete (max 10 seconds)
+            val maxWaitTime = (timeout?.toLong() ?: 10000L).coerceAtMost(10000L)
+            val startTime = System.currentTimeMillis()
+            while (System.currentTimeMillis() - startTime < maxWaitTime) {
+                val results = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                    if (hasPermission(Manifest.permission.ACCESS_FINE_LOCATION)) {
+                        manager.scanResults
+                    } else {
+                        emptyList()
+                    }
+                } else {
+                    manager.scanResults
+                }
+
+                if (results.isNotEmpty()) {
+                    scanResults.clear()
+                    results.forEach { result ->
+                        val ssid = result.SSID ?: ""
+                        if (ssid.isNotEmpty()) {
+                            scanResults[ssid] = result
+                        }
+                    }
+
+                    val networks = scanResults.values.map { convertScanResult(it) }
+                    val max = maxResults?.toInt() ?: networks.size
+                    return networks.take(max)
+                }
+
+                Thread.sleep(100)
+            }
+
+            Log.w("MunimWifi", "Scan timeout")
+            return emptyList()
+        } catch (e: SecurityException) {
+            Log.e("MunimWifi", "Security exception during scan", e)
+            return emptyList()
+        } catch (e: Exception) {
+            Log.e("MunimWifi", "Error scanning networks", e)
+            return emptyList()
+        }
+    }
+
+    override fun startScan(maxResults: Double?, timeout: Double?) {
+        isScanning = true
+        val manager = getWifiManager() ?: return
+
+        if (!checkLocationPermission()) {
+            Log.w("MunimWifi", "Location permission not granted")
+            isScanning = false
+            return
+        }
+
+        if (!manager.isWifiEnabled) {
+            Log.w("MunimWifi", "Wi-Fi is not enabled")
+            isScanning = false
+            return
+        }
+
+        try {
+            manager.startScan()
+        } catch (e: Exception) {
+            Log.e("MunimWifi", "Error starting scan", e)
+            isScanning = false
+        }
+    }
+
+    override fun stopScan() {
+        isScanning = false
+    }
+
+    override fun getSSIDs(): List<String> {
+        val manager = getWifiManager() ?: return emptyList()
+        val results = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            if (hasPermission(Manifest.permission.ACCESS_FINE_LOCATION)) {
+                manager.scanResults
+            } else {
+                emptyList()
+            }
+        } else {
+            manager.scanResults
+        }
+
+        return results.mapNotNull { it.SSID }.distinct()
+    }
+
+    override fun getWifiFingerprint(): com.margelo.nitro.munimwifi.WifiFingerprint {
+        val manager = getWifiManager() ?: return com.margelo.nitro.munimwifi.WifiFingerprint(
+            networks = emptyList(),
+            timestamp = System.currentTimeMillis()
+        )
+        val results = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            if (hasPermission(Manifest.permission.ACCESS_FINE_LOCATION)) {
+                manager.scanResults
+            } else {
+                emptyList()
+            }
+        } else {
+            manager.scanResults
+        }
+
+        val networks = results.map { convertScanResult(it) }
+
+        return com.margelo.nitro.munimwifi.WifiFingerprint(
+            networks = networks,
+            timestamp = System.currentTimeMillis()
+        )
+    }
+
+    override fun getRSSI(ssid: String): Double? {
+        val manager = getWifiManager() ?: return null
+        val results = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            if (hasPermission(Manifest.permission.ACCESS_FINE_LOCATION)) {
+                manager.scanResults
+            } else {
+                emptyList()
+            }
+        } else {
+            manager.scanResults
+        }
+
+        val network = results.find { it.SSID == ssid }
+        return network?.level?.toDouble()
+    }
+
+    override fun getBSSID(ssid: String): String? {
+        val manager = getWifiManager() ?: return null
+        val results = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            if (hasPermission(Manifest.permission.ACCESS_FINE_LOCATION)) {
+                manager.scanResults
+            } else {
+                emptyList()
+            }
+        } else {
+            manager.scanResults
+        }
+
+        val network = results.find { it.SSID == ssid }
+        return network?.BSSID
+    }
+
+    override fun getChannelInfo(ssid: String): com.margelo.nitro.munimwifi.ChannelInfo? {
+        val manager = getWifiManager() ?: return null
+        val results = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            if (hasPermission(Manifest.permission.ACCESS_FINE_LOCATION)) {
+                manager.scanResults
+            } else {
+                emptyList()
+            }
+        } else {
+            manager.scanResults
+        }
+
+        val network = results.find { it.SSID == ssid } ?: return null
+        val channel = getFrequencyChannel(network.frequency)
+
+        return com.margelo.nitro.munimwifi.ChannelInfo(
+            channel = channel,
+            frequency = network.frequency
+        )
+    }
+
+    override fun getNetworkInfo(ssid: String): com.margelo.nitro.munimwifi.WifiNetwork? {
+        val manager = getWifiManager() ?: return null
+        val results = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            if (hasPermission(Manifest.permission.ACCESS_FINE_LOCATION)) {
+                manager.scanResults
+            } else {
+                emptyList()
+            }
+        } else {
+            manager.scanResults
+        }
+
+        val network = results.find { it.SSID == ssid } ?: return null
+        return convertScanResult(network)
+    }
+
+    override fun addListener(eventName: String) {
+        Log.d(TAG, "Adding listener for event: $eventName")
+    }
+
+    override fun removeListeners(count: Double) {
+        Log.d(TAG, "Removing $count listeners")
+    }
+}

package/android/src/main/java/com/munimwifi/MunimWifiPackage.kt

@@ -0,0 +1,20 @@
+package com.munimwifi;
+
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.facebook.react.TurboReactPackage;
+import com.margelo.nitro.munimwifi.MunimWifiOnLoad;
+
+
+public class MunimWifiPackage : TurboReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider { emptyMap() }
+
+  companion object {
+    init {
+      MunimWifiOnLoad.initializeNative();
+    }
+  }
+}

package/ios/Bridge.h

@@ -0,0 +1,8 @@
+//
+//  Bridge.h
+//  munim-wifi
+//
+//  Created by sheehanmunim on 1/26/2026
+//
+
+#pragma once