首页 > 代码库 > Android中使用代码截图的各种方法总结

Android中使用代码截图的各种方法总结

2024-07-09 13:26:52   222人阅读

1,基于Android SDK的截屏方法

(1)主要就是利用SDK提供的View.getDrawingCache()方法。网上已经有很多的实例了。首先创建一个android project，然后进行Layout，画一个按键（res/layout/main.xml）：

<?xmlversion="1.0"encoding="utf-8"?>
<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
<TextView
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="@string/hello"
    />
<Button
  android:text="NiceButton"
  android:id="@+id/my_button"
  android:layout_width="fill_parent"
  android:layout_height="wrap_content"
  android:layout_alignParentBottom="true"></Button>
</LinearLayout>

HelloAndroid.java实现代码为：

packagecom.example.helloandroid;
 
importjava.io.FileOutputStream;
importjava.text.SimpleDateFormat;
importjava.util.Date;
importjava.util.Locale;
 
importandroid.app.Activity;
importandroid.graphics.Bitmap;
importandroid.os.Bundle;
importandroid.view.View;
importandroid.view.View.OnClickListener;
importandroid.widget.Button;
 
publicclassHelloAndroidextendsActivity {
 
  privateButton button;
 
  /** Called when the activity is first created. */
  @Override
  publicvoidonCreate(Bundle savedInstanceState) {
 
    super.onCreate(savedInstanceState);
    this.setContentView(R.layout.main);
    this.button = (Button) this.findViewById(R.id.my_button);
    this.button.setOnClickListener(newOnClickListener() {
 
      publicvoidonClick(View v) {
        SimpleDateFormat sdf = newSimpleDateFormat(
            "yyyy-MM-dd_HH-mm-ss", Locale.US);
        String fname = "/sdcard/"+ sdf.format(newDate()) + ".png";
        View view = v.getRootView();
        view.setDrawingCacheEnabled(true);
        view.buildDrawingCache();
        Bitmap bitmap = view.getDrawingCache();
        if(bitmap != null) {
          System.out.println("bitmap got!");
          try{
            FileOutputStream out = newFileOutputStream(fname);
            bitmap.compress(Bitmap.CompressFormat.PNG,100, out);
            System.out.println("file " + fname + "output done.");
          }catch(Exception e) {
            e.printStackTrace();
          }
        }else{
          System.out.println("bitmap is NULL!");
        }
      }
 
    });
 
  }
}

这个代码会在按下app中按键的时候自动在手机的/sdcard/目录下生成一个时间戳命名的png截屏文件。

这种截屏有一个问题，就是只能截到一部分，比如电池指示部分就截不出来了。

(2)在APK中调用“adb shell screencap -pfilepath” 命令

 
该命令读取系统的framebuffer，需要获得系统权限：
（1）. 在AndroidManifest.xml文件中添加
android:name="android.permission.READ_FRAME_BUFFER"/>
（2）. 修改APK为系统权限，将APK放到源码中编译， 修改Android.mk
 LOCAL_CERTIFICATE := platform

  1. publicvoid takeScreenShot(){

  2.    String mSavedPath = Environment.getExternalStorageDirectory()+File. separator +

    try {                    

  3.           Runtime. getRuntime().exec(

       } catch (Exception e) {

  4.           e.printStackTrace();

  5.    }


(3).利用系统的API，实现Screenshot,这部分代码是系统隐藏的，需要在源码下编译，

    1).修改Android.mk， 添加系统权限
          LOCAL_CERTIFICATE := platform
         2).修改AndroidManifest.xml 文件，添加
