我工作的媒体播放器应用程序。我想它同步到搜索栏，这样当媒体所扮演的搜索栏会自动的进行。下面是我的源$ C ​​$ C：

 公共类MusicDroid扩展ListActivity工具
        SeekBar.OnSeekBarChangeListener，可运行{

    私人诠释CUR_TIME = 0;
    私人搜索栏搜索栏;
    INT song_dur = 0;
    GroveService GS;
    公共天文台计时;
    INT timer_time = 0;

    @覆盖
    公共无效的onCreate（包冰柱）{
        尝试 {
            super.onCreate（冰柱）;
            的setContentView（R.layout.songlist）;
            GS =新GroveService（）;
            gs.updateSongList（）;
        }赶上（NullPointerException异常E）{
            Log.v（的getString（R.string.app_name），e.getMessage（））;
        }
        搜索栏=（搜索栏）findViewById（R.id.SeekBar01）;
        计时器=（天文台）findViewById（R.id.C​​hronometer01）;
        seekbar.setOnSeekBarChangeListener（本）;
        // this.bindService（新意图（这一点，GroveService.class），康涅狄格州，
        // Context.BIND_AUTO_CREATE）;
        ArrayAdapter＆LT;字符串＆GT;的SongList =新的ArrayAdapter＆LT;字符串＆GT;（这一点，
                R.layout.song_item，gs.songs）;
        setListAdapter（的SongList）;
        timer.setOnChronometerTickListener（新OnChronometerTickListener（）{
            @覆盖
            公共无效onChronometerTick（记时计为arg0）{
                // TODO自动生成方法存根
                seekbar.setProgress（CUR_TIME）;
            }
        }）;
    }

    保护无效onListItemClick（ListView的L，视图V，INT位置，长的id）{
        timer.stop（）;
        timer.start（）;
        gs.playSong（位置，0）;
    }

    / *
     *私人ServiceConnection康恩=新ServiceConnection（）{
     *
     * @覆盖公共无效onServiceConnected（组件名称为arg0，的IBinder
     * ARG1）{Log.v（状态：，服务连接到播放器）; // 去做
     *自动生成方法存根TPROG =新主题（新的Runnable（）{
     *
     *}）; tprog.setPriority（从Thread.MIN_PRIORITY）; tprog.start（）; }
     *
     * @覆盖公共无效onServiceDisconnected（组件名称为arg0）{// TODO
     *自动生成方法存根
     *
     *}};
     * /
    // code基于菜单的媒体播放器控制
    / *
     *公共布尔onOptionsItemSelected（菜单项项）{开关
     *（item.getItemId（））{情况R.id. $ P $光伏：GS prevSong（）;打破;外壳
     * R.id.play：gs.playSong（gs.songindex，CUR_TIME）;打破;案例R.id.pause：
     * gs.mp.getDuration（）; gs.mp.pause（）;打破;案R.id.nxt：gs.nextSong（）;
     * 打破; }返回true; }
     * /

    公共无效myClickHandler（查看视图）{
        开关（view.getId（））{
        案例R.id.ImageButton01：
            GS prevSong（）。
            timer.stop（）;
            seekbar.setMax（gs.getSongDuration（gs.songindex））;
            Log.v（搜索栏最大，将String.valueOf（seekbar.getMax（）））;
            timer.start（）;
            打破;
        案例R.id.ImageButton02：
            线程t =新的Thread（）;
            t.start（）;
            gs.playSong（gs.songindex，CUR_TIME）;
            timer.start（）;
            seekbar.setMax（gs.getSongDuration（gs.songindex））;
            Log.v（搜索栏最大，将String.valueOf（seekbar.getMax（）））;
            打破;
        案例R.id.ImageButton03：
            CUR_TIME = gs.getCurrentDuration（gs.songindex）;

              如果（gs.mp.isPlaying（））{
              timer_time =的Integer.parseInt（（字符串）timer.getText（））;
              timer.stop（）;
              timer.setBase（timer_time）;
              Log.v（定时器超时，将String.valueOf（timer_time））; }
              gs.mp.pause（）;
            seekbar.setMax（gs.getSongDuration（gs.songindex））;
            Log.v（搜索栏最大，将String.valueOf（seekbar.getMax（）））;
            打破;
        案例R.id.ImageButton04：
            gs.nextSong（）;
            timer.stop（）;
            timer.start（）;
            seekbar.setMax（gs.getSongDuration（gs.songindex））;
            Log.v（搜索栏最大，将String.valueOf（seekbar.getMax（）））;
            打破;
        }
    }

    @覆盖
    公共无效onProgressChanged（搜索栏为arg0，INT ARG1，布尔ARG2）{
        // TODO自动生成方法存根
        gs.mp.seekTo（ARG1）;
    }

    @覆盖
    公共无效onStartTrackingTouch（搜索栏为arg0）{
        // TODO自动生成方法存根
    }

    @覆盖
    公共无效onStopTrackingTouch（搜索栏为arg0）{
        // TODO自动生成方法存根
    }

    @覆盖
    公共无效的run（）{
        // TODO自动生成方法存根
        INT currentPosition = 0;
        INT总= gs.mp.getDuration（）;
        seekbar.setMax（总）;
        而（gs.mp = NULL和放大器;！＆安培; currentPosition＆LT;总）{
            尝试 {
                视频下载（1000）;
                currentPosition = gs.mp.getCurrentPosition（）;
            }赶上（InterruptedException异常E）{
                返回;
            }赶上（例外五）{
                返回;
            }
            seekbar.setProgress（currentPosition）;
        }
    }
}
 

