@capgo/capacitor-device-info 8.0.0

package/ios/Sources/DeviceInfoPlugin/DeviceInfo.swift

@@ -0,0 +1,279 @@
+import CoreMotion
+import Darwin
+import Foundation
+import Metal
+
+@objc public class DeviceInfo: NSObject {
+    private var previousCpuLoad: host_cpu_load_info?
+
+    @objc public func getInfo() -> [String: Any] {
+        var result: [String: Any] = [
+            "timestamp": currentTimestamp(),
+            "platform": "ios",
+            "cpu": cpuInfo(),
+            "memory": memoryInfo(),
+            "storage": storageInfo(),
+            "thermalState": thermalState(),
+            "lowPowerMode": ProcessInfo.processInfo.isLowPowerModeEnabled,
+            "sensors": onboardSensorsInfo()
+        ]
+
+        if let gpu = gpuInfo() {
+            result["gpu"] = gpu
+        }
+
+        return result
+    }
+
+    @objc public func getPluginVersion() -> String {
+        return "8.0.0"
+    }
+
+    private func cpuInfo() -> [String: Any] {
+        var info: [String: Any] = [
+            "cores": ProcessInfo.processInfo.processorCount,
+            "activeCores": ProcessInfo.processInfo.activeProcessorCount,
+            "architecture": cpuArchitecture(),
+            "model": modelIdentifier()
+        ]
+
+        if let usagePercent = cpuUsagePercent() {
+            info["usagePercent"] = usagePercent
+        }
+
+        return info
+    }
+
+    private func cpuUsagePercent() -> Double? {
+        guard let currentLoad = currentCpuLoad() else {
+            return nil
+        }
+
+        defer {
+            previousCpuLoad = currentLoad
+        }
+
+        guard let previousLoad = previousCpuLoad else {
+            return nil
+        }
+
+        let user = tickDelta(currentLoad.cpu_ticks.0, previousLoad.cpu_ticks.0)
+        let system = tickDelta(currentLoad.cpu_ticks.1, previousLoad.cpu_ticks.1)
+        let idle = tickDelta(currentLoad.cpu_ticks.2, previousLoad.cpu_ticks.2)
+        let nice = tickDelta(currentLoad.cpu_ticks.3, previousLoad.cpu_ticks.3)
+        let total = user + system + idle + nice
+
+        guard total > 0 else {
+            return nil
+        }
+
+        return clampPercent((Double(total - idle) / Double(total)) * 100)
+    }
+
+    private func currentCpuLoad() -> host_cpu_load_info? {
+        var cpuInfo = host_cpu_load_info()
+        var count = mach_msg_type_number_t(MemoryLayout<host_cpu_load_info>.stride / MemoryLayout<integer_t>.stride)
+
+        let result = withUnsafeMutablePointer(to: &cpuInfo) {
+            $0.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
+                host_statistics(mach_host_self(), HOST_CPU_LOAD_INFO, $0, &count)
+            }
+        }
+
+        return result == KERN_SUCCESS ? cpuInfo : nil
+    }
+
+    private func memoryInfo() -> [String: Any] {
+        let totalBytes = Double(ProcessInfo.processInfo.physicalMemory)
+        var info: [String: Any] = [
+            "totalBytes": totalBytes,
+            "pressure": "normal"
+        ]
+
+        if let vmInfo = vmMemoryInfo(totalBytes: totalBytes) {
+            info.merge(vmInfo) { _, new in new }
+        }
+
+        if let appUsedBytes = appMemoryBytes() {
+            info["appUsedBytes"] = appUsedBytes
+        }
+
+        return info
+    }
+
+    private func vmMemoryInfo(totalBytes: Double) -> [String: Any]? {
+        var stats = vm_statistics64()
+        var count = mach_msg_type_number_t(MemoryLayout<vm_statistics64_data_t>.stride / MemoryLayout<integer_t>.stride)
+
+        let result = withUnsafeMutablePointer(to: &stats) {
+            $0.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
+                host_statistics64(mach_host_self(), HOST_VM_INFO64, $0, &count)
+            }
+        }
+
+        guard result == KERN_SUCCESS else {
+            return nil
+        }
+
+        var pageSize: vm_size_t = 0
+        host_page_size(mach_host_self(), &pageSize)
+        let pageBytes = Double(pageSize)
+        let freeBytes = Double(UInt64(stats.free_count) + UInt64(stats.inactive_count)) * pageBytes
+        let usedBytes = max(totalBytes - freeBytes, 0)
+
+        return [
+            "freeBytes": freeBytes,
+            "usedBytes": usedBytes,
+            "usedPercent": percent(usedBytes, totalBytes)
+        ]
+    }
+
+    private func appMemoryBytes() -> Double? {
+        var info = task_vm_info_data_t()
+        var count = mach_msg_type_number_t(MemoryLayout<task_vm_info_data_t>.stride / MemoryLayout<natural_t>.stride)
+
+        let result = withUnsafeMutablePointer(to: &info) {
+            $0.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
+                task_info(mach_task_self_, task_flavor_t(TASK_VM_INFO), $0, &count)
+            }
+        }
+
+        return result == KERN_SUCCESS ? Double(info.phys_footprint) : nil
+    }
+
+    private func storageInfo() -> [String: Any] {
+        let url = URL(fileURLWithPath: NSHomeDirectory())
+
+        do {
+            let values = try url.resourceValues(forKeys: [
+                .volumeTotalCapacityKey,
+                .volumeAvailableCapacityKey,
+                .volumeAvailableCapacityForImportantUsageKey
+            ])
+            let totalBytes = values.volumeTotalCapacity.map(Double.init)
+            let importantFreeBytes = values.volumeAvailableCapacityForImportantUsage.map(Double.init)
+            let freeBytes = importantFreeBytes ?? values.volumeAvailableCapacity.map(Double.init)
+            var info: [String: Any] = [:]
+
+            if let totalBytes {
+                info["totalBytes"] = totalBytes
+            }
+            if let freeBytes {
+                info["freeBytes"] = freeBytes
+            }
+            if let totalBytes, let freeBytes {
+                let usedBytes = max(totalBytes - freeBytes, 0)
+                info["usedBytes"] = usedBytes
+                info["usedPercent"] = percent(usedBytes, totalBytes)
+            }
+
+            return info
+        } catch {
+            return [:]
+        }
+    }
+
+    private func gpuInfo() -> [String: Any]? {
+        guard let device = MTLCreateSystemDefaultDevice() else {
+            return nil
+        }
+
+        return [
+            "api": "metal",
+            "vendor": "Apple",
+            "renderer": device.name
+        ]
+    }
+
+    private func onboardSensorsInfo() -> [String: Any] {
+        let motionManager = CMMotionManager()
+        var availableSensors: [[String: Any]] = []
+
+        if motionManager.isAccelerometerAvailable {
+            availableSensors.append(sensorDescriptor(type: "accelerometer", name: "Accelerometer"))
+        }
+        if motionManager.isGyroAvailable {
+            availableSensors.append(sensorDescriptor(type: "gyroscope", name: "Gyroscope"))
+        }
+        if motionManager.isMagnetometerAvailable {
+            availableSensors.append(sensorDescriptor(type: "magnetometer", name: "Magnetometer"))
+        }
+        if motionManager.isDeviceMotionAvailable {
+            availableSensors.append(sensorDescriptor(type: "deviceMotion", name: "Device Motion"))
+        }
+        if CMAltimeter.isRelativeAltitudeAvailable() {
+            availableSensors.append(sensorDescriptor(type: "barometer", name: "Barometer"))
+        }
+
+        return [
+            "availableSensors": availableSensors,
+            "readings": []
+        ]
+    }
+
+    private func sensorDescriptor(type: String, name: String) -> [String: Any] {
+        return [
+            "type": type,
+            "name": name,
+            "vendor": "Apple"
+        ]
+    }
+
+    private func thermalState() -> String {
+        switch ProcessInfo.processInfo.thermalState {
+        case .nominal:
+            return "nominal"
+        case .fair:
+            return "fair"
+        case .serious:
+            return "serious"
+        case .critical:
+            return "critical"
+        @unknown default:
+            return "unknown"
+        }
+    }
+
+    private func modelIdentifier() -> String {
+        var systemInfo = utsname()
+        uname(&systemInfo)
+
+        return withUnsafeBytes(of: &systemInfo.machine) { rawBuffer in
+            let pointer = rawBuffer.bindMemory(to: CChar.self).baseAddress
+            return pointer.map { String(cString: $0) } ?? "unknown"
+        }
+    }
+
+    private func cpuArchitecture() -> String {
+        #if arch(arm64)
+        return "arm64"
+        #elseif arch(arm)
+        return "arm"
+        #elseif arch(x86_64)
+        return "x86_64"
+        #elseif arch(i386)
+        return "i386"
+        #else
+        return "unknown"
+        #endif
+    }
+
+    private func currentTimestamp() -> Double {
+        return Date().timeIntervalSince1970 * 1000
+    }
+
+    private func tickDelta(_ current: natural_t, _ previous: natural_t) -> UInt64 {
+        return UInt64(current >= previous ? current - previous : 0)
+    }
+
+    private func percent(_ used: Double, _ total: Double) -> Double {
+        guard total > 0 else {
+            return 0
+        }
+        return clampPercent((used / total) * 100)
+    }
+
+    private func clampPercent(_ value: Double) -> Double {
+        return min(max(value, 0), 100)
+    }
+}