权限
android:name="android.permission.READ_FRAME_BUFFER"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
      public boolean takeScreenShot(String imagePath){
                     
                    
                     
             if(imagePath.equals("" )){
                      imagePath = Environment.getExternalStorageDirectory()+File. separator+"Screenshot.png" ;
             }
                     
          Bitmap mScreenBitmap;
          WindowManager mWindowManager;
          DisplayMetrics mDisplayMetrics;
          Display mDisplay;
                  
          mWindowManager = (WindowManager) mcontext.getSystemService(Context.WINDOW_SERVICE);
          mDisplay = mWindowManager.getDefaultDisplay();
          mDisplayMetrics = new DisplayMetrics();
          mDisplay.getRealMetrics(mDisplayMetrics);
                                 
          float[] dims = {mDisplayMetrics.widthPixels , mDisplayMetrics.heightPixels };
          mScreenBitmap = Surface. screenshot((int) dims[0], ( int) dims[1]);
                     
          if (mScreenBitmap == null) {  
                 return false ;
          }
                  
       try {
          FileOutputStream out = new FileOutputStream(imagePath);
          mScreenBitmap.compress(Bitmap.CompressFormat. PNG, 100, out);
             
        } catch (Exception e) {
                
                
          return false ;
        }       
                            
       return true ;
}

2 基于Android ddmlib进行截屏

