AudioFocusRequestClass Classe

Definizione

Spazio dei nomi:

Android.Media

Assembly:

Mono.Android.dll

Classe per incapsulare informazioni su una richiesta di messa a fuoco audio.

[Android.Runtime.Register("android/media/AudioFocusRequest", ApiSince=26, DoNotGenerateAcw=true)]
public sealed class AudioFocusRequestClass : Java.Lang.Object

[<Android.Runtime.Register("android/media/AudioFocusRequest", ApiSince=26, DoNotGenerateAcw=true)>]
type AudioFocusRequestClass = class
    inherit Object

Ereditarietà

Object

Object

AudioFocusRequestClass

Attributi

RegisterAttribute

Commenti

Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. Un'istanza AudioFocusRequest viene compilata da Buildere viene usata per richiedere e abbandonare lo stato attivo audio, rispettivamente con AudioManager#requestAudioFocus(AudioFocusRequest) e AudioManager#abandonAudioFocusRequest(AudioFocusRequest).

<h3>Che cos'è lo stato attivo audio?</h3>

Lo stato attivo audio è un concetto introdotto nell'API 8. Viene usato per trasmettere il fatto che un utente può concentrarsi solo su un singolo flusso audio alla volta, ad esempio l'ascolto di musica o podcast, ma non entrambi contemporaneamente. In alcuni casi, più flussi audio possono essere riprodotti contemporaneamente, ma c'è solo un utente ascolterebbe veramente (messa a fuoco), mentre l'altro viene riprodotto in background. Un esempio è che le indicazioni stradali vengono pronunciate mentre la musica suona a un volume ridotto (ad esempio anatraggio).

Quando un'applicazione richiede lo stato attivo audio, esprime l'intenzione di "possedere" lo stato attivo audio per riprodurre l'audio. Verranno ora esaminati i diversi tipi di richieste di messa a fuoco, il valore restituito dopo una richiesta e le risposte a una perdita. <p class="note">Nota: le applicazioni non devono riprodurre nulla fino a quando non viene concesso lo stato attivo.

<h3>I diversi tipi di richieste< di stato attivo/h3>

Esistono quattro tipi di richiesta messa a fuoco. Una richiesta di messa a fuoco riuscita con ognuno produrrà comportamenti diversi dal sistema e dall'altra applicazione che in precedenza teneva lo stato attivo audio. <ul><li>AudioManager#AUDIOFOCUS_GAIN esprime il fatto che l'applicazione è ora l'unica fonte di audio che l'utente sta ascoltando. La durata della riproduzione audio è sconosciuta ed è probabilmente molto lunga: al termine dell'interazione con l'applicazione, (s) non prevede la ripresa di un altro flusso audio. Esempi di utilizzo di questo guadagno di stato attivo sono per la riproduzione musicale, per un gioco o un lettore video.</li>

<li>AudioManager#AUDIOFOCUS_GAIN_TRANSIENT è per una situazione in cui si sa che l'applicazione sta temporaneamente afferrando lo stato attivo dal proprietario corrente, ma l'utente prevede che la riproduzione torni a dove era una volta che l'applicazione non richiede più lo stato attivo audio. Un esempio è la riproduzione di un allarme o durante una chiamata VoIP. La riproduzione è nota per essere limitata: l'allarme timeout o verrà ignorato, la chiamata VoIP ha un inizio e una fine. Quando uno di questi eventi termina e se l'utente stava ascoltando musica all'avvio, l'utente si aspetta che la musica venga ripresa, ma non vuole ascoltare entrambi contemporaneamente.</li>

<li>AudioManager#AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK: questo tipo di richiesta messa a fuoco è simile a AUDIOFOCUS_GAIN_TRANSIENT per l'aspetto temporaneo della richiesta di messa a fuoco, ma esprime anche il fatto durante il tempo in cui si è concentrati, si consente a un'altra applicazione di continuare a giocare a un volume ridotto, "anatrato". Esempi sono quando si suonano indicazioni stradali o notifiche, è ok che la musica continui a suonare, ma non abbastanza forte che impedirebbe che le indicazioni stradali siano difficili da capire. Un'attenuazione tipica dell'applicazione "anatrata" è un fattore di 0,2f (o -14dB), che può ad esempio essere applicato con MediaPlayer.setVolume(0.2f) quando si usa questa classe per la riproduzione.</li>

