blocks|key|307376|text|根据this+link的说法，可以使用android+sdk的tools目录中的ddms来截取屏幕。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|307377|要在应用程序中(而不是在开发期间)执行此操作，也有应用程序可以执行此操作。但正如@zed_0xff指出的那样，它肯定需要根用户。|307378|entityMap|0|LINK|mutability|MUTABLE|url|http://www.mobilecrunch.com/2008/10/31/how-to-capture-the-screen-of-an-android-device/^0|2|9|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

According to <a href="http://www.mobilecrunch.com/2008/10/31/how-to-capture-the-screen-of-an-android-device/" rel="nofollow noreferrer">this link</a>, it is possible to use ddms in the tools directory of the android sdk to take screen captures.

To do this within an application (and not during development), there are also applications to do so. But as @zed_0xff points out it certainly requires root.

blocks|key|304460|text|如果你想在Android应用程序AFAIK中从Java代码中截取屏幕，你必须拥有Root权限。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|304461|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

if you want to do screen capture from Java code in Android app AFAIK you must have Root provileges.

blocks|key|302196|text|AFAIK，目前捕获android屏幕截图的所有方法都使用/dev/graphics/fb0帧缓冲区。这包括ddms。它确实需要root用户才能从该流中读取数据。ddms使用adbd请求信息，因此不需要root用户，因为adb拥有从/dev/graphics/fb0请求数据所需的权限。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|302197|帧缓冲区包含RGB565图像的2%2B“帧”。如果您能够读取数据，则必须知道屏幕分辨率才能知道需要多少字节才能获得图像。每个像素为2字节，因此如果屏幕分辨率为480x800，则必须读取图像的768,000字节，因为480x800+RGB565图像具有384,000像素。|302198|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

AFAIK, All of the methods currently to capture a screenshot of android use the /dev/graphics/fb0 framebuffer. This includes ddms. It does require root to read from this stream. ddms uses adbd to request the information, so root is not required as adb has the permissions needed to request the data from /dev/graphics/fb0. 

The framebuffer contains 2+ "frames" of RGB565 images. If you are able to read the data, you would have to know the screen resolution to know how many bytes are needed to get the image. each pixel is 2 bytes, so if the screen res was 480x800, you would have to read 768,000 bytes for the image, since a 480x800 RGB565 image has 384,000 pixels.

blocks|key|304468|text|你可以尝试下面的库：Android+Screenshot+Library+(ASL)支持以编程方式从安卓设备捕获屏幕截图，而不需要拥有根用户访问权限。相反，ASL利用在后台运行的本机服务，通过Android+Debug+Bridge+(ADB)在每次设备引导时启动一次。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|304469|entityMap|0|LINK|mutability|MUTABLE|url|https://code.google.com/p/android-screenshot-library/^0|A|W|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

You can try the following library: <a href="https://code.google.com/p/android-screenshot-library/" rel="nofollow noreferrer">Android Screenshot Library (ASL)</a> enables to programmatically capture screenshots from Android devices without requirement of having root access privileges. Instead, ASL utilizes a native service running in the background, started via the Android Debug Bridge (ADB) once per device boot.

blocks|key|304513|text|基于Android源码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|304514|在C%2B%2B端，SurfaceFlinger实现captureScreen应用编程接口。这是通过绑定器IPC接口公开的，每次返回一个包含屏幕原始像素的新ashmem区域。实际的屏幕截图是通过OpenGL拍摄的。|304515|对于系统C%2B%2B客户端，接口通过ScreenshotClient类公开，该类在<surfaceflinger_client/SurfaceComposerClient.h>+For+Android+<+4.1中定义；对于Android+>4.1，使用<gui/SurfaceComposerClient.h>|offset|length|style|CODE|304516|在JB之前，要在C%2B%2B程序中截图，这就足够了：|304517|ScreenshotClient+ssc;
ssc.update();|code-block|syntax|javascript|304518|有了JB和多个显示器，就会变得稍微复杂一些：|304519|ssc.update(
++++android::SurfaceComposerClient::getBuiltInDisplay(
++++++++android::ISurfaceComposer::eDisplayIdMain));|304520|然后你就可以访问它了：|304521|do_something_with_raw_bits(ssc.getPixels(),+ssc.getSize(),+...);|304522|使用Android源代码，您可以编译自己的共享库来访问该API，然后通过JNI将其公开给Java。要从你的应用程序创建屏幕截图，该应用程序必须具有READ_FRAME_BUFFER权限。但即使这样，显然你也只能从系统应用程序中创建屏幕截图，即那些使用与系统相同的密钥签名的应用程序。(这一部分我还是不太理解，因为我对Android权限系统还不够熟悉。)|304523|以下是JB+4.1+/4.2的一段代码：|304524|#include+<utils/RefBase.h>
#include+<binder/IBinder.h>
#include+<binder/MemoryHeapBase.h>
#include+<gui/ISurfaceComposer.h>
#include+<gui/SurfaceComposerClient.h>

