content: package com.cj.ScreenShotUtil;
  
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.text.SimpleDateFormat;
  import java.util.Date;
  
  import android.annotation.SuppressLint;
  import android.content.Context;
  import android.graphics.Bitmap;
  import android.graphics.Canvas;
  import android.graphics.Matrix;
  import android.util.DisplayMetrics;
  import android.util.Log;
  import android.view.Display;
  import android.view.Surface;
  import android.view.WindowManager;
  import android.widget.Toast;
  
  public class ScreentShotUtil
  {
  
  	private static final String TAG = "ScreentShotUtil";
  
  	private static final String CLASS1_NAME = "android.view.SurfaceControl";
  
  	private static final String CLASS2_NAME = "android.view.Surface";
  
  	private static final String METHOD_NAME = "screenshot";
  
  	private static ScreentShotUtil instance;
  
  	private Display mDisplay;
  
  	private DisplayMetrics mDisplayMetrics;
  
  	private Matrix mDisplayMatrix;
  
  	private WindowManager wm;
  	
  	private SimpleDateFormat format;
  
  	private ScreentShotUtil()
  	{
  
  	}
  
  	public static ScreentShotUtil getInstance()
  	{
  		synchronized (ScreentShotUtil.class)
  		{
  			if (instance == null)
  			{
  				instance = new ScreentShotUtil();
  			}
  		}
  		return instance;
  	}
  
  	private Bitmap screenShot(int width, int height)
  	{
  		Log.i(TAG, "android.os.Build.VERSION.SDK : " + android.os.Build.VERSION.SDK_INT);
  		Class<?> surfaceClass = null;
  		Method method = null;
  		try
  		{
  			Log.i(TAG, "width : " + width);
  			Log.i(TAG, "height : " + height);
  			if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR2)
  			{
  				
  				surfaceClass = Class.forName(CLASS1_NAME);
  			}
  			else
  			{
  				surfaceClass = Class.forName(CLASS2_NAME);
  			}
  			method = surfaceClass.getDeclaredMethod(METHOD_NAME, int.class, int.class);
  			method.setAccessible(true);
  			return (Bitmap) method.invoke(null, width, height);
  		}
  		catch (NoSuchMethodException e)
  		{
  			Log.e(TAG, e.toString());
  		}
  		catch (IllegalArgumentException e)
  		{
  			Log.e(TAG, e.toString());
  		}
  		catch (IllegalAccessException e)
  		{
  			Log.e(TAG, e.toString());
  		}
  		catch (InvocationTargetException e)
  		{
  			Log.e(TAG, e.toString());
  		}
  		catch (ClassNotFoundException e)
  		{
  			Log.e(TAG, e.toString());
  		}
  		return null;
  	}
  
  	/**
  	 * Takes a screenshot of the current display and shows an animation.
  	 */
  	@SuppressLint("NewApi")
  	public void takeScreenshot(Context context, String fileFullPath)
  	{
  		if(fileFullPath == ""){
  			format = new SimpleDateFormat("yyyyMMddHHmmss");
  			String fileName = format.format(new Date(System.currentTimeMillis())) + ".png";
  			fileFullPath = "/data/local/tmp/" + fileName;
  		}
  		
  		if(ShellUtils.checkRootPermission()){
  			if(android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.ICE_CREAM_SANDWICH){
  				ShellUtils.execCommand("/system/bin/screencap -p "+ fileFullPath,true);
  			}
  		}
  		else {
  			if(android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.JELLY_BEAN_MR2 && android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.ICE_CREAM_SANDWICH){
  				wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
  				mDisplay = wm.getDefaultDisplay();
  				mDisplayMatrix = new Matrix();
  				mDisplayMetrics = new DisplayMetrics();
  				// 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]);
  				}
  
  				Bitmap mScreenBitmap = screenShot((int) dims[0], (int) dims[1]);
  				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;
  					if (ss != null && !ss.isRecycled())
  					{
  						ss.recycle();
  					}
  				}
  
  				// If we couldn't take the screenshot, notify the user
  				if (mScreenBitmap == null)
  				{
  					Toast.makeText(context, "screen shot fail", Toast.LENGTH_SHORT).show();
  				}
  
  				// Optimizations
  				mScreenBitmap.setHasAlpha(false);
  				mScreenBitmap.prepareToDraw();
  
  				saveBitmap2file(context, mScreenBitmap, fileFullPath);
  			}
  		}
  		
  	}
  
  	// 
  	public void saveBitmap2file(Context context, Bitmap bmp, String fileName)
  	{
  		int quality = 100;
  		ByteArrayOutputStream baos = new ByteArrayOutputStream();
  		bmp.compress(Bitmap.CompressFormat.PNG, quality, baos);
  		InputStream is = new ByteArrayInputStream(baos.toByteArray());
  		byte[] buffer = new byte[1024];
  		int len = 0;
  		File file = new File(fileName);
  		if (!file.exists())
  		{
  			try
  			{
  				file.getParentFile().mkdir();
  				file.getParentFile().createNewFile();
  			}
  			catch (IOException e)
  			{
  				Log.e(TAG, e.toString());
  			}
  		}
  		else
  		{
  			try
  			{
  				file.getParentFile().delete();
  				file.getParentFile().createNewFile();
  			}
  			catch (IOException e)
  			{
  				Log.e(TAG, e.toString());
  			}
  		}
  		FileOutputStream stream = null;
  		try
  		{
  			stream = new FileOutputStream(file);
  			while ((len = is.read(buffer)) != -1)
  			{
  				stream.write(buffer, 0, len);
  			}
  			stream.flush();
  		}
  		catch (FileNotFoundException e)
  		{
  			Log.i(TAG, e.toString());
  		}
  		catch (IOException e)
  		{
  			Log.i(TAG, e.toString());
  		}
  		finally
  		{
  			if (is != null)
  			{
  				try
  				{
  					is.close();
  				}
  				catch (IOException e)
  				{
  					Log.i(TAG, e.toString());
  				}
  			}
  			if (stream != null)
  			{
  				try
  				{
  					stream.close();
  				}
  				catch (IOException e)
  				{
  					Log.i(TAG, e.toString());
  				}
  			}
  		}
  		if (bmp != null && !bmp.isRecycled())
  		{
  			bmp.recycle();
  		}
  	}
  
  	/**
  	 * @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;
  	}
  
  }
  