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