static+void+do_save(const+char+*filename,+const+void+*buf,+size_t+size)+{
++++int+out+=+open(filename,+O_RDWR%7CO_CREAT,+0666);
++++int+len+=+write(out,+buf,+size);
++++printf("Wrote+%25d+bytes+to+out.\n",+len);
++++close(out);
}

int+main(int+ac,+char+**av)+{
++++android::ScreenshotClient+ssc;
++++const+void+*pixels;
++++size_t+size;
++++int+buffer_index;

++++if(ssc.update(
++++++++android::SurfaceComposerClient::getBuiltInDisplay(
++++++++++++android::ISurfaceComposer::eDisplayIdMain))+!=+NO_ERROR+){
++++++++printf("Captured:+w=%25d,+h=%25d,+format=%25d\n");
++++++++ssc.getWidth(),+ssc.getHeight(),+ssc.getFormat());
++++++++size+=+ssc.getSize();
++++++++do_save(av[1],+pixels,+size);
++++}
++++else
++++++++printf("+screen+shot+client+Captured+Failed");
++++return+0;
}|304525|entityMap^0|0|0|12|1B|3G|T|0|0|0|0|0|0|0|21|H|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|18|8|@$F|19|G|1A|H|I]|$F|1B|G|1C|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1D|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|1E|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|1F|8|@]|9|@]|A|$]]|$1|S|3|T|5|N|7|1G|8|@]|9|@]|A|$O|P]]|$1|U|3|V|5|6|7|1H|8|@]|9|@]|A|$]]|$1|W|3|X|5|N|7|1I|8|@]|9|@]|A|$O|P]]|$1|Y|3|Z|5|6|7|1J|8|@$F|1K|G|1L|H|I]]|9|@]|A|$]]|$1|10|3|11|5|6|7|1M|8|@]|9|@]|A|$]]|$1|12|3|13|5|N|7|1N|8|@]|9|@]|A|$O|P]]|$1|14|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|15|$]]

[Based on Android source code:]

At the C++ side, the SurfaceFlinger implements the captureScreen API. This is exposed over the binder IPC interface, returning each time a new ashmem area that contains the raw pixels from the screen. The actual screenshot is taken through OpenGL.

For the system C++ clients, the interface is exposed through the ScreenshotClient class, defined in <code>&lt;surfaceflinger_client/SurfaceComposerClient.h&gt;</code> for Android &lt; 4.1; for Android > 4.1 use <code>&lt;gui/SurfaceComposerClient.h&gt;</code>

Before JB, to take a screenshot in a C++ program, this was enough:

<pre><code>ScreenshotClient ssc;
ssc.update();
</code></pre>

With JB and multiple displays, it becomes slightly more complicated:

<pre><code>ssc.update(
 android::SurfaceComposerClient::getBuiltInDisplay(
 android::ISurfaceComposer::eDisplayIdMain));
</code></pre>

Then you can access it:

<pre><code>do_something_with_raw_bits(ssc.getPixels(), ssc.getSize(), ...);
</code></pre>

Using the Android source code, you can compile your own shared library to access that API, and then expose it through JNI to Java. To create a screen shot form your app, the app has to have the <code>READ_FRAME_BUFFER</code> permission.
But even then, apparently you can create screen shots only from system applications, i.e. ones that are signed with the same key as the system. (This part I still don't quite understand, since I'm not familiar enough with the Android Permissions system.)

Here is a piece of code, for JB 4.1 / 4.2:

<pre><code>#include &lt;utils/RefBase.h&gt;
#include &lt;binder/IBinder.h&gt;
#include &lt;binder/MemoryHeapBase.h&gt;
#include &lt;gui/ISurfaceComposer.h&gt;
#include &lt;gui/SurfaceComposerClient.h&gt;

static void do_save(const char *filename, const void *buf, size_t size) {
 int out = open(filename, O_RDWR|O_CREAT, 0666);
 int len = write(out, buf, size);
 printf("Wrote %d bytes to out.\n", len);
 close(out);
}

int main(int ac, char **av) {
 android::ScreenshotClient ssc;
 const void *pixels;
 size_t size;
 int buffer_index;

 if(ssc.update(
 android::SurfaceComposerClient::getBuiltInDisplay(
 android::ISurfaceComposer::eDisplayIdMain)) != NO_ERROR ){
 printf("Captured: w=%d, h=%d, format=%d\n");
 ssc.getWidth(), ssc.getHeight(), ssc.getFormat());
 size = ssc.getSize();
 do_save(av[1], pixels, size);
 }
 else
 printf(" screen shot client Captured Failed");
 return 0;
}
</code></pre>

