Android 5.0 후 캡 처, 루트 필요 없 음

Android 50 캡 처 루트 필요 없 음

실현 절차

화면의 실시 간 정보 받 기

가상 화면 새로 만 들 기

가상 화면의 이미지 처리

Android 캡 처 셸 방식 은 루트 가 필요 합 니 다. 버 전에 대한 요구 가 없습니다

Android 5.0 캡 처, 루트 필요 없 음
캡 처 에 대해 안 드 로 이 드 는 5.0 이후 공식 API 를 제공 했다. 캡 처 에 대해 서도 adb, root, 아 날로 그 버튼 을 사용 하거나 숨겨 진 코드 를 제거 할 필요 가 없다.주로 다음 과 같은 몇 가지 유형 을 사용 합 니 다. 1. MediaProjection 2. MediaProjectionManager 3. MediaProjection. Callback 4. DisplayManager 5. VirtualDisplay 6. VirtualDisplay. Callback 7. ImageReader 8. Image 9. Bitmap 10. PixelFormat
실현 절차
화면의 실시 간 정 보 를 가 져 옵 니 다.
먼저 캡 처 서 비 스 를 요청 하고 돌아 온 Intent 데 이 터 를 가 져 옵 니 다. 이 서 비 스 는 일반 서비스 와 달리 Media Projection Manager 로 전 환 됩 니 다. 이름 을 보 니 관리자 입 니 다. 이 관리 자 는 MediaProjection 을 가지 고 있 고 캡 처 를 요청 하 는 Intent 도 있 습 니 다.이 MediaProjection Manager 를 받 는 방법 은 두 가지 가 있 습 니 다.
Context.getSystemService(Context.MEDIA_PROJECTION_SERVICE); or Context.getSystemService(MediaProjectionManager.class);
MediaProjectionManager 를 받 으 면 그 명의 의 Intent 를 받 을 수 있 습 니 다. 이 Intent 를 시작 하면 우 리 는 다른 Intent 를 받 을 수 있 습 니 다.그래서 우 리 는 startActivity ForResult 라 는 방식 으로 이 Intent 를 시작 해 야 합 니 다.이 Intent 를 시작 하면 시스템 은 사용자 에 게 권한 을 신청 하여 사용자 에 게 다음 에 캡 처 작업 이 있 을 것 이 라 고 알 리 는 동시에 캡 처 준비 도 시작 합 니 다.startActivity ForResult 방식 으로 시작 되 기 때문에 onActivity Result 에서 실시 간 화면의 정 보 를 되 돌려 줍 니 다.(녹화 도 이렇게 했다)

    public void requestScreenShot() {
        if (Build.VERSION.SDK_INT >= 21) {
//            MediaProjectionManager mediaProjectionManager = (MediaProjectionManager) getSystemService(Context.MEDIA_PROJECTION_SERVICE);  //方式一
            MediaProjectionManager mediaProjectionManager = getSystemService(MediaProjectionManager.class);  //方式二
            startActivityForResult(mediaProjectionManager.createScreenCaptureIntent(), REQUEST_MEDIA_PROJECTION);//REQUEST_MEDIA_PROJECTION是我们自己定义的一个int，随便给可以。
        } else {
            Toast.makeText(MainActivity.this, "版本过低,无法截屏", Toast.LENGTH_SHORT).show();
        }
    }

onActivity Result 방법 에서 되 돌아 오 는 데이터, Intent 형식 을 얻 을 수 있 습 니 다.

@Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        switch (requestCode) {
            case REQUEST_MEDIA_PROJECTION: {
                if (resultCode == -1 && data != null) {//这里的resultCode必须为-1（Activity.RESULT_OK），后面也会用到-1（系统返回的-1，只需要记住就可以了）；
                    this.data = data;  //记录这里拿到data，是一个Intent，实际上这里记录的只是一个引用，里面的东西是实时在改变的（因为里面记录的是屏幕信息），信息存储在intent里面的bundle，bundle里面记录的是一个用Android专用序列化方式Parcelable序列化过的一个对象。
                }
            }
        }
    }

