Media Player chiamato nello stato 0, errore (-38,0)

Attualmente sto cercando di progettare una semplice app che trasmetta in streaming una stazione radio Internet. Ho l'URL della stazione e sto configurando il Media Player come

    MediaPlayer mediaPlayer = new MediaPlayer();
    try {
        mediaPlayer.setDataSource(URL);
    } catch (IllegalArgumentException e) {
        e.printStackTrace();
    } catch (SecurityException e) {
        e.printStackTrace();
    } catch (IllegalStateException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    try {
        mediaPlayer.prepare();
    } catch (IllegalStateException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    mediaPlayer.start();

Il programma non si arresta in modo anomalo quando emulato, ma non viene riprodotto nulla e viene visualizzato il seguente errore:

start called in state 0

e proprio sotto lo è

Error (-38,0)

Qualcuno sa cosa significa?

Ho letto un po 'di questi errori di stato, ma non sono riuscito a trovare nulla che si applichi al mio progetto.

È necessario chiamare mediaPlayer.start()il onPreparedmetodo utilizzando un listener. Ricevi questo errore perché stai chiamando mediaPlayer.start()prima che abbia raggiunto lo stato preparato.

Ecco come puoi farlo :

mp.setDataSource(url); 
mp.setOnPreparedListener(this);
mp.prepareAsync();

public void onPrepared(MediaPlayer player) {
    player.start();
}

Sembra che l'errore -38 significhi un'eccezione di stato (come indica il messaggio di errore). Ad esempio, se chiami start(), prima che il brano fosse pronto o quando chiami pause(), anche se il brano non viene riprodotto affatto.

Per risolvere questo problema, controllare lo stato del mediaPlayer prima di chiamare i metodi. Per esempio:

if(mediaPlayer.isPlaying()) {
    mediaPlayer.pause();
}

Inoltre, MediaPlayer invia messaggi di eventi. Anche se non hai bisogno dell'evento preparato (anche se sarebbe una buona idea non avviare la riproduzione prima che questo evento fosse attivato) devi impostare un listener di richiamata. Questo vale anche per il OnErrorListener, OnCompletionListener, OnPreparedListenere OnSeekCompletedListener(se si chiama il metodo Seek).

Gli ascoltatori possono essere attaccati semplicemente da

mediaPlayer.setOnPreparedListener(new OnPreparedListener() {
    @Override
    public void onPrepared(MediaPlayer mp) {
        // Do something. For example: playButton.setEnabled(true);
    }
});

Ho ricevuto questo errore quando stavo cercando di ottenere la posizione corrente (MediaPlayer.getCurrentPosition ()) del lettore multimediale quando non era nel preparato dichiarato. Ho aggirato questo problema tenendo traccia del suo stato e chiamando il metodo getCurrentPosition () solo dopo aver chiamato onPreparedListener.

Questo è il mio codice, testato e funzionante:

package com.example.com.mak.mediaplayer;

import android.media.MediaPlayer;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.app.Activity;

public class MainActivity extends Activity {

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    final MediaPlayer mpp = MediaPlayer.create(this, R.raw.red); //mp3 file in res/raw folder

    Button btnplay = (Button) findViewById(R.id.btnplay); //Play
    btnplay.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View vone) {
        mpp.start();
      }
    });

    Button btnpause = (Button) findViewById(R.id.btnpause); //Pause
    btnpause.setOnClickListener(new View.OnClickListener() {

      @Override
      public void onClick(View vtwo) {
        if (mpp.isPlaying()) {
          mpp.pause();
          mpp.seekTo(0);
        }
      }
    });
  }
}

ho provato sotto il codice. funziona bene

public class test extends Activity implements OnErrorListener, OnPreparedListener {

private MediaPlayer player;

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);


    player = new MediaPlayer();
    player.setAudioStreamType(AudioManager.STREAM_MUSIC);
    try {
        player.setDataSource("http://www.hubharp.com/web_sound/BachGavotte.mp3");
        player.setOnErrorListener(this);
        player.setOnPreparedListener(this);
        player.prepareAsync();
    } catch (IllegalArgumentException e) {
        e.printStackTrace();
    } catch (IllegalStateException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }       
}
@Override
public void onDestroy() {
    super.onDestroy();
    player.release();
    player = null;
}
@Override
public void onPrepared(MediaPlayer play) {
    play.start();
}
@Override
public boolean onError(MediaPlayer arg0, int arg1, int arg2) {
    return false;
}
}

Ho riscontrato lo stesso problema pochi giorni fa. Il mio audio MediaPlayer funziona bene su dispositivi con elevata potenza di elaborazione, ma per dispositivi lenti, il lettore multimediale semplicemente non ha funzionato per un po 'di tempo e da LogCat molti si sono lamentati di chiamare in uno stato sbagliato. Così ho risolto chiamando mettendo la chiamata a start () , pause () , ... in onPrepared () il metodo di OnPreparedListener () come di seguito:

mediaPlayer.prepare();
mediaPlayer.setOnPreparedListener(new OnPreparedListener() {
                @Override
                public void onPrepared(MediaPlayer mp) {
                    ........
                    mediaPlayer.start();
                    ....
                    songControlBtn.setOnClickListener(new OnClickListener() {
                        @Override
                        public void onClick(View v) {
                            if (mediaPlayer.isPlaying()) {
                                mediaPlayer.pause();

                            } else {
                                mediaPlayer.start();

                            }
                        }
                    });

                    mediaPlayer.setOnCompletionListener(new OnCompletionListener() {
                        @Override
                        public void onCompletion(MediaPlayer mp) {
                            ............

                        }
                    });
                }
            });

Prova anche a rilasciare qualsiasi lettore multimediale che non ti serve più. Ad esempio, se non si desidera riprodurre l'audio o il video in background, è necessario chiamare mediaPlayer.release () in onPause () .