<li>AudioManager#AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE è anche per una richiesta temporanea, ma esprime anche che l'applicazione prevede che il dispositivo non giochi altro. Questa operazione viene in genere usata se si esegue la registrazione audio o il riconoscimento vocale e non si vuole che le notifiche di esempio vengano riprodotte dal sistema durante tale periodo.</li></ul>

Un'istanza AudioFocusRequest contiene sempre uno dei quattro tipi di richieste descritte in precedenza. Viene passato durante la compilazione di un'istanza AudioFocusRequest con il Builder relativo generatore nel costruttore AudioFocusRequest.Builder#Builder(int)o con AudioFocusRequest.Builder#setFocusGain(int) dopo la copia di un'istanza esistente con AudioFocusRequest.Builder#Builder(AudioFocusRequest).

<h3>Qualificare la richiesta< di stato attivo/h3><h4>Caso d'uso che richiede una richiesta< di stato attivo/h4>

Qualsiasi richiesta di messa a fuoco è qualificata da AudioAttributes (vedere Builder#setAudioAttributes(AudioAttributes)) che descrivono il caso d'uso audio che seguirà la richiesta (una volta che ha avuto esito positivo o concesso). È consigliabile usare lo stesso AudioAttributes per la richiesta degli attributi usati per la riproduzione audio/multimediale. <br>Se non sono impostati attributi, vengono usati gli attributi predefiniti di AudioAttributes#USAGE_MEDIA .

<h4>Stato attivo< ritardato/h4>

Lo stato attivo audio può essere "bloccato" dal sistema per diversi motivi: durante una telefonata, quando l'auto a cui è connesso il dispositivo riproduce un messaggio di emergenza... Per supportare queste situazioni, l'applicazione può richiedere di ricevere una notifica quando la richiesta viene soddisfatta, contrassegnando la richiesta come accettazione dello stato attivo ritardato, con Builder#setAcceptsDelayedFocusGain(boolean). <br>Se lo stato attivo viene richiesto durante il blocco dal sistema, AudioManager#requestAudioFocus(AudioFocusRequest) restituirà AudioManager#AUDIOFOCUS_REQUEST_DELAYED. Quando lo stato attivo non è più bloccato, il listener dello stato attivo impostato con Builder#setOnAudioFocusChangeListener(OnAudioFocusChangeListener) o con Builder#setOnAudioFocusChangeListener(OnAudioFocusChangeListener, Handler) verrà chiamato per notificare all'applicazione che ora possiede lo stato attivo audio.

<h4>Sospensione e anatra/<h4>

Quando un'applicazione ha richiesto lo stato attivo audio con AudioManager#AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK, il sistema anatrerà il proprietario dello stato attivo corrente. <p class="nota">Nota: questo comportamento è <b>new per Android O</b>, mentre le applicazioni destinate al livello SDK fino all'API 25 devono implementare l'anatraggio quando hanno ricevuto una perdita di stato attivo di AudioManager#AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK.

Ma l'anatraggio non è sempre il comportamento previsto dall'utente. Un esempio tipico è quando il dispositivo riproduce indicazioni stradali mentre l'utente è in ascolto di un audio book o podcast e prevede che la riproduzione audio venga sospesa, anziché anatra, perché è difficile comprendere una richiesta di spostamento e un contenuto parlato contemporaneamente. Pertanto, il sistema non verrà automaticamente anatrato quando rileva che sarebbe anatra contenuto parlato: tale contenuto viene rilevato quando il AudioAttributes del lettore è qualificato da AudioAttributes#CONTENT_TYPE_SPEECH. Fai riferimento ad esempio a AudioAttributes.Builder#setContentType(int) e MediaPlayer#setAudioAttributes(AudioAttributes) se stai scrivendo un'applicazione di riproduzione multimediale per audio book, podcast... Poiché il sistema non eseguirà automaticamente l'anatra applicazioni che riproduceno il parlato, chiama invece il listener dello stato attivo per notificarli di AudioManager#AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK, in modo che possano invece sospendere. Si noti che questo comportamento è indipendente dall'uso di AudioFocusRequest, ma associato all'uso di AudioAttributes.

Se l'applicazione richiede la sospensione anziché l'anatraggio per qualsiasi altro motivo rispetto alla riproduzione vocale, è anche possibile dichiarare in modo che con Builder#setWillPauseWhenDucked(boolean), il sistema chiamerà il listener dello stato attivo invece di anatrarsi automaticamente.

<esempio< h4>/h4>

L'esempio seguente illustra i passaggi seguenti da trovare in qualsiasi applicazione che riproduce l'audio e usa lo stato attivo audio. Qui si riproduce un audio book e l'applicazione è destinata a sospendere anziché anatra quando perde lo stato attivo. Questi passaggi sono costituiti da: <ul><li>Creating AudioAttributes da usare per la riproduzione e la richiesta di messa a fuoco.</li><li>Configurazione e creazione dell'istanza AudioFocusRequest che definisce i comportamenti di stato attivo previsti.</li><li>Richiedere lo stato attivo audio e controllare il codice restituito per verificare se la riproduzione può verificarsi subito o è ritardata.</li li><>Implementazione di un listener di modifica dello stato attivo per rispondere ai guadagni e alle perdite dello stato attivo.</li></ul>

// initialization of the audio attributes and focus request
            mAudioManager = (AudioManager) Context.getSystemService(Context.AUDIO_SERVICE);
            mPlaybackAttributes = new AudioAttributes.Builder()
                    .setUsage(AudioAttributes.USAGE_MEDIA)
                    .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
                    .build();
            mFocusRequest = new AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN)
                    .setAudioAttributes(mPlaybackAttributes)
                    .setAcceptsDelayedFocusGain(true)
                    .setWillPauseWhenDucked(true)
                    .setOnAudioFocusChangeListener(this, mMyHandler)
                    .build();
            mMediaPlayer = new MediaPlayer();
            mMediaPlayer.setAudioAttributes(mPlaybackAttributes);
            final Object mFocusLock = new Object();

            boolean mPlaybackDelayed = false;

            // requesting audio focus
            int res = mAudioManager.requestAudioFocus(mFocusRequest);
            synchronized (mFocusLock) {
                if (res == AudioManager.AUDIOFOCUS_REQUEST_FAILED) {
                    mPlaybackDelayed = false;
                } else if (res == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
                    mPlaybackDelayed = false;
                    playbackNow();
                } else if (res == AudioManager.AUDIOFOCUS_REQUEST_DELAYED) {
                   mPlaybackDelayed = true;
                }
            }

            // implementation of the OnAudioFocusChangeListener
            @Override
            public void onAudioFocusChange(int focusChange) {
                switch (focusChange) {
                    case AudioManager.AUDIOFOCUS_GAIN:
                        if (mPlaybackDelayed || mResumeOnFocusGain) {
                            synchronized (mFocusLock) {
                                mPlaybackDelayed = false;
                                mResumeOnFocusGain = false;
                            }
                            playbackNow();
                        }
                        break;
                    case AudioManager.AUDIOFOCUS_LOSS:
                        synchronized (mFocusLock) {
                            // this is not a transient loss, we shouldn't automatically resume for now
                            mResumeOnFocusGain = false;
                            mPlaybackDelayed = false;
                        }
                        pausePlayback();
                        break;
                    case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT:
                    case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK:
                        // we handle all transient losses the same way because we never duck audio books
                        synchronized (mFocusLock) {
                            // we should only resume if playback was interrupted
                            mResumeOnFocusGain = mMediaPlayer.isPlaying();
                            mPlaybackDelayed = false;
                        }
                        pausePlayback();
                        break;
                }
            }

            // Important:
            // Also set "mResumeOnFocusGain" to false when the user pauses or stops playback: this way your
            // application doesn't automatically restart when it gains focus, even though the user had
            // stopped it.