package/ios/Sources/DeviceInfoPlugin/DeviceInfoPlugin.swift

@@ -0,0 +1,157 @@
+import Capacitor
+import Foundation
+
+@objc(DeviceInfoPlugin)
+public class DeviceInfoPlugin: CAPPlugin, CAPBridgedPlugin {
+    private let pluginVersion = "8.0.0"
+    private let defaultIntervalMs = 1000
+    private let minimumIntervalMs = 250
+
+    public let identifier = "DeviceInfoPlugin"
+    public let jsName = "DeviceInfo"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "getInfo", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "startMonitoring", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopMonitoring", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "isMonitoring", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "removeAllListeners", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getPluginVersion", returnType: CAPPluginReturnPromise)
+    ]
+
+    private let implementation = DeviceInfo()
+    private var timer: Timer?
+    private var intervalMs: Int?
+    private var startedAt: Double?
+    private var sampleLimit: Int?
+    private var stopAt: Double?
+    private var samplesEmitted = 0
+
+    @objc func getInfo(_ call: CAPPluginCall) {
+        call.resolve(implementation.getInfo())
+    }
+
+    @objc func startMonitoring(_ call: CAPPluginCall) {
+        stopMonitoringInternal()
+
+        let effectiveIntervalMs = max(call.getInt("intervalMs") ?? defaultIntervalMs, minimumIntervalMs)
+        let now = currentTimestamp()
+        intervalMs = effectiveIntervalMs
+        startedAt = now
+        samplesEmitted = 0
+        sampleLimit = positiveInt(call.getInt("sampleCount"))
+
+        if let durationMs = positiveDouble(call.getDouble("durationMs")) {
+            stopAt = now + durationMs
+        }
+
+        if call.getBool("emitImmediately") != false {
+            emitSample()
+        }
+
+        if startedAt != nil {
+            let timer = Timer(timeInterval: Double(effectiveIntervalMs) / 1000, repeats: true) { [weak self] _ in
+                self?.emitSample()
+            }
+            RunLoop.main.add(timer, forMode: .common)
+            self.timer = timer
+        }
+
+        call.resolve([
+            "monitoring": startedAt != nil,
+            "intervalMs": effectiveIntervalMs,
+            "startedAt": now
+        ])
+    }
+
+    @objc func stopMonitoring(_ call: CAPPluginCall) {
+        stopMonitoringInternal()
+        call.resolve(["monitoring": false])
+    }
+
+    @objc func isMonitoring(_ call: CAPPluginCall) {
+        var result: [String: Any] = [
+            "monitoring": timer != nil
+        ]
+
+        if let intervalMs {
+            result["intervalMs"] = intervalMs
+        }
+        if let startedAt {
+            result["startedAt"] = startedAt
+        }
+        if timer != nil {
+            result["samplesEmitted"] = samplesEmitted
+        }
+
+        call.resolve(result)
+    }
+
+    @objc override public func removeAllListeners(_ call: CAPPluginCall) {
+        super.removeAllListeners(call)
+    }
+
+    @objc func getPluginVersion(_ call: CAPPluginCall) {
+        call.resolve(["version": pluginVersion])
+    }
+
+    deinit {
+        stopMonitoringInternal()
+    }
+
+    private func emitSample() {
+        guard let startedAt else {
+            return
+        }
+
+        var sample = implementation.getInfo()
+        samplesEmitted += 1
+        let timestamp = sample["timestamp"] as? Double ?? currentTimestamp()
+        sample["sequence"] = samplesEmitted
+        sample["startedAt"] = startedAt
+        sample["elapsedMs"] = timestamp - startedAt
+
+        notifyListeners("deviceInfoUpdate", data: sample)
+
+        if shouldStopMonitoring() {
+            stopMonitoringInternal()
+        }
+    }
+
+    private func shouldStopMonitoring() -> Bool {
+        if let sampleLimit, samplesEmitted >= sampleLimit {
+            return true
+        }
+        if let stopAt, currentTimestamp() >= stopAt {
+            return true
+        }
+        return false
+    }
+
+    private func stopMonitoringInternal() {
+        timer?.invalidate()
+        timer = nil
+        intervalMs = nil
+        startedAt = nil
+        sampleLimit = nil
+        stopAt = nil
+        samplesEmitted = 0
+    }
+
+    private func positiveInt(_ value: Int?) -> Int? {
+        guard let value, value > 0 else {
+            return nil
+        }
+        return value
+    }
+
+    private func positiveDouble(_ value: Double?) -> Double? {
+        guard let value, value > 0 else {
+            return nil
+        }
+        return value
+    }
+
+    private func currentTimestamp() -> Double {
+        return Date().timeIntervalSince1970 * 1000
+    }
+}

