Audio Manager

[[needs.privilege]]
id = "com.amazon.audio.privilege.settings.control"

[wants]
[[wants.service]]
id = "com.amazon.audio.control"

/*
Sets volume of audio type alarm to 50% and stores returned AudioStatus type in
status after the promise resolves, otherwise stores undefined and prints an error
if promise fails
*/

const status = AudioManager.setVolumeAsync(AudioVolumeType.VOLUME_TYPE_ALARM, 50)
.then((status) => {return status;}).catch((error) => console.log(error));

/*
Retrieves volume percent of audio type media and stores it in volume after promise resolves
*/

const volume = AudioManager.getVolumeAsync(AudioVolumeType.VOLUME_TYPE_MEDIA)
.then((volume) => {return volume;}).catch((error) => console.log(error));

/*
Mutes microphone input and stores returned AudioStatus type in status after promise
resolves
*/

const status = AudioManager.setMicMuteAsync(true).then((status) => {return status;}).catch((error) => console.log(error));

/*
Gets mute status of microphone input and stores the returned boolean in mute_status
after promise resolves
*/

const mute_status = AudioManager.getMicMuteAsync()
.then((mute_status) => {return mute_status;}).catch((error) => console.log(error));

/*
Sets global mute to true and stores returned AudioStatus type in status after
promise resolves
 */

const status = AudioManager.setGlobalVolumeMuteAsync(true).then((status) => {return status;}).catch((error) => console.log(error));

/*
Gets global mute status and stores the boolean in global_mute after promise resolves
*/

const global_mute = AudioManager.getGlobalVolumeMuteAsync().then((global_mute) => {return global_mute;}).catch((error) => console.log(error));

/*
Creates a function and registers it in the Audio Event Observer to execute this
function whenever an audio change happens and stores returned AudioStatus
type in status after promise resolves
*/

// Register for system-wide audio events
await AudioManager.registerAudioEventObserverAsync((event) => {
    // Event object will contain different properties based on the event type
    switch (event.audioEvent) {
        case AudioEvent.DEVICE_STATE_UPDATE:
            // Triggered when an audio device's connection state changes
            // Parameters:
            // - device: AudioDevice enum value
            // - role: AudioRole enum value
            // - connect: boolean indicating if device was connected (true) or disconnected (false)
            console.log(`Device ${event.device} with role ${event.role} ${event.connect ? 'connected' : 'disconnected'}`);
            break;

        case AudioEvent.VOLUME_UPDATE:
            // Triggered when volume changes for any audio type
            // Parameters:
            // - type: AudioVolumeType enum value
            // - volume: number (0-100)
            console.log('Volume changed for:', event.audioEvent, 'to:', event.volume);
            break;

        case AudioEvent.GLOBAL_VOLUME_MUTE_UPDATE:
            // Triggered when global mute state changes
            // Parameters:
            // - mute: boolean indicating if system is muted
            console.log('Global mute updated to state: ', event.mute);
            break;

        case AudioEvent.SERVER_DOWN:
            // Triggered when audio server becomes unavailable
            console.log('Audio server is down');
            break;

        case AudioEvent.SERVER_UP:
            // Triggered when audio server becomes available
            console.log('Audio server is up');
            break;

        case AudioEvent.AUDIO_USAGE_STATE_CHANGE:
            // Triggered when audio usage state changes
            // Parameters:
            // - usage: AudioUsageType enum value
            // - active: boolean indicating if usage became active
            console.log('Usage: ', event.usage);
            console.log('Active status: ', event.active);
            break;

        case AudioEvent.MIC_MUTE_STATE_UPDATE:
            // Triggered when microphone mute state changes
            // Parameters:
            // - state: boolean indicating if mic is muted
            console.log('Mic mute state changed: ', event.muteState);
            break;

        case AudioEvent.VOLUME_MUTE_UPDATE:
            // Triggered when volume mute state changes for specific volume type
            // Parameters:
            // - volumeType: AudioVolumeType enum value
            // - mute: boolean indicating if type is muted
            console.log('Volume type: ', event.volumeType);
            console.log('Mute state: ', event.muteState);
            break;

        case AudioEvent.TELEPHONY_MUTE_UPDATE:
            // Triggered when telephony mute state changes
            // Parameters:
            // - deviceType: AudioDevice enum value
            // - address: string representing device address
            // - deviceName: string representing device name
            // - mute: boolean indicating if telephony is muted
            console.log('Telephony mute update!: ');
            console.log('Device type: ', event.deviceType);
            console.log('Device address: ', event.deviceAddress);
            console.log('Device name: ', event.deviceName);
            console.log('Device mute state: ', event.muteState);
            break;
    }
});

// Cleanup
await AudioManager.unregisterAudioEventObserverAsync();

/*
Unregisters callback function and stores returned AudioStatus type in status after
promise resolves
*/

const status = AudioManager.unregisterAudioEventObserverAsync().then((status) => {return status;}).catch((error) => console.log(error));

