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;

importandroid.app.Activity;
importandroid.graphics.Bitmap;
importandroid.graphics.Rect;
importandroid.util.Log;
importandroid.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目录里面才可以执行）。

[cpp] view plain copy

1. /*
2. *Copyright(C)2010TheAndroidOpenSourceProject
3. *
4. *LicensedundertheApacheLicense,Version2.0(the"License");
5. *youmaynotusethisfileexceptincompliancewiththeLicense.
6. *YoumayobtainacopyoftheLicenseat
7. *
8. *http://www.apache.org/licenses/LICENSE-2.0
9. *
10. *Unlessrequiredbyapplicablelaworagreedtoinwriting,software
11. *distributedundertheLicenseisdistributedonan"ASIS"BASIS,
12. *WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied.
13. *SeetheLicenseforthespecificlanguagegoverningpermissionsand
14. *limitationsundertheLicense.
15. */
17. #include<utils/Log.h>
19. #include<binder/IPCThreadState.h>
20. #include<binder/ProcessState.h>
21. #include<binder/IServiceManager.h>
23. #include<binder/IMemory.h>
24. #include<surfaceflinger/ISurfaceComposer.h>
26. #include<SkImageEncoder.h>
27. #include<SkBitmap.h>
29. usingnamespaceandroid;
31. intmain(intargc,char**argv)
32. {
33. if(argc!=2){
34. printf("usage:%spath\n",argv[0]);
35. exit(0);
36. }
38. constString16name("SurfaceFlinger");
39. sp<ISurfaceComposer>composer;
40. getService(name,&composer);
42. sp<IMemoryHeap>heap;
43. uint32_tw,h;
44. PixelFormatf;
45. status_terr=composer->captureScreen(0,&heap,&w,&h,&f,0,0);
46. if(err!=NO_ERROR){
47. fprintf(stderr,"screencapturefailed:%s\n",strerror(-err));
48. exit(0);
49. }
51. printf("screencapturesuccess:w=%u,h=%u,pixels=%p\n",
52. w,h,heap->getBase());
54. printf("savingfileasPNGin%s...\n",argv[1]);
56. SkBitmapb;
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);
62. return0;
63. }

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

下面是代码：

[cpp] view plain copy

