com.dzt.musicplay.player.AudioService.java Source code

Java tutorial

Introduction

Here is the source code for com.dzt.musicplay.player.AudioService.java

Source

/*****************************************************************************
 * AudioService.java
 *****************************************************************************
 * Copyright  2011-2013 VLC authors and VideoLAN
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
 *****************************************************************************/

package com.dzt.musicplay.player;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Random;
import java.util.Stack;

import org.videolan.libvlc.EventHandler;
import org.videolan.libvlc.LibVLC;
import org.videolan.libvlc.LibVlcException;
import org.videolan.libvlc.LibVlcUtil;
import org.videolan.libvlc.Media;
import org.videolan.libvlc.MediaList;
import org.videolan.vlc.MediaDatabase;
import org.videolan.vlc.audio.RepeatType;
import org.videolan.vlc.interfaces.IAudioService;
import org.videolan.vlc.interfaces.IAudioServiceCallback;
import org.videolan.vlc.util.AndroidDevices;
import org.videolan.vlc.util.AudioUtil;
import org.videolan.vlc.util.Constant;
import org.videolan.vlc.util.VLCInstance;
import org.videolan.vlc.util.WeakHandler;

import android.annotation.TargetApi;
import android.app.Notification;
import android.app.PendingIntent;
import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.graphics.Bitmap;
import android.media.AudioManager;
import android.media.AudioManager.OnAudioFocusChangeListener;
import android.media.MediaMetadataRetriever;
import android.media.RemoteControlClient;
import android.media.RemoteControlClient.MetadataEditor;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.os.PowerManager;
import android.os.Process;
import android.os.RemoteException;
import android.preference.PreferenceManager;
import android.support.v4.app.NotificationCompat;
import android.telephony.TelephonyManager;
import android.util.Log;
import android.widget.RemoteViews;
import android.widget.Toast;

import com.dzt.musicplay.MusicPlayActivity;
import com.dzt.musicplay.constant.GlobalConstants;
import com.dzt.vlcaudiolib.R;

import org.videolan.vlc.audio.MusicInfo;

public class AudioService extends Service {

    private static final String TAG = "VLC/AudioService";

    private static final int SHOW_PROGRESS = 0;
    private static final int SHOW_TOAST = 1;
    public static final String START_FROM_NOTIFICATION = "from_notification";
    public static final String ACTION_REMOTE_GENERIC = "org.videolan.vlc.remote.";
    public static final String ACTION_REMOTE_BACKWARD = "org.videolan.vlc.remote.Backward";
    public static final String ACTION_REMOTE_PLAY = "org.videolan.vlc.remote.Play";
    public static final String ACTION_REMOTE_PLAYPAUSE = "org.videolan.vlc.remote.PlayPause";
    public static final String ACTION_REMOTE_PAUSE = "org.videolan.vlc.remote.Pause";
    public static final String ACTION_REMOTE_STOP = "org.videolan.vlc.remote.Stop";
    public static final String ACTION_REMOTE_FORWARD = "org.videolan.vlc.remote.Forward";
    public static final String ACTION_REMOTE_LAST_PLAYLIST = "org.videolan.vlc.remote.LastPlaylist";
    public static final String ACTION_WIDGET_INIT = "org.videolan.vlc.widget.INIT";
    public static final String ACTION_WIDGET_UPDATE = "org.videolan.vlc.widget.UPDATE";
    public static final String ACTION_WIDGET_UPDATE_COVER = "org.videolan.vlc.widget.UPDATE_COVER";
    public static final String ACTION_WIDGET_UPDATE_POSITION = "org.videolan.vlc.widget.UPDATE_POSITION";

    public static final String WIDGET_PACKAGE = "org.videolan.vlc";
    public static final String WIDGET_CLASS = "org.videolan.vlc.widget.VLCAppWidgetProvider";

    public final static String SLEEP_INTENT = "org.videolan.vlc.SleepIntent";

    public static final int CURRENT_ITEM = 1;
    public static final int PREVIOUS_ITEM = 2;
    public static final int NEXT_ITEM = 3;

    private LibVLC mLibVLC;
    private HashMap<IAudioServiceCallback, Integer> mCallback;
    private EventHandler mEventHandler;
    private OnAudioFocusChangeListener audioFocusListener;
    private boolean mDetectHeadset = true;
    private PowerManager.WakeLock mWakeLock;

    // Index management
    /**
     * Stack of previously played indexes, used in shuffle mode
     */
    private Stack<Integer> mPrevious;
    private int mCurrentIndex; // Set to -1 if no media is currently loaded
    private int mPrevIndex; // Set to -1 if no previous media
    private int mNextIndex; // Set to -1 if no next media

    // Playback management
    private boolean mShuffling = false;
    private RepeatType mRepeating = RepeatType.None;

    // RemoteControlClient-related
    /**
     * RemoteControlClient is for lock screen playback control.
     */
    private RemoteControlClient mRemoteControlClient = null;
    private RemoteControlClientReceiver mRemoteControlClientReceiver = null;
    /**
     * Last widget position update timestamp
     */
    private long mWidgetPositionTimestamp = Calendar.getInstance().getTimeInMillis();
    private ComponentName mRemoteControlClientReceiverComponent;

    // add by dzt 2014.08.09
    private ArrayList<Media> mMediaList;
    private Media mCurrentMedia;
    private boolean mLibVLCPlaylistActive = false;

    @Override
    public void onCreate() {
        super.onCreate();
        GlobalConstants.print_i(getClass(), "onCreate");
        // Get libVLC instance
        try {
            mLibVLC = VLCInstance.getLibVlcInstance(getApplicationContext());
        } catch (LibVlcException e) {
            e.printStackTrace();
        }
        StartLoadFileThread();

        mCallback = new HashMap<IAudioServiceCallback, Integer>();
        mMediaList = new ArrayList<Media>();
        mCurrentIndex = -1;
        mPrevIndex = -1;
        mNextIndex = -1;
        mPrevious = new Stack<Integer>();
        mEventHandler = EventHandler.getInstance();
        mRemoteControlClientReceiverComponent = new ComponentName(getPackageName(),
                RemoteControlClientReceiver.class.getName());

        // Make sure the audio player will acquire a wake-lock while playing. If
        // we don't do
        // that, the CPU might go to sleep while the song is playing, causing
        // playback to stop.
        PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
        mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);

        IntentFilter filter = new IntentFilter();
        filter.setPriority(Integer.MAX_VALUE);
        filter.addAction(ACTION_REMOTE_BACKWARD);
        filter.addAction(ACTION_REMOTE_PLAYPAUSE);
        filter.addAction(ACTION_REMOTE_PLAY);
        filter.addAction(ACTION_REMOTE_PAUSE);
        filter.addAction(ACTION_REMOTE_STOP);
        filter.addAction(ACTION_REMOTE_FORWARD);
        filter.addAction(ACTION_REMOTE_LAST_PLAYLIST);
        filter.addAction(ACTION_WIDGET_INIT);
        filter.addAction(Intent.ACTION_HEADSET_PLUG);
        filter.addAction(AudioManager.ACTION_AUDIO_BECOMING_NOISY);
        filter.addAction(SLEEP_INTENT);
        registerReceiver(serviceReceiver, filter);

