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 @Overri de 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 (mSt ate != 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 }