public void OnAudioFocusChange(AudioFocus focusChange) { switch (focusChange) { case AudioFocus.Gain: if (player == null) { IntializePlayer(); } if (!player.IsPlaying) { player.Start(); OpenActivity.pause = false; } player.SetVolume(1.0f, 1.0f); break; case AudioFocus.Loss: Stop(); break; case AudioFocus.LossTransientCanDuck: if (player.IsPlaying) { player.SetVolume(.1f, .1f); } break; } }
public void OnAudioFocusChange([GeneratedEnum] AudioFocus focusChange) { switch (focusChange) { case AudioFocus.Gain: musicaplayer.SetVolume(1.0f, 1.0f); //Turn it up! break; case AudioFocus.Loss: //We have lost focus stop! musicaplayer.SetVolume(0f, 0f); //turn it down! break; case AudioFocus.LossTransient: //We have lost focus for a short time, but likely to resume so pause musicaplayer.SetVolume(0f, 0f); break; case AudioFocus.LossTransientCanDuck: //We have lost focus but should till play at a muted 10% volume if (musicaplayer.IsPlaying) { musicaplayer.SetVolume(.1f, .1f); //turn it down! } break; } }
/// <summary> /// For a good user experience we should account for when audio focus has changed. /// There is only 1 audio output there may be several media services trying to use it so /// we should act correctly based on this. "duck" to be quiet and when we gain go full. /// All applications are encouraged to follow this, but are not enforced. /// </summary> /// <param name="focusChange"></param> public async void OnAudioFocusChange(AudioFocus focusChange) { switch (focusChange) { case AudioFocus.Gain: if (TransientPaused && !ManuallyPaused) { await Play(); } SetVolume(1.0f, 1.0f); //Turn it up! TransientPaused = false; break; case AudioFocus.Loss: //We have lost focus stop! await Stop(); break; case AudioFocus.LossTransient: //We have lost focus for a short time, but likely to resume so pause TransientPaused = true; await Pause(); break; case AudioFocus.LossTransientCanDuck: //We have lost focus but should still play at a muted 10% volume SetVolume(.1f, .1f); break; } }
public void OnAudioFocusChange(AudioFocus focusChange) { print("AUDIOFOCUS CHANGED:::: " + focusChange.ToString() + "|" + (int)focusChange); switch (focusChange) { case AudioFocus.GainTransient: FocusChanged?.Invoke(this, true); break; case AudioFocus.LossTransient: FocusChanged?.Invoke(this, false); break; case AudioFocus.Loss: FocusChanged?.Invoke(this, false); break; case AudioFocus.GainTransientExclusive: FocusChanged?.Invoke(this, true); break; case AudioFocus.Gain: FocusChanged?.Invoke(this, true); break; } }
/// <summary> /// For a good user experience we should account for when audio focus has changed. /// There is only 1 audio output there may be several media services trying to use it so /// we should act correctly based on this. "duck" to be quiet and when we gain go full. /// All applications are encouraged to follow this, but are not enforced. /// </summary> /// <param name="focusChange"></param> public void OnAudioFocusChange(AudioFocus focusChange) { switch (focusChange) { case AudioFocus.Gain: ////if (player == null) //// IntializePlayer(); ////if (!player.IsPlaying) ////{ //// player.Start(); //// paused = false; ////} ////player.SetVolume(1.0f, 1.0f);//Turn it up! break; case AudioFocus.Loss: //We have lost focus stop! Stop(); break; case AudioFocus.LossTransient: //We have lost focus for a short time, but likely to resume so pause Pause(); break; case AudioFocus.LossTransientCanDuck: //We have lost focus but should till play at a muted 10% volume ////if (player.IsPlaying) //// player.SetVolume(.1f, .1f);//turn it down! break; } }
public void OnAudioFocusChange(AudioFocus focusChange) { try { switch (focusChange) { case AudioFocus.Gain: case AudioFocus.LossTransientCanDuck: // Resume your media player here break; case AudioFocus.Loss: case AudioFocus.LossTransient: try { //if (Constant.Player.PlayWhenReady) //{ // GetPlayerService()?.TogglePlay(); //} } catch (Exception e) { Console.WriteLine(e); } break; } } catch (Exception e) { Console.WriteLine(e); } }
public void OnAudioFocusChange(AudioFocus focusChange) { switch (focusChange) { case AudioFocus.Gain: audioFocus = PlayerAudioState.Focused; break; case AudioFocus.Loss: case AudioFocus.GainTransient: case AudioFocus.LossTransientCanDuck: var canDuck = focusChange == AudioFocus.LossTransientCanDuck; audioFocus = canDuck ? PlayerAudioState.NoFocusCanDuck : PlayerAudioState.NoFocusNoDuck; if (State == PlaybackStateCompat.StatePlaying && !canDuck) { playOnFocus = true; } break; default: Console.WriteLine($"Audio focus changed {focusChange}"); break; } ConfigureMediaPlayerState(); }
public void OnAudioFocusChange([GeneratedEnum] AudioFocus focusChange) { switch (focusChange) { case AudioFocus.Gain: if (_player != null) { if (!_player.IsPlaying) { Play(); UpdatePlaybackState(PlaybackStateCompat.StatePlaying); } _player.SetVolume(1.0f, 1.0f); } break; case AudioFocus.Loss: Pause(); break; case AudioFocus.LossTransient: Pause(); break; case AudioFocus.LossTransientCanDuck: if (_player != null && _player.IsPlaying) { _player.SetVolume(.1f, .1f); } break; } }
// stop the player if we lose focus / play if we get it back void AudioManager.IOnAudioFocusChangeListener.OnAudioFocusChange(AudioFocus focusChange) { switch (focusChange) { case AudioFocus.Loss: case AudioFocus.LossTransient: HandleActionAsync(ServiceActions.Pause); break; case AudioFocus.Gain: //case AudioFocus.GainTransient: HandleActionAsync(ServiceActions.Play); break; case AudioFocus.LossTransientCanDuck: player.SetVolume(0.2f, 0.2f); // lower volume break; case AudioFocus.GainTransientMayDuck: player.SetVolume(1f, 1f); // bring back volume break; } }
/// <summary> /// Properly cleanup of your player by releasing resources /// </summary> //public override void OnDestroy() //{ // base.OnDestroy(); // if (mediaPlayer != null) // { // mediaPlayer.Release(); // mediaPlayer = null; // } //} /// <summary> /// For a good user experience we should account for when audio focus has changed. /// There is only 1 audio output there may be several media services trying to use it so /// we should act correctly based on this. "duck" to be quiet and when we gain go full. /// All applications are encouraged to follow this, but are not enforced. /// </summary> /// <_parameter name="focusChange"></_parameter> public void OnAudioFocusChange(AudioFocus focusChange) { switch (focusChange) { case AudioFocus.Gain: if (!MediaPlayer.IsPlaying) { MediaPlayer.Start(); isPaused = false; } MediaPlayer.SetVolume(1.0f, 1.0f); //Turn it up! break; case AudioFocus.Loss: //We have lost focus stop! Stop(); break; case AudioFocus.LossTransient: //We have lost focus for a short time, but likely to resume so pause Pause(); break; case AudioFocus.LossTransientCanDuck: //We have lost focus but should till play at a muted 10% volume if (MediaPlayer.IsPlaying) { MediaPlayer.SetVolume(.1f, .1f); //turn it down! } break; } }
/// <summary> /// Focus change, when user change application /// </summary> /// <param name="focusChange">Check app audio focus</param> public void OnAudioFocusChange(AudioFocus focusChange) { switch (focusChange) { case AudioFocus.Gain: if (_player == null) { IntializePlayer(); } if (!_player.IsPlaying) { _player.Start(); _paused = false; } _player.SetVolume(1.0f, 1.0f); //Turn it up! break; case AudioFocus.Loss: //We have lost focus stop! Stop(); break; case AudioFocus.LossTransient: Pause(); break; case AudioFocus.LossTransientCanDuck: if (_player.IsPlaying) { _player.SetVolume(.1f, .1f); //turn it down! } break; } }
void AudioManager.IOnAudioFocusChangeListener.OnAudioFocusChange(AudioFocus focusChange) { var maxVolume = _audioManager.GetStreamMaxVolume(Stream.Music); switch (focusChange) { case AudioFocus.Gain: Start(); if (_previousAudioVolume != null) { _audioManager.SetStreamVolume(Stream.Music, _previousAudioVolume.Value, VolumeNotificationFlags.RemoveSoundAndVibrate); _previousAudioVolume = null; } break; case AudioFocus.Loss: case AudioFocus.LossTransient: Stop(); break; case AudioFocus.LossTransientCanDuck: _previousAudioVolume = _audioManager.GetStreamVolume(Stream.Music); _audioManager.SetStreamVolume(Stream.Music, (int)Math.Round(maxVolume * 0.1), VolumeNotificationFlags.RemoveSoundAndVibrate); break; } }
public void OnAudioFocusChange([GeneratedEnum] AudioFocus focusChange) { switch (focusChange) { case AudioFocus.Gain: break; case AudioFocus.Loss: break; case AudioFocus.LossTransientCanDuck: break; } }
public void OnAudioFocusChange(AudioFocus focus_change) { switch (focus_change) { case AudioFocus.Loss: // Permanent loss of audio focus // Pause playback immediately VoIPManager.hangupCall(null, true); break; } }
public void OnAudioFocusChange(AudioFocus focusChange) { switch (focusChange) { case AudioFocus.GainTransient: break; case AudioFocus.LossTransient: break; } }
void AudioManager.IOnAudioFocusChangeListener.OnAudioFocusChange(AudioFocus focusChange) { switch (focusChange) { case Android.Media.AudioFocus.Gain: case Android.Media.AudioFocus.GainTransient: Play(); break; case Android.Media.AudioFocus.LossTransient: case Android.Media.AudioFocus.Loss: Stop(); break; } }
/// <summary> /// For a good user experience we should account for when audio focus has changed. /// There is only 1 audio output there may be several media services trying to use it so /// we should act correctly based on this. "duck" to be quiet and when we gain go full. /// All applications are encouraged to follow this, but are not enforced. /// </summary> /// <param name="focusChange"></param> public void OnAudioFocusChange(AudioFocus focusChange) { try { switch (focusChange) { case AudioFocus.Gain: if (Player == null) { this.IntializePlayer(); } if (!Player.PlayWhenReady && !this.starting && this.prevPlay) { Player.PlayWhenReady = true; this.paused = false; } //Player.SetVolume(1.0f, 1.0f);//Turn it up! break; case AudioFocus.Loss: //We have lost focus stop! this.prevPlay = Player?.PlayWhenReady ?? false; this.Pause(); break; case AudioFocus.LossTransient: //We have lost focus for a short time, but likely to resume so pause this.prevPlay = Player?.PlayWhenReady ?? false; this.Pause(); break; case AudioFocus.LossTransientCanDuck: //We have lost focus but should till play at a muted 10% volume if (Player.PlayWhenReady) { } //Player.SetVolume(.1f, .1f);//turn it down! break; } } catch { // Ignored } }
public void OnAudioFocusChange([GeneratedEnum] AudioFocus focusChange) { switch (focusChange) { case AudioFocus.Gain: // resume playback if (player == null) { InitPlayer(); } else if (!player.IsPlaying) { player.Start(); } player.SetVolume(1.0f, 1.0f); break; case AudioFocus.Loss: // Lost focus for an unbounded amount of time: stop playback and release media player if (player.IsPlaying) { player.Stop(); } player.Release(); player = null; break; case AudioFocus.LossTransient: // Lost focus for a short time, but we have to stop // playback. We don't release the media player because playback // is likely to resume if (player.IsPlaying) { player.Pause(); } break; case AudioFocus.LossTransientCanDuck: // Lost focus for a short time, but it's ok to keep playing // at an attenuated level if (player.IsPlaying) { player.SetVolume(0.1f, 0.1f); } break; } }
public void OnAudioFocusChange(AudioFocus focusChange) { switch (focusChange) { case AudioFocus.Gain: FocusChanged(this, true); break; case AudioFocus.LossTransient: FocusChanged(this, false); break; case AudioFocus.Loss: FocusChanged(this, false); break; } }
public void OnAudioFocusChange(AudioFocus focusChange) { Logger.Debug($"OnAudioFocusChange. focusChange={focusChange}"); if (focusChange == AudioFocus.Gain) { _audioFocusState = AudioFocusState.Focused; } else if (focusChange == AudioFocus.Loss || focusChange == AudioFocus.LossTransient || focusChange == AudioFocus.LossTransientCanDuck) { bool canDuck = focusChange == AudioFocus.LossTransientCanDuck; _audioFocusState = canDuck ? AudioFocusState.NoFocusAndCanHide : AudioFocusState.NoFocusAndNoHide; _playOnFocusGain |= MusicPlayerState == PlaybackStateCode.Playing && !canDuck; } ConfigMediaPlayerState(); }
/// <summary> /// For a good user experience we should account for when audio focus has changed. /// There is only 1 audio output there may be several media services trying to use it so /// we should act correctly based on this. "duck" to be quiet and when we gain go full. /// All applications are encouraged to follow this, but are not enforced. /// </summary> /// <param name="focusChange"></param> public void OnAudioFocusChange(AudioFocus focusChange) { switch (focusChange) { case AudioFocus.Gain: if (mediaPlayer == null) { InitializePlayer(); } if (!mediaPlayer.IsPlaying && !manuallyPaused) { mediaPlayer.Start(); UpdatePlaybackState(PlaybackStateCompat.StatePlaying); } mediaPlayer.SetVolume(1.0f, 1.0f); //Turn it up! transientPaused = false; break; case AudioFocus.Loss: //We have lost focus stop! Stop(); break; case AudioFocus.LossTransient: //We have lost focus for a short time, but likely to resume so pause transientPaused = true; Pause(); break; case AudioFocus.LossTransientCanDuck: //We have lost focus but should till play at a muted 10% volume if (mediaPlayer.IsPlaying) { mediaPlayer.SetVolume(.1f, .1f); //turn it down! } break; } }
public void OnAudioFocusChange (AudioFocus focusChange) { switch (focusChange) { // We will take any flavor of AudioFocusgain that the system gives us and use it. case AudioFocus.GainTransient: case AudioFocus.GainTransientMayDuck: case AudioFocus.Gain: parent.StartAsync (); SetStatus ("Granted"); break; // If we get any notificationthat removes focus - just terminate what we were doing. case AudioFocus.LossTransientCanDuck: case AudioFocus.LossTransient: case AudioFocus.Loss: parent.Stop (); SetStatus ("Removed"); break; default: break; } }
//public void StartDetect(){ // dtmfClipListener = new DTMFClipListener (true); // dtmfClipListener.DetectSilence = true; // //dtmfClipListener.ToneDetected += OnToneDetected; // //if(!modoComplemento) // dtmfClipListener.NewToken += OnNewToken; // //else // // dtmfClipListener.NewToken += OnNewTokenModoComplemento; // Detecting = true; // recorderThread = new Task( // ()=> // { // clipRecorder = new AudioClipRecorder(dtmfClipListener,recorderThread); // clipRecorder.startRecording (AudioClipRecorder.RECORDER_SAMPLERATE_CD, Android.Media.Encoding.Pcm16bit); // },TaskCreationOptions.LongRunning); // recorderThread.Start(); //} //public void StopDetect(){ // try{ // //if (modoComplemento) // //dtmfClipListener.NewToken -= OnNewTokenModoComplemento; // //else // dtmfClipListener.NewToken -= OnNewToken; // }catch(Exception){;} // dtmfClipListener = null; // tone_detected_reciver = null; // Detecting = false; // if(clipRecorder!=null) // clipRecorder.stopRecording (); // recorderThread = null; //} #endregion public void OnAudioFocusChange(AudioFocus focusChange) { if (prefs_model.Teclado_Enabled || prefs_model.Ready) { switch (focusChange) { case AudioFocus.Loss: StopDetect(); break; case AudioFocus.LossTransient: StopDetect(); break; case AudioFocus.LossTransientCanDuck: StopDetect(); break; case AudioFocus.Gain: StartDetect(); break; case AudioFocus.GainTransient: StartDetect(); break; case AudioFocus.GainTransientExclusive: StartDetect(); break; case AudioFocus.GainTransientMayDuck: StartDetect(); break; default: StopDetect(); break; } } }
/// <summary> /// For a good user experience we should account for when audio focus has changed. /// There is only one audio output there may be several media services trying to use it so /// we should act correctly based on this. "duck" to be quiet and when we gain go full. /// All applications are encouraged to follow this, but are not enforced. /// </summary> /// <param name="focusChange"></param> public void OnAudioFocusChange(AudioFocus focusChange) { Log.Debug(TAG, "StreamingBackgroundService.OnAudioFocusChange() focusChange = " + focusChange); switch (focusChange) { case AudioFocus.Gain: Log.Debug(TAG, "AudioFocus.Gain"); if (mediaPlayer == null) { mediaPlayer = ExoPlayerFactory.NewInstance(1); } if (!IsPlaying) { Play(source); MessagingCenter.Send<PlayerStartedMessage>(new PlayerStartedMessage(), "PlayerStarted"); } mediaPlayer.SendMessage(audioRenderer, MediaCodecAudioTrackRenderer.MsgSetVolume, 1.0f); break; case AudioFocus.Loss: Log.Debug(TAG, "AudioFocus.Loss"); Stop(); MessagingCenter.Send<PlayerStoppedMessage>(new PlayerStoppedMessage(), "PlayerStopped"); break; case AudioFocus.LossTransient: Log.Debug(TAG, "AudioFocus.LossTransient"); // We have lost focus for a short time, but likely to resume Stop(); MessagingCenter.Send<PlayerStoppedMessage>(new PlayerStoppedMessage(), "PlayerStopped"); break; case AudioFocus.LossTransientCanDuck: // We have lost focus but should till play at a muted 10% volume Log.Debug(TAG, "AudioFocus.LossTransientCanDuck"); if (IsPlaying) { mediaPlayer.SendMessage(audioRenderer, MediaCodecAudioTrackRenderer.MsgSetVolume, 0.1f); } break; } }
public void OnAudioFocusChange([GeneratedEnum] AudioFocus focusChange) { string typeOfChange; switch (focusChange) { case AudioFocus.Gain: typeOfChange = "AUDIOFOCUS_GAIN"; break; case AudioFocus.GainTransient: typeOfChange = "AUDIOFOCUS_GAIN_TRANSIENT"; break; case AudioFocus.GainTransientExclusive: typeOfChange = "AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE"; break; case AudioFocus.GainTransientMayDuck: typeOfChange = "AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK"; break; case AudioFocus.Loss: typeOfChange = "AUDIOFOCUS_LOSS"; break; case AudioFocus.LossTransient: typeOfChange = "AUDIOFOCUS_LOSS_TRANSIENT"; break; case AudioFocus.LossTransientCanDuck: typeOfChange = "AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK"; break; default: typeOfChange = "AUDIOFOCUS_INVALID"; break; } }
public void OnAudioFocusChange(AudioFocus focusChange) { switch (focusChange) { // We will take any flavor of AudioFocusgain that the system gives us and use it. case AudioFocus.GainTransient: case AudioFocus.GainTransientMayDuck: case AudioFocus.Gain: parent.StartAsync(); break; // If we get any notificationthat removes focus - just terminate what we were doing. case AudioFocus.LossTransientCanDuck: case AudioFocus.LossTransient: case AudioFocus.Loss: parent.Stop(); break; default: break; } }
/// <summary> /// For a good user experience we should account for when audio focus has changed. /// There is only 1 audio output there may be several media services trying to use it so /// we should act correctly based on this. "duck" to be quiet and when we gain go full. /// All applications are encouraged to follow this, but are not enforced. /// </summary> /// <param name="focusChange"></param> public async void OnAudioFocusChange(AudioFocus focusChange) { switch (focusChange) { case AudioFocus.Gain: if (mediaPlayer == null) { this.InitializePlayer(); } if (!mediaPlayer.IsPlaying) { mediaPlayer.Start(); } mediaPlayer.SetVolume(1.0f, 1.0f); //Turn it up! break; case AudioFocus.Loss: //We have lost focus stop! await this.Stop(); break; case AudioFocus.LossTransient: //We have lost focus for a short time, but likely to resume so pause await this.Pause(); break; case AudioFocus.LossTransientCanDuck: //We have lost focus but should till play at a muted 10% volume if (mediaPlayer.IsPlaying) { mediaPlayer.SetVolume(.1f, .1f); //turn it down! } break; } }
public void OnAudioFocusChange(AudioFocus focusChange) { switch (focusChange) { case AudioFocus.GainTransient: case AudioFocus.GainTransientMayDuck: case AudioFocus.Gain: parent.StartAsync(); SetStatus("Granted"); break; case AudioFocus.LossTransientCanDuck: case AudioFocus.LossTransient: case AudioFocus.Loss: parent.Stop(); SetStatus("Removed"); break; default: break; } }
public void OnAudioFocusChange(AudioFocus focusChange) { LogHelper.Debug(Tag, "onAudioFocusChange. focusChange=", focusChange); if (focusChange == AudioFocus.Gain) { audioFocus = AudioFocused; } else if (focusChange == AudioFocus.Loss || focusChange == AudioFocus.LossTransient || focusChange == AudioFocus.LossTransientCanDuck) { bool canDuck = focusChange == AudioFocus.LossTransientCanDuck; audioFocus = canDuck ? AudioNoFocusCanDuck : AudioNoFocusNoDuck; playOnFocusGain |= State == PlaybackStateCode.Playing && !canDuck; } else { LogHelper.Error(Tag, "onAudioFocusChange: Ignoring unsupported focusChange: ", focusChange); } ConfigMediaPlayerState(); }
public void OnAudioFocusChange (AudioFocus focusChange) { LogHelper.Debug(Tag, "onAudioFocusChange. focusChange=", focusChange); if (focusChange == AudioFocus.Gain) { audioFocus = AudioFocused; } else if (focusChange == AudioFocus.Loss || focusChange == AudioFocus.LossTransient || focusChange == AudioFocus.LossTransientCanDuck) { bool canDuck = focusChange == AudioFocus.LossTransientCanDuck; audioFocus = canDuck ? AudioNoFocusCanDuck : AudioNoFocusNoDuck; playOnFocusGain |= State == PlaybackStateCode.Playing && !canDuck; } else { LogHelper.Error (Tag, "onAudioFocusChange: Ignoring unsupported focusChange: ", focusChange); } ConfigMediaPlayerState (); }
//============== AudioManager.IOnAudioFocusChangeListener public void OnAudioFocusChange(AudioFocus focusChange) { }
public void OnAudioFocusChange(AudioFocus focusChange) { if (focusChange > 0) { MusicManager.pInstance.pManualMusicDisabled = false; } else if (focusChange < 0) { MusicManager.pInstance.pManualMusicDisabled = true; } MusicManager.pInstance.ChangeMusic(); }
/// <summary> /// For a good user experience we should account for when audio focus has changed. /// There is only 1 audio output there may be several media services trying to use it so /// we should act correctly based on this. "duck" to be quiet and when we gain go full. /// All applications are encouraged to follow this, but are not enforced. /// </summary> public void OnAudioFocusChange (AudioFocus focusChange) { switch (focusChange) { case AudioFocus.Gain: if (_player == null) { IntializePlayer (); } if (!_player.IsPlaying) { _player.Start (); _paused = false; } _player.SetVolume (1.0f, 1.0f);//Turn it up! break; case AudioFocus.Loss: //We have lost focus stop! Stop (); break; case AudioFocus.LossTransient: //We have lost focus for a short time, but likely to resume so pause Pause (); break; case AudioFocus.LossTransientCanDuck: //We have lost focus but should till play at a muted 10% volume if (_player.IsPlaying) _player.SetVolume (.1f, .1f);//turn it down! break; } }
public void OnAudioFocusChange([GeneratedEnum] AudioFocus focusChange) { }
public void OnAudioFocusChange([GeneratedEnum] AudioFocus focusChange) { Log.Info(TAG, "OnAudioFocusChange: Audio focus changed"); }
/// <summary> /// For a good user experience we should account for when audio focus has changed. /// There is only 1 audio output there may be several media services trying to use it so /// we should act correctly based on this. "duck" to be quiet and when we gain go full. /// All applications are encouraged to follow this, but are not enforced. /// </summary> /// <param name="focusChange"></param> public async void OnAudioFocusChange(AudioFocus focusChange) { switch (focusChange) { case AudioFocus.Gain: if (TransientPaused && !ManuallyPaused) { await Play(); } SetVolume(1.0f, 1.0f);//Turn it up! TransientPaused = false; break; case AudioFocus.Loss: //We have lost focus stop! await Stop(); break; case AudioFocus.LossTransient: //We have lost focus for a short time, but likely to resume so pause TransientPaused = true; await Pause(); break; case AudioFocus.LossTransientCanDuck: //We have lost focus but should still play at a muted 10% volume SetVolume(.1f, .1f); break; } }