Android截屏浅析

Android的调试工具DDMS提供截屏功能，很多同步软件例如豌豆荚也都提供截屏功能，经分析Android截屏原理大致如下：

DDMS是通过adb调用设备端的adbd（ADBdaemon）提供的framebufferservice进行截屏（源码在system/core/adb/framebuffer_service.c），在较早版本的Android中，framebuffer service通过直接读framebuffer 设备（/dev/graphics/fb0）来截屏，在较新版本的Android中，framebuffer service则调用截屏工具screencap来截屏。那些同步软件也是调用screencap实现截屏的。

screencap是Android原生自带的工具，是一个C写的可执行文件，在设备上的/system/bin/下面可以找到它，screencap截屏后可保存为PNG格式文件或RGBRAW文件。

screencap的源码在frameworks/base/cmds/screencap/，它调用SurfaceFlinger提供的截屏接口ScreenshotClient，其源码在frameworks/native/libs/gui/SurfaceComposerClient.cpp（该路径在不同版本的Android源码中可能略有差别），ScreenshotClient通过进程间通信调用SurfaceFlinger service的截屏功能，源码在frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp中的函数SurfaceFlinger::captureScreen。

在各种截屏方法中，读framebuffer设备（/dev/graphics/fb0）的方式在某些使用硬件overlay显示的设备上可能无法截取到某些画面（例如video playback和camera preview画面），但是SurfaceFlinger提供的上述截屏接口则可以完美截取任何屏幕画面，因此相对来说是Android上最正规最完善的截屏方法，使用起来也非常简单。但需注意，ScreenshotClient等接口在不同Android版本上可能存在差异，例如在JellyBean的最新版本上ScreenshotClient的成员函数update增加了一个参数display（应该是为了支持多个显示设备），导致与之前版本不兼容。

此外Android还自带另一个截屏工具screenshot，源码在frameworks/base/cmds/screenshot/，它通过直接读framebuffer 设备（/dev/graphics/fb0）来截屏，保存为PNG格式文件。screenshot貌似没有用处。

原文二：（用自己的方式实现截屏）

Android代码截屏

链接：http://myhpu2008.iteye.com/blog/999779

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.Rect;
import android.util.Log;
import android.view.View;

public class ScreenShot {
    // 获取指定Activity的截屏，保存到png文件
    private static Bitmap takeScreenShot(Activity activity) {
        // View是你需要截图的View
        View view = activity.getWindow().getDecorView();
        view.setDrawingCacheEnabled(true);
        view.buildDrawingCache();
        Bitmap b1 = view.getDrawingCache();

        // 获取状态栏高度
        Rect frame = new Rect();
        activity.getWindow().getDecorView().getWindowVisibleDisplayFrame(frame);
        int statusBarHeight = frame.top;
        Log.i("TAG", "" + statusBarHeight);

        // 获取屏幕长和高
        int width = activity.getWindowManager().getDefaultDisplay().getWidth();
        int height = activity.getWindowManager().getDefaultDisplay()
                .getHeight();
        // 去掉标题栏
        // Bitmap b = Bitmap.createBitmap(b1, 0, 25, 320, 455);
        Bitmap b = Bitmap.createBitmap(b1, 0, statusBarHeight, width, height
                - statusBarHeight);
        view.destroyDrawingCache();
        return b;
    }

    // 保存到sdcard
    private static void savePic(Bitmap b, String strFileName) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(strFileName);
            if (null != fos) {
                b.compress(Bitmap.CompressFormat.PNG, 90, fos);
                fos.flush();
                fos.close();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 程序入口
    public static void shoot(Activity a) {
        ScreenShot.savePic(ScreenShot.takeScreenShot(a), "sdcard/xx.png");
    }
}

 

 

需要注意的是，shoot方法只能在view已经被加载后方可调用。

或者在    @Override
    public void onWindowFocusChanged(boolean hasFocus) {
        // TODO Auto-generated method stub
        super.onWindowFocusChanged(hasFocus);
        ScreenShot.shoot(this);
    }中调用

原文三：

浅谈android截屏问题

链接： http://my.oschina.net/JumpLong/blog/75556

做了几个月的截屏开发，稍微了解了一下这方面的知识，于是拿来分享一下，也许对你有一些帮助吧。