Documentazione java per android.media.AudioFocusRequest.

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dal Android e usato in base ai termini descritti in 2.5 Attribution License Creative Commons 2.5 Attribution License.

Proprietà

AudioAttributes	Restituisce il AudioAttributes set per questo AudioFocusRequestoggetto o gli attributi predefiniti se non è stato impostato alcun valore.
Class	Restituisce la classe di runtime di questo Objectoggetto . (Ereditato da Object)
FocusGain	Restituisce il tipo di richiesta di messa a fuoco audio configurata per questo AudioFocusRequestoggetto .
Handle	Handle per l'istanza di Android sottostante. (Ereditato da Object)
JniIdentityHashCode	Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da Object)
JniPeerMembers	Classe per incapsulare informazioni su una richiesta di messa a fuoco audio.
PeerReference	Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da Object)
ThresholdClass	Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice. (Ereditato da Object)
ThresholdType	Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice. (Ereditato da Object)

Metodi

AcceptsDelayedFocusGain()	Restituisce un valore che indica se l'applicazione che userebbe supporta AudioFocusRequest un miglioramento dello stato attivo concesso dopo un errore temporaneo della richiesta.
Clone()	Crea e restituisce una copia di questo oggetto. (Ereditato da Object)
Dispose()	Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da Object)
Dispose(Boolean)	Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da Object)
Equals(Object)	Indica se un altro oggetto è "uguale a" questo. (Ereditato da Object)
GetHashCode()	Restituisce un valore del codice hash per l'oggetto. (Ereditato da Object)
JavaFinalize()	Chiamato dal Garbage Collector su un oggetto quando Garbage Collection determina che non sono presenti altri riferimenti all'oggetto . (Ereditato da Object)
Notify()	Riattiva un singolo thread in attesa del monitor dell'oggetto. (Ereditato da Object)
NotifyAll()	Riattiva tutti i thread in attesa del monitoraggio di questo oggetto. (Ereditato da Object)
SetHandle(IntPtr, JniHandleOwnership)	Imposta la proprietà Handle. (Ereditato da Object)
ToArray<T>()	Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da Object)
ToString()	Restituisce una rappresentazione in formato stringa dell'oggetto. (Ereditato da Object)
UnregisterFromRuntime()	Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da Object)
Wait()	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere eseguendo <una>notifica</em> o <em>interrotto</em>. (Ereditato da Object)
Wait(Int64)	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere eseguendo <una notifica</>em> o <em>interrotto</em> o fino a quando non è trascorsa una certa quantità di tempo reale. (Ereditato da Object)
Wait(Int64, Int32)	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere eseguendo <una notifica</>em> o <em>interrotto</em> o fino a quando non è trascorsa una certa quantità di tempo reale. (Ereditato da Object)
WillPauseWhenDucked()	Restituisce un valore che indica se l'applicazione che userebbe questa AudioFocusRequest operazione viene sospesa quando viene richiesta l'anatra.

Implementazioni dell'interfaccia esplicita

IJavaPeerable.Disposed()	Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da Object)
IJavaPeerable.DisposeUnlessReferenced()	Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da Object)
IJavaPeerable.Finalized()	Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da Object)
IJavaPeerable.JniManagedPeerState	Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da Object)

Metodi di estensione

JavaCast<TResult>(IJavaObject)	Esegue una conversione del tipo verificato dal runtime Android.
JavaCast<TResult>(IJavaObject)	Classe per incapsulare informazioni su una richiesta di messa a fuoco audio.
GetJniTypeName(IJavaPeerable)	Classe per incapsulare informazioni su una richiesta di messa a fuoco audio.