Anleitung

Kompatibilität

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

Installieren

Sie können unsere AI-gestützte Einrichtung verwenden, um das Plugin zu installieren. Fügen Sie den Capgo-Fähigkeiten Ihrer AI-Anwendung mit folgendem Befehl hinzu:

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

Verwenden Sie dann folgende Anweisung:

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

Für eine manuelle Einrichtung installieren Sie das Paket und synchronisieren Sie die native Projekte:

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

Importieren

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

Eine 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 ist delta-basiert. Die erste native Probe kann es überspringen; rufen Sie getInfo() wieder später oder verwenden Sie die Überwachung, um nach der zweiten Probe den mit Belegung befüllten CPU-Aufruf zu erhalten.

Aktualisierungen 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);

Überwachungsverhalten

• intervalMs standardmäßig 1000 Millisekunden. Werte unter 250 Millisekunden werden auf 250.
• emitImmediately standardmäßig true.
• Setzen durationMs oder sampleCount Wählen Sie, ob Sie die Überwachung automatisch beenden möchten.
• Anrufen startMonitoring() während die Überwachung aktiv ist, startet die Sitzung mit den neuen Optionen neu.
• Jedes deviceInfoUpdate einschließt eine einsbezogene sequence, die Sitzungstimestamp, und startedAt Beenden Sie Updates und entfernen Sie Listener elapsedMs.

Abschnitt mit dem Titel „Beenden Sie Updates und entfernen Sie Listener“

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

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

Überprüfen Sie den Überwachungsstatus

const state = await DeviceInfo.isMonitoring();

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

Sensorfelder einrichten

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);

Sensorfelder sind optional. Sie sind nur dann vorhanden, wenn das Gerät, Betriebssystem und die Anwendungs-App-Isolierung dieses Metrik ausgeben.

Plattformhinweise

• Für iOS sind keine Berechtigungen erforderlich, um die ausgestellten Metriken zu überprüfen. Es wird die Verfügbarkeit von CoreMotion-Sensoren gemeldet, aber keine Rohwerte für CPU- oder GPU-Temperatur.
• Für Android sind keine Berechtigungen erforderlich, um die ausgestellten Metriken zu überprüfen. CPU- und GPU-Temperaturwerte sind bestmögliche thermische-Zonen-Lesungen.
• Die Unterstützung von Web ist bestmöglich und meldet leerere aufgebaute Sensorarrays, da Browser native Gerätesensoren nicht konsistent ausgeben.

API Referenz

Methode	Rückgabewerte	Hinweise
getInfo()	Promise<DeviceInfoSnapshot>	Einen Snapshot liest.
startMonitoring(options?)	Promise<StartMonitoringResult>	Periodische Snapshots startet, oder eine aktive Sitzung mit neuen Optionen neu startet.
stopMonitoring()	Promise<StopMonitoringResult>	Die aktive Sitzung beendet.
isMonitoring()	Promise<MonitoringState>	Aktuelle Sitzungszustand zurückgibt.
addListener('deviceInfoUpdate', listener)	Promise<PluginListenerHandle>	Ein periodischer Snapshot-Listener registriert.
removeAllListeners()	Promise<void>	Alle auf dem Plugin registrierten Listener entfernt.
getPluginVersion()	Promise<PluginVersionResult>	Die native Pluginversion liest.

PluginListenerHandle ist durch Capacitor und hat remove() für die Entfernung dieses einzelnen Hörers.

Schnappschuss-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;
}

Die Größen sind Byte, maxFrequencyHz ist Hertz und die Temperaturwerte sind Celsius. usagePercent werden null bis die Plattform genug Proben hat, um es zu berechnen.

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;
}

Die Zeitstempel der Sensordaten sind in Millisekunden als Unix-Epoche angegeben. Gemeinsame Einheiten sind Celsius, Prozent, hPa, Lux und Zentimeter.

Überwachungstypen

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 jeder Überwachungssitzung.

Wahrheitsquelle

Diese Referenz folgt der öffentlichen API im Plugin- src/definitions.tsaktualisieren Sie diese Seite, wenn sich diese Quelle ändert.

Weiter zum Erste Schritt

Wenn Sie Erste Schritt für Gerätediagnosen verwenden, verbinden Sie es mit @capgo/capacitor-geräte-info für eine Übersicht Verwendung von @capgo/capacitor-geräte-info für die Anleitung Verwendung von @capgo/capacitor-barometer für fokussierte Druckmessungen und Verwendung von @capgo/capacitor-licht-sensor für konzentrierte Lichtsensorwerte.