android 安卓MediaPlayer AudioStream AudioFlinger服务器死了！，致命信号11

dfty9e19  于 2023-04-10  发布在  Android
关注(0)|答案(2)|浏览(117)

我有两个片段（左和右），在左边的片段中得到一个Radiostreams列表。通过单击其中一个流，右边的片段应该更改流的名称，并开始播放给定URI的流。
2个问题：
1.有些广播流不是最新的，所以很多都不能用了。问题是，这会导致我的应用程序强制关闭！我做了错误处理，但在调用这样的流后，我得到：
03-20 14：23：28.192：A/libc（1021）：致命信号11（SIGSEGV），0x 0000000（代码=1）
03-20 14：23：28.192：带音频系统（1021）：AudioFlinger服务器死亡！
03-20 14：23：28.192：W/IMMediaDeathNotifier（1021）：媒体服务器死亡
03-20 14：23：28.192：E/MediaPlayer（1021）：错误（100，0）
03-20 14：23：28.192：I/ServiceManager（1021）：等待服务media.audio_flinger...
03-20 14：23：28.752：I/dalvikvm（1021）：threadid=3：对信号3作出React
03-20 14：23：28.782：I/dalvikvm（1021）：将堆栈跟踪写入“/data/anr/traces.txt”
03-20 14：23：29.192：I/ServiceManager（1021）：等待服务media.audio_flinger...
我不知道为什么。有没有其他的方法来处理错误？或者有没有一种方法在调用mediaPlayer.setDataSource（uri）之前检查所有的流，以避免准备defekt uri？（请参阅我的代码在最后）
1.我正在用遥控器控制左边的ListFragment。当我试图从一个频道快速切换到另一个频道时，一切都非常滞后。似乎媒体播放器的恢复需要很长时间。当我不恢复时，当我再次调用mediaPlayer.setDataSource（..）时，我会得到一个runtimeerror。有没有办法在一个MediaPlayer对象上调用.setDataSource两次？
下面是我的代码：我的MediaPlayer Wrapper类：

package net.smart4life.tvplay.model;

import java.io.IOException;
import java.lang.reflect.Method;
import java.util.AbstractCollection;
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.media.MediaPlayer.OnBufferingUpdateListener;
import android.media.MediaPlayer.OnCompletionListener;
import android.media.MediaPlayer.OnErrorListener;
import android.media.MediaPlayer.OnInfoListener;
import android.media.MediaPlayer.OnPreparedListener;
import android.util.Log;

/**
 * A wrapper class for {@link android.media.MediaPlayer}.
 * <p>
 * Encapsulates an instance of MediaPlayer, and makes a record of its internal
 * state accessible via a {@link MediaPlayerWrapper#getState()} accessor.
 */
public class MediaPlayerStateWrapper {

    private static String tag = "MediaPlayerWrapper";
    private MediaPlayer mPlayer;
    private State currentState;
    private MediaPlayerStateWrapper mWrapper;

    public MediaPlayerStateWrapper() {
        mWrapper = this;
        mPlayer = new MediaPlayer();
        currentState = State.IDLE;
        mPlayer.setOnPreparedListener(mOnPreparedListener);
        mPlayer.setOnCompletionListener(mOnCompletionListener);
        mPlayer.setOnBufferingUpdateListener(mOnBufferingUpdateListener);
        mPlayer.setOnErrorListener(mOnErrorListener);
        mPlayer.setOnInfoListener(mOnInfoListener);
    }

    /* METHOD WRAPPING FOR STATE CHANGES */
    public static enum State {
        IDLE, ERROR, INITIALIZED, PREPARING, PREPARED, STARTED, STOPPED, PLAYBACK_COMPLETE, PAUSED;
    }

