LocalPlayer.java

1
/*
2
 * Copyright (C) 2013 The Android Open Source Project
3
 *
4
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 * you may not use this file except in compliance with the License.
6
 * You may obtain a copy of the License at
7
 *
8
 *      http://www.apache.org/licenses/LICENSE-2.0
9
 *
10
 * Unless required by applicable law or agreed to in writing, software
11
 * distributed under the License is distributed on an "AS IS" BASIS,
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 * See the License for the specific language governing permissions and
14
 * limitations under the License.
15
 */
16
 
17
package com.example.android.mediarouter.player;
18
 
19
import android.app.Activity;
20
import android.app.Presentation;
21
import android.content.Context;
22
import android.content.DialogInterface;
23
import android.media.MediaPlayer;
24
import android.os.Build;
25
import android.os.Bundle;
26
import android.os.Handler;
27
import android.os.SystemClock;
28
import android.support.v7.media.MediaItemStatus;
29
import android.support.v7.media.MediaRouter.RouteInfo;
30
import android.util.Log;
31
import android.view.Display;
32
import android.view.Gravity;
33
import android.view.Surface;
34
import android.view.SurfaceHolder;
35
import android.view.SurfaceView;
36
import android.view.View;
37
import android.view.ViewGroup;
38
import android.view.WindowManager;
39
import android.widget.FrameLayout;
40
 
41
import com.example.android.mediarouter.R;
42
 
43
import java.io.IOException;
44
 
45
/**
46
 * Handles playback of a single media item using MediaPlayer.
47
 */
48
public abstract class LocalPlayer extends Player implements
49
        MediaPlayer.OnPreparedListener,
50
        MediaPlayer.OnCompletionListener,
51
        MediaPlayer.OnErrorListener,
