Java MediaPlayer oncomplete侦听器在服务中未执行

我正在尝试创建一个在后台播放音乐的服务，但是当一首歌完成时，应该播放nextone，但似乎不调用oncomplete listener。谁能告诉我哪里出了问题

另外，我在logcat中没有任何内容，也没有在进入oncomplete listener时显示的日志

这是我的密码：

public class myPlayService extends Service implements OnCompletionListener,
        OnPreparedListener, OnErrorListener, OnSeekCompleteListener,
        OnInfoListener, OnBufferingUpdateListener {

    private static final String TAG = "--";
    public static MediaPlayer mediaPlayer = new MediaPlayer();

    // songs
    private static ArrayList<Songs> songs;
    private static int position;

    // Set up the notification ID
    private static final int NOTIFICATION_ID = 1;
    private boolean isPausedInCall = false;
    private PhoneStateListener phoneStateListener;
    private TelephonyManager telephonyManager;

    // ---Variables for seekbar processing---
    String sntSeekPos;
    static int intSeekPos;
    int mediaPosition;
    int mediaMax;
    // Intent intent;
    private final Handler handler = new Handler();
    private static int songEnded;
    public static boolean serviceStarted=false;
    public static final String BROADCAST_ACTION = "com.darkovski.quran.seekprogress";

    // Set up broadcast identifier and intent
    public static final String BROADCAST_BUFFER = "com.darkovski.quran.broadcastbuffer";

    Intent bufferIntent;
    Intent seekIntent;

    // Declare headsetSwitch variable
    private int headsetSwitch = 1;

    // OnCreate
    @Override
    public void onCreate() {
        Log.v(TAG, "Creating Service");
        // android.os.Debug.waitForDebugger();
        // Instantiate bufferIntent to communicate with Activity for progress
        // dialogue
        serviceStarted=true;
        songs = new ArrayList<Songs>();
        bufferIntent = new Intent(BROADCAST_BUFFER);
        // ---Set up intent for seekbar broadcast ---
        seekIntent = new Intent(BROADCAST_ACTION);
        mediaPlayer.setOnCompletionListener(this);
        mediaPlayer.setOnErrorListener(this);
        mediaPlayer.setOnPreparedListener(this);
        mediaPlayer.setOnBufferingUpdateListener(this);
        mediaPlayer.setOnSeekCompleteListener(this);
        mediaPlayer.setOnInfoListener(this);
        mediaPlayer.reset();

        // Register headset receiver
        registerReceiver(headsetReceiver, new IntentFilter(
                Intent.ACTION_HEADSET_PLUG));

    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // get songs and position
        songs = new ArrayList<Songs>();
        songs = (ArrayList<Songs>) intent.getSerializableExtra("songs");
        Log.v("--", songs.size() + " size!#$");
        position = intent.getIntExtra("position", -1);
        // ---Set up receiver for seekbar change ---
        registerReceiver(broadcastReceiver, new IntentFilter(
                Player.BROADCAST_SEEKBAR));

        // Manage incoming phone calls during playback. Pause mp on incoming,
        // resume on hangup.
        // -----------------------------------------------------------------------------------
        // Get the telephony manager
        Log.v(TAG, "Starting telephony");
        telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
        Log.v(TAG, "Starting listener");
        phoneStateListener = new PhoneStateListener() {
            @Override
            public void onCallStateChanged(int state, String incomingNumber) {
                // String stateString = "N/A";
                Log.v(TAG, "Starting CallStateChange");
                switch (state) {
                case TelephonyManager.CALL_STATE_OFFHOOK:
                case TelephonyManager.CALL_STATE_RINGING:
                    if (mediaPlayer != null) {
                        pauseMedia();
                        isPausedInCall = true;
                    }

                    break;
                case TelephonyManager.CALL_STATE_IDLE:
                    // Phone idle. Start playing.
                    if (mediaPlayer != null) {
                        if (isPausedInCall) {
                            isPausedInCall = false;
                            playMedia();
                        }

                    }
                    break;
                }

            }
        };

        // Register the listener with the telephony manager
        telephonyManager.listen(phoneStateListener,
                PhoneStateListener.LISTEN_CALL_STATE);

        // Insert notification start
        initNotification();

        mediaPlayer.reset();

        // Set up the MediaPlayer data source using the strAudioLink value
        if (!mediaPlayer.isPlaying()) {
            try {

                // Send message to Activity to display progress dialogue
                sendBufferingBroadcast();
                mediaPlayer.setDataSource(songs.get(position).getLink());
                ;
                // Prepare mediaplayer
                mediaPlayer.prepare();

            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalStateException e) {
                e.printStackTrace();
            } catch (IOException e) {
            }
        }
        // --- Set up seekbar handler ---
        setupHandler();

        return START_STICKY;
    }

    // ---Send seekbar info to activity----
    private void setupHandler() {
        handler.removeCallbacks(sendUpdatesToUI);
        handler.postDelayed(sendUpdatesToUI, 300); // 1 second
    }

    private Runnable sendUpdatesToUI = new Runnable() {
        public void run() {
            // // Log.d(TAG, "entered sendUpdatesToUI");

            LogMediaPosition();

            handler.postDelayed(this, 1000); // 2 seconds

        }
    };

    private void LogMediaPosition() {
        // // Log.d(TAG, "entered LogMediaPosition");
        if (mediaPlayer.isPlaying()) {
            mediaPosition = mediaPlayer.getCurrentPosition();
            // if (mediaPosition < 1) {
            // Toast.makeText(this, "Buffering...", Toast.LENGTH_SHORT).show();
            // }
            mediaMax = mediaPlayer.getDuration();
            // seekIntent.putExtra("time", new Date().toLocaleString());
            seekIntent.putExtra("counter", String.valueOf(mediaPosition));
            seekIntent.putExtra("mediamax", String.valueOf(mediaMax));
            seekIntent.putExtra("song_ended", String.valueOf(songEnded));
            sendBroadcast(seekIntent);
        }
    }

    // --Receive seekbar position if it has been changed by the user in the
    // activity
    private BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            updateSeekPos(intent);
        }
    };

    // Update seek position from Activity
    public void updateSeekPos(Intent intent) {
        int seekPos = intent.getIntExtra("seekpos", 0);
        if (mediaPlayer.isPlaying()) {
            handler.removeCallbacks(sendUpdatesToUI);
            mediaPlayer.seekTo(seekPos);
            setupHandler();
        }

    }

    // ---End of seekbar code

    // If headset gets unplugged, stop music and service.
    private BroadcastReceiver headsetReceiver = new BroadcastReceiver() {
        private boolean headsetConnected = false;

        @Override
        public void onReceive(Context context, Intent intent) {
            // TODO Auto-generated method stub
            // Log.v(TAG, "ACTION_HEADSET_PLUG Intent received");
            if (intent.hasExtra("state")) {
                if (headsetConnected && intent.getIntExtra("state", 0) == 0) {
                    headsetConnected = false;
                    headsetSwitch = 0;
                    // Log.v(TAG, "State =  Headset disconnected");
                    // headsetDisconnected();
                } else if (!headsetConnected
                        && intent.getIntExtra("state", 0) == 1) {
                    headsetConnected = true;
                    headsetSwitch = 1;
                    // Log.v(TAG, "State =  Headset connected");
                }

            }

            switch (headsetSwitch) {
            case (0):
                headsetDisconnected();
                break;
            case (1):
                break;
            }
        }

    };

    private void headsetDisconnected() {
        stopMedia();
        stopSelf();

    }

    // --- onDestroy, stop media player and release. Also stop
    // phoneStateListener, notification, receivers...---
    @Override
    public void onDestroy() {
        super.onDestroy();
        if (mediaPlayer != null) {
            if (mediaPlayer.isPlaying()) {
                mediaPlayer.stop();
            }
            mediaPlayer.release();
        }

        if (phoneStateListener != null) {
            telephonyManager.listen(phoneStateListener,
                    PhoneStateListener.LISTEN_NONE);
        }

        // Cancel the notification
        cancelNotification();

        // Unregister headsetReceiver
        unregisterReceiver(headsetReceiver);

        // Unregister seekbar receiver
        unregisterReceiver(broadcastReceiver);

        // Stop the seekbar handler from sending updates to UI
        handler.removeCallbacks(sendUpdatesToUI);

        // Service ends, need to tell activity to display "Play" button
        resetButtonPlayStopBroadcast();
    }

    // Send a message to Activity that audio is being prepared and buffering
    // started.
    private void sendBufferingBroadcast() {
        // Log.v(TAG, "BufferStartedSent");
        bufferIntent.putExtra("buffering", "1");
        sendBroadcast(bufferIntent);
    }

    // Send a message to Activity that audio is prepared and ready to start
    // playing.
    private void sendBufferCompleteBroadcast() {
        // Log.v(TAG, "BufferCompleteSent");
        bufferIntent.putExtra("buffering", "0");
        sendBroadcast(bufferIntent);
    }

    // Send a message to Activity to reset the play button.
    private void resetButtonPlayStopBroadcast() {
        // Log.v(TAG, "BufferCompleteSent");
        bufferIntent.putExtra("buffering", "2");
        sendBroadcast(bufferIntent);
    }

    @Override
    public void onBufferingUpdate(MediaPlayer arg0, int arg1) {
        // TODO Auto-generated method stub

    }

    @Override
    public boolean onInfo(MediaPlayer arg0, int arg1, int arg2) {
        // TODO Auto-generated method stub
        return false;
    }

    @Override
    public void onSeekComplete(MediaPlayer mp) {

        if (!mediaPlayer.isPlaying()) {
            playMedia();
            Toast.makeText(this, "SeekComplete", Toast.LENGTH_SHORT).show();
        }

    }

    // ---Error processing ---
    @Override
    public boolean onError(MediaPlayer mp, int what, int extra) {
        switch (what) {
        case MediaPlayer.MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK:
            Toast.makeText(this,
                    "MEDIA ERROR NOT VALID FOR PROGRESSIVE PLAYBACK " + extra,
                    Toast.LENGTH_SHORT).show();
            break;
        case MediaPlayer.MEDIA_ERROR_SERVER_DIED:
            Toast.makeText(this, "MEDIA ERROR SERVER DIED " + extra,
                    Toast.LENGTH_SHORT).show();
            break;
        case MediaPlayer.MEDIA_ERROR_UNKNOWN:
            Toast.makeText(this, "MEDIA ERROR UNKNOWN " + extra,
                    Toast.LENGTH_SHORT).show();
            break;
        }
        return false;
    }

    @Override
    public void onPrepared(MediaPlayer arg0) {

        // Send a message to activity to end progress dialogue

        sendBufferCompleteBroadcast();
        playMedia();

    }

    @Override
    public void onCompletion(MediaPlayer mp) {
        // When song ends, need to tell activity to display "Play" button
        position += 1;
        mp.stop();
        mp.release();
        Log.v("--", "complete");
//      stopMedia();
        playMedia();
        // stopSelf();

    }

    @Override
    public IBinder onBind(Intent arg0) {
        // TODO Auto-generated method stub
        return null;
    }

    public static void pause() {
        mediaPlayer.pause();
    }
    public static void resume(){
        mediaPlayer.start();
    }

    public static void playMedia() {
        if (!mediaPlayer.isPlaying()) {
            try {
                mediaPlayer.stop();
                mediaPlayer.release();
                mediaPlayer = new MediaPlayer();
                mediaPlayer.setDataSource(songs.get(position).getLink());
                mediaPlayer.prepare();
                mediaPlayer.start();
            } catch (IllegalStateException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } else {
            try {
                mediaPlayer.setDataSource(songs.get(position).getLink());
                mediaPlayer.prepare();
                mediaPlayer.start();
            } catch (IllegalArgumentException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SecurityException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IllegalStateException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

    public static void nextSong() {
        if (position + 1 == songs.size())
            position = 0;
        else
            position += 1;
        playMedia();
    }

    public static void prevSong() {
        if (position - 1 >= 0)
            position -= 1;
        else
            position = songs.size() - 1;
        playMedia();
    }

    // Add for Telephony Manager
    public void pauseMedia() {
        // Log.v(TAG, "Pause Media");
        if (mediaPlayer.isPlaying()) {
            mediaPlayer.pause();
        }

    }

    public void stopMedia() {
        if (mediaPlayer.isPlaying()) {
            mediaPlayer.stop();
        }
        mediaPlayer.release();
    }

    // Create Notification
    private void initNotification() {
        String ns = Context.NOTIFICATION_SERVICE;
        NotificationManager mNotificationManager = (NotificationManager) getSystemService(ns);
        int icon = R.drawable.ic_launcher;
        CharSequence tickerText = "Tutorial: Music In Service";
        long when = System.currentTimeMillis();
        Notification notification = new Notification(icon, tickerText, when);
        notification.flags = Notification.FLAG_ONGOING_EVENT;
        Context context = getApplicationContext();
        CharSequence contentTitle = "Music In Service App Tutorial";
        CharSequence contentText = "Listen To Music While Performing Other Tasks";
        Intent notificationIntent = new Intent(this, Player.class);
        PendingIntent contentIntent = PendingIntent.getActivity(context, 0,
                notificationIntent, 0);
        notification.setLatestEventInfo(context, contentTitle, contentText,
                contentIntent);
        mNotificationManager.notify(NOTIFICATION_ID, notification);
    }

    // Cancel Notification
    private void cancelNotification() {
        String ns = Context.NOTIFICATION_SERVICE;
        NotificationManager mNotificationManager = (NotificationManager) getSystemService(ns);
        mNotificationManager.cancel(NOTIFICATION_ID);
    }
}

公共类myPlayService扩展服务实现OnCompletionListener，
OnPreparedListener、OnErrorListener、OnSeekCompleteListener、，
OnInfoListener、OnBufferingUpdateListener{
私有静态最终字符串标记=“--”；
public static MediaPlayer MediaPlayer=new MediaPlayer（）；
//歌曲
私人静态ArrayList歌曲；
私有静态内部位置；
//设置通知ID
私有静态最终整数通知_ID=1；
私有布尔值isPausedCall=false；
私有PhoneStateListener PhoneStateListener；
专用电话管理器电话管理器；
//---seekbar处理的变量---
字符串sntSeekPos；
静态int intSeekPos；
中间位置；
int mediaMax；
//意图；
私有最终处理程序=新处理程序（）；
私有静态文件；
公共静态布尔serviceStarted=false；
公共静态最终字符串广播\u ACTION=“com.darkovski.quran.seekprogress”；
//设置广播标识符和意图
public static final String BROADCAST_BUFFER=“com.darkovski.quran.broadcastbuffer”；
意图；意图；
意向性seekIntent；
//声明headsetSwitch变量
专用int头戴式开关=1；
//一次创建
@凌驾
public void onCreate（）{
Log.v（标记“创建服务”）；
//android.os.Debug.waitForDebugger（）；
//实例化bufferIntent以与活动进行通信以获得进展
//对话
serviceStarted=true；
歌曲=新的ArrayList（）；
bufferIntent=新意图（广播缓冲区）；
//---设置seekbar广播的意图---
seekIntent=新意图（广播行动）；
mediaPlayer.setOnCompletionListener（此）；
mediaPlayer.setOneErrorListener（此）；
mediaPlayer.setOnPreparedListener（这个）；
mediaPlayer.setOnBufferingUpdateListener（这个）；
setOnSeekCompleteListener（这个）；
mediaPlayer.setOnInfo侦听器（此）；
mediaPlayer.reset（）；
//注册耳机接收器
注册接收装置（头接收装置，新的意向过滤器(
意图。行动（耳机（插头））；
}
@凌驾
公共int onStartCommand（Intent Intent、int标志、int startId）{
//获得歌曲和位置
歌曲=新的ArrayList（）；
歌曲=（ArrayList）intent.getSerializableExtra（“歌曲”）；
Log.v（“-”，songs.size（）+“size！#$”；
位置=intent.getIntExtra（“位置”，-1）；
//---为seekbar更改设置接收器---
registerReceiver（广播接收器，新意向过滤器(
播放机（SEEKBAR））；
//在播放过程中管理来电。在来电时暂停mp，
//挂断时继续。
// -----------------------------------------------------------------------------------
//找电话经理
Log.v（标签“启动电话”）；
telephonyManager=（telephonyManager）getSystemService（Context.TELEPHONY_服务）；
Log.v（标记“启动侦听器”）；
phoneStateListener=新的phoneStateListener（）{
@凌驾
public void onCallStateChanged（int状态，字符串incomingNumber）{
//String stateString=“不适用”；
Log.v（标签，“启动CallStateChange”）；
开关（状态）{
case TelephonyManager.CALL_STATE_OFFHOOK：
case TelephonyManager.CALL_STATE_响铃：
如果（mediaPlayer！=null）{
pauseMedia（）；
isPausedCall=true；
}
打破
case TelephonyManager.CALL_STATE_IDLE:
//手机空闲，开始播放。
如果（mediaPlayer！=null）{
如果（ISPausedCall）{
isPausedCall=false；
playMedia（）；
}
}
打破
}
}
};
//向电话管理器注册侦听器
telephonyManager.listen（phoneStateListener，
PhoneStateListener.LISTEN\u CALL\u STATE）；
//插入通知开始
初始化通知（）；
mediaPlayer.reset（）；
//使用strAudioLink值设置MediaPlayer数据源
如果（！mediaPlayer.isPlaying（））{
试一试{
//向活动发送消息以显示进度对话
sendBufferingBroadcast（）；
setDataSource（songs.get（position.getLink（））；
;
//准备mediaplayer
mediaPlayer.prepare（）；
}捕获（IllegalArgumentException e）{
e、 printStackTrace（）；
}捕获（非法状态）{
e、 printStackTrace（）；
}捕获（IOE异常）{
}
}
//---设置seekbar处理程序---
setupHandler（）；
返回开始时间；
}
//---将seekbar信息发送到活动----
私有void setupHandler（）{
handler.removeCallbacks（sendUpdatesToUI）；
handler.postDelayed（sendUpdateStoreUI，300）；//1秒
}
private Runnable sendUpdatesToUI=new Runnable（）{
公开募捐{
////Log.d（标记“entered sendUpdatesToUI”）；
LogMediaPosition（）；
handler.postDelayed（这个，1000）；//2秒
}
};
私人空间