package/ios/Tests/DeviceInfoPluginTests/DeviceInfoTests.swift

@@ -0,0 +1,22 @@
+import XCTest
+@testable import DeviceInfoPlugin
+
+class DeviceInfoTests: XCTestCase {
+    func testGetInfo() {
+        let implementation = DeviceInfo()
+        let result = implementation.getInfo()
+
+        XCTAssertEqual("ios", result["platform"] as? String)
+        XCTAssertNotNil(result["cpu"])
+        XCTAssertNotNil(result["memory"])
+        XCTAssertNotNil(result["storage"])
+        XCTAssertNotNil(result["sensors"])
+    }
+
+    func testGetPluginVersion() {
+        let implementation = DeviceInfo()
+        let result = implementation.getPluginVersion()
+
+        XCTAssertEqual("8.0.0", result)
+    }
+}

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@capgo/capacitor-device-info",
+  "version": "8.0.0",
+  "description": "Capacitor plugin for reading CPU, memory, GPU, storage, and onboard sensor metrics.",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "ios/Sources",
+    "ios/Tests",
+    "Package.swift",
+    "CapgoCapacitorDeviceInfo.podspec"
+  ],
+  "author": "Cap-go <contact@capgo.app>",
+  "license": "MPL-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Cap-go/capacitor-device-info.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Cap-go/capacitor-device-info/issues"
+  },
+  "homepage": "https://capgo.app/docs/plugins/device-info/",
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "device",
+    "metrics",
+    "cpu",
+    "memory",
+    "gpu",
+    "storage",
+    "sensors",
+    "temperature",
+    "barometer",
+    "capgo"
+  ],
+  "scripts": {
+    "verify": "bun run verify:ios && bun run verify:android && bun run verify:web",
+    "verify:ios": "xcodebuild -scheme CapgoCapacitorDeviceInfo -destination generic/platform=iOS",
+    "verify:android": "cd android && ./gradlew clean build test && cd ..",
+    "verify:web": "bun run build",
+    "lint": "bun run eslint && bun run prettier -- --check && bun run swiftlint -- lint",
+    "fmt": "bun run eslint -- --fix && bun run prettier -- --write && bun run swiftlint -- --fix --format",
+    "eslint": "eslint \"**/*.ts\"",
+    "prettier": "prettier-pretty-check \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api DeviceInfoPlugin --output-readme README.md --output-json dist/docs.json",
+    "build": "bun run clean && bun run docgen && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "prepublishOnly": "bun run build",
+    "check:wiring": "node scripts/check-capacitor-plugin-wiring.mjs"
+  },
+  "devDependencies": {
+    "@capacitor/android": "^8.3.4",
+    "@capacitor/cli": "^8.3.4",
+    "@capacitor/core": "^8.3.4",
+    "@capacitor/docgen": "^0.3.1",
+    "@capacitor/ios": "^8.3.4",
+    "@eslint/js": "^10.0.1",
+    "@ionic/prettier-config": "^4.0.0",
+    "@ionic/swiftlint-config": "^2.0.0",
+    "@types/node": "^25.9.1",
+    "eslint": "^10.4.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import": "^2.32.0",
+    "husky": "^9.1.7",
+    "prettier": "^3.8.3",
+    "prettier-plugin-java": "^2.9.2",
+    "prettier-pretty-check": "^0.2.0",
+    "rimraf": "^6.1.3",
+    "rollup": "^4.60.4",
+    "swiftlint": "^2.0.0",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.59.4"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=8.0.0"
+  },
+  "prettier": "@ionic/prettier-config",
+  "swiftlint": "@ionic/swiftlint-config",
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  }
+}