Condividi tramite

Android Audio

  • Articolo

Il sistema operativo Android offre un ampio supporto per i contenuti multimediali, che comprendono sia audio che video. Questa guida è incentrata sull'audio in Android e illustra la riproduzione e la registrazione dell'audio usando le classi predefinite di lettore audio e registratore, nonché l'API audio di basso livello. Illustra anche l'uso di eventi audio trasmessi da altre applicazioni, in modo che gli sviluppatori possano creare applicazioni ben comportate.

Panoramica

I moderni dispositivi mobili hanno adottato funzionalità che in precedenza avrebbero richiesto pezzi dedicati di apparecchiature: telecamere, lettori musicali e videoregistratori. Per questo motivo, i framework multimediali sono diventati una funzionalità di prima classe nelle API per dispositivi mobili.

Android offre un ampio supporto per i contenuti multimediali. Questo articolo esamina l'uso dell'audio in Android e illustra gli argomenti seguenti

  1. Riproduzione di audio con MediaPlayer : uso della classe predefinita MediaPlayer per riprodurre l'audio, inclusi i file audio locali e i file audio trasmessi con la AudioTrack classe .

  2. Registrazione audio : uso della classe predefinita MediaRecorder per registrare l'audio.

  3. Uso delle notifiche audio: uso delle notifiche audio per creare applicazioni ben comportate che rispondono correttamente agli eventi (ad esempio le chiamate telefoniche in ingresso) sospendendo o annullando gli output audio.

  4. Uso dell'audio di basso livello: riproduzione di audio con la AudioTrack classe scrivendo direttamente nei buffer di memoria. Registrazione dell'audio usando la AudioRecord classe e la lettura direttamente dai buffer di memoria.

Requisiti

Questa guida richiede Android 2.0 (livello API 5) o versione successiva. Si noti che il debug dell'audio in Android deve essere eseguito in un dispositivo.

È necessario richiedere le RECORD_AUDIO autorizzazioni in AndroidManifest.XML:

Sezione Autorizzazioni necessarie del manifesto Android con RECORD_AUDIO abilitato

Riproduzione di audio con la classe MediaPlayer

Il modo più semplice per riprodurre audio in Android è la classe MediaPlayer predefinita. MediaPlayer può riprodurre file locali o remoti passando il percorso del file. Tuttavia, MediaPlayer è molto sensibile allo stato e la chiamata a uno dei relativi metodi nello stato errato causerà la generazione di un'eccezione. È importante interagire con MediaPlayer nell'ordine descritto di seguito per evitare errori.

Inizializzazione e riproduzione

La riproduzione di audio con MediaPlayer richiede la sequenza seguente:

  1. Creare un'istanza di un nuovo oggetto MediaPlayer .

  2. Configurare il file da riprodurre tramite il metodo SetDataSource .

  3. Chiamare il metodo Prepare per inizializzare il lettore.

  4. Chiamare il metodo Start per avviare la riproduzione audio.

L'esempio di codice seguente illustra questo utilizzo:

protected MediaPlayer player;
public void StartPlayer(String  filePath)
{
  if (player == null) {
    player = new MediaPlayer();
  } else {
    player.Reset();
    player.SetDataSource(filePath);
    player.Prepare();
    player.Start();
  }
}

Sospensione e ripresa della riproduzione

La riproduzione può essere sospesa chiamando il metodo Pause :

player.Pause();

Per riprendere la riproduzione sospesa, chiamare il metodo Start . Questo riprenderà dalla posizione sospesa nella riproduzione:

player.Start();

La chiamata al metodo Stop sul lettore termina una riproduzione in corso:

player.Stop();

Quando il lettore non è più necessario, le risorse devono essere rilasciate chiamando il metodo Release :

player.Release();

Uso della classe MediaRecorder per registrare l'audio

La classe MediaRecorder a MediaPlayer per la registrazione dell'audio in Android. Come , MediaPlayerè sensibile allo stato e passa attraverso diversi stati per arrivare al punto in cui può iniziare la registrazione. Per registrare l'audio, è necessario impostare l'autorizzazione RECORD_AUDIO . Per istruzioni su come impostare le autorizzazioni dell'applicazione, vedere Uso di AndroidManifest.xml.