[java] view plaincopy
  1. public class ScreenShot {  
  2.  private BufferedImage image = null;  
  3.  /** 
  4.   * @param args 
  5.   */  
  6.  public static void main(String[] args) {  
  7.   // TODO Auto-generated method stub  
  8.   AndroidDebugBridge.init(false); //  
  9.   ScreenShot screenshot = new ScreenShot();  
  10.   IDevice device = screenshot.getDevice();  
  11.     
  12.   for (int i = 0; i < 10; i++) {  
  13.    Date date=new Date();  
  14.    SimpleDateFormat df=new SimpleDateFormat("MM-dd-HH-mm-ss");   
  15.    String nowTime = df.format(date);  
  16.    screenshot.getScreenShot(device, "Robotium" + nowTime);  
  17.    try {  
  18.     Thread.sleep(1000);  
  19.    } catch (InterruptedException e) {  
  20.     // TODO Auto-generated catch block  
  21.     e.printStackTrace();  
  22.    }  
  23.   }  
  24.  }  
  25.   
  26.    
  27.  public void getScreenShot(IDevice device,String filename) {  
  28.   RawImage rawScreen = null;  
  29.   try {  
  30.    rawScreen = device.getScreenshot();  
  31.   } catch (TimeoutException e) {  
  32.    // TODO Auto-generated catch block  
  33.    e.printStackTrace();  
  34.   } catch (AdbCommandRejectedException e) {  
  35.    // TODO Auto-generated catch block  
  36.    e.printStackTrace();  
  37.   } catch (IOException e) {  
  38.    // TODO Auto-generated catch block  
  39.    e.printStackTrace();  
  40.   }  
  41.   if (rawScreen != null) {  
  42.    Boolean landscape = false;  
  43.    int width2 = landscape ? rawScreen.height : rawScreen.width;  
  44.    int height2 = landscape ? rawScreen.width : rawScreen.height;  
  45.    if (image == null) {  
  46.     image = new BufferedImage(width2, height2,  
  47.       BufferedImage.TYPE_INT_RGB);  
  48.    } else {  
  49.     if (image.getHeight() != height2 || image.getWidth() != width2) {  
  50.      image = new BufferedImage(width2, height2,  
  51.        BufferedImage.TYPE_INT_RGB);  
  52.     }  
  53.    }  
  54.    int index = 0;  
  55.    int indexInc = rawScreen.bpp >> 3;  
  56.    for (int y = 0; y < rawScreen.height; y++) {  
  57.     for (int x = 0; x < rawScreen.width; x++, index += indexInc) {  
  58.      int value = rawScreen.getARGB(index);  
  59.      if (landscape)  
  60.       image.setRGB(y, rawScreen.width - x - 1, value);  
  61.      else  
  62.       image.setRGB(x, y, value);  
  63.     }  
  64.    }  
  65.    try {  
  66.     ImageIO.write((RenderedImage) image, "PNG", new File("D:/"  
  67.       + filename + ".jpg"));  
  68.    } catch (IOException e) {  
  69.     // TODO Auto-generated catch block  
  70.     e.printStackTrace();  
  71.    }  
  72.   }  
  73.  }  
  74.   
  75.  /** 
  76.   * 获取得到device对象 
  77.   * @return 
  78.   */  
  79.  private IDevice getDevice(){  
  80.   IDevice device;  
  81.   AndroidDebugBridge bridge = AndroidDebugBridge  
  82.     .createBridge("adb", true);//如果代码有问题请查看API，修改此处的参数值试一下  
  83.   waitDevicesList(bridge);  
  84.   IDevice devices[] = bridge.getDevices();  
  85.   device = devices[0];  
  86.   return device;  
  87.  }  
  88.    
  89.  /** 
  90.   * 等待查找device 
  91.   * @param bridge 
  92.   */  
  93.  private void waitDevicesList(AndroidDebugBridge bridge) {  
  94.   int count = 0;  
  95.   while (bridge.hasInitialDeviceList() == false) {  
  96.    try {  
  97.     Thread.sleep(500);   
  98.     count++;  
  99.    } catch (InterruptedException e) {  
  100.    }  
  101.    if (count > 240) {  
  102.     System.err.print("等待获取设备超时");  
  103.     break;  
  104.    }  
  105.   }  
  106.  }  

3 Android本地编程（Native Programming）读取framebuffer


(1)命令行，框架的截屏功能是通过framebuffer来实现的，所以我们先来介绍一下framebuffer。

framebuffer介绍
帧缓冲（framebuffer）是Linux为显示设备提供的一个接口，把显存抽象后的一种设备，他允许上层应用程序在图形模式下直接对显示缓冲区进行 读写操作。这种操作是抽象的，统一的。用户不必关心物理显存的位置、换页机制等等具体细节。这些都是由Framebuffer设备驱动来完成的。
Linux FrameBuffer 本质上只是提供了对图形设备的硬件抽象，在开发者看来，FrameBuffer 是一块显示缓存，往显示缓存中写入特定格式的数据就意味着向屏幕输出内容。所以说FrameBuffer就是一块白板。例如对于初始化为16 位色的FrameBuffer 来说， FrameBuffer中的两个字节代表屏幕上一个点，从上到下，从左至右，屏幕位置与内存地址是顺序的线性关系。
帧缓存有个地址，是在内存里。我们通过不停的向frame buffer中写入数据， 显示控制器就自动的从frame buffer中取数据并显示出来。全部的图形都共享内存中同一个帧缓存。

Android截屏实现思路
Android系统是基于Linux内核的，所以也存在framebuffer这个设备，我们要实现截屏的话只要能获取到framebuffer中的数据，然后把数据转换成图片就可以了，android中的framebuffer数据是存放在 /dev/graphics/fb0 文件中的，所以我们只需要来获取这个文件的数据就可以得到当前屏幕的内容。
现在我们的测试代码运行时候是通过RC(remote controller)方式来运行被测应用的，那就需要在PC机上来访问模拟器或者真机上的framebuffer数据，这个的话可以通过android的ADB命令来实现。

具体实现


/***********************************************************************
  *
  *   ScreenShot.java
  ***********************************************************************/
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.DataInput;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import javax.imageio.ImageIO;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.internal.Base64Encoder;
import com.google.common.io.Closeables;
import com.google.common.io.LittleEndianDataInputStream;

/**
 */
public class ScreenShot {

    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {    
        try {
            //分辨率大小，后续可以通过代码来获取到当前的分辨率
            int xResolution = 320;
            int yResolution = 480;
            //执行adb命令，把framebuffer中内容保存到fb1文件中
             Runtime.getRuntime().exec("adb pull /dev/graphics/fb0 C:/fb1");
             //等待几秒保证framebuffer中的数据都被保存下来，如果没有保存完成进行读取操作会有IO异常
             Thread.sleep(15000);
             //读取文件中的数据
             InputStream in = (InputStream)new FileInputStream("C:/fb1");
             DataInput frameBuffer = new LittleEndianDataInputStream(in);
             
             BufferedImage screenImage = new BufferedImage(
                     xResolution, yResolution, BufferedImage.TYPE_INT_ARGB);
                 int[] oneLine = new int[xResolution];
                for (int y = 0; y < yResolution; y++) {
                    //从frameBuffer中计算出rgb值
                    convertToRgba32(frameBuffer, oneLine);
                    //把rgb值设置到image对象中
                    screenImage.setRGB(0, y, xResolution, 1, oneLine, 0, xResolution);
                }
                Closeables.closeQuietly(in);
                
                ByteArrayOutputStream rawPngStream = new ByteArrayOutputStream();
                try {
                      if (!ImageIO.write(screenImage, "png", rawPngStream)) {
                        throw new RuntimeException(
                            "This Java environment does not support converting to PNG.");
                      }
                    } catch (IOException exception) {
                      // This should never happen because rawPngStream is an in-memory stream.
                     System.out.println("IOException=" + exception);
                    }
                byte[] rawPngBytes = rawPngStream.toByteArray();
                String base64Png = new Base64Encoder().encode(rawPngBytes);
                
                File screenshot = OutputType.FILE.convertFromBase64Png(base64Png);
                System.out.println("screenshot==" + screenshot.toString());
                screenshot.renameTo(new File("C:\\screenshottemp.png"));
                
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println(e);
        }
    }
    
    
    public static void convertToRgba32(DataInput frameBuffer, int[] into) {
        try {
            for (int x = 0; x < into.length; x++) {
                try{
                int rgb = frameBuffer.readShort() & 0xffff;
                int red = rgb >> 11;
                red = (red << 3) | (red >> 2);
                int green = (rgb >> 5) & 63;
                green = (green << 2) | (green >> 4);
                int blue = rgb & 31;
                blue = (blue << 3) | (blue >> 2);
                into[x] = 0xff000000 | (red << 16) | (green << 8) | blue;
                }catch (EOFException e){
                    System.out.println("EOFException=" + e);
                }
              }
        } catch (IOException exception) {
            System.out.println("convertToRgba32Exception=" + exception);
      }
    }
    
}

（2）

 

[java] view plaincopy
  1. 首先是直接移植SystemUI的代码，实现截图效果，这部分的代码就不贴出来了，直接去下载代码吧， 关键的代码没有几句，最最主要的是：Surface.screenshot()，请看代码吧。  
  2.   
  3. [java]  
  4. <SPAN style="FONT-SIZE: 16px">package org.winplus.ss;   
  5.    
  6. import java.io.File;   
  7. import java.io.FileNotFoundException;   
  8. import java.io.FileOutputStream;   
  9. import java.io.IOException;   
  10. import java.text.SimpleDateFormat;   
  11. import java.util.Date;   
  12.    
  13. import android.app.Activity;   
  14. import android.content.Context;   
  15. import android.graphics.Bitmap;   
  16. import android.graphics.Canvas;   
  17. import android.graphics.Matrix;   
  18. import android.os.Bundle;   
  19. import android.util.DisplayMetrics;   
  20. import android.util.Log;   
  21. import android.view.Display;   
  22. import android.view.Surface;   
  23. import android.view.WindowManager;   
  24. import android.os.SystemProperties;   
  25.    
  26. public class SimpleScreenshotActivity extends Activity {   
  27.    
  28.     private Display mDisplay;   
  29.     private WindowManager mWindowManager;   
  30.     private DisplayMetrics mDisplayMetrics;   
  31.     private Bitmap mScreenBitmap;   
  32.     private Matrix mDisplayMatrix;   
  33.    
  34.     @Override   
  35.     public void onCreate(Bundle savedInstanceState) {   
  36.         super.onCreate(savedInstanceState);   
  37.         setContentView(R.layout.main);   
  38.    
  39.         new Thread(new Runnable() {   
  40.    
  41.             @Override   
  42.             public void run() {   
  43.                 takeScreenshot();   
  44.    
  45.             }   
  46.         }).start();   
  47.     }   
  48.    
  49.     private float getDegreesForRotation(int value) {   
  50.         switch (value) {   
  51.         case Surface.ROTATION_90:   
  52.             return 360f - 90f;   
  53.         case Surface.ROTATION_180:   
  54.             return 360f - 180f;   
  55.         case Surface.ROTATION_270:   
  56.             return 360f - 270f;   
  57.         }   
  58.         return 0f;   
  59.     }   
  60.    
  61.     private void takeScreenshot() {   
  62.         mWindowManager = (WindowManager) getSystemService(Context.WINDOW_SERVICE);   
  63.         mDisplay = mWindowManager.getDefaultDisplay();   
  64.         mDisplayMetrics = new DisplayMetrics();   
  65.         mDisplay.getRealMetrics(mDisplayMetrics);   
  66.         mDisplayMatrix = new Matrix();   
  67.         float[] dims = { mDisplayMetrics.widthPixels,   
  68.                 mDisplayMetrics.heightPixels };   
  69.    
  70.         int value = mDisplay.getRotation();   
  71.         String hwRotation = SystemProperties.get("ro.sf.hwrotation", "0");   
  72.         if (hwRotation.equals("270") || hwRotation.equals("90")) {   
  73.             value = (value + 3) % 4;   
  74.         }   
  75.         float degrees = getDegreesForRotation(value);   
  76.    
  77.         boolean requiresRotation = (degrees > 0);   
  78.         if (requiresRotation) {   
  79.             // Get the dimensions of the device in its native orientation    
  80.             mDisplayMatrix.reset();   
  81.             mDisplayMatrix.preRotate(-degrees);   
  82.             mDisplayMatrix.mapPoints(dims);   
  83.    
  84.             dims[0] = Math.abs(dims[0]);   
  85.             dims[1] = Math.abs(dims[1]);   
  86.         }   
  87.    
  88.         mScreenBitmap = Surface.screenshot((int) dims[0], (int) dims[1]);   
  89.    
  90.         if (requiresRotation) {   
  91.             // Rotate the screenshot to the current orientation    
  92.             Bitmap ss = Bitmap.createBitmap(mDisplayMetrics.widthPixels,   
  93.                     mDisplayMetrics.heightPixels, Bitmap.Config.ARGB_8888);   
  94.             Canvas c = new Canvas(ss);   
  95.             c.translate(ss.getWidth() / 2, ss.getHeight() / 2);   
  96.             c.rotate(degrees);   
  97.             c.translate(-dims[0] / 2, -dims[1] / 2);   
  98.             c.drawBitmap(mScreenBitmap, 0, 0, null);   
  99.             c.setBitmap(null);   
  100.             mScreenBitmap = ss;   
  101.         }   
  102.    
  103.         // If we couldn‘t take the screenshot, notify the user    
  104.         if (mScreenBitmap == null) {   
  105.             return;   
  106.         }   
  107.    
  108.         // Optimizations    
  109.         mScreenBitmap.setHasAlpha(false);   
  110.         mScreenBitmap.prepareToDraw();   
  111.            
  112.         try {   
  113.             saveBitmap(mScreenBitmap);   
  114.         } catch (IOException e) {   
  115.             System.out.println(e.getMessage());   
  116.         }   
  117.     }   
  118.    
  119.     public void saveBitmap(Bitmap bitmap) throws IOException {   
  120.         String imageDate = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss")   
  121.                 .format(new Date(System.currentTimeMillis()));   
  122.         File file = new File("/mnt/sdcard/Pictures/"+imageDate+".png");   
  123.         if(!file.exists()){   
  124.             file.createNewFile();   
  125.         }   
  126.         FileOutputStream out;   
  127.         try {   
  128.             out = new FileOutputStream(file);   
  129.             if (bitmap.compress(Bitmap.CompressFormat.PNG, 70, out)) {   
  130.                 out.flush();   
  131.                 out.close();   
  132.             }   
  133.         } catch (FileNotFoundException e) {   
  134.             e.printStackTrace();   
  135.         } catch (IOException e) {   
  136.             e.printStackTrace();   
  137.         }   
  138.     }   
  139. }   
  140. </SPAN>   
  141.   
  142. package org.winplus.ss;  
  143.   
  144. import java.io.File;  
  145. import java.io.FileNotFoundException;  
  146. import java.io.FileOutputStream;  
  147. import java.io.IOException;  
  148. import java.text.SimpleDateFormat;  
  149. import java.util.Date;  
  150.   
  151. import android.app.Activity;  
  152. import android.content.Context;  
  153. import android.graphics.Bitmap;  
  154. import android.graphics.Canvas;  
  155. import android.graphics.Matrix;  
  156. import android.os.Bundle;  
  157. import android.util.DisplayMetrics;  
  158. import android.util.Log;  
  159. import android.view.Display;  
  160. import android.view.Surface;  
  161. import android.view.WindowManager;  
  162. import android.os.SystemProperties;  
  163.   
  164. public class SimpleScreenshotActivity extends Activity {  
  165.   
  166.  private Display mDisplay;  
  167.  private WindowManager mWindowManager;  
  168.  private DisplayMetrics mDisplayMetrics;  
  169.  private Bitmap mScreenBitmap;  
  170.  private Matrix mDisplayMatrix;  
  171.   
  172.  @Override  
  173.  public void onCreate(Bundle savedInstanceState) {  
  174.   super.onCreate(savedInstanceState);  
  175.   setContentView(R.layout.main);  
  176.   
  177.   new Thread(new Runnable() {  
  178.   
  179.    @Override  
  180.    public void run() {  
  181.     takeScreenshot();  
  182.   
  183.    }  
  184.   }).start();  
  185.  }  
  186.   
  187.  private float getDegreesForRotation(int value) {  
  188.   switch (value) {  
  189.   case Surface.ROTATION_90:  
  190.    return 360f - 90f;  
  191.   case Surface.ROTATION_180:  
  192.    return 360f - 180f;  
  193.   case Surface.ROTATION_270:  
  194.    return 360f - 270f;  
  195.   }  
  196.   return 0f;  
  197.  }  
  198.   
  199.  private void takeScreenshot() {  
  200.   mWindowManager = (WindowManager) getSystemService(Context.WINDOW_SERVICE);  
  201.   mDisplay = mWindowManager.getDefaultDisplay();  
  202.   mDisplayMetrics = new DisplayMetrics();  
  203.   mDisplay.getRealMetrics(mDisplayMetrics);  
  204.   mDisplayMatrix = new Matrix();  
  205.   float[] dims = { mDisplayMetrics.widthPixels,  
  206.     mDisplayMetrics.heightPixels };  
  207.   
  208.   int value = mDisplay.getRotation();  
  209.   String hwRotation = SystemProperties.get("ro.sf.hwrotation", "0");  
  210.   if (hwRotation.equals("270") || hwRotation.equals("90")) {  
  211.    value = (value + 3) % 4;  
  212.   }  
  213.   float degrees = getDegreesForRotation(value);  
  214.   
  215.   boolean requiresRotation = (degrees > 0);  
  216.   if (requiresRotation) {  
  217.    // Get the dimensions of the device in its native orientation  
  218.    mDisplayMatrix.reset();  
  219.    mDisplayMatrix.preRotate(-degrees);  
  220.    mDisplayMatrix.mapPoints(dims);  
  221.   
  222.    dims[0] = Math.abs(dims[0]);  
  223.    dims[1] = Math.abs(dims[1]);  
  224.   }  
  225.   
  226.   mScreenBitmap = Surface.screenshot((int) dims[0], (int) dims[1]);  
  227.   
  228.   if (requiresRotation) {  
  229.             // Rotate the screenshot to the current orientation  
  230.             Bitmap ss = Bitmap.createBitmap(mDisplayMetrics.widthPixels,  
  231.                     mDisplayMetrics.heightPixels, Bitmap.Config.ARGB_8888);  
  232.             Canvas c = new Canvas(ss);  
  233.             c.translate(ss.getWidth() / 2, ss.getHeight() / 2);  
  234.             c.rotate(degrees);  
  235.             c.translate(-dims[0] / 2, -dims[1] / 2);  
  236.             c.drawBitmap(mScreenBitmap, 0, 0, null);  
  237.             c.setBitmap(null);  
  238.             mScreenBitmap = ss;  
  239.         }  
  240.   
  241.         // If we couldn‘t take the screenshot, notify the user  
  242.         if (mScreenBitmap == null) {  
  243.             return;  
  244.         }  
  245.   
  246.         // Optimizations  
  247.         mScreenBitmap.setHasAlpha(false);  
  248.         mScreenBitmap.prepareToDraw();  
  249.          
  250.   try {  
  251.    saveBitmap(mScreenBitmap);  
  252.   } catch (IOException e) {  
  253.    System.out.println(e.getMessage());  
  254.   }  
  255.  }  
  256.   
  257.  public void saveBitmap(Bitmap bitmap) throws IOException {  
  258.   String imageDate = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss")  
  259.     .format(new Date(System.currentTimeMillis()));  
  260.   File file = new File("/mnt/sdcard/Pictures/"+imageDate+".png");  
  261.   if(!file.exists()){  
  262.    file.createNewFile();  
  263.   }  
  264.   FileOutputStream out;  
  265.   try {  
  266.    out = new FileOutputStream(file);  
  267.    if (bitmap.compress(Bitmap.CompressFormat.PNG, 70, out)) {  
  268.     out.flush();  
  269.     out.close();  
  270.    }  
  271.   } catch (FileNotFoundException e) {  
  272.    e.printStackTrace();  
  273.   } catch (IOException e) {  
  274.    e.printStackTrace();  
  275.   }  
  276.  }  
  277. }  
  278.   
  279. PS：1、需要在AndroidManifest.xml中加入代码：android:sharedUserId="android.uid.system"  
  280.   
  281.          2、由于调用了@hide的API，所以编译得时候请使用makefile编译。或者通过在Eclipse中添加Jar文件通过编译。  
  282.   
  283.          3、此代码只在Android4.0中使用过，2.3的就没去做测试了。  



 

4 利用TakeScreenShotService截图

Android手机一般都自带有手机屏幕截图的功能：在手机任何界面（当然手机要是开机点亮状态），通过按组合键，屏幕闪一下，然后咔嚓一声，截图的照片会保存到当前手机的图库中，真是一个不错的功能！

以我手头的测试手机为例，是同时按电源键+音量下键来实现截屏，苹果手机则是电源键 + HOME键，小米手机是菜单键+音量下键，而HTC一般是按住电源键再按左下角的“主页”键。那么Android源码中使用组合键是如何实现屏幕截图功能呢？前段时间由于工作的原因仔细看了一下，这两天不忙，便把相关的知识点串联起来整理一下，分下面两部分简单分析下实现流程：

Android源码中对组合键的捕获。

Android源码中对按键的捕获位于文件PhoneWindowManager.java（alps\frameworks\base\policy\src\com\android\internal\policy\impl）中，这个类处理所有的键盘输入事件，其中函数interceptKeyBeforeQueueing（）会对常用的按键做特殊处理。以我手头的测试机为例，是同时按电源键和音量下键来截屏，那么在这个函数中我们会看到这么两段代码：

 1 2 3 4 5 6 7 8 9101112131415161718192021222324252627282930
....... 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();                    }......            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();                    }......

