`typescript
import { Wifi } from '@tolutronics/capacitor-wifi';
import { Capacitor } from '@capacitor/core';

// Platform check helper
const isNativePlatform = () => {
return Capacitor.isNativePlatform();
};

// Check and request permissions first
const checkWifiPermissions = async () => {
if (!isNativePlatform()) {
console.warn('WiFi operations are only available on native platforms');
return false;
}

const status = await Wifi.checkPermissions();

if (status.LOCATION !== 'granted' || status.NETWORK !== 'granted') {
const result = await Wifi.requestPermissions();
return result.LOCATION === 'granted' && result.NETWORK === 'granted';
}

return true;
};
`

`typescript
const scanForNetworks = async () => {
try {
const hasPermissions = await checkWifiPermissions();
if (!hasPermissions) {
console.error('WiFi permissions not granted');
return;
}

const result = await Wifi.scanWifi();
console.log('Available networks:', result.wifis);

// Display networks to user
result.wifis.forEach(wifi => {
console.log(SSID: ${wifi.ssid}, Signal: ${wifi.level}, Current: ${wifi.isCurrentWifi});
});
} catch (error) {
console.error('Failed to scan WiFi:', error);
}
};
`

`typescript
// Connect to a specific network
const connectToWifi = async (ssid: string, password: string) => {
try {
const result = await Wifi.connectToWifiBySsidAndPassword({
ssid,
password
});

if (result.wasSuccess) {
console.log('Connected successfully!', result.wifi);
}
} catch (error) {
console.error('Failed to connect:', error);
}
};

// Connect to IoT device by SSID prefix (useful for devices with dynamic names)
const connectToIoTDevice = async (devicePrefix: string, password: string) => {
try {
const result = await Wifi.connectToWifiBySsidPrefixAndPassword({
ssidPrefix: devicePrefix, // e.g., "MyCamera_"
password
});

if (result.wasSuccess) {
console.log('Connected to IoT device!', result.wifi);
}
} catch (error) {
console.error('Failed to connect to IoT device:', error);
}
};
`

`typescript
const getCurrentNetwork = async () => {
try {
const result = await Wifi.getCurrentWifi();

if (result.currentWifi) {
console.log('Current WiFi:', {
ssid: result.currentWifi.ssid,
bssid: result.currentWifi.bssid,
signal: result.currentWifi.level
});
} else {
console.log('Not connected to any WiFi network');
}
} catch (error) {
console.error('Failed to get current WiFi:', error);
}
};
`

`typescript
const setupIoTDevice = async (devicePrefix: string, devicePassword: string) => {
try {
// 1. Check permissions
const hasPermissions = await checkWifiPermissions();
if (!hasPermissions) {
throw new Error('WiFi permissions required');
}

// 2. Get current WiFi (to restore later if needed)
const currentWifi = await Wifi.getCurrentWifi();
console.log('Current network:', currentWifi.currentWifi?.ssid);

// 3. Scan for available networks
const scanResult = await Wifi.scanWifi();
const deviceNetworks = scanResult.wifis.filter(wifi =>
wifi.ssid.startsWith(devicePrefix)
);

if (deviceNetworks.length === 0) {
throw new Error(No devices found with prefix: ${devicePrefix});
}

console.log(Found ${deviceNetworks.length} device(s));

// 4. Connect to device
const connectResult = await Wifi.connectToWifiBySsidPrefixAndPassword({
ssidPrefix: devicePrefix,
password: devicePassword
});

if (!connectResult.wasSuccess) {
throw new Error('Failed to connect to device');
}

console.log('Successfully connected to device:', connectResult.wifi?.ssid);

// 5. Perform device configuration here
// ... your device setup logic ...

// 6. Disconnect from device (keeping it saved for future connections)
// await Wifi.disconnect();

// OR completely remove the device network from saved networks
// await Wifi.disconnectAndForget();

} catch (error) {
console.error('IoT setup failed:', error);
}
};

// Usage
setupIoTDevice('MyCamera_', 'device123');
`

#### disconnect() - Disconnect but Keep Network Saved
`typescript
const disconnectTemporarily = async () => {
try {
// Get current network info before disconnecting
const currentResult = await Wifi.getCurrentWifi();
if (currentResult.currentWifi) {
console.log(Disconnecting from: ${currentResult.currentWifi.ssid});

// Disconnect but keep the network configuration saved
await Wifi.disconnect();
console.log('Disconnected - network configuration preserved');

// The device can automatically reconnect to this network later
// without requiring the password again
}
} catch (error) {
console.error('Failed to disconnect:', error);
}
};
`

