Main.java - 

package de.vogella.android.touch;

import java.io.File;
import java.io.FileOutputStream;

import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.os.Bundle;
import android.util.Log;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;

public class WriteOnScreenActivity extends Activity 
{
	SignatureView3Fast signature;
	/** Called when the activity is first created. */
	@Override
	public void onCreate(Bundle savedInstanceState) 
	{
		super.onCreate(savedInstanceState);
		setContentView(new SignatureView3Fast(this, null));
		signature = new SignatureView3Fast(this, null);
		System.out.println("This is a log message");
		Log.e("Mein Tag", "Hello");
	}
	@Override
	public boolean onCreateOptionsMenu(Menu menu) 
	{
		MenuInflater inflater = getMenuInflater();
		inflater.inflate(R.menu.menu, menu);
		return true;
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem item) 
	{
		switch (item.getItemId()) 
		{
		case R.id.save:
			View content = findViewById(R.id.linear);
			content.setDrawingCacheEnabled(true);
			getScreen(content);
//			signature.saveScreenshot();
			break;
		case R.id.Clear:
			onCreate(null);
			break;
		}
		return true;
	}
	private void getScreen(View content) {
		// TODO Auto-generated method stub
		Bitmap bitmap = content.getDrawingCache();
        File file = new File("/sdcard/test.png");
        try 
        {
            file.createNewFile();
            FileOutputStream ostream = new FileOutputStream(file);
            bitmap.compress(CompressFormat.PNG, 100, ostream);
            ostream.close();
        } 
        catch (Exception e) 
        {
            e.printStackTrace();
        }
	}
}

Calling Class - 

package de.vogella.android.touch;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.RectF;
import android.os.Environment;
import android.util.AttributeSet;
import android.util.Log;
import android.view.Display;
import android.view.MotionEvent;
import android.view.View;
import android.view.WindowManager;

public class SignatureView3Fast extends View {

	  private static final float STROKE_WIDTH = 3f;

	  /** Need to track this so the dirty region can accommodate the stroke. **/
	  private static final float HALF_STROKE_WIDTH = STROKE_WIDTH / 2;

	  private Paint paint = new Paint();
	  private Path path = new Path();
	  private Context context = this.getContext();
	  String mScreenshotPath = Environment.getExternalStorageDirectory() + "/Signature";

	  /**
	   * Optimizes painting by invalidating the smallest possible area.
	   */
	  private float lastTouchX;
	  private float lastTouchY;
	  private final RectF dirtyRect = new RectF();

	  public SignatureView3Fast(Context context, AttributeSet attrs) {
	    super(context, attrs);

	    paint.setAntiAlias(true);
	    paint.setColor(Color.WHITE);
	    paint.setStyle(Paint.Style.STROKE);
	    paint.setStrokeJoin(Paint.Join.ROUND);
	    paint.setStrokeWidth(STROKE_WIDTH);
	  }

	  /**
	   * Erases the signature.
	   */
	  public void clear() {
	    path.reset();
	    // Repaints the entire view.
	    invalidate();
	  }

	  @Override
	  protected void onDraw(Canvas canvas) 
	  {
	    canvas.drawPath(path, paint);
	  }

	  @Override
	  public boolean onTouchEvent(MotionEvent event) {
	    float eventX = event.getX();
	    float eventY = event.getY();

	    switch (event.getAction()) {
	      case MotionEvent.ACTION_DOWN:
	        path.moveTo(eventX, eventY);
	        lastTouchX = eventX;
	        lastTouchY = eventY;
	        // There is no end point yet, so don't waste cycles invalidating.
	        return true;

	      case MotionEvent.ACTION_MOVE:
	      case MotionEvent.ACTION_UP:
	        // Start tracking the dirty region.
	        resetDirtyRect(eventX, eventY);

	        // When the hardware tracks events faster than they are delivered, the
	        // event will contain a history of those skipped points.
	        int historySize = event.getHistorySize();
	        for (int i = 0; i < historySize; i++) {
	          float historicalX = event.getHistoricalX(i);
	          float historicalY = event.getHistoricalY(i);
	          expandDirtyRect(historicalX, historicalY);
	          path.lineTo(historicalX, historicalY);
	        }

	        // After replaying history, connect the line to the touch point.
	        path.lineTo(eventX, eventY);
	        break;

	      default:
	        return false;
	    }

	    // Include half the stroke width to avoid clipping.
	    invalidate(
	        (int) (dirtyRect.left - HALF_STROKE_WIDTH),
	        (int) (dirtyRect.top - HALF_STROKE_WIDTH),
	        (int) (dirtyRect.right + HALF_STROKE_WIDTH),
	        (int) (dirtyRect.bottom + HALF_STROKE_WIDTH));
	    
	    lastTouchX = eventX;
	    lastTouchY = eventY;

	    return true;
	  }

	  /**
	   * Called when replaying history to ensure the dirty region includes all
	   * points.
	   */
	  private void expandDirtyRect(float historicalX, float historicalY) {
	    if (historicalX < dirtyRect.left) {
	      dirtyRect.left = historicalX;
	    } else if (historicalX > dirtyRect.right) {
	      dirtyRect.right = historicalX;
	    }
	    if (historicalY < dirtyRect.top) {
	      dirtyRect.top = historicalY;
	    } else if (historicalY > dirtyRect.bottom) {
	      dirtyRect.bottom = historicalY;
	    }
	  }

	  /**
	   * Resets the dirty region when the motion event occurs.
	   */
	  private void resetDirtyRect(float eventX, float eventY) {

	    // The lastTouchX and lastTouchY were set when the ACTION_DOWN
	    // motion event occurred.
	    dirtyRect.left = Math.min(lastTouchX, eventX);
	    dirtyRect.right = Math.max(lastTouchX, eventX);
	    dirtyRect.top = Math.min(lastTouchY, eventY);
	    dirtyRect.bottom = Math.max(lastTouchY, eventY);
	  }
	    public void saveScreenshot() 
	    {
	        if (ensureSDCardAccess()) 
	        {
	        	Display display = ((WindowManager)context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
	        	int width = display.getWidth();
	        	int height = display.getHeight();
	            Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
	            Canvas canvas = new Canvas(bitmap);
	            onDraw(canvas);
	            File file = new File(mScreenshotPath + "/" + System.currentTimeMillis() + ".jpg");
	            FileOutputStream fos;
	            try {
	                fos = new FileOutputStream(file);
	                bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fos);
	                fos.close();
	            } catch (FileNotFoundException e) {
	                Log.e("Panel", "FileNotFoundException", e);
	            } catch (IOException e) {
	                Log.e("Panel", "IOEception", e);
	            }
	        }
	    }
	    
	    /**
	     * Helper method to ensure that the given path exists.
	     * TODO: check external storage state
	     */
	    private boolean ensureSDCardAccess() {
	        File file = new File(mScreenshotPath);
	        if (file.exists()) {
	            return true;
	        } else if (file.mkdirs()) {
	            return true;
	        }
	        return false;
	    }
}