这是进行音乐播放服务类。 code是在这里：

 类Mp3Filter实现了FilenameFilter {
    公共布尔接受（文件目录，字符串名称）{
        返程（name.endsWith（MP3））;
    }
}

公共类GroveService延伸服务{
    静态最后弦乐MEDIA_PATH =新的String（/ SD卡/）;
    名单＆LT;字符串＆GT;歌曲=新的ArrayList＆LT;字符串＆GT;（）;
    MediaPlayer的熔点为新的MediaPlayer（）;
    INT songindex = 0;
    INT持续时间= 0;
    // MusicDroid MD;
    @覆盖
    公众的IBinder onBind（意向为arg0）{
        // TODO自动生成方法存根
        返回null;
    }
    公共无效的onCreate（）
    {
        super.onCreate（）;
        updateSongList（）;
        // MD =新MusicDroid（）;
    }

    公共无效updateSongList（）{
        文件家庭=新的文件（MEDIA_PATH）;
        如果（home.listFiles（新Mp3Filter（））长度GT; 0）{
            对于（文件文件：home.listFiles（新Mp3Filter（）））{
                songs.add（file.getName（））;
            }
        }
    }
    公共无效playSong（最终诠释的位置，最终诠释CUR_POS）{
        尝试 {
            mp.reset（）;
            mp.setDataSource（MEDIA_PATH + songs.get（位置））;
            MP prepare（）。
            //song_dur=mp.getDuration（）;
            mp.seekTo（CUR_POS）;
            mp.start（）;
            持续时间=位置;
            mp.setOnCompletionListener（新OnCompletionListener（）{
                公共无效onCompletion（MediaPlayer的为arg0）{
                    nextSong（）;
                }
            }）;
        }赶上（IOException异常E）{
            Log.v（的getString（R.string.app_name），e.getMessage（））;
        }
    }

    公共无效nextSong（）{
        如果（++ songindex＆GT; = songs.size（））
            songindex = 0;
        其他
            playSong（songindex，0）;
    }

    公共无效prevSong（）{
        songindex--;
        如果（songindex大于0）
            playSong（songindex，0）;
        其他 {
            songindex = 0;
            playSong（songindex，0）;
        }
    }
    公众诠释getSongDuration（INT指数）
    {
        持续时间= mp.getDuration（）;
        Log.v（宋持续时间，将String.valueOf（持续时间））;
        返回时间;
    }
    公众诠释getCurrentDuration（INT指数）{
        INT current_position;
        current_position = mp.getCurrentPosition（）;
        Log.v（当前DUR：将String.valueOf（current_position））;
        返回current_position;
    }
}
 

解决方案