    我是基于android2.3.3系统之上的，想必大家应该知道在android源码下面有个文件叫做screencap吧，位于frameworks\base\services\surfaceflinger\tests\screencap\screencap.cpp,你直接在linux下编译（就是去screencap的文件mm，然后保存在 /system/bin/test-screencap），然后push到手机上再通过电脑去敲命令./test-screencap /mnt/sdcard/scapxx.png就可以实现截屏（不要导入到/mntsdcard，反正我是导入到system目录里面才可以执行）。

 /*
  * Copyright (C) 2010 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.
  */

 #include <utils/Log.h>

 #include <binder/IPCThreadState.h>
 #include <binder/ProcessState.h>
 #include <binder/IServiceManager.h>

 #include <binder/IMemory.h>
 #include <surfaceflinger/ISurfaceComposer.h>

 #include <SkImageEncoder.h>
 #include <SkBitmap.h>

 using namespace android;

 int main(int argc, char** argv)
 {
     if (argc != 2) {
         printf("usage: %s path\n", argv[0]);
         exit(0);
     }

     const String16 name("SurfaceFlinger");
     sp<ISurfaceComposer> composer;
     getService(name, &composer);

     sp<IMemoryHeap> heap;
     uint32_t w, h;
     PixelFormat f;
     status_t err = composer->captureScreen(0, &heap, &w, &h, &f, 0, 0);
     if (err != NO_ERROR) {
         fprintf(stderr, "screen capture failed: %s\n", strerror(-err));
         exit(0);
     }

     printf("screen capture success: w=%u, h=%u, pixels=%p\n",
             w, h, heap->getBase());

     printf("saving file as PNG in %s ...\n", argv[1]);

     SkBitmap b;
     b.setConfig(SkBitmap::kARGB_8888_Config, w, h);
     b.setPixels(heap->getBase());
     SkImageEncoder::EncodeFile(argv[1], b,
             SkImageEncoder::kPNG_Type, SkImageEncoder::kDefaultQuality);

     return 0;
 }

    其实这个程序真正用到的就是一个叫做capturescreen的函数，而capturescreen会调用captureScreenImplLocked这个函数

下面是代码：

