AudioManager

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

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

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

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

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

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

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

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

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

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

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

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

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

// 如果服务器准备好接收命令，则返回true；如果未准备就绪，则返回false
const server_ready = AudioManager.isServerReadyAsync()
.then((ready) => {return ready;}).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
// 事件对象将根据事件类型包含不同的属性

// 当音频设备的连接状态发生变化时触发
await AudioManager.registerAudioEventObserverAsync((event) => {
    // 参数：
    switch (event.audioEvent) {
        case AudioEvent.DEVICE_STATE_UPDATE:
            // - device: AudioDevice枚举值
            // - role: AudioRole枚举值
            // - connect：表示设备是已连接 (true) 还是已断开连接 (false) 的布尔值
            // 当任何音频类型的音量发生变化时触发
            // 参数：
            console.log(`Device ${event.device} with role ${event.role} ${event.connect ? 'connected' : 'disconnected'}`);
            break;

        case AudioEvent.VOLUME_UPDATE:
            // - type: AudioVolumeType枚举值
            // - volume：数字 (0-100)
            // 当全局静音状态发生变化时触发
            // 参数：
            console.log('Volume changed for:', event.audioEvent, 'to:', event.volume);
            break;

        case AudioEvent.GLOBAL_VOLUME_MUTE_UPDATE:
            // - mute：表示系统是否静音的布尔值
            // 当音频服务器变得不可用时触发
            // 当音频服务器变得可用时触发
            console.log('全局静音更新为状态：', event.mute);
            break;

        case AudioEvent.SERVER_DOWN:
            // 当音频使用状态发生变化时触发
            console.log('音频服务器停止');
            break;

        case AudioEvent.SERVER_UP:
            // 参数：
            console.log('音频服务器已启动');
            break;

        case AudioEvent.AUDIO_USAGE_STATE_CHANGE:
            // - usage: AudioUsageType枚举值
            // - active：表示使用是否处于活动状态的布尔值
            // 当麦克风静音状态发生变化时触发
            // 参数：
            console.log('使用情况：', event.usage);
            console.log('活动状态：', event.active);
            break;

        case AudioEvent.MIC_MUTE_STATE_UPDATE:
            // - state：表示麦克风是否静音的布尔值
            // 当特定音量类型的音量静音状态发生变化时触发
            // 参数：
            console.log('麦克风静音状态已更改：', event.muteState);
            break;

        case AudioEvent.VOLUME_MUTE_UPDATE:
            // - volumeType: AudioVolumeType枚举值
            // - mute：表示类型是否静音的布尔值
            // 当电话静音状态发生变化时触发
            // 参数：
            console.log('Volume type: ', event.volumeType);
            console.log('静音状态：', event.muteState);
            break;

        case AudioEvent.TELEPHONY_MUTE_UPDATE:
            // - deviceType: AudioDevice枚举值
            // - address：表示设备地址的字符串
            // - deviceName：表示设备名称的字符串
            // - mute：表示电话是否静音的布尔值
            // 清理
            // - mute：表示电话是否静音的布尔值
            console.log('电话静音更新！：');
            console.log('设备类型：', event.deviceType);
            console.log('设备地址：', event.deviceAddress);
            console.log('设备名称：', event.deviceName);
            console.log('设备静音状态：', event.muteState);
            break;
    }
});

// 清理
await AudioManager.unregisterAudioEventObserverAsync();

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

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

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

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

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 testSetSinkFormatsSelectionPolicyAsync = async () => {
    let sinkStatus = await AudioManager.setSinkFormatsSelectionPolicyAsync(SinkFormatsSelectionPolicy.AUTO);
    if (sinkStatus == 0) {
        console.log("setSinkFormatsSelectionPolicyAsync(): Result: SUCCESS")
    } else {
        console.log("setSinkFormatsSelectionPolicyAsync(): Result: ERROR: ", sinkStatus);
    }
};

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

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

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

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