音频播放器的实现

音频播放器的实现

Service是Android中实现程序后台运行的解决方案，非常适合用于去执行哪些不需要和用户交互而且还要求长期运行的任务。不能运行在一个独立的进程当中，而是依赖与创建服务时所在的应用程序进程。只能在后台运行，并且可以和其他组件进行交互。

Service可以在很多场合使用，比如播放多媒体的时候用户启动了其他Activity，此时要在后台继续播放；比如检测SD卡上文件的变化；比如在后台记录你的地理信息位置的改变等等，总之服务是藏在后台的。

因此音频播放器也是通过Service来实现的。

音频播放器主要依赖MediaPlayer类，通过实现

1
2
MediaPlayer.OnCompletionListener, MediaPlayer.OnBufferingUpdateListener,
MediaPlayer.OnPreparedListener, MediaPlayer.OnErrorListener

这几个接口来对MediaPlayer类的对象进行播放状态的控制。

布局文件设计：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
<LinearLayout
  android:id="@+id/layout_play_controls"
  android:layout_width="match_parent"
  android:layout_height="wrap_content"
  android:layout_alignParentBottom="true"
  android:layout_centerHorizontal="true"
  android:background="#33000000"
  android:showDividers="middle"
  android:divider="@drawable/common_divider_xlarge_horizontal"
  android:gravity="center_vertical">

  <android.support.v7.widget.AppCompatImageView
     android:id="@+id/button_play_last"
     android:layout_width="0dp"
     android:layout_weight="1"
     android:layout_height="wrap_content"
     android:clickable="true"
     app:srcCompat="@drawable/ic_play_last"
     android:background="?attr/selectableItemBackgroundBorderless" />

  <android.support.v7.widget.AppCompatImageView
     android:id="@+id/button_play_toggle"
     android:layout_width="0dp"
     android:layout_weight="1"
     android:layout_height="wrap_content"
     android:clickable="true"
     app:srcCompat="@drawable/ic_play"
     android:background="?attr/selectableItemBackgroundBorderless" />

   <android.support.v7.widget.AppCompatImageView
      android:id="@+id/button_play_next"
      android:layout_width="0dp"
      android:layout_weight="1"
      android:layout_height="wrap_content"
      android:clickable="true"
      app:srcCompat="@drawable/ic_play_next"
      android:background="?attr/selectableItemBackgroundBorderless" />
</LinearLayout>
<LinearLayout
   android:layout_above="@id/layout_play_controls"
   android:id="@+id/layout_progress"
   android:layout_width="match_parent"
   android:layout_height="wrap_content"
   android:minHeight="44dp"
   android:background="#33000000"
   android:gravity="center_vertical" >

   <TextView
      android:id="@+id/text_view_progress"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:textColor="@color/white"
      android:textSize="12sp"
      android:singleLine="true"
      android:text="00：00" />

   <android.support.v7.widget.AppCompatSeekBar
      android:id="@+id/seek_bar"
      style="@style/Widget.AppCompat.SeekBar"
      android:layout_width="0dp"
      android:layout_height="wrap_content"
      android:layout_weight="1"
      android:max="10000"/>

   <TextView
      android:id="@+id/text_view_duration"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:textColor="@color/white"
      android:textSize="12sp"
      android:singleLine="true"
      android:text="03：00" />
</LinearLayout>

布局效果展示：

1. 接口编程的实现

对于接口IPlayback以及接口内定义的接口Callback，如：

1
2
3
4
5
6
7
8
9
10
11
public interface IPlayback {
    ....
    void registerCallback(Callback callback);
    void unregisterCallback(Callback callback);
    void removeCallbacks();
    interface Callback {
        void onComplete(PlayState state);
        void onPlayStatusChanged(PlayState status);
        void onPosition(int position);
    }
}

在Player类中实现接口IPlayback，包括registerCallback等方法，

1
2
3
4
5
private List<Callback> mCallbacks = new ArrayList<>();
@Override
public void registerCallback(Callback callback) {
    mCallbacks.add(callback);
}

在Activity、Service中都需要实现IPlayback.Callback接口，

Activity中的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
private PlaybackService playbackService;
private ServiceConnection connection = new ServiceConnection() {
  @Override
  public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
    playbackService = ((PlaybackService.LocalBinder) iBinder).getService();
    register();
  }

  @Override
  public void onServiceDisconnected(ComponentName componentName) {
    unRegister();
    playbackService = null;
  }
};

