Prise en main

Compatibilité

@capgo/capacitor-device-info nécessite Capacitor 8 ou ultérieur (@capacitor/core >=8.0.0).

Installer

Vous pouvez utiliser notre configuration assistée par IA pour installer le plugin. Ajoutez les skills Capgo à votre outil d'IA avec la commande suivante :

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

Utilisez ensuite le prompt suivant :

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

Démarrage rapide

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

const result = await DeviceInfo.getInfo();
console.log(result);

Exemple : startMonitoring

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

const result = await DeviceInfo.startMonitoring();
console.log(result);

Exemple : stopMonitoring

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

const result = await DeviceInfo.stopMonitoring();
console.log(result);

Erreurs courantes

• Écouteurs: supprimez les handles lors du démontage des écrans.
• Sync native : exécuter npx cap sync après les mises à jour du plugin.
• Source de vérité : fiez-vous src/definitions.ts au repo GitHub.

Lire un snapshot

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 repose sur des deltas. Le premier échantillon natif peut l'omettre ; appelez getInfo() réessayez plus tard ou utilisez le monitoring pour recevoir l'utilisation CPU renseignée après le second échantillon.

Mises à jour en flux

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 du monitoring

• intervalMs par défaut sur 1000 millisecondes. Les valeurs inférieures à 250 millisecondes sont limitées à 250.
• emitImmediately par défaut sur true.
• Définissez durationMs ou sampleCount pour arrêter automatiquement le monitoring.
• Appeler startMonitoring() pendant que le monitoring est actif, redémarre la session avec les nouvelles options.
• Chaque deviceInfoUpdate comprend un index commençant à 1 sequence, de la session startedAt horodatage, et 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 du monitoring

const state = await DeviceInfo.isMonitoring();

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

Intégrer les champs de 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 de capteurs sont optionnels. Ils ne sont présents que lorsque l'appareil, l'OS et le sandbox de l'app exposent cette métrique.

Notes sur les plateformes

• iOS ne nécessite aucune permission pour les métriques exposées. Il indique la disponibilité du capteur CoreMotion, mais pas la température brute du CPU ou du GPU.
• Android ne nécessite aucune permission pour les métriques exposées. Les températures du CPU et du GPU proviennent de lectures best-effort des zones thermiques.
• La prise en charge Web est fournie à titre indicatif et renvoie des tableaux de capteurs vides, car les navigateurs n'exposent pas de manière cohérente les capteurs natifs de l'appareil.

Référence API

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

PluginListenerHandle est fourni par Capacitor et possède remove() pour supprimer ce listener spécifique.

Types de snapshots

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 assez 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 horodatages des lectures de capteurs sont en millisecondes Unix epoch. Les unités courantes sont le degré Celsius, le pourcentage, l'hPa, le lux et le centimètre.

Types de monitoring

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 en millisecondes. sequence commence à 1 pour chaque session de surveillance.

Source de vérité

Cette référence suit l’API public dans le src/definitions.ts. Mettez à jour cette page lorsque cette source change.

Continuer depuis Getting Started

Si vous utilisez Prise en main pour les diagnostics de l’appareil, connectez-l’avec @capgo/capacitor-device-info pour l'aperçu, Utiliser @capgo/capacitor-device-info pour la page du tutoriel, @capgo/capacitor-barometer pour des mesures de pression ciblées, et @capgo/capacitor-light-sensor pour des mesures précises du capteur de luminosité.