 status_t SurfaceFlinger::captureScreenImplLocked(DisplayID dpy,
         sp<IMemoryHeap>* heap,
         uint32_t* w, uint32_t* h, PixelFormat* f,
         uint32_t sw, uint32_t sh)
 {
    LOGI("captureScreenImplLocked");
     status_t result = PERMISSION_DENIED;

     // only one display supported for now
     if (UNLIKELY(uint32_t(dpy) >= DISPLAY_COUNT))
         return BAD_VALUE;

     if (!GLExtensions::getInstance().haveFramebufferObject())
         return INVALID_OPERATION;

     // get screen geometry
     const DisplayHardware& hw(graphicPlane(dpy).displayHardware());
     const uint32_t hw_w = hw.getWidth();
     const uint32_t hw_h = hw.getHeight();

     if ((sw > hw_w) || (sh > hw_h))
         return BAD_VALUE;

     sw = (!sw) ? hw_w : sw;
     sh = (!sh) ? hw_h : sh;
     const size_t size = sw * sh * 4;

     // make sure to clear all GL error flags
     while ( glGetError() != GL_NO_ERROR ) ;

     // create a FBO
     GLuint name, tname;
     glGenRenderbuffersOES(1, &tname);
     glBindRenderbufferOES(GL_RENDERBUFFER_OES, tname);
     glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_RGBA8_OES, sw, sh);
     glGenFramebuffersOES(1, &name);
     glBindFramebufferOES(GL_FRAMEBUFFER_OES, name);
     glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES,
             GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, tname);

     GLenum status = glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES);
     if (status == GL_FRAMEBUFFER_COMPLETE_OES) {

         // invert everything, b/c glReadPixel() below will invert the FB
         glViewport(0, 0, sw, sh);
         glScissor(0, 0, sw, sh);
         glMatrixMode(GL_PROJECTION);
         glPushMatrix();
         glLoadIdentity();
         glOrthof(0, hw_w, 0, hw_h, 0, 1);
         glMatrixMode(GL_MODELVIEW);

         // redraw the screen entirely...
         glClearColor(0,0,0,1);
         glClear(GL_COLOR_BUFFER_BIT);

         const Vector< sp<LayerBase> >& layers(mVisibleLayersSortedByZ);
         const size_t count = layers.size();
         for (size_t i=0 ; i<count ; ++i) {
             const sp<LayerBase>& layer(layers[i]);
             layer->drawForSreenShot();
         }

         // XXX: this is needed on tegra
         glScissor(0, 0, sw, sh);

         // check for errors and return screen capture
         if (glGetError() != GL_NO_ERROR) {
             // error while rendering
             result = INVALID_OPERATION;
         } else {
             // allocate shared memory large enough to hold the
             // screen capture
             sp<MemoryHeapBase> base(
                     new MemoryHeapBase(size, 0, "screen-capture") );
             void* const ptr = base->getBase();
             if (ptr) {
                 // capture the screen with glReadPixels()
                 glReadPixels(0, 0, sw, sh, GL_RGBA, GL_UNSIGNED_BYTE, ptr);
                 if (glGetError() == GL_NO_ERROR) {
                     *heap = base;
                     *w = sw;
                     *h = sh;
                     *f = PIXEL_FORMAT_RGBA_8888;
                     result = NO_ERROR;
                 }
             } else {
                 result = NO_MEMORY;
             }
         }
         glEnable(GL_SCISSOR_TEST);
         glViewport(0, 0, hw_w, hw_h);
         glMatrixMode(GL_PROJECTION);
         glPopMatrix();
         glMatrixMode(GL_MODELVIEW);


     } else {
         result = BAD_VALUE;
     }

     // release FBO resources
     glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0);
     glDeleteRenderbuffersOES(1, &tname);
     glDeleteFramebuffersOES(1, &name);

     hw.compositionComplete();

     return result;
 }


 status_t SurfaceFlinger::captureScreen(DisplayID dpy,
         sp<IMemoryHeap>* heap,
         uint32_t* width, uint32_t* height, PixelFormat* format,
         uint32_t sw, uint32_t sh)
 {
            LOGI("into captureScreen");
     // only one display supported for now
     if (UNLIKELY(uint32_t(dpy) >= DISPLAY_COUNT))
         return BAD_VALUE;

     if (!GLExtensions::getInstance().haveFramebufferObject())
         return INVALID_OPERATION;

     class MessageCaptureScreen : public MessageBase {
         SurfaceFlinger* flinger;
         DisplayID dpy;
         sp<IMemoryHeap>* heap;
         uint32_t* w;
         uint32_t* h;
         PixelFormat* f;
         uint32_t sw;
         uint32_t sh;
         status_t result;
     public:
         MessageCaptureScreen(SurfaceFlinger* flinger, DisplayID dpy,
                 sp<IMemoryHeap>* heap, uint32_t* w, uint32_t* h, PixelFormat* f,
                 uint32_t sw, uint32_t sh)
             : flinger(flinger), dpy(dpy),
               heap(heap), w(w), h(h), f(f), sw(sw), sh(sh), result(PERMISSION_DENIED)
         {

         }
         status_t getResult() const {
            LOGI("getResult()");
          return result;
         }
         virtual bool handler() {


    LOGI("handler()");
             Mutex::Autolock _l(flinger->mStateLock);

             // if we have secure windows, never allow the screen capture
             if (flinger->mSecureFrameBuffer)
                 return true;

             result = flinger->captureScreenImplLocked(dpy,
                     heap, w, h, f, sw, sh);

             return true;
         }
     };
    LOGI("before messagecapturescreen");
     sp<MessageBase> msg = new MessageCaptureScreen(this,
             dpy, heap, width, height, format, sw, sh);
     status_t res = postMessageSync(msg);
     if (res == NO_ERROR) {
         res = static_cast<MessageCaptureScreen*>( msg.get() )->getResult();
     }
     return res;
 }

