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() 現在のフォーマット：", currentSinkPolicy);
};

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

for (let audioConfig: supportedAudioConfigs) {
  console.log("フォーマット", audioConfig.format);
  console.log("サンプルレート", audioConfig.sampleRate);
  console.log("チャンネルマスク", audioConfig.channelMask);
  console.log("レイアウト", audioConfig.layout);
}

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

    if (supportedSinkFormats.length > 0) {
        supportedSinkFormats.forEach(data => {
            console.log("サポート対象ポリシー（整数表現）：", 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('音量が変更されました：', 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('音量タイプ：', 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が成功");
    } 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()が成功");
    } 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()が成功");
    } else {
        console.log("setMuteAsync()： ERROR: " + updateStatus);
    }
};

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

let muteStatus = await AudioManager.setTelephonyMuteAsync(AudioDevice.DEVICE_TELEPHONY, "0X859978AF", true);
if (muteStatus == 0) {
    console.log("setTelephonyMuteAsync()： 結果： SUCCESS")
    status = status + "setTelephonyMuteAsync():\nResult: SUCCESS\n";
} else {
    console.log("setTelephonyMuteAsync()： 結果： 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()が成功");
    } 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()が成功");
    } else {
        console.log("updateVolumeAsync()： ERROR: " + updateStatus);
    }
};