0}{else}no-cache{/if}" />
通用的安卓智能电视截屏及图片目录文件获取方法
通用的安卓智能电视截屏及图片目录文件获取方法
辰光 发表于 11-28
当前没有评论，快来抢沙发
通用的安卓智能电视截屏及图片目录文件获取方法
辰光 发表于 11-28
huaqiang 编辑
　　截屏终于成功了，简单得不能再简单了，再也不用&炫&烂的不行的拍摄技术了，拍得太烂严重影响申精华、发图的情绪，严重打击自信心。虽然很简单，但真是好用的干货，图片美美的，原始的图片就是美。
　　【附带网络共享&电视存储&的方法】
　　网络上用软件&悟空助手&截屏都很成功。&悟空助手&就是用ADB调试能(wkadb.exe)来连接电视端操作的。adb不通，&悟空助手&也无法正常使用，看得见却吃不到。悟空助手使用需要打开ADB调试模式，但连接设备呈现离线状态(offline)，有时悟空助手能发现电视，但是截屏都是失败的，能出现保存文件对话框，但实际是空文件夹，没有真正写入文件，还是ADB调试问题。经过一些简单尝试，找到了另一种截屏方式方法，原始而有效、通用。
　　用的是电脑中我最常用的技术【PrintScreen】键截屏，在安卓上一样可行，通用性能就是好用。
　　适用范围:本方法对安卓系统的智能电视都应该是有效的。
　　操作方法:将USB键盘插入电视USB端口，电视切换到想截屏的画面，按键盘的【PrintScreen】键截屏，电视端会有蜂鸣提示音。
　　截屏文件默认存储位置(目录):本机SD卡(TF卡)/Pictures/Screenshots/ (绝对位置 /mnt/sdcard/Pictures/Screenshots)
　　文件格式: 例子Screenshot_-09-31-48.png，Screenshot+日期+小时分钟秒.png
　　如图所示
　　下面提供几种取用截屏图片的方法:
　　1.直接从电视TF卡槽弹出TF卡，插入电脑USB端口读取(将TF卡插入USB读卡器卡托)。
　　2.用各种文件管理器从【本机SD卡(TF卡)/Pictures/Screenshots/】目录中读取截屏文件，或直接存入U盘，或者通过文件管理器的网络共享写入电脑共享的文件夹。
　　3.共享电视端的SD卡(TF卡),直接在电脑端读取使用截屏文件。(省略了U盘读写或繁琐的电视版文件管理器的网络共享操作【可在电视端借助USB鼠标辅助操作】)
　　简略说一下第三种方法&共享磁盘&的操作。(网络共享&电视存储&的方法)
　　1.在电脑上网下载小白文件管理器(现在各种文件管理器都被暂时禁用了，电视自带的应用商店中电视助手、文件管理器都下架了):
　　在电脑上下载电视版的安卓软件(APK安装包)，拷入U盘插入电视，安装即可。
　　2.&共享磁盘&:进入小白文件管理器，选择&全部文件&--&选择打开的磁盘，选择&共享磁盘&--&将当前磁盘共享到家庭网络，按&启动服务&--&请在电脑上&我的电脑&的地址栏中输入: ftp://192.168.1.112:2121
　　(注意:192.168.1.112是电视的IP地址，具体使用中请查看自己电视的实际IP地址[具体看小白文件管理器的提示]，本文中的【192.168.1.112】是作者演示时用的,2121是共享服务绑定的端口号，照输就是。)
　　操作过程的图例:
　　2.在电脑上打开资源管理器(explorer.exe),地址栏内输入 ftp://192.168.1.112:2121,就会出现如下画面，
　　进入ftp://192.168.1.112:2121/文件夹Pictures/Screenshots/ ，就可以看到你截屏的图片了。
　　(Screenshot_-09-31-48.png)
　　3.把截屏图片*.png复制到电脑本地的磁盘中保存。
　　(复制文件操作完毕后，电视端的小白&共享磁盘&就可以按&停止服务&了，退出小白文件管理器。多个服务多占用一份运行内存RAM)
　　4.有新的截屏操作，要刷新文件列表显示部分，才能出现新文件列表。
　　本人现在从电视上截屏的图片都是用小白文件管理器通过共享的方法传输到电脑上的。
● ● ● ● ● ● ● ●android 关于屏幕截屏的几种办法
年末较闲，就上个星期查找各方面的资料关于android截图事情，自已也测试一些代码，已改改进或者优化。接下来进行总结一下。其实，如果真正android截屏是需要root权限的。但要用户使用都root，似乎不可能，体验性太差了。这期间我稍微观察了QQ的截图。QQ的截图是摇一摇截图当前屏幕，这个是不需要root权限的。然而，如果你要截图页面不是当前页面，就需要root权限。可以使用360超级root尝试一下。
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());
if (!file.exists()) {
file.createNewFile();
FileOutputStream foStream = new FileOutputStream(file);
pressFormat.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());
if (!file.exists()) {
file.createNewFile();
FileOutputStream foStream = new FileOutputStream(file);
pressFormat.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.
import java.io.IOE
import java.text.SimpleDateF
import java.util.D
import com.android.ddmlib.AdbCommandRejectedE
import com.android.ddmlib.DebugB
import com.android.ddmlib.ID
import com.android.ddmlib.RawI
import com.android.ddmlib.TimeoutE
public class ScreenShoddmlib {
private BufferedImage image =
* @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);
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
public void getScreenShot(IDevice device,String filename) {
RawImage rawScreen =
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 =
int width2 = landscape ? rawScreen.height : rawScreen.
int height2 = landscape ? rawScreen.width : rawScreen.
if (image == null) {
image = new BufferedImage(width2, height2,
BufferedImage.TYPE_INT_RGB);
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. y++) {
for (int x = 0; x & rawScreen. x++, index += indexInc) {
int value = rawScreen.getARGB(index);
if (landscape)
image.setRGB(y, rawScreen.width - x - 1, value);
image.setRGB(x, y, value);
ImageIO.write((RenderedImage) image, &PNG&, new File(&D:/&
+ filename + &.jpg&));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
* 获取得到device对象
private IDevice getDevice(){
AndroidDebugBridge bridge = AndroidDebugBridge
.createBridge(&adb&, true);//如果代码有问题请查看API，修改此处的参数值试一下
waitDevicesList(bridge);
IDevice devices[] = bridge.getDevices();
device = devices[0];
* 等待查找device
* @param bridge
private void waitDevicesList(AndroidDebugBridge bridge) {
int count = 0;
while (bridge.hasInitialDeviceList() == false) {
Thread.sleep(500);
} catch (InterruptedException e) {
if (count & 240) {
System.err.print(&等待获取设备超时&);
4、使用adb命令
需要系统权限，在APK中调用&adb shell screencap -pfilepath& 命令
需要获得系统权限：1、 在AndroidManifest.xml文件中添加
2、修改APK为系统权限，将APK放到中编译， 修改Android.mk LOCAL_CERTIFICATE := platform
在这里我要说一下，搞过jni调用就知道Android.mk的作用。此举也是麻烦，效果也不是很好。
public void takeScreenShot(){
String mSavedPath = Environment.getExternalStorageDirectory()+File. separator + &screenshot.png& ;
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 =
mVolumeDownKeyTime = event.getDownTime();
mVolumeDownKeyConsumedByScreenshotChord =
cancelPendingPowerKeyAction();
interceptScreenshotChord();
mVolumeDownKeyTriggered =
cancelPendingScreenshotChordAction();
} else if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
if (down) {
if (isScreenOn && !mVolumeUpKeyTriggered
&& (event.getFlags() & KeyEvent.FLAG_FALLBACK) == 0) {
mVolumeUpKeyTriggered =
cancelPendingPowerKeyAction();
cancelPendingScreenshotChordAction();
mVolumeUpKeyTriggered =
cancelPendingScreenshotChordAction();
if (down) {
ITelephony telephonyService = getTelephonyService();
if (telephonyService != null) {
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;
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);
} 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);
case KeyEvent.KEYCODE_ENDCALL: {
result &= ~ACTION_PASS_TO_USER;
if (down) {
ITelephony telephonyService = getTelephonyService();
boolean hungUp =
if (telephonyService != null) {
hungUp = telephonyService.endCall();
} catch (RemoteException ex) {
Log.w(TAG, &ITelephony threw RemoteException&, ex);
interceptPowerKeyDown(!isScreenOn || hungUp);
if (interceptPowerKeyUp(canceled)) {
if ((mEndcallBehavior
& Settings.System.END_BUTTON_BEHAVIOR_HOME) != 0) {
if (goHome()) {
if ((mEndcallBehavior
& Settings.System.END_BUTTON_BEHAVIOR_SLEEP) != 0) {
result = (result & ~ACTION_WAKE_UP) | ACTION_GO_TO_SLEEP;
case KeyEvent.KEYCODE_POWER: {
result &= ~ACTION_PASS_TO_USER;
if (down) {
if (isScreenOn && !mPowerKeyTriggered
&& (event.getFlags() & KeyEvent.FLAG_FALLBACK) == 0) {
mPowerKeyTriggered =
mPowerKeyTime = event.getDownTime();
interceptScreenshotChord();
ITelephony telephonyService = getTelephonyService();
boolean hungUp =
if (telephonyService != null) {
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);
mPowerKeyTriggered =
cancelPendingScreenshotChordAction();
if (interceptPowerKeyUp(canceled || mPendingPowerKeyUpCanceled)) {
result = (result & ~ACTION_WAKE_UP) | ACTION_GO_TO_SLEEP;
mPendingPowerKeyUpCanceled =
响应截屏的方法：
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 =
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());
return ViewConfiguration.getGlobalActionKeyTimeout();
接受响应的服务
private final Runnable mScreenshotChordLongPress = new Runnable() {
public void run() {
takeScreenshot();
private void takeScreenshot() {
synchronized (mScreenshotLock) {
if (mScreenshotConnection != null) {
ComponentName cn = new ComponentName(&com.android.systemui&,
&com.android.systemui.screenshot.TakeScreenshotService&);
Intent intent = new Intent();
intent.setComponent(cn);
ServiceConnection conn = new ServiceConnection() {
public void onServiceConnected(ComponentName name, IBinder service) {
synchronized (mScreenshotLock) {
if (mScreenshotConnection != this) {
Messenger messenger = new Messenger(service);
Message msg = Message.obtain(null, 1);
final ServiceConnection myConn =
Handler h = new Handler(mHandler.getLooper()) {
public void handleMessage(Message msg) {
synchronized (mScreenshotLock) {
if (mScreenshotConnection == myConn) {
mContext.unbindService(mScreenshotConnection);
mScreenshotConnection =
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;
messenger.send(msg);
} catch (RemoteException e) {
public void onServiceDisconnected(ComponentName name) {}
if (mContext.bindService(
intent, conn, Context.BIND_AUTO_CREATE, UserHandle.USER_CURRENT)) {
mScreenshotConnection =
mHandler.postDelayed(mScreenshotTimeout, 10000);
启动时这个服务ComponentName cn = new ComponentName(&com.android.systemui&,&com.android.systemui.screenshot.TakeScreenshotService&);
package com.android.systemui.
import android.app.S
import android.content.I
import android.os.H
import android.os.IB
import android.os.M
import android.os.M
import android.os.RemoteE
public class TakeScreenshotService extends Service {
private static final String TAG = &TakeScreenshotService&;
private static GlobalScreenshot mS
private Handler mHandler = new Handler() {
public void handleMessage(Message msg) {
switch (msg.what) {
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);
callback.send(reply);
} catch (RemoteException e) {
}, msg.arg1 & 0, msg.arg2 & 0);
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.
import android.animation.A
import android.animation.AnimatorListenerA
import android.animation.AnimatorS
import android.animation.ValueA
import android.animation.ValueAnimator.AnimatorUpdateL
import android.app.N
import android.app.Notification.BigPictureS
import android.app.NotificationM
import android.app.PendingI
import android.content.ContentR
import android.content.ContentV
import android.content.C
import android.content.I
import android.content.res.R
import android.graphics.B
import android.graphics.C
import android.graphics.ColorM
import android.graphics.ColorMatrixColorF
import android.graphics.M
import android.graphics.P
import android.graphics.PixelF
import android.graphics.PointF;
import android.media.MediaActionS
import android.net.U
import android.os.AsyncT
import android.os.E
import android.os.P
import android.provider.MediaS
import android.util.DisplayM
import android.view.D
import android.view.LayoutI
import android.view.MotionE
import android.view.S
import android.view.V
import android.view.ViewG
import android.view.WindowM
import android.view.animation.I
import android.widget.ImageV
import com.android.systemui.R;
import java.io.F
import java.io.OutputS
import java.text.SimpleDateF
import java.util.D
* POD used in the AsyncTask which saves an image in the background.
class SaveImageInBackgroundData {
Uri imageU
* An AsyncTask that saves an image to the media store in the background.
class SaveImageInBackgroundTask extends AsyncTask {
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 mNotificationM
private Notification.Builder mNotificationB
private String mImageFileN
private String mImageFileP
private long mImageT
private BigPictureStyle mNotificationS
// 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 mTickerAddS
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.iconS
final int shortSide = imageWidth & imageHeight ? imageWidth : imageH
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 = !mTickerAddS
mNotificationId = nId;
mNotificationManager = nM
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);
protected SaveImageInBackgroundData doInBackground(SaveImageInBackgroundData... params) {
if (params.length != 1)
// 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].
Bitmap image = params[0].
Resources r = context.getResources();
// 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);
pressFormat.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 =
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];
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);
// 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();
- 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 mC
private WindowManager mWindowM
private WindowManager.LayoutParams mWindowLayoutP
private NotificationManager mNotificationM
private Display mD
private DisplayMetrics mDisplayM
private Matrix mDisplayM
private Bitmap mScreenB
private View mScreenshotL
private ImageView mBackgroundV
private ImageView mScreenshotV
private ImageView mScreenshotF
private AnimatorSet mScreenshotA
private int mNotificationIconS
private float mBgP
private float mBgPaddingS
private MediaActionSound mCameraS
* @param context everything needs a context :(
public GlobalScreenshot(Context context) {
Resources r = context.getResources();
mContext =
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() {
public boolean onTouch(View v, MotionEvent event) {
// Intercept and ignore all touch events
// 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.widthP
// 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 = mC
data.image = mScreenB
data.iconSize = mNotificationIconS
data.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();
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 =
// 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() {
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() {
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 * flashPeakDurationP
final Interpolator flashAlphaInterpolator = new Interpolator() {
public float getInterpolation(float x) {
// Flash the flash view in and out quickly
if (x &= flashDurationPct) {
return (float) Math.sin(Math.PI * (x / flashDurationPct));
final Interpolator scaleInterpolator = new Interpolator() {
public float getInterpolation(float x) {
// We start scaling when the flash is at it's peak
if (x & flashPeakDurationPct) {
return (x - flashDurationPct) / (1f - flashDurationPct);
ValueAnimator anim = ValueAnimator.ofFloat(0f, 1f);
anim.setDuration(SCREENSHOT_DROP_IN_DURATION);
anim.addListener(new AnimatorListenerAdapter() {
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);
public void onAnimationEnd(android.animation.Animator animation) {
mScreenshotFlash.setVisibility(View.GONE);
anim.addUpdateListener(new AnimatorUpdateListener() {
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));
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() {
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() {
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);
// 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() {
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() {
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);
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& 进行后续开发。
先到这里，有时间后续再从这里往下研究。各位也可以yanjiuyxia