| /* |
| * Copyright (C) 2020 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.google.android.car.kitchensink.volume; |
| |
| import static android.car.media.CarAudioManager.AUDIO_FEATURE_VOLUME_GROUP_MUTING; |
| import static android.media.AudioManager.FLAG_PLAY_SOUND; |
| |
| import android.car.media.CarAudioManager; |
| import android.media.AudioAttributes; |
| import android.media.AudioAttributes.AttributeUsage; |
| import android.media.AudioManager; |
| import android.media.Ringtone; |
| import android.media.RingtoneManager; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.Message; |
| import android.util.Log; |
| import android.util.SparseIntArray; |
| import android.view.LayoutInflater; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.widget.ListView; |
| |
| import androidx.fragment.app.Fragment; |
| |
| import com.android.internal.annotations.GuardedBy; |
| |
| import com.google.android.car.kitchensink.R; |
| import com.google.android.car.kitchensink.volume.VolumeTestFragment.CarAudioZoneVolumeInfo; |
| |
| public final class CarAudioZoneVolumeFragment extends Fragment { |
| private static final String TAG = "CarVolumeTest." |
| + CarAudioZoneVolumeFragment.class.getSimpleName(); |
| private static final boolean DEBUG = true; |
| |
| private static final int MSG_VOLUME_CHANGED = 0; |
| private static final int MSG_REQUEST_FOCUS = 1; |
| private static final int MSG_FOCUS_CHANGED = 2; |
| private static final int MSG_STOP_RINGTONE = 3; |
| private static final int MSG_ADJUST_VOLUME = 4; |
| private static final long RINGTONE_STOP_TIME_MS = 3_000; |
| private static final int ADJUST_VOLUME_UP = 0; |
| private static final int ADJUST_VOLUME_DOWN = 1; |
| |
| private final int mZoneId; |
| private final Object mLock = new Object(); |
| private final CarAudioManager mCarAudioManager; |
| private final AudioManager mAudioManager; |
| private CarAudioZoneVolumeInfo[] mVolumeInfos = |
| new CarAudioZoneVolumeInfo[0]; |
| private final Handler mHandler = new VolumeHandler(); |
| |
| private CarAudioZoneVolumeAdapter mCarAudioZoneVolumeAdapter; |
| private final SparseIntArray mGroupIdIndexMap = new SparseIntArray(); |
| |
| @GuardedBy("mLock") |
| private Ringtone mRingtone; |
| |
| void sendVolumeChangedMessage(int groupId, int flags) { |
| mHandler.sendMessage(mHandler.obtainMessage(MSG_VOLUME_CHANGED, groupId, flags)); |
| } |
| |
| void adjustVolumeUp(int groupId) { |
| mHandler.sendMessage(mHandler.obtainMessage(MSG_ADJUST_VOLUME, groupId, ADJUST_VOLUME_UP)); |
| } |
| |
| void adjustVolumeDown(int groupId) { |
| mHandler.sendMessage(mHandler |
| .obtainMessage(MSG_ADJUST_VOLUME, groupId, ADJUST_VOLUME_DOWN)); |
| } |
| |
| private class VolumeHandler extends Handler { |
| private AudioFocusListener mFocusListener; |
| |
| @Override |
| public void handleMessage(Message msg) { |
| if (DEBUG) { |
| Log.d(TAG, "zone " + mZoneId + " handleMessage : " + getMessageName(msg)); |
| } |
| switch (msg.what) { |
| case MSG_VOLUME_CHANGED: |
| initVolumeInfo(); |
| playRingtoneForGroup(msg.arg1, msg.arg2); |
| break; |
| case MSG_STOP_RINGTONE: |
| stopRingtone(); |
| break; |
| case MSG_REQUEST_FOCUS: |
| int groupId = msg.arg1; |
| if (mFocusListener != null) { |
| mAudioManager.abandonAudioFocus(mFocusListener); |
| mVolumeInfos[mGroupIdIndexMap.get(groupId)].hasAudioFocus = false; |
| mCarAudioZoneVolumeAdapter.notifyDataSetChanged(); |
| } |
| |
| mFocusListener = new AudioFocusListener(groupId); |
| mAudioManager.requestAudioFocus(mFocusListener, groupId, |
| AudioManager.AUDIOFOCUS_GAIN); |
| break; |
| case MSG_FOCUS_CHANGED: |
| int focusGroupId = msg.arg1; |
| mVolumeInfos[mGroupIdIndexMap.get(focusGroupId)].hasAudioFocus = true; |
| mCarAudioZoneVolumeAdapter.refreshVolumes(mVolumeInfos); |
| break; |
| case MSG_ADJUST_VOLUME: |
| adjustVolumeByOne(msg.arg1, msg.arg2 == ADJUST_VOLUME_UP); |
| break; |
| default: |
| Log.wtf(TAG, "VolumeHandler handleMessage called with unknown message" |
| + msg.what); |
| } |
| } |
| } |
| |
| public CarAudioZoneVolumeFragment(int zoneId, CarAudioManager carAudioManager, |
| AudioManager audioManager) { |
| mZoneId = zoneId; |
| mCarAudioManager = carAudioManager; |
| mAudioManager = audioManager; |
| } |
| |
| @Override |
| public View onCreateView(LayoutInflater inflater, ViewGroup container, |
| Bundle savedInstanceState) { |
| if (DEBUG) { |
| Log.d(TAG, "onCreateView " + mZoneId); |
| } |
| View v = inflater.inflate(R.layout.zone_volume_tab, container, false); |
| ListView volumeListView = v.findViewById(R.id.volume_list); |
| mCarAudioZoneVolumeAdapter = |
| new CarAudioZoneVolumeAdapter(getContext(), R.layout.volume_item, mVolumeInfos, |
| this, mCarAudioManager.isAudioFeatureEnabled( |
| AUDIO_FEATURE_VOLUME_GROUP_MUTING)); |
| initVolumeInfo(); |
| volumeListView.setAdapter(mCarAudioZoneVolumeAdapter); |
| return v; |
| } |
| |
| void initVolumeInfo() { |
| int volumeGroupCount = mCarAudioManager.getVolumeGroupCount(mZoneId); |
| mVolumeInfos = new CarAudioZoneVolumeInfo[volumeGroupCount + 1]; |
| mGroupIdIndexMap.clear(); |
| CarAudioZoneVolumeInfo titlesInfo = new CarAudioZoneVolumeInfo(); |
| titlesInfo.id = "Group id"; |
| titlesInfo.currentGain = "Current"; |
| mVolumeInfos[0] = titlesInfo; |
| |
| int i = 1; |
| for (int groupId = 0; groupId < volumeGroupCount; groupId++) { |
| CarAudioZoneVolumeInfo volumeInfo = new CarAudioZoneVolumeInfo(); |
| mGroupIdIndexMap.put(groupId, i); |
| volumeInfo.groupId = groupId; |
| volumeInfo.id = String.valueOf(groupId); |
| int current = mCarAudioManager.getGroupVolume(mZoneId, groupId); |
| int max = mCarAudioManager.getGroupMaxVolume(mZoneId, groupId); |
| int min = mCarAudioManager.getGroupMinVolume(mZoneId, groupId); |
| volumeInfo.currentGain = String.valueOf(current); |
| volumeInfo.maxGain = max; |
| volumeInfo.minGain = min; |
| volumeInfo.isMuted = mCarAudioManager.isVolumeGroupMuted(mZoneId, groupId); |
| |
| mVolumeInfos[i] = volumeInfo; |
| if (DEBUG) { |
| Log.d(TAG, groupId + " max: " + volumeInfo.maxGain + " current: " |
| + volumeInfo.currentGain + " is muted " + volumeInfo.isMuted); |
| } |
| i++; |
| } |
| mCarAudioZoneVolumeAdapter.refreshVolumes(mVolumeInfos); |
| } |
| |
| private void adjustVolumeByOne(int groupId, boolean up) { |
| if (mCarAudioManager == null) { |
| Log.e(TAG, "CarAudioManager is null"); |
| return; |
| } |
| int current = mCarAudioManager.getGroupVolume(mZoneId, groupId); |
| CarAudioZoneVolumeInfo info = getVolumeInfo(groupId); |
| int volume = up ? current + 1 : current - 1; |
| if (volume > info.maxGain) { |
| if (DEBUG) { |
| Log.d(TAG, "Reached " + groupId + " max volume " |
| + " limit " + volume); |
| } |
| return; |
| } |
| if (volume < info.minGain) { |
| if (DEBUG) { |
| Log.d(TAG, "Reached " + groupId + " min volume " |
| + " limit " + volume); |
| } |
| return; |
| } |
| mCarAudioManager.setGroupVolume(mZoneId, groupId, volume, /* flags= */ 0); |
| if (DEBUG) { |
| Log.d(TAG, "Set group " + groupId + " volume " |
| + mCarAudioManager.getGroupVolume(mZoneId, groupId) |
| + " in audio zone " + mZoneId); |
| } |
| } |
| |
| private CarAudioZoneVolumeInfo getVolumeInfo(int groupId) { |
| return mVolumeInfos[mGroupIdIndexMap.get(groupId)]; |
| } |
| |
| public void toggleMute(int groupId) { |
| if (mCarAudioManager == null) { |
| Log.e(TAG, "CarAudioManager is null"); |
| return; |
| } |
| boolean isMuted = mCarAudioManager.isVolumeGroupMuted(mZoneId, groupId); |
| mCarAudioManager.setVolumeGroupMute(mZoneId, groupId, !isMuted, AudioManager.FLAG_SHOW_UI); |
| if (DEBUG) { |
| Log.d(TAG, "Set group mute " + groupId + " mute " + !isMuted + " in audio zone " |
| + mZoneId); |
| } |
| } |
| |
| void requestFocus(int groupId) { |
| // Automatic volume change only works for primary audio zone. |
| if (mZoneId == CarAudioManager.PRIMARY_AUDIO_ZONE) { |
| mHandler.sendMessage(mHandler |
| .obtainMessage(MSG_REQUEST_FOCUS, groupId, /* arg2= */ 0)); |
| } |
| } |
| |
| private void playRingtoneForGroup(int groupId, int flags) { |
| if (DEBUG) { |
| Log.d(TAG, "playRingtoneForGroup(" + groupId + ") in zone " + mZoneId); |
| } |
| |
| if ((flags & FLAG_PLAY_SOUND) == 0) { |
| return; |
| } |
| |
| int usage = mCarAudioManager.getUsagesForVolumeGroupId(mZoneId, groupId)[0]; |
| if (isRingtoneActiveForUsage(usage)) { |
| return; |
| } |
| |
| mHandler.removeMessages(MSG_STOP_RINGTONE); |
| |
| stopRingtone(); |
| startRingtone(usage); |
| |
| mHandler.sendEmptyMessageDelayed(MSG_STOP_RINGTONE, RINGTONE_STOP_TIME_MS); |
| } |
| |
| private void startRingtone(@AttributeUsage int usage) { |
| if (DEBUG) { |
| Log.d(TAG, "Start ringtone for zone " + mZoneId + " and usage " |
| + AudioAttributes.usageToString(usage)); |
| } |
| AudioAttributes attributes = new AudioAttributes.Builder() |
| .setUsage(usage) |
| .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION) |
| .build(); |
| |
| Uri uri = RingtoneManager.getActualDefaultRingtoneUri(getContext(), |
| AudioAttributes.toLegacyStreamType(attributes)); |
| |
| Ringtone ringtone = |
| RingtoneManager.getRingtone(mCarAudioZoneVolumeAdapter.getContext(), uri); |
| ringtone.setAudioAttributes(attributes); |
| ringtone.setLooping(true); |
| |
| ringtone.play(); |
| |
| synchronized (mLock) { |
| mRingtone = ringtone; |
| } |
| } |
| |
| private void stopRingtone() { |
| synchronized (mLock) { |
| if (mRingtone == null) { |
| return; |
| } |
| if (mRingtone.isPlaying()) { |
| mRingtone.stop(); |
| } |
| mRingtone = null; |
| } |
| } |
| |
| boolean isRingtoneActiveForUsage(@AttributeUsage int usage) { |
| synchronized (mLock) { |
| return mRingtone != null && mRingtone.isPlaying() |
| && mRingtone.getAudioAttributes().getUsage() == usage; |
| } |
| } |
| |
| private class AudioFocusListener implements AudioManager.OnAudioFocusChangeListener { |
| private final int mGroupId; |
| AudioFocusListener(int groupId) { |
| mGroupId = groupId; |
| } |
| @Override |
| public void onAudioFocusChange(int focusChange) { |
| if (focusChange == AudioManager.AUDIOFOCUS_GAIN) { |
| mHandler.sendMessage(mHandler |
| .obtainMessage(MSG_FOCUS_CHANGED, mGroupId, /* arg2= */ 0)); |
| } else { |
| Log.e(TAG, "Audio focus request failed"); |
| } |
| } |
| } |
| } |