AudioFocusRequestClass Classe
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
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à
- Attributi
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 un podcast, ma non entrambi contemporaneamente. In alcuni casi, più flussi audio possono essere riprodotti contemporaneamente, ma c'è solo uno su cui l'utente ascolterebbe realmente (messa a fuoco), mentre l'altro riproduce in background. Un esempio di questo è guidare le indicazioni vocali mentre la musica suona a un volume ridotto (a.k.a. anatra).
Quando un'applicazione richiede lo stato attivo audio, esprime l'intenzione di "possedere" lo stato attivo audio per riprodurre l'audio. Esaminiamo i diversi tipi di richieste di stato attivo, il valore restituito dopo una richiesta e le risposte a una perdita.
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 dell'utente con l'applicazione, (s) non si aspetta che un altro flusso audio riprenda. 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 si aspetta 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 finita: 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 di messa a fuoco è simile all'aspetto AUDIOFOCUS_GAIN_TRANSIENT temporaneo della richiesta di messa a fuoco, ma esprime anche il fatto durante il momento in cui si è concentrati, si consente a un'altra applicazione di continuare a giocare a un volume ridotto, "anatrato". Gli 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 comprendere. Una tipica attenuazione da parte dell'applicazione "anatrata" è un fattore di 0,2f (o -14dB), che può essere applicato ad esempio 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 si aspetta che il dispositivo non giochi altro. Questo viene in genere usato 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 quando si compila un'istanza AudioFocusRequest con il Builder relativo generatore nel costruttore AudioFocusRequest.Builder#Builder(int)o con AudioFocusRequest.Builder#setFocusGain(int) dopo aver copiato un'istanza esistente con AudioFocusRequest.Builder#Builder(AudioFocusRequest).
"nota"><b Nota:</b>> Se un'app è destinata ad Android 15 (livello API 35) o superiore, non può richiedere lo stato attivo audio a meno che non sia l'app principale o che esegua un servizio in primo piano. Questo requisito è simile ai requisiti per la riproduzione audio. Se un'app richiede lo stato attivo audio quando non soddisfa questi requisiti, il metodo restituisce <c>AudioManager#AUDIOFOCUS_REQUEST_FAILED</c>. </aside>
<h3>Qualificare la richiesta< di messa a fuoco/h3><h4>Caso d'uso che richiede una richiesta< di messa a fuoco/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 completata o concessa). È consigliabile usare la stessa AudioAttributes opzione 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 il dispositivo è connesso 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 mentre è bloccato 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 vs 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.
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 il ducking 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, invece di anatra, perché è difficile comprendere una richiesta di navigazione 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 giocatore è 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 anatra automaticamente le applicazioni che riproduceno il parlato, chiama invece il listener di 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 dichiararla con Builder#setWillPauseWhenDucked(boolean), che causerà il sistema di chiamare 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 riproduciamo un audio book e la nostra 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><>Configurazione e creazione dell'istanza AudioFocusRequest che definisce i comportamenti dello stato attivo previsti.</li><li>Richiedere lo stato attivo audio e controllare il codice restituito per verificare se la riproduzione può verificarsi immediatamente o viene 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.
per android.media.AudioFocusRequest.
Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.
Proprietà
| Nome | Descrizione |
|---|---|
| AudioAttributes |
Restituisce il |
| Class |
Restituisce la classe di runtime di questo |
| FocusGain |
Restituisce il tipo di richiesta di messa a fuoco audio configurata per questo |
| Handle |
Handle per l'istanza di Android sottostante. (Ereditato da Object) |
| JniIdentityHashCode |
Ottiene il codice hash di identità assegnato a questo Java peer dal runtime di interoperabilità. (Ereditato da Object) |
| JniManagedPeerState |
Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da JavaObject) |
| JniPeerMembers |
Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. |
| PeerReference |
Ottiene il riferimento all'oggetto JNI per questo peer Java. (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
| Nome | Descrizione |
|---|---|
| AcceptsDelayedFocusGain() |
Restituisce un valore che indica se l'applicazione che userebbe supporta |
| Clone() |
Crea e restituisce una copia di questo oggetto. (Ereditato da Object) |
| Construct(JniObjectReference, JniObjectReferenceOptions) |
Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da JavaObject) |
| Dispose() |
Rilascia le risorse contenute in questo peer Java. (Ereditato da Object) |
| Dispose(Boolean) |
Rilascia le risorse contenute in questo peer Java. (Ereditato da Object) |
| DisposeUnlessReferenced() |
Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da JavaObject) |
| Equals(Object) |
Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da JavaObject) |
| Equals(Object) |
Indica se un altro oggetto è "uguale a" questo. (Ereditato da Object) |
| GetHashCode() |
Restituisce un valore di 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 monitor dell'oggetto. (Ereditato da Object) |
| SetHandle(IntPtr, JniHandleOwnership) |
Imposta la proprietà Handle. (Ereditato da Object) |
| SetPeerReference(JniObjectReference, JniObjectReferenceOptions) |
Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da JavaObject) |
| ToArray<T>() |
Crea una matrice gestita da questo wrapper di matrice Java. (Ereditato da Object) |
| ToString() |
Restituisce una rappresentazione di stringa dell'oggetto . (Ereditato da Object) |
| UnregisterFromRuntime() |
Annulla la registrazione di questo Java peer dal runtime di interoperabilità. (Ereditato da Object) |
| Wait() |
Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo <>una notifica</em> o <em>interrotto</em>. (Ereditato da Object) |
| Wait(Int64, Int32) |
Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo<> una notifica</em> o <em>interrotto</em> o fino a quando non è trascorsa una determinata quantità di tempo reale. (Ereditato da Object) |
| Wait(Int64) |
Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo<> una notifica</em> o <em>interrotto</em> o fino a quando non è trascorsa una determinata quantità di tempo reale. (Ereditato da Object) |
| WillPauseWhenDucked() |
Restituisce un valore che indica se l'applicazione che userebbe questa |
Implementazioni dell'interfaccia esplicita
| Nome | Descrizione |
|---|---|
| IJavaPeerable.Disposed() |
Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da JavaObject) |
| IJavaPeerable.Finalized() |
Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da JavaObject) |
| IJavaPeerable.JniObjectReferenceControlBlock |
Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da JavaObject) |
| IJavaPeerable.SetJniIdentityHashCode(Int32) |
Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da JavaObject) |
| IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates) |
Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da JavaObject) |
| IJavaPeerable.SetPeerReference(JniObjectReference) |
Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. (Ereditato da JavaObject) |
Metodi di estensione
| Nome | Descrizione |
|---|---|
| GetJniTypeName(IJavaPeerable) |
Ottiene il nome JNI del tipo dell'istanza |
| JavaAs<TResult>(IJavaPeerable) |
Provare a digitare |
| JavaCast<TResult>(IJavaObject) |
Esegue una conversione del tipo di tipo controllato dal runtime Android. |
| JavaCast<TResult>(IJavaObject) |
Classe per incapsulare informazioni su una richiesta di messa a fuoco audio. |
| TryJavaCast<TResult>(IJavaPeerable, TResult) |
Provare a digitare |