52
        MediaPlayer.OnSeekCompleteListener {
53
    private static final String TAG = "LocalPlayer";
54
    private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
55
 
56
    private static final int STATE_IDLE = 0;
57
    private static final int STATE_PLAY_PENDING = 1;
58
    private static final int STATE_READY = 2;
59
    private static final int STATE_PLAYING = 3;
60
    private static final int STATE_PAUSED = 4;
61
 
62
    private final Context mContext;
63
    private final Handler mHandler = new Handler();
64
    private MediaPlayer mMediaPlayer;
65
    private int mState = STATE_IDLE;
66
    private int mSeekToPos;
67
    private int mVideoWidth;
68
    private int mVideoHeight;
69
    private Surface mSurface;
70
    private SurfaceHolder mSurfaceHolder;
71
 
72
    public LocalPlayer(Context context) {
73
        mContext = context;
74
 
75
        // reset media player
76
        reset();
77
    }
78
 
79
    @Override
80
    public boolean isRemotePlayback() {
81
        return false;
82
    }
83
 
84
    @Override
85
    public boolean isQueuingSupported() {
86
        return false;
87
    }
88
 
89
    @Override
90
    public void connect(RouteInfo route) {
91
        if (DEBUG) {
92
            Log.d(TAG, "connecting to: " + route);
93
        }
94
    }
95
 
96
    @Override
97
    public void release() {
98
        if (DEBUG) {
99
            Log.d(TAG, "releasing");
100
        }
101
        // release media player
102
        if (mMediaPlayer != null) {
103
            mMediaPlayer.stop();
104
            mMediaPlayer.release();
105
            mMediaPlayer = null;
106
        }
107
    }
108
 
109
    // Player
110
    @Override
111
    public void play(final PlaylistItem item) {
112
        if (DEBUG) {
113
            Log.d(TAG, "play: item=" + item);
114
        }
115
        reset();
116
        mSeekToPos = (int)item.getPosition();
117
        try {
118
            mMediaPlayer.setDataSource(mContext, item.getUri());
119
            mMediaPlayer.prepareAsync();
120
        } catch (IllegalStateException e) {
121
            Log.e(TAG, "MediaPlayer throws IllegalStateException, uri=" + item.getUri());
122
        } catch (IOException e) {
123
            Log.e(TAG, "MediaPlayer throws IOException, uri=" + item.getUri());
124
        } catch (IllegalArgumentException e) {
125
            Log.e(TAG, "MediaPlayer throws IllegalArgumentException, uri=" + item.getUri());
126
        } catch (SecurityException e) {
127
            Log.e(TAG, "MediaPlayer throws SecurityException, uri=" + item.getUri());
128
        }
129
        if (item.getState() == MediaItemStatus.PLAYBACK_STATE_PLAYING) {
130
            resume();
131
        } else {
132
            pause();
133
        }
134
    }
135
 
136
    @Override
137
    public void seek(final PlaylistItem item) {
138
        if (DEBUG) {
139
            Log.d(TAG, "seek: item=" + item);
140
        }
141
        int pos = (int)item.getPosition();
142
        if (mState == STATE_PLAYING || mState == STATE_PAUSED) {
143
            mMediaPlayer.seekTo(pos);
144
            mSeekToPos = pos;
145
        } else if (mState == STATE_IDLE || mState == STATE_PLAY_PENDING) {
146
            // Seek before onPrepared() arrives,
147
            // need to performed delayed seek in onPrepared()
148
            mSeekToPos = pos;
149
        }
150
    }
151
 
152
    @Override
153
    public void getStatus(final PlaylistItem item, final boolean update) {
154
        if (mState == STATE_PLAYING || mState == STATE_PAUSED) {
155
            // use mSeekToPos if we're currently seeking (mSeekToPos is reset
156
            // when seeking is completed)
157
            item.setDuration(mMediaPlayer.getDuration());
158
            item.setPosition(mSeekToPos > 0 ?
159
                    mSeekToPos : mMediaPlayer.getCurrentPosition());
160
            item.setTimestamp(SystemClock.elapsedRealtime());
161
        }
162
        if (update && mCallback != null) {
163
            mCallback.onPlaylistReady();
164
        }
165
    }
166
 
167
    @Override
168
    public void pause() {
169
        if (DEBUG) {
170
            Log.d(TAG, "pause");
171
        }
172
        if (mState == STATE_PLAYING) {
173
            mMediaPlayer.pause();
174
            mState = STATE_PAUSED;
175
        }
176
    }
177
 
178
    @Override
179
    public void resume() {
180
        if (DEBUG) {
181
            Log.d(TAG, "resume");
182
        }
183
        if (mState == STATE_READY || mState == STATE_PAUSED) {
184
            mMediaPlayer.start();
185
            mState = STATE_PLAYING;
186
        } else if (mState == STATE_IDLE){
187
            mState = STATE_PLAY_PENDING;
188
        }
189
    }
190
 
191
    @Override
192
    public void stop() {
193
        if (DEBUG) {
194
            Log.d(TAG, "stop");
195
        }
196
        if (mState == STATE_PLAYING || mState == STATE_PAUSED) {
197
            mMediaPlayer.stop();
198
            mState = STATE_IDLE;
199
        }
200
    }
201
 
202
    @Override
203
    public void enqueue(final PlaylistItem item) {
204
        throw new UnsupportedOperationException("LocalPlayer doesn't support enqueue!");
205
    }
206
 
207
    @Override
208
    public PlaylistItem remove(String iid) {
209
        throw new UnsupportedOperationException("LocalPlayer doesn't support remove!");
210
    }
211
 
212
    //MediaPlayer Listeners
213
    @Override
214
    public void onPrepared(MediaPlayer mp) {
215
        if (DEBUG) {
216
            Log.d(TAG, "onPrepared");
217
        }
218
        mHandler.post(new Runnable() {
219
            @Override
220
            public void run() {
221
                if (mState == STATE_IDLE) {
222
                    mState = STATE_READY;
223
                    updateVideoRect();
224
                } else if (mState == STATE_PLAY_PENDING) {
225
                    mState = STATE_PLAYING;
226
                    updateVideoRect();
227
                    if (mSeekToPos > 0) {
228
                        if (DEBUG) {
229
                            Log.d(TAG, "seek to initial pos: " + mSeekToPos);
230
                        }
231
                        mMediaPlayer.seekTo(mSeekToPos);
232
                    }
233
                    mMediaPlayer.start();
234
                }
235
                if (mCallback != null) {
236
                    mCallback.onPlaylistChanged();
237
                }
238
            }
239
        });
240
    }
241
 
242
    @Override
243
    public void onCompletion(MediaPlayer mp) {
244
        if (DEBUG) {
245
            Log.d(TAG, "onCompletion");
246
        }
247
        mHandler.post(new Runnable() {
248
            @Override
249
            public void run() {
250
                if (mCallback != null) {
251
                    mCallback.onCompletion();
252
                }
253
            }
254
        });
255
    }
256
 
257
    @Override
258
    public boolean onError(MediaPlayer mp, int what, int extra) {
259
        if (DEBUG) {
260
            Log.d(TAG, "onError");
261
        }
262
        mHandler.post(new Runnable() {
263
            @Override
264
            public void run() {
265
                if (mCallback != null) {
266
                    mCallback.onError();
267
                }
268
            }
269
        });
270
        // return true so that onCompletion is not called
271
        return true;
272
    }
273
 
274
    @Override
275
    public void onSeekComplete(MediaPlayer mp) {
276
        if (DEBUG) {
277
            Log.d(TAG, "onSeekComplete");
278
        }
279
        mHandler.post(new Runnable() {
280
            @Override
281
            public void run() {
282
                mSeekToPos = 0;
283
                if (mCallback != null) {
284
                    mCallback.onPlaylistChanged();
285
                }
286
            }
287
        });
288
    }
289
 
290
    protected Context getContext() { return mContext; }
291
    protected MediaPlayer getMediaPlayer() { return mMediaPlayer; }
292
    protected int getVideoWidth() { return mVideoWidth; }
293
    protected int getVideoHeight() { return mVideoHeight; }
294
    protected void setSurface(Surface surface) {
295
        mSurface = surface;
296
        mSurfaceHolder = null;
297
        updateSurface();
298
    }
299
 
300
    protected void setSurface(SurfaceHolder surfaceHolder) {
301
        mSurface = null;
302
        mSurfaceHolder = surfaceHolder;
303
        updateSurface();
304
    }
305
 
306
    protected void removeSurface(SurfaceHolder surfaceHolder) {
307
        if (surfaceHolder == mSurfaceHolder) {
308
            setSurface((SurfaceHolder)null);
309
        }
310
    }
311
 
312
    protected void updateSurface() {
313
        if (mMediaPlayer == null) {
314
            // just return if media player is already gone
315
            return;
316
        }
317
        if (mSurface != null) {
318
            // The setSurface API does not exist until V14+.
319
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
320
                ICSMediaPlayer.setSurface(mMediaPlayer, mSurface);
321
            } else {
322
                throw new UnsupportedOperationException("MediaPlayer does not support "
323
                        + "setSurface() on this version of the platform.");
324
            }
325
        } else if (mSurfaceHolder != null) {
326
            mMediaPlayer.setDisplay(mSurfaceHolder);
327
        } else {
328
            mMediaPlayer.setDisplay(null);
329
        }
330
    }