#### disconnectAndForget() - Disconnect and Remove Network
`typescript
const disconnectPermanently = async () => {
try {
const currentResult = await Wifi.getCurrentWifi();
if (currentResult.currentWifi) {
console.log(Removing network: ${currentResult.currentWifi.ssid});

// Disconnect and completely remove network from device
await Wifi.disconnectAndForget();
console.log('Network removed from saved networks');

// To reconnect later, user will need to enter password again
}
} catch (error) {
console.error('Failed to disconnect and forget:', error);
}
};
`

#### When to Use Each Method

Use disconnect() when:
- Testing network configurations temporarily
- Switching between networks programmatically
- Implementing network failover scenarios
- You want the device to auto-reconnect later
- Working with trusted networks that should remain saved

Use disconnectAndForget() when:
- Removing untrusted or temporary networks
- Cleaning up after IoT device configuration
- Implementing a "forget network" feature for users
- Security requires complete removal of network credentials
- Working with one-time setup networks

#### Platform Behavior Differences

Android:
- disconnect(): Disables current network but preserves configuration
- disconnectAndForget(): Removes network from saved networks entirely
- Device can auto-reconnect to networks disconnected with disconnect()

iOS:
- disconnect(): Limited functionality due to iOS restrictions
- disconnectAndForget(): Standard iOS behavior for removing network configurations
- iOS doesn't support true "disconnect without forgetting" due to platform limitations

`typescript
// Example: Smart network management
const smartDisconnect = async (networkSsid: string, shouldForget: boolean = false) => {
try {
const current = await Wifi.getCurrentWifi();

if (current.currentWifi?.ssid === networkSsid) {
if (shouldForget) {
console.log(Removing ${networkSsid} permanently);
await Wifi.disconnectAndForget();
} else {
console.log(Disconnecting from ${networkSsid} temporarily);
await Wifi.disconnect();
}
} else {
console.log(Not currently connected to ${networkSsid});
}
} catch (error) {
console.error('Disconnect operation failed:', error);
}
};

// Usage examples
smartDisconnect('TempSetupNetwork', true); // Remove setup network
smartDisconnect('HomeWiFi', false); // Disconnect but keep saved
`

`typescript
import { Wifi } from '@tolutronics/capacitor-wifi';
import { PluginListenerHandle } from '@capacitor/core';

let wifiListener: PluginListenerHandle;

const startWifiMonitoring = async () => {
try {
// Set up event listener for WiFi connection changes
wifiListener = await Wifi.addListener('wifiConnectionChange', (event) => {
console.log('WiFi connection state changed:', {
isConnected: event.isConnected,
timestamp: new Date(event.timestamp).toLocaleString(),
wifi: event.wifi
});

if (event.isConnected && event.wifi) {
console.log(Connected to: ${event.wifi.ssid} (${event.wifi.bssid}));
console.log(Signal strength: ${event.wifi.level} dBm);
} else {
console.log('Disconnected from WiFi network');
}

// Handle the event in your app logic
handleWifiStateChange(event);
});

console.log('WiFi monitoring started');
} catch (error) {
console.error('Failed to start WiFi monitoring:', error);
}
};

const stopWifiMonitoring = async () => {
if (wifiListener) {
await wifiListener.remove();
console.log('WiFi monitoring stopped');
}
};

// Handle WiFi state changes in your app
const handleWifiStateChange = (event) => {
if (event.isConnected) {
// Device connected to WiFi
onWifiConnected(event.wifi);
} else {
// Device disconnected from WiFi
onWifiDisconnected();
}
};

const onWifiConnected = (wifiInfo) => {
// Update UI, sync data, etc.
console.log('WiFi connected - enabling online features');
};

const onWifiDisconnected = () => {
// Handle offline state, show offline banner, etc.
console.log('WiFi disconnected - switching to offline mode');
};

// Start monitoring when app initializes
startWifiMonitoring();

// Remember to stop monitoring when the component/app is destroyed
// stopWifiMonitoring();
`