而这个函数关键又使用了opengl的几个函数去获得图片，然而opengl又去read framebuffer（这是我的理解）。如果你去用jni调用so的方法去截屏的话，就可以把screencap这个文件稍微修改一下然后做成so文件，方法可以参考这篇博客：http://blog.csdn.net/zx19899891/article/details/7072291

    主要是补充一下怎么去存放文件与编译吧，当然我说的方法只是我做的方法不代表是很好用的。

    存放：在eclipse新建一个android工程，保存后找到这个工程（如screencap）的存放位置 然后把这个文件放到android源代码的development文件里面，然后在你的那个工程文件里面新建一个文件夹，名字叫做jni（这个文件夹平行于src文件夹，screencap/jni），把上面博客提到的那个C++跟mk（screencap/jni/com_android_ScreenCap_ScreenCapNative.cpp和screencap/jni/Android.mk）文件放进去，最后在把编译的mk文件放在screencap目录下（screencap/Android.mk）;

    编译：编译是个很伟大的工程，需要你花大量的时间与精力。直接在终端进入工程存放的所在位置，我的是Administrator/Android.2.3.3/development，然后mm（Builds all of the modules in the current directory），如果成功，那么你运气比较好，在终端回提示你APK保存的位置。push进手机试一试。但是往往是不成功的。你可能会遇到一些问题，比如android.permission.ACCESS_SURFACE_FLINGER ,android.permission.READ_FRAME_BUFFER（因为capturescrren这个函数是surfaceflinger里面的函数，然而surfaceflinger里面的opengl截屏函数会去读取framebuffer），相关源代码是：

 status_t SurfaceFlinger::onTransact(
     uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
 {

     switch (code) {
         case CREATE_CONNECTION:
         case OPEN_GLOBAL_TRANSACTION:
         case CLOSE_GLOBAL_TRANSACTION:
         case SET_ORIENTATION:
         case FREEZE_DISPLAY:
         case UNFREEZE_DISPLAY:
         case BOOT_FINISHED:
         case TURN_ELECTRON_BEAM_OFF:
         case TURN_ELECTRON_BEAM_ON:
         {
             // codes that require permission check
             IPCThreadState* ipc = IPCThreadState::self();
             const int pid = ipc->getCallingPid();
             const int uid = ipc->getCallingUid();
             if ((uid != AID_GRAPHICS) && !mAccessSurfaceFlinger.check(pid, uid)) {
                 LOGE("Permission Denial: "
                         "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
                 return PERMISSION_DENIED;
             }
             break;
         }
         case CAPTURE_SCREEN:
         {
             // codes that require permission check
             IPCThreadState* ipc = IPCThreadState::self();
             const int pid = ipc->getCallingPid();
             const int uid = ipc->getCallingUid();
             if ((uid != AID_GRAPHICS) && !mReadFramebuffer.check(pid, uid)) {

                 LOGE("Permission Denial: "
                         "can't read framebuffer pid=%d, uid=%d", pid, uid);
                 return PERMISSION_DENIED;
             }

             break;
         }
     }

     status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
     if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
         CHECK_INTERFACE(ISurfaceComposer, data, reply);
         if (UNLIKELY(!mHardwareTest.checkCalling())) {
             IPCThreadState* ipc = IPCThreadState::self();
             const int pid = ipc->getCallingPid();
             const int uid = ipc->getCallingUid();

    LOGI("err");
             LOGE("Permission Denial: "
                     "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
             return PERMISSION_DENIED;
         }
         int n;
         switch (code) {
             case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
             case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
                 return NO_ERROR;
             case 1002:  // SHOW_UPDATES
                 n = data.readInt32();
                 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
                 return NO_ERROR;
             case 1003:  // SHOW_BACKGROUND
                 n = data.readInt32();
                 mDebugBackground = n ? 1 : 0;
                 return NO_ERROR;
             case 1004:{ // repaint everything
                 Mutex::Autolock _l(mStateLock);
                 const DisplayHardware& hw(graphicPlane(0).displayHardware());
                 mDirtyRegion.set(hw.bounds()); // careful that's not thread-safe
                 signalEvent();
                 return NO_ERROR;
             }
             case 1005:{ // force transaction
                 setTransactionFlags(eTransactionNeeded|eTraversalNeeded);
                 return NO_ERROR;
             }
             case 1006:{ // enable/disable GraphicLog
                 int enabled = data.readInt32();
                 GraphicLog::getInstance().setEnabled(enabled);
                 return NO_ERROR;
             }
             case 1007: // set mFreezeCount
                 mFreezeCount = data.readInt32();
                 mFreezeDisplayTime = 0;
                 return NO_ERROR;
             case 1010:  // interrogate.
                 reply->writeInt32(0);
                 reply->writeInt32(0);
                 reply->writeInt32(mDebugRegion);
                 reply->writeInt32(mDebugBackground);
                 return NO_ERROR;
             case 1013: {
                 Mutex::Autolock _l(mStateLock);
                 const DisplayHardware& hw(graphicPlane(0).displayHardware());
                 reply->writeInt32(hw.getPageFlipCount());
             }
             return NO_ERROR;
         }
     }
     return err;
 }

这个仅仅只是开始！  你会发现你即使在xml里面添加相应的权限仍然会有这个问题出现，为什么呢？在packageManger文件里面发现相关代码：

 int checkSignaturesLP(Signature[] s1, Signature[] s2) {
     if (s1 == null) {
         return s2 == null
                 ? PackageManager.SIGNATURE_NEITHER_SIGNED
                 : PackageManager.SIGNATURE_FIRST_NOT_SIGNED;
     }
     if (s2 == null) {
         return PackageManager.SIGNATURE_SECOND_NOT_SIGNED;
     }
     HashSet<Signature> set1 = new HashSet<Signature>();
     for (Signature sig : s1) {
         set1.add(sig);
     }
     HashSet<Signature> set2 = new HashSet<Signature>();
     for (Signature sig : s2) {
         set2.add(sig);
     }
     // Make sure s2 contains all signatures in s1.
     if (set1.equals(set2)) {
         return PackageManager.SIGNATURE_MATCH;
     }
     return PackageManager.SIGNATURE_NO_MATCH;
 }



 Check for shared user signatures
     if (pkgSetting.sharedUser != null && pkgSetting.sharedUser.signatures.mSignatures != null) {
         if (checkSignaturesLP(pkgSetting.sharedUser.signatures.mSignatures,
                 pkg.mSignatures) != PackageManager.SIGNATURE_MATCH) {
             Slog.e(TAG, "Package " + pkg.packageName
                     + " has no signatures that match those in shared user "
                     + pkgSetting.sharedUser.name + "; ignoring!");
             mLastScanError = PackageManager.INSTALL_FAILED_SHARED_USER_INCOMPATIBLE;
             return false;
         }
     }
     return true;


 private boolean verifySignaturesLP(PackageSetting pkgSetting,
         PackageParser.Package pkg) {

     // Check for shared user signatures
     if (pkgSetting.sharedUser != null && pkgSetting.sharedUser.signatures.mSignatures != null) {

  (checkSignaturesLP(pkgSetting.sharedUser.signatures.mSignatures,
                 pkg.mSignatures) != PackageManager.SIGNATURE_MATCH) {

 log.e(TAG, "Package " + pkg.packageName
                     + " has no signatures that match those in shared user "
                     + pkgSetting.sharedUser.name + "; ignoring!");
             mLastScanError = PackageManager.INSTALL_FAILED_SHARED_USER_INCOMPATIBLE;
             return false;

         }
     }
     return true;
 }

你在终端输入adb logcat | grep PackageManager 你会发现这两个权限根本没有赋予给你的apk，我的理解是，程序需要权限，然后apk仍然需要权限。那怎么样给apk赋予权限呢，两个方法，一个是在我上面说的screencap/Android.mk里面添加platform一行，然后在回到mm。还有一个方法就是通过sign。这两个方法都是给apk赋予system权限，但是我试过这两种方法，都有问题，就是在adb install的时候会显示签名不兼容，查看源代码会发现uid跟gid不匹配。这些是我这段时间发现的问题，大家有问题可以交流交流。

再说说几个简单的应用层截屏吧，很简单，就是几个函数调用而已

 View view = getWindow().getDecorView();
       Display display = this.getWindowManager().getDefaultDisplay();
       view.layout(0, 0, display.getWidth(), display.getHeight());
       view.setDrawingCacheEnabled(true);//允许当前窗口保存缓存信息，这样  getDrawingCache()方法才会返回一个Bitmap
       Bitmap bmp = Bitmap.createBitmap(view.getDrawingCache());

我对这个程序的理解就是，它仅仅只能截取当前的activity，也就是说如果你运行这个程序后它就截取你这个程序的当前屏幕的信息。我们假设你做成一个按钮，在点击按钮后sleep5秒再调用这个方法（假设你的activity叫做screen）。当你点击按钮以后，然后你再点击home或者返回按钮，等到5秒后你那个程序就会截取到你当前屏幕？不是！它只会截取那个运行于后台的screen这个activity。

还有个截屏的方法就是用OPENGL。

这里有我的opengl截屏的程序，方便的话可以下载后去看看。

http://www.oschina.net/code/snippet_729469_19233

这些只是我的一点小小的总结，而且肯定有不对的地方，希望大家一起来解决截屏的问题！

链接：http://blog.sina.com.cn/s/blog_69a04cf4010173fz.html