battery-optimization

Mobile Battery Optimization

When to Use

Use this skill when:

• Optimizing for mobile battery life
• Implementing adaptive quality systems
• Managing background behavior
• Reducing power consumption
• Handling device thermal throttling
• Creating power-efficient games

Core Principles

1. Adaptive Quality: Scale based on power state
2. Intelligent Throttling: Reduce updates when inactive
3. Background Pause: Stop rendering when hidden
4. Thermal Management: Detect and respond to heat
5. Power Awareness: Monitor battery state
6. Efficient Rendering: Minimize GPU/CPU usage

Battery Optimization Implementation

1. Power State Management

// power/PowerStateManager.ts
export enum PowerState {
  High = 'high', // Plugged in, full quality
  Normal = 'normal', // Good battery, normal quality
  Low = 'low', // Low battery, reduced quality
  Critical = 'critical', // Very low battery, minimal quality
}

export interface PowerMetrics {
  batteryLevel: number; // 0-1
  isCharging: boolean;
  isSaveModeEnabled: boolean;
  temperature?: number; // Device temperature if available
}

export class PowerStateManager {
  private state: PowerState = PowerState.Normal;
  private metrics: PowerMetrics = {
    batteryLevel: 1,
    isCharging: false,
    isSaveModeEnabled: false,
  };

  private listeners = new Set<(state: PowerState) => void>();

  constructor() {
    this.initBatteryAPI();
    this.initVisibilityAPI();
  }

  private async initBatteryAPI(): Promise<void> {
    if ('getBattery' in navigator) {
      try {
        const battery = await (navigator as any).getBattery();

        // Initial state
        this.updateMetrics({
          batteryLevel: battery.level,
          isCharging: battery.charging,
        });

        // Listen for changes
        battery.addEventListener('levelchange', () => {
          this.updateMetrics({ batteryLevel: battery.level });
        });

        battery.addEventListener('chargingchange', () => {
          this.updateMetrics({ isCharging: battery.charging });
        });
      } catch (error) {
        console.warn('Battery API not available:', error);
      }
    }
  }

  private initVisibilityAPI(): void {
    document.addEventListener('visibilitychange', () => {
      if (document.hidden) {
        this.onBackgrounded();
      } else {
        this.onForegrounded();
      }
    });
  }

  private updateMetrics(partial: Partial<PowerMetrics>): void {
    Object.assign(this.metrics, partial);
    this.updatePowerState();
  }

  private updatePowerState(): void {
    const newState = this.calculatePowerState();

    if (newState !== this.state) {
      this.state = newState;
      this.notifyListeners();
    }
  }

  private calculatePowerState(): PowerState {
    // Charging = high performance
    if (this.metrics.isCharging) {
      return PowerState.High;
    }

    // Battery-based states
    if (this.metrics.batteryLevel < 0.1) {
      return PowerState.Critical;
    } else if (this.metrics.batteryLevel < 0.2) {
      return PowerState.Low;
    } else {
      return PowerState.Normal;
    }
  }

  private notifyListeners(): void {
    for (const listener of this.listeners) {
      listener(this.state);
    }
  }

  private onBackgrounded(): void {
    // Notify listeners that app is backgrounded
    for (const listener of this.listeners) {
      listener(PowerState.Critical); // Treat as critical to pause everything
    }
  }

  private onForegrounded(): void {
    // Resume normal power state
    this.updatePowerState();
  }

  getPowerState(): PowerState {
    return this.state;
  }

  getMetrics(): PowerMetrics {
    return { ...this.metrics };
  }

  onStateChange(listener: (state: PowerState) => void): () => void {
    this.listeners.add(listener);
    return () => this.listeners.delete(listener);
  }
}