android 截屏

最新推荐文章于 2024-06-18 17:57:08 发布

原创最新推荐文章于 2024-06-18 17:57:08 发布 · 1.5k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#android #null #permissions #frameworks #user #jni

音视频多媒体专栏收录该内容

21 篇文章

订阅专栏

部署运行你感兴趣的模型镜像

http://www.oschina.net/question/223340_45857

http://my.oschina.net/JumpLong/blog/75556

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

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

 
   01/* 
 
   02 * Copyright (C) 2010 The Android Open Source Project 
 
   03 * 
 
   04 * Licensed under the Apache License, Version 2.0 (the "License"); 
 
   05 * you may not use this file except in compliance with the License. 
 
   06 * You may obtain a copy of the License at 
 
   07 * 
 
   08 *      http://www.apache.org/licenses/LICENSE-2.0 
 
   09 * 
 
   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#include <utils/Log.h> 
 
   18  
 
   19#include <binder/IPCThreadState.h> 
 
   20#include <binder/ProcessState.h> 
 
   21#include <binder/IServiceManager.h> 
 
   22  
 
   23#include <binder/IMemory.h> 
 
   24#include <surfaceflinger/ISurfaceComposer.h> 
 
   25  
 
   26#include <SkImageEncoder.h> 
 
   27#include <SkBitmap.h> 
 
   28  
 
   29using namespace android; 
 
   30  
 
   31int main(int argc, char** argv) 
 
   32{  
 
   33    if (argc != 2) { 
 
   34        printf("usage: %s path\n", argv[0]); 
 
   35        exit(0); 
 
   36    } 
 
   37  
 
   38    const String16 name("SurfaceFlinger"); 
 
   39    sp<ISurfaceComposer> composer; 
 
   40    getService(name, &composer); 
 
   41  
 
   42    sp<IMemoryHeap> heap; 
 
   43    uint32_t w, h; 
 
   44    PixelFormat f; 
 
   45    status_t err = composer->captureScreen(0, &heap, &w, &h, &f, 0, 0); 
 
   46    if (err != NO_ERROR) {  
 
   47        fprintf(stderr, "screen capture failed: %s\n", strerror(-err)); 
 
   48        exit(0); 
 
   49    } 
 
   50  
 
   51    printf("screen capture success: w=%u, h=%u, pixels=%p\n", 
 
   52            w, h, heap->getBase()); 
 
   53  
 
   54    printf("saving file as PNG in %s ...\n", argv[1]); 
 
   55  
 
   56    SkBitmap b; 
 
   57    b.setConfig(SkBitmap::kARGB_8888_Config, w, h); 
 
   58    b.setPixels(heap->getBase()); 
 
   59    SkImageEncoder::EncodeFile(argv[1], b, 
 
   60            SkImageEncoder::kPNG_Type, SkImageEncoder::kDefaultQuality); 
 
   61  
 
   62    return 0; 
 
   63}

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

下面是代码：

 
   001status_t SurfaceFlinger::captureScreenImplLocked(DisplayID dpy, 
 
   002        sp<IMemoryHeap>* heap, 
 
   003        uint32_t* w, uint32_t* h, PixelFormat* f, 
 
   004        uint32_t sw, uint32_t sh) 
 
   005{  
 
   006   LOGI("captureScreenImplLocked"); 
 
   007    status_t result = PERMISSION_DENIED; 
 
   008  
 
   009    // only one display supported for now 
 
   010    if (UNLIKELY(uint32_t(dpy) >= DISPLAY_COUNT)) 
 
   011        return BAD_VALUE; 
 
   012  
 
   013    if (!GLExtensions::getInstance().haveFramebufferObject()) 
 
   014        return INVALID_OPERATION;  
 
   015  
 
   016    // get screen geometry 
 
   017    const DisplayHardware& hw(graphicPlane(dpy).displayHardware()); 
 
   018    const uint32_t hw_w = hw.getWidth(); 
 
   019    const uint32_t hw_h = hw.getHeight(); 
 
   020  
 
   021    if ((sw > hw_w) || (sh > hw_h)) 
 
   022        return BAD_VALUE; 
 
   023  
 
   024    sw = (!sw) ? hw_w : sw; 
 
   025    sh = (!sh) ? hw_h : sh; 
 
   026    const size_t size = sw * sh * 4;  
 
   027  
 
   028    // make sure to clear all GL error flags 
 
   029    while ( glGetError() != GL_NO_ERROR ) ; 
 
   030  
 
   031    // create a FBO 
 
   032    GLuint name, tname; 
 
   033    glGenRenderbuffersOES(1, &tname); 
 
   034    glBindRenderbufferOES(GL_RENDERBUFFER_OES, tname); 
 
   035    glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_RGBA8_OES, sw, sh); 
 
   036    glGenFramebuffersOES(1, &name); 
 
   037    glBindFramebufferOES(GL_FRAMEBUFFER_OES, name); 
 
   038    glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, 
 
   039            GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, tname); 
 
   040  
 
   041    GLenum status = glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES); 
 
   042    if (status == GL_FRAMEBUFFER_COMPLETE_OES) { 
 
   043  
 
   044        // invert everything, b/c glReadPixel() below will invert the FB 
 
   045        glViewport(0, 0, sw, sh); 
 
   046        glScissor(0, 0, sw, sh); 
 
   047        glMatrixMode(GL_PROJECTION); 
 
   048        glPushMatrix(); 
 
   049        glLoadIdentity(); 
 
   050        glOrthof(0, hw_w, 0, hw_h, 0, 1); 
 
   051        glMatrixMode(GL_MODELVIEW); 
 
   052  
 
   053        // redraw the screen entirely... 
 
   054        glClearColor(0,0,0,1); 
 
   055        glClear(GL_COLOR_BUFFER_BIT); 
 
   056  
 
   057        const Vector< sp<LayerBase> >& layers(mVisibleLayersSortedByZ); 
 
   058        const size_t count = layers.size();  
 
   059        for (size_t i=0 ; i<count ; ++i) {  
 
   060            const sp<LayerBase>& layer(layers[i]); 
 
   061            layer->drawForSreenShot(); 
 
   062        } 
 
   063  
 
   064        // XXX: this is needed on tegra 
 
   065        glScissor(0, 0, sw, sh); 
 
   066  
 
   067        // check for errors and return screen capture 
 
   068        if (glGetError() != GL_NO_ERROR) { 
 
   069            // error while rendering 
 
   070            result = INVALID_OPERATION; 
 
   071        } else  { 
 
   072            // allocate shared memory large enough to hold the 
 
   073            // screen capture 
 
   074            sp<MemoryHeapBase> base( 
 
   075                    new MemoryHeapBase(size, 0, "screen-capture") ); 
 
   076            void* const  ptr = base->getBase(); 
 
   077            if (ptr) { 
 
   078                // capture the screen with glReadPixels() 
 
   079                glReadPixels(0, 0, sw, sh, GL_RGBA, GL_UNSIGNED_BYTE, ptr); 
 
   080                if (glGetError() == GL_NO_ERROR) { 
 
   081                    *heap = base; 
 
   082                    *w = sw; 
 
   083                    *h = sh; 
 
   084                    *f = PIXEL_FORMAT_RGBA_8888; 
 
   085                    result = NO_ERROR; 
 
   086                } 
 
   087            } else  { 
 
   088                result = NO_MEMORY; 
 
   089            } 
 
   090        } 
 
   091        glEnable(GL_SCISSOR_TEST); 
 
   092        glViewport(0, 0, hw_w, hw_h); 
 
   093        glMatrixMode(GL_PROJECTION); 
 
   094        glPopMatrix(); 
 
   095        glMatrixMode(GL_MODELVIEW); 
 
   096  
 
   097  
 
   098    } else  { 
 
   099        result = BAD_VALUE; 
 
   100    } 
 
   101  
 
   102    // release FBO resources 
 
   103    glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0); 
 
   104    glDeleteRenderbuffersOES(1, &tname); 
 
   105    glDeleteFramebuffersOES(1, &name); 
 
   106  
 
   107    hw.compositionComplete(); 
 
   108  
 
   109    return result; 
 
   110}  
 
   111  
 
   112  
 
   113status_t SurfaceFlinger::captureScreen(DisplayID dpy, 
 
   114        sp<IMemoryHeap>* heap, 
 
   115        uint32_t* width, uint32_t* height, PixelFormat* format, 
 
   116        uint32_t sw, uint32_t sh) 
 
   117{  
 
   118           LOGI("into captureScreen");            
 
   119    // only one display supported for now 
 
   120    if (UNLIKELY(uint32_t(dpy) >= DISPLAY_COUNT)) 
 
   121        return BAD_VALUE; 
 
   122  
 
   123    if (!GLExtensions::getInstance().haveFramebufferObject()) 
 
   124        return INVALID_OPERATION;  
 
   125  
 
   126    class MessageCaptureScreen :  public MessageBase { 
 
   127        SurfaceFlinger* flinger; 
 
   128        DisplayID dpy; 
 
   129        sp<IMemoryHeap>* heap; 
 
   130        uint32_t* w; 
 
   131        uint32_t* h; 
 
   132        PixelFormat* f; 
 
   133        uint32_t sw; 
 
   134        uint32_t sh; 
 
   135        status_t result; 
 
   136    public: 
 
   137        MessageCaptureScreen(SurfaceFlinger* flinger, DisplayID dpy, 
 
   138                sp<IMemoryHeap>* heap, uint32_t* w, uint32_t* h, PixelFormat* f, 
 
   139                uint32_t sw, uint32_t sh) 
 
   140            : flinger(flinger), dpy(dpy), 
 
   141              heap(heap), w(w), h(h), f(f), sw(sw), sh(sh), result(PERMISSION_DENIED) 
 
   142        { 
 
   143  
 
   144        } 
 
   145        status_t getResult() const  { 
 
   146           LOGI("getResult()");            
 
   147         return result; 
 
   148        } 
 
   149        virtual bool handler() { 
 
   150  
 
   151  
 
   152   LOGI("handler()"); 
 
   153            Mutex::Autolock _l(flinger->mStateLock); 
 
   154  
 
   155            // if we have secure windows, never allow the screen capture 
 
   156            if (flinger->mSecureFrameBuffer) 
 
   157                return true; 
 
   158  
 
   159            result = flinger->captureScreenImplLocked(dpy, 
 
   160                    heap, w, h, f, sw, sh); 
 
   161  
 
   162            return true; 
 
   163        } 
 
   164    }; 
 
   165   LOGI("before messagecapturescreen"); 
 
   166    sp<MessageBase> msg = new  MessageCaptureScreen(this, 
 
   167            dpy, heap, width, height, format, sw, sh); 
 
   168    status_t res = postMessageSync(msg); 
 
   169    if (res == NO_ERROR) {  
 
   170        res = static_cast<MessageCaptureScreen*>( msg.get() )->getResult(); 
 
   171    } 
 
   172    return res; 
 
   173}

而这个函数关键又使用了opengl的几个函数去获得图片，然而opengl又去read framebuffer（这是我的理解）。如果你去用jni调用so的方法去截屏的话，就可以把screencap这个文件稍微修改一下然后做成so文件，方法可以参考这篇博客：http://blog.youkuaiyun.com/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），相关源代码是：

 
   001status_t SurfaceFlinger::onTransact( 
 
   002    uint32_t code, const  Parcel& data, Parcel* reply, uint32_t flags)  
 
   003{  
 
   004  
 
   005    switch (code) { 
 
   006        case CREATE_CONNECTION:  
 
   007        case OPEN_GLOBAL_TRANSACTION: 
 
   008        case CLOSE_GLOBAL_TRANSACTION: 
 
   009        case SET_ORIENTATION:  
 
   010        case FREEZE_DISPLAY:  
 
   011        case UNFREEZE_DISPLAY:  
 
   012        case BOOT_FINISHED: 
 
   013        case TURN_ELECTRON_BEAM_OFF: 
 
   014        case TURN_ELECTRON_BEAM_ON:  
 
   015        { 
 
   016            // codes that require permission check 
 
   017            IPCThreadState* ipc = IPCThreadState::self(); 
 
   018            const int pid = ipc->getCallingPid(); 
 
   019            const int uid = ipc->getCallingUid(); 
 
   020            if ((uid != AID_GRAPHICS) && !mAccessSurfaceFlinger.check(pid, uid)) { 
 
   021                LOGE("Permission Denial: "
 
   022                        "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid); 
 
   023                return PERMISSION_DENIED;  
 
   024            } 
 
   025            break; 
 
   026        } 
 
   027        case CAPTURE_SCREEN:  
 
   028        { 
 
   029            // codes that require permission check 
 
   030            IPCThreadState* ipc = IPCThreadState::self(); 
 
   031            const int pid = ipc->getCallingPid(); 
 
   032            const int uid = ipc->getCallingUid(); 
 
   033            if ((uid != AID_GRAPHICS) && !mReadFramebuffer.check(pid, uid)) { 
 
   034  
 
   035                LOGE("Permission Denial: "
 
   036                        "can't read framebuffer pid=%d, uid=%d", pid, uid); 
 
   037                return PERMISSION_DENIED;  
 
   038            } 
 
   039  
 
   040            break; 
 
   041        } 
 
   042    } 
 
   043  
 
   044    status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags); 
 
   045    if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) { 
 
   046        CHECK_INTERFACE(ISurfaceComposer, data, reply); 
 
   047        if (UNLIKELY(!mHardwareTest.checkCalling())) { 
 
   048            IPCThreadState* ipc = IPCThreadState::self(); 
 
   049            const int pid = ipc->getCallingPid(); 
 
   050            const int uid = ipc->getCallingUid(); 
 
   051  
 
   052   LOGI("err"); 
 
   053            LOGE("Permission Denial: "
 
   054                    "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid); 
 
   055            return PERMISSION_DENIED;  
 
   056        } 
 
   057        int n; 
 
   058        switch (code) { 
 
   059            case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE 
 
   060            case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE 
 
   061                return NO_ERROR; 
 
   062            case 1002:  // SHOW_UPDATES 
 
   063                n = data.readInt32(); 
 
   064                mDebugRegion = n ? n : (mDebugRegion ? 0 : 1); 
 
   065                return NO_ERROR; 
 
   066            case 1003:  // SHOW_BACKGROUND 
 
   067                n = data.readInt32(); 
 
   068                mDebugBackground = n ? 1 : 0; 
 
   069                return NO_ERROR; 
 
   070            case 1004:{ // repaint everything 
 
   071                Mutex::Autolock _l(mStateLock); 
 
   072                const DisplayHardware& hw(graphicPlane(0).displayHardware()); 
 
   073                mDirtyRegion.set(hw.bounds()); // careful that's not thread-safe 
 
   074                signalEvent(); 
 
   075                return NO_ERROR; 
 
   076            } 
 
   077            case 1005:{ // force transaction 
 
   078                setTransactionFlags(eTransactionNeeded|eTraversalNeeded); 
 
   079                return NO_ERROR; 
 
   080            } 
 
   081            case 1006:{ // enable/disable GraphicLog 
 
   082                int enabled = data.readInt32(); 
 
   083                GraphicLog::getInstance().setEnabled(enabled); 
 
   084                return NO_ERROR; 
 
   085            } 
 
   086            case 1007: // set mFreezeCount 
 
   087                mFreezeCount = data.readInt32(); 
 
   088                mFreezeDisplayTime = 0; 
 
   089                return NO_ERROR; 
 
   090            case 1010:  // interrogate. 
 
   091                reply->writeInt32(0); 
 
   092                reply->writeInt32(0); 
 
   093                reply->writeInt32(mDebugRegion); 
 
   094                reply->writeInt32(mDebugBackground); 
 
   095                return NO_ERROR; 
 
   096            case 1013: { 
 
   097                Mutex::Autolock _l(mStateLock); 
 
   098                const DisplayHardware& hw(graphicPlane(0).displayHardware()); 
 
   099                reply->writeInt32(hw.getPageFlipCount()); 
 
   100            } 
 
   101            return NO_ERROR; 
 
   102        } 
 
   103    } 
 
   104    return err; 
 
   105}

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

 
   01   int checkSignaturesLP(Signature[] s1, Signature[] s2) { 
 
   02       if (s1 == null) { 
 
   03           return s2 == null 
 
   04                   ? PackageManager.SIGNATURE_NEITHER_SIGNED 
 
   05                   : PackageManager.SIGNATURE_FIRST_NOT_SIGNED; 
 
   06       } 
 
   07       if (s2 == null) { 
 
   08           return PackageManager.SIGNATURE_SECOND_NOT_SIGNED; 
 
   09       } 
 
   10       HashSet<Signature> set1 = new HashSet<Signature>(); 
 
   11       for (Signature sig : s1) {  
 
   12           set1.add(sig); 
 
   13       } 
 
   14       HashSet<Signature> set2 = new HashSet<Signature>(); 
 
   15       for (Signature sig : s2) {  
 
   16           set2.add(sig); 
 
   17       } 
 
   18       // Make sure s2 contains all signatures in s1. 
 
   19       if (set1.equals(set2)) {  
 
   20           return PackageManager.SIGNATURE_MATCH; 
 
   21       } 
 
   22       return PackageManager.SIGNATURE_NO_MATCH; 
 
   23   } 
 
   24 
 
   25 
 
   26 
 
   27// Check for shared user signatures 
 
   28       if (pkgSetting.sharedUser != null && pkgSetting.sharedUser.signatures.mSignatures != null) { 
 
   29           if (checkSignaturesLP(pkgSetting.sharedUser.signatures.mSignatures, 
 
   30                   pkg.mSignatures) != PackageManager.SIGNATURE_MATCH) { 
 
   31               Slog.e(TAG, "Package "  + pkg.packageName 
 
   32                       + " has no signatures that match those in shared user "
 
   33                       + pkgSetting.sharedUser.name + "; ignoring!");  
 
   34               mLastScanError = PackageManager.INSTALL_FAILED_SHARED_USER_INCOMPATIBLE; 
 
   35               return false; 
 
   36           } 
 
   37       } 
 
   38       return true; 
 
   39 
 
   40 
 
   41   private boolean verifySignaturesLP(PackageSetting pkgSetting, 
 
   42           PackageParser.Package pkg) { 
 
   43 
 
   44       // Check for shared user signatures 
 
   45       if (pkgSetting.sharedUser != null && pkgSetting.sharedUser.signatures.mSignatures != null) { 
 
   46             
 
   47       if (checkSignaturesLP(pkgSetting.sharedUser.signatures.mSignatures, 
 
   48                   pkg.mSignatures) != PackageManager.SIGNATURE_MATCH) { 
 
   49                 
 
   50           Slog.e(TAG, "Package "  + pkg.packageName 
 
   51                       + " has no signatures that match those in shared user "
 
   52                       + pkgSetting.sharedUser.name + "; ignoring!");  
 
   53               mLastScanError = PackageManager.INSTALL_FAILED_SHARED_USER_INCOMPATIBLE; 
 
   54               return false; 
 
   55 
 
   56           } 
 
   57       } 
 
   58       return true; 
 
   59   }

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

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

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

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

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

您可能感兴趣的与本文相关的镜像