let package = Package(
    name: "my-package",
    products: [
        .library(name: "MyProduct", targets: ["MyTarget"]),
    ],
    dependencies: [
        .package(url: "https://source.skip.dev/skip-device.git", "0.0.0"..<"2.0.0"),
    ],
    targets: [
        .target(name: "MyTarget", dependencies: [
            .product(name: "SkipDevice", package: "skip-device")
        ])
    ]
)

let provider = SomeProvider()
provider.updateInterval = 0.1 // optional, in seconds
do {
    for try await event in provider.monitor() {
        // process event
    }
} catch {
    // handle error
}

import SkipDevice
let isReachable = NetworkReachability.isNetworkReachable

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

import SkipDevice
let identity = DeviceIdentity.current
print(identity.name ?? "Unnamed device")
print(identity.model ?? "Unknown model")

import SkipDevice
let provider = LocationProvider()
let location = try await provider.fetchCurrentLocation()
print("lat: \(location.latitude), lon: \(location.longitude), alt: \(location.altitude)")

import SwiftUI
import SkipKit // for PermissionManager
import SkipDevice
struct LocationView: View {
    @State var event: LocationEvent?
    @State var errorMessage: String?
    var body: some View {
        VStack {
            if let event = event {
                Text("Latitude: \(event.latitude)")
                Text("Longitude: \(event.longitude)")
                Text("Altitude: \(event.altitude) m")
                Text("Speed: \(event.speed) m/s")
                Text("Course: \(event.course)")
                Text("Accuracy: \(event.horizontalAccuracy) m")
            } else if let errorMessage = errorMessage {
                Text(errorMessage).foregroundStyle(.red)
            } else {
                ProgressView()
            }
        }
        .task {
            let status = await PermissionManager.requestLocationPermission(precise: true, always: false)
            guard status.isAuthorized == true else {
                errorMessage = "Location permission denied"
                return
            }
            let provider = LocationProvider()
            do {
                for try await event in provider.monitor() {
                    self.event = event
                }
            } catch {
                errorMessage = "\(error)"
            }
        }
    }
}

INFOPLIST_KEY_NSLocationWhenInUseUsageDescription = "This app uses your location to …"

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

import SkipDevice
let provider = ApplicationRuntimeProvider()
Task {
    for await event in provider.monitorLifecycle() {
        print("event: \(event.kind.rawValue), phase: \(event.phase.rawValue)")
    }
}
Task {
    for await event in provider.monitorMemoryPressure() {
        print("memory pressure: \(event.level.rawValue)")
    }
}

import SkipDevice
let identifier = try await BackgroundActivity.begin(BackgroundActivityRequest(
    name: "Syncing media",
    reason: BackgroundActivityReason.localNetworkTransfer,
    detail: "Keeping the transfer active"
))
await performTransfer()
await BackgroundActivity.end(identifier)

<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
<uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
<uses-permission android:name="android.permission.FOREGROUND_SERVICE_CONNECTED_DEVICE" />
<uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROCESSING" />
<application>
    <service
        android:name="skip.device.BackgroundActivityService"
        android:exported="false"
        android:foregroundServiceType="dataSync|mediaProcessing|connectedDevice|shortService" />
</application>

INFOPLIST_KEY_NSMotionUsageDescription = "This app uses motion sensors to …"

import SwiftUI
import SkipDevice
struct AccelerometerView: View {
    @State var event: AccelerometerEvent?
    var body: some View {
        VStack {
            if let event = event {
                Text("X: \(event.x) G")
                Text("Y: \(event.y) G")
                Text("Z: \(event.z) G")
            }
        }
        .task {
            let provider = AccelerometerProvider()
            guard provider.isAvailable else { return }
            provider.updateInterval = 0.1
            do {
                for try await event in provider.monitor() {
                    self.event = event
                }
            } catch {
                logger.error("accelerometer error: \(error)")
            }
        }
    }
}

import SwiftUI
import SkipDevice
struct GyroscopeView: View {
    @State var event: GyroscopeEvent?
    var body: some View {
        VStack {
            if let event = event {
                Text("X: \(event.x) rad/s")
                Text("Y: \(event.y) rad/s")
                Text("Z: \(event.z) rad/s")
            }
        }
        .task {
            let provider = GyroscopeProvider()
            guard provider.isAvailable else { return }
            provider.updateInterval = 0.1
            do {
                for try await event in provider.monitor() {
                    self.event = event
                }
            } catch {
                logger.error("gyroscope error: \(error)")
            }
        }
    }
}

import SwiftUI
import SkipDevice
struct MagnetometerView: View {
    @State var event: MagnetometerEvent?
    var heading: Double {
        guard let event = event else { return 0 }
        let angle = atan2(event.y, event.x) * 180.0 / .pi
        return angle < 0 ? angle + 360 : angle
    }
    var body: some View {
        VStack {
            if let event = event {
                Text("X: \(event.x) uT")
                Text("Y: \(event.y) uT")
                Text("Z: \(event.z) uT")
                Text("Heading: \(heading)")
            }
        }
        .task {
            let provider = MagnetometerProvider()
            guard provider.isAvailable else { return }
            provider.updateInterval = 0.1
            do {
                for try await event in provider.monitor() {
                    self.event = event
                }
            } catch {
                logger.error("magnetometer error: \(error)")
            }
        }
    }
}

import SwiftUI
import SkipDevice
struct BarometerView: View {
    @State var event: BarometerEvent?
    var body: some View {
        VStack {
            if let event = event {
                Text("Pressure: \(event.pressure) kPa")
                Text("Relative altitude: \(event.relativeAltitude) m")
            }
        }
        .task {
            let provider = BarometerProvider()
            guard provider.isAvailable else { return }
            provider.updateInterval = 0.5
            do {
                for try await event in provider.monitor() {
                    self.event = event
                }
            } catch {
                logger.error("barometer error: \(error)")
            }
        }
    }
}

<uses-feature android:name="android.hardware.sensor.barometer" android:required="false" />