//Returns true if server is ready to receive commands, false if not ready
const server_ready = AudioManager.isServerReadyAsync()
.then((ready) => {return ready;}).catch((error) => console.log(error));

let muteStatus = await AudioManager.setTelephonyMuteAsync(AudioDevice.DEVICE_TELEPHONY, "0X859978AF", true);
if (muteStatus == 0) {
    console.log("setTelephonyMuteAsync(): Result: SUCCESS")
    status = status + "setTelephonyMuteAsync():\nResult: SUCCESS\n";
} else {
    console.log("setTelephonyMuteAsync(): Result: ERROR: ", muteStatus);
    status = status + "setTelephonyMuteAsync():\nResult: ERROR: " + muteStatus.toString() + "\n";
}

let muteStatus = await AudioManager.getTelephonyMuteAsync(AudioDevice.DEVICE_TELEPHONY, "0X859978AF");
console.log("getTelephonyMuteAsync(): SUCCESS, Mute state: ", Boolean(muteStatus));

export const testSetActiveVolumeAsync = async (volume: number) => {
    let requestStatus = await AudioManager.setActiveVolumeAsync(parseInt(volume));

    if (requestStatus == 0) {
        console.log("setActiveVolumeAsync SUCCESS");
    } else {
        console.log("setActiveVolumeAsync(): ERROR: " + requestStatus);
    }
};

const testUpdateVolumeAsync = async () => {
    let updateStatus = await AudioManager.updateVolumeAsync(AudioVolumeType.VOLUME_TYPE_MEDIA, 0);

    if (updateStatus == 0) {
        console.log("updateVolumeAsync() SUCCESS");
    } else {
        console.log("updateVolumeAsync(): ERROR: " + updateStatus);
    }
};

const testUpdateActiveVolumeAsync = async () => {
    let updateStatus = await AudioManager.updateActiveVolumeAsync(0, AudioVolumeType.VOLUME_TYPE_MEDIA);

    if (updateStatus == 0) {
        console.log("updateActiveVolumeAsync() SUCCESS");
    } else {
        console.log("updateActiveVolumeAsync(): ERROR: " + updateStatus);
    }
};

const testSetMuteAsync = async () => {
    let updateStatus = await AudioManager.setMuteAsync(AudioVolumeType.VOLUME_TYPE_MEDIA, true);

    if (updateStatus == 0) {
        console.log("setMuteAsync() SUCCESS");
    } else {
        console.log("setMuteAsync(): ERROR: " + updateStatus);
    }
};

const testGetMuteAsync = async () => {
    let muteStatus = await AudioManager.setMuteAsync(AudioVolumeType.VOLUME_TYPE_MEDIA);
    console.log("setMuteAsync(): SUCCESS, Mute state: ", Boolean(muteStatus));
};

const testSetMaxVolume = async () => {
    let volumeChangeStatus = await AudioManager.setMaxVolumeAsync(50);
    if (volumeChangeStatus == 0) {
        console.log("setMaxVolumeAsync() SUCCESS");
    } else {
        console.log("setMaxVolumeAsync(): ERROR: " + volumeChangeStatus);
    }
};

const testGetMaxVolume = async () => {
    let maxVolume = await AudioManager.getMaxVolumeAsync();
    console.log("getMaxVolumeAsync(): SUCCESS, Max volume: ", maxVolume);
};

let supportedAudioConfigs = await AudioManager.getSupportedPlaybackConfigurationsAsync(configAttr, AudioDevice.DEVICE_DEFAULT);

for (let audioConfig: supportedAudioConfigs) {
  console.log("format", audioConfig.format);
  console.log("sample rate", audioConfig.sampleRate);
  console.log("channel mask", audioConfig.channelMask);
  console.log("layout", audioConfig.layout);
}

const testSetSinkFormatsSelectionPolicyAsync = async () => {
    let sinkStatus = await AudioManager.setSinkFormatsSelectionPolicyAsync(SinkFormatsSelectionPolicy.AUTO);
    if (sinkStatus == 0) {
        console.log("setSinkFormatsSelectionPolicyAsync(): Result: SUCCESS")
    } else {
        console.log("setSinkFormatsSelectionPolicyAsync(): Result: ERROR: ", sinkStatus);
    }
};

const testGetSinkFormatsSelectionPolicyAsync = async () => {
    let currentSinkPolicy = await AudioManager.getSinkFormatsSelectionPolicyAsync();
    console.log("getSinkFormatsSelectionPolicyAsync() Current format: ", currentSinkPolicy);
};

const testGetSupportedSinkFormatsSelectionPoliciesAsync = async () => {
    let supportedSinkFormats = await AudioManager.getSupportedSinkFormatsSelectionPoliciesAsync();

    if (supportedSinkFormats.length > 0) {
        supportedSinkFormats.forEach(data => {
            console.log("Supported policy (integer representation): ", parseInt(data), "\n");
        });
    }
};