浅谈android截屏问题

于 2012-10-13 21:11:25 发布
阅读量8.7k 收藏 10
点赞数
分类专栏： android 文章标签： android null permissions frameworks user jni

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

    我是基于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  
29 using namespace android;
30  
31 int 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这个函数

下面是代码：

001 status_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  
113 status_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），相关源代码是：

001 status_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不匹配。这些是我这段时间发现的问题，大家有问题可以交流交流。

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

1 View 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。 

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

评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值