Anleitung

Kompatibilität

@capgo/capacitor-device-info erfordert Capacitor 8 oder später (@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 KI-Tool mithilfe der folgenden Befehl hinzu:

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

Verwenden Sie dann die 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 Daten gefü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 Setzen Sie die Überwachung automatisch ab.
• Aufrufen startMonitoring() während die Überwachung aktiv ist, startet die Sitzung mit den neuen Optionen neu.
• Jedes deviceInfoUpdate einschließlich einer einbezogenen sequence, die Sitzungstimestamp, und startedAt Stoppen Sie Updates und entfernen Sie Listener. elapsedMs.

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

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

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

Überwachungsstatus überprüfen

const state = await DeviceInfo.isMonitoring();

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

Sensoren für die Einbindung 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);

Sensoren sind optional. Sie sind nur dann vorhanden, wenn das Gerät, Betriebssystem und die App-Isolierung das entsprechende Metrik freigeben.

Plattformhinweise

• Für iOS sind keine Berechtigungen erforderlich, um die freigegebenen Metriken anzuzeigen. Es wird die Verfügbarkeit der CoreMotion-Sensoren angezeigt, aber keine Rohwerte für CPU- oder GPU-Temperatur.
• Für Android sind keine Berechtigungen erforderlich, um die freigegebenen Metriken anzuzeigen. CPU- und GPU-Temperaturwerte sind bestmögliche thermische-Zonen-Lesungen.
• Die Unterstützung von Web ist bestmöglich und meldet leere Sensorenpools, da Browser die nativen Gerätesensoren nicht konsistent freigeben.

API Referenz

Methode	Rückgabe	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 gemäß dem Unix-Epochzeitstempel. 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 für jede Überwachungssitzung.

Quelle der Wahrheit

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

Weiter zum Anfangen

Wenn Sie Anfangen für Gerätediagnosen verwenden, verbinden Sie es mit @capgo/capacitor-geräte-info für eine Übersicht Mit @capgo/capacitor-geräte-info für die Anleitung Mit @capgo/capacitor-druckmessgerät für präzise Druckmessungen, und Mit @capgo/capacitor-lichtsensor für konzentrierte Lichtsensormessungen.