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

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

Mise à jour 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 surveillance

• intervalMs par défaut 1000 s'applique en millisecondes. Les valeurs inférieures 250 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 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 capteur 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 sur la plateforme

• iOS n'exige aucune autorisation pour les métriques exposées. Il signale la disponibilité des capteurs de mouvement Core 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 de capteur vides car les navigateurs ne exposent pas les capteurs de capteur natifs de manière cohérente.

API référence

Méthode	Résultats	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 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 timestamps des lectures de capteurs sont en millisecondes Unix epoch. Les unités courantes sont les degrés Celsius, les pourcents, les hPa, les lux et les 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, timestamp, et elapsedMs sont des millisecondes. sequence débute à 1 pour chaque session de suivi.

Source de vérité

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

Continuez de là depuis Getting Started

Si vous utilisez Getting Started pour les diagnostics de dispositif, 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 axées sur la lumière.