blocks|key|307469|text|对于较新的安卓平台，用户可以在没有根用户权限的情况下在/system/bin中执行系统实用程序screencap来获取屏幕截图。您可以尝试使用/system/bin/screencap+-h，看看如何在adb或任何shell下使用它。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|307470|顺便说一下，我认为这种方法只适用于单次快照。如果我们想要捕获多个帧用于屏幕播放，它将会太慢。我不知道是否有其他方法可以更快地捕获屏幕。|307471|entityMap^0|R|B|1B|9|1Z|O|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

For newer Android platforms, one can execute a system utility <code>screencap</code> in <code>/system/bin</code> to get the screenshot without root permission.
You can try <code>/system/bin/screencap -h</code> to see how to use it under adb or any shell.

By the way, I think this method is only good for single snapshot. 
If we want to capture multiple frames for screen play, it will be too slow.
I don't know if there exists any other approach for a faster screen capture.

blocks|key|302278|text|Framebuffer似乎是个不错的选择，它不会像Ryan+Conrad提到的那样总是包含2%2B帧。在我的例子中，它只包含一个。我猜这取决于帧/显示器的大小。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|302279|我试图连续读取帧缓冲区，但它似乎返回了固定数量的读取字节。在我的例子中是(3,410,432)字节，这足以存储854*480+RGBA+(3,279,360字节)的显示帧。是的，从fb0输出的二进制帧在我的device中是RGBA。这很可能取决于不同的设备。这对你解码它很重要=)|offset|length|style|BOLD|302280|在我的设备/dev//+fb0中，权限是这样的，只有根图形和来自组图形的用户才能读取fb0。graphics是一个受限制的组，因此您可能只能使用su命令通过根电话访问fb0。|302281|Android应用程序有用户id+(uid)+app_##和组id+(guid)+app_##。|302282|adb+shell有uid+shell和guid+shell，它比应用程序拥有更多的权限。您实际上可以在/system/permissions/platform.xml上查看这些权限|302283|这意味着您可以在没有根用户的情况下在adb+shell中读取fb0，但在没有根用户的情况下将无法在应用程序中读取它。|302284|此外，在AndroidManifest.xml上授予READ_FRAME_BUFFER和/或ACCESS_SURFACE_FLINGER权限对常规应用程序没有任何作用，因为这些权限仅适用于“签名”应用程序。|302285|entityMap^0|0|2H|K|38|C|0|W|3|1A|8|0|H|C|Y|D|0|A|9|K|A|1G|W|0|0|1M|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@$D|V|E|W|F|G]|$D|X|E|Y|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|Z|8|@$D|10|E|11|F|G]|$D|12|E|13|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|14|8|@$D|15|E|16|F|G]|$D|17|E|18|F|G]]|9|@]|A|$]]|$1|L|3|M|5|6|7|19|8|@$D|1A|E|1B|F|G]|$D|1C|E|1D|F|G]|$D|1E|E|1F|F|G]]|9|@]|A|$]]|$1|N|3|O|5|6|7|1G|8|@$D|1H|E|1I|F|G]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1J|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|S|$]]

Framebuffer seems the way to go, it will not always contain 2+ frames like mentioned by Ryan Conrad. In my case it contained only one. I guess it depends on the frame/display size. 

I tried to read the framebuffer continuously but it seems to return for a fixed amount of bytes read. In my case that is (3 410 432) bytes, which is enough to store a display frame of 854*480 RGBA (3 279 360 bytes). Yes, the frame in binary outputed from fb0 is RGBA in my device. This will most likely depend from device to device. This will be important for you to decode it =)

In my device /dev/graphics/fb0 permissions are so that only root and users from group graphics can read the fb0. graphics is a restricted group so you will probably only access fb0 with a rooted phone using su command. 

Android apps have the user id (uid) app_## and group id (guid) app_## .

adb shell has uid shell and guid shell, which has much more permissions than an app.
You can actually check those permissions at /system/permissions/platform.xml

This means you will be able to read fb0 in the adb shell without root but you will not read it within the app without root.

Also, giving READ_FRAME_BUFFER and/or ACCESS_SURFACE_FLINGER permissions on AndroidManifest.xml will do nothing for a regular app because these will only work for 'signature' apps.

<blockquote>
 Possible Duplicate: 
 <a href="https://stackoverflow.com/questions/2661536/how-to-programatically-take-a-screenshot-on-android">How to programatically take a screenshot on Android?</a> 
</blockquote>



How to capture the android device screen content and make an image file using the snapshot data? Which API should I use or where could I find related resources?

BTW:
not camera snapshot, but device screen

How to capture the android device screen content? 

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

 可能重复：如何抓取android设备屏幕内容，并使用快照数据制作图片文件？我应该使用哪个API，或者在哪里可以找到相关资源？顺便说一句:不是相机快照，而是设备屏幕

问如何抓取android设备的屏幕内容？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何抓取android设备的屏幕内容？EN