Device & System Information

/**
 * Device class providing static properties for device information
 * All properties are available immediately after device ready event
 */
class Device {
  /** Version of Cordova running on the device */
  static cordova: string;
  /** Name of device's model or product */
  static model: string;
  /** Operating system name (iOS, Android, etc.) */
  static platform: string;
  /** Device's Universally Unique Identifier */
  static uuid: string;
  /** Operating system version */
  static version: string;
  /** Device's manufacturer */
  static manufacturer: string;
  /** Whether the device is running on a simulator */
  static isVirtual: boolean;
  /** Device hardware serial number (Android only) */
  static serial: string;
}

import { Device } from 'ionic-native';

// Access device information
console.log('Device model: ' + Device.model);
console.log('Platform: ' + Device.platform);
console.log('UUID: ' + Device.uuid);
console.log('Version: ' + Device.version);
console.log('Cordova version: ' + Device.cordova);

// Check if running on simulator
if (Device.isVirtual) {
  console.log('Running on simulator/emulator');
}

// Platform-specific logic
if (Device.platform === 'iOS') {
  // iOS-specific code
} else if (Device.platform === 'Android') {
  // Android-specific code
}

/**
 * AppVersion class for retrieving application version information
 * All methods return promises with version-related data
 */
class AppVersion {
  /** 
   * Get the name of the app from app bundle
   * @returns Promise resolving to app name string
   */
  static getAppName(): Promise<string>;
  
  /** 
   * Get the package name/bundle identifier
   * @returns Promise resolving to package name (e.g., com.example.app)
   */
  static getPackageName(): Promise<string>;
  
  /** 
   * Get the version code (build number)
   * @returns Promise resolving to version code as string or number
   */
  static getVersionCode(): Promise<string | number>;
  
  /** 
   * Get the version number (display version)
   * @returns Promise resolving to version number string (e.g., "1.2.3")
   */
  static getVersionNumber(): Promise<string>;
}

import { AppVersion } from 'ionic-native';

// Get app information
AppVersion.getAppName().then((name) => {
  console.log('App name: ' + name);
});

AppVersion.getPackageName().then((packageName) => {
  console.log('Package: ' + packageName);
});

AppVersion.getVersionNumber().then((version) => {
  console.log('Version: ' + version);
});

AppVersion.getVersionCode().then((build) => {
  console.log('Build: ' + build);
});

// Get all version info
async function getVersionInfo() {
  try {
    const name = await AppVersion.getAppName();
    const packageName = await AppVersion.getPackageName();
    const version = await AppVersion.getVersionNumber();
    const build = await AppVersion.getVersionCode();
    
    return {
      name,
      packageName,
      version,
      build
    };
  } catch (error) {
    console.error('Error getting version info:', error);
  }
}

/**
 * IsDebug class for detecting debug/development mode
 */
class IsDebug {
  /** 
   * Check if the app is running in debug mode
   * @returns Promise resolving to boolean indicating debug status
   */
  static getIsDebug(): Promise<boolean>;
}

import { IsDebug } from 'ionic-native';

// Check debug status
IsDebug.getIsDebug().then((isDebug) => {
  if (isDebug) {
    console.log('Running in debug mode');
    // Enable debug features
  } else {
    console.log('Running in production mode');
    // Disable debug features
  }
});

// Conditional feature enabling
async function initializeApp() {
  const isDebug = await IsDebug.getIsDebug();
  
  if (isDebug) {
    // Enable debugging tools
    enableDebugger();
    showDebugMenu();
  }
  
  // Continue normal app initialization
}

/**
 * UniqueDeviceID class for getting device-specific unique identifier
 */
class UniqueDeviceID {
  /** 
   * Get unique device identifier
   * @returns Promise resolving to unique device ID string
   */
  static get(): Promise<string>;
}

import { UniqueDeviceID } from 'ionic-native';

// Get unique device ID
UniqueDeviceID.get().then((uuid) => {
  console.log('Device ID: ' + uuid);
  
  // Use for analytics tracking
  analytics.setUserId(uuid);
  
  // Use for device-specific settings
  loadDeviceSettings(uuid);
});

// Error handling
UniqueDeviceID.get().then((uuid) => {
  // Successfully got unique ID
  return uuid;
}).catch((error) => {
  console.error('Failed to get device ID:', error);
  // Fallback to generated ID
  return generateFallbackId();
});

/**
 * Diagnostic class for system capability checking
 */
class Diagnostic {
  /** Check if location services are enabled */
  static isLocationEnabled(): Promise<boolean>;
  
  /** Check if GPS location is available */
  static isGpsLocationEnabled(): Promise<boolean>;
  
  /** Check if network location is available */
  static isNetworkLocationEnabled(): Promise<boolean>;
  
  /** Check if camera is available */
  static isCameraAvailable(): Promise<boolean>;
  
  /** Check if Bluetooth is available */
  static isBluetoothAvailable(): Promise<boolean>;
  
  /** Check if Wi-Fi is available */
  static isWifiAvailable(): Promise<boolean>;
  
  /** Get location authorization status */
  static getLocationAuthorizationStatus(): Promise<string>;
  
  /** Request location authorization */
  static requestLocationAuthorization(): Promise<string>;
  
  /** Switch to device settings */
  static switchToSettings(): Promise<any>;
}

import { Diagnostic } from 'ionic-native';

// Check system capabilities
async function checkSystemCapabilities() {
  try {
    const locationEnabled = await Diagnostic.isLocationEnabled();
    const cameraAvailable = await Diagnostic.isCameraAvailable();
    const wifiAvailable = await Diagnostic.isWifiAvailable();
    
    console.log('Location enabled:', locationEnabled);
    console.log('Camera available:', cameraAvailable);
    console.log('WiFi available:', wifiAvailable);
    
    if (!locationEnabled) {
      // Prompt user to enable location
      const authStatus = await Diagnostic.requestLocationAuthorization();
      if (authStatus !== 'GRANTED') {
        // Direct user to settings
        await Diagnostic.switchToSettings();
      }
    }
  } catch (error) {
    console.error('Error checking capabilities:', error);
  }
}