可以看到正是在这里（响应Down事件）捕获是否按了音量下键和电源键的，而且两个地方都会进入函数interceptScreenshotChord()中，那么接下来看看这个函数干了什么工作：

 1 2 3 4 5 6 7 8 910111213
    private void interceptScreenshotChord() {        if (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,                        ViewConfiguration.getGlobalActionKeyTimeout());            }        }    }

在这个函数中，用两个布尔变量判断是否同时按了音量下键和电源键后，再计算两个按键响应Down事件之间的时间差不超过150毫秒，也就认为是同时按了这两个键后，算是真正的捕获到屏幕截屏的组合键。

附言：文件PhoneWindowManager.java类是拦截键盘消息的处理类，在此类中还有对home键、返回键等好多按键的处理。

Android源码中调用屏幕截图的接口。

捕获到组合键后，我们再看看android源码中是如何调用屏幕截图的函数接口。在上面的函数interceptScreenshotChord中我们看到用handler判断长按组合键500毫秒之后，会进入如下函数：

12345
    private final Runnable mScreenshotChordLongPress = new Runnable() {        public void run() {            takeScreenshot();        }    };

在这里启动了一个线程来完成截屏的功能，接着看函数takeScreenshot():

 1 2 3 4 5 6 7 8 910111213141516171819202122232425262728293031323334353637383940414243444546474849505152
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)) {                mScreenshotConnection = conn;                mHandler.postDelayed(mScreenshotTimeout, 10000);            }        }    }

