Prise en main

Compatibilité

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

Installation

Vous pouvez utiliser notre configuration assistée par l'IA pour installer le plugin. Ajoutez les compétences Capgo à 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 installation 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';

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 est basé sur les deltas. Le premier échantillon natif peut l'omettre ; appelez-le à nouveau plus tard ou utilisez la surveillance pour recevoir l'utilisation CPU remplie après le deuxième échantillon. getInfo() Flux d'actualisation

Section intitulée “Flux d'actualisation”

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

Suivi du comportement

• intervalMs par défaut 1000 millisecondes. Les valeurs inférieures à 250 millisecondes sont arrondies à 250.
• emitImmediately par défaut true.
• Définir durationMs ou sampleCount pour arrêter automatiquement le suivi.
• Appeler startMonitoring() tandis que le suivi est actif, redémarre la session avec les nouvelles options.
• Chaque deviceInfoUpdate comprend une référence basée sur un sequencela session’s startedAt l'heure de début et elapsedMs.

Arrêtez les mises à jour et supprimez les écouteurs

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

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

Vérifiez l'état de suivi

const state = await DeviceInfo.isMonitoring();

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

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

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

Remarques de plateforme

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

API de référence

Méthode	Retourne	Remarques
getInfo()	Promise<DeviceInfoSnapshot>	Lit un instantané.
startMonitoring(options?)	Promise<StartMonitoringResult>	Prend en charge des snapshots 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 snapshot périodique.
removeAllListeners()	Promise<void>	Supprime tous les écouteurs enregistrés sur le plugin.
getPluginVersion()	Promise<PluginVersionResult>	Lire la version native du plugin.

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

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 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 horodatages des lectures de capteurs sont en millisecondes Unix epoch. Les unités courantes sont Celsius, pour cent, 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 en 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 Mettre à jour cette page lorsque ce référentiel change.

Continuez de l'étape de démarrage

Si vous utilisez Démarrage pour les diagnostics de périphérique, connectez-le avec @capgo/capacitor-device-info pour l'aperçu Utilisation de @capgo/capacitor-device-info pour la page du tutoriel @capgo/capacitor-baromètre pour des lectures de pression ciblées @capgo/capacitor-capteur de lumière pour des lectures du capteur de lumière ciblées