Inizializzazione e registrazione

La registrazione dell'audio con richiede MediaRecorder i passaggi seguenti:

  1. Creare un'istanza di un nuovo oggetto MediaRecorder .

  2. Specificare il dispositivo hardware da usare per acquisire l'input audio tramite il metodo SetAudioSource .

  3. Impostare il formato audio del file di output usando il metodo SetOutputFormat . Per un elenco dei tipi audio supportati, vedi Formati multimediali supportati da Android.

  4. Chiamare il metodo SetAudioEncoder per impostare il tipo di codifica audio.

  5. Chiamare il metodo SetOutputFile per specificare il nome del file di output in cui vengono scritti i dati audio.

  6. Chiamare il metodo Prepare per inizializzare il registratore.

  7. Chiamare il metodo Start per avviare la registrazione.

L'esempio di codice seguente illustra questa sequenza:

protected MediaRecorder recorder;
void RecordAudio (String filePath)
{
  try {
    if (File.Exists (filePath)) {
      File.Delete (filePath);
    }
    if (recorder == null) {
      recorder = new MediaRecorder (); // Initial state.
    } else {
      recorder.Reset ();
      recorder.SetAudioSource (AudioSource.Mic);
      recorder.SetOutputFormat (OutputFormat.ThreeGpp);
      recorder.SetAudioEncoder (AudioEncoder.AmrNb);
      // Initialized state.
      recorder.SetOutputFile (filePath);
      // DataSourceConfigured state.
      recorder.Prepare (); // Prepared state
      recorder.Start (); // Recording state.
    }
  } catch (Exception ex) {
    Console.Out.WriteLine( ex.StackTrace);
  }
}

Arresto della registrazione

Per arrestare la registrazione, chiamare il Stop metodo su MediaRecorder:

recorder.Stop();

Pulizia

Dopo l'arresto MediaRecorder di , chiamare il metodo Reset per ripristinarne lo stato di inattività:

recorder.Reset();

Quando non MediaRecorder è più necessario, le relative risorse devono essere rilasciate chiamando il metodo Release :

recorder.Release();

Gestione delle notifiche audio

Classe AudioManager

La classe AudioManager fornisce l'accesso alle notifiche audio che consentono alle applicazioni di sapere quando si verificano eventi audio. Questo servizio fornisce anche l'accesso ad altre funzionalità audio, ad esempio il controllo della modalità del volume e del ringer. AudioManager consente a un'applicazione di gestire le notifiche audio per controllare la riproduzione audio.

Gestione dello stato attivo audio

Le risorse audio del dispositivo (il lettore e il registratore predefiniti) sono condivise da tutte le applicazioni in esecuzione.

Concettualmente, si tratta di applicazioni simili alle applicazioni in un computer desktop in cui solo un'applicazione ha lo stato attivo della tastiera: dopo aver selezionato una delle applicazioni in esecuzione facendo clic con il mouse, l'input della tastiera passa solo a tale applicazione.

Lo stato attivo audio è un'idea simile e impedisce a più applicazioni di riprodurre o registrare audio contemporaneamente. È più complicato dello stato attivo della tastiera perché è volontario - l'applicazione può ignorare che attualmente non ha lo stato attivo e la riproduzione audio indipendentemente dal fatto che ci sono diversi tipi di stato attivo audio che possono essere richiesti. Ad esempio, se il richiedente deve riprodurre l'audio solo per un breve periodo di tempo, potrebbe richiedere lo stato attivo temporaneo.

Lo stato attivo audio può essere concesso immediatamente o inizialmente negato e concesso in seguito. Ad esempio, se un'applicazione richiede lo stato attivo audio durante una telefonata, verrà negata, ma lo stato attivo potrebbe essere concesso al termine della chiamata telefonica. In questo caso, un listener viene registrato per rispondere di conseguenza se lo stato attivo audio viene tolto. La richiesta di stato attivo audio viene usata per determinare se è ok o meno riprodurre o registrare l'audio.