可以看到这个函数使用AIDL绑定了service服务 到"com.android.systemui.screenshot.TakeScreenshotService"，注意在service连接成功 时，对message的msg.arg1和msg.arg2两个参数的赋值。其中在mScreenshotTimeout中对服务service做了超时 处理。接着我们找到实现这个服务service的类TakeScreenshotService，看看其实现的流程：

 1 2 3 4 5 6 7 8 91011121314151617181920212223242526272829303132
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();    }}

在这个类中，我们主要看调用接口，用到了mScreenshot.takeScreenshot（）传递了三个参数，第一个是个runnable，第二和 第三个是之前message传递的两个参数msg.arg1和msg.arg2。最后我们看看这个函数takeScreenshot()，位于文件 GlobalScreenshot.java中（跟之前的函数重名但是文件路径不一样）：

 1 2 3 4 5 6 7 8 9101112131415161718192021222324252627282930313233343536373839404142434445464748
 /**     * 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);    }

这段代码的注释比较详细，其实看到这里，我们算是真正看到截屏的操作了，具体的工作包括对屏幕大小、旋转角度的获取，然后调用Surface类的 screenshot方法截屏保存到bitmap中，之后把这部分位图填充到一个画布上，最后再启动一个延迟的拍照动画效果。如果再往下探究 screenshot方法，发现已经是一个native方法了：

1234567
    /**     * Like {@link #screenshot(int, int, int, int)} but includes all     * Surfaces in the screenshot.     *     * @hide     */    public static native Bitmap screenshot(int width, int height);