Alcune volte i file sono codificati in un modo che Android non può decodificare. Anche alcuni file mp4 non possono essere riprodotti. Prova un formato di file diverso (la maggior parte delle volte vengono riprodotti .3gp) e vedi ..

sopra l'immagine, puoi ottenere il modo giusto.

Ottieni questo messaggio nei log, perché fai qualcosa che non è consentito nello stato corrente della tua istanza MediaPlayer.

Pertanto dovresti sempre registrare un gestore degli errori per catturare queste cose (come suggerito da @tidbeck).

All'inizio, ti consiglio di dare un'occhiata alla documentazione per la MediaPlayerclasse e di capire cosa significa questo con gli stati. Vedi: http://developer.android.com/reference/android/media/MediaPlayer.html#StateDiagram

Il tuo errore qui potrebbe essere uno di quelli comuni, gli altri hanno scritto qui, ma in generale, darei un'occhiata alla documentazione di quali metodi sono validi per chiamare in quale stato: http://developer.android.com/ di riferimento / android / media / MediaPlayer.html # Valid_and_Invalid_States

Nel mio esempio è stato il metodo mediaPlayer.CurrentPosition, che ho chiamato mentre il lettore multimediale era in uno stato in cui non era consentito chiamare questa proprietà.

Ho risolto sia gli errori (-19,0) che (-38,0), creando un nuovo oggetto di MediaPlayer ogni volta prima di riprodurlo e rilasciandolo dopo.

Prima :

void play(int resourceID) {
if (getActivity() != null) {

     //Using the same object - Problem persists
    player = MediaPlayer.create(getActivity(), resourceID);
    player.setAudioStreamType(AudioManager.STREAM_MUSIC);

    player.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
        @Override
        public void onCompletion(MediaPlayer mp) {
            player.release();
        }
    });

    player.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
        @Override
        public void onPrepared(MediaPlayer mp) {
            mp.start();
        }
    });

}

}

Dopo:

void play(int resourceID) {

if (getActivity() != null) {

    //Problem Solved
    //Creating new MediaPlayer object every time and releasing it after completion
    final MediaPlayer player = MediaPlayer.create(getActivity(), resourceID);
    player.setAudioStreamType(AudioManager.STREAM_MUSIC);

    player.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
        @Override
        public void onCompletion(MediaPlayer mp) {
            player.release();
        }
    });

    player.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
        @Override
        public void onPrepared(MediaPlayer mp) {
            mp.start();
        }
    });

}

}

  if(length>0)
        {
            mediaPlayer = new MediaPlayer();
            Log.d("length",""+length);
            try {
                mediaPlayer.setDataSource(getApplication(),Uri.parse(uri));
            } catch(IOException e) {
                e.printStackTrace();
            }
            mediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
                @Override
                public void onPrepared(MediaPlayer mediaPlayer) {
                    mediaPlayer.seekTo(length);
                    mediaPlayer.start();

                }
            });
            mediaPlayer.prepareAsync();

Era tutto molto frustrato. Quindi, ho una soluzione che funziona per me.

try {
                        if (mediaPlayer != null) {
                            mediaPlayer.release();
                            mediaPlayer = null;

                        }
                        mediaPlayer = new MediaPlayer();
                        mediaPlayer.setDataSource(file.getAbsolutePath());
                        mediaPlayer.setAudioStreamType(AudioManager.STREAM_NOTIFICATION);
                        mediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
                            @Override
                            public void onPrepared(MediaPlayer mediaPlayer) {
                                mediaPlayer.start();
                                mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
                                    @Override
                                    public void onCompletion(MediaPlayer mediaPlayer) {
                                        mediaPlayer.stop();
                                        mediaPlayer.release();
                                        mediaPlayer = null;
                                    }
                                });
                            }
                        });
                        mediaPlayer.prepare();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }

Per me questo ha funzionato

mp.seekTo(0);
mp.start();

Ho anche ricevuto questo errore che ho provato con onPreparedListener ma ho ancora ricevuto questo errore. Finalmente ho avuto la soluzione che l'errore è colpa mia perché ho dimenticato l'autorizzazione a Internet in Android Manifest xml. :)

<uses-permission android:name="android.permission.INTERNET" />

Ho usato la codifica di esempio per mediaplayer. Ho usato nel metodo StreamService.java
onCreate

String url = "http://s17.myradiostream.com:11474/";
mediaPlayer = new MediaPlayer();            
mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
mediaPlayer.setDataSource(url);
mediaPlayer.prepare();

Ho incontrato lo stesso problema poco prima, l'amico al primo piano aveva ragione, hai chiamato start()nel momento sbagliato, dovresti impostare un listener per prepare () o prepareSync()con questo metodo mediaPlayer.setOnPreparedListener(this); prima di prepararsi, in questa chiamata di richiamata start(). Potrebbe risolvere il problema. Ho già provato.

Sono nuovo nella programmazione Android e ho avuto lo stesso errore di questo. quindi ho semplicemente ridefinito mp.createmediaPlayer = MediaPlayer.create (getApplicationContext (), Settings.System.DEFAULT_RINGTONE_URI). Potrebbe non essere il vero modo per farlo, ma per me ha funzionato bene:

try {
  mp = MediaPlayer.create(getApplicationContext(), Settings.System.DEFAULT_RINGTONE_URI);
} catch (Exception e) {
  e.printStackTrace();
}

mp.start();

mp = new MediaPlayer();
AssetFileDescriptor afd = mContext.getAssets().openFd(fileName);
mp.reset();
mp.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());
mp.prepare();
mp.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
  public void onPrepared(MediaPlayer mp) {
    mp.start();
  }
});

mp.prepareAsync();