MediaController in Android con Java: guida completa

In questa pagina vediamo in dettaglio come usare MediaController in Android con Java per controllare la riproduzione audio/video, integrandolo con MediaPlayer e gestendo correttamente ciclo di vita, errori e best practice per Android 8.0 (API 26) e successivi.

5. Mini app di esempio: “AudioPlayer” completa

Vediamo ora una mini app completa in Java che usa MediaPlayer e MediaController per riprodurre un file audio scelto dall’utente. L’interfaccia contiene una SurfaceView (per mostrare come si integrerebbe con il video) e un bottone per caricare l’audio.

5.1 Layout: activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/root_view"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="16dp">

    <SurfaceView
        android:id="@+id/surface_view"
        android:layout_width="match_parent"
        android:layout_height="200dp"
        android:layout_alignParentTop="true"
        android:layout_marginBottom="16dp" />

    <Button
        android:id="@+id/btn_select_audio"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Seleziona audio"
        android:layout_below="@id/surface_view" />

</RelativeLayout>

5.2 Activity: MainActivity.java

La MainActivity implementa MediaPlayerControl, gestisce il permesso di lettura storage (runtime), inizializza MediaPlayer e MediaController, e usa un Intent.ACTION_GET_CONTENT per far scegliere un file audio all’utente.

package com.example.audioplayer;

import android.Manifest;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.media.MediaPlayer;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.widget.Button;
import android.widget.MediaController;
import android.widget.Toast;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

import java.io.IOException;