    public void setDataSource(String path) {
        if (currentState == State.IDLE) {
            try {
                mPlayer.setDataSource(path);
                currentState = State.INITIALIZED;
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalStateException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else
            throw new RuntimeException();
    }

    public void prepareAsync() {
        Log.d(tag, "prepareAsync()");
        if (EnumSet.of(State.INITIALIZED, State.STOPPED).contains(currentState)) {
            mPlayer.prepareAsync();
            currentState = State.PREPARING;
        } else
            throw new RuntimeException();
    }

    public boolean isPlaying() {
        Log.d(tag, "isPlaying()");
        if (currentState != State.ERROR) {
            return mPlayer.isPlaying();
        } else
            throw new RuntimeException();
    }

    public void seekTo(int msec) {
        Log.d(tag, "seekTo()");
        if (EnumSet.of(State.PREPARED, State.STARTED, State.PAUSED,
                State.PLAYBACK_COMPLETE).contains(currentState)) {
            mPlayer.seekTo(msec);
        } else
            throw new RuntimeException();
    }

    public void pause() {
        Log.d(tag, "pause()");
        if (EnumSet.of(State.STARTED, State.PAUSED).contains(currentState)) {
            mPlayer.pause();
            currentState = State.PAUSED;
        } else
            throw new RuntimeException();
    }

    public void start() {
        Log.d(tag, "start()");
        if (EnumSet.of(State.PREPARED, State.STARTED, State.PAUSED,
                State.PLAYBACK_COMPLETE).contains(currentState)) {
            mPlayer.start();
            currentState = State.STARTED;
        } else
            throw new RuntimeException();
    }

    public void stop() {
        Log.d(tag, "stop()");
        if (EnumSet.of(State.PREPARED, State.STARTED, State.STOPPED,
                State.PAUSED, State.PLAYBACK_COMPLETE).contains(currentState)) {
            mPlayer.stop();
            currentState = State.STOPPED;
        } else
            throw new RuntimeException();
    }

    public void reset() {
        Log.d(tag, "reset()");
        mPlayer.reset();
        currentState = State.IDLE;
    }

    /**
     * @return The current state of the mediaplayer state machine.
     */
    public State getState() {
        Log.d(tag, "getState()");
        return currentState;
    }

    public void release() {
        Log.d(tag, "release()");
        mPlayer.release();
    }

    /* INTERNAL LISTENERS */
    private OnPreparedListener mOnPreparedListener = new OnPreparedListener() {

        @Override
        public void onPrepared(MediaPlayer mp) {
            Log.d(tag, "on prepared");
            currentState = State.PREPARED;
            mWrapper.onPrepared(mp);
            mPlayer.start();
            currentState = State.STARTED;
        }
    };
    private OnCompletionListener mOnCompletionListener = new OnCompletionListener() {

        @Override
        public void onCompletion(MediaPlayer mp) {
            Log.d(tag, "on completion");
            currentState = State.PLAYBACK_COMPLETE;
            mWrapper.onCompletion(mp);
        }
    };
    private OnBufferingUpdateListener mOnBufferingUpdateListener = new OnBufferingUpdateListener() {

        @Override
        public void onBufferingUpdate(MediaPlayer mp, int percent) {
            Log.d(tag, "on buffering update");
            mWrapper.onBufferingUpdate(mp, percent);
        }
    };
    private OnErrorListener mOnErrorListener = new OnErrorListener() {

        @Override
        public boolean onError(MediaPlayer mp, int what, int extra) {
            Log.d(tag, "on error");
            currentState = State.ERROR;
            mWrapper.onError(mp, what, extra);
            return false;
        }
    };
    private OnInfoListener mOnInfoListener = new OnInfoListener() {

        @Override
        public boolean onInfo(MediaPlayer mp, int what, int extra) {
            Log.d(tag, "on info");
            mWrapper.onInfo(mp, what, extra);
            return false;
        }
    };

    /* EXTERNAL STUBS TO OVERRIDE */
    public void onPrepared(MediaPlayer mp) {
    }

    public void onCompletion(MediaPlayer mp) {
    }

    public void onBufferingUpdate(MediaPlayer mp, int percent) {
    }

    boolean onError(MediaPlayer mp, int what, int extra) {
        // Error Handling of type: "MEdiaPlayer error(100,0)
        mp.stop();
        mp.release();
        return false;
    }

    public boolean onInfo(MediaPlayer mp, int what, int extra) {
        return false;
    }

    /* OTHER STUFF */
    public int getCurrentPosition() {
        if (currentState != State.ERROR) {
            return mPlayer.getCurrentPosition();
        } else {
            return 0;
        }
    }

    public int getDuration() {
        // Prepared, Started, Paused, Stopped, PlaybackCompleted
        if (EnumSet.of(State.PREPARED, State.STARTED, State.PAUSED,
                State.STOPPED, State.PLAYBACK_COMPLETE).contains(currentState)) {
            return mPlayer.getDuration();
        } else {
            return 100;
        }
    }
}

下面是我的TestFragment（右Fragment）。每当列表项被点击时，左边的片段从TestFragment调用方法“newChannel（radioChannel）”。

package net.smart4life.tvplay.fragment;

import java.io.IOException;

import net.smart4life.tvplay.R;
import net.smart4life.tvplay.model.MediaPlayerStateWrapper;
import net.smart4life.tvplay.model.RadioChannel;
import android.app.Fragment;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.media.MediaPlayer.OnErrorListener;
import android.media.MediaPlayer.OnPreparedListener;
import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import android.widget.Toast;

public class TestFragment extends Fragment {

    private RadioChannel radioCh;
    private TextView tv_RadioCh;
    private MediaPlayerStateWrapper mediaWrapper;
    private View view;

    // firstcall
    public TestFragment(RadioChannel radioChannel) {
        this.radioCh = radioChannel;
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onActivityCreated(savedInstanceState);

        setRetainInstance(true);

        tv_RadioCh = (TextView) view.findViewById(R.id.radioText);

        mediaWrapper = new MediaPlayerStateWrapper();

        newChannel(radioCh);
    }

    public void newChannel (RadioChannel radioChannel) {
        this.radioCh = radioChannel;
        Log.e("RadioChannel", radioCh.getName());
        tv_RadioCh.setText(radioCh.getName());

        if(mediaWrapper.isPlaying()) {
            mediaWrapper.stop();
            mediaWrapper.reset(); 
        } else if(mediaWrapper.getState() == MediaPlayerStateWrapper.State.PREPARING) {
            mediaWrapper.release();
            mediaWrapper = new MediaPlayerStateWrapper();
        }
        mediaWrapper.setDataSource(radioCh.getUrl().toString());    
        mediaWrapper.prepareAsync();
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {

        view = inflater.inflate(R.layout.fragment_radio_player, container,
                false);

        return view;
    }

    @Override
    public void onDetach() {
        super.onDetach();

        mediaWrapper.release();
    }

}

Maven们，你们能帮我回答一个或两个问题吗？

android

2条答案

按热度按时间
vulvrdjw

vulvrdjw1#

如果一个流不能加载，你经常被困在准备状态，你可以在这里尝试，当mediaWrapper.getState() == MediaPlayerStateWrapper.State.ERROR：

mediaWrapper.reset();
mediaWrapper.release();
System.gc();
mediaWrapper = new MediaPlayerStateWrapper();
mediaWrapper.setDataSource(radioCh.getUrl().toString());
mediaWrapper.prepareAsync();

最好把它放在一个AsyncTask中，以避免Not responding error。或者当你得到一个错误时，你必须创建一个新的MediaPlayer，因为Media Server died：

if(mediaWrapper.getState() == MediaPlayerStateWrapper.State.ERROR){
    mediaWrapper = new MediaPlayerStateWrapper();
    mediaWrapper.setDataSource(radioCh.getUrl().toString());
    mediaWrapper.prepareAsync();
}

如果MediaPlayer正在播放流，则必须先停止并重置它：

mediaWrapper.stop();
mediaWrapper.reset();
mediaWrapper.setDataSource(radioCh.getUrl().toString());
mediaWrapper.prepareAsync();

这对我来说很有效，但我认为这不是最好的方法。希望有人能找到一个更好的解决方案，当你陷入准备状态时。

赞(0）分享  回复(0）举报  2023-04-10
qxsslcnc

qxsslcnc2#

关于audioflinger服务错误，正如您所注意到的，它被标记为“what == 100”或error（100，0）。
你可以做些什么来避免audioflinger错误从我卑微的经验：
1.避免快速调用服务（我在创建播放器后添加了500米利斯延迟）
1.限制同时活动的并发媒体播放器的数量。
你可以做什么来处理audioflinger错误：
1.检测audioflinger错误100，设置它发生的标志并禁用GUI（建议仅释放播放器，因为当它已经处于错误状态时停止它是不安全的，并且将抛出IllegalStateException & error（38，0））
1.启动另一个线程，持续测试服务是否恢复（可以通过创建一个新的MediaPlayer，没有异常），超时时间为5-10秒
1.当服务返回时，重置标志并重新启用GUI
参考你的代码：

boolean onError(MediaPlayer mp, int what, int extra) {
    // Error Handling of type: "MEdiaPlayer error(100,0)
    mp.release();
    // here you add logic communicating the wrapper or main UI thread
    // to disable GUI and set a flag
    return false;
}

然后在 Package 器中添加一个方法来处理这个问题。
如果你能解决这个问题并发布一个解决方案，我将非常感激。我也面临着一个非常类似的问题。

赞(0）分享  回复(0）举报  2023-04-10
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备2022004421号-2 NULL123 https://www.null123.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com