화면 정 보 를 받 은 후, 우 리 는 그것 을 우리 가 필요 로 하 는 PNG 나 bitmap 형식 으로 변환 하 는 것 을 처리 해 야 한다.처 리 는 크게 두 단계 로 나 뉘 는데 첫 번 째 단 계 는 가상 화면 을 새로 만 들 고 이전에 받 은 정 보 를 가상 화면 에 표시 합 니 다.두 번 째 단 계 는 화면의 그림 을 가 져 옵 니 다.
새 가상 화면
MediaProjectionManager 를 빌려 야 합 니 다. 위 에서 말 했 듯 이 MediaProjectionManager 는 MediaProjection 을 가지 고 있 고 캡 처 를 요청 하 는 Intent 도 있 습 니 다. Intent 는 이미 사 용 했 습 니 다. 여 기 는 MediaProjection 을 사용 할 것 입 니 다.우 리 는 이 MediaProjection 을 받 아야 합 니 다. 방법 에는 두 개의 인자 가 있 습 니 다. (하 나 는 위 에서 말 한 - 1 (Activity. RESULT OK), 하 나 는 위 에서 받 은 화면 정보 Intent)

if(null==mMediaProjection)
    mMediaProjection = mediaProjectionManager.getMediaProjection(Activity.RESULT_OK,data);
 //这里的mediaProjectionManager 跟上面的不一定是同一个对象，可以自己通过Context重新请求一个MediaProjectionManager

ImageReader 대상 을 초기 화 합 니 다. 이 대상 은 가상 화 화면 에 사 용 됩 니 다. 이 ImageReader 는 실제 화면 에 있 는 화면 입 니 다.ImageReader 를 4 개의 인자 로 초기 화 합 니 다.new Instance (int width, int height, int format, int maxImages) 는 각각 이미지 의 너비, 높이, 이미지 색상 형식, imagereader 에 최대 몇 장의 그림 (메모리 소모 가 많 음) 을 저장 합 니 다. 이 형식 은 ImageFormat 이나 PixelFormat 에 있어 야 합 니 다. 모든 형식 이 지원 되 는 것 이 아니 라 ImageFormat. NV 21 은 지원 되 지 않 습 니 다.

mImageReader = ImageReader.newInstance(
                    getScreenWidth(),  //真实屏幕宽度
                    getScreenHeight(),  //真实屏幕高度
                    PixelFormat.RGBA_8888,// a pixel两节省一些内存 个2个字节 此处RGBA_8888 必须和下面 buffer处理一致的格式
                    1);  //最多存储一张图像

다음은 실제 화면 파 라 메 터 를 가 져 오 는 방법 입 니 다.

//获取真实屏幕宽度（单位px）
private int getScreenWidth() {
        return Resources.getSystem().getDisplayMetrics().widthPixels;
    }

//获取真实屏幕高度（单位px）
private int getScreenHeight() {
        return Resources.getSystem().getDisplayMetrics().heightPixels;
    }

//获取状态栏高度（单位px）
private int getStatusBatHeight(){
        /**
         * 获取状态栏高度——方法1
         * */
       //获取status_bar_height资源的ID
        int resourceId = getContext().getResources().getIdentifier("status_bar_height", "dimen", "android");
        if (resourceId > 0) {
            //根据资源ID获取响应的尺寸值
            statusBarHeight1 = getContext().getResources().getDimensionPixelSize(resourceId);
            float scale = getContext().getResources().getDisplayMetrics().density;
            statusBarHeight1= (int) (statusBarHeight1*scale+0.5f);
            return statusBarHeight1;
        }
        return 0;
    }

그 다음 에 가상 화면 을 새로 만 듭 니 다. 이전에 받 은 mMedia Projection 을 사용 하면 이 대상 아래 에 createVirtual Display 방법 이 있 습 니 다. 이 방법 은 가상 화면 을 만 드 는 것 입 니 다.다음은 각 매개 변수의 의 미 를 소개 한다.
VirtualDisplay createVirtualDisplay (String name,/가상 화면의 이름, 비어 있 으 면 안 됩 니 다. int width,/가상 화면의 너비 int height,/가상 화면의 높이 int dpi,/가상 화면의 DPI int flags,/가상 화면의 디 스 플레이 로 고 를 마음대로 가 져 올 수 있 습 니 다. displayManager 아래 int 상수 Surface surface surface,/가상 화면 이미 지 를 저장 하 는 UI Virtual Display. Callback callback,/가상 화면 상태 가 변 경 된 리 셋 Handler handler)//위 에서 실행 중인 스 레 드 를 리 셋 합 니 다. null 위 에서 리 셋 하면 주 스 레 드 에서 실 행 됩 니 다.

