Erste Schritte

Kompatibilität

@capgo/capacitor-device-info erfordert Capacitor 8 oder höher (@capacitor/core >=8.0.0).

Installieren

Du kannst unser KI-gestütztes Setup nutzen, um das Plugin zu installieren. Füge die Capgo Skills mit dem folgenden Befehl deinem KI-Tool hinzu:

npx skills add https://github.com/Cap-go/capgo-skills --skill capacitor-plugins

Nutze dann diesen Prompt:

Use the `capacitor-plugins` skill from `Cap-go/capgo-skills` to install the `@capgo/capacitor-device-info` plugin in my project.

Für ein manuelles Setup installiere das Package und synchronisiere die nativen Projekte:

npm install @capgo/capacitor-device-info
npx cap sync

Importieren

import { DeviceInfo } from '@capgo/capacitor-device-info';

Quickstart

import { DeviceInfo } from '@capgo/capacitor-device-info';

const result = await DeviceInfo.getInfo();
console.log(result);

Beispiel: startMonitoring

import { DeviceInfo } from '@capgo/capacitor-device-info';

const result = await DeviceInfo.startMonitoring();
console.log(result);

Beispiel: stopMonitoring

import { DeviceInfo } from '@capgo/capacitor-device-info';

const result = await DeviceInfo.stopMonitoring();
console.log(result);

Häufige Stolperfallen

• Listener: Handles beim Unmounten von Screens entfernen.
• Nativer Sync: ausführen npx cap sync nach Plugin-Upgrades.
• Single Source of Truth: Vertrauen src/definitions.ts im GitHub Repo.

Einen Snapshot lesen

const snapshot = await DeviceInfo.getInfo();

console.log(snapshot.cpu.cores);
console.log(snapshot.memory.usedPercent);
console.log(snapshot.storage.freeBytes);
console.log(snapshot.sensors?.pressureHpa);

cpu.usagePercent basiert auf Deltas. Der erste native Sample kann es weglassen; rufe getInfo() es später erneut auf oder nutze Monitoring, um nach dem zweiten Sample tatsächliche CPU-Auslastungswerte zu erhalten.

Updates streamen

const handle = await DeviceInfo.addListener('deviceInfoUpdate', (sample) => {
  console.log(sample.sequence, sample.elapsedMs);
  console.log(sample.cpu.usagePercent);
  console.log(sample.sensors?.readings);
});

const session = await DeviceInfo.startMonitoring({
  intervalMs: 1000,
  emitImmediately: true,
});

console.log(session.intervalMs, session.startedAt);

Monitoring-Verhalten

• intervalMs ist standardmäßig 1000 Millisekunden. Werte unter 250 Millisekunden werden begrenzt auf 250.
• emitImmediately ist standardmäßig true.
• Setzen Sie durationMs oder sampleCount um das Monitoring automatisch zu stoppen.
• Aufruf startMonitoring() startet die Session mit den neuen Optionen neu, solange das Monitoring aktiv ist.
• Jedes deviceInfoUpdate enthält eine einsbasierte sequence, die Session- startedAt Zeitstempel und elapsedMs.

Updates stoppen und Listener entfernen

await DeviceInfo.stopMonitoring();
await handle.remove();

// Or remove every listener registered on this plugin:
await DeviceInfo.removeAllListeners();

Monitoring-Status prüfen

const state = await DeviceInfo.isMonitoring();

if (state.monitoring) {
  console.log(state.samplesEmitted);
}

Sensor-Felder einbinden

const { sensors, cpu, gpu } = await DeviceInfo.getInfo();

console.log(cpu.temperatureCelsius);
console.log(gpu?.temperatureCelsius);
console.log(sensors?.batteryTemperatureCelsius);
console.log(sensors?.ambientTemperatureCelsius);
console.log(sensors?.relativeHumidityPercent);
console.log(sensors?.pressureHpa);
console.log(sensors?.illuminanceLux);
console.log(sensors?.proximityDistanceCm);
console.log(sensors?.availableSensors);

Sensor-Felder sind optional. Sie sind nur vorhanden, wenn das Gerät, das OS und die App-Sandbox diese Metrik bereitstellen.

Plattform-Hinweise

• iOS benötigt keine Berechtigungen für die bereitgestellten Metriken. Es meldet, ob CoreMotion-Sensoren verfügbar sind, aber nicht die rohe CPU- oder GPU-Temperatur.
• Android benötigt keine Berechtigungen für die bereitgestellten Metriken. CPU- und GPU-Temperaturen sind Best-Effort-Auslesungen aus den Thermal Zones.
• Web-Support erfolgt nach bestem Wissen und Gewissen; Sensordaten können leer sein, da Browser native Sensoren nicht konsistent bereitstellen.

API-Referenz

