Android手机截屏

 

　　刚开始打算做一个简单的截屏程序时，以为很轻松就能搞定。

　　在Activity上放一个按钮，点击完成截屏操作，并将数据以图片形式保存在手机中。

　　动手之前，自然是看书和网上各种查资料。结果发现了解的知识越多，就越发感觉不对劲。

　　截屏，总以为其类似于其他小应用的开发，有现成的接口或者只需要稍微改动就能达到预期的效果。

　　一般讲解Android的书籍并没有提到截屏的内容，网上的文章很多，但也没有哪篇文章能真正完整地把解决思路和具体实现说清楚的。

　　总结的比较合理的一篇文章为Android截屏学习经历。

　　直白点说，就是在Windows平台下，不root，不签名，不......，就很难做到将手机整个屏幕截取下来（包括状态栏）

　　1、先介绍一下将应用程序本身的界面截取下来的方法，比较简单，不过对于手机屏幕上的其他信息就不会发挥任何作用了。如状态栏或者其他应用的界面。

View viewScreen = getWindow().getDecorView();
viewScreen.setDrawingCacheEnabled(true);
viewScreen.buildDrawingCache();
Bitmap bitmap = Bitmap.createBitmap(viewScreen.getDrawingCache(),0,0,windowWidth,windowHeight);
viewScreen.destroyDrawingCache();
imgScreen.setImageBitmap(bitmap);

　　其中，viewScreen.getDrawingCache()方法获取屏幕信息，通过ImageView对象imgScreen显示出来，效果如下：

           

　　可以看出，截取的部分只是为当前应用的界面，状态栏信息无法获取。中间的图案为imgView的初始显示内容，为手机桌面。

　　顺便提一下，桌面获取与ImageView视图显示为：

imgScreen.setImageDrawable(getWallpaper());

　　这其实从调用方法也可以知道，getWindow().getDecorView()是针对当前视图（View）的，并不是针对手机整个屏幕的。

　　2、接下来看一段比较有诱惑性的代码，出自这里。

public void screenShot() throws InterruptedException
{
    Process sh;
    try
    {
        sh = Runtime.getRuntime().exec("su", null, null);
        OutputStream os = sh.getOutputStream();
        os.write(("/system/bin/screencap -p " + "/sdcard/Image.png").getBytes("ASCII"));
        os.flush();
        os.close();
        sh.waitFor();
    }
    catch (IOException e)
    {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

}

　　个人没有在Linux下进行测试，如果哪位朋友有这方面的开发经验，还望分享与指点。

　　但从代码来看，如果没有其他约束（如手机权限、应用签名等）的话，是多么简单明了。

　　3、旧版本的Android API其实是有关于截屏的接口，只不过被Google隐藏了，所以还是不能轻易使用。

　　资料中也提到不少API中的截屏函数：screenshot()。

　　4、而在新版本中，Google在Examples中给出了一个样例：ScreenCapture工程，环境为Android Studio。

　　本人的API版本为22，工程路径为“Android\sdk\samples\android-22\media\ScreenCapture”。

　　找到时确实激动一番，马上导入、运行，应用界面成功出现了，点击 开始按钮，效果如下：

      

　　结果又很有趣，出现了一直截取的现象。很眼熟，在前后墙都装上镜子就会出现同样的场景了。

　　样例的实现是点击START就开始不断截屏，点击STOP就停止。

　　到手机文件管理中去找了一通，没发现有任何新的图片保存下来，起初以为Google只是没有做将屏幕数据保存为图片这一步。

　　去看源码之前还是抱有希望的，想着自己可以马上实现从data-->image的这一步。

　　5、程序中用到了Fragment，FragmentActivity。

　　将截取下来的屏幕信息显示在Fragment对象中，而该对象又作为主视图的一部分，及上图中的上半部分为主Activity视图，下半部分为Fragment部分。

　　主Activity中做的事情就是打开继承自Fragment类ScreenCaptureFragment的事务：

@Override
protected void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.activity_main);
     if (savedInstanceState == null) {
         FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();
         ScreenCaptureFragment fragment = new ScreenCaptureFragment(); 8          transaction.replace(R.id.sample_content_fragment, fragment);  
         transaction.commit();
        }
    }

