package com.screenshot.ui;


import android.annotation.SuppressLint;
import android.app.Service;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.os.Environment;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.view.View;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Field;


public class ScreenShotService extends Service {
    public static final boolean SSS_DEFAULT_START = false;
    public static final boolean SSS_START = true;
    public static final boolean SSS_STOP = false;
    public static final String TRANSCRIBE_TAG = "TRANSCRIBE_TAG";
    public static final long SSS_DELAY_MILLIS = 100L;
    public static final  String SSS_FILE_PATH = "/luzhi/";
    public static final int SSS_MSG_WHAT = 256;
    private ScreenShotServiceHandler handler;
    private boolean isStart = SSS_STOP;

    private View[] sortViews(View[] viewarray){
        if ((viewarray == null) || (viewarray.length < 0)) {
            return null;
        }
        int i = 0;
        View[] views = new View[viewarray.length];
        for (View v : viewarray) {
            views[i++] = v;
        }


        int[] arrayOfInt = new int[2];
        View localView;
        int j = 0;
        int length = views.length;
        for (i = 0; i < length; i++) {
            localView = views[i];
            localView.getLocationOnScreen(arrayOfInt);
            if ((arrayOfInt[0] > 0) || (arrayOfInt[1] > 0)) {
                for (j = i + 1; j < views.length; j++) {
                    views[j - 1] = views[j];
                }
                views[views.length - 1] = localView;
                length--;
                i--;
            }
        }
        return views;
    }
    
    private View[] getWindowDecorViewsDownApi15() throws Exception {
        Class<?> windowManager = Class
                .forName("android.view.WindowManagerImpl");
        Field viewsField = windowManager.getDeclaredField("mViews");
        Field instanceField = windowManager.getDeclaredField("mWindowManager");
        viewsField.setAccessible(true);
        instanceField.setAccessible(true);
        Object instance = instanceField.get(null);
        View[] viewarray = (View[]) viewsField.get(instance);
        return sortViews(viewarray);
    }
    
    private View[] getWindowDecorViewsApi14_16() throws Exception {
        Class<?> windowManager = Class
                .forName("android.view.WindowManagerImpl");        
        Field viewsField = windowManager.getDeclaredField("mViews");
        Field instanceField = windowManager.getDeclaredField("sWindowManager");
        viewsField.setAccessible(true);
        instanceField.setAccessible(true);
        Object instance = instanceField.get(null);
        View[] viewarray = (View[]) viewsField.get(instance);
        return sortViews(viewarray);
    }
    
    private View[] getWindowDecorViewsApiUp17() throws Exception {
        Class<?> windowManager = Class
                .forName("android.view.WindowManagerGlobal");        
        Field viewsField = windowManager.getDeclaredField("mViews");
        Field instanceField = windowManager.getDeclaredField("sDefaultWindowManager");
        viewsField.setAccessible(true);
        instanceField.setAccessible(true);
        Object instance = instanceField.get(null);
        View[] viewarray = (View[]) viewsField.get(instance);
        return sortViews(viewarray);
    }
    
    private View[] getWindowDecorViews() throws Exception {
        View[] views;
        if(android.os.Build.VERSION.SDK_INT >= 14 && android.os.Build.VERSION.SDK_INT  < 17 ){
            views = getWindowDecorViewsApi14_16();
        }else if(android.os.Build.VERSION.SDK_INT >= 17 ){
            views = getWindowDecorViewsApiUp17();
        }else{
            views = getWindowDecorViewsDownApi15();
        }
        return views;
    }

