Démarrage

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

Lire une 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 getInfo() à nouveau plus tard ou utilisez le suivi pour recevoir l'utilisation du processeur CPU après le deuxième échantillon.

Actualiser en continu

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 suivi

• intervalMs par défaut 1000 millisecondes. Les valeurs inférieures 250 millisecondes sont arrondies à 250.
• emitImmediately par défaut true.
• Configurer durationMs ou sampleCount arrêter la surveillance automatiquement.
• Appeler startMonitoring() Lorsque la surveillance est active, redémarrer la session avec les nouvelles options.
• Chaque deviceInfoUpdate comprend un indexé à partir de 1 sequencele timestamp de la session, et startedAt Arrêter les mises à jour et supprimer les écouteurs elapsedMs.

Section intitulée « Arrêter les mises à jour et supprimer les écouteurs »

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

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

Section intitulée « Vérifier l'état de la surveillance »

const state = await DeviceInfo.isMonitoring();

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

Champs de capteurs à bord

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 facultatifs. Ils sont présents uniquement lorsque l'appareil, 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 de mouvement 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 volonté.
• Le support Web est de meilleure volonté et signale des tableaux de capteurs à bord vides car les navigateurs ne exposent pas les capteurs de dispositif natif de manière cohérente.

API référence

méthode	retourne	notes
getInfo()	Promise<DeviceInfoSnapshot>	Lit une capture.
startMonitoring(options?)	Promise<StartMonitoringResult>	Démarrer des captures périodiques, ou reprend un session active avec de nouvelles options.
stopMonitoring()	Promise<StopMonitoringResult>	Arrête la session active.
isMonitoring()	Promise<MonitoringState>	Retourne l'état de la session actuelle.
addListener('deviceInfoUpdate', listener)	Promise<PluginListenerHandle>	Enregistre un écouteur de capture périodique.
removeAllListeners()	Promise<void>	Supprime chaque écouteur enregistré sur le plugin.
getPluginVersion()	Promise<PluginVersionResult>	Lit la version native du plugin.

PluginListenerHandle est fourni par Capacitor et a 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;
}

Les tailles sont en octets, maxFrequencyHz est en hertz, et les valeurs de température sont en Celsius. usagePercent peuvent ê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, pourcentage, hPa, lux et centimètres.

Types de suivi

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 suivi.

Source de vérité

Cette référence suit la documentation publique API dans le plugin’s src/definitions.ts. Mettre à jour cette page lorsque cette source change.

Continuez de Getting Started

Si vous utilisez Début de l'installation pour les diagnostics de périphérique, connectez-le à @capgo/capacitor-device-info pour l'aperçu, Utiliser @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.