| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package android.media.projection; |
| |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.content.Context; |
| import android.hardware.display.DisplayManager; |
| import android.hardware.display.VirtualDisplay; |
| import android.media.AudioRecord; |
| import android.media.projection.IMediaProjection; |
| import android.media.projection.IMediaProjectionCallback; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.os.RemoteException; |
| import android.util.ArrayMap; |
| import android.util.Log; |
| import android.view.Surface; |
| |
| import java.util.Map; |
| |
| /** |
| * A token granting applications the ability to capture screen contents and/or |
| * record system audio. The exact capabilities granted depend on the type of |
| * MediaProjection. |
| * |
| * <p> |
| * A screen capture session can be started through {@link |
| * MediaProjectionManager#createScreenCaptureIntent}. This grants the ability to |
| * capture screen contents, but not system audio. |
| * </p> |
| */ |
| public final class MediaProjection { |
| private static final String TAG = "MediaProjection"; |
| |
| private final IMediaProjection mImpl; |
| private final Context mContext; |
| private final Map<Callback, CallbackRecord> mCallbacks; |
| |
| /** @hide */ |
| public MediaProjection(Context context, IMediaProjection impl) { |
| mCallbacks = new ArrayMap<Callback, CallbackRecord>(); |
| mContext = context; |
| mImpl = impl; |
| try { |
| mImpl.start(new MediaProjectionCallback()); |
| } catch (RemoteException e) { |
| throw new RuntimeException("Failed to start media projection", e); |
| } |
| } |
| |
| /** Register a listener to receive notifications about when the {@link |
| * MediaProjection} changes state. |
| * |
| * @param callback The callback to call. |
| * @param handler The handler on which the callback should be invoked, or |
| * null if the callback should be invoked on the calling thread's looper. |
| * |
| * @see #unregisterCallback |
| */ |
| public void registerCallback(Callback callback, Handler handler) { |
| if (callback == null) { |
| throw new IllegalArgumentException("callback should not be null"); |
| } |
| mCallbacks.put(callback, new CallbackRecord(callback, handler)); |
| } |
| |
| /** Unregister a MediaProjection listener. |
| * |
| * @param callback The callback to unregister. |
| * |
| * @see #registerCallback |
| */ |
| public void unregisterCallback(Callback callback) { |
| if (callback == null) { |
| throw new IllegalArgumentException("callback should not be null"); |
| } |
| mCallbacks.remove(callback); |
| } |
| |
| /** |
| * @hide |
| */ |
| public VirtualDisplay createVirtualDisplay(@NonNull String name, |
| int width, int height, int dpi, boolean isSecure, @Nullable Surface surface, |
| @Nullable VirtualDisplay.Callback callback, @Nullable Handler handler) { |
| DisplayManager dm = (DisplayManager) mContext.getSystemService(Context.DISPLAY_SERVICE); |
| int flags = isSecure ? DisplayManager.VIRTUAL_DISPLAY_FLAG_SECURE : 0; |
| return dm.createVirtualDisplay(this, name, width, height, dpi, surface, |
| flags | DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR | |
| DisplayManager.VIRTUAL_DISPLAY_FLAG_PRESENTATION, callback, handler); |
| } |
| |
| /** |
| * Creates a {@link android.hardware.display.VirtualDisplay} to capture the |
| * contents of the screen. |
| * |
| * @param name The name of the virtual display, must be non-empty. |
| * @param width The width of the virtual display in pixels. Must be |
| * greater than 0. |
| * @param height The height of the virtual display in pixels. Must be |
| * greater than 0. |
| * @param dpi The density of the virtual display in dpi. Must be greater |
| * than 0. |
| * @param surface The surface to which the content of the virtual display |
| * should be rendered, or null if there is none initially. |
| * @param flags A combination of virtual display flags. See {@link DisplayManager} for the full |
| * list of flags. |
| * @param callback Callback to call when the virtual display's state |
| * changes, or null if none. |
| * @param handler The {@link android.os.Handler} on which the callback should be |
| * invoked, or null if the callback should be invoked on the calling |
| * thread's main {@link android.os.Looper}. |
| * |
| * @see android.hardware.display.VirtualDisplay |
| */ |
| public VirtualDisplay createVirtualDisplay(@NonNull String name, |
| int width, int height, int dpi, int flags, @Nullable Surface surface, |
| @Nullable VirtualDisplay.Callback callback, @Nullable Handler handler) { |
| DisplayManager dm = (DisplayManager) mContext.getSystemService(Context.DISPLAY_SERVICE); |
| return dm.createVirtualDisplay( |
| this, name, width, height, dpi, surface, flags, callback, handler); |
| } |
| |
| /** |
| * Creates an AudioRecord to capture audio played back by the system. |
| * @hide |
| */ |
| public AudioRecord createAudioRecord( |
| int sampleRateInHz, int channelConfig, |
| int audioFormat, int bufferSizeInBytes) { |
| return null; |
| } |
| |
| /** |
| * Stops projection. |
| */ |
| public void stop() { |
| try { |
| mImpl.stop(); |
| } catch (RemoteException e) { |
| Log.e(TAG, "Unable to stop projection", e); |
| } |
| } |
| |
| /** |
| * Get the underlying IMediaProjection. |
| * @hide |
| */ |
| public IMediaProjection getProjection() { |
| return mImpl; |
| } |
| |
| /** |
| * Callbacks for the projection session. |
| */ |
| public static abstract class Callback { |
| /** |
| * Called when the MediaProjection session is no longer valid. |
| * <p> |
| * Once a MediaProjection has been stopped, it's up to the application to release any |
| * resources it may be holding (e.g. {@link android.hardware.display.VirtualDisplay}s). |
| * </p> |
| */ |
| public void onStop() { } |
| } |
| |
| private final class MediaProjectionCallback extends IMediaProjectionCallback.Stub { |
| @Override |
| public void onStop() { |
| final int N = mCallbacks.size(); |
| for (int i = 0; i < N; i++) { |
| mCallbacks.get(i).onStop(); |
| } |
| } |
| } |
| |
| private final static class CallbackRecord { |
| private Callback mCallback; |
| private Handler mHandler; |
| |
| public CallbackRecord(Callback callback, Handler handler) { |
| mCallback = callback; |
| mHandler = handler; |
| } |
| |
| public void onStop() { |
| mHandler.post(new Runnable() { |
| @Override |
| public void run() { |
| mCallback.onStop(); |
| } |
| }); |
| } |
| } |
| } |