Gestire l’audio

18 ottobre 2014

Quello del multimedia è uno dei settori più floridi e di maggiore interesse delle applicazioni per dispositivi mobili. Abbiamo già visto come sia possibile utilizzare il MediaPlayer per la riproduzione di contenuti multimediali. In questo capitolo approfondiremo la tematica relativa alla gestione dell’audio. In particolare verranno trattati due aspetti: la registrazione dell’audio e l’AudioManager.

Registrare e riascoltare

L’esempio presentato è un grande classico del multimedia: una semplice applicazione con due pulsanti, uno per avviare/fermare la registrazione, l’altro per gestire l’ascolto.

Vediamo subito il layout, molto semplice:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    >

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/btn_registra"
        android:text="Registra" 
        android:onClick="registra"/>
    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/btn_ascolta"
        android:text="Ascolta" 
        android:onClick="ascolta"/>

</LinearLayout>

Il codice dell’Activity, oltre all’onCreate(), include diversi altri metodi che servono a gestire i pulsanti:

public class MainActivity extends Activity
{
	private MediaRecorder registratore = null;
    private MediaPlayer   riproduttore = null;
    
    private static String filename = null;
    
    private boolean ascoltando=false;
    private boolean registrando=false;
	
         @Override
    public void onCreate(Bundle args) 
    {
        super.onCreate(args);
        setContentView(R.layout.activity_main);
        filename = Environment.getExternalStorageDirectory().getAbsolutePath();
        filename += "/registrazione.3gp";
    }

    @Override
    public void onPause() {
        super.onPause();
        if (registratore != null) {
            registratore.release();
            registratore = null;
        }

        if (riproduttore != null) {
            riproduttore.release();
            riproduttore = null;
        }
    }

        . . .
        . . .
}

I membri privati visibili nell’Activity sono:

  • due booleani, chiamati ascoltando e registrando. Loro eventuali valori positivi indicherebbero che è in corso, rispettivamente, la riproduzione dell’audio e la registrazione;
  • filename è una stringa che indica il nome del file in cui andremo a salvare l’audio registrato. Il salvataggio verrà fatto nella directory principale dello storage esterno il che permetterà, in caso di dubbi, di cercarlo sulla SD card ed ascoltarlo con il lettore di sistema;
  • i due protagonisti dell’esempio, MediaRecorder e MediaPlayer. Appartengono entrambi al package android.media e servono a registrare l’audio – il primo – e a gestirne la riproduzione, il secondo.

Il frammento di codice precedente mostra anche onCreate e onPause. Il primo metodo non fa altro che svolgere inizializzazioni, mentre il secondo fa un po’ di pulizia in memoria controllando che il MediaPlayer ed il MediaRecorder siano non-nulli ed in tal caso chiede il rilascio delle rispettive risorse.

Al click su uno dei pulsanti del layout, verranno impartiti i comandi per la registrazione e l’ascolto. In entrambi i casi l’Activity cambierà nome al pulsante, assegnando un’etichetta appropriata. In tutto ciò, giocano un ruolo fondamentale i due booleani, denominati ascoltando e registrando, che permettono di avere sempre chiaro in quale fase di lavoro l’applicazione si trovi. Questi i metodi che reagiscono al click dei pulsanti:

    public void registra(View v)
    {
    	Button btn=(Button) v;
    	if (registrando)
    	{
    		// serve ad interrompere
    		fermaRegistrazione();
    		btn.setText("Registra");
    	}
    	else
    	{
    		// serve ad iniziare la registrazione
    		registra();
    		btn.setText("Ferma registrazione");
    	}
    	registrando=!registrando;
    }
    
    public void ascolta(View v)
    {
    	Button btn=(Button) v;
    	if (ascoltando)
    	{
    		// serve ad interrompere
    		fermaRiproduzione();
    		btn.setText("Ascolta");
    	}
    	else
    	{
    		// serve ad iniziare la riproduzione dell'audio
    		riproduci();
    		btn.setText("Ferma");
    	}
    	ascoltando=!ascoltando;
    }

Infine, vediamo il cuore dell’esempio, la parte che conterrà il codice più significativo: i metodi che provvedono ad avviare/interrompere riproduzione e registrazione.

    private void riproduci() {
        riproduttore = new MediaPlayer();
        try 
        {
            riproduttore.setDataSource(filename);
            riproduttore.prepare();
            riproduttore.start();
        } 
        catch (IOException e) 
        {
        	// gestisci eccezione
        }
    }

    private void fermaRiproduzione() {
        riproduttore.release();
        riproduttore = null;
    }

    private void registra() {
        registratore = new MediaRecorder();
        registratore.setAudioSource(MediaRecorder.AudioSource.MIC);
        registratore.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
        registratore.setOutputFile(filename);
        registratore.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);

        try 
        {
            registratore.prepare();
        } 
        catch (IOException e) 
        {
        	// gestisci eccezione
        }

        registratore.start();
    }

    private void fermaRegistrazione() {
        registratore.stop();
        registratore.release();
        registratore = null;
    }

Per quanto riguarda il MediaPlayer, non abbiamo nulla da aggiungere a quanto visto nel capitolo al riguardo. Anche il MediaRecorder non riserva grandi sorprese. Come si può vedere, è uno strumento molto completo: non solo permette di impostare tutti i parametri della registrazione – tra cui il microfono come sorgente ed il formato .3gp – ma si occupa di tutta la fase di registrazione su file (è sufficiente impostargli nome e percorso della destinazione).

AudioManager

Oltre all’esempio riportato, è giusto citare un’altra classe appartenente al framework: AudioManager. Si tratta di un servizio di sistema, richiamabile quindi nel seguente modo:

    AudioManager manager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);

Offre diversi metodi per configurare rapidamente vari aspetti dell’audio. Almeno due di essi meritano di essere citati per la grande importanza che rivestono:

  • setRingerMode: permette di impostare il volume della suoneria del dispositivo. Richiede in input un valore intero da scegliere tra valori costanti: RINGER_MODE_SILENT (silenzioso), RINGER_MODE_NORMAL (normale suoneria), RINGER_MODE_VIBRATE (con vibrazione);
  • adjustVolume: permette di regolare il volume. La direzione della variazione di volume va descritta con apposite costanti: ADJUST_LOWER (per diminuire) e ADJUST_RAISE (per aumentarlo).

Tutte le lezioni

1 ... 50 51 52 ... 84

Se vuoi aggiornamenti su Gestire l'audio inserisci la tua e-mail nel box qui sotto:
Tags:
 
X
Se vuoi aggiornamenti su Gestire l'audio

inserisci la tua e-mail nel box qui sotto:

Ho letto e acconsento l'informativa sulla privacy

Acconsento al trattamento di cui al punto 3 dell'informativa sulla privacy