331
 
332
    protected abstract void updateSize();
333
 
334
    private void reset() {
335
        if (mMediaPlayer != null) {
336
            mMediaPlayer.stop();
337
            mMediaPlayer.release();
338
            mMediaPlayer = null;
339
        }
340
        mMediaPlayer = new MediaPlayer();
341
        mMediaPlayer.setOnPreparedListener(this);
342
        mMediaPlayer.setOnCompletionListener(this);
343
        mMediaPlayer.setOnErrorListener(this);
344
        mMediaPlayer.setOnSeekCompleteListener(this);
345
        updateSurface();
346
        mState = STATE_IDLE;
347
        mSeekToPos = 0;
348
    }
349
 
350
    private void updateVideoRect() {
351
        if (mState != STATE_IDLE && mState != STATE_PLAY_PENDING) {
352
            int width = mMediaPlayer.getVideoWidth();
353
            int height = mMediaPlayer.getVideoHeight();
354
            if (width > 0 && height > 0) {
355
                mVideoWidth = width;
356
                mVideoHeight = height;
357
                updateSize();
358
            } else {
359
                Log.e(TAG, "video rect is 0x0!");
360
                mVideoWidth = mVideoHeight = 0;
361
            }
362
        }
363
    }
364
 
365
    private static final class ICSMediaPlayer {
366
        public static final void setSurface(MediaPlayer player, Surface surface) {
367
            player.setSurface(surface);
368
        }
369
    }
370
 
371
    /**
372
     * Handles playback of a single media item using MediaPlayer in SurfaceView
373
     */
374
    public static class SurfaceViewPlayer extends LocalPlayer implements