private void register() {
  playbackService.registerCallback(this);
}

private void unRegister() {
  if (playbackService != null) {
    playbackService.unregisterCallback(this);
  }
}

@Override
public void onPlayStatusChanged(PlayState status) {
  switch (status) {
    case INIT:
      break;
    case PREPARE:
      break;
    case PLAYING:
      updateDuration();
      playTimer();
      buttonPlayToggle.setImageResource(R.drawable.ic_pause);
      break;
    case ERROR:
      break;
    case COMPLETE:
      cancelTimer();
      buttonPlayToggle.setImageResource(R.drawable.ic_play);
      seekBar.setProgress(0);
      break;
  }
}

在Service中的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
private Player mPlayer;
@Override
public void onCreate() {
  super.onCreate();
  mPlayer = Player.getInstance();
  mPlayer.registerCallback(this);
}

@Override
public void registerCallback(Callback callback) {
  mPlayer.registerCallback(callback);
}

@Override
public void onPlayStatusChanged(PlayState status) {
  showNotification(status);
}

其中Activity和Service中registerCallback(this)，this表示在各自的类中实现Callback接口中的所有方法。

2. 播放器具体实现

定义Player类实现IPlayback接口，在Player类中添加Callback的列表，并对注册入其中的所有Callback调用相应的回调函数。

IPlayback.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public interface IPlayback {
  boolean play();
  boolean play(String song);
  boolean pause();
  boolean isPlaying();
  int getProgress();
  int getDuration();
  boolean seekTo(int progress);
  void registerCallback(Callback callback);
  void unregisterCallback(Callback callback);
  void removeCallbacks();
  void releasePlayer();
  interface Callback {
    void onComplete(PlayState state);
    void onPlayStatusChanged(PlayState status);
    void onPosition(int position);
  }
}

在Player类中pause()、play()、onCompletion()等方法中实现播放状态的转换，在状态转换的方法中实现所有注册的Callback的回调方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
public class Player implements IPlayback, MediaPlayer.OnCompletionListener, MediaPlayer.OnBufferingUpdateListener,
MediaPlayer.OnPreparedListener, MediaPlayer.OnErrorListener{

  private static volatile Player sInstance;
  private MediaPlayer mediaPlayer;
  private List<Callback> mCallbacks = new ArrayList<>();
  private boolean isPaused;
  private String song;

  private Player() {
    mediaPlayer = new MediaPlayer();
    mediaPlayer.setOnCompletionListener(this);
    mediaPlayer.setOnPreparedListener(this);
    mediaPlayer.setOnBufferingUpdateListener(this);
  }

  public static Player getInstance() {
    if (sInstance == null) {
      synchronized (Player.class) {
        if (sInstance == null) {
          sInstance = new Player();
        }
      }
    }
    return sInstance;
  }

  @Override
  public void onBufferingUpdate(MediaPlayer mediaPlayer, int i) {

  }

  @Override
  public void onCompletion(MediaPlayer mediaPlayer) {
    mediaPlayer.reset();
    notifyPlayStatusChanged(PlayState.COMPLETE);
  }

  @Override
  public boolean onError(MediaPlayer mediaPlayer, int i, int i1) {
    notifyPlayStatusChanged(PlayState.ERROR);
    return false;
  }

  @Override
  public void onPrepared(MediaPlayer mediaPlayer) {
    mediaPlayer.start();
    notifyPlayStatusChanged(PlayState.PLAYING);
  }

  @Override
  public boolean play() {
    if (isPaused) {
      mediaPlayer.start();
      notifyPlayStatusChanged(PlayState.PLAYING);
      return true;
    }
    return false;
  }

  @Override
  public boolean play(String song) {
    try {
      mediaPlayer.reset();
      mediaPlayer.setDataSource(song);
      mediaPlayer.prepare();
      this.song = song;
      notifyPlayStatusChanged(PlayState.PLAYING);
      return true;
    } catch (IOException e) {
      notifyPlayStatusChanged(PlayState.ERROR);
      e.printStackTrace();
    }
    return false;
  }

  @Override
  public boolean pause() {
    if (mediaPlayer.isPlaying()) {
      mediaPlayer.pause();
      isPaused = true;
      notifyPlayStatusChanged(PlayState.PAUSE);
      return true;
    }
    return false;
  }

  @Override
  public boolean isPlaying() {
    return mediaPlayer.isPlaying();
  }

  @Override
  public int getProgress() {
    return mediaPlayer.getCurrentPosition();
  }

  @Override
  public int getDuration() {
    return mediaPlayer.getDuration();
  }

  @Override
  public boolean seekTo(int progress) {
    try {
      mediaPlayer.seekTo(progress);
    }
    catch (IllegalStateException e) {
      e.printStackTrace();
    }
    return true;
  }

  @Override
  public void registerCallback(Callback callback) {
    mCallbacks.add(callback);
  }

  @Override
  public void unregisterCallback(Callback callback) {
    mCallbacks.remove(callback);
  }

  @Override
  public void removeCallbacks() {
    mCallbacks.clear();
  }

  @Override
  public void releasePlayer() {
    mediaPlayer.reset();
    mediaPlayer.release();
    mediaPlayer = null;
    sInstance = null;
    song = null;
  }

  public String getSong() {
    return song;
  }

  private void notifyPlayStatusChanged(PlayState state) {
    for (Callback callback: mCallbacks) {
      callback.onPlayStatusChanged(state);
    }
  }

  private void notifyComplete(PlayState state) {
    for (Callback callback : mCallbacks) {
      callback.onComplete(state);
    }
  }
}