mVirtualDisplay = mMediaProjection.createVirtualDisplay("screen-mirror",
                getScreenWidth(),
                getScreenHeight(),
                getScreenDpi(),
                DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR,
                mImageReader.getSurface(), null, null);

가상 화면의 그림 처리
가상 화면 을 저장 하 는 ImageReader 대상 에서 이미지 이미 지 를 가 져 오 면 이미지 의 바이트 배열 정 보 를 얻 을 수 있 습 니 다. bitmap 대상 을 새로 만 들 고 바이트 정 보 를 bitmap 에 전달 하면 우리 가 필요 로 하 는 이미 지 를 얻 을 수 있 습 니 다. 이 bitmap 는 바로 우리 의 스크린 캡 처 입 니 다. bitmap 의 색채 형식 과 위 에서 ImageReader 에 설정 해 야 합 니 다.같다

            Image image = mImageReader.acquireLatestImage();
            while(null==image)
                image=mImageReader.acquireLatestImage();
            int width = image.getWidth();
            int height = image.getHeight();
            final Image.Plane[] planes = image.getPlanes();
            final ByteBuffer buffer = planes[0].getBuffer();
            //每个像素的间距
            int pixelStride = planes[0].getPixelStride();
            //总的间距
            int rowStride = planes[0].getRowStride();
            int rowPadding = rowStride - pixelStride * width;
            Bitmap bitmap = Bitmap.createBitmap(width + rowPadding / pixelStride, height,
                    Bitmap.Config.ARGB_8888);
            bitmap.copyPixelsFromBuffer(buffer);
            bitmap = Bitmap.createBitmap(bitmap,0,0,width,height);//这里的bitmap为最终的截图
            image.close();
            File fileImage = null;
            if (bitmap != null) {
                try {
                    fileImage = new File(mLocalUrl);//mLocalURL为存储的路径
                    if (!fileImage.exists()) {
                        fileImage.createNewFile();
                    }
                    FileOutputStream out = new FileOutputStream(fileImage);
                    if (out != null) {
                        bitmap.compress(Bitmap.CompressFormat.PNG, 100, out);
                        out.flush();
                        out.close();
                    }
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                    fileImage = null;
                } catch (IOException e) {
                    e.printStackTrace();
                    fileImage = null;
                }
            }
            if (bitmap != null && !bitmap.isRecycled()) {
                bitmap.recycle();
            }
        }

        if (mVirtualDisplay != null) {
            mVirtualDisplay.release();
        }

        if (mOnShotListener != null) {
            mOnShotListener.onFinish();
        }
        if(null!=mMediaProjection){
            mMediaProjection.stop();
        }

아래 에 완전한 코드 가 붙 어 있 습 니 다. 회사 의 프로젝트 이기 때문에 전체 프로젝트 를 붙 이지 않 습 니 다. 이 코드 는 위 단계 의 두 단계 입 니 다. 이전의 점프 는 activity 에서 스스로 가 져 와 야 합 니 다. 획득 방법 은 다음 과 같 습 니 다.

//在oncreate或者onresume里面调用
public void requestScreenShot() {
        if (Build.VERSION.SDK_INT >= 21) {
//            MediaProjectionManager mediaProjectionManager = (MediaProjectionManager) getSystemService(Context.MEDIA_PROJECTION_SERVICE);  //方式一
            MediaProjectionManager mediaProjectionManager = getSystemService(MediaProjectionManager.class);  //方式二
            startActivityForResult(mediaProjectionManager.createScreenCaptureIntent(), REQUEST_MEDIA_PROJECTION);//REQUEST_MEDIA_PROJECTION是我们自己定义的一个int，随便给可以。
        } else {
            Toast.makeText(MainActivity.this, "版本过低,无法截屏", Toast.LENGTH_SHORT).show();
        }
    }


 @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        switch (requestCode) {
            case REQUEST_MEDIA_PROJECTION: {
                if (resultCode == -1 && data != null) {//这里的resultCode必须为-1（Activity.RESULT_OK），后面也会用到-1（系统返回的-1，只需要记住就可以了）；
                    this.data = data;  //记录这里拿到data，是一个Intent，实际上这里记录的只是一个引用，里面的东西是实时在改变的（因为里面记录的是屏幕信息），信息存储在intent里面的bundle，bundle里面记录的是一个用Android专用序列化方式Parcelable序列化过的一个对象。
                }
            }
        }
    }