使用JNI技术调用底层的代码，如果再往下走，会发现映射这这个jni函数在文件android_view_Surface.cpp中，这个真的已经是底层c++语言了，统一调用的底层函数是：

 1 2 3 4 5 6 7 8 91011121314151617181920212223242526272829303132
static jobject doScreenshot(JNIEnv* env, jobject clazz, jint width, jint height,        jint minLayer, jint maxLayer, bool allLayers){    ScreenshotPixelRef* pixels = new ScreenshotPixelRef(NULL);    if (pixels->update(width, height, minLayer, maxLayer, allLayers) != NO_ERROR) {        delete pixels;        return 0;    }    uint32_t w = pixels->getWidth();    uint32_t h = pixels->getHeight();    uint32_t s = pixels->getStride();    uint32_t f = pixels->getFormat();    ssize_t bpr = s * android::bytesPerPixel(f);    SkBitmap* bitmap = new SkBitmap();    bitmap->setConfig(convertPixelFormat(f), w, h, bpr);    if (f == PIXEL_FORMAT_RGBX_8888) {        bitmap->setIsOpaque(true);    }    if (w > 0 && h > 0) {        bitmap->setPixelRef(pixels)->unref();        bitmap->lockPixels();    } else {        // be safe with an empty bitmap.        delete pixels;        bitmap->setPixels(NULL);    }    return GraphicsJNI::createBitmap(env, bitmap, false, NULL);}

由于对C++不熟，我这里就不敢多言了。其实到这里，算是对手机android源码中通过组合键屏幕截图的整个流程有个大体了解了，一般我们在改动中熟悉按键的捕获原理，并且清楚调用的截屏函数接口即可，如果有兴趣的，可以继续探究更深的底层是如何实现的。

应用


联系
我们