Getting Started

Compatibilité

@capgo/capacitor-device-info exige Capacitor 8 ou une version ultérieure (@capacitor/core >=8.0.0).

Installation

Vous pouvez utiliser notre configuration assistée par l'IA pour installer le plugin. Ajoutez les Capgo compétences à votre outil IA à l'aide de la commande suivante :

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

Ensuite, utilisez la prompt suivante :

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

Pour une configuration manuelle, installez le package et synchronisez les projets natifs :

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

Importer

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

Lisez une capture

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 est basé sur les deltas. La première capture native peut l'omettre ; appelez-le getInfo() encore plus tard ou utilisez la surveillance pour recevoir l'utilisation CPU remplie après la deuxième capture.

Flux d'actualisations

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

Surveillance du comportement

• intervalMs Copier 1000 millisecondes. Valeurs en dessous 250 les millisecondes sont limités à 250.
• emitImmediately défaut à true.
• Fixer durationMs ou sampleCount ou arrêter la surveillance automatiquement.
• Appeler startMonitoring() tandis que la surveillance est active, redémarre la session avec les nouvelles options.
• Chaque deviceInfoUpdate comprend un indicateur de 1 basé sequence, le timestamp de la session startedAt timestamp, and elapsedMs.

Stop updates and remove listeners

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

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

Vérifier l'état de surveillance

const state = await DeviceInfo.isMonitoring();

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

Surboard les champs de capteur

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 fields are optional. They are present only when the device, OS, and app sandbox expose that metric.

Notes de plateforme

• iOS n'exige aucune autorisation pour les métriques exposées. Il signale la disponibilité des capteurs de CoreMotion mais pas la température CPU ou GPU brute.
• Aucun accès n'est requis pour les métriques exposées sur Android. Les températures CPU et GPU sont des lectures de zones thermiques à effort de meilleure qualité.
• Le support Web est de meilleure volonté et signale des tableaux de capteurs embarqués vides car les navigateurs ne révèlent pas les capteurs de dispositif natifs de manière cohérente.

Référence de API

Méthode	Renvoie	Remarques
getInfo()	Promise<DeviceInfoSnapshot>	Lit une instantanée.
startMonitoring(options?)	Promise<StartMonitoringResult>	Démarre des instantanées périodiques, ou reprend une session active avec de nouvelles options.
stopMonitoring()	Promise<StopMonitoringResult>	Arrête la session active.
isMonitoring()	Promise<MonitoringState>	Renvoie l'état de la session actuelle.
addListener('deviceInfoUpdate', listener)	Promise<PluginListenerHandle>	Enregistre un écouteur d'instantanées périodiques.
removeAllListeners()	Promise<void>	Supprime tous les écouteurs enregistrés sur le plugin.
getPluginVersion()	Promise<PluginVersionResult>	Lit la version native du plugin.

PluginListenerHandle est fourni par Capacitor et comporte remove() pour supprimer cet écouteur individuel.

Types de captures

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

Tailles sont en octets. maxFrequencyHz is hertz, and temperature values are Celsius. usagePercent peut être null jusqu'à ce que la plateforme ait suffisamment d'échantillons pour le calculer.

Types de capteurs

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

Les timestamps des lectures de capteurs sont en millisecondes Unix epoch. Les unités courantes sont Celsius, pourcentage, hPa, lux et centimètres.

Types de surveillance

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, timestampet elapsedMs sont des millisecondes. sequence démarre à 1 pour chaque session de surveillance.

Source de vérité

This reference follows the public API in the plugin’s src/definitions.tsMettez à jour cette page lorsque cette source change.

Continuez de Getting Started

Si vous utilisez Getting Started pour les diagnostics de dispositif, connectez-l’avec capgo/capacitor-informations-sur-le-dispositif pour l'aperçu, Utilisez @capgo/capacitor-device-info pour la page de tutoriel, @capgo/capacitor-baromètre pour des lectures de pression ciblées, et @capgo/capacitor-senseur de lumière pour des lectures de capteur de lumière ciblées.