이 코드 는 하위 스 레 드 에서 실행 하 는 것 이 좋 습 니 다. 프로젝트 에서 이미 하위 스 레 드 에서 실행 되 었 기 때문에 여 기 는 Thread 와 Handler 를 사용 하지 않 습 니 다.

package com.hskj.damnicomniplusvic.wevenation.util;

import android.annotation.TargetApi;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.PixelFormat;
import android.graphics.Rect;
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.SystemClock;
import android.text.TextUtils;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.ref.SoftReference;
import java.nio.ByteBuffer;

/**
 * Created by wei on 16-12-1.
 */
public class Shotter {

    private final SoftReference mRefContext;
    private ImageReader mImageReader;
    private MediaProjection mMediaProjection;
    private VirtualDisplay mVirtualDisplay;
    int statusBarHeight1 = -1;
    private String mLocalUrl = "";
    private Rect mRect;


//rect是我在项目里面需要截图的区域，一个图标。
    public Shotter(Context context, Intent data, Rect rect) {
        this.mRefContext = new SoftReference<>(context);
        this.mRect=rect;

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            if(null==mMediaProjection)
                mMediaProjection = getMediaProjectionManager().getMediaProjection(Activity.RESULT_OK,
                    data);
            mImageReader = ImageReader.newInstance(
                    getScreenWidth(),
                    getScreenHeight(),
                    PixelFormat.RGBA_8888,// a pixel两节省一些内存 个2个字节 此处RGBA_8888 必须和下面 buffer处理一致的格式
                    1);
            getStatusBatHeight();
        }
    }


    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    private void virtualDisplay() {

        mVirtualDisplay = mMediaProjection.createVirtualDisplay("screen-mirror",
                getScreenWidth(),
                getScreenHeight(),
                getScreenDpi(),
                DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR,
                mImageReader.getSurface(), null, null);

    }

    public void startScreenShot(String loc_url) {
        mLocalUrl = loc_url;
        startScreenShot();
    }


    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    public void startScreenShot() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            virtualDisplay();
            Image image = mImageReader.acquireLatestImage();
            while(null==image)
                image=mImageReader.acquireLatestImage();
            int width = image.getWidth();
            int height = image.getHeight();
            final Image.Plane[] planes = image.getPlanes();
            final ByteBuffer buffer = planes[0].getBuffer();
            //每个像素的间距
            int pixelStride = planes[0].getPixelStride();
            //总的间距
            int rowStride = planes[0].getRowStride();
            int rowPadding = rowStride - pixelStride * width;
            Bitmap bitmap = Bitmap.createBitmap(width + rowPadding / pixelStride, height,
                    Bitmap.Config.ARGB_8888);
            bitmap.copyPixelsFromBuffer(buffer);
            if(null!=mRect)
                bitmap = Bitmap.createBitmap(bitmap, mRect.left, mRect.top, mRect.width(), mRect.height());
            else
                bitmap = Bitmap.createBitmap(bitmap,0,0,width,height);
            image.close();
            File fileImage = null;
            if (bitmap != null) {
                try {
                    if (TextUtils.isEmpty(mLocalUrl)) {
                        mLocalUrl = getContext().getExternalFilesDir("screenshot").getAbsoluteFile() + "/" + SystemClock.currentThreadTimeMillis() + ".png";
                    }
                    fileImage = new File(mLocalUrl);

                    if (!fileImage.exists()) {
                        fileImage.createNewFile();
                    }
                    FileOutputStream out = new FileOutputStream(fileImage);
                    if (out != null) {
                        bitmap.compress(Bitmap.CompressFormat.PNG, 100, out);
                        out.flush();
                        out.close();
                    }

                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                    fileImage = null;
                } catch (IOException e) {
                    e.printStackTrace();
                    fileImage = null;
                }
            }
            if (bitmap != null && !bitmap.isRecycled()) {
                bitmap.recycle();
            }
        }

        if (mVirtualDisplay != null) {
            mVirtualDisplay.release();
        }

        if(null!=mMediaProjection){
            mMediaProjection.stop();
        }

    }



    private MediaProjectionManager getMediaProjectionManager() {

        return (MediaProjectionManager) getContext().getSystemService(
                Context.MEDIA_PROJECTION_SERVICE);
    }

    private Context getContext() {
        return mRefContext.get();
    }


    private int getScreenWidth() {
        return Resources.getSystem().getDisplayMetrics().widthPixels;
    }

    private int getScreenHeight() {
        return Resources.getSystem().getDisplayMetrics().heightPixels;
    }

    private int getScreenDpi(){
        return Resources.getSystem().getDisplayMetrics().densityDpi;
    }

    private void getStatusBatHeight(){
        /**
         * 获取状态栏高度——方法1
         * */
       //获取status_bar_height资源的ID
        int resourceId = getContext().getResources().getIdentifier("status_bar_height", "dimen", "android");
        if (resourceId > 0) {
            //根据资源ID获取响应的尺寸值
            statusBarHeight1 = getContext().getResources().getDimensionPixelSize(resourceId);
            float scale = getContext().getResources().getDisplayMetrics().density;
            statusBarHeight1= (int) (statusBarHeight1*scale+0.5f);
        }
    }
}