1. status_tSurfaceFlinger::captureScreenImplLocked(DisplayIDdpy,
2. sp<IMemoryHeap>*heap,
3. uint32_t*w,uint32_t*h,PixelFormat*f,
4. uint32_tsw,uint32_tsh)
5. {
6. LOGI("captureScreenImplLocked");
7. status_tresult=PERMISSION_DENIED;
9. //onlyonedisplaysupportedfornow
10. if(UNLIKELY(uint32_t(dpy)>=DISPLAY_COUNT))
11. returnBAD_VALUE;
13. if(!GLExtensions::getInstance().haveFramebufferObject())
14. returnINVALID_OPERATION;
16. //getscreengeometry
17. constDisplayHardware&hw(graphicPlane(dpy).displayHardware());
18. constuint32_thw_w=hw.getWidth();
19. constuint32_thw_h=hw.getHeight();
21. if((sw>hw_w)||(sh>hw_h))
22. returnBAD_VALUE;
24. sw=(!sw)?hw_w:sw;
25. sh=(!sh)?hw_h:sh;
26. constsize_tsize=sw*sh*4;
28. //makesuretoclearallGLerrorflags
29. while(glGetError()!=GL_NO_ERROR);
31. //createaFBO
32. GLuintname,tname;
33. glGenRenderbuffersOES(1,&tname);
34. glBindRenderbufferOES(GL_RENDERBUFFER_OES,tname);
35. glRenderbufferStorageOES(GL_RENDERBUFFER_OES,GL_RGBA8_OES,sw,sh);
36. glGenFramebuffersOES(1,&name);
37. glBindFramebufferOES(GL_FRAMEBUFFER_OES,name);
38. glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES,
39. GL_COLOR_ATTACHMENT0_OES,GL_RENDERBUFFER_OES,tname);
41. GLenumstatus=glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES);
42. if(status==GL_FRAMEBUFFER_COMPLETE_OES){
44. //inverteverything,b/cglReadPixel()belowwillinverttheFB
45. glViewport(0,0,sw,sh);
46. glScissor(0,0,sw,sh);
47. glMatrixMode(GL_PROJECTION);
48. glPushMatrix();
49. glLoadIdentity();
50. glOrthof(0,hw_w,0,hw_h,0,1);
51. glMatrixMode(GL_MODELVIEW);
53. //redrawthescreenentirely...
54. glClearColor(0,0,0,1);
55. glClear(GL_COLOR_BUFFER_BIT);
57. constVector<sp<LayerBase>>&layers(mVisibleLayersSortedByZ);
58. constsize_tcount=layers.size();
59. for(size_ti=0;i<count;++i){
60. constsp<LayerBase>&layer(layers[i]);
61. layer->drawForSreenShot();
62. }
64. //XXX:thisisneededontegra
65. glScissor(0,0,sw,sh);
67. //checkforerrorsandreturnscreencapture
68. if(glGetError()!=GL_NO_ERROR){
69. //errorwhilerendering
70. result=INVALID_OPERATION;
71. }else{
72. //allocatesharedmemorylargeenoughtoholdthe
73. //screencapture
74. sp<MemoryHeapBase>base(
75. newMemoryHeapBase(size,0,"screen-capture"));
76. void*constptr=base->getBase();
77. if(ptr){
78. //capturethescreenwithglReadPixels()
79. glReadPixels(0,0,sw,sh,GL_RGBA,GL_UNSIGNED_BYTE,ptr);
80. if(glGetError()==GL_NO_ERROR){
81. *heap=base;
82. *w=sw;
83. *h=sh;
84. *f=PIXEL_FORMAT_RGBA_8888;
85. result=NO_ERROR;
86. }
87. }else{
88. result=NO_MEMORY;
89. }
90. }
91. glEnable(GL_SCISSOR_TEST);
92. glViewport(0,0,hw_w,hw_h);
93. glMatrixMode(GL_PROJECTION);
94. glPopMatrix();
95. glMatrixMode(GL_MODELVIEW);
98. }else{
99. result=BAD_VALUE;
100. }
102. //releaseFBOresources
103. glBindFramebufferOES(GL_FRAMEBUFFER_OES,0);
104. glDeleteRenderbuffersOES(1,&tname);
105. glDeleteFramebuffersOES(1,&name);
107. hw.compositionComplete();
109. returnresult;
110. }
113. status_tSurfaceFlinger::captureScreen(DisplayIDdpy,
114. sp<IMemoryHeap>*heap,
115. uint32_t*width,uint32_t*height,PixelFormat*format,
116. uint32_tsw,uint32_tsh)
117. {
118. LOGI("intocaptureScreen");
119. //onlyonedisplaysupportedfornow
120. if(UNLIKELY(uint32_t(dpy)>=DISPLAY_COUNT))
121. returnBAD_VALUE;
123. if(!GLExtensions::getInstance().haveFramebufferObject())
124. returnINVALID_OPERATION;
126. classMessageCaptureScreen:publicMessageBase{
127. SurfaceFlinger*flinger;
128. DisplayIDdpy;
129. sp<IMemoryHeap>*heap;
130. uint32_t*w;
131. uint32_t*h;
132. PixelFormat*f;
133. uint32_tsw;
134. uint32_tsh;
135. status_tresult;
136. public:
137. MessageCaptureScreen(SurfaceFlinger*flinger,DisplayIDdpy,
138. sp<IMemoryHeap>*heap,uint32_t*w,uint32_t*h,PixelFormat*f,
139. uint32_tsw,uint32_tsh)
140. :flinger(flinger),dpy(dpy),
141. heap(heap),w(w),h(h),f(f),sw(sw),sh(sh),result(PERMISSION_DENIED)
142. {
144. }
145. status_tgetResult()const{
146. LOGI("getResult()");
147. returnresult;
148. }
149. virtualboolhandler(){
152. LOGI("handler()");
153. Mutex::Autolock_l(flinger->mStateLock);
155. //ifwehavesecurewindows,neverallowthescreencapture
156. if(flinger->mSecureFrameBuffer)
157. returntrue;
159. result=flinger->captureScreenImplLocked(dpy,
160. heap,w,h,f,sw,sh);
162. returntrue;
163. }
164. };
165. LOGI("beforemessagecapturescreen");
166. sp<MessageBase>msg=newMessageCaptureScreen(this,
167. dpy,heap,width,height,format,sw,sh);
168. status_tres=postMessageSync(msg);
169. if(res==NO_ERROR){
170. res=static_cast<MessageCaptureScreen*>(msg.get())->getResult();
171. }
172. returnres;
173. }

