Primeros pasos

Compatibilidad

@capgo/capacitor-device-info requiere Capacitor 8 o superior (@capacitor/core >=8.0.0).

Instalar

Puedes usar nuestro setup asistido por IA para instalar el plugin. Añade las skills de Capgo a tu herramienta de IA con el siguiente comando:

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

Luego usa el siguiente prompt:

Use the `capacitor-plugins` skill from `Cap-go/capgo-skills` to install the `@capgo/capacitor-device-info` plugin in my project.

Para una configuración manual, instala el paquete y sincroniza los proyectos nativos:

npm install @capgo/capacitor-device-info
npx cap sync

Importar

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

Inicio rápido

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

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

Ejemplo: startMonitoring

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

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

Ejemplo: stopMonitoring

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

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

Errores comunes

• Listeners: elimina los handles cuando se desmonten las pantallas.
• Sync nativo: ejecuta npx cap sync tras actualizar los plugins.
• Fuente de verdad: confianza src/definitions.ts en el repo de GitHub.

Leer 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 se basa en deltas. La primera muestra nativa puede omitirlo; llama getInfo() después o usa el monitoreo para recibir el uso de CPU tras la segunda muestra.

Transmitir actualizaciones

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

Comportamiento del monitoreo

• intervalMs por defecto es 1000 milisegundos. Los valores inferiores a 250 milisegundos se limitan a 250.
• emitImmediately por defecto es true.
• Configurar durationMs o sampleCount para dejar de monitorear automáticamente.
• Llamar a startMonitoring() mientras el monitoreo esté activo, reinicia la sesión con las nuevas opciones.
• Cada deviceInfoUpdate incluye un índice basado en uno sequence, la sesión de startedAt timestamp, y elapsedMs.

Detener actualizaciones y eliminar listeners

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

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

Verificar estado del monitoreo

const state = await DeviceInfo.isMonitoring();

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

Incorporar campos del sensor

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

Los campos de sensores son opcionales. Solo aparecen si el dispositivo, el SO y el sandbox de la app exponen esa métrica.

Notas de plataforma

• iOS no requiere permisos para las métricas expuestas. Informa la disponibilidad de sensores de CoreMotion, pero no la temperatura bruta de CPU o GPU.
• Android no requiere permisos para las métricas expuestas. Las temperaturas de CPU y GPU son lecturas de zonas térmicas bajo el principio de mejor esfuerzo.
• El soporte web es 'best effort' y reporta arrays de sensores vacíos, ya que los navegadores no exponen los sensores nativos de forma consistente.

Referencia de API

Método	Devuelve	Notas
getInfo()	Promise<DeviceInfoSnapshot>	Lee una instantánea.
startMonitoring(options?)	Promise<StartMonitoringResult>	Inicia snapshots periódicos o reinicia una sesión activa con nuevas opciones.
stopMonitoring()	Promise<StopMonitoringResult>	Detiene la sesión activa.
isMonitoring()	Promise<MonitoringState>	Devuelve el estado de la sesión actual.
addListener('deviceInfoUpdate', listener)	Promise<PluginListenerHandle>	Registra un listener para snapshots periódicos.
removeAllListeners()	Promise<void>	Elimina todos los listeners registrados en el plugin.
getPluginVersion()	Promise<PluginVersionResult>	Lee la versión del plugin nativo.

PluginListenerHandle es proporcionado por Capacitor y tiene remove() para eliminar ese listener individual.

Tipos de snapshot

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

Los tamaños están en bytes, maxFrequencyHz es hertz, y la temperatura es en Celsius. usagePercent pueden ser null hasta que la plataforma tenga suficientes muestras para calcularlo.

Tipos de sensores

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

Los timestamps de lectura de sensores están en milisegundos Unix epoch. Las unidades comunes son Celsius, porcentaje, hPa, lux y centímetros.

Tipos de monitoreo

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, y elapsedMs son milisegundos. sequence comienza en 1 para cada sesión de monitoreo.

Fuente de verdad

Esta referencia sigue el API público del plugin src/definitions.tsActualiza esta página si cambia la fuente.

Continúa desde Getting Started

Si estás usando Primeros pasos para diagnósticos del dispositivo, conéctalo con @capgo/capacitor-device-info para el resumen, Usando @capgo/capacitor-device-info para la página del tutorial, @capgo/capacitor-barometer para lecturas de presión específicas, y @capgo/capacitor-light-sensor para lecturas focalizadas del sensor de luz.