        final SharedPreferences pref = PreferenceManager.getDefaultSharedPreferences(this);
        boolean stealRemoteControl = pref.getBoolean("enable_steal_remote_control", false);

        if (!LibVlcUtil.isFroyoOrLater() || stealRemoteControl) {
            /* Backward compatibility for API 7 */
            filter = new IntentFilter();
            if (stealRemoteControl)
                filter.setPriority(Integer.MAX_VALUE);
            filter.addAction(Intent.ACTION_MEDIA_BUTTON);
            mRemoteControlClientReceiver = new RemoteControlClientReceiver();
            registerReceiver(mRemoteControlClientReceiver, filter);
        }
        GlobalConstants.print_i(getClass(), "onCreate----end");
    }

    /**
     * Set up the remote control and tell the system we want to be the default
     * receiver for the MEDIA buttons
     * 
     * @see http 
     *      ://android-developers.blogspot.fr/2010/06/allowing-applications-to
     *      -play-nicer.html
     */
    @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
    public void setUpRemoteControlClient() {
        Context context = getApplicationContext();
        AudioManager audioManager = (AudioManager) context.getSystemService(AUDIO_SERVICE);

        if (LibVlcUtil.isICSOrLater()) {
            audioManager.registerMediaButtonEventReceiver(mRemoteControlClientReceiverComponent);

            if (mRemoteControlClient == null) {
                Intent mediaButtonIntent = new Intent(Intent.ACTION_MEDIA_BUTTON);
                mediaButtonIntent.setComponent(mRemoteControlClientReceiverComponent);
                PendingIntent mediaPendingIntent = PendingIntent.getBroadcast(context, 0, mediaButtonIntent, 0);

                // create and register the remote control client
                mRemoteControlClient = new RemoteControlClient(mediaPendingIntent);
                audioManager.registerRemoteControlClient(mRemoteControlClient);
            }

            mRemoteControlClient.setTransportControlFlags(RemoteControlClient.FLAG_KEY_MEDIA_PLAY
                    | RemoteControlClient.FLAG_KEY_MEDIA_PAUSE | RemoteControlClient.FLAG_KEY_MEDIA_PREVIOUS
                    | RemoteControlClient.FLAG_KEY_MEDIA_NEXT | RemoteControlClient.FLAG_KEY_MEDIA_STOP);
        } else if (LibVlcUtil.isFroyoOrLater()) {
            audioManager.registerMediaButtonEventReceiver(mRemoteControlClientReceiverComponent);
        }
    }

    /**
     * A function to control the Remote Control Client. It is needed for
     * compatibility with devices below Ice Cream Sandwich (4.0).
     * 
     * @param p
     *            Playback state
     */
    @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
    private void setRemoteControlClientPlaybackState(int state) {
        if (!LibVlcUtil.isICSOrLater() || mRemoteControlClient == null)
            return;

        switch (state) {
        case EventHandler.MediaPlayerPlaying:
            mRemoteControlClient.setPlaybackState(RemoteControlClient.PLAYSTATE_PLAYING);
            break;
        case EventHandler.MediaPlayerPaused:
            mRemoteControlClient.setPlaybackState(RemoteControlClient.PLAYSTATE_PAUSED);
            break;
        case EventHandler.MediaPlayerStopped:
            mRemoteControlClient.setPlaybackState(RemoteControlClient.PLAYSTATE_STOPPED);
            break;
        }
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        updateWidget(this);
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        System.out.println("AudioService------------------>onDestroy");
        stop();
        if (mWakeLock.isHeld())
            mWakeLock.release();
        unregisterReceiver(serviceReceiver);
        if (mRemoteControlClientReceiver != null) {
            unregisterReceiver(mRemoteControlClientReceiver);
            mRemoteControlClientReceiver = null;
        }
    }

    @Override
    public IBinder onBind(Intent intent) {
        return mInterface;
    }

    @TargetApi(Build.VERSION_CODES.FROYO)
    private void changeAudioFocus(boolean gain) {
        if (!LibVlcUtil.isFroyoOrLater()) // NOP if not supported
            return;

        if (audioFocusListener == null) {
            audioFocusListener = new OnAudioFocusChangeListener() {
                @Override
                public void onAudioFocusChange(int focusChange) {
                    LibVLC libVLC = LibVLC.getExistingInstance();
                    switch (focusChange) {
                    case AudioManager.AUDIOFOCUS_LOSS:
                        if (libVLC.isPlaying())
                            libVLC.pause();
                        break;
                    case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT:
                    case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK:
                        /*
                         * Lower the volume to 36% to "duck" when an alert or
                         * something needs to be played.
                         */
                        libVLC.setVolume(36);
                        break;
                    case AudioManager.AUDIOFOCUS_GAIN:
                    case AudioManager.AUDIOFOCUS_GAIN_TRANSIENT:
                    case AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK:
                        libVLC.setVolume(100);
                        break;
                    }
                }
            };
        }

        AudioManager am = (AudioManager) getSystemService(AUDIO_SERVICE);
        if (gain)
            am.requestAudioFocus(audioFocusListener, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN);
        else
            am.abandonAudioFocus(audioFocusListener);

    }

    private final BroadcastReceiver serviceReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            int state = intent.getIntExtra("state", 0);
            if (mLibVLC == null) {
                Log.w(TAG, "Intent received, but VLC is not loaded, skipping.");
                return;
            }

            // skip all headsets events if there is a call
            TelephonyManager telManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
            if (telManager != null && telManager.getCallState() != TelephonyManager.CALL_STATE_IDLE)
                return;

            /*
             * Launch the activity if needed
             */
            if (action.startsWith(ACTION_REMOTE_GENERIC) && !mLibVLC.isPlaying() && !hasCurrentMedia()) {
                Constant.print_i("AudioService--------serviceReceiver mLibVLC is playing");
                // Intent iVlc = new Intent(context, MainActivity.class);
                // iVlc.putExtra(START_FROM_NOTIFICATION, true);
                // iVlc.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
                // | Intent.FLAG_ACTIVITY_SINGLE_TOP);
                // context.startActivity(iVlc);
            }

            /*
             * Remote / headset control events
             */
            if (action.equalsIgnoreCase(ACTION_REMOTE_PLAYPAUSE)) {
                if (mLibVLC.isPlaying() && hasCurrentMedia())
                    pause();
                else if (!mLibVLC.isPlaying() && hasCurrentMedia())
                    play();
            } else if (action.equalsIgnoreCase(ACTION_REMOTE_PLAY)) {
                if (!mLibVLC.isPlaying() && hasCurrentMedia())
                    play();
            } else if (action.equalsIgnoreCase(ACTION_REMOTE_PAUSE)) {
                if (mLibVLC.isPlaying() && hasCurrentMedia())
                    pause();
            } else if (action.equalsIgnoreCase(ACTION_REMOTE_BACKWARD)) {
                previous();
            } else if (action.equalsIgnoreCase(ACTION_REMOTE_STOP)) {
                stop();
            } else if (action.equalsIgnoreCase(ACTION_REMOTE_FORWARD)) {
                next();
            } else if (action.equalsIgnoreCase(ACTION_REMOTE_LAST_PLAYLIST)) {
                loadLastPlaylist();
            } else if (action.equalsIgnoreCase(ACTION_WIDGET_INIT)) {
                updateWidget(context);
            }

            /*
             * headset plug events
             */
            if (mDetectHeadset) {
                if (action.equalsIgnoreCase(AudioManager.ACTION_AUDIO_BECOMING_NOISY)) {
                    Log.i(TAG, "Headset Removed.");
                    if (mLibVLC.isPlaying() && hasCurrentMedia())
                        pause();
                } else if (action.equalsIgnoreCase(Intent.ACTION_HEADSET_PLUG) && state != 0) {
                    Log.i(TAG, "Headset Inserted.");
                    if (!mLibVLC.isPlaying() && hasCurrentMedia())
                        play();
                }
            }

            /*
             * Sleep
             */
            if (action.equalsIgnoreCase(SLEEP_INTENT)) {
                stop();
            }
        }
    };

    /**
     * Handle libvlc asynchronous events
     */
    private final Handler mVlcEventHandler = new AudioServiceEventHandler(this);

    private static class AudioServiceEventHandler extends WeakHandler<AudioService> {
        public AudioServiceEventHandler(AudioService fragment) {
            super(fragment);
        }

        @Override
        public void handleMessage(Message msg) {
            AudioService service = getOwner();
            if (service == null)
                return;

            switch (msg.getData().getInt("event")) {
            case EventHandler.MediaParsedChanged:
                Log.i(TAG, "MediaParsedChanged");
                break;
            case EventHandler.MediaPlayerPlaying:
                Log.i(TAG, "MediaPlayerPlaying");
                service.executeUpdate();
                service.executeUpdateProgress();

                String location = service.mLibVLC.getMediaList().getMRL(service.mCurrentIndex);
                long length = service.mLibVLC.getLength();
                MediaDatabase dbManager = MediaDatabase.getInstance(service.getApplicationContext());
                Media m = dbManager.getMedia(location);
                /**
                 * 1) There is a media to update 2) It has a length of 0
                 * (dynamic track loading - most notably the OGG container) 3)
                 * We were able to get a length even after parsing (don't want
                 * to replace a 0 with a 0)
                 */
                if (m != null && m.getLength() == 0 && length > 0) {
                    Log.d(TAG, "Updating audio file length");
                    dbManager.updateMedia(location, MediaDatabase.mediaColumn.MEDIA_LENGTH, length);
                }

                service.changeAudioFocus(true);
                service.setRemoteControlClientPlaybackState(EventHandler.MediaPlayerPlaying);
                service.showNotification();
                if (!service.mWakeLock.isHeld())
                    service.mWakeLock.acquire();
                break;
            case EventHandler.MediaPlayerPaused:
                Log.i(TAG, "MediaPlayerPaused");
                service.executeUpdate();
                service.executeUpdateProgress();
                service.showNotification();
                service.setRemoteControlClientPlaybackState(EventHandler.MediaPlayerPaused);
                if (service.mWakeLock.isHeld())
                    service.mWakeLock.release();
                break;
            case EventHandler.MediaPlayerStopped:
                Log.i(TAG, "MediaPlayerStopped");
                service.executeUpdate();
                service.executeUpdateProgress();
                service.setRemoteControlClientPlaybackState(EventHandler.MediaPlayerStopped);
                if (service.mWakeLock.isHeld())
                    service.mWakeLock.release();
                break;
            case EventHandler.MediaPlayerEndReached:
                Log.i(TAG, "MediaPlayerEndReached");
                service.executeUpdate();
                service.executeUpdateProgress();
                service.determinePrevAndNextIndices(true);
                service.next();
                if (service.mWakeLock.isHeld())
                    service.mWakeLock.release();
                break;
            case EventHandler.MediaPlayerVout:
                if (msg.getData().getInt("data") > 0) {
                    service.handleVout();
                }
                break;
            case EventHandler.MediaPlayerPositionChanged:
                float pos = msg.getData().getFloat("data");
                service.updateWidgetPosition(service, pos);
                break;
            case EventHandler.MediaPlayerEncounteredError:
                service.showToast(service.getString(R.string.invalid_location,
                        service.mLibVLC.getMediaList().getMRL(service.mCurrentIndex)), Toast.LENGTH_SHORT);
                service.executeUpdate();
                service.executeUpdateProgress();
                service.next();
                if (service.mWakeLock.isHeld())
                    service.mWakeLock.release();
                break;
            default:
                Log.e(TAG, "Event not handled");
                break;
            }
        }
    };

    private final Handler mListEventHandler = new MediaListEventHandler(this);

    private static class MediaListEventHandler extends WeakHandler<AudioService> {
        // Don't clobber mCurrentIndex when MediaList is expanding itself.
        boolean expanding = false;

        public MediaListEventHandler(AudioService audioService) {
            super(audioService);
        }

        @Override
        public void handleMessage(Message msg) {
            AudioService service = getOwner();
            if (service == null)
                return;

            int index;
            switch (msg.getData().getInt("event")) {
            case EventHandler.CustomMediaListItemAdded:
                Log.i(TAG, "CustomMediaListItemAdded");
                index = msg.getData().getInt("item_index");
                if (service.mCurrentIndex >= index && !expanding)
                    service.mCurrentIndex++;

                service.determinePrevAndNextIndices();
                service.executeUpdate();
                break;
            case EventHandler.CustomMediaListItemDeleted:
                Log.i(TAG, "CustomMediaListItemDeleted");
                index = msg.getData().getInt("item_index");
                if (service.mCurrentIndex == index && !expanding) {
                    // The current item has been deleted
                    System.out.println("AudioService------------------>handleMessage--CustomMediaListItemDeleted");
                    service.mCurrentIndex--;
                    service.determinePrevAndNextIndices();
                    if (service.mNextIndex != -1)
                        service.next();
                    else if (service.mCurrentIndex != -1)
                        service.mLibVLC.playIndex(service.mCurrentIndex);
                    else
                        service.stop();
                    break;
                }

                if (service.mCurrentIndex > index && !expanding)
                    service.mCurrentIndex--;
                service.determinePrevAndNextIndices();
                service.executeUpdate();
                break;
            case EventHandler.CustomMediaListItemMoved:
                Log.i(TAG, "CustomMediaListItemMoved");
                int positionStart = msg.getData().getInt("index_before");
                int positionEnd = msg.getData().getInt("index_after");
                if (service.mCurrentIndex == positionStart) {
                    service.mCurrentIndex = positionEnd;
                    if (positionEnd > positionStart)
                        service.mCurrentIndex--;
                } else if (positionStart > service.mCurrentIndex && positionEnd <= service.mCurrentIndex)
                    service.mCurrentIndex++;
                else if (positionStart < service.mCurrentIndex && positionEnd > service.mCurrentIndex)
                    service.mCurrentIndex--;

                // If we are in random mode, we completely reset the stored
                // previous track
                // as their indices changed.
                service.mPrevious.clear();

                service.determinePrevAndNextIndices();
                service.executeUpdate();
                break;
            case EventHandler.CustomMediaListExpanding:
                expanding = true;
                break;
            case EventHandler.CustomMediaListExpandingEnd:
                expanding = false;
                break;
            }
        }
    };

    private void handleVout() {
        if (!hasCurrentMedia())
            return;
        Log.i(TAG, "Obtained video track");
        String title = getCurrentMedia().getTitle();
        String MRL = mLibVLC.getMediaList().getMRL(mCurrentIndex);
        int index = mCurrentIndex;
        mCurrentIndex = -1;
        mEventHandler.removeHandler(mVlcEventHandler);
        // Preserve playback when switching to video
        hideNotification(false);

        // Switch to the video player & don't lose the currently playing stream
        // Edited by dzt 2014.08.08
        // VideoPlayerActivity.start(VLCApplication.getAppContext(), MRL, title,
        // index, true);
    }

    private void executeUpdate() {
        executeUpdate(true);
    }

    private void executeUpdate(Boolean updateWidget) {
        for (IAudioServiceCallback callback : mCallback.keySet()) {
            try {
                callback.update();
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        if (updateWidget)
            updateWidget(this);
    }

    private void executeUpdateProgress() {
        for (IAudioServiceCallback callback : mCallback.keySet()) {
            try {
                callback.updateProgress();
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * Return the current media.
     * 
     * @return The current media or null if there is not any.
     */
    private Media getCurrentMedia() {
        return mLibVLC.getMediaList().getMedia(mCurrentIndex);
    }

    /**
     * Alias for mCurrentIndex >= 0
     * 
     * @return True if a media is currently loaded, false otherwise
     */
    private boolean hasCurrentMedia() {
        return mCurrentIndex >= 0 && mCurrentIndex < mLibVLC.getMediaList().size();
    }

    private final Handler mHandler = new AudioServiceHandler(this);

    private static class AudioServiceHandler extends WeakHandler<AudioService> {
        public AudioServiceHandler(AudioService fragment) {
            super(fragment);
        }

        @Override
        public void handleMessage(Message msg) {
            AudioService service = getOwner();
            if (service == null)
                return;

            switch (msg.what) {
            case SHOW_PROGRESS:
                if (service.mCallback.size() > 0) {
                    removeMessages(SHOW_PROGRESS);
                    service.executeUpdateProgress();
                    sendEmptyMessageDelayed(SHOW_PROGRESS, 1000);
                }
                break;
            case SHOW_TOAST:
                final Bundle bundle = msg.getData();
                final String text = bundle.getString("text");
                final int duration = bundle.getInt("duration");
                Toast.makeText(service.getApplicationContext(), text, duration).show();
                break;
            }
        }
    };

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
    private void showNotification() {
        Constant.print_i("AudioService----------->showNotification");
        try {
            Media media = getCurrentMedia();
            if (media == null)
                return;
            Bitmap cover = AudioUtil.getCover(this, media, 64);
            String title = media.getTitle();
            String artist = media.getArtist();
            String album = media.getAlbum();
            Notification notification;

            // add notification to status bar
            NotificationCompat.Builder builder = new NotificationCompat.Builder(this)
                    .setSmallIcon(R.drawable.icon_music).setTicker(title + " - " + artist).setAutoCancel(false)
                    .setOngoing(true);

            //Activity
            Intent notificationIntent = new Intent(this, MusicPlayActivity.class);
            notificationIntent.setAction(MusicPlayActivity.ACTION_SHOW_PLAYER);
            notificationIntent.addCategory(Intent.CATEGORY_LAUNCHER);
            notificationIntent.putExtra(START_FROM_NOTIFICATION, true);
            PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent,
                    PendingIntent.FLAG_UPDATE_CURRENT);

            if (LibVlcUtil.isJellyBeanOrLater()) {
                Intent iBackward = new Intent(ACTION_REMOTE_BACKWARD);
                Intent iPlay = new Intent(ACTION_REMOTE_PLAYPAUSE);
                Intent iForward = new Intent(ACTION_REMOTE_FORWARD);
                Intent iStop = new Intent(ACTION_REMOTE_STOP);
                PendingIntent piBackward = PendingIntent.getBroadcast(this, 0, iBackward,
                        PendingIntent.FLAG_UPDATE_CURRENT);
                PendingIntent piPlay = PendingIntent.getBroadcast(this, 0, iPlay,
                        PendingIntent.FLAG_UPDATE_CURRENT);
                PendingIntent piForward = PendingIntent.getBroadcast(this, 0, iForward,
                        PendingIntent.FLAG_UPDATE_CURRENT);
                PendingIntent piStop = PendingIntent.getBroadcast(this, 0, iStop,
                        PendingIntent.FLAG_UPDATE_CURRENT);

                RemoteViews view = new RemoteViews(getPackageName(), R.layout.notification);
                if (cover != null)
                    view.setImageViewBitmap(R.id.cover, cover);
                view.setTextViewText(R.id.songName, title);
                view.setTextViewText(R.id.artist, artist);
                view.setImageViewResource(R.id.play_pause,
                        mLibVLC.isPlaying() ? R.drawable.ic_pause_w : R.drawable.ic_play_w);
                view.setOnClickPendingIntent(R.id.play_pause, piPlay);
                view.setOnClickPendingIntent(R.id.forward, piForward);
                view.setOnClickPendingIntent(R.id.stop, piStop);
                view.setOnClickPendingIntent(R.id.content, pendingIntent);

                RemoteViews view_expanded = new RemoteViews(getPackageName(), R.layout.notification_expanded);
                if (cover != null)
                    view_expanded.setImageViewBitmap(R.id.cover, cover);
                view_expanded.setTextViewText(R.id.songName, title);
                view_expanded.setTextViewText(R.id.artist, artist);
                view_expanded.setTextViewText(R.id.album, album);
                view_expanded.setImageViewResource(R.id.play_pause,
                        mLibVLC.isPlaying() ? R.drawable.ic_pause_w : R.drawable.ic_play_w);
                view_expanded.setOnClickPendingIntent(R.id.backward, piBackward);
                view_expanded.setOnClickPendingIntent(R.id.play_pause, piPlay);
                view_expanded.setOnClickPendingIntent(R.id.forward, piForward);
                view_expanded.setOnClickPendingIntent(R.id.stop, piStop);
                view_expanded.setOnClickPendingIntent(R.id.content, pendingIntent);

                notification = builder.build();
                notification.contentView = view;
                notification.bigContentView = view_expanded;
            } else {
                builder.setLargeIcon(cover).setContentTitle(title)
                        .setContentText(LibVlcUtil.isJellyBeanOrLater() ? artist : media.getSubtitle())
                        .setContentInfo(album).setContentIntent(pendingIntent);
                notification = builder.build();
            }

            startService(new Intent(this, AudioService.class));
            startForeground(3, notification);
        } catch (NoSuchMethodError e) {
            // Compat library is wrong on 3.2
            // http://code.google.com/p/android/issues/detail?id=36359
            // http://code.google.com/p/android/issues/detail?id=36502
        }
        Constant.print_i("AudioService----------->showNotification----end");
    }

    private void hideNotification() {
        hideNotification(true);
    }

    /**
     * Hides the VLC notification and stops the service.
     * 
     * @param stopPlayback
     *            True to also stop playback at the same time. Set to false to
     *            preserve playback (e.g. for vout events)
     */
    private void hideNotification(boolean stopPlayback) {
        stopForeground(true);
        if (stopPlayback)
            stopSelf();
    }

    private void pause() {
        System.out.println("AudioService------------------>pause");
        setUpRemoteControlClient();
        mHandler.removeMessages(SHOW_PROGRESS);
        // hideNotification(); <-- see event handler
        // mLibVLC.pause();
        if (mLibVLC.isPlaying())
            mLibVLC.customizePause();
    }

    private void play() {
        System.out.println("AudioService------------------>play");
        if (hasCurrentMedia()) {
            setUpRemoteControlClient();
            // mLibVLC.play();
            mLibVLC.customizePlay();
            mHandler.sendEmptyMessage(SHOW_PROGRESS);
            showNotification();
            updateWidget(this);
        }
    }

    private void stop() {
        System.out.println("AudioService------------------>stop");
        mLibVLC.stop();
        mEventHandler.removeHandler(mVlcEventHandler);
        mLibVLC.getMediaList().getEventHandler().removeHandler(mListEventHandler);
        setRemoteControlClientPlaybackState(EventHandler.MediaPlayerStopped);
        mCurrentIndex = -1;
        mPrevious.clear();
        mHandler.removeMessages(SHOW_PROGRESS);
        hideNotification();
        executeUpdate();
        executeUpdateProgress();
        changeAudioFocus(false);
    }

    private void determinePrevAndNextIndices() {
        determinePrevAndNextIndices(false);
    }

    private void determinePrevAndNextIndices(boolean expand) {
        mNextIndex = expand ? mLibVLC.expand() : -1;
        mPrevIndex = -1;

        if (mNextIndex == -1) {
            // No subitems; play the next item.
            int size = mLibVLC.getMediaList().size();

            // Repeating once doesn't change the index
            if (mRepeating == RepeatType.Once) {
                mPrevIndex = mNextIndex = mCurrentIndex;
            } else {

                if (mShuffling) {
                    if (mPrevious.size() > 0)
                        mPrevIndex = mPrevious.peek();
                    // If we've played all songs already in shuffle, then either
                    // reshuffle or stop (depending on RepeatType).
                    if (mPrevious.size() + 1 == size) {
                        if (mRepeating == RepeatType.None) {
                            mNextIndex = -1;
                            return;
                        } else {
                            mPrevious.clear();
                        }
                    }
                    // Find a new index not in mPrevious.
                    do {
                        mNextIndex = new Random().nextInt(size);
                    } while (mNextIndex == mCurrentIndex || mPrevious.contains(mNextIndex));

                } else {
                    // normal playback
                    if (mCurrentIndex > 0)
                        mPrevIndex = mCurrentIndex - 1;
                    if (mCurrentIndex + 1 < size)
                        mNextIndex = mCurrentIndex + 1;
                    else {
                        if (mRepeating == RepeatType.None) {
                            mNextIndex = -1;
                        } else {
                            mNextIndex = 0;
                        }
                    }
                }
            }
        }
    }

    private void next() {
        mPrevious.push(mCurrentIndex);
        mCurrentIndex = mNextIndex;

        int size = mLibVLC.getMediaList().size();
        if (size == 0 || mCurrentIndex < 0 || mCurrentIndex >= size) {
            Log.w(TAG, "Warning: invalid next index, aborted !");
            stop();
            return;
        }

        mLibVLC.playIndex(mCurrentIndex);

        mHandler.sendEmptyMessage(SHOW_PROGRESS);
        setUpRemoteControlClient();
        showNotification();
        updateWidget(this);
        updateRemoteControlClientMetadata();
        saveCurrentMedia();

        determinePrevAndNextIndices();
    }

    @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
    private void updateRemoteControlClientMetadata() {
        if (!LibVlcUtil.isICSOrLater()) // NOP check
            return;

        Media media = getCurrentMedia();
        if (mRemoteControlClient != null && media != null) {
            MetadataEditor editor = mRemoteControlClient.editMetadata(true);
            editor.putString(MediaMetadataRetriever.METADATA_KEY_ALBUM, media.getAlbum());
            editor.putString(MediaMetadataRetriever.METADATA_KEY_ARTIST, media.getArtist());
            editor.putString(MediaMetadataRetriever.METADATA_KEY_GENRE, media.getGenre());
            editor.putString(MediaMetadataRetriever.METADATA_KEY_TITLE, media.getTitle());
            editor.putLong(MediaMetadataRetriever.METADATA_KEY_DURATION, media.getLength());
            // Copy the cover bitmap because the RemonteControlClient can
            // recycle its artwork bitmap.
            Bitmap cover = getCover();
            editor.putBitmap(MetadataEditor.BITMAP_KEY_ARTWORK,
                    ((cover != null) ? cover.copy(cover.getConfig(), false) : null));
            editor.apply();
        }
    }

    private void previous() {
        mCurrentIndex = mPrevIndex;
        if (mPrevious.size() > 0)
            mPrevious.pop();

        int size = mLibVLC.getMediaList().size();
        if (size == 0 || mPrevIndex < 0 || mCurrentIndex >= size) {
            Log.w(TAG, "Warning: invalid previous index, aborted !");
            stop();
            return;
        }

        mLibVLC.playIndex(mCurrentIndex);
        mHandler.sendEmptyMessage(SHOW_PROGRESS);
        setUpRemoteControlClient();
        showNotification();
        updateWidget(this);
        updateRemoteControlClientMetadata();
        saveCurrentMedia();

        determinePrevAndNextIndices();
    }

    private void shuffle() {
        if (mShuffling)
            mPrevious.clear();
        mShuffling = !mShuffling;
        saveCurrentMedia();
        determinePrevAndNextIndices();
    }

    private void setRepeatType(int t) {
        mRepeating = RepeatType.values()[t];
        determinePrevAndNextIndices();
    }

    private Bitmap getCover() {
        Media media = getCurrentMedia();
        return media != null ? AudioUtil.getCover(this, media, 512) : null;
    }

    private final IAudioService.Stub mInterface = new IAudioService.Stub() {

        @Override
        public void pause() throws RemoteException {
            AudioService.this.pause();
        }

        @Override
        public void play() throws RemoteException {
            AudioService.this.play();
        }

        @Override
        public void stop() throws RemoteException {
            AudioService.this.stop();
        }

        @Override
        public boolean isPlaying() throws RemoteException {
            return mLibVLC.isPlaying();
        }

        @Override
        public boolean isShuffling() {
            return mShuffling;
        }

        @Override
        public int getRepeatType() {
            return mRepeating.ordinal();
        }

        @Override
        public boolean hasMedia() throws RemoteException {
            return hasCurrentMedia();
        }

        @Override
        public String getAlbum() throws RemoteException {
            if (hasCurrentMedia())
                return getCurrentMedia().getAlbum();
            else
                return null;
        }

        @Override
        public String getArtist() throws RemoteException {
            if (hasCurrentMedia())
                return getCurrentMedia().getArtist();
            else
                return null;
        }

        @Override
        public String getArtistPrev() throws RemoteException {
            if (mPrevIndex != -1)
                return mLibVLC.getMediaList().getMedia(mPrevIndex).getArtist();
            else
                return null;
        }

        @Override
        public String getArtistNext() throws RemoteException {
            if (mNextIndex != -1)
                return mLibVLC.getMediaList().getMedia(mNextIndex).getArtist();
            else
                return null;
        }

        @Override
        public String getTitle() throws RemoteException {
            if (hasCurrentMedia())
                return getCurrentMedia().getTitle();
            else
                return null;
        }

        @Override
        public String getTitlePrev() throws RemoteException {
            if (mPrevIndex != -1)
                return mLibVLC.getMediaList().getMedia(mPrevIndex).getTitle();
            else
                return null;
        }

        @Override
        public String getTitleNext() throws RemoteException {
            if (mNextIndex != -1)
                return mLibVLC.getMediaList().getMedia(mNextIndex).getTitle();
            else
                return null;
        }

        @Override
        public Bitmap getCover() {
            if (hasCurrentMedia()) {
                return AudioService.this.getCover();
            }
            return null;
        }

        @Override
        public Bitmap getCoverPrev() throws RemoteException {
            if (mPrevIndex != -1)
                return AudioUtil.getCover(AudioService.this, mLibVLC.getMediaList().getMedia(mPrevIndex), 64);
            else
                return null;
        }

        @Override
        public Bitmap getCoverNext() throws RemoteException {
            if (mNextIndex != -1)
                return AudioUtil.getCover(AudioService.this, mLibVLC.getMediaList().getMedia(mNextIndex), 64);
            else
                return null;
        }

        @Override
        public synchronized void addAudioCallback(IAudioServiceCallback cb) throws RemoteException {
            Integer count = mCallback.get(cb);
            if (count == null)
                count = 0;
            mCallback.put(cb, count + 1);
            if (hasCurrentMedia())
                mHandler.sendEmptyMessage(SHOW_PROGRESS);
        }

        @Override
        public synchronized void removeAudioCallback(IAudioServiceCallback cb) throws RemoteException {
            Integer count = mCallback.get(cb);
            if (count == null)
                count = 0;
            if (count > 1)
                mCallback.put(cb, count - 1);
            else
                mCallback.remove(cb);
        }

        @Override
        public int getTime() throws RemoteException {
            return (int) mLibVLC.getTime();
        }

        @Override
        public int getLength() throws RemoteException {
            return (int) mLibVLC.getLength();
        }

        /**
         * Loads a selection of files (a non-user-supplied collection of media)
         * into the primary or "currently playing" playlist.
         * 
         * @param mediaPathList
         *            A list of locations to load
         * @param position
         *            The position to start playing at
         * @param noVideo
         *            True to disable video, false otherwise
         * @throws RemoteException
         */
        @Override
        public void load(List<String> mediaPathList, int position, boolean noVideo) throws RemoteException {

            Log.v(TAG, "Loading position " + ((Integer) position).toString() + " in " + mediaPathList.toString());
            mEventHandler.addHandler(mVlcEventHandler);

            mLibVLC.getMediaList().getEventHandler().removeHandler(mListEventHandler);
            mLibVLC.setMediaList();
            mLibVLC.getPrimaryMediaList().clear();
            MediaList mediaList = mLibVLC.getMediaList();

            mPrevious.clear();

            MediaDatabase db = MediaDatabase.getInstance(getApplicationContext());
            for (int i = 0; i < mediaPathList.size(); i++) {
                String location = mediaPathList.get(i);
                Media media = db.getMedia(location);
                if (media == null) {
                    if (!validateLocation(location)) {
                        Log.w(TAG, "Invalid location " + location);
                        showToast(getResources().getString(R.string.invalid_location, location),
                                Toast.LENGTH_SHORT);
                        continue;
                    }
                    Log.v(TAG, "Creating on-the-fly Media object for " + location);
                    media = new Media(mLibVLC, location);
                }
                mediaList.add(media, noVideo);
            }

            if (mLibVLC.getMediaList().size() == 0) {
                Log.w(TAG, "Warning: empty media list, nothing to play !");
                return;
            }
            if (mLibVLC.getMediaList().size() > position && position >= 0) {
                mCurrentIndex = position;
            } else {
                Log.w(TAG, "Warning: positon " + position + " out of bounds");
                mCurrentIndex = 0;
            }

            // Add handler after loading the list
            mLibVLC.getMediaList().getEventHandler().addHandler(mListEventHandler);

            mLibVLC.playIndex(mCurrentIndex);
            mHandler.sendEmptyMessage(SHOW_PROGRESS);
            setUpRemoteControlClient();
            showNotification();
            updateWidget(AudioService.this);
            updateRemoteControlClientMetadata();
            AudioService.this.saveMediaList();
            AudioService.this.saveCurrentMedia();
            determinePrevAndNextIndices();
        }

        /**
         * Use this function to play a media inside whatever MediaList LibVLC is
         * following.
         * 
         * Unlike load(), it does not import anything into the primary list.
         */
        @Override
        public void playIndex(int index) {
            if (mLibVLC.getMediaList().size() == 0) {
                Log.w(TAG, "Warning: empty media list, nothing to play !");
                return;
            }
            if (index >= 0 && index < mLibVLC.getMediaList().size()) {
                mCurrentIndex = index;
            } else {
                Log.w(TAG, "Warning: index " + index + " out of bounds");
                mCurrentIndex = 0;
            }

            mEventHandler.addHandler(mVlcEventHandler);
            mLibVLC.playIndex(mCurrentIndex);
            mHandler.sendEmptyMessage(SHOW_PROGRESS);
            setUpRemoteControlClient();
            showNotification();
            updateWidget(AudioService.this);
            updateRemoteControlClientMetadata();
            determinePrevAndNextIndices();
        }

        /**
         * Use this function to show an URI in the audio interface WITHOUT
         * interrupting the stream.
         * 
         * Mainly used by VideoPlayerActivity in response to loss of video
         * track.
         */
        @Override
        public void showWithoutParse(int index) throws RemoteException {
            String URI = mLibVLC.getMediaList().getMRL(index);
            Log.v(TAG, "Showing index " + index + " with playing URI " + URI);
            // Show an URI without interrupting/losing the current stream

            if (URI == null || !mLibVLC.isPlaying())
                return;
            mEventHandler.addHandler(mVlcEventHandler);
            mCurrentIndex = index;

            // Notify everyone
            mHandler.sendEmptyMessage(SHOW_PROGRESS);
            showNotification();
            determinePrevAndNextIndices();
            executeUpdate();
            executeUpdateProgress();
        }

        /**
         * Append to the current existing playlist
         */
        @Override
        public void append(List<String> mediaLocationList) throws RemoteException {
            if (!hasCurrentMedia()) {
                load(mediaLocationList, 0, false);
                return;
            }

            MediaDatabase db = MediaDatabase.getInstance(getApplicationContext());
            for (int i = 0; i < mediaLocationList.size(); i++) {
                String location = mediaLocationList.get(i);
                Media media = db.getMedia(location);
                if (media == null) {
                    if (!validateLocation(location)) {
                        showToast(getResources().getString(R.string.invalid_location, location),
                                Toast.LENGTH_SHORT);
                        continue;
                    }
                    Log.v(TAG, "Creating on-the-fly Media object for " + location);
                    media = new Media(mLibVLC, location);
                }
                mLibVLC.getMediaList().add(media);
            }
            AudioService.this.saveMediaList();
            determinePrevAndNextIndices();
            executeUpdate();
        }

        /**
         * Move an item inside the playlist.
         */
        @Override
        public void moveItem(int positionStart, int positionEnd) throws RemoteException {
            mLibVLC.getMediaList().move(positionStart, positionEnd);
        }

        @Override
        public void remove(int position) {
            mLibVLC.getMediaList().remove(position);
        }

        @Override
        public void removeLocation(String location) {
            mLibVLC.getMediaList().remove(location);
        }

        @Override
        public List<String> getMediaLocations() {
            ArrayList<String> medias = new ArrayList<String>();
            for (int i = 0; i < mLibVLC.getMediaList().size(); i++) {
                medias.add(mLibVLC.getMediaList().getMRL(i));
            }
            return medias;
        }

        @Override
        public String getCurrentMediaLocation() throws RemoteException {
            return mLibVLC.getMediaList().getMRL(mCurrentIndex);
        }

        @Override
        public void next() throws RemoteException {
            AudioService.this.next();
        }

        @Override
        public void previous() throws RemoteException {
            AudioService.this.previous();
        }

        @Override
        public void shuffle() throws RemoteException {
            AudioService.this.shuffle();
        }

        @Override
        public void setRepeatType(int t) throws RemoteException {
            AudioService.this.setRepeatType(t);
        }

        @Override
        public void setTime(long time) throws RemoteException {
            mLibVLC.setTime(time);
        }

        @Override
        public boolean hasNext() throws RemoteException {
            if (mNextIndex != -1)
                return true;
            else
                return false;
        }

        @Override
        public boolean hasPrevious() throws RemoteException {
            if (mPrevIndex != -1)
                return true;
            else
                return false;
        }

        @Override
        public void detectHeadset(boolean enable) throws RemoteException {
            mDetectHeadset = enable;
        }

        @Override
        public float getRate() throws RemoteException {
            return mLibVLC.getRate();
        }

        @Override
        public void loadMediaList(int position, boolean libvlcBacked, boolean noVideo) throws RemoteException {
            // TODO Auto-generated method stub
            Log.d("fbh", "E/ loadMediaList add start :");
            mLibVLCPlaylistActive = libvlcBacked;

            mEventHandler.addHandler(mVlcEventHandler);

            mMediaList.clear();
            mPrevious.clear();

            ArrayList<Media> tmp = AudioPlayingList.getInstance().GetServicePlayList();
            for (Media f : tmp)
                mMediaList.add(f);

            Log.d("fbh", "E/ add cost :" + System.currentTimeMillis());

            if (mMediaList.size() > position) {
                mCurrentMedia = mMediaList.get(position);
            }

            if (mCurrentMedia != null) {
                if (mLibVLCPlaylistActive) {
                    playIndex(position);
                } else {
                    readMedia(mCurrentMedia.getLocation(), noVideo);
                }
                Log.d("fbh", "E/ loadMediaList load read cost :");
                setUpRemoteControlClient();
                showNotification();
                // updateWidget(AudioService.this);
                updateRemoteControlClientMetadata();
                Log.d("fbh", "E/ loadMediaList load read then :");
            }
            AudioService.this.saveMediaList();
            AudioService.this.saveCurrentMedia();

            mHandler.sendEmptyMessage(SHOW_PROGRESS);

            Log.d("fbh", "E/ load over :" + System.currentTimeMillis());
        }
    };

    private void updateWidget(Context context) {
        Log.d(TAG, "Updating widget");
        updateWidgetState(context);
        updateWidgetCover(context);
    }

    private void updateWidgetState(Context context) {
        Intent i = new Intent();
        i.setClassName(WIDGET_PACKAGE, WIDGET_CLASS);
        i.setAction(ACTION_WIDGET_UPDATE);

        if (hasCurrentMedia()) {
            i.putExtra("title", getCurrentMedia().getTitle());
            i.putExtra("artist", getCurrentMedia().getArtist());
        } else {
            i.putExtra("title", context.getString(R.string.widget_name));
            i.putExtra("artist", "");
        }
        i.putExtra("isplaying", mLibVLC.isPlaying());

        sendBroadcast(i);
    }

    private void updateWidgetCover(Context context) {
        Intent i = new Intent();
        i.setClassName(WIDGET_PACKAGE, WIDGET_CLASS);
        i.setAction(ACTION_WIDGET_UPDATE_COVER);

        Bitmap cover = hasCurrentMedia() ? AudioUtil.getCover(this, getCurrentMedia(), 64) : null;
        i.putExtra("cover", cover);

        sendBroadcast(i);
    }

    private void updateWidgetPosition(Context context, float pos) {
        // no more than one widget update for each 1/50 of the song
        long timestamp = Calendar.getInstance().getTimeInMillis();
        if (!hasCurrentMedia() || timestamp - mWidgetPositionTimestamp < getCurrentMedia().getLength() / 50)
            return;

        updateWidgetState(context);

        mWidgetPositionTimestamp = timestamp;
        Intent i = new Intent();
        i.setClassName(WIDGET_PACKAGE, WIDGET_CLASS);
        i.setAction(ACTION_WIDGET_UPDATE_POSITION);
        i.putExtra("position", pos);
        sendBroadcast(i);
    }

    private synchronized void loadLastPlaylist() {
        if (!AndroidDevices.hasExternalStorage())
            return;

        String line;
        FileInputStream input;
        BufferedReader br;
        int rowCount = 0;

        int position = 0;
        String currentMedia;
        List<String> mediaPathList = new ArrayList<String>();

        try {
            // read CurrentMedia
            input = new FileInputStream(AudioUtil.CACHE_DIR + "/" + "CurrentMedia.txt");
            br = new BufferedReader(new InputStreamReader(input));
            currentMedia = br.readLine();
            mShuffling = "1".equals(br.readLine());
            br.close();
            input.close();

            // read MediaList
            input = new FileInputStream(AudioUtil.CACHE_DIR + "/" + "MediaList.txt");
            br = new BufferedReader(new InputStreamReader(input));
            while ((line = br.readLine()) != null) {
                mediaPathList.add(line);
                if (line.equals(currentMedia))
                    position = rowCount;
                rowCount++;
            }
            br.close();
            input.close();

            // load playlist
            mInterface.load(mediaPathList, position, false);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

    private synchronized void saveCurrentMedia() {
        if (!AndroidDevices.hasExternalStorage())
            return;

        FileOutputStream output;
        BufferedWriter bw;

        try {
            output = new FileOutputStream(AudioUtil.CACHE_DIR + "/" + "CurrentMedia.txt");
            bw = new BufferedWriter(new OutputStreamWriter(output));
            bw.write(mLibVLC.getMediaList().getMRL(mCurrentIndex));
            bw.write('\n');
            bw.write(mShuffling ? "1" : "0");
            bw.write('\n');
            bw.close();
            output.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private synchronized void saveMediaList() {
        if (!AndroidDevices.hasExternalStorage())
            return;

        FileOutputStream output;
        BufferedWriter bw;

        try {
            output = new FileOutputStream(AudioUtil.CACHE_DIR + "/" + "MediaList.txt");
            bw = new BufferedWriter(new OutputStreamWriter(output));
            for (int i = 0; i < mLibVLC.getMediaList().size(); i++) {
                bw.write(mLibVLC.getMediaList().getMRL(i));
                bw.write('\n');
            }
            bw.close();
            output.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private boolean validateLocation(String location) {
        /* Check if the MRL contains a scheme */
        if (!location.matches("\\w+://.+"))
            location = "file://".concat(location);
        if (location.toLowerCase(Locale.ENGLISH).startsWith("file://")) {
            /* Ensure the file exists */
            File f;
            try {
                f = new File(new URI(location));
            } catch (URISyntaxException e) {
                return false;
            }
            if (!f.isFile())
                return false;
        }
        return true;
    }

    private void showToast(String text, int duration) {
        Message msg = new Message();
        Bundle bundle = new Bundle();
        bundle.putString("text", text);
        bundle.putInt("duration", duration);
        msg.setData(bundle);
        msg.what = SHOW_TOAST;
        mHandler.sendMessage(msg);
    }

    // add by dzt 2014.08.08
    private void StartLoadFileThread() {
        loadMp3Thread = new HandlerThread("load_mp3_file_thread", Process.THREAD_PRIORITY_FOREGROUND);
        loadMp3Thread.start();
        mPlayFileHandler = new LoadFileHandler(loadMp3Thread.getLooper());
    }

    HandlerThread loadMp3Thread = null;
    Handler mPlayFileHandler = null;

    class LoadFileHandler extends Handler {
        public LoadFileHandler(Looper looper) {
            super(looper);
        }

        // Handler mPlayFileHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            // TODO Auto-generated method stub
            super.handleMessage(msg);

            if (msg.what == 3) {// next
                // mLibVLC.next();
            } else if (msg.what == 4) {// pre
                // mLibVLC.previous();
            } else if (msg.what == 1) {// 
                Bundle bundle = msg.getData();
                if (bundle != null) {
                    Log.d(TAG, "fbh E/ load file thread start :");
                    String filePath = bundle.getString("filePath");
                    boolean noVideo = bundle.getBoolean("noVideo");
                    String path = LibVLC.PathToURI(filePath);
                    mLibVLC.readMedia(getApplicationContext(), path, noVideo);

                    Log.d(TAG, "fbh E/ load file thread  path = " + path);
                }
            } else if (msg.what == 2) {// playindex
                Bundle bundle = msg.getData();
                if (bundle != null) {
                    int position = bundle.getInt("position");
                    mLibVLC.playIndex(position);
                }
            }
            updateWidget(AudioService.this);
        }
    };

    private void readMedia(String filePath, boolean noVideo) {
        Message message = Message.obtain(mPlayFileHandler);
        Bundle data = new Bundle();
        data.putString("filePath", filePath);
        data.putBoolean("noVideo", noVideo);
        message.what = 1;
        message.setData(data);
        message.sendToTarget();
    }

    private void playIndex(int position) {
        Message message = Message.obtain(mPlayFileHandler);
        Bundle data = new Bundle();
        data.putInt("position", position);
        message.what = 2;
        message.setData(data);
        message.sendToTarget();
    }

    private void playNext() {
        Message message = Message.obtain(mPlayFileHandler);
        message.what = 3;
        message.sendToTarget();
    }

    private void playPrevious() {
        Message message = Message.obtain(mPlayFileHandler);
        message.what = 4;
        message.sendToTarget();
    }

    // 
    private void fast_forward() {
        setUpRemoteControlClient();

        long time = mLibVLC.customizeGetTime();
        if (time >= 0) {
            mLibVLC.setTime(time + 5000);
        }
        mHandler.sendEmptyMessage(SHOW_PROGRESS);
        showNotification();
        // updateWidget(this);
    }

    // 
    private void fast_back() {
        setUpRemoteControlClient();

        long time = mLibVLC.customizeGetTime();
        if (time >= 5000) {
            mLibVLC.setTime(time - 5000);
        } else {
            mLibVLC.setTime(0);
        }
        mHandler.sendEmptyMessage(SHOW_PROGRESS);
        showNotification();
        // updateWidget(this);
    }
}