而这个函数关键又使用了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），相关源代码是：

[cpp] view plain copy

1. status_tSurfaceFlinger::onTransact(
2. uint32_tcode,constParcel&data,Parcel*reply,uint32_tflags)
3. {
5. switch(code){
6. caseCREATE_CONNECTION:
7. caseOPEN_GLOBAL_TRANSACTION:
8. caseCLOSE_GLOBAL_TRANSACTION:
9. caseSET_ORIENTATION:
10. caseFREEZE_DISPLAY:
11. caseUNFREEZE_DISPLAY:
12. caseBOOT_FINISHED:
13. caseTURN_ELECTRON_BEAM_OFF:
14. caseTURN_ELECTRON_BEAM_ON:
15. {
16. //codesthatrequirepermissioncheck
17. IPCThreadState*ipc=IPCThreadState::self();
18. constintpid=ipc->getCallingPid();
19. constintuid=ipc->getCallingUid();
20. if((uid!=AID_GRAPHICS)&&!mAccessSurfaceFlinger.check(pid,uid)){
21. LOGE("PermissionDenial:"
22. "can'taccessSurfaceFlingerpid=%d,uid=%d",pid,uid);
23. returnPERMISSION_DENIED;
24. }
25. break;
26. }
27. caseCAPTURE_SCREEN:
28. {
29. //codesthatrequirepermissioncheck
30. IPCThreadState*ipc=IPCThreadState::self();
31. constintpid=ipc->getCallingPid();
32. constintuid=ipc->getCallingUid();
33. if((uid!=AID_GRAPHICS)&&!mReadFramebuffer.check(pid,uid)){
35. LOGE("PermissionDenial:"
36. "can'treadframebufferpid=%d,uid=%d",pid,uid);
37. returnPERMISSION_DENIED;
38. }
40. break;
41. }
42. }
44. status_terr=BnSurfaceComposer::onTransact(code,data,reply,flags);
45. if(err==UNKNOWN_TRANSACTION||err==PERMISSION_DENIED){
46. CHECK_INTERFACE(ISurfaceComposer,data,reply);
47. if(UNLIKELY(!mHardwareTest.checkCalling())){
48. IPCThreadState*ipc=IPCThreadState::self();
49. constintpid=ipc->getCallingPid();
50. constintuid=ipc->getCallingUid();
52. LOGI("err");
53. LOGE("PermissionDenial:"
54. "can'taccessSurfaceFlingerpid=%d,uid=%d",pid,uid);
55. returnPERMISSION_DENIED;
56. }
57. intn;
58. switch(code){
59. case1000://SHOW_CPU,NOTSUPPORTEDANYMORE
60. case1001://SHOW_FPS,NOTSUPPORTEDANYMORE
61. returnNO_ERROR;
62. case1002://SHOW_UPDATES
63. n=data.readInt32();
64. mDebugRegion=n?n:(mDebugRegion?0:1);
65. returnNO_ERROR;
66. case1003://SHOW_BACKGROUND
67. n=data.readInt32();
68. mDebugBackground=n?1:0;
69. returnNO_ERROR;
70. case1004:{//repainteverything
71. Mutex::Autolock_l(mStateLock);
72. constDisplayHardware&hw(graphicPlane(0).displayHardware());
73. mDirtyRegion.set(hw.bounds());//carefulthat'snotthread-safe
74. signalEvent();
75. returnNO_ERROR;
76. }
77. case1005:{//forcetransaction
78. setTransactionFlags(eTransactionNeeded|eTraversalNeeded);
79. returnNO_ERROR;
80. }
81. case1006:{//enable/disableGraphicLog
82. intenabled=data.readInt32();
83. GraphicLog::getInstance().setEnabled(enabled);
84. returnNO_ERROR;
85. }
86. case1007://setmFreezeCount
87. mFreezeCount=data.readInt32();
88. mFreezeDisplayTime=0;
89. returnNO_ERROR;
90. case1010://interrogate.
91. reply->writeInt32(0);
92. reply->writeInt32(0);
93. reply->writeInt32(mDebugRegion);
94. reply->writeInt32(mDebugBackground);
95. returnNO_ERROR;
96. case1013:{
97. Mutex::Autolock_l(mStateLock);
98. constDisplayHardware&hw(graphicPlane(0).displayHardware());
99. reply->writeInt32(hw.getPageFlipCount());
100. }
101. returnNO_ERROR;
102. }
103. }
104. returnerr;
105. }

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