`typescript
import { useState, useEffect } from 'react';
import { Wifi, WifiConnectionStateChangeEvent } from '@tolutronics/capacitor-wifi';
import { PluginListenerHandle } from '@capacitor/core';

interface WifiState {
isConnected: boolean;
currentWifi: any | null;
connectionHistory: WifiConnectionStateChangeEvent[];
}

export const useWifiMonitoring = () => {
const [wifiState, setWifiState] = useState({
isConnected: false,
currentWifi: null,
connectionHistory: []
});

useEffect(() => {
let listener: PluginListenerHandle;

const setupWifiMonitoring = async () => {
try {
// Get initial state
const current = await Wifi.getCurrentWifi();
setWifiState(prev => ({
...prev,
isConnected: !!current.currentWifi,
currentWifi: current.currentWifi
}));

// Set up event listener
listener = await Wifi.addListener('wifiConnectionChange', (event) => {
setWifiState(prev => ({
isConnected: event.isConnected,
currentWifi: event.wifi || null,
connectionHistory: [event, ...prev.connectionHistory.slice(0, 9)] // Keep last 10 events
}));
});
} catch (error) {
console.error('Failed to setup WiFi monitoring:', error);
}
};

setupWifiMonitoring();

return () => {
if (listener) {
listener.remove();
}
};
}, []);

const refreshCurrentWifi = async () => {
try {
const result = await Wifi.getCurrentWifi();
setWifiState(prev => ({
...prev,
isConnected: !!result.currentWifi,
currentWifi: result.currentWifi
}));
} catch (error) {
console.error('Failed to refresh WiFi state:', error);
}
};

return {
...wifiState,
refreshCurrentWifi
};
};

// Usage in component
const WiFiStatusComponent = () => {
const { isConnected, currentWifi, connectionHistory } = useWifiMonitoring();

return (


`typescript
const setupIoTDeviceWithMonitoring = async (devicePrefix: string, devicePassword: string) => {
let isSetupComplete = false;

// Set up monitoring before connecting
const listener = await Wifi.addListener('wifiConnectionChange', (event) => {
if (!event.isConnected) {
console.log('Lost connection to device');
if (!isSetupComplete) {
console.log('Setup interrupted - may need to retry');
}
} else if (event.wifi?.ssid.startsWith(devicePrefix)) {
console.log(Connected to device: ${event.wifi.ssid});
} else {
console.log(Connected to different network: ${event.wifi?.ssid});
}
});

try {
// Connect to device
await Wifi.connectToWifiBySsidPrefixAndPassword({
ssidPrefix: devicePrefix,
password: devicePassword
});

// Perform device configuration
await configureDevice();
isSetupComplete = true;

console.log('Device setup completed successfully');
} catch (error) {
console.error('Device setup failed:', error);
} finally {
// Clean up listener
await listener.remove();
}
};

const configureDevice = async () => {
// Your device configuration logic here
// This might include HTTP requests to the device's local IP
return new Promise(resolve => setTimeout(resolve, 5000)); // Simulated delay
};
`

`typescript
import { Component, OnDestroy, OnInit } from '@angular/core';
import { Wifi } from '@tolutronics/capacitor-wifi';
import { PluginListenerHandle } from '@capacitor/core';