　　关键类ScreenCaptureFragment的实现代码为：

package com.example.android.screencapture;

import android.annotation.TargetApi;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.hardware.display.DisplayManager;
import android.hardware.display.VirtualDisplay;
import android.media.Image;
import android.media.ImageReader;
import android.media.projection.MediaProjection;
import android.media.projection.MediaProjectionManager;
import android.os.Build;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.Surface;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.Toast;
import java.io.IOException;

public class ScreenCaptureFragment extends Fragment implements View.OnClickListener {

    private static final String TAG = "ScreenCaptureFragment";

    private static final String STATE_RESULT_CODE = "result_code";
    private static final String STATE_RESULT_DATA = "result_data";

    private static final int REQUEST_MEDIA_PROJECTION = 1;

    private int mScreenDensity;

    private int mResultCode;
    private Intent mResultData;

    private Surface mSurface;
    private MediaProjection mMediaProjection;
    private VirtualDisplay mVirtualDisplay;
    private MediaProjectionManager mMediaProjectionManager;
    private Button mButtonToggle;
    private SurfaceView mSurfaceView;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (savedInstanceState != null) {
            mResultCode = savedInstanceState.getInt(STATE_RESULT_CODE);
            mResultData = savedInstanceState.getParcelable(STATE_RESULT_DATA);
        }
    }

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        return inflater.inflate(R.layout.fragment_screen_capture, container, false);
    }

    @Override
    public void onViewCreated(View view, Bundle savedInstanceState) {
        mSurfaceView = (SurfaceView) view.findViewById(R.id.surface);
        mSurface = mSurfaceView.getHolder().getSurface();
        mButtonToggle = (Button) view.findViewById(R.id.toggle);
        mButtonToggle.setOnClickListener(this);
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        Activity activity = getActivity();
        DisplayMetrics metrics = new DisplayMetrics();
        activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);
        mScreenDensity = metrics.densityDpi;
        mMediaProjectionManager = (MediaProjectionManager)
                activity.getSystemService(Context.MEDIA_PROJECTION_SERVICE);
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        if (mResultData != null) {
            outState.putInt(STATE_RESULT_CODE, mResultCode);
            outState.putParcelable(STATE_RESULT_DATA, mResultData);
        }
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.toggle:
                if (mVirtualDisplay == null) {
                    try {
                        startScreenCapture();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                } else {
                    stopScreenCapture();
                }
                break;
        }
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (requestCode == REQUEST_MEDIA_PROJECTION) {
            if (resultCode != Activity.RESULT_OK) {
                Toast.makeText(getActivity(), R.string.user_cancelled, Toast.LENGTH_SHORT).show();
                return;
            }
            Activity activity = getActivity();
            if (activity == null) {
                return;
            }

            mResultCode = resultCode;
            mResultData = data;
            setUpMediaProjection();
            try {
                setUpVirtualDisplay();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void onPause() {
        super.onPause();
        stopScreenCapture();
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        tearDownMediaProjection();
    }

    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    private void setUpMediaProjection() {
        mMediaProjection = mMediaProjectionManager.getMediaProjection(mResultCode, mResultData);
    }

    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    private void tearDownMediaProjection() {
        if (mMediaProjection != null) {
            mMediaProjection.stop();
            mMediaProjection = null;
        }
    }

    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    private void startScreenCapture() throws IOException {
        Activity activity = getActivity();
        if (mSurface == null || activity == null) {
            return;
        }
        if (mMediaProjection != null) {
            setUpVirtualDisplay();
        } else if (mResultCode != 0 && mResultData != null) {
            setUpMediaProjection();
            setUpVirtualDisplay();
        } else {
            startActivityForResult(
                    mMediaProjectionManager.createScreenCaptureIntent(),
                    REQUEST_MEDIA_PROJECTION);
        }
    }

    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    private void setUpVirtualDisplay() throws IOException {

        mVirtualDisplay = mMediaProjection.createVirtualDisplay("ScreenCapture",
180                 mSurfaceView.getWidth(), mSurfaceView.getHeight(), mScreenDensity,
181                 DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR,
182                 mSurface, null, null);

        mButtonToggle.setText(R.string.stop);
    }

    private void stopScreenCapture() {
        if (mVirtualDisplay == null) {
            return;
        }
        mVirtualDisplay.release();
        mVirtualDisplay = null;
        mButtonToggle.setText(R.string.start);
    }

}

　　上面高亮的代码作用是将截屏信息显示在界面下方Fragment的SurfaceView中，完全没有data的影子。

　　6、继续查资料，在老外的文章中找到了一些零散的建议与代码，总结之后，实现代码如下：

public void takeScreenshot2(View v){
        MediaProjectionManager projectionManager = (MediaProjectionManager) getSystemService(Context.MEDIA_PROJECTION_SERVICE);
        Intent intent = projectionManager.createScreenCaptureIntent();
        startActivity(intent);
        
        int mWidth = mWindowManager.getDefaultDisplay().getWidth();
        int mHeight = mWindowManager.getDefaultDisplay().getHeight();
        ImageReader mImageReader = ImageReader.newInstance(mWidth, mHeight, ImageFormat.RGB_565, 2);
        DisplayMetrics metrics = new DisplayMetrics();
        mWindowManager.getDefaultDisplay().getMetrics(metrics);
        int mScreenDensity = metrics.densityDpi;

        MediaProjection mProjection = projectionManager.getMediaProjection(1, intent);
        final VirtualDisplay virtualDisplay = mProjection.createVirtualDisplay("screen-mirror",
                mWidth, mHeight, mScreenDensity, DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR,
                mImageReader.getSurface(), null, null);
        Image image = mImageReader.acquireLatestImage();
        final Image.Plane[] planes = image.getPlanes();
        final ByteBuffer buffer = planes[0].getBuffer();
        int offset = 0;
        int pixelStride = planes[0].getPixelStride();
        int rowStride = planes[0].getRowStride();
        int rowPadding = rowStride - pixelStride * mWidth;
        Bitmap bitmap = Bitmap.createBitmap(mWidth+rowPadding/pixelStride, mHeight, Bitmap.Config.RGB_565);
        bitmap.copyPixelsFromBuffer(buffer);
        image.close();

        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy_MM_dd_hh_mm_ss");
        String strDate = dateFormat.format(new java.util.Date());
        String pathImage = Environment.getExternalStorageDirectory().getPath()+"/Pictures/";
        String nameImage = pathImage+strDate+".png";
        if(bitmap != null) {
            try{
                File fileImage = new File(nameImage);
                if(!fileImage.exists()){
                    fileImage.createNewFile();
                }
                FileOutputStream out = new FileOutputStream(fileImage);
                if(out != null){
                    bitmap.compress(Bitmap.CompressFormat.PNG, 100, out);
                    out.flush();
                    out.close();
                    Toast.makeText(this,"get phone's screen succeed",Toast.LENGTH_SHORT).show();
                    Intent media = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
                    Uri contentUri = Uri.fromFile(fileImage);
                    media.setData(contentUri);
                    getApplicationContext().sendBroadcast(media);
                }
            }catch(FileNotFoundException e) {
                e.printStackTrace();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
        else{
            Toast.makeText(this,"cannot get phone's screen",Toast.LENGTH_SHORT).show();
        }
    }

　　理想中，这段代码可以实现的功能有：

　　　　　　a、截取手机整个屏幕信息；

　　　　　　b、将屏幕信息利用ImageReader的acquireLatestImage()保存入Image对象；

　　　　　　c、通过缓存读取方式赋给Bitmap对象；

　　　　　　d、有了Bitmap，接下来就不解释了；

　　但是，一运行就出现异常，还没来得及截程序就终止了。

　　希望有兴趣的朋友可以一起交流与学习，有已经实现了该功能的大神那就最好了，求教。