在MediaPlayer的，你可以在preparedListener设置中，你可以同步你寻求为如下

  mMediaPlayer.setOn preparedListener（新在preparedListener（）
          {
            @覆盖
            在prepared公共无效（最终的MediaPlayer MP）
            {
                seekBar.setMax（mp.getDuration（））;
                   新主题（新的Runnable（）{

                           @覆盖
                           公共无效的run（）{
                                   而（MP =空＆放大器;！＆安培; mp.getCurrentPosition（）＆LT; mp.getDuration（））
                                   {
                                       seekBar.setProgress（mp.getCurrentPosition（））;
                                       消息味精=新的Message（）;
                                       INT米利斯= mp.getCurrentPosition（）;

                                       msg.obj =米利斯/ 1000;
                                       mHandler.sendMessage（MSG）;
                                        尝试 {
                                            视频下载（100）;
                                        }
                                        赶上（InterruptedException异常E）{
                                           e.printStackTrace（）;
                                        }
                                   }
                           }
                   }）。开始（）;

            }
        }）;
 

I am working on a media player app. I am trying to sync it to a seekbar so that when media is played the seek bar progresses automatically. Here is my source code:

public class MusicDroid extends ListActivity implements
        SeekBar.OnSeekBarChangeListener, Runnable {

    private int cur_time = 0;
    private SeekBar seekbar;
    int song_dur = 0;
    GroveService gs;
    public Chronometer timer;
    int timer_time = 0;

    @Override
    public void onCreate(Bundle icicle) {
        try {
            super.onCreate(icicle);
            setContentView(R.layout.songlist);
            gs = new GroveService();
            gs.updateSongList();
        } catch (NullPointerException e) {
            Log.v(getString(R.string.app_name), e.getMessage());
        }
        seekbar = (SeekBar) findViewById(R.id.SeekBar01);
        timer = (Chronometer) findViewById(R.id.Chronometer01);
        seekbar.setOnSeekBarChangeListener(this);
        // this.bindService(new Intent(this, GroveService.class), conn,
        // Context.BIND_AUTO_CREATE);
        ArrayAdapter<String> songList = new ArrayAdapter<String>(this,
                R.layout.song_item, gs.songs);
        setListAdapter(songList);
        timer.setOnChronometerTickListener(new OnChronometerTickListener() {
            @Override
            public void onChronometerTick(Chronometer arg0) {
                // TODO Auto-generated method stub
                seekbar.setProgress(cur_time);
            }
        });
    }

    protected void onListItemClick(ListView l, View v, int position, long id) {
        timer.stop();
        timer.start();
        gs.playSong(position, 0);
    }

    /*
     * private ServiceConnection conn= new ServiceConnection(){
     * 
     * @Override public void onServiceConnected(ComponentName arg0, IBinder
     * arg1) { Log.v("Status:","Service Connected to player"); // TODO
     * Auto-generated method stub tprog= new Thread(new Runnable(){
     * 
     * }); tprog.setPriority(Thread.MIN_PRIORITY); tprog.start(); }
     * 
     * @Override public void onServiceDisconnected(ComponentName arg0) { // TODO
     * Auto-generated method stub
     * 
     * } };
     */
    // code for menu based media player controls
    /*
     * public boolean onOptionsItemSelected(MenuItem item) { switch
     * (item.getItemId()) { case R.id.prev: gs.prevSong(); break; case
     * R.id.play: gs.playSong(gs.songindex,cur_time); break; case R.id.pause:
     * gs.mp.getDuration(); gs.mp.pause(); break; case R.id.nxt: gs.nextSong();
     * break; } return true; }
     */

    public void myClickHandler(View view) {
        switch (view.getId()) {
        case R.id.ImageButton01:
            gs.prevSong();
            timer.stop();
            seekbar.setMax(gs.getSongDuration(gs.songindex));
            Log.v("SeekBar Max", String.valueOf(seekbar.getMax()));
            timer.start();
            break;
        case R.id.ImageButton02:
            Thread t=new Thread();
            t.start();
            gs.playSong(gs.songindex, cur_time);
            timer.start();
            seekbar.setMax(gs.getSongDuration(gs.songindex));
            Log.v("SeekBar Max", String.valueOf(seekbar.getMax()));
            break;
        case R.id.ImageButton03:
            cur_time = gs.getCurrentDuration(gs.songindex);

              if(gs.mp.isPlaying()){
              timer_time=Integer.parseInt((String)timer.getText());
              timer.stop(); 
              timer.setBase(timer_time);
              Log.v("Timer Time",String.valueOf(timer_time)); }
              gs.mp.pause(); 
            seekbar.setMax(gs.getSongDuration(gs.songindex));
            Log.v("SeekBar Max", String.valueOf(seekbar.getMax()));
            break;
        case R.id.ImageButton04:
            gs.nextSong();
            timer.stop();
            timer.start();
            seekbar.setMax(gs.getSongDuration(gs.songindex));
            Log.v("SeekBar Max", String.valueOf(seekbar.getMax()));
            break;
        }
    }

    @Override
    public void onProgressChanged(SeekBar arg0, int arg1, boolean arg2) {
        // TODO Auto-generated method stub
        gs.mp.seekTo(arg1);
    }

    @Override
    public void onStartTrackingTouch(SeekBar arg0) {
        // TODO Auto-generated method stub
    }

    @Override
    public void onStopTrackingTouch(SeekBar arg0) {
        // TODO Auto-generated method stub
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        int currentPosition = 0;
        int total = gs.mp.getDuration();
        seekbar.setMax(total);
        while (gs.mp != null && currentPosition < total) {
            try {
                Thread.sleep(1000);
                currentPosition = gs.mp.getCurrentPosition();
            } catch (InterruptedException e) {
                return;
            } catch (Exception e) {
                return;
            }
            seekbar.setProgress(currentPosition);
        }
    }
}

