Android 屏幕截屏方法汇总

1、直接使用getwindow().getdecorview().getrootview()

直接使用getwindow().getdecorview().getrootview()是获取当前屏幕的activity。然而对于系统状态栏的信息是截不了，出现一条空白的。如下图：

 

主要到没，有一条白色边就是系统状态栏。看一下代码，很简单都加了注释了。

//这种方法状态栏是空白，显示不了状态栏的信息
private void savecurrentimage()
{
//获取当前屏幕的大小
int width = getwindow().getdecorview().getrootview().getwidth();
int height = getwindow().getdecorview().getrootview().getheight();
//生成相同大小的图片
bitmap tembitmap = bitmap.createbitmap( width, height, config.argb_8888 );
//找到当前页面的跟布局
view view = getwindow().getdecorview().getrootview();
//设置缓存
view.setdrawingcacheenabled(true);
view.builddrawingcache();
//从缓存中获取当前屏幕的图片
tembitmap = view.getdrawingcache();
//输出到sd卡
if (fileioutil.getexiststorage()) {
fileioutil.getinstance().onfolderanalysis(fileioutil.getinstance().getfilepathandname());
file file = new file(fileioutil.getinstance().getfilepathandname());
try {
if (!file.exists()) {
file.createnewfile();
}
fileoutputstream fostream = new fileoutputstream(file);
tembitmap.compress(bitmap.compressformat.png, 100, fostream);
fostream.flush();
fostream.close();
} catch (exception e) {
log.i("show", e.tostring());
}
}
}

2、自定义view控件的截图

自定义view控件都是继承view的吗，那么就有可以获取宽度，高度。生成图片，把它绘制出来的。我拿了直接写的自定义随机验证码的例子来截图。

//保存自定义view的截图
private void savecustomviewbitmap() {
//获取自定义view图片的大小
bitmap tembitmap = bitmap.createbitmap(mcodeview.getwidth(), mcodeview.getheight(), config.argb_8888);
//使用canvas，调用自定义view控件的ondraw方法，绘制图片
canvas canvas = new canvas(tembitmap);
mcodeview.ondraw(canvas);
//输出到sd卡
if (fileioutil.getexiststorage()) {
fileioutil.getinstance().onfolderanalysis(fileioutil.getinstance().getfilepathandname());
file file = new file(fileioutil.getinstance().getfilepathandname());
try {
if (!file.exists()) {
file.createnewfile();
}
fileoutputstream fostream = new fileoutputstream(file);
tembitmap.compress(bitmap.compressformat.png, 100, fostream);
fostream.flush();
fostream.close();
toast.maketext(mainactivity.this, "截屏文件已保存至" + fileioutil.getinstance().getfilepathandname(), toast.length_long).show();
} catch (exception e) {
log.i("show", e.tostring());
}
}
}

有人根据这种思路，自定义整个布局的view，然后来截图。也是够拼的，我有点不赞成这样使用。

3、基于android ddmlib截屏

这个是java写的一个类，入口是mian函数。那么这种实现方式是要android连接着电脑，还需要android设备调试。这种不多说，搞android开发都懂。太麻烦了，我们也不使用。