375
            SurfaceHolder.Callback {
376
        private static final String TAG = "SurfaceViewPlayer";
377
        private RouteInfo mRoute;
378
        private final SurfaceView mSurfaceView;
379
        private final FrameLayout mLayout;
380
        private DemoPresentation mPresentation;
381
 
382
        public SurfaceViewPlayer(Context context) {
383
            super(context);
384
 
385
            mLayout = (FrameLayout)((Activity)context).findViewById(R.id.player);
386
            mSurfaceView = (SurfaceView)((Activity)context).findViewById(R.id.surface_view);
387
 
388
            // add surface holder callback
389
            SurfaceHolder holder = mSurfaceView.getHolder();
390
            holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
391
            holder.addCallback(this);
392
        }
393
 
394
        @Override
395
        public void connect(RouteInfo route) {
396
            super.connect(route);
397
            mRoute = route;
398
        }
399
 
400
        @Override
401
        public void release() {
402
            super.release();
403
 
404
            // dismiss presentation display
405
            if (mPresentation != null) {
406
                Log.i(TAG, "Dismissing presentation because the activity is no longer visible.");
407
                mPresentation.dismiss();
408
                mPresentation = null;
409
            }
410
 
411
            // remove surface holder callback
412
            SurfaceHolder holder = mSurfaceView.getHolder();
413
            holder.removeCallback(this);
414
 
415
            // hide the surface view when SurfaceViewPlayer is destroyed
416
            mSurfaceView.setVisibility(View.GONE);
417
            mLayout.setVisibility(View.GONE);
418
        }
419
 
420
        @Override
421
        public void updatePresentation() {
422
            // Get the current route and its presentation display.
423
            Display presentationDisplay = mRoute != null ? mRoute.getPresentationDisplay() : null;
424
 
425
            // Dismiss the current presentation if the display has changed.
426
            if (mPresentation != null && mPresentation.getDisplay() != presentationDisplay) {
427
                Log.i(TAG, "Dismissing presentation because the current route no longer "
428
                        + "has a presentation display.");
429
                mPresentation.dismiss();
430
                mPresentation = null;
431
            }
432
 
433
            // Show a new presentation if needed.
434
            if (mPresentation == null && presentationDisplay != null) {
435
                Log.i(TAG, "Showing presentation on display: " + presentationDisplay);
436
                mPresentation = new DemoPresentation(getContext(), presentationDisplay);
437
                mPresentation.setOnDismissListener(mOnDismissListener);
438
                try {
439
                    mPresentation.show();
440
                } catch (WindowManager.InvalidDisplayException ex) {
441
                    Log.w(TAG, "Couldn't show presentation!  Display was removed in "
442
                              + "the meantime.", ex);
443
                    mPresentation = null;
444
                }
445
            }
446
 
447
            updateContents();
448
        }
449
 
450
        // SurfaceHolder.Callback
451
        @Override
452
        public void surfaceChanged(SurfaceHolder holder, int format,
453
                int width, int height) {
454
            if (DEBUG) {
455
                Log.d(TAG, "surfaceChanged: " + width + "x" + height);
456
            }
457
            setSurface(holder);
458
        }
459
 
460
        @Override
461
        public void surfaceCreated(SurfaceHolder holder) {
462
            if (DEBUG) {
463
                Log.d(TAG, "surfaceCreated");
464
            }
465
            setSurface(holder);
466
            updateSize();
467
        }
468
 
469
        @Override
470
        public void surfaceDestroyed(SurfaceHolder holder) {
471
            if (DEBUG) {
472
                Log.d(TAG, "surfaceDestroyed");
473
            }
474
            removeSurface(holder);
475
        }
476
 
477
        @Override
478
        protected void updateSize() {
479
            int width = getVideoWidth();
480
            int height = getVideoHeight();
481
            if (width > 0 && height > 0) {
482
                if (mPresentation == null) {
483
                    int surfaceWidth = mLayout.getWidth();
484
                    int surfaceHeight = mLayout.getHeight();
485
 
486
                    // Calculate the new size of mSurfaceView, so that video is centered
487
                    // inside the framelayout with proper letterboxing/pillarboxing
488
                    ViewGroup.LayoutParams lp = mSurfaceView.getLayoutParams();
489
                    if (surfaceWidth * height < surfaceHeight * width) {
490
                        // Black bars on top&bottom, mSurfaceView has full layout width,
491
                        // while height is derived from video's aspect ratio
492
                        lp.width = surfaceWidth;
493
                        lp.height = surfaceWidth * height / width;
494
                    } else {
495
                        // Black bars on left&right, mSurfaceView has full layout height,
496
                        // while width is derived from video's aspect ratio
497
                        lp.width = surfaceHeight * width / height;
498
                        lp.height = surfaceHeight;
499
                    }
500
                    Log.i(TAG, "video rect is " + lp.width + "x" + lp.height);
501
                    mSurfaceView.setLayoutParams(lp);
502
                } else {
503
                    mPresentation.updateSize(width, height);
504
                }
505
            }
506
        }
507
 
508
        private void updateContents() {
509
            // Show either the content in the main activity or the content in the presentation
510
            if (mPresentation != null) {
511
                mLayout.setVisibility(View.GONE);
512
                mSurfaceView.setVisibility(View.GONE);
513
            } else {
514
                mLayout.setVisibility(View.VISIBLE);
515
                mSurfaceView.setVisibility(View.VISIBLE);
516
            }
517
        }
518
 
519
        // Listens for when presentations are dismissed.
520
        private final DialogInterface.OnDismissListener mOnDismissListener =
521
                new DialogInterface.OnDismissListener() {
522
            @Override
523
            public void onDismiss(DialogInterface dialog) {
524
                if (dialog == mPresentation) {
525
                    Log.i(TAG, "Presentation dismissed.");
526
                    mPresentation = null;
527
                    updateContents();
528
                }
529
            }
530
        };
531
 
532
        // Presentation
533
        private final class DemoPresentation extends Presentation {
534
            private SurfaceView mPresentationSurfaceView;
535
 
536
            public DemoPresentation(Context context, Display display) {
537
                super(context, display);
538
            }
539
 
540
            @Override
541
            protected void onCreate(Bundle savedInstanceState) {
542
                // Be sure to call the super class.
543
                super.onCreate(savedInstanceState);
544
 
545
                // Inflate the layout.
546
                setContentView(R.layout.sample_media_router_presentation);
547
 
548
                // Set up the surface view.
549
                mPresentationSurfaceView = (SurfaceView)findViewById(R.id.surface_view);
550
                SurfaceHolder holder = mPresentationSurfaceView.getHolder();
551
                holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
552
                holder.addCallback(SurfaceViewPlayer.this);
553
                Log.i(TAG, "Presentation created");
554
            }
555
 
556
            public void updateSize(int width, int height) {
557
                int surfaceHeight = getWindow().getDecorView().getHeight();
558
                int surfaceWidth = getWindow().getDecorView().getWidth();
559
                ViewGroup.LayoutParams lp = mPresentationSurfaceView.getLayoutParams();
560
                if (surfaceWidth * height < surfaceHeight * width) {
561
                    lp.width = surfaceWidth;
562
                    lp.height = surfaceWidth * height / width;
563
                } else {
564
                    lp.width = surfaceHeight * width / height;
565
                    lp.height = surfaceHeight;
566
                }
567
                Log.i(TAG, "Presentation video rect is " + lp.width + "x" + lp.height);
568
                mPresentationSurfaceView.setLayoutParams(lp);
569
            }
570
        }
571
    }
