/*
|
* Copyright (C) 2019 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.android.settings.notification;
|
|
import android.content.Context;
|
import android.media.session.MediaController;
|
import android.media.session.MediaSession;
|
import android.media.session.MediaSessionManager;
|
import android.net.Uri;
|
import android.os.Looper;
|
import android.text.TextUtils;
|
|
import androidx.annotation.VisibleForTesting;
|
import androidx.lifecycle.OnLifecycleEvent;
|
import androidx.preference.PreferenceScreen;
|
|
import com.android.settings.R;
|
import com.android.settings.slices.SliceBackgroundWorker;
|
import com.android.settingslib.core.lifecycle.Lifecycle;
|
import com.android.settingslib.volume.MediaSessions;
|
|
import java.io.IOException;
|
import java.util.List;
|
import java.util.Objects;
|
|
public class RemoteVolumePreferenceController extends VolumeSeekBarPreferenceController {
|
|
private static final String KEY_REMOTE_VOLUME = "remote_volume";
|
@VisibleForTesting
|
static final int REMOTE_VOLUME = 100;
|
|
private MediaSessions mMediaSessions;
|
@VisibleForTesting
|
MediaSession.Token mActiveToken;
|
@VisibleForTesting
|
MediaController mMediaController;
|
|
@VisibleForTesting
|
MediaSessions.Callbacks mCallbacks = new MediaSessions.Callbacks() {
|
@Override
|
public void onRemoteUpdate(MediaSession.Token token, String name,
|
MediaController.PlaybackInfo pi) {
|
if (mActiveToken == null) {
|
updateToken(token);
|
}
|
if (Objects.equals(mActiveToken, token)) {
|
updatePreference(mPreference, mActiveToken, pi);
|
}
|
}
|
|
@Override
|
public void onRemoteRemoved(MediaSession.Token t) {
|
if (Objects.equals(mActiveToken, t)) {
|
updateToken(null);
|
if (mPreference != null) {
|
mPreference.setVisible(false);
|
}
|
}
|
}
|
|
@Override
|
public void onRemoteVolumeChanged(MediaSession.Token token, int flags) {
|
if (Objects.equals(mActiveToken, token)) {
|
final MediaController.PlaybackInfo pi = mMediaController.getPlaybackInfo();
|
if (pi != null) {
|
setSliderPosition(pi.getCurrentVolume());
|
}
|
}
|
}
|
};
|
|
public RemoteVolumePreferenceController(Context context) {
|
super(context, KEY_REMOTE_VOLUME);
|
mMediaSessions = new MediaSessions(context, Looper.getMainLooper(), mCallbacks);
|
updateToken(getActiveRemoteToken(mContext));
|
}
|
|
@Override
|
public int getAvailabilityStatus() {
|
// Always return true to make it indexed in database
|
return AVAILABLE_UNSEARCHABLE;
|
}
|
|
/**
|
* Return {@link android.media.session.MediaSession.Token} for active remote token, or
|
* {@code null} if there is no active remote token.
|
*/
|
public static MediaSession.Token getActiveRemoteToken(Context context) {
|
final MediaSessionManager sessionManager = context.getSystemService(
|
MediaSessionManager.class);
|
final List<MediaController> controllers = sessionManager.getActiveSessions(null);
|
for (MediaController mediaController : controllers) {
|
final MediaController.PlaybackInfo pi = mediaController.getPlaybackInfo();
|
if (isRemote(pi)) {
|
return mediaController.getSessionToken();
|
}
|
}
|
|
// No active remote media at this point
|
return null;
|
}
|
|
@Override
|
public void displayPreference(PreferenceScreen screen) {
|
super.displayPreference(screen);
|
mPreference.setVisible(mActiveToken != null);
|
if (mMediaController != null) {
|
updatePreference(mPreference, mActiveToken, mMediaController.getPlaybackInfo());
|
}
|
}
|
|
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
|
public void onResume() {
|
super.onResume();
|
mMediaSessions.init();
|
}
|
|
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
|
public void onPause() {
|
super.onPause();
|
mMediaSessions.destroy();
|
}
|
|
@Override
|
public int getSliderPosition() {
|
if (mPreference != null) {
|
return mPreference.getProgress();
|
}
|
if (mMediaController == null) {
|
return 0;
|
}
|
final MediaController.PlaybackInfo playbackInfo = mMediaController.getPlaybackInfo();
|
return playbackInfo != null ? playbackInfo.getCurrentVolume() : 0;
|
}
|
|
@Override
|
public boolean setSliderPosition(int position) {
|
if (mPreference != null) {
|
mPreference.setProgress(position);
|
}
|
if (mMediaController == null) {
|
return false;
|
}
|
mMediaController.setVolumeTo(position, 0);
|
return true;
|
}
|
|
@Override
|
public int getMax() {
|
if (mPreference != null) {
|
return mPreference.getMax();
|
}
|
if (mMediaController == null) {
|
return 0;
|
}
|
final MediaController.PlaybackInfo playbackInfo = mMediaController.getPlaybackInfo();
|
return playbackInfo != null ? playbackInfo.getMaxVolume() : 0;
|
}
|
|
@Override
|
public int getMin() {
|
if (mPreference != null) {
|
return mPreference.getMin();
|
}
|
return 0;
|
}
|
|
@Override
|
public boolean isSliceable() {
|
return TextUtils.equals(getPreferenceKey(), KEY_REMOTE_VOLUME);
|
}
|
|
@Override
|
public boolean useDynamicSliceSummary() {
|
return true;
|
}
|
|
@Override
|
public String getPreferenceKey() {
|
return KEY_REMOTE_VOLUME;
|
}
|
|
@Override
|
public int getAudioStream() {
|
// This can be anything because remote volume controller doesn't rely on it.
|
return REMOTE_VOLUME;
|
}
|
|
@Override
|
public int getMuteIcon() {
|
return R.drawable.ic_volume_remote_mute;
|
}
|
|
public static boolean isRemote(MediaController.PlaybackInfo pi) {
|
return pi != null
|
&& pi.getPlaybackType() == MediaController.PlaybackInfo.PLAYBACK_TYPE_REMOTE;
|
}
|
|
@Override
|
public Class<? extends SliceBackgroundWorker> getBackgroundWorkerClass() {
|
return RemoteVolumeSliceWorker.class;
|
}
|
|
private void updatePreference(VolumeSeekBarPreference seekBarPreference,
|
MediaSession.Token token, MediaController.PlaybackInfo playbackInfo) {
|
if (seekBarPreference == null || token == null || playbackInfo == null) {
|
return;
|
}
|
|
seekBarPreference.setMax(playbackInfo.getMaxVolume());
|
seekBarPreference.setVisible(true);
|
setSliderPosition(playbackInfo.getCurrentVolume());
|
}
|
|
private void updateToken(MediaSession.Token token) {
|
mActiveToken = token;
|
if (token != null) {
|
mMediaController = new MediaController(mContext, mActiveToken);
|
} else {
|
mMediaController = null;
|
}
|
}
|
|
/**
|
* Listener for background change to remote volume, which listens callback
|
* from {@code MediaSessions}
|
*/
|
public static class RemoteVolumeSliceWorker extends SliceBackgroundWorker<Void> implements
|
MediaSessions.Callbacks {
|
|
private MediaSessions mMediaSessions;
|
|
public RemoteVolumeSliceWorker(Context context, Uri uri) {
|
super(context, uri);
|
mMediaSessions = new MediaSessions(context, Looper.getMainLooper(), this);
|
}
|
|
@Override
|
protected void onSlicePinned() {
|
mMediaSessions.init();
|
}
|
|
@Override
|
protected void onSliceUnpinned() {
|
mMediaSessions.destroy();
|
}
|
|
@Override
|
public void close() throws IOException {
|
mMediaSessions = null;
|
}
|
|
@Override
|
public void onRemoteUpdate(MediaSession.Token token, String name,
|
MediaController.PlaybackInfo pi) {
|
notifySliceChange();
|
}
|
|
@Override
|
public void onRemoteRemoved(MediaSession.Token t) {
|
notifySliceChange();
|
}
|
|
@Override
|
public void onRemoteVolumeChanged(MediaSession.Token token, int flags) {
|
notifySliceChange();
|
}
|
}
|
}
|