Per altre informazioni sullo stato attivo audio, vedi Gestione dello stato attivo audio.

Registrazione del callback per lo stato attivo audio

La registrazione del FocusChangeListener callback da IOnAudioChangeListener è una parte importante di ottenere e rilasciare lo stato attivo audio. Ciò è dovuto al fatto che la concessione dello stato attivo audio può essere posticipata fino a un secondo momento. Ad esempio, un'applicazione può richiedere di riprodurre musica mentre è in corso una telefonata. Lo stato attivo audio non verrà concesso fino al termine della chiamata telefonica.

Per questo motivo, l'oggetto callback viene passato come parametro nel GetAudioFocus metodo dell'oggetto AudioManagered è questa chiamata che registra il callback. Se lo stato attivo audio viene inizialmente negato ma successivamente concesso, l'applicazione viene informata richiamando OnAudioFocusChange il callback. Lo stesso metodo viene usato per indicare all'applicazione che lo stato attivo audio viene eliminato.

Al termine dell'uso delle risorse audio, l'applicazione chiama il AbandonFocus metodo dell'oggetto AudioManagere passa di nuovo il callback. Questo annulla la registrazione del callback e rilascia le risorse audio, in modo che altre applicazioni possano ottenere lo stato attivo audio.

Richiesta di stato attivo audio

I passaggi necessari per richiedere le risorse audio del dispositivo sono i seguenti:

  1. Ottenere un handle per il servizio di AudioManager sistema.

  2. Creare un'istanza della classe di callback.

  3. Richiedere le risorse audio del dispositivo chiamando il RequestAudioFocus metodo su AudioManager . I parametri sono l'oggetto callback, il tipo di flusso (musica, chiamata vocale, anello e così via) e il tipo del diritto di accesso richiesto (le risorse audio possono essere richieste momentaneamente o per un periodo illimitato, ad esempio).

  4. Se viene concessa la richiesta, il playMusic metodo viene richiamato immediatamente e l'audio inizia a riprodurre.

  5. Se la richiesta viene negata, non viene eseguita alcuna ulteriore azione. In questo caso, l'audio verrà riprodotto solo se la richiesta viene concessa in un secondo momento.

L'esempio di codice seguente illustra questi passaggi:

Boolean RequestAudioResources(INotificationReceiver parent)
{
  AudioManager audioMan = (AudioManager) GetSystemService(Context.AudioService);
  AudioManager.IOnAudioFocusChangeListener listener  = new MyAudioListener(this);
  var ret = audioMan.RequestAudioFocus (listener, Stream.Music, AudioFocus.Gain );
  if (ret == AudioFocusRequest.Granted) {
    playMusic();
    return (true);
  } else if (ret == AudioFocusRequest.Failed) {
    return (false);
  }
  return (false);
}

Rilascio dello stato attivo audio

Al termine della riproduzione della traccia, viene richiamato il AbandonFocus metodo su AudioManager . In questo modo un'altra applicazione può ottenere le risorse audio del dispositivo. Altre applicazioni riceveranno una notifica di modifica dello stato attivo audio se hanno registrato i propri listener.

API audio di basso livello

Le API audio di basso livello offrono un maggiore controllo sulla riproduzione e la registrazione audio perché interagiscono direttamente con i buffer di memoria anziché usare gli URI dei file. Esistono alcuni scenari in cui questo approccio è preferibile. Tali scenari includono:

  1. Durante la riproduzione da file audio crittografati.

  2. Quando si riproduce una successione di brevi clip.

  3. Streaming audio.

Classe AudioTrack

La classe AudioTrack usa le API audio di basso livello per la registrazione ed è l'equivalente di basso livello della MediaPlayer classe.

Inizializzazione e riproduzione

Per riprodurre l'audio, è necessario creare un'istanza di una nuova istanza di AudioTrack . L'elenco di argomenti passato nel costruttore specifica come riprodurre l'esempio audio contenuto nel buffer. Gli argomenti sono:

  1. Tipo di flusso: voce, suoneria, musica, sistema o allarme.

  2. Frequenza: frequenza di campionamento espressa in Hz.

  3. Configurazione del canale: Mono o stereo.

  4. Formato audio: codifica a 8 bit o a 16 bit.

  5. Dimensioni del buffer: in byte.

  6. Modalità buffer: streaming o statico.

