🔊 Capacitor Volume Control Plugin

// Get current volume and set it to 50%
const currentVolume = await VolumeControl.getVolumeLevel();
console.log('Current volume:', currentVolume.value);

await VolumeControl.setVolumeLevel({ value: 0.5 });

// Watch for volume changes
await VolumeControl.watchVolume({
  suppressVolumeIndicator: true
}, (event) => {
  console.log('Volume changed:', event.direction);
});

import { VolumeControl } from '@odion-cloud/capacitor-volume-control';

// Get current volume level (0.0 to 1.0)
const currentVolume = await VolumeControl.getVolumeLevel();
console.log('Current volume:', currentVolume.value);

// Get specific volume type
const musicVolume = await VolumeControl.getVolumeLevel({
  type: 'music'
});

// Set volume to 50%
await VolumeControl.setVolumeLevel({ value: 0.5 });

// Set specific volume type
await VolumeControl.setVolumeLevel({
  value: 0.8,
  type: 'system'
});

// Method 1: Using watchVolume with callback
await VolumeControl.watchVolume({
  suppressVolumeIndicator: true,    // Android: hide volume UI
  disableSystemVolumeHandler: true  // iOS: disable system UI
}, (event) => {
  console.log('Volume changed:', event.direction);
});

// Method 2: Using event listeners (recommended for frameworks)
const listener = await VolumeControl.addListener('volumeChanged', (event) => {
  console.log('Volume changed:', event.direction);
});

// Start watching (required for both methods)
await VolumeControl.watchVolume({
  disableSystemVolumeHandler: true,
  suppressVolumeIndicator: true
}, () => {}); // Empty callback if using event listeners

// Stop watching
await VolumeControl.clearWatch();

// Remove specific listener
listener.remove();

// Or remove all listeners
await VolumeControl.removeAllListeners();

// Check if watching
const isWatching = await VolumeControl.isWatching();
console.log('Is watching:', isWatching.value);

class MusicPlayer {
  constructor() {
    this.isWatching = false;
  }

  async initialize() {
    // Get current volume
    const volume = await VolumeControl.getVolumeLevel();
    this.currentVolume = volume.value;
    
    // Start watching volume changes
    await this.startVolumeWatching();
  }

  async startVolumeWatching() {
    if (this.isWatching) return;
    
    await VolumeControl.watchVolume({
      suppressVolumeIndicator: true
    }, (event) => {
      this.handleVolumeChange(event);
    });
    
    this.isWatching = true;
  }

  handleVolumeChange(event) {
    this.currentVolume = event.level;
    console.log(`Volume ${event.direction}: ${event.level}`);
    
    // Update UI or trigger other actions
    this.updateVolumeDisplay(event.level);
  }

  async setVolume(level) {
    await VolumeControl.setVolumeLevel({ value: level });
    this.currentVolume = level;
  }
}

class AudioMixer {
  constructor() {
    this.volumeLevels = {
      music: 0.5,
      notification: 0.3,
      system: 0.7
    };
  }

  async setMusicVolume(level) {
    await VolumeControl.setVolumeLevel({
      value: level,
      type: 'music'
    });
    this.volumeLevels.music = level;
  }

  async setNotificationVolume(level) {
    await VolumeControl.setVolumeLevel({
      value: level,
      type: 'notification'
    });
    this.volumeLevels.notification = level;
  }

  async getCurrentLevels() {
    const music = await VolumeControl.getVolumeLevel({ type: 'music' });
    const notification = await VolumeControl.getVolumeLevel({ type: 'notification' });
    const system = await VolumeControl.getVolumeLevel({ type: 'system' });
    
    return {
      music: music.value,
      notification: notification.value,
      system: system.value
    };
  }
}

class GameVolumeManager {
  constructor() {
    this.isMuted = false;
    this.previousVolume = 0.5;
  }

  async initialize() {
    // Get current volume
    const volume = await VolumeControl.getVolumeLevel();
    this.previousVolume = volume.value;
    
    // Start watching for volume changes
    await VolumeControl.watchVolume({
      disableSystemVolumeHandler: true
    }, (event) => {
      this.handleGameVolumeChange(event);
    });
  }

  handleGameVolumeChange(event) {
    if (this.isMuted) {
      // If muted, restore previous volume
      VolumeControl.setVolumeLevel({ value: this.previousVolume });
    } else {
      // Update previous volume
      this.previousVolume = event.level;
    }
  }

  async mute() {
    this.isMuted = true;
    await VolumeControl.setVolumeLevel({ value: 0 });
  }

  async unmute() {
    this.isMuted = false;
    await VolumeControl.setVolumeLevel({ value: this.previousVolume });
  }
}

import { useEffect, useState } from 'react';
import { VolumeControl } from '@odion-cloud/capacitor-volume-control';