Service class that performs music playback. code is here:

class Mp3Filter implements FilenameFilter {
    public boolean accept(File dir, String name) {
        return (name.endsWith(".mp3"));
    }
}

public class GroveService extends Service {
    static final String MEDIA_PATH = new String("/sdcard/");
    List<String> songs = new ArrayList<String>();
    MediaPlayer mp = new MediaPlayer();
    int songindex = 0;
    int duration=0;
    //MusicDroid md;
    @Override
    public IBinder onBind(Intent arg0) {
        // TODO Auto-generated method stub
        return null;
    }
    public void onCreate()
    {
        super.onCreate();
        updateSongList();
        //md=new MusicDroid();
    }

    public void updateSongList() {
        File home = new File(MEDIA_PATH);
        if (home.listFiles(new Mp3Filter()).length > 0) {
            for (File file : home.listFiles(new Mp3Filter())) {
                songs.add(file.getName());
            }                                   
        }
    }
    public void playSong(final int position, final int cur_pos) {
        try {                     
            mp.reset();         
            mp.setDataSource(MEDIA_PATH + songs.get(position)); 
            mp.prepare();   
            //song_dur=mp.getDuration();
            mp.seekTo(cur_pos); 
            mp.start(); 
            duration=position;
            mp.setOnCompletionListener(new OnCompletionListener() {
                public void onCompletion(MediaPlayer arg0) {
                    nextSong();
                }
            });         
        } catch (IOException e) {
            Log.v(getString(R.string.app_name), e.getMessage());
        }
    }    

    public void nextSong() {
        if (++songindex >= songs.size())
            songindex = 0;
        else
            playSong(songindex,0);
    }

    public void prevSong() {
        songindex--;
        if (songindex > 0)
            playSong(songindex,0);
        else {
            songindex = 0;
            playSong(songindex,0);
        }
    }
    public int getSongDuration(int index)
    {   
        duration=mp.getDuration();
        Log.v("Song Duration", String.valueOf(duration));
        return duration;
    }
    public int getCurrentDuration(int index){
        int current_position;
        current_position=mp.getCurrentPosition();
        Log.v("Current Dur:",String.valueOf(current_position));
        return current_position;
    }
}

in MediaPlayer you can set onPreparedListener in which you can synchronize your seek as as follow

mMediaPlayer.setOnPreparedListener(new OnPreparedListener() 
          {
            @Override
            public void onPrepared(final MediaPlayer mp) 
            {
                seekBar.setMax(mp.getDuration());
                   new Thread(new Runnable() {

                           @Override
                           public void run() {
                                   while(mp!=null && mp.getCurrentPosition()<mp.getDuration())
                                   {
                                       seekBar.setProgress(mp.getCurrentPosition());
                                       Message msg=new Message();
                                       int millis = mp.getCurrentPosition();

                                       msg.obj=millis/1000;
                                       mHandler.sendMessage(msg);
                                        try {
                                            Thread.sleep(100);
                                        } 
                                        catch (InterruptedException e) {
                                           e.printStackTrace();
                                        }
                                   }
                           }
                   }).start();

            }
        });