Dopo la costruzione, viene richiamato il metodo Play di AudioTrack per impostarlo per iniziare a giocare. La scrittura del buffer audio nell'oggetto AudioTrack avvia la riproduzione:

void PlayAudioTrack(byte[] audioBuffer)
{
  AudioTrack audioTrack = new AudioTrack(
    // Stream type
    Stream.Music,
    // Frequency
    11025,
    // Mono or stereo
    ChannelOut.Mono,
    // Audio encoding
    Android.Media.Encoding.Pcm16bit,
    // Length of the audio clip.
    audioBuffer.Length,
    // Mode. Stream or static.
    AudioTrackMode.Stream);

    audioTrack.Play();
    audioTrack.Write(audioBuffer, 0, audioBuffer.Length);
}

Sospensione e arresto della riproduzione

Chiamare il metodo Pause per sospendere la riproduzione:

audioTrack.Pause();

La chiamata al metodo Stop terminerà la riproduzione in modo permanente:

audioTrack.Stop();

Pulizia

Quando non AudioTrack è più necessario, le relative risorse devono essere rilasciate chiamando Release:

audioTrack.Release();

Classe AudioRecord

La classe AudioRecord è l'equivalente di AudioTrack sul lato di registrazione. Come AudioTrack, usa direttamente i buffer di memoria, al posto di file e URI. Richiede che l'autorizzazione RECORD_AUDIO sia impostata nel manifesto.

Inizializzazione e registrazione

Il primo passaggio consiste nel costruire un nuovo oggetto AudioRecord . L'elenco di argomenti passato nel costruttore fornisce tutte le informazioni necessarie per la registrazione. A differenza di AudioTrack, dove gli argomenti sono in gran parte enumerazioni, gli argomenti equivalenti in AudioRecord sono numeri interi. tra cui:

  1. Origine di input audio hardware, ad esempio microfono.

  2. Tipo di flusso: voce, suoneria, musica, sistema o allarme.

  3. Frequenza: frequenza di campionamento espressa in Hz.

  4. Configurazione del canale: Mono o stereo.

  5. Formato audio: codifica a 8 bit o a 16 bit.

  6. Dimensioni del buffer in byte

AudioRecord Una volta costruito, viene richiamato il relativo metodo StartRecording. È ora pronto per iniziare la registrazione. Legge AudioRecord continuamente il buffer audio per l'input e scrive questo input in un file audio.

void RecordAudio()
{
  byte[] audioBuffer = new byte[100000];
  var audRecorder = new AudioRecord(
    // Hardware source of recording.
    AudioSource.Mic,
    // Frequency
    11025,
    // Mono or stereo
    ChannelIn.Mono,
    // Audio encoding
    Android.Media.Encoding.Pcm16bit,
    // Length of the audio clip.
    audioBuffer.Length
  );
  audRecorder.StartRecording();
  while (true) {
    try
    {
      // Keep reading the buffer while there is audio input.
      audRecorder.Read(audioBuffer, 0, audioBuffer.Length);
      // Write out the audio file.
    } catch (Exception ex) {
      Console.Out.WriteLine(ex.Message);
      break;
    }
  }
}

Arresto della registrazione

La chiamata al metodo Stop termina la registrazione:

audRecorder.Stop();

Pulizia

Quando l'oggetto AudioRecord non è più necessario, la chiamata al metodo Release rilascia tutte le risorse associate:

audRecorder.Release();

Riepilogo

Il sistema operativo Android offre un framework potente per la riproduzione, la registrazione e la gestione dell'audio. Questo articolo ha illustrato come riprodurre e registrare audio usando le classi e MediaRecorder di alto livelloMediaPlayer. Successivamente, è stato illustrato come usare le notifiche audio per condividere le risorse audio del dispositivo tra applicazioni diverse. Infine, ha affrontato come riprodurre e registrare audio usando le API di basso livello, che si interfacciano direttamente con i buffer di memoria.