export function useVolumeControl() {
  const [volume, setVolume] = useState(0.5);
  const [isWatching, setIsWatching] = useState(false);

  useEffect(() => {
    // Get initial volume
    VolumeControl.getVolumeLevel().then(result => {
      setVolume(result.value);
    });

    // Cleanup on unmount
    return () => {
      VolumeControl.clearWatch();
      VolumeControl.removeAllListeners();
    };
  }, []);

  const startWatching = async () => {
    if (isWatching) return;

    try {
      // Add event listener first
      await VolumeControl.addListener('volumeChanged', (event) => {
        setVolume(event.level);
      });
      
      // Start watching with empty callback since we're using event listeners
      await VolumeControl.watchVolume({
        disableSystemVolumeHandler: true,
        suppressVolumeIndicator: true
      }, () => {});
      
      setIsWatching(true);
    } catch (error) {
      console.error('Failed to start watching:', error);
    }
  };

  const stopWatching = async () => {
    try {
      await VolumeControl.clearWatch();
      await VolumeControl.removeAllListeners();
      setIsWatching(false);
    } catch (error) {
      console.error('Failed to stop watching:', error);
    }
  };

  const setVolumeLevel = async (value) => {
    try {
      await VolumeControl.setVolumeLevel({ value });
      setVolume(value);
    } catch (error) {
      console.error('Failed to set volume:', error);
    }
  };

  return {
    volume,
    isWatching,
    startWatching,
    stopWatching,
    setVolumeLevel
  };
}

import { ref, onMounted, onUnmounted } from 'vue';
import { VolumeControl } from '@odion-cloud/capacitor-volume-control';

export function useVolumeControl() {
  const volume = ref(0.5);
  const isWatching = ref(false);
  let volumeListener = null;

  onMounted(async () => {
    // Get initial volume
    try {
      const result = await VolumeControl.getVolumeLevel();
      volume.value = result.value;
    } catch (error) {
      console.error('Failed to get initial volume:', error);
    }
  });

  onUnmounted(async () => {
    await stopWatching();
  });

  const startWatching = async () => {
    if (isWatching.value) return;

    try {
      // Add event listener
      volumeListener = await VolumeControl.addListener('volumeChanged', (event) => {
        volume.value = event.level;
        console.log('Volume changed:', event.direction);
      });

      // Start watching
      await VolumeControl.watchVolume({
        disableSystemVolumeHandler: true,
        suppressVolumeIndicator: true
      }, () => {});

      isWatching.value = true;
    } catch (error) {
      console.error('Failed to start watching:', error);
    }
  };

  const stopWatching = async () => {
    try {
      await VolumeControl.clearWatch();
      
      if (volumeListener) {
        volumeListener.remove();
        volumeListener = null;
      }
      
      await VolumeControl.removeAllListeners();
      isWatching.value = false;
    } catch (error) {
      console.error('Failed to stop watching:', error);
    }
  };

  const setVolumeLevel = async (value) => {
    try {
      await VolumeControl.setVolumeLevel({ value });
      volume.value = value;
    } catch (error) {
      console.error('Failed to set volume:', error);
    }
  };

  return {
    volume,
    isWatching,
    startWatching,
    stopWatching,
    setVolumeLevel
  };
}

import { Injectable } from '@angular/core';
import { BehaviorSubject } from 'rxjs';
import { VolumeControl } from '@odion-cloud/capacitor-volume-control';

@Injectable({
  providedIn: 'root'
})
export class VolumeService {
  private volumeSubject = new BehaviorSubject<number>(0.5);
  private isWatchingSubject = new BehaviorSubject<boolean>(false);
  private volumeListener = null;

  public volume$ = this.volumeSubject.asObservable();
  public isWatching$ = this.isWatchingSubject.asObservable();

  constructor() {
    this.initializeVolume();
  }

  private async initializeVolume() {
    try {
      const result = await VolumeControl.getVolumeLevel();
      this.volumeSubject.next(result.value);
    } catch (error) {
      console.error('Failed to get initial volume:', error);
    }
  }

  async startWatching(): Promise<void> {
    if (this.isWatchingSubject.value) return;

    try {
      // Add event listener
      this.volumeListener = await VolumeControl.addListener('volumeChanged', (event) => {
        this.volumeSubject.next(event.level);
        console.log('Volume changed:', event.direction);
      });

      // Start watching
      await VolumeControl.watchVolume({
        disableSystemVolumeHandler: true,
        suppressVolumeIndicator: true
      }, () => {});

      this.isWatchingSubject.next(true);
    } catch (error) {
      console.error('Failed to start watching:', error);
      throw error;
    }
  }

  async stopWatching(): Promise<void> {
    try {
      await VolumeControl.clearWatch();
      
      if (this.volumeListener) {
        this.volumeListener.remove();
        this.volumeListener = null;
      }
      
      await VolumeControl.removeAllListeners();
      this.isWatchingSubject.next(false);
    } catch (error) {
      console.error('Failed to stop watching:', error);
      throw error;
    }
  }

  async setVolumeLevel(value: number): Promise<void> {
    try {
      await VolumeControl.setVolumeLevel({ value });
      this.volumeSubject.next(value);
    } catch (error) {
      console.error('Failed to set volume:', error);
      throw error;
    }
  }
}