Implement screen capture for android

media/screen_capture/android/screen_capturer_android.h

Index: media/screen_capture/android/screen_capturer_android.h
diff --git a/media/screen_capture/android/screen_capturer_android.h b/media/screen_capture/android/screen_capturer_android.h
new file mode 100644
index 0000000000000000000000000000000000000000..ee87493369267797789d6b59755ba52f63367642
--- /dev/null
+++ b/media/screen_capture/android/screen_capturer_android.h
@@ -0,0 +1,56 @@
+// Copyright (c) 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef MEDIA_SCREEN_CAPTURE_ANDROID_SCREEN_CAPTURER_ANDROID_H_
+#define MEDIA_SCREEN_CAPTURE_ANDROID_SCREEN_CAPTURER_ANDROID_H_
+
+#include <jni.h>
+
+#include "base/android/scoped_java_ref.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_capture_types.h"
+#include "third_party/webrtc/modules/desktop_capture/screen_capture_frame_queue.h"
+#include "third_party/webrtc/modules/desktop_capture/screen_capturer.h"
+
+namespace media {
+
+// ScreenCapturerAndroid captures 32bit RGB using SurfaceFlinger.
+class ScreenCapturerAndroid : public webrtc::ScreenCapturer {

[miu, 2015/05/20 03:33:27]

After looking at all the code, I really don't think you should inherit from
webrtc::ScreenCapturer for this implementation.  webrtc::ScreenCapturer is a
single-threaded, poll-based interface; but the Android platform is providing a
multi-threaded, pushed-based interface.  Also:

1. None of the webrtc::ScreenCapturer methods, except for Start(), needs to be
implemented (or is doing what the interface declares they should do).

2. This change is introducing a huge amount of new dependencies on
third_party/webrtc all over the build/DEPS and C++ files.  Every class you're
using in the webrtc namespace has an analogue in Chromium code (e.g.,
webrtc::TickTime --> base::TimeTicks).  In other words, you could simplify this
change a lot by depending only on code found in the Chromium project.

My suggestions: I'd move this ScreenCapturerAndroid class to
content/browser/media/capture, rename it to ScreenCaptureMachineAndroid, and
have it implement the content::VideoCaptureMachine interface:
https://code.google.com/p/chromium/codesearch#chromium/src/content/browser/me...

For a good example of how that interface is implemented, see
AuraWindowCaptureMachine::Start() and Stop().

Also, note that using the content::ThreadSafeOracleProxy class, as
AuraWindowCaptureMachine does, will allow you to leverage all the hard work
that's gone into the capture implementation:

1. Smooth sampling of frames.  For example, when Android produces frames at 60
FPS, but the consumer can only handle 24 FPS, what should be done?

2. Detecting animated content for perfect frame timestamp rewriting.  Meaning,
Android will capture frames and provide compositor presentation timestamps (from
Image.getTimestamp()).  However, consumers of your screen capture will do better
to receive smoothed-out timestamps instead of 60Hz-rounded ones.  In other
words, when a 24 FPS video is playing, you want your all the frame timestamps to
be 41.7 ms apart, not 33.3 then 50.0 then 33.3 then 50.0...

3. All the in-progress work the team is doing to improve the user experience. 
In particular, there's an effort which will automatically change capture
resolutions in CPU- or network-constrained user environments throughout a
capture session.  I expect this will be just as, if not more, important on
Android than it is on the desktop platforms.  If you implement a
ScreenCaptureMachineAndroid, we'll be forced to upgrade the android experience
along with the desktop platforms as we land code changes.  ;-)

[jiajia.qin, 2015/05/20 12:07:16]

Agree with you. Inheriting from webrtc::ScreenCapturer was my initial thought.
At
the beginning, I was considering to put these implementation into
'webrtc/modules/desktop_capture'. But I found that I couldn't use jni to call
the
android API and benefit chromium. So I moved the code to src/media/ but still
inherited from webrtc::ScreenCapturer.

Currently, I tried another method which let ScreenCapturerAndroid inherit
VideoCaptureDevice.
Since I almost have finished the function in this way, I submit it as PS#2.
In this method, ScreenCapturerAndroid implements media::VideoCaptureDevice
interface.
I basically refer to media::VideoCaptureDeviceAndroid as the example.
Please ignore the number '2' in class name or file name. It's just a distinguish
with the
first method. I want to give you a preview, so I submit it. 

  
Thanks, miu. I will investigate this method tomorrow and see if it is better.
Please also check PS#2 since it also solves the issues you list above. 

+ public:
+  explicit ScreenCapturerAndroid();
+  virtual ~ScreenCapturerAndroid();
+
+  static bool RegisterScreenCapturer(JNIEnv* env);
+
+  // Implement org.chromium.media.ScreenCapture.nativeOnFrameAvailable.
+  void OnFrameAvailable(
+      JNIEnv* env,
+      jobject obj,
+      jbyteArray data,
+      jint width,
+      jint height);
+
+  // Implement org.chromium.media.ScreenCapture.nativeOnActivityResult.
+  void OnActivityResult(JNIEnv* env, jobject obj, jint result);
+
+  // Overridden from ScreenCapturer:
+  void Start(webrtc::DesktopCapturer::Callback* callback) override;
+  void Capture(const webrtc::DesktopRegion& region) override;
+  bool GetScreenList(ScreenList* screens) override;
+  bool SelectScreen(webrtc::ScreenId id) override;
+
+ private:
+  // Queue of the frames buffers.
+  webrtc::ScreenCaptureFrameQueue queue_;
+
+  // Java ScreenCaptureAndroid instance.
+  base::android::ScopedJavaLocalRef<jobject> j_capture_;
+
+  webrtc::DesktopCapturer::Callback* callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScreenCapturerAndroid);
+};
+
+}  // namespace webrtc
+
+#endif  // MEDIA_SCREEN_CAPTURE_ANDROID_SCREEN_CAPTURER_ANDROID_H_