@Component({
selector: 'app-wifi-manager',
template:

async connectToNetwork(ssid: string) {
// In a real app, you'd get the password from user input
const password = prompt(Enter password for ${ssid}:);
if (!password) return;

this.loading = true;
try {
const result = await Wifi.connectToWifiBySsidAndPassword({
ssid,
password
});

if (result.wasSuccess) {
console.log('Connected successfully to:', ssid);
// Update current WiFi info
await this.getCurrentWifiStatus();
}
} catch (error) {
console.error('Failed to connect to network:', error);
} finally {
this.loading = false;
}
}

private handleWifiConnectionChange(event: any) {
if (event.isConnected && event.wifi) {
console.log(Connected to WiFi: ${event.wifi.ssid});
// Handle WiFi connected state
// e.g., enable certain features, sync data, etc.
} else {
console.log('WiFi disconnected');
// Handle WiFi disconnected state
// e.g., show offline mode, disable certain features
}
}

formatTimestamp(timestamp: number): string {
return new Date(timestamp).toLocaleTimeString();
}

private async cleanup() {
if (this.wifiListener) {
try {
await this.wifiListener.remove();
console.log('WiFi listener removed successfully');
} catch (error) {
console.error('Error removing WiFi listener:', error);
}
}
}
}
`

`typescript
import { Injectable } from '@angular/core';
import { BehaviorSubject, Observable } from 'rxjs';
import { Wifi } from '@tolutronics/capacitor-wifi';
import { PluginListenerHandle } from '@capacitor/core';

export interface WifiState {
isConnected: boolean;
currentWifi: any | null;
networks: any[];
loading: boolean;
connectionHistory: any[];
}

@Injectable({
providedIn: 'root'
})
export class WifiService {
private wifiStateSubject = new BehaviorSubject({
isConnected: false,
currentWifi: null,
networks: [],
loading: false,
connectionHistory: []
});

private wifiListener?: PluginListenerHandle;
private isInitialized = false;

constructor() {
this.initialize();
}

get wifiState$(): Observable {
return this.wifiStateSubject.asObservable();
}

get currentState(): WifiState {
return this.wifiStateSubject.value;
}

private async initialize() {
if (this.isInitialized) return;

try {
// Check and request permissions
const permissions = await Wifi.checkPermissions();
if (permissions.LOCATION !== 'granted' || permissions.NETWORK !== 'granted') {
await Wifi.requestPermissions();
}

// Get initial WiFi state
await this.refreshCurrentWifi();

// Set up event listener
this.wifiListener = await Wifi.addListener('wifiConnectionChange', (event) => {
this.handleWifiConnectionChange(event);
});

this.isInitialized = true;
console.log('WiFi service initialized');

} catch (error) {
console.error('WiFi service initialization failed:', error);
}
}

private handleWifiConnectionChange(event: any) {
const currentState = this.currentState;

// Update connection history
const newHistory = [event, ...currentState.connectionHistory.slice(0, 9)];

// Update state
this.wifiStateSubject.next({
...currentState,
isConnected: event.isConnected,
currentWifi: event.wifi || null,
connectionHistory: newHistory
});

console.log('WiFi state updated:', {
isConnected: event.isConnected,
ssid: event.wifi?.ssid
});
}

async refreshCurrentWifi(): Promise {
try {
const result = await Wifi.getCurrentWifi();
const currentState = this.currentState;

this.wifiStateSubject.next({
...currentState,
isConnected: !!result.currentWifi,
currentWifi: result.currentWifi
});
} catch (error) {
console.error('Failed to refresh current WiFi:', error);
}
}

async scanNetworks(): Promise {
const currentState = this.currentState;

// Set loading state
this.wifiStateSubject.next({
...currentState,
loading: true
});

try {
const result = await Wifi.scanWifi();

this.wifiStateSubject.next({
...this.currentState,
networks: result.wifis,
loading: false
});
} catch (error) {
console.error('Failed to scan networks:', error);

this.wifiStateSubject.next({
...this.currentState,
loading: false
});
}
}

async connectToNetwork(ssid: string, password: string): Promise {
const currentState = this.currentState;

// Set loading state
this.wifiStateSubject.next({
...currentState,
loading: true
});

try {
const result = await Wifi.connectToWifiBySsidAndPassword({
ssid,
password
});

if (result.wasSuccess) {
await this.refreshCurrentWifi();
return true;
}

return false;
} catch (error) {
console.error('Failed to connect to network:', error);
return false;
} finally {
this.wifiStateSubject.next({
...this.currentState,
loading: false
});
}
}

async connectToIoTDevice(devicePrefix: string, password: string): Promise {
const currentState = this.currentState;

this.wifiStateSubject.next({
...currentState,
loading: true
});

try {
const result = await Wifi.connectToWifiBySsidPrefixAndPassword({
ssidPrefix: devicePrefix,
password
});

if (result.wasSuccess) {
await this.refreshCurrentWifi();
return true;
}

return false;
} catch (error) {
console.error('Failed to connect to IoT device:', error);
return false;
} finally {
this.wifiStateSubject.next({
...this.currentState,
loading: false
});
}
}

async disconnect(shouldForget: boolean = false): Promise {
try {
if (shouldForget) {
await Wifi.disconnectAndForget();
} else {
await Wifi.disconnect();
}
await this.refreshCurrentWifi();
} catch (error) {
console.error('Failed to disconnect:', error);
}
}

destroy(): void {
if (this.wifiListener) {
this.wifiListener.remove();
}
}
}
`

`typescript
import { Component, OnDestroy, OnInit } from '@angular/core';
import { WifiService, WifiState } from './wifi.service';
import { Observable } from 'rxjs';

@Component({
selector: 'app-home',
template:

toggleTracking() {
this.isTracking = !this.isTracking;
// Your tracking logic here
}
}
`

`typescript
// React Hook Example
import { useState, useEffect } from 'react';
import { Wifi } from '@tolutronics/capacitor-wifi';

export const useWifi = () => {
const [networks, setNetworks] = useState([]);
const [currentWifi, setCurrentWifi] = useState(null);
const [loading, setLoading] = useState(false);

const scanNetworks = async () => {
setLoading(true);
try {
const result = await Wifi.scanWifi();
setNetworks(result.wifis);
} catch (error) {
console.error('Scan failed:', error);
} finally {
setLoading(false);
}
};

const connectToNetwork = async (ssid: string, password: string) => {
setLoading(true);
try {
await Wifi.connectToWifiBySsidAndPassword({ ssid, password });
// Refresh current WiFi info
const current = await Wifi.getCurrentWifi();
setCurrentWifi(current.currentWifi);
} catch (error) {
console.error('Connection failed:', error);
} finally {
setLoading(false);
}
};

return {
networks,
currentWifi,
loading,
scanNetworks,
connectToNetwork
};
};
`