自定义PlaybackService类，默认的实现方法包括onCreate()、onStartCommand()、stopService()等，在其中各自实现相应的逻辑。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
public class PlaybackService extends Service implements IPlayback, IPlayback.Callback {

  private static final String ACTION_PLAY_TOGGLE = "com.github.baby.owspace.ACTION.PLAY_TOGGLE";
  private static final String ACTION_PLAY_LAST = "com.github.baby.owspace.ACTION.PLAY_LAST";
  private static final String ACTION_PLAY_NEXT = "com.github.baby.owspace.ACTION.PLAY_NEXT";
  private static final String ACTION_STOP_SERVICE = "com.github.baby.owspace.ACTION.STOP_SERVICE";

  private static final int NOTIFICATION_ID = 1;

  private RemoteViews mContentViewBig, mContentViewSmall;

  private Player mPlayer;

  public class LocalBinder extends Binder {
    public PlaybackService getService() {
      return PlaybackService.this;
    }
  }

  private final Binder mBinder = new LocalBinder();

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

  @Override
  public void onCreate() {
    super.onCreate();
    mPlayer = Player.getInstance();
    mPlayer.registerCallback(this);
  }

  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
    if (intent != null) {
      String action = intent.getAction();
      if (ACTION_PLAY_TOGGLE.equals(action)) {
        if (isPlaying()) {
          pause();
        }
        else {
          play();
        }
      }
      else if (ACTION_STOP_SERVICE.equals(action)) {
        if (isPlaying()) {
          pause();
        }
        stopForeground(true);
        unregisterCallback(this);
      }
    }
    return START_STICKY;
  }

  @Override
  public boolean stopService(Intent name) {
    stopForeground(true);
    unregisterCallback(this);
    return super.stopService(name);
  }

  @Override
  public void onDestroy() {
    releasePlayer();
    super.onDestroy();
  }

  @Override
  public boolean onUnbind(Intent intent) {
    return super.onUnbind(intent);
  }

  @Override
  public boolean play() {
    return mPlayer.play();
  }

  @Override
  public boolean play(String song) {
    return mPlayer.play(song);
  }

  @Override
  public boolean pause() {
    return mPlayer.pause();
  }

  @Override
  public boolean isPlaying() {
    return mPlayer.isPlaying();
  }

  @Override
  public int getProgress() {
    return mPlayer.getProgress();
  }

  @Override
  public int getDuration() {
    return mPlayer.getDuration();
  }

  @Override
  public boolean seekTo(int progress) {
    return mPlayer.seekTo(progress);
  }

  @Override
  public void registerCallback(Callback callback) {
    mPlayer.registerCallback(callback);
  }

  @Override
  public void unregisterCallback(Callback callback) {
    mPlayer.unregisterCallback(callback);
  }

  @Override
  public void removeCallbacks() {
    mPlayer.removeCallbacks();
  }

  @Override
  public void releasePlayer() {
    mPlayer.releasePlayer();
    super.onDestroy();
  }

  public String getSong(){
    return mPlayer.getSong();
  }

  @Override
  public void onComplete(PlayState state) {
    showNotification(state);
  }

  @Override
  public void onPlayStatusChanged(PlayState status) {
    showNotification(status);
  }

  @Override
  public void onPosition(int position) {

  }

  /**
     * Show a notification while this service is running.
     */
  private void showNotification(PlayState status) {
    String CHANNEL_ONE_ID = "com.primedu.cn";
    String CHANNEL_ONE_NAME = "Channel One";
    NotificationChannel notificationChannel = null;
    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
      notificationChannel = new NotificationChannel(CHANNEL_ONE_ID,
                                                    CHANNEL_ONE_NAME, NotificationManager.IMPORTANCE_HIGH);
      notificationChannel.enableLights(true);
      notificationChannel.setLightColor(Color.RED);
      notificationChannel.setShowBadge(true);
      notificationChannel.setLockscreenVisibility(Notification.VISIBILITY_PUBLIC);
      NotificationManager manager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
      manager.createNotificationChannel(notificationChannel);
    }

    // The PendingIntent to launch our activity if the user selects this notification
    PendingIntent contentIntent = PendingIntent.getActivity(this, 0, new Intent(this, MainActivity.class), 0);

    // Set the info for the views that show in the notification panel.
    Notification notification = new NotificationCompat.Builder(this)
      .setChannelId(CHANNEL_ONE_ID)
      .setSmallIcon(R.mipmap.ic_launcher)  // the status icon
      .setWhen(System.currentTimeMillis())  // the time stamp
      .setContentIntent(contentIntent)  // The intent to send when the entry is clicked
      .setCustomContentView(getSmallContentView())
      .setPriority(NotificationCompat.PRIORITY_MAX)
      .setOngoing(true)
      .build();

    // Send the notification.
    startForeground(NOTIFICATION_ID, notification);
  }

  private RemoteViews getSmallContentView() {
    if (mContentViewSmall == null) {
      mContentViewSmall = new RemoteViews(getPackageName(), R.layout.remote_view_music_player_small);
      setUpRemoteView(mContentViewSmall);
    }
    updateRemoteViews(mContentViewSmall);
    return mContentViewSmall;
  }

  private RemoteViews getBigContentView() {
    if (mContentViewBig == null) {
      mContentViewBig = new RemoteViews(getPackageName(), R.layout.remote_view_music_player);
      setUpRemoteView(mContentViewBig);
    }
    updateRemoteViews(mContentViewBig);
    return mContentViewBig;
  }

  private void setUpRemoteView(RemoteViews remoteView) {
    remoteView.setImageViewResource(R.id.image_view_close, R.drawable.ic_remote_view_close);
    remoteView.setImageViewResource(R.id.image_view_play_last, R.drawable.ic_remote_view_play_last);
    remoteView.setImageViewResource(R.id.image_view_play_next, R.drawable.ic_remote_view_play_next);

    remoteView.setOnClickPendingIntent(R.id.button_close, getPendingIntent(ACTION_STOP_SERVICE));
    remoteView.setOnClickPendingIntent(R.id.button_play_last, getPendingIntent(ACTION_PLAY_LAST));
    remoteView.setOnClickPendingIntent(R.id.button_play_next, getPendingIntent(ACTION_PLAY_NEXT));
    remoteView.setOnClickPendingIntent(R.id.button_play_toggle, getPendingIntent(ACTION_PLAY_TOGGLE));
  }

  private void updateRemoteViews(RemoteViews remoteView) {
    remoteView.setImageViewResource(R.id.image_view_play_toggle, isPlaying()
                                    ? R.drawable.ic_remote_view_pause : R.drawable.ic_remote_view_play);

  }

  // PendingIntent

  private PendingIntent getPendingIntent(String action) {
    return PendingIntent.getService(this, 0, new Intent(action), 0);
  }
}

