Démarrage

Cette section est intitulée « Compatibilité »

@capgo/capacitor-device-info requires Capacitor 8 or later (@capacitor/core >=8.0.0).

Section intitulée « Installation »

You can use our AI-Assisted Setup to install the plugin. Add the Capgo skills to your AI tool using the following command:

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

Utilisez ensuite la commande 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';

Section intitulée « Lire une capture d'écran »

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 la différence. La première échantillon natif peut l'omettre ; appelez getInfo() à nouveau plus tard ou utilisez la surveillance pour recevoir l'utilisation CPU remplie après le deuxième échantillon.

Flux de mise à jour

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

Comportement de surveillance

• intervalMs par défaut 1000 millisecondes. Les valeurs inférieures 250 millisecondes sont arrondies à 250.
• emitImmediately par défaut true.
• Configurer durationMs ou sampleCount Configurer
• ou startMonitoring() Configurer
• ou deviceInfoUpdate Configurer les mises à jour et supprimer les écouteurs sequenceSection intitulée « Configurer les mises à jour et supprimer les écouteurs » startedAt Copier dans le presse-papier elapsedMs.

Arrêter la surveillance automatiquement.

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

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

Vérifiez l'état de surveillance

const state = await DeviceInfo.isMonitoring();

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

Sur le champ des capteurs

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

Les champs des capteurs sont facultatifs. Ils sont présents uniquement lorsque l'appareil, le système d'exploitation et le sandbox de l'application exposent ce métrique.

Notes de plateforme

• Sur iOS, aucune autorisation n'est requise pour les métriques exposées. Il signale la disponibilité des capteurs de mouvement CoreMotion, mais pas les températures CPU ou GPU brutes.
• Sur Android, aucune autorisation n'est requise pour les métriques exposées. Les températures CPU et GPU sont des lectures de zone thermique de meilleure volonté.
• Le support Web est de meilleure volonté et signale des tableaux de capteurs embarqués vides car les navigateurs ne exposent pas les capteurs de dispositif natif de manière cohérente.

API référence

Méthode	Renvoie	Remarques
getInfo()	Promise<DeviceInfoSnapshot>	Lit une capture instantanée.
startMonitoring(options?)	Promise<StartMonitoringResult>	Démarre des captures périodiques, ou redémarre 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 de capture périodique.
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 individuel écouteur.

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

Les tailles sont en octets, maxFrequencyHz est en hertz, et les valeurs de température sont en 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 des millisecondes de l'époque Unix. Les unités courantes sont les degrés Celsius, les pourcents, les hectopascals, les lux et les 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, timestamp, et elapsedMs sont des millisecondes. sequence commence à 1 pour chaque session de surveillance.

Source de vérité

Cette référence suit le référentiel public API dans le plugin's src/definitions.ts. Mettez à jour cette page lorsque cette source change.

Continuez de là

Si vous utilisez Getting Started pour les diagnostics de périphérique, connectez-l’à @capgo/capacitor-device-info pour une vue d'ensemble, Utilisez @capgo/capacitor-device-info pour la page de tutoriel, @capgo/capacitor-barometer pour des lectures de pression ciblées, et @capgo/capacitor-light-sensor pour des lectures de capteur de lumière ciblées.