public class MainActivity extends AppCompatActivity
        implements MediaController.MediaPlayerControl, SurfaceHolder.Callback {

    private static final int REQUEST_CODE_PICK_AUDIO = 1001;
    private static final int REQUEST_CODE_PERMISSION_READ = 2001;

    private MediaPlayer mediaPlayer;
    private MediaController mediaController;
    private SurfaceView surfaceView;
    private SurfaceHolder surfaceHolder;
    private Button btnSelectAudio;

    private Uri currentAudioUri; // URI del file audio selezionato

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Inizializzazione vista SurfaceView (utile per video; per audio rimane comunque valida)
        surfaceView = findViewById(R.id.surface_view);
        surfaceHolder = surfaceView.getHolder();
        surfaceHolder.addCallback(this); // Registriamo il callback per sapere quando la Surface è pronta

        // Bottone per selezionare l'audio
        btnSelectAudio = findViewById(R.id.btn_select_audio);
        btnSelectAudio.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // Quando l'utente clicca, verifichiamo il permesso e apriamo il selettore file
                checkPermissionAndPickAudio();
            }
        });

        // Creiamo il MediaController e lo colleghiamo a questa Activity (MediaPlayerControl)
        mediaController = new MediaController(this);
        mediaController.setMediaPlayer(this);
        // Ancoriamo i controlli alla root view del layout
        mediaController.setAnchorView(findViewById(R.id.root_view));
    }

    /**
     * Verifica il permesso READ_EXTERNAL_STORAGE e se concesso apre il selettore di file audio.
     */
    private void checkPermissionAndPickAudio() {
        // Dalla API 23 in poi, i permessi "dangerous" vanno richiesti a runtime
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            int permission = ContextCompat.checkSelfPermission(this,
                    Manifest.permission.READ_EXTERNAL_STORAGE);

            if (permission != PackageManager.PERMISSION_GRANTED) {
                // Permesso non ancora concesso: lo richiediamo
                ActivityCompat.requestPermissions(this,
                        new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},
                        REQUEST_CODE_PERMISSION_READ);
                return;
            }
        }
        // Se siamo qui, il permesso è già stato concesso o non è richiesto (API < 23)
        openAudioPicker();
    }

    /**
     * Apre un Intent per permettere all'utente di scegliere un file audio dal dispositivo.
     */
    private void openAudioPicker() {
        Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
        intent.setType("audio/*"); // Filtriamo solo i file audio
        startActivityForResult(Intent.createChooser(intent, "Seleziona file audio"),
                REQUEST_CODE_PICK_AUDIO);
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        if (requestCode == REQUEST_CODE_PICK_AUDIO && resultCode == RESULT_OK && data != null) {
            // L'utente ha selezionato un file: ne otteniamo l'URI
            currentAudioUri = data.getData();
            if (currentAudioUri != null) {
                // Inizializziamo o re-inizializziamo il MediaPlayer con il nuovo file
                initMediaPlayer(currentAudioUri);
            }
        }
    }

    /**
     * Inizializza il MediaPlayer con l'URI fornito e prepara la riproduzione.
     */
    private void initMediaPlayer(Uri audioUri) {
        // Se esiste già un MediaPlayer, lo rilasciamo
        releaseMediaPlayer();

        mediaPlayer = new MediaPlayer();

        try {
            // Impostiamo la sorgente dati usando l'URI scelto dall'utente
            mediaPlayer.setDataSource(this, audioUri);

            // Collegamento opzionale alla Surface per il video (per audio non è necessario)
            if (surfaceHolder != null) {
                mediaPlayer.setDisplay(surfaceHolder);
            }

            // Listener chiamato quando il file è pronto alla riproduzione
            mediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
                @Override
                public void onPrepared(MediaPlayer mp) {
                    // Abilitiamo il MediaController e lo mostriamo
                    mediaController.setEnabled(true);
                    mediaController.show();
                    // Avviamo immediatamente la riproduzione
                    mp.start();
                }
            });

            // Listener per completamento della traccia
            mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
                @Override
                public void onCompletion(MediaPlayer mp) {
                    // Alla fine della traccia riportiamo la posizione a 0 e aggiorniamo il controller
                    mp.seekTo(0);
                    mediaController.show();
                    Toast.makeText(MainActivity.this,
                            "Riproduzione terminata", Toast.LENGTH_SHORT).show();
                }
            });

            // Listener per errori di riproduzione
            mediaPlayer.setOnErrorListener(new MediaPlayer.OnErrorListener() {
                @Override
                public boolean onError(MediaPlayer mp, int what, int extra) {
                    // Gestione semplificata degli errori
                    Toast.makeText(MainActivity.this,
                            "Errore nella riproduzione (" + what + ")",
                            Toast.LENGTH_LONG).show();
                    // Resettiamo e rilasciamo il player per evitare stati inconsistenti
                    releaseMediaPlayer();
                    return true; // Indichiamo che l'errore è stato gestito
                }
            });

            // Preparazione asincrona: non blocca il thread UI
            mediaPlayer.prepareAsync();

        } catch (IOException e) {
            // Eccezione in caso di problemi con la sorgente dati
            e.printStackTrace();
            Toast.makeText(this, "Impossibile riprodurre il file selezionato",
                    Toast.LENGTH_LONG).show();
            releaseMediaPlayer();
        }
    }

    /**
     * Rilascia il MediaPlayer se esiste, liberando le risorse native.
     */
    private void releaseMediaPlayer() {
        if (mediaPlayer != null) {
            try {
                mediaPlayer.reset(); // Resettiamo lo stato interno
                mediaPlayer.release(); // Rilasciamo le risorse native
            } catch (IllegalStateException e) {
                // Può capitare se il player è in stato inconsistente
                e.printStackTrace();
            }
            mediaPlayer = null;
        }
    }

    /**
     * Callback del risultato della richiesta di permessi runtime.
     */
    @Override
    public void onRequestPermissionsResult(int requestCode,
                                           @NonNull String[] permissions,
                                           @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);

        if (requestCode == REQUEST_CODE_PERMISSION_READ) {
            if (grantResults.length > 0
                    && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                // Permesso concesso: apriamo il selettore audio
                openAudioPicker();
            } else {
                // Permesso negato: notifichiamo l'utente
                Toast.makeText(this,
                        "Permesso di lettura storage negato",
                        Toast.LENGTH_LONG).show();
            }
        }
    }

    // ===================== Implementazione MediaPlayerControl =====================

    @Override
    public void start() {
        if (mediaPlayer != null) {
            mediaPlayer.start();
        }
    }

    @Override
    public void pause() {
        if (mediaPlayer != null && mediaPlayer.isPlaying()) {
            mediaPlayer.pause();
        }
    }

    @Override
    public int getDuration() {
        if (mediaPlayer != null) {
            try {
                return mediaPlayer.getDuration();
            } catch (IllegalStateException e) {
                return 0;
            }
        }
        return 0;
    }

    @Override
    public int getCurrentPosition() {
        if (mediaPlayer != null) {
            try {
                return mediaPlayer.getCurrentPosition();
            } catch (IllegalStateException e) {
                return 0;
            }
        }
        return 0;
    }

    @Override
    public void seekTo(int pos) {
        if (mediaPlayer != null) {
            try {
                mediaPlayer.seekTo(pos);
            } catch (IllegalStateException e) {
                // Ignoriamo o logghiamo l'errore
            }
        }
    }

    @Override
    public boolean isPlaying() {
        if (mediaPlayer != null) {
            try {
                return mediaPlayer.isPlaying();
            } catch (IllegalStateException e) {
                return false;
            }
        }
        return false;
    }

    @Override
    public int getBufferPercentage() {
        // Per file locali possiamo considerare 100% bufferizzato
        return 100;
    }

    @Override
    public boolean canPause() {
        return true;
    }

    @Override
    public boolean canSeekBackward() {
        return true;
    }

    @Override
    public boolean canSeekForward() {
        return true;
    }

    @Override
    public int getAudioSessionId() {
        if (mediaPlayer != null) {
            return mediaPlayer.getAudioSessionId();
        }
        return 0;
    }

    // ===================== Gestione ciclo di vita Activity =====================

    @Override
    protected void onPause() {
        super.onPause();
        // Se l'utente lascia l'Activity, mettiamo in pausa la riproduzione
        if (mediaPlayer != null && mediaPlayer.isPlaying()) {
            mediaPlayer.pause();
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // Alla distruzione dell'Activity rilasciamo completamente il player
        releaseMediaPlayer();
    }

    // ===================== Callback SurfaceHolder (per SurfaceView) =====================

    @Override
    public void surfaceCreated(@NonNull SurfaceHolder holder) {
        // La Surface è stata creata: possiamo collegarla al MediaPlayer se esiste
        surfaceHolder = holder;
        if (mediaPlayer != null) {
            mediaPlayer.setDisplay(surfaceHolder);
        }
    }

    @Override
    public void surfaceChanged(@NonNull SurfaceHolder holder, int format, int width, int height) {
        // Cambiamenti nella Surface (rotazione, resize, ecc.)
    }

    @Override
    public void surfaceDestroyed(@NonNull SurfaceHolder holder) {
        // La Surface non è più disponibile: scolleghiamo il display dal MediaPlayer
        if (mediaPlayer != null) {
            mediaPlayer.setDisplay(null);
        }
        surfaceHolder = null;
    }
}