其中remoteViews用来显示通知栏中的播放状态，设置播放的icon等。

AudioDetailActivity类同样注册callback，实现其中的回调方法，同时用bindService的方法和service通信，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
public class AudioDetailActivity extends BaseActivity implements DetailContract.View, ObservableScrollViewCallbacks, IPlayback.Callback {
  private PlaybackService playbackService;

  private ServiceConnection connection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
      playbackService = ((PlaybackService.LocalBinder) iBinder).getService();
      register();
    }

    @Override
    public void onServiceDisconnected(ComponentName componentName) {
      unRegister();
      playbackService = null;
    }
  };

  private void register() {
    playbackService.registerCallback(this);
  }

  private void unRegister() {
    if (playbackService != null) {
      playbackService.unregisterCallback(this);
    }
  }

  @Override
  protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_audio);
    ButterKnife.bind(this);
    initView();
    initPresenter();
    bindPlaybackService();
  }

  private void initView() {
    setSupportActionBar(toolBar);
    ActionBar actionBar = getSupportActionBar();
    actionBar.setDisplayHomeAsUpEnabled(true);
    actionBar.setTitle("");
    toolBar.setNavigationOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View view) {
        onBackPressed();
      }
    });
    toolBar.setBackgroundColor(ScrollUtils.getColorWithAlpha(0, getResources().getColor(R.color.primary)));
    scrollView.setScrollViewCallbacks(this);
    mParallaxImageHeight = getResources().getDimensionPixelSize(R.dimen.parallax_image_height);
    seekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
      @Override
      public void onProgressChanged(SeekBar seekBar, int i, boolean b) {

      }

      @Override
      public void onStartTrackingTouch(SeekBar seekBar) {

      }

      @Override
      public void onStopTrackingTouch(SeekBar seekBar) {
        playbackService.seekTo(getSeekDuration(seekBar.getProgress()));
      }
    });
  }

  private int getSeekDuration(int progress) {
    return (int) (getCurrentSongDuration() * ((float) progress / seekBar.getMax()));
  }

  private int getCurrentSongDuration() {
    int duration=0;
    if (playbackService != null){
      duration = playbackService.getDuration();
    }
    return duration;
  }

  @Override
  protected void onStart() {
    super.onStart();
    Bundle bundle = getIntent().getExtras();
    Item item = bundle.getParcelable("item");
    if (item != null) {
      GlideApp.with(this).load(item.getThumbnail()).centerCrop().into(image);
      newsTopImgUnderLine.setVisibility(View.VISIBLE);
      newsTopType.setText("音 频");
      newsTopDate.setText(item.getUpdate_time());
      newsTopTitle.setText(item.getTitle());
      newsTopAuthor.setText(item.getAuthor());
      newsTopLead.setText(item.getLead());
      newsTopLead.setLineSpacing(1.5f, 1.8f);
      presenter.getDetail(item.getId());
    }
  }

  private void initPresenter() {
    DaggerDetailComponent.builder()
      .netComponent(OwspaceApplication.get(this).getNetComponent())
      .detailModule(new DetailModule(this))
      .build()
      .inject(this);
  }

  private void bindPlaybackService() {
    this.bindService(new Intent(this, PlaybackService.class), connection, Context.BIND_AUTO_CREATE);
  }

  @Override
  public void showLoading() {

  }

  @Override
  public void dismissLoading() {

  }

  String song;

  @Override
  public void updateListUI(DetailEntity detailEntity) {
    song = detailEntity.getFm();
    if (detailEntity.getParseXML() == 1) {
      int i = detailEntity.getLead().trim().length();
      AnalysizeHTML analysisHTML = new AnalysizeHTML();
      analysisHTML.loadHtml(this, detailEntity.getContent(), analysisHTML.HTML_STRING, newsParseWeb, i);
      newsTopType.setText("音 频");
    }
    else {
      initWebViewSetting();
      newsParseWeb.setVisibility(View.GONE);
      image.setVisibility(View.GONE);
      webView.setVisibility(View.VISIBLE);
      newsTop.setVisibility(View.GONE);
      webView.loadUrl(addParams2WezeitUrl(detailEntity.getHtml5(), false));
    }
  }

  private void initWebViewSetting() {
    WebSettings localWebSettings = this.webView.getSettings();
    localWebSettings.setRenderPriority(WebSettings.RenderPriority.HIGH);
    localWebSettings.setJavaScriptEnabled(true);
    localWebSettings.setSupportZoom(true);
    webView.setScrollBarStyle(View.SCROLLBARS_OUTSIDE_OVERLAY);
    localWebSettings.setUseWideViewPort(true);
    localWebSettings.setLoadWithOverviewMode(true);
  }

  public String addParams2WezeitUrl(String url, boolean paramBoolean) {
    StringBuffer localStringBuffer = new StringBuffer();
    localStringBuffer.append(url);
    localStringBuffer.append("?client=android");
    localStringBuffer.append("&device_id=" + AppUtil.getDeviceId(this));
    localStringBuffer.append("&version=" + "1.3.0");
    if (paramBoolean)
      localStringBuffer.append("&show_video=0");
    else {
      localStringBuffer.append("&show_video=1");
    }
    return localStringBuffer.toString();
  }

  @Override
  protected void onDestroy() {
    unRegister();
    handleProgress.removeCallbacks(runnable);
    super.onDestroy();
  }

  Handler handleProgress = new Handler();

  Runnable runnable = new Runnable() {
    @Override
    public void run() {
      if (playbackService.isPlaying()) {
        if (isFinishing()) {
          return;
        }
        int progress = (int) (seekBar.getMax()
                              * ((float) playbackService.getProgress() / (float) playbackService.getDuration()));
        updateProgressTextWithProgress(playbackService.getProgress());
        if (progress >= 0 && progress <= seekBar.getMax()) {
          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            seekBar.setProgress(progress, true);
          }
          else {
            seekBar.setProgress(progress);
          }
        }
      }
    }
  };

  private void updateProgressTextWithProgress(int progress) {
    textViewProgress.setText(TimeUtils.formatDuration(progress));
  }

  @Override
  public void showOnFailure() {

  }

  @Override
  public void onScrollChanged(int i, boolean b, boolean b1) {
    int baseColor = getResources().getColor(R.color.primary);
    float alpha = Math.min(1, (float) i / mParallaxImageHeight);
    toolBar.setBackgroundColor(ScrollUtils.getColorWithAlpha(alpha, baseColor));
  }

  @Override
  public void onDownMotionEvent() {

  }

  @Override
  public void onUpOrCancelMotionEvent(ScrollState scrollState) {

  }

  @OnClick(R.id.button_play_toggle)
  public void onClick() {
    if (playbackService == null || song == null) {
      Log.d("sunxinrong", "playBackService == null");
      return;
    }
    if (playbackService.isPlaying()) {
      if (song.equals(playbackService.getSong())) {
        playbackService.pause();
        buttonPlayToggle.setImageResource(R.drawable.ic_play);
      }
      else {
        playbackService.play(song);
        buttonPlayToggle.setImageResource(R.drawable.ic_pause);
      }
    }
    else {
      if (song.equals(playbackService.getSong())) {
        playbackService.play();
      }
      else {
        playbackService.play(song);
      }
      buttonPlayToggle.setImageResource(R.drawable.ic_pause);
    }
  }

  Timer timer = null;

  @Override
  public void onComplete(PlayState state) {
    cancelTimer();
  }

  private void cancelTimer() {
    if (timer != null) {
      timer.cancel();
    }
    timer = null;
  }

  @Override
  public void onPlayStatusChanged(PlayState status) {
    switch (status) {
      case INIT:
        break;
      case PREPARE:
        break;
      case PLAYING:
        updateDuration();
        playTimer();
        buttonPlayToggle.setImageResource(R.drawable.ic_pause);
        break;
      case ERROR:
        break;
      case COMPLETE:
        cancelTimer();
        buttonPlayToggle.setImageResource(R.drawable.ic_play);
        seekBar.setProgress(0);
        break;
    }
  }

  private void updateDuration() {
    textViewDuration.setText(TimeUtils.formatDuration(playbackService.getDuration()));
  }

  private void playTimer() {
    timer = new Timer();
    timer.schedule(new TimerTask() {
      @Override
      public void run() {
        if (playbackService == null) {
          return;
        }
        if (playbackService.isPlaying()) {
          handleProgress.post(runnable);
        }
      }
    }, 0, 1000);
  }

  @Override
  public void onPosition(int position) {

  }
}

在播放时seekBar的进度显示通过子线程控制，通过Handler和Runnable来实现。

1
handleProgress.post(runnable);
赏

谢谢你请我吃糖果

微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

<br><br><br>愿你我都被世界温柔以待<br><br>QQ:969406418<br>欢迎交流