package com.example.screenshot;
import java.io.ioexception;
import java.text.simpledateformat;
import java.util.date;
import com.android.ddmlib.adbcommandrejectedexception;
import com.android.ddmlib.androiddebugbridge;
import com.android.ddmlib.idevice;
import com.android.ddmlib.rawimage;
import com.android.ddmlib.timeoutexception;
public class screenshoddmlib {
private bufferedimage image = null;
/**
* @param args
*/
public static void main(string[] args) {
// todo auto-generated method stub
androiddebugbridge.init(false); //
screenshoddmlib screenshot = new screenshoddmlib();
idevice device = screenshot.getdevice();
for (int i = 0; i < 10; i++) {
date date=new date();
simpledateformat df=new simpledateformat("mm-dd-hh-mm-ss");
string nowtime = df.format(date);
screenshot.getscreenshot(device, "robotium" + nowtime);
try {
thread.sleep(1000);
} catch (interruptedexception e) {
// todo auto-generated catch block
e.printstacktrace();
}
}
}
public void getscreenshot(idevice device,string filename) {
rawimage rawscreen = null;
try {
rawscreen = device.getscreenshot();
} catch (timeoutexception e) {
// todo auto-generated catch block
e.printstacktrace();
} catch (adbcommandrejectedexception e) {
// todo auto-generated catch block
e.printstacktrace();
} catch (ioexception e) {
// todo auto-generated catch block
e.printstacktrace();
}
if (rawscreen != null) {
boolean landscape = false;
int width2 = landscape ? rawscreen.height : rawscreen.width;
int height2 = landscape ? rawscreen.width : rawscreen.height;
if (image == null) {
image = new bufferedimage(width2, height2,
bufferedimage.type_int_rgb);
} else {
if (image.getheight() != height2 || image.getwidth() != width2) {
image = new bufferedimage(width2, height2,
bufferedimage.type_int_rgb);
}
}
int index = 0;
int indexinc = rawscreen.bpp >> 3;
for (int y = 0; y < rawscreen.height; y++) {
for (int x = 0; x < rawscreen.width; x++, index += indexinc) {
int value = rawscreen.getargb(index);
if (landscape)
image.setrgb(y, rawscreen.width - x - 1, value);
else
image.setrgb(x, y, value);
}
}
try {
imageio.write((renderedimage) image, "png", new file("d:/"
+ filename + ".jpg"));
} catch (ioexception e) {
// todo auto-generated catch block
e.printstacktrace();
}
}
}
/**
* 获取得到device对象
* @return
*/
private idevice getdevice(){
idevice device;
androiddebugbridge bridge = androiddebugbridge
.createbridge("adb", true);//如果代码有问题请查看api，修改此处的参数值试一下
waitdeviceslist(bridge);
idevice devices[] = bridge.getdevices();
device = devices[0];
return device;
}
/**
* 等待查找device
* @param bridge
*/
private void waitdeviceslist(androiddebugbridge bridge) {
int count = 0;
while (bridge.hasinitialdevicelist() == false) {
try {
thread.sleep(500);
count++;
} catch (interruptedexception e) {
}
if (count > 240) {
system.err.print("等待获取设备超时");
break;
}
}
}

4、使用adb命令

需要系统权限，在apk中调用“adb shell screencap -pfilepath” 命令

需要获得系统权限：

1、 在androidmanifest.xml文件中添加 <uses-permissionandroid:name="android.permission.read_frame_buffer"/>

2、修改apk为系统权限，将apk放到源码中编译， 修改android.mk local_certificate := platform
在这里我要说一下，搞过jni调用就知道android.mk的作用。此举也是麻烦，效果也不是很好。

public void takescreenshot(){
string msavedpath = environment.getexternalstoragedirectory()+file. separator + "screenshot.png" ;
try {
runtime. getruntime().exec("screencap -p " + msavedpath);
} catch (exception e) {
e.printstacktrace();
}

5、看一下系统截屏是怎样的

相信大家都知道，三星的机子是同时按下 home键 + 电源键 3秒截图。
如果没有home键的机子是按下 音量键向下那个 + 电源键 3秒截图的。
获取物理键盘按下的源码：phonewindowmanager.java

// handle special keys.
switch (keycode) {
case keyevent.keycode_volume_down:
case keyevent.keycode_volume_up:
case keyevent.keycode_volume_mute: {
if (keycode == keyevent.keycode_volume_down) {
if (down) {
if (isscreenon && !mvolumedownkeytriggered
&& (event.getflags() & keyevent.flag_fallback) == 0) {
mvolumedownkeytriggered = true;
mvolumedownkeytime = event.getdowntime();
mvolumedownkeyconsumedbyscreenshotchord = false;
cancelpendingpowerkeyaction();
interceptscreenshotchord();
}
} else {
mvolumedownkeytriggered = false;
cancelpendingscreenshotchordaction();
}
} else if (keycode == keyevent.keycode_volume_up) {
if (down) {
if (isscreenon && !mvolumeupkeytriggered
&& (event.getflags() & keyevent.flag_fallback) == 0) {
mvolumeupkeytriggered = true;
cancelpendingpowerkeyaction();
cancelpendingscreenshotchordaction();
}
} else {
mvolumeupkeytriggered = false;
cancelpendingscreenshotchordaction();
}
}
if (down) {
itelephony telephonyservice = gettelephonyservice();
if (telephonyservice != null) {
try {
if (telephonyservice.isringing()) {
// if an incoming call is ringing, either volume key means
// "silence ringer". we handle these keys here, rather than
// in the incallscreen, to make sure we'll respond to them
// even if the incallscreen hasn't come to the foreground yet.
// look for the down event here, to agree with the "fallback"
// behavior in the incallscreen.
log.i(tag, "interceptkeybeforequeueing:"
+ " volume key-down while ringing: silence ringer!");
// silence the ringer. (it's safe to call this
// even if the ringer has already been silenced.)
telephonyservice.silenceringer();
// and *don't* pass this key thru to the current activity
// (which is probably the incallscreen.)
result &= ~action_pass_to_user;
break;
}
if (telephonyservice.isoffhook()
&& (result & action_pass_to_user) == 0) {
// if we are in call but we decided not to pass the key to
// the application, handle the volume change here.
handlevolumekey(audiomanager.stream_voice_call, keycode);
break;
}
} catch (remoteexception ex) {
log.w(tag, "itelephony threw remoteexception", ex);
}
}
if (ismusicactive() && (result & action_pass_to_user) == 0) {
// if music is playing but we decided not to pass the key to the
// application, handle the volume change here.
handlevolumekey(audiomanager.stream_music, keycode);
break;
}
}
break;
}
case keyevent.keycode_endcall: {
result &= ~action_pass_to_user;
if (down) {
itelephony telephonyservice = gettelephonyservice();
boolean hungup = false;
if (telephonyservice != null) {
try {
hungup = telephonyservice.endcall();
} catch (remoteexception ex) {
log.w(tag, "itelephony threw remoteexception", ex);
}
}
interceptpowerkeydown(!isscreenon || hungup);
} else {
if (interceptpowerkeyup(canceled)) {
if ((mendcallbehavior
& settings.system.end_button_behavior_home) != 0) {
if (gohome()) {
break;
}
}
if ((mendcallbehavior
& settings.system.end_button_behavior_sleep) != 0) {
result = (result & ~action_wake_up) | action_go_to_sleep;
}
}
}
break;
}
case keyevent.keycode_power: {
result &= ~action_pass_to_user;
if (down) {
if (isscreenon && !mpowerkeytriggered
&& (event.getflags() & keyevent.flag_fallback) == 0) {
mpowerkeytriggered = true;
mpowerkeytime = event.getdowntime();
interceptscreenshotchord();
}
itelephony telephonyservice = gettelephonyservice();
boolean hungup = false;
if (telephonyservice != null) {
try {
if (telephonyservice.isringing()) {
// pressing power while there's a ringing incoming
// call should silence the ringer.
telephonyservice.silenceringer();
} else if ((mincallpowerbehavior
& settings.secure.incall_power_button_behavior_hangup) != 0
&& telephonyservice.isoffhook()) {
// otherwise, if "power button ends call" is enabled,
// the power button will hang up any current active call.
hungup = telephonyservice.endcall();
}
} catch (remoteexception ex) {
log.w(tag, "itelephony threw remoteexception", ex);
}
}
interceptpowerkeydown(!isscreenon || hungup
|| mvolumedownkeytriggered || mvolumeupkeytriggered);
} else {
mpowerkeytriggered = false;
cancelpendingscreenshotchordaction();
if (interceptpowerkeyup(canceled || mpendingpowerkeyupcanceled)) {
result = (result & ~action_wake_up) | action_go_to_sleep;
}
mpendingpowerkeyupcanceled = false;
}
break;
}

响应截屏的方法：

private void interceptscreenshotchord() {
if (mscreenshotchordenabled
&& mvolumedownkeytriggered && mpowerkeytriggered && !mvolumeupkeytriggered) {
final long now = systemclock.uptimemillis();
if (now <= mvolumedownkeytime + screenshot_chord_debounce_delay_millis
&& now <= mpowerkeytime + screenshot_chord_debounce_delay_millis) {
mvolumedownkeyconsumedbyscreenshotchord = true;
cancelpendingpowerkeyaction();
mhandler.postdelayed(mscreenshotchordlongpress, getscreenshotchordlongpressdelay());
}
}
}
private long getscreenshotchordlongpressdelay() {
if (mkeyguardmediator.isshowing()) {
// double the time it takes to take a screenshot from the keyguard
return (long) (keyguard_screenshot_chord_delay_multiplier *
viewconfiguration.getglobalactionkeytimeout());
} else {
return viewconfiguration.getglobalactionkeytimeout();
}
}

接受响应的服务

private final runnable mscreenshotchordlongpress = new runnable() {
public void run() {
takescreenshot();
}
};
private void takescreenshot() {
synchronized (mscreenshotlock) {
if (mscreenshotconnection != null) {
return;
}
componentname cn = new componentname("com.android.systemui",
"com.android.systemui.screenshot.takescreenshotservice");
intent intent = new intent();
intent.setcomponent(cn);
serviceconnection conn = new serviceconnection() {
@override
public void onserviceconnected(componentname name, ibinder service) {
synchronized (mscreenshotlock) {
if (mscreenshotconnection != this) {
return;
}
messenger messenger = new messenger(service);
message msg = message.obtain(null, 1);
final serviceconnection myconn = this;
handler h = new handler(mhandler.getlooper()) {
@override
public void handlemessage(message msg) {
synchronized (mscreenshotlock) {
if (mscreenshotconnection == myconn) {
mcontext.unbindservice(mscreenshotconnection);
mscreenshotconnection = null;
mhandler.removecallbacks(mscreenshottimeout);
}
}
}
};
msg.replyto = new messenger(h);
msg.arg1 = msg.arg2 = 0;
if (mstatusbar != null && mstatusbar.isvisiblelw())
msg.arg1 = 1;
if (mnavigationbar != null && mnavigationbar.isvisiblelw())
msg.arg2 = 1;
try {
messenger.send(msg);
} catch (remoteexception e) {
}
}
}
@override
public void onservicedisconnected(componentname name) {}
};
if (mcontext.bindservice(
intent, conn, context.bind_auto_create, userhandle.user_current)) {
mscreenshotconnection = conn;
mhandler.postdelayed(mscreenshottimeout, 10000);
}
}
}

启动时这个服务 componentname cn = new componentname("com.android.systemui", "com.android.systemui.screenshot.takescreenshotservice");

package com.android.systemui.screenshot;
import android.app.service;
import android.content.intent;
import android.os.handler;
import android.os.ibinder;
import android.os.message;
import android.os.messenger;
import android.os.remoteexception;
public class takescreenshotservice extends service {
private static final string tag = "takescreenshotservice";
private static globalscreenshot mscreenshot;
private handler mhandler = new handler() {
@override
public void handlemessage(message msg) {
switch (msg.what) {
case 1:
final messenger callback = msg.replyto;
if (mscreenshot == null) {
mscreenshot = new globalscreenshot(takescreenshotservice.this);
}
mscreenshot.takescreenshot(new runnable() {
@override public void run() {
message reply = message.obtain(null, 1);
try {
callback.send(reply);
} catch (remoteexception e) {
}
}
}, msg.arg1 > 0, msg.arg2 > 0);
}
}
};
@override
public ibinder onbind(intent intent) {
return new messenger(mhandler).getbinder();
}

再往下就是底层库，需要编译出来才能看得到了。这些就先不研究了。

6、还有部分系统源码是截图的

/*
* copyright (c) 2011 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.
*/
package com.android.systemui.screenshot;
import android.animation.animator;
import android.animation.animatorlisteneradapter;
import android.animation.animatorset;
import android.animation.valueanimator;
import android.animation.valueanimator.animatorupdatelistener;
import android.app.notification;
import android.app.notification.bigpicturestyle;
import android.app.notificationmanager;
import android.app.pendingintent;
import android.content.contentresolver;
import android.content.contentvalues;
import android.content.context;
import android.content.intent;
import android.content.res.resources;
import android.graphics.bitmap;
import android.graphics.canvas;
import android.graphics.colormatrix;
import android.graphics.colormatrixcolorfilter;
import android.graphics.matrix;
import android.graphics.paint;
import android.graphics.pixelformat;
import android.graphics.pointf;
import android.media.mediaactionsound;
import android.net.uri;
import android.os.asynctask;
import android.os.environment;
import android.os.process;
import android.provider.mediastore;
import android.util.displaymetrics;
import android.view.display;
import android.view.layoutinflater;
import android.view.motionevent;
import android.view.surface;
import android.view.view;
import android.view.viewgroup;
import android.view.windowmanager;
import android.view.animation.interpolator;
import android.widget.imageview;
import com.android.systemui.r;
import java.io.file;
import java.io.outputstream;
import java.text.simpledateformat;
import java.util.date;
/**
* pod used in the asynctask which saves an image in the background.
*/
class saveimageinbackgrounddata {
context context;
bitmap image;
uri imageuri;
runnable finisher;
int iconsize;
int result;
}
/**
* an asynctask that saves an image to the media store in the background.
*/
class saveimageinbackgroundtask extends asynctask<saveimageinbackgrounddata, void,
saveimageinbackgrounddata> {
private static final string screenshots_dir_name = "screenshots";
private static final string screenshot_file_name_template = "screenshot_%s.png";
private static final string screenshot_file_path_template = "%s/%s/%s";
private int mnotificationid;
private notificationmanager mnotificationmanager;
private notification.builder mnotificationbuilder;
private string mimagefilename;
private string mimagefilepath;
private long mimagetime;
private bigpicturestyle mnotificationstyle;
// workaround: we want the same notification across screenshots that we update so that we don't
// spam a user's notification drawer. however, we only show the ticker for the saving state
// and if the ticker text is the same as the previous notification, then it will not show. so
// for now, we just add and remove a space from the ticker text to trigger the animation when
// necessary.
private static boolean mtickeraddspace;
saveimageinbackgroundtask(context context, saveimageinbackgrounddata data,
notificationmanager nmanager, int nid) {
resources r = context.getresources();
// prepare all the output metadata
mimagetime = system.currenttimemillis();
string imagedate = new simpledateformat("yyyy-mm-dd-hh-mm-ss").format(new date(mimagetime));
string imagedir = environment.getexternalstoragepublicdirectory(
environment.directory_pictures).getabsolutepath();
mimagefilename = string.format(screenshot_file_name_template, imagedate);
mimagefilepath = string.format(screenshot_file_path_template, imagedir,
screenshots_dir_name, mimagefilename);
// create the large notification icon
int imagewidth = data.image.getwidth();
int imageheight = data.image.getheight();
int iconsize = data.iconsize;
final int shortside = imagewidth < imageheight ? imagewidth : imageheight;
bitmap preview = bitmap.createbitmap(shortside, shortside, data.image.getconfig());
canvas c = new canvas(preview);
paint paint = new paint();
colormatrix desat = new colormatrix();
desat.setsaturation(0.25f);
paint.setcolorfilter(new colormatrixcolorfilter(desat));
matrix matrix = new matrix();
matrix.posttranslate((shortside - imagewidth) / 2,
(shortside - imageheight) / 2);
c.drawbitmap(data.image, matrix, paint);
c.drawcolor(0x40ffffff);
bitmap croppedicon = bitmap.createscaledbitmap(preview, iconsize, iconsize, true);
// show the intermediate notification
mtickeraddspace = !mtickeraddspace;
mnotificationid = nid;
mnotificationmanager = nmanager;
mnotificationbuilder = new notification.builder(context)
.setticker(r.getstring(r.string.screenshot_saving_ticker)
+ (mtickeraddspace ? " " : ""))
.setcontenttitle(r.getstring(r.string.screenshot_saving_title))
.setcontenttext(r.getstring(r.string.screenshot_saving_text))
.setsmallicon(r.drawable.stat_notify_image)
.setwhen(system.currenttimemillis());
mnotificationstyle = new notification.bigpicturestyle()
.bigpicture(preview);
mnotificationbuilder.setstyle(mnotificationstyle);
notification n = mnotificationbuilder.build();
n.flags |= notification.flag_no_clear;
mnotificationmanager.notify(nid, n);
// on the tablet, the large icon makes the notification appear as if it is clickable (and
// on small devices, the large icon is not shown) so defer showing the large icon until
// we compose the final post-save notification below.
mnotificationbuilder.setlargeicon(croppedicon);
// but we still don't set it for the expanded view, allowing the smallicon to show here.
mnotificationstyle.biglargeicon(null);
}
@override
protected saveimageinbackgrounddata doinbackground(saveimageinbackgrounddata... params) {
if (params.length != 1) return null;
// by default, asynctask sets the worker thread to have background thread priority, so bump
// it back up so that we save a little quicker.
process.setthreadpriority(process.thread_priority_foreground);
context context = params[0].context;
bitmap image = params[0].image;
resources r = context.getresources();
try {
// save the screenshot to the mediastore
contentvalues values = new contentvalues();
contentresolver resolver = context.getcontentresolver();
values.put(mediastore.images.imagecolumns.data, mimagefilepath);
values.put(mediastore.images.imagecolumns.title, mimagefilename);
values.put(mediastore.images.imagecolumns.display_name, mimagefilename);
values.put(mediastore.images.imagecolumns.date_taken, mimagetime);
values.put(mediastore.images.imagecolumns.date_added, mimagetime);
values.put(mediastore.images.imagecolumns.date_modified, mimagetime);
values.put(mediastore.images.imagecolumns.mime_type, "image/png");
uri uri = resolver.insert(mediastore.images.media.external_content_uri, values);
intent sharingintent = new intent(intent.action_send);
sharingintent.settype("image/png");
sharingintent.putextra(intent.extra_stream, uri);
intent chooserintent = intent.createchooser(sharingintent, null);
chooserintent.addflags(intent.flag_activity_clear_task
| intent.flag_activity_new_task);
mnotificationbuilder.addaction(r.drawable.ic_menu_share,
r.getstring(com.android.internal.r.string.share),
pendingintent.getactivity(context, 0, chooserintent,
pendingintent.flag_cancel_current));
outputstream out = resolver.openoutputstream(uri);
image.compress(bitmap.compressformat.png, 100, out);
out.flush();
out.close();
// update file size in the database
values.clear();
values.put(mediastore.images.imagecolumns.size, new file(mimagefilepath).length());
resolver.update(uri, values, null, null);
params[0].imageuri = uri;
params[0].result = 0;
} catch (exception e) {
// ioexception/unsupportedoperationexception may be thrown if external storage is not
// mounted
params[0].result = 1;
}
return params[0];
}
@override
protected void onpostexecute(saveimageinbackgrounddata params) {
if (params.result > 0) {
// show a message that we've failed to save the image to disk
globalscreenshot.notifyscreenshoterror(params.context, mnotificationmanager);
} else {
// show the final notification to indicate screenshot saved
resources r = params.context.getresources();
// create the intent to show the screenshot in gallery
intent launchintent = new intent(intent.action_view);
launchintent.setdataandtype(params.imageuri, "image/png");
launchintent.setflags(intent.flag_activity_new_task);
mnotificationbuilder
.setcontenttitle(r.getstring(r.string.screenshot_saved_title))
.setcontenttext(r.getstring(r.string.screenshot_saved_text))
.setcontentintent(pendingintent.getactivity(params.context, 0, launchintent, 0))
.setwhen(system.currenttimemillis())
.setautocancel(true);
notification n = mnotificationbuilder.build();
n.flags &= ~notification.flag_no_clear;
mnotificationmanager.notify(mnotificationid, n);
}
params.finisher.run();
}
}
/**
* todo:
* - performance when over gl surfaces? ie. gallery
* - what do we say in the toast? which icon do we get if the user uses another
* type of gallery?
*/
class globalscreenshot {
private static final int screenshot_notification_id = 789;
private static final int screenshot_flash_to_peak_duration = 130;
private static final int screenshot_drop_in_duration = 430;
private static final int screenshot_drop_out_delay = 500;
private static final int screenshot_drop_out_duration = 430;
private static final int screenshot_drop_out_scale_duration = 370;
private static final int screenshot_fast_drop_out_duration = 320;
private static final float background_alpha = 0.5f;
private static final float screenshot_scale = 1f;
private static final float screenshot_drop_in_min_scale = screenshot_scale * 0.725f;
private static final float screenshot_drop_out_min_scale = screenshot_scale * 0.45f;
private static final float screenshot_fast_drop_out_min_scale = screenshot_scale * 0.6f;
private static final float screenshot_drop_out_min_scale_offset = 0f;
private context mcontext;
private windowmanager mwindowmanager;
private windowmanager.layoutparams mwindowlayoutparams;
private notificationmanager mnotificationmanager;
private display mdisplay;
private displaymetrics mdisplaymetrics;
private matrix mdisplaymatrix;
private bitmap mscreenbitmap;
private view mscreenshotlayout;
private imageview mbackgroundview;
private imageview mscreenshotview;
private imageview mscreenshotflash;
private animatorset mscreenshotanimation;
private int mnotificationiconsize;
private float mbgpadding;
private float mbgpaddingscale;
private mediaactionsound mcamerasound;
/**
* @param context everything needs a context :(
*/
public globalscreenshot(context context) {
resources r = context.getresources();
mcontext = context;
layoutinflater layoutinflater = (layoutinflater)
context.getsystemservice(context.layout_inflater_service);
// inflate the screenshot layout
mdisplaymatrix = new matrix();
mscreenshotlayout = layoutinflater.inflate(r.layout.global_screenshot, null);
mbackgroundview = (imageview) mscreenshotlayout.findviewbyid(r.id.global_screenshot_background);
mscreenshotview = (imageview) mscreenshotlayout.findviewbyid(r.id.global_screenshot);
mscreenshotflash = (imageview) mscreenshotlayout.findviewbyid(r.id.global_screenshot_flash);
mscreenshotlayout.setfocusable(true);
mscreenshotlayout.setontouchlistener(new view.ontouchlistener() {
@override
public boolean ontouch(view v, motionevent event) {
// intercept and ignore all touch events
return true;
}
});
// setup the window that we are going to use
mwindowlayoutparams = new windowmanager.layoutparams(
viewgroup.layoutparams.match_parent, viewgroup.layoutparams.match_parent, 0, 0,
windowmanager.layoutparams.type_secure_system_overlay,
windowmanager.layoutparams.flag_fullscreen
| windowmanager.layoutparams.flag_hardware_accelerated
| windowmanager.layoutparams.flag_layout_in_screen
| windowmanager.layoutparams.flag_show_when_locked,
pixelformat.translucent);
mwindowlayoutparams.settitle("screenshotanimation");
mwindowmanager = (windowmanager) context.getsystemservice(context.window_service);
mnotificationmanager =
(notificationmanager) context.getsystemservice(context.notification_service);
mdisplay = mwindowmanager.getdefaultdisplay();
mdisplaymetrics = new displaymetrics();
mdisplay.getrealmetrics(mdisplaymetrics);
// get the various target sizes
mnotificationiconsize =
r.getdimensionpixelsize(android.r.dimen.notification_large_icon_height);
// scale has to account for both sides of the bg
mbgpadding = (float) r.getdimensionpixelsize(r.dimen.global_screenshot_bg_padding);
mbgpaddingscale = mbgpadding / mdisplaymetrics.widthpixels;
// setup the camera shutter sound
mcamerasound = new mediaactionsound();
mcamerasound.load(mediaactionsound.shutter_click);
}
/**
* creates a new worker thread and saves the screenshot to the media store.
*/
private void savescreenshotinworkerthread(runnable finisher) {
saveimageinbackgrounddata data = new saveimageinbackgrounddata();
data.context = mcontext;
data.image = mscreenbitmap;
data.iconsize = mnotificationiconsize;
data.finisher = finisher;
new saveimageinbackgroundtask(mcontext, data, mnotificationmanager,
screenshot_notification_id).execute(data);
}
/**
* @return the current display rotation in degrees
*/
private float getdegreesforrotation(int value) {
switch (value) {
case surface.rotation_90:
return 360f - 90f;
case surface.rotation_180:
return 360f - 180f;
case surface.rotation_270:
return 360f - 270f;
}
return 0f;
}
/**
* takes a screenshot of the current display and shows an animation.
*/
void takescreenshot(runnable finisher, boolean statusbarvisible, boolean navbarvisible) {
// we need to orient the screenshot correctly (and the surface api seems to take screenshots
// only in the natural orientation of the device :!)
mdisplay.getrealmetrics(mdisplaymetrics);
float[] dims = {mdisplaymetrics.widthpixels, mdisplaymetrics.heightpixels};
float degrees = getdegreesforrotation(mdisplay.getrotation());
boolean requiresrotation = (degrees > 0);
if (requiresrotation) {
// get the dimensions of the device in its native orientation
mdisplaymatrix.reset();
mdisplaymatrix.prerotate(-degrees);
mdisplaymatrix.mappoints(dims);
dims[0] = math.abs(dims[0]);
dims[1] = math.abs(dims[1]);
}
// take the screenshot
mscreenbitmap = surface.screenshot((int) dims[0], (int) dims[1]);
if (mscreenbitmap == null) {
notifyscreenshoterror(mcontext, mnotificationmanager);
finisher.run();
return;
}
if (requiresrotation) {
// rotate the screenshot to the current orientation
bitmap ss = bitmap.createbitmap(mdisplaymetrics.widthpixels,
mdisplaymetrics.heightpixels, bitmap.config.argb_8888);
canvas c = new canvas(ss);
c.translate(ss.getwidth() / 2, ss.getheight() / 2);
c.rotate(degrees);
c.translate(-dims[0] / 2, -dims[1] / 2);
c.drawbitmap(mscreenbitmap, 0, 0, null);
c.setbitmap(null);
mscreenbitmap = ss;
}
// optimizations
mscreenbitmap.sethasalpha(false);
mscreenbitmap.preparetodraw();
// start the post-screenshot animation
startanimation(finisher, mdisplaymetrics.widthpixels, mdisplaymetrics.heightpixels,
statusbarvisible, navbarvisible);
}
/**
* starts the animation after taking the screenshot
*/
private void startanimation(final runnable finisher, int w, int h, boolean statusbarvisible,
boolean navbarvisible) {
// add the view for the animation
mscreenshotview.setimagebitmap(mscreenbitmap);
mscreenshotlayout.requestfocus();
// setup the animation with the screenshot just taken
if (mscreenshotanimation != null) {
mscreenshotanimation.end();
}
mwindowmanager.addview(mscreenshotlayout, mwindowlayoutparams);
valueanimator screenshotdropinanim = createscreenshotdropinanimation();
valueanimator screenshotfadeoutanim = createscreenshotdropoutanimation(w, h,
statusbarvisible, navbarvisible);
mscreenshotanimation = new animatorset();
mscreenshotanimation.playsequentially(screenshotdropinanim, screenshotfadeoutanim);
mscreenshotanimation.addlistener(new animatorlisteneradapter() {
@override
public void onanimationend(animator animation) {
// save the screenshot once we have a bit of time now
savescreenshotinworkerthread(finisher);
mwindowmanager.removeview(mscreenshotlayout);
}
});
mscreenshotlayout.post(new runnable() {
@override
public void run() {
// play the shutter sound to notify that we've taken a screenshot
mcamerasound.play(mediaactionsound.shutter_click);
mscreenshotview.setlayertype(view.layer_type_hardware, null);
mscreenshotview.buildlayer();
mscreenshotanimation.start();
}
});
}
private valueanimator createscreenshotdropinanimation() {
final float flashpeakdurationpct = ((float) (screenshot_flash_to_peak_duration)
/ screenshot_drop_in_duration);
final float flashdurationpct = 2f * flashpeakdurationpct;
final interpolator flashalphainterpolator = new interpolator() {
@override
public float getinterpolation(float x) {
// flash the flash view in and out quickly
if (x <= flashdurationpct) {
return (float) math.sin(math.pi * (x / flashdurationpct));
}
return 0;
}
};
final interpolator scaleinterpolator = new interpolator() {
@override
public float getinterpolation(float x) {
// we start scaling when the flash is at it's peak
if (x < flashpeakdurationpct) {
return 0;
}
return (x - flashdurationpct) / (1f - flashdurationpct);
}
};
valueanimator anim = valueanimator.offloat(0f, 1f);
anim.setduration(screenshot_drop_in_duration);
anim.addlistener(new animatorlisteneradapter() {
@override
public void onanimationstart(animator animation) {
mbackgroundview.setalpha(0f);
mbackgroundview.setvisibility(view.visible);
mscreenshotview.setalpha(0f);
mscreenshotview.settranslationx(0f);
mscreenshotview.settranslationy(0f);
mscreenshotview.setscalex(screenshot_scale + mbgpaddingscale);
mscreenshotview.setscaley(screenshot_scale + mbgpaddingscale);
mscreenshotview.setvisibility(view.visible);
mscreenshotflash.setalpha(0f);
mscreenshotflash.setvisibility(view.visible);
}
@override
public void onanimationend(android.animation.animator animation) {
mscreenshotflash.setvisibility(view.gone);
}
});
anim.addupdatelistener(new animatorupdatelistener() {
@override
public void onanimationupdate(valueanimator animation) {
float t = (float) animation.getanimatedvalue();
float scalet = (screenshot_scale + mbgpaddingscale)
- scaleinterpolator.getinterpolation(t)
* (screenshot_scale - screenshot_drop_in_min_scale);
mbackgroundview.setalpha(scaleinterpolator.getinterpolation(t) * background_alpha);
mscreenshotview.setalpha(t);
mscreenshotview.setscalex(scalet);
mscreenshotview.setscaley(scalet);
mscreenshotflash.setalpha(flashalphainterpolator.getinterpolation(t));
}
});
return anim;
}
private valueanimator createscreenshotdropoutanimation(int w, int h, boolean statusbarvisible,
boolean navbarvisible) {
valueanimator anim = valueanimator.offloat(0f, 1f);
anim.setstartdelay(screenshot_drop_out_delay);
anim.addlistener(new animatorlisteneradapter() {
@override
public void onanimationend(animator animation) {
mbackgroundview.setvisibility(view.gone);
mscreenshotview.setvisibility(view.gone);
mscreenshotview.setlayertype(view.layer_type_none, null);
}
});
if (!statusbarvisible || !navbarvisible) {
// there is no status bar/nav bar, so just fade the screenshot away in place
anim.setduration(screenshot_fast_drop_out_duration);
anim.addupdatelistener(new animatorupdatelistener() {
@override
public void onanimationupdate(valueanimator animation) {
float t = (float) animation.getanimatedvalue();
float scalet = (screenshot_drop_in_min_scale + mbgpaddingscale)
- t * (screenshot_drop_in_min_scale - screenshot_fast_drop_out_min_scale);
mbackgroundview.setalpha((1f - t) * background_alpha);
mscreenshotview.setalpha(1f - t);
mscreenshotview.setscalex(scalet);
mscreenshotview.setscaley(scalet);
}
});
} else {
// in the case where there is a status bar, animate to the origin of the bar (top-left)
final float scaledurationpct = (float) screenshot_drop_out_scale_duration
/ screenshot_drop_out_duration;
final interpolator scaleinterpolator = new interpolator() {
@override
public float getinterpolation(float x) {
if (x < scaledurationpct) {
// decelerate, and scale the input accordingly
return (float) (1f - math.pow(1f - (x / scaledurationpct), 2f));
}
return 1f;
}
};
// determine the bounds of how to scale
float halfscreenwidth = (w - 2f * mbgpadding) / 2f;
float halfscreenheight = (h - 2f * mbgpadding) / 2f;
final float offsetpct = screenshot_drop_out_min_scale_offset;
final pointf finalpos = new pointf(
-halfscreenwidth + (screenshot_drop_out_min_scale + offsetpct) * halfscreenwidth,
-halfscreenheight + (screenshot_drop_out_min_scale + offsetpct) * halfscreenheight);
// animate the screenshot to the status bar
anim.setduration(screenshot_drop_out_duration);
anim.addupdatelistener(new animatorupdatelistener() {
@override
public void onanimationupdate(valueanimator animation) {
float t = (float) animation.getanimatedvalue();
float scalet = (screenshot_drop_in_min_scale + mbgpaddingscale)
- scaleinterpolator.getinterpolation(t)
* (screenshot_drop_in_min_scale - screenshot_drop_out_min_scale);
mbackgroundview.setalpha((1f - t) * background_alpha);
mscreenshotview.setalpha(1f - scaleinterpolator.getinterpolation(t));
mscreenshotview.setscalex(scalet);
mscreenshotview.setscaley(scalet);
mscreenshotview.settranslationx(t * finalpos.x);
mscreenshotview.settranslationy(t * finalpos.y);
}
});
}
return anim;
}
static void notifyscreenshoterror(context context, notificationmanager nmanager) {
resources r = context.getresources();
// clear all existing notification, compose the new notification and show it
notification n = new notification.builder(context)
.setticker(r.getstring(r.string.screenshot_failed_title))
.setcontenttitle(r.getstring(r.string.screenshot_failed_title))
.setcontenttext(r.getstring(r.string.screenshot_failed_text))
.setsmallicon(r.drawable.stat_notify_image_error)
.setwhen(system.currenttimemillis())
.setautocancel(true)
.getnotification();
nmanager.notify(screenshot_notification_id, n);
}

可以从这部分源码中，去寻找解决办法。

其中有一个很重要的方法就是

mscreenbitmap = surface.screenshot((int) dims[0], (int) dims[1]);

这个是可以截图的，但是是隐藏的代码，不提供外面调用的。

注意需要在androidmanifest.xml中加入代码：android:shareduserid="android.uid.system" 进行后续开发。