Methode	Rückgabewert	Notizen
getInfo()	Promise<DeviceInfoSnapshot>	Liest einen Snapshot aus.
startMonitoring(options?)	Promise<StartMonitoringResult>	Startet periodische Snapshots oder startet eine aktive Session mit neuen Optionen neu.
stopMonitoring()	Promise<StopMonitoringResult>	Stoppt die aktive Session.
isMonitoring()	Promise<MonitoringState>	Gibt den aktuellen Session-Status zurück.
addListener('deviceInfoUpdate', listener)	Promise<PluginListenerHandle>	Registriert einen Listener für periodische Snapshots.
removeAllListeners()	Promise<void>	Entfernt alle beim Plugin registrierten Listener.
getPluginVersion()	Promise<PluginVersionResult>	Liest die Version des nativen Plugins.

PluginListenerHandle wird von Capacitor bereitgestellt und hat remove() um diesen einzelnen Listener zu entfernen.

Snapshot-Typen

interface CpuInfo {
  cores: number;
  activeCores?: number;
  architecture?: string;
  model?: string;
  usagePercent?: number | null;
  maxFrequencyHz?: number;
  temperatureCelsius?: number;
}

interface MemoryInfo {
  totalBytes?: number;
  freeBytes?: number;
  usedBytes?: number;
  usedPercent?: number;
  appUsedBytes?: number;
  appLimitBytes?: number;
  lowMemory?: boolean;
  pressure?: 'normal' | 'warning' | 'critical' | 'unknown';
}

interface StorageInfo {
  totalBytes?: number;
  freeBytes?: number;
  usedBytes?: number;
  usedPercent?: number;
}

interface GpuInfo {
  api?: 'metal' | 'opengl' | 'webgl' | 'unknown';
  vendor?: string;
  renderer?: string;
  version?: string;
  maxTextureSize?: number;
  temperatureCelsius?: number;
}

type ThermalState = 'nominal' | 'fair' | 'serious' | 'critical' | 'unknown';

interface DeviceInfoSnapshot {
  timestamp: number;
  platform: 'ios' | 'android' | 'web';
  cpu: CpuInfo;
  memory: MemoryInfo;
  storage: StorageInfo;
  gpu?: GpuInfo;
  thermalState?: ThermalState;
  lowPowerMode?: boolean;
  sensors?: OnboardSensorsInfo;
}

Größenangaben sind in Bytes, maxFrequencyHz ist Hertz, und Temperaturwerte sind in Celsius. usagePercent kann null bis die Plattform genügend Samples zur Berechnung hat.

Sensortypen

interface OnboardSensorDescriptor {
  type: string;
  name?: string;
  vendor?: string;
  platformType?: number;
  maximumRange?: number;
  resolution?: number;
  powerMilliamp?: number;
  minDelayMicroseconds?: number;
  wakeUp?: boolean;
}

interface OnboardSensorReading {
  type: string;
  unit: string;
  value: number;
  name?: string;
  timestamp?: number;
}

interface OnboardSensorsInfo {
  availableSensors?: OnboardSensorDescriptor[];
  readings?: OnboardSensorReading[];
  batteryTemperatureCelsius?: number;
  ambientTemperatureCelsius?: number;
  relativeHumidityPercent?: number;
  pressureHpa?: number;
  illuminanceLux?: number;
  proximityDistanceCm?: number;
}

Zeitstempel von Sensorwerten liegen in Unix-Epoch-Millisekunden vor. Gängige Einheiten sind Celsius, Prozent, hPa, Lux und Zentimeter.

Monitoring-Typen

interface MonitoringOptions {
  intervalMs?: number;
  durationMs?: number;
  sampleCount?: number;
  emitImmediately?: boolean;
}

interface StartMonitoringResult {
  monitoring: boolean;
  intervalMs: number;
  startedAt: number;
}

interface StopMonitoringResult {
  monitoring: boolean;
}

interface MonitoringState {
  monitoring: boolean;
  intervalMs?: number;
  startedAt?: number;
  samplesEmitted?: number;
}

interface DeviceInfoUpdate extends DeviceInfoSnapshot {
  sequence: number;
  startedAt: number;
  elapsedMs: number;
}

interface PluginVersionResult {
  version: string;
}

startedAt, timestamp, und elapsedMs sind Millisekunden. sequence beginnt bei 1 für jede Monitoring-Session.

Single Source of Truth

Diese Referenz orientiert sich an der öffentlichen API im Plugin src/definitions.tsDiese Seite aktualisieren, wenn sich die Quelle ändert.

Weiter geht's nach Getting Started

Wenn du es nutzt Erste Schritte Verbinden Sie das Gerät für die Geräte-Diagnose mit @capgo/capacitor-device-info für die Übersicht, Verwendung von @capgo/capacitor-device-info für die Tutorial-Seite, @capgo/capacitor-barometer für präzise Druckmessungen und @capgo/capacitor-light-sensor für gezielte Lichtsensor-Messwerte.