572
 
573
    /**
574
     * Handles playback of a single media item using MediaPlayer in
575
     * OverlayDisplayWindow.
576
     */
577
    public static class OverlayPlayer extends LocalPlayer implements
578
            OverlayDisplayWindow.OverlayWindowListener {
579
        private static final String TAG = "OverlayPlayer";
580
        private final OverlayDisplayWindow mOverlay;
581
 
582
        public OverlayPlayer(Context context) {
583
            super(context);
584
 
585
            mOverlay = OverlayDisplayWindow.create(getContext(),
586
                    getContext().getResources().getString(
587
                            R.string.sample_media_route_provider_remote),
588
                    1024, 768, Gravity.CENTER);
589
 
590
            mOverlay.setOverlayWindowListener(this);
591
        }
592
 
593
        @Override
594
        public void connect(RouteInfo route) {
595
            super.connect(route);
596
            mOverlay.show();
597
        }
598
 
599
        @Override
600
        public void release() {
601
            super.release();
602
            mOverlay.dismiss();
603
        }
604
 
605
        @Override
606
        protected void updateSize() {
607
            int width = getVideoWidth();
608
            int height = getVideoHeight();
609
            if (width > 0 && height > 0) {
610
                mOverlay.updateAspectRatio(width, height);
611
            }
612
        }
613
 
614
        // OverlayDisplayWindow.OverlayWindowListener
615
        @Override
616
        public void onWindowCreated(Surface surface) {
617
            setSurface(surface);
618
        }
619
 
620
        @Override
621
        public void onWindowCreated(SurfaceHolder surfaceHolder) {
622
            setSurface(surfaceHolder);
623
        }
624
 
625
        @Override
626
        public void onWindowDestroyed() {
627
            setSurface((SurfaceHolder)null);
628
        }
629
    }
630
}