1 /* 2 * Copyright (C) 2012 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.content.Context; 20 import android.graphics.SurfaceTexture; 21 import android.hardware.display.DisplayManager; 22 import android.os.Build; 23 import android.util.DisplayMetrics; 24 import android.util.Log; 25 import android.view.Display; 26 import android.view.GestureDetector; 27 import android.view.Gravity; 28 import android.view.LayoutInflater; 29 import android.view.MotionEvent; 30 import android.view.ScaleGestureDetector; 31 import android.view.Surface; 32 import android.view.SurfaceHolder; 33 import android.view.SurfaceView; 34 import android.view.TextureView; 35 import android.view.TextureView.SurfaceTextureListener; 36 import android.view.View; 37 import android.view.WindowManager; 38 import android.widget.TextView; 39 40 import com.example.android.mediarouter.R; 41 42 /** 43 * Manages an overlay display window, used for simulating remote playback. 44 */ 45 public abstract class OverlayDisplayWindow { 46 private static final String TAG = "OverlayDisplayWindow"; 47 private static final boolean DEBUG = false; 48 49 private static final float WINDOW_ALPHA = 0.8f; 50 private static final float INITIAL_SCALE = 0.5f; 51 private static final float MIN_SCALE = 0.3f; 52 private static final float MAX_SCALE = 1.0f; 53 54 protected final Context mContext; 55 protected final String mName; 56 protected final int mWidth; 57 protected final int mHeight; 58 protected final int mGravity; 59 protected OverlayWindowListener mListener; 60 61 protected OverlayDisplayWindow(Context context, String name, 62 int width, int height, int gravity) { 63 mContext = context; 64 mName = name; 65 mWidth = width; 66 mHeight = height; 67 mGravity = gravity; 68 } 69 70 public static OverlayDisplayWindow create(Context context, String name, 71 int width, int height, int gravity) { 72 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) { 73 return new JellybeanMr1Impl(context, name, width, height, gravity); 74 } else { 75 return new LegacyImpl(context, name, width, height, gravity); 76 } 77 } 78 79 public void setOverlayWindowListener(OverlayWindowListener listener) { 80 mListener = listener; 81 } 82 83 public Context getContext() { 84 return mContext; 85 } 86 87 public abstract void show(); 88 89 public abstract void dismiss(); 90 91 public abstract void updateAspectRatio(int width, int height); 92 93 // Watches for significant changes in the overlay display window lifecycle. 94 public interface OverlayWindowListener { 95 public void onWindowCreated(Surface surface); 96 public void onWindowCreated(SurfaceHolder surfaceHolder); 97 public void onWindowDestroyed(); 98 } 99 100 /** 101 * Implementation for older versions. 102 */ 103 private static final class LegacyImpl extends OverlayDisplayWindow { 104 private final WindowManager mWindowManager; 105 106 private boolean mWindowVisible; 107 private SurfaceView mSurfaceView; 108 109 public LegacyImpl(Context context, String name, 110 int width, int height, int gravity) { 111 super(context, name, width, height, gravity); 112 113 mWindowManager = (WindowManager)context.getSystemService( 114 Context.WINDOW_SERVICE); 115 } 116 117 @Override 118 public void show() { 119 if (!mWindowVisible) { 120 mSurfaceView = new SurfaceView(mContext); 121 122 Display display = mWindowManager.getDefaultDisplay(); 123 124 Wi ndowManager.LayoutParams params = new WindowManager.LayoutParams( 125 WindowManager.LayoutParams.TYPE_SYSTEM_ALERT); 126 params.flags |= WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN 127 | WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS 128 | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE 129 | WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL 130 | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE; 131 params.alpha = WINDOW_ALPHA; 132 params.gravity = Gravity.LEFT | Gravity.BOTTOM; 133 params.setTitle(mName); 134 135 int width = (int)(display.getWidth() * INITIAL_SCALE); 136 int height = (int)(display.getHeight() * INITIAL_SCALE); 137 if (mWidth > mHeight) { 138 height = mHeight * width / mWidth; 139 } else { 140 width = mWidth * height / mHeight; 141 } 142 params.width = width; 143 params.height = height; 144 145 mWindowManager.addView(mSurfaceView, params); 146 mWindowVisible = true; 147 148 SurfaceHolder holder = mSurfaceView.getHolder(); 149 holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS); 150 mListener.onWindowCreated(holder); 151 } 152 } 153 154 @Override 155 public void dismiss() { 156 if (mWindowVisible) { 157 mListener.onWindowDestroyed(); 158 159 mWindowManager.removeView(mSurfaceView); 160 mWindowVisible = false; 161 } 162 } 163 164 @Override 165 public void updateAspectRatio(int width, int height) { 166 } 167 } 168 169 /** 170 * Implementation for API version 17+. 171 */ 172 private static final class JellybeanMr1Impl extends OverlayDisplayWindow { 173 // When true, disables support for moving and resizing the overlay. 174 // The window is made non-touchable, which makes it possible to 175 // directly interact with the content underneath. 176 private static final boolean DISABLE_MOVE_AND_RESIZE = false; 177 178 private final DisplayManager mDisplayManager; 179 private final WindowManager mWindowManager; 180 181 private final Display mDefaultDisplay; 182 private final DisplayMetrics mDefaultDisplayMetrics = new DisplayMetrics(); 183 184 private View mWindowContent; 185 private WindowManager.LayoutParams mWindowParams; 186 private TextureView mTextureView; 187 private TextView mNameTextView; 188 189 private GestureDetector mGestureDetector; 190 private ScaleGestureDetector mScaleGestureDetector; 191 192 private boolean mWindowVisible; 193 private int mWindowX; 194 private int mWindowY; 195 private float mWindowScale; 196 197 private float mLiveTranslationX; 198 private float mLiveTranslationY; 199 private float mLiveScale = 1.0f; 200 201 public JellybeanMr1Impl(Context context, String name, 202 int width, int height, int gravity) { 203 super(context, name, width, height, gravity); 204 205 mDisplayManager = (DisplayManager)context.getSystemService( 206 Context.DISPLAY_SERVICE); 207 mWindowManager = (WindowManager)context.getSystemService( 208 Context.WINDOW_SERVICE); 209 210 mDefaultDisplay = mWindowManager.getDefaultDisplay(); 211 updateDefaultDisplayInfo(); 212 213 createWindow(); 214 } 215 216 @Override 217 public void show() { 218 if (!mWindowVisible) { 219 mDisplayManager.registerDisplayListener(mDisplayListener, null); 220 if (!updateDefaultDisplayInfo()) { 221 mDisplayManager.unregisterDisplayListener(mDisplayListener); 222 return; 223 } 224 225 clearLiveState(); 226 updateWindowParams(); 227 mWindowManager.addView(mWindowContent, mWindowParams); 228 mWindowVisible = true; 229 } 230 } 231 232 @Override 233 public void dismiss() { 234 if (mWindowVisible) { 235 mDisplayManager.unregisterDisplayListener(mDisplayListener); 236 mWindowManager.removeView(mWindowContent); 237 mWindowVisible = false; 238 } 239 } 240 241 @Override 242 public void updateAspectRatio(int width, int height) { 243 if (mWidth * height < mHeight * width) { 244 mTextureView.getLayoutParams().width = mWidth; 245 mTextureView.getLayoutParams().height = mWidth * height / width; 246 } else { 247 mTextureView.getLayoutParams().width = mHeight * width / height; 248 mTextureView.getLayoutParams().height = mHeight; 249 } 250 relayout(); 251 } 252 253 private void relayout() { 254 if (mWindowVisible) { 255 updateWindowParams(); 256 mWindowManager.updateViewLayout(mWindowContent, mWindowParams); 257 } 258 } 259 260 private boolean updateDefaultDisplayInfo() { 261 mDefaultDisplay.getMetrics(mDefaultDisplayMetrics); 262 return true; 263 } 264 265 private vo id createWindow() { 266 LayoutInflater inflater = LayoutInflater.from(mContext); 267 268 mWindowContent = inflater.inflate( 269 R.layout.overlay_display_window, null); 270 mWindowContent.setOnTouchListener(mOnTouchListener); 271 272 mTextureView = (TextureView)mWindowContent.findViewById( 273 R.id.overlay_display_window_texture); 274 mTextureView.setPivotX(0); 275 mTextureView.setPivotY(0); 276 mTextureView.getLayoutParams().width = mWidth; 277 mTextureView.getLayoutParams().height = mHeight; 278 mTextureView.setOpaque(false); 279 mTextureView.setSurfaceTextureListener(mSurfaceTextureListener); 280 281 mNameTextView = (TextView)mWindowContent.findViewById( 282 R.id.overlay_display_window_title); 283 mNameTextView.setText(mName); 284 285 mWindowParams = new WindowManager.LayoutParams( 286 WindowManager.LayoutParams.TYPE_SYSTEM_ALERT); 287 mWindowParams.flags |= WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN 288 | WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS 289 | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE 290 | WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL 291 | WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED; 292 if (DISABLE_MOVE_AND_RESIZE) { 293 mWindowParams.flags |= WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE; 294 } 295 mWindowParams.alpha = WINDOW_ALPHA; 296 mWindowParams.gravity = Gravity.TOP | Gravity.LEFT; 297 mWindowParams.setTitle(mName); 298 299 mGestureDetector = new GestureDetector(mContext, mOnGestureListener); 300 mScaleGestureDetector = new ScaleGestureDetector(mContext, mOnScaleGestureListener); 301 302 // Set the initial position and scale. 303 // The position and scale will be clamped when the display is first shown. 304 mWindowX = (mGravity & Gravity.LEFT) == Gravity.LEFT ? 305 0 : mDefaultDisplayMetrics.widthPixels; 306 mWindowY = (mGravity & Gravity.TOP) == Gravity.TOP ? 307 0 : mDefaultDisplayMetrics.heightPixels; 308 Log.d(TAG, mDefaultDisplayMetrics.toString()); 309 mWindowScale = INITIAL_SCALE; 310 311 // calculate and save initial settings 312 updateWindowParams(); 313 saveWindowParams(); 314 } 315 316 private void updateWindowParams() { 317 float scale = mWindowScale * mLiveScale; 318 scale = Math.min(scale, (float)mDefaultDisplayMetrics.widthPixels / mWidth); 319 scale = Math.min(scale, (float)mDefaultDisplayMetrics.heightPixels / mHeight); 320 scale = Math.max(MIN_SCALE, Math.min(MAX_SCALE, scale)); 321 322 float offsetScale = (scale / mWindowScale - 1.0f) * 0.5f; 323 int width = (int)(mWidth * scale); 324 int height = (int)(mHeight * scale); 325 int x = (int)(mWindowX + mLiveTranslationX - width * offsetScale); 326 int y = (int)(mWindowY + mLiveTranslationY - height * offsetScale); 327 x = Math.max(0, Math.min(x, mDefaultDisplayMetrics.widthPixels - width)); 328 y = Math.max(0, Math.min(y, mDefaultDisplayMetrics.heightPixels - height)); 329 330 if (DEBUG) { 331 Log.d(TAG, "updateWindowParams: scale=" + scale 332 + ", offsetScale=" + offsetScale 333 + ", x=" + x + ", y=" + y 334 + ", width=" + width + ", height=" + height); 335 } 336 337 mTextureView.setScaleX(scale); 338 mTextureView.setScaleY(scale); 339 340 mTextureView.setTranslationX( 341 (mWidth - mTextureView.getLayoutParams().width) * scale / 2); 342 mTextureView.setTranslationY( 343 (mHeight - mTextureView.getLayoutParams().height) * scale / 2); 344 345 mWindowParams.x = x; 346 mWindowParams.y = y; 347 mWindowParams.width = width; 348 mWindowParams.height = height; 349 } 350 351 private void saveWindowParams() { 352 mWindowX = mWindowParams.x; 353 mWindowY = mWindowParams.y; 354 mWindowScale = mTextureView.getScaleX(); 355 clearLiveState(); 356 } 357 358 private void clearLiveState() { 359 mLiveTranslationX = 0f; 360 mLiveTranslationY = 0f; 361 mLiveScale = 1.0f; 362 } 363 364 private final DisplayManager.DisplayListener mDisplayListener = 365 new DisplayManager.DisplayListener() { 366 @Override 367 public void onDisplayAdded(int displayId) { 368 } 369 370 @Override 371 public void onDisplayChanged(int displayId) { 372 if (displayId == mDefaultDisplay.getDisplayId()) { 373 if (updateDefaultDisplayInfo()) { 374 relayout(); 375 } else { 376 dismiss(); 377 } 378 } 379 } 380 381 @Override 382 public void onDisplayRemoved(int displayId) { 383 if (displayId == mDefaultDisplay.getDisplayId()) { 384 dismiss(); 385 } 386 } 387 }; 388 389 private final SurfaceTextureListener mSurfaceTextureListener = 390 new SurfaceTextureListener() { 391 @Override 392 public void onSurfaceTextureAvailable(SurfaceTexture surfaceTexture, 393 int width, int height) { 394 if (mListener != null) { 395 mListener.onWindowCreated(new Surface(surfaceTexture)); 396 } 397 } 398 399 @Override 400 public boolean onSurfaceTextureDestroyed(SurfaceTexture surfaceTexture) { 401 if (mListener != null) { 402 mListener.onWindowDestroyed(); 403 } 404 return true; 405 } 406 407 @Override 408 public void onSurfaceTextureSizeChanged(SurfaceTexture surfaceTexture, 409 int width, int height) { 410 } 411 412 @Override 413 public void onSurfaceTextureUpdated(SurfaceTexture surfaceTexture) { 414 } 415 }; 416 417 private final View.OnTouchListener mOnTouchListener = new View.OnTouchListener() { 418 @Override 419 public boolean onTouch(View view, MotionEvent event) { 420 // Work in screen coordinates. 421 final float oldX = event.getX(); 422 final float oldY = event.getY(); 423 event.setLocation(event.getRawX(), event.getRawY()); 424 425 mGestureDetector.onTouchEvent(event); 426 mScaleGestureDetector.onTouchEvent(event); 427 428 switch (event.getActionMasked()) { 429 case MotionEvent.ACTION_UP: 430 case MotionEvent.ACTION_CANCEL: 431 saveWindowParams(); 432 break; 433 } 434 435 // Revert to window coordinates. 436 event.setLocation(oldX, oldY); 437 return true; 438 } 439 }; 440 441 private final GestureDetector.OnGestureListener mOnGestureListener = 442 new GestureDetector.SimpleOnGestureListener() { 443 @Override 444 public boolean onScroll(MotionEvent e1, MotionEvent e2, 445 float distanceX, float distanceY) { 446 mLiveTranslationX -= distanceX; 447 mLiveTranslationY -= distanceY; 448 relayout(); 449 return true; 450 } 451 }; 452 453 private final ScaleGestureDetector.OnScaleGestureListener mOnScaleGestureListener = 454 new ScaleGestureDetector.SimpleOnScaleGestureListener() { 455 @Override 456 public boolean onScale(ScaleGestureDetector detector) { 457 mLiveScale *= detector.getScaleFactor(); 458 relayout(); 459 return true; 460 } 461 }; 462 } 463 }