La máquina de estados de MediaPlayer: reproducir audio en Android sin errores

1import java.util.Scanner;
2
3enum Estado { Idle, Initialized, Prepared, Started, Paused, Stopped, PlaybackCompleted, Error, End }
4
5class EstadoIlegal extends RuntimeException {
6    EstadoIlegal(String mensaje) { super(mensaje); }
7}
8
9/** Un reproductor con la máquina de estados de android.media.MediaPlayer. */
10class Reproductor {
11    Estado estado = Estado.Idle;
12    String fuente;
13    int duracion, posicion;
14    boolean bucle, pausadoPorFoco;
15
16    static String tiempo(int s) { return s / 60 + ":" + String.format("%02d", s % 60); }
17
18    String describir() { return fuente == null ? estado.name() : estado + " (" + tiempo(posicion) + " / " + tiempo(duracion) + ")"; }
19
20    /**
21     * Comprueba que el método se puede llamar en el estado actual. Si no, lanza EstadoIlegal y, si
22     * alError es true (start, pause, stop, seekTo), el reproductor pasa al estado Error.
23     */
24    private void exigir(String metodo, boolean alError, Estado... validos) {
25        if (estado == Estado.End) throw new EstadoIlegal("el reproductor ya se ha liberado");
26        for (Estado v : validos) if (estado == v) return;
27        String msg = metodo + "() en estado " + estado;
28        if (alError && estado != Estado.Error) {
29            estado = Estado.Error;
30            msg += " → Error";
31        }
32        throw new EstadoIlegal(msg);
33    }
34
35    void setDataSource(String f, int dur) {
36        exigir("setDataSource", false, Estado.Idle);
37        fuente = f;
38        duracion = dur;
39        posicion = 0;
40        estado = Estado.Initialized;
41    }
42
43    void prepare() {
44        exigir("prepare", false, Estado.Initialized, Estado.Stopped);
45        posicion = 0;
46        estado = Estado.Prepared;
47    }
48
49    void start() {
50        exigir("start", true, Estado.Prepared, Estado.Started, Estado.Paused, Estado.PlaybackCompleted);
51        if (estado == Estado.PlaybackCompleted) posicion = 0;      // vuelve a empezar desde el principio
52        estado = Estado.Started;
53    }
54
55    void pause() {
56        exigir("pause", true, Estado.Started, Estado.Paused);
57        estado = Estado.Paused;
58    }
59
60    void stop() {
61        exigir("stop", true, Estado.Prepared, Estado.Started, Estado.Paused, Estado.Stopped, Estado.PlaybackCompleted);
62        estado = Estado.Stopped;
63    }
64
65    void seekTo(int s) {
66        exigir("seekTo", true, Estado.Prepared, Estado.Started, Estado.Paused, Estado.PlaybackCompleted);
67        posicion = Math.max(0, Math.min(duracion, s));
68    }
69
70    void setLooping(boolean b) {
71        exigir("setLooping", false, Estado.Idle, Estado.Initialized, Estado.Prepared, Estado.Started, Estado.Paused, Estado.Stopped, Estado.PlaybackCompleted);
72        bucle = b;
73    }
74
75    void reset() {
76        exigir("reset", false, Estado.values());
77        estado = Estado.Idle;
78        fuente = null;
79        duracion = posicion = 0;
80        bucle = false;
81    }
82
83    void release() {
84        estado = Estado.End;
85        fuente = null;
86    }
87
88    /** Pasa el tiempo: solo avanza reproduciendo; al llegar al final, vuelve a empezar o se completa. */
89    String avanzar(int s) {
90        if (estado != Estado.Started) return "No avanza: el reproductor está en " + estado;
91        posicion += s;
92        if (posicion < duracion) return describir();
93        if (bucle) {
94            posicion %= duracion;
95            return describir() + ", ha vuelto a empezar";
96        }
97        posicion = duracion;
98        estado = Estado.PlaybackCompleted;
99        return "onCompletion() → " + describir();
100    }
101}
102
103public class Main {
104    public static void main(String[] args) {
105        Scanner sc = new Scanner(System.in);
106        Reproductor r = new Reproductor();
107        while (sc.hasNextLine()) {
108            String linea = sc.nextLine().trim();
109            if (linea.isEmpty()) continue;
110            System.out.println("> " + linea);
111            String[] p = linea.split("\\s+");
112            try {
113                switch (p[0]) {
114                    case "setDataSource" -> {
115                        if (p.length != 3 || !p[2].matches("[1-9]\\d*")) throw new IllegalArgumentException();
116                        r.setDataSource(p[1], Integer.parseInt(p[2]));
117                        System.out.println(r.describir());
118                    }
119                    case "prepare", "start", "pause", "stop", "reset", "release" -> {
120                        if (p.length != 1) throw new IllegalArgumentException();
121                        r.pausadoPorFoco = false;          // una orden del usuario manda sobre el foco de audio
122                        switch (p[0]) {
123                            case "prepare" -> r.prepare();
124                            case "start" -> r.start();
125                            case "pause" -> r.pause();
126                            case "stop" -> r.stop();
127                            case "reset" -> r.reset();
128                            default -> r.release();
129                        }
130                        System.out.println(r.describir());
131                    }
132                    case "seekTo", "avanzar" -> {
133                        if (p.length != 2 || !p[1].matches("\\d+")) throw new IllegalArgumentException();
134                        int n = Integer.parseInt(p[1]);
135                        if (p[0].equals("avanzar")) System.out.println(r.avanzar(n));
136                        else {
137                            r.seekTo(n);
138                            System.out.println(r.describir());
139                        }
140                    }
141                    case "setLooping" -> {
142                        if (p.length != 2 || !p[1].matches("true|false")) throw new IllegalArgumentException();
143                        r.setLooping(Boolean.parseBoolean(p[1]));
144                        System.out.println("Bucle: " + (r.bucle ? "sí" : "no"));
145                    }
146                    case "llamada" -> {
147                        if (r.estado == Estado.Started) {
148                            r.pause();
149                            r.pausadoPorFoco = true;
150                            System.out.println("AUDIOFOCUS_LOSS_TRANSIENT: pause() → " + r.describir());
151                        } else System.out.println("AUDIOFOCUS_LOSS_TRANSIENT: no hay nada que pausar");
152                    }
153                    case "colgar" -> {
154                        if (r.pausadoPorFoco && r.estado == Estado.Paused) {
155                            r.start();
156                            System.out.println("AUDIOFOCUS_GAIN: start() → " + r.describir());
157                        } else System.out.println("AUDIOFOCUS_GAIN: no hay nada que reanudar");
158                        r.pausadoPorFoco = false;
159                    }
160                    case "estado" -> System.out.println("Estado: " + r.estado + (r.fuente == null ? "" : " · " + r.fuente + " · "
161                            + Reproductor.tiempo(r.posicion) + " / " + Reproductor.tiempo(r.duracion)) + " · bucle: " + (r.bucle ? "sí" : "no"));
162                    default -> System.out.println("Orden desconocida: " + p[0]);
163                }
164            } catch (EstadoIlegal e) {
165                System.out.println("IllegalStateException: " + e.getMessage());
166            } catch (IllegalArgumentException e) {
167                System.out.println("Orden no válida: " + linea);
168            }
169        }
170    }
171}