Android 캡 처, 셸 방식, 루트 필요, 버 전 요구 없 음
코드 에서 셸 명령 을 직접 실행 합 니 다. 이 명령 은 컴퓨터 에서 adb 방식 으로 실행 되 며 루트 없 이도 캡 처 할 수 있 습 니 다. 코드 에 루트 권한 이 필요 합 니 다. PC 에서 캡 처 하고 DOS 창 에 입력 adb shell screencap -p /sdcard/damn.png 하면 sdcard 의 루트 디 렉 터 리 에 저 장 된 damn. png 파일 을 캡 처 하고 저장 할 수 있 습 니 다. 외부 에서 직접 호출 doCmds("screencap -p /sdcard/damn.png") 여 기 는 앞의 adb shell 을 사용 하지 않 습 니 다.pc 에서 우리 의 adb 는 휴대 전화 에 연결 하 는 도구 이기 때문에 휴대 전화 자체 에 이 단 계 를 연결 하지 않 아 도 됩 니 다.

    /**
     * 执行shell命令函数
     * @param cmd 需要执行的shell命令
     */
    public static void doCmds(String cmd){
        Process process = null;
        try {
            process = Runtime.getRuntime().exec("sh");
            DataOutputStream os = new DataOutputStream(process.getOutputStream());
            os.writeBytes(cmd+"
");
            os.writeBytes("exit
");
            os.flush();
            os.close();
            process.waitFor();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

다음은 셸 스 크 립 트 를 실행 하 는 도구 류 를 제공 합 니 다. 다른 블 로그 에서 옮 겨 왔 습 니 다.

package com.hskj.damnicomniplusvic.wevenation.util;

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.List;

/**
 * Android执行shell命令工具类
 * Created by DAMNICOMNIPLUSVIC on 2017/7/26.
 * (c) 2017 DAMNICOMNIPLUSVIC Inc,All Rights Reserved.
 */

public class ShellUtil {
    private static final String COMMAND_SU       = "su";
    private static final String COMMAND_SH       = "ls";
    private static final String COMMAND_EXIT     = "exit
";
    private static final String COMMAND_LINE_END = "
";


    private ShellUtil() {
        throw new AssertionError();
    }


    /**
     * check whether has root permission
     *
     * @return root or not
     */
    public static boolean checkRootPermission() {
        return execCommand("echo root", true, false).result == 0;
    }


    /**
     * execute shell command, default return result msg
     *
     * @param command command
     * @param isRoot whether need to run with root
     * @return the result of execute command
     * @see ShellUtil#execCommand(String[], boolean, boolean)
     */
    public static CommandResult execCommand(String command, boolean isRoot) {
        return execCommand(new String[] {command}, isRoot, true);
    }


    /**
     * execute shell commands, default return result msg
     *
     * @param commands command list
     * @param isRoot whether need to run with root
     * @return the result of execute command
     * @see ShellUtil#execCommand(String[], boolean, boolean)
     */
    public static CommandResult execCommand(List commands, boolean isRoot) {
        return execCommand(commands == null ? null : commands.toArray(new String[] {}), isRoot, true);
    }


    /**
     * execute shell commands, default return result msg
     *
     * @param commands command array
     * @param isRoot whether need to run with root
     * @return the result of execute command
     * @see ShellUtil#execCommand(String[], boolean, boolean)
     */
    public static CommandResult execCommand(String[] commands, boolean isRoot) {
        return execCommand(commands, isRoot, true);
    }


    /**
     * execute shell command
     *
     * @param command command
     * @param isRoot whether need to run with root
     * @param isNeedResultMsg whether need result msg
     * @return the result of execute command
     * @see ShellUtil#execCommand(String[], boolean, boolean)
     */
    public static CommandResult execCommand(String command, boolean isRoot, boolean isNeedResultMsg) {
        return execCommand(new String[] {command}, isRoot, isNeedResultMsg);
    }


    /**
     * execute shell commands
     *
     * @param commands command list
     * @param isRoot whether need to run with root
     * @param isNeedResultMsg whether need result msg
     * @return the result of execute command
     * @see ShellUtil#execCommand(String[], boolean, boolean)
     */
    public static CommandResult execCommand(List commands, boolean isRoot, boolean isNeedResultMsg) {
        return execCommand(commands == null ? null : commands.toArray(new String[] {}), isRoot, isNeedResultMsg);
    }


    /**
     * execute shell commands
     *
     * @param commands command array
     * @param isRoot whether need to run with root
     * @param isNeedResultMsg whether need result msg
     * @return 

     *         
if isNeedResultMsg is false, {@link CommandResult#successMsg} is null and
     *         {@link CommandResult#errorMsg} is null.
     *         
if {@link CommandResult#result} is -1, there maybe some excepiton.
     *         
     */
    public static CommandResult execCommand(String[] commands, boolean isRoot, boolean isNeedResultMsg) {
        int result = -1;
        if (commands == null || commands.length == 0) {
            return new CommandResult(result, null, null);
        }


        Process process = null;
        BufferedReader successResult = null;
        BufferedReader errorResult = null;
        StringBuilder successMsg = null;
        StringBuilder errorMsg = null;


        DataOutputStream os = null;
        try {
            process = Runtime.getRuntime().exec(isRoot ? COMMAND_SU : COMMAND_SH);
            os = new DataOutputStream(process.getOutputStream());
            for (String command : commands) {
                if (command == null) {
                    continue;
                }


                // donnot use os.writeBytes(commmand), avoid chinese charset error
                os.write(command.getBytes());
                os.writeBytes(COMMAND_LINE_END);
                os.flush();
            }
            os.writeBytes(COMMAND_EXIT);
            os.flush();


            result = process.waitFor();
            // get command result
            if (isNeedResultMsg) {
                successMsg = new StringBuilder();
                errorMsg = new StringBuilder();
                successResult = new BufferedReader(new InputStreamReader(process.getInputStream()));
                errorResult = new BufferedReader(new InputStreamReader(process.getErrorStream()));
                String s;
                while ((s = successResult.readLine()) != null) {
                    successMsg.append(s);
                }
                while ((s = errorResult.readLine()) != null) {
                    errorMsg.append(s);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (os != null) {
                    os.close();
                }
                if (successResult != null) {
                    successResult.close();
                }
                if (errorResult != null) {
                    errorResult.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }


            if (process != null) {
                process.destroy();
            }
        }
        return new CommandResult(result, successMsg == null ? null : successMsg.toString(), errorMsg == null ? null
                : errorMsg.toString());
    }


    /**
     * result of command
     * 

     * 
{@link CommandResult#result} means result of command, 0 means normal, else means error, same to excute in
     * linux shell
     * 
{@link CommandResult#successMsg} means success message of command result
     * 
{@link CommandResult#errorMsg} means error message of command result
     * 
     *
     * @author Trinea 2013-5-16
     */
    public static class CommandResult {


        /** result of command **/
        public int    result;
        /** success message of command result **/
        public String successMsg;
        /** error message of command result **/
        public String errorMsg;


        public CommandResult(int result) {
            this.result = result;
        }


        public CommandResult(int result, String successMsg, String errorMsg) {
            this.result = result;
            this.successMsg = successMsg;
            this.errorMsg = errorMsg;
        }
    }
}