[cpp] view plain copy

1. intcheckSignaturesLP(Signature[]s1,Signature[]s2){
2. if(s1==null){
3. returns2==null
4. ?PackageManager.SIGNATURE_NEITHER_SIGNED
5. :PackageManager.SIGNATURE_FIRST_NOT_SIGNED;
6. }
7. if(s2==null){
8. returnPackageManager.SIGNATURE_SECOND_NOT_SIGNED;
9. }
10. HashSet<Signature>set1=newHashSet<Signature>();
11. for(Signaturesig:s1){
12. set1.add(sig);
13. }
14. HashSet<Signature>set2=newHashSet<Signature>();
15. for(Signaturesig:s2){
16. set2.add(sig);
17. }
18. //Makesures2containsallsignaturesins1.
19. if(set1.equals(set2)){
20. returnPackageManager.SIGNATURE_MATCH;
21. }
22. returnPackageManager.SIGNATURE_NO_MATCH;
23. }
27. Checkforsharedusersignatures
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. +"hasnosignaturesthatmatchthoseinshareduser"
33. +pkgSetting.sharedUser.name+";ignoring!");
34. mLastScanError=PackageManager.INSTALL_FAILED_SHARED_USER_INCOMPATIBLE;
35. returnfalse;
36. }
37. }
38. returntrue;
41. privatebooleanverifySignaturesLP(PackageSettingpkgSetting,
42. PackageParser.Packagepkg){
44. //Checkforsharedusersignatures
45. if(pkgSetting.sharedUser!=null&&pkgSetting.sharedUser.signatures.mSignatures!=null){
47. (checkSignaturesLP(pkgSetting.sharedUser.signatures.mSignatures,
48. pkg.mSignatures)!=PackageManager.SIGNATURE_MATCH){
50. log.e(TAG,"Package"+pkg.packageName
51. +"hasnosignaturesthatmatchthoseinshareduser"
52. +pkgSetting.sharedUser.name+";ignoring!");
53. mLastScanError=PackageManager.INSTALL_FAILED_SHARED_USER_INCOMPATIBLE;
54. returnfalse;
56. }
57. }
58. returntrue;
59. }

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

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

[java] view plain copy

1. Viewview=getWindow().getDecorView();
2. Displaydisplay=this.getWindowManager().getDefaultDisplay();
3. view.layout(0,0,display.getWidth(),display.getHeight());
4. view.setDrawingCacheEnabled(true);//允许当前窗口保存缓存信息，这样getDrawingCache()方法才会返回一个Bitmap
5. Bitmapbmp=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

更多相关文章

1. C语言函数以及函数的使用
2. Android中attrs.xml文件的使用详解
3. 安卓selector使用方法
4. 如何给你的Android 安装文件（APK）瘦身
5. 教你用电脑从 Google Play 下载 Android 程序 apk 文件
6. 应用界面主题Theme使用方法
7. Android 使用html做UI的方法---js与java的相互调用

随机推荐

1. js调Android与IOS方法
2. Android调用摄像头和相册
3. Android adb 常用命令
4. android 二维码 扫描与生成（内置）
5. Android(安卓)开机Process xxx (pid xxxx
6. 使用eclipse与android studio 在开发自定
7. 微信内置浏览器UserAgent获取
8. Android通过zxing来进行二维码识别与生成
9. Android Fragment 生命周期onCreatView、
10. Android帧缓冲区（Frame Buffer）硬件抽象层（H