Getting Started

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 die Capgo Fähigkeiten Ihrem AI-Tool mit der folgenden Befehl hinzu:

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

Verwenden Sie dann folgende Anfrage:

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

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

Abschnitt mit dem Titel “Stream-Updates”

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

Abschnitt mit dem Titel “Überwachungsverhalten”

• intervalMs defaults zu 1000 Millisekunden. Werte unter 250 Millisekunden werden auf 250.
• emitImmediately defaults zu true.
• Setzen durationMs oder sampleCount Automatisch die Überwachung beenden.
• Calling startMonitoring() Während die Überwachung aktiv ist, wird die Sitzung mit den neuen Optionen neu gestartet.
• Every deviceInfoUpdate einschließt eine einsbezogene sequenceeine einsbezogene startedAt Zeitstempel, und elapsedMs.

Stoppen 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 Zustand der Überwachung

const state = await DeviceInfo.isMonitoring();

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

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

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

Plattformhinweise

• iOS benötigt keine Berechtigungen für die angezeigten Metriken. Es meldet die Verfügbarkeit der CoreMotion-Sensoren, aber nicht die Rohwerte der CPU- oder GPU-Temperatur.
• Android benötigt keine Berechtigungen für die angebotenen Metriken. CPU- und GPU-Temperaturen sind Schätzungen der thermischen Zonen.
• Die Unterstützung für Web ist bestmöglich und meldet leere Bord-Sensor-Arrays, da Browser die native Gerätesensoren nicht konsistent ausgeben.

API Referenz

Methode	Rückgabe	Hinweise
getInfo()	Promise<DeviceInfoSnapshot>	Ermittelt einen Snapshot.
startMonitoring(options?)	Promise<StartMonitoringResult>	Startet periodische Snapshots oder startet einen aktiven Session mit neuen Optionen.
stopMonitoring()	Promise<StopMonitoringResult>	Beendet die aktive Session.
isMonitoring()	Promise<MonitoringState>	Gibt die aktuelle Sitzungszustand zurück.
addListener('deviceInfoUpdate', listener)	Promise<PluginListenerHandle>	Registriert einen periodischen Snapshot-Listener.
removeAllListeners()	Promise<void>	Entfernt jeden Listener, der auf dem Plugin registriert wurde.
getPluginVersion()	Promise<PluginVersionResult>	Liest die native Pluginversion.

PluginListenerHandle wird durch Capacitor bereitgestellt und hat remove() für die Entfernung des einzelnen Listeners.

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

Die Größen sind in Byte angegeben, maxFrequencyHz ist Hertz und die Temperaturwerte sind in Celsius. usagePercent kann null bis das Plattform genügend Beispiele 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;
}

Sensordaten sind in Unix-Epoch-Millisekunden 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, timestampund elapsedMs sind Millisekunden. sequence beginnt bei 1 für jede Überwachungssitzung.

Quelle der Wahrheit

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

Weiter geht’s von Getting Started

Wenn Sie Capgo verwenden Getting Started für Gerätediagnosen verwenden, verbinden Sie es mit @capgo/capacitor-Geräte-Info für eine Übersicht Mit @capgo/capacitor-device-info für die Tutorial-Seite @capgo/capacitor-Barometer für fokussierte Druckmessungen und @capgo/capacitor-Lichtsensor Beginnen Sie mit __CAPGO_KEEP_0__