    private void savePic(Bitmap paramBitmap, String paramString) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(paramString);
            if (null != fos) {
                paramBitmap.compress(Bitmap.CompressFormat.PNG, 90, fos);
                fos.flush();
                fos.close();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    private void screenShot() {
        try {
            View[] arrayOfView = getWindowDecorViews();
            Bitmap localBitmap = view2Bitmap(arrayOfView);
            new saveFileThread(localBitmap).start();
        } catch (Exception localException) {
            localException.printStackTrace();
        }
    }


    private Bitmap view2Bitmap(View paramView) {
        Log.e("saveFileThread view2Bitmap(View view)");
        paramView.setDrawingCacheEnabled(true);
        paramView.buildDrawingCache();
        Bitmap localBitmap1 = paramView.getDrawingCache();
        Bitmap localBitmap2 = null;
        if (localBitmap1 != null) {
            localBitmap2 = Bitmap.createBitmap(localBitmap1);
        }
        paramView.destroyDrawingCache();
        return localBitmap2;
    }


    private Bitmap view2Bitmap(View[] paramArrayOfView) {
        Canvas localCanvas = null;
        Paint localPaint = null;
        Bitmap newbitmap = null;
        int[] arrayOfInt = new int[2];


        for (View localView : paramArrayOfView) {
            Bitmap localBitmap = view2Bitmap(localView);
            localView.getLocationOnScreen(arrayOfInt);
            if (localBitmap != null) {
                if (localCanvas == null) {
                    newbitmap = Bitmap.createBitmap(localView.getWidth(),
                            localView.getHeight(), Config.ARGB_8888);// 创建一个新的和SRC
                    localCanvas = new Canvas(newbitmap);
                    localPaint = new Paint();
                }
                localCanvas.drawBitmap(localBitmap, arrayOfInt[0],
                        arrayOfInt[1], localPaint);
                localBitmap.recycle();
                localBitmap = null;
            }
        }
        if (localCanvas != null) {
            localCanvas.save(Canvas.ALL_SAVE_FLAG);// 保存
            localCanvas.restore();// 存储
        }
        return newbitmap;
    }


    public IBinder onBind(Intent paramIntent) {
        return null;
    }


    public void onCreate() {
        super.onCreate();
        Log.e("ScreenShotService onCreate");
        handler = new ScreenShotServiceHandler();
    }


    public void onStart(Intent paramIntent, int paramInt) {
        super.onStart(paramIntent, paramInt);
        Log.e("ScreenShotService onStart -----start----");
        String str = TRANSCRIBE_TAG;
        boolean localstart = paramIntent
                .getBooleanExtra(str, SSS_DEFAULT_START);
        if (this.isStart != localstart) {
            this.isStart = localstart;
            if (this.isStart == SSS_START) {
                handler.sendEmptyMessageDelayed(SSS_MSG_WHAT, SSS_DELAY_MILLIS);
            } else {
                handler.removeMessages(SSS_MSG_WHAT);
            }
        }
    }


    @SuppressLint({ "HandlerLeak", "HandlerLeak" })
    private class ScreenShotServiceHandler extends Handler {
        public void handleMessage(Message paramMessage) {
            if (paramMessage.what == SSS_MSG_WHAT) {
                ScreenShotService.this.screenShot();
                if (ScreenShotService.this.isStart) {
                    ScreenShotService.this.handler.sendEmptyMessageDelayed(
                            SSS_MSG_WHAT, SSS_DELAY_MILLIS);
                }
            }
        }
    }


    private class saveFileThread extends Thread {
        private Bitmap mbitmap;


        public saveFileThread(Bitmap arg2) {
            this.mbitmap = arg2;
        }


        public void run() {
            if (this.mbitmap == null) {
                Log.e("saveFileThread run mbitmap is null ");
            }
            File localFile1 = Environment.getExternalStorageDirectory();
            File localFile2 = new File(localFile1, SSS_FILE_PATH);
            if (!localFile2.exists()) {
                localFile2.mkdirs();
            }
            String filename = localFile2.getAbsolutePath() + "/"
                    + System.currentTimeMillis() + ".png";
            Log.e("saveFileThread run picPath = " + filename);
            ScreenShotService.this.savePic(mbitmap, filename);
            this.mbitmap.recycle();
            this.mbitmap = null;
        }
    }
}

package com.screenshot.ui;

import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.view.Window;
import android.view.WindowManager;
import android.widget.ImageView;
import java.io.File;
import java.util.Arrays;
import java.util.Comparator;

import com.screenshot.R;

public class PlayActivity extends Activity {
    private PlayActivityHandler mHandler;
    private ImageView play_iv;
    private File[] arrayOfFile2;

    private File[] getFileList() {
        File localFile1 = Environment.getExternalStorageDirectory();
        File localFile2 = new File(localFile1, ScreenShotService.SSS_FILE_PATH);
        File[] arrayOfFile;
        if (!localFile2.exists()) {
            return null;
        }
        arrayOfFile = localFile2.listFiles();
        Arrays.sort(arrayOfFile, new Comparator<File>() {

            @Override
            public int compare(File paramFile1, File paramFile2) {
                long file1name = Long.valueOf(getFileNameNoEx(paramFile1
                        .getName()));
                long file2name = Long.valueOf(getFileNameNoEx(paramFile2
                        .getName()));
                return (int) (file1name - file2name);
            }

        });
        return arrayOfFile;
    }

    private void play() {
        arrayOfFile2 = getFileList();
        mHandler.setCount(0);
        mHandler.sendEmptyMessageDelayed(ScreenShotService.SSS_MSG_WHAT,
                ScreenShotService.SSS_DELAY_MILLIS);
    }

    public String getExtensionName(String paramString) {
        if ((paramString != null) && (paramString.length() > 0)) {
            int i = paramString.lastIndexOf(‘.‘);
            if (i > -1) {
                int j = paramString.length() + -1;
                if (i < j) {
                    int k = i + 1;
                    paramString = paramString.substring(k);
                }
            }
        }
        return paramString;
    }

    public String getFileNameNoEx(String paramString) {
        if ((paramString != null) && (paramString.length() > 0)) {
            int i = paramString.lastIndexOf(‘.‘);
            if (i > -1) {
                int j = paramString.length();
                if (i < j)
                    paramString = paramString.substring(0, i);
            }
        }
        return paramString;
    }

    protected void onCreate(Bundle paramBundle) {
        super.onCreate(paramBundle);
        // 设置无标题
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        // 设置全屏
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);

        setContentView(R.layout.play);
        this.play_iv = (ImageView) findViewById(R.id.play_iv);
        mHandler = new PlayActivityHandler();
        play();
    }

    private class PlayActivityHandler extends Handler {
        private int count = 0;
        //private Bitmap localBitmap;
        public void setCount(int vaule) {
            count = vaule;
        }

        @Override
        public void handleMessage(Message msg) {
            if (arrayOfFile2 != null && count < arrayOfFile2.length) {                
                Bitmap localBitmap = BitmapFactory
                        .decodeFile(arrayOfFile2[count++].getAbsolutePath());
                play_iv.setImageBitmap(localBitmap);
                mHandler.sendEmptyMessageDelayed(
                        ScreenShotService.SSS_MSG_WHAT,
                        ScreenShotService.SSS_DELAY_MILLIS);                
            }
        }

    }
}