Merge branch 'master' into froyo-release (0252330e) · Commits · e / os / android_frameworks_native-old

calendar/Android.mk

+0 −1

Original line number	Diff line number	Diff line
		@@ -10,7 +10,6 @@ LOCAL_SRC_FILES := \
		../core/java/android/pim/ICalendar.java \
		../core/java/android/pim/RecurrenceSet.java \
		../core/java/android/pim/ContactsAsyncHelper.java \
		../core/java/android/pim/DateException.java

		include $(BUILD_STATIC_JAVA_LIBRARY)

common/java/com/android/common/ui/PointerLocationView.java

deleted100644 → 0

+0 −337

Original line number	Diff line number	Diff line
		package com.android.common.ui;

		import android.content.Context;
		import android.graphics.Canvas;
		import android.graphics.Paint;
		import android.graphics.Paint.FontMetricsInt;
		import android.util.Log;
		import android.view.MotionEvent;
		import android.view.VelocityTracker;
		import android.view.View;
		import android.view.ViewConfiguration;

		import java.util.ArrayList;

		public class PointerLocationView extends View {
		public static class PointerState {
		private final ArrayList<Float> mXs = new ArrayList<Float>();
		private final ArrayList<Float> mYs = new ArrayList<Float>();
		private boolean mCurDown;
		private int mCurX;
		private int mCurY;
		private float mCurPressure;
		private float mCurSize;
		private int mCurWidth;
		private VelocityTracker mVelocity;
		}

		private final ViewConfiguration mVC;
		private final Paint mTextPaint;
		private final Paint mTextBackgroundPaint;
		private final Paint mTextLevelPaint;
		private final Paint mPaint;
		private final Paint mTargetPaint;
		private final Paint mPathPaint;
		private final FontMetricsInt mTextMetrics = new FontMetricsInt();
		private int mHeaderBottom;
		private boolean mCurDown;
		private int mCurNumPointers;
		private int mMaxNumPointers;
		private final ArrayList<PointerState> mPointers
		= new ArrayList<PointerState>();

		private boolean mPrintCoords = true;

		public PointerLocationView(Context c) {
		super(c);
		mVC = ViewConfiguration.get(c);
		mTextPaint = new Paint();
		mTextPaint.setAntiAlias(true);
		mTextPaint.setTextSize(10
		* getResources().getDisplayMetrics().density);
		mTextPaint.setARGB(255, 0, 0, 0);
		mTextBackgroundPaint = new Paint();
		mTextBackgroundPaint.setAntiAlias(false);
		mTextBackgroundPaint.setARGB(128, 255, 255, 255);
		mTextLevelPaint = new Paint();
		mTextLevelPaint.setAntiAlias(false);
		mTextLevelPaint.setARGB(192, 255, 0, 0);
		mPaint = new Paint();
		mPaint.setAntiAlias(true);
		mPaint.setARGB(255, 255, 255, 255);
		mPaint.setStyle(Paint.Style.STROKE);
		mPaint.setStrokeWidth(2);
		mTargetPaint = new Paint();
		mTargetPaint.setAntiAlias(false);
		mTargetPaint.setARGB(255, 0, 0, 192);
		mPathPaint = new Paint();
		mPathPaint.setAntiAlias(false);
		mPathPaint.setARGB(255, 0, 96, 255);
		mPaint.setStyle(Paint.Style.STROKE);
		mPaint.setStrokeWidth(1);

		PointerState ps = new PointerState();
		ps.mVelocity = VelocityTracker.obtain();
		mPointers.add(ps);
		}

		public void setPrintCoords(boolean state) {
		mPrintCoords = state;
		}

		@Override
		protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
		super.onMeasure(widthMeasureSpec, heightMeasureSpec);
		mTextPaint.getFontMetricsInt(mTextMetrics);
		mHeaderBottom = -mTextMetrics.ascent+mTextMetrics.descent+2;
		if (false) {
		Log.i("foo", "Metrics: ascent=" + mTextMetrics.ascent
		+ " descent=" + mTextMetrics.descent
		+ " leading=" + mTextMetrics.leading
		+ " top=" + mTextMetrics.top
		+ " bottom=" + mTextMetrics.bottom);
		}
		}

		@Override
		protected void onDraw(Canvas canvas) {
		synchronized (mPointers) {
		final int w = getWidth();
		final int itemW = w/7;
		final int base = -mTextMetrics.ascent+1;
		final int bottom = mHeaderBottom;

		final int NP = mPointers.size();

		if (NP > 0) {
		final PointerState ps = mPointers.get(0);
		canvas.drawRect(0, 0, itemW-1, bottom,mTextBackgroundPaint);
		canvas.drawText("P: " + mCurNumPointers + " / " + mMaxNumPointers,
		1, base, mTextPaint);

		final int N = ps.mXs.size();
		if ((mCurDown && ps.mCurDown) \|\| N == 0) {
		canvas.drawRect(itemW, 0, (itemW * 2) - 1, bottom, mTextBackgroundPaint);
		canvas.drawText("X: " + ps.mCurX, 1 + itemW, base, mTextPaint);
		canvas.drawRect(itemW * 2, 0, (itemW * 3) - 1, bottom, mTextBackgroundPaint);
		canvas.drawText("Y: " + ps.mCurY, 1 + itemW * 2, base, mTextPaint);
		} else {
		float dx = ps.mXs.get(N-1) - ps.mXs.get(0);
		float dy = ps.mYs.get(N-1) - ps.mYs.get(0);
		canvas.drawRect(itemW, 0, (itemW * 2) - 1, bottom,
		Math.abs(dx) < mVC.getScaledTouchSlop()
		? mTextBackgroundPaint : mTextLevelPaint);
		canvas.drawText("dX: " + String.format("%.1f", dx), 1 + itemW, base, mTextPaint);
		canvas.drawRect(itemW * 2, 0, (itemW * 3) - 1, bottom,
		Math.abs(dy) < mVC.getScaledTouchSlop()
		? mTextBackgroundPaint : mTextLevelPaint);
		canvas.drawText("dY: " + String.format("%.1f", dy), 1 + itemW * 2, base, mTextPaint);
		}

		canvas.drawRect(itemW * 3, 0, (itemW * 4) - 1, bottom, mTextBackgroundPaint);
		int velocity = ps.mVelocity == null ? 0 : (int) (ps.mVelocity.getXVelocity() * 1000);
		canvas.drawText("Xv: " + velocity, 1 + itemW * 3, base, mTextPaint);

		canvas.drawRect(itemW * 4, 0, (itemW * 5) - 1, bottom, mTextBackgroundPaint);
		velocity = ps.mVelocity == null ? 0 : (int) (ps.mVelocity.getYVelocity() * 1000);
		canvas.drawText("Yv: " + velocity, 1 + itemW * 4, base, mTextPaint);

		canvas.drawRect(itemW * 5, 0, (itemW * 6) - 1, bottom, mTextBackgroundPaint);
		canvas.drawRect(itemW * 5, 0, (itemW * 5) + (ps.mCurPressure * itemW) - 1,
		bottom, mTextLevelPaint);
		canvas.drawText("Prs: " + String.format("%.2f", ps.mCurPressure), 1 + itemW * 5,
		base, mTextPaint);

		canvas.drawRect(itemW * 6, 0, w, bottom, mTextBackgroundPaint);
		canvas.drawRect(itemW * 6, 0, (itemW * 6) + (ps.mCurSize * itemW) - 1,
		bottom, mTextLevelPaint);
		canvas.drawText("Size: " + String.format("%.2f", ps.mCurSize), 1 + itemW * 6,
		base, mTextPaint);
		}

		for (int p=0; p<NP; p++) {
		final PointerState ps = mPointers.get(p);

		if (mCurDown && ps.mCurDown) {
		canvas.drawLine(0, (int)ps.mCurY, getWidth(), (int)ps.mCurY, mTargetPaint);
		canvas.drawLine((int)ps.mCurX, 0, (int)ps.mCurX, getHeight(), mTargetPaint);
		int pressureLevel = (int)(ps.mCurPressure*255);
		mPaint.setARGB(255, pressureLevel, 128, 255-pressureLevel);
		canvas.drawPoint(ps.mCurX, ps.mCurY, mPaint);
		canvas.drawCircle(ps.mCurX, ps.mCurY, ps.mCurWidth, mPaint);
		}
		}

		for (int p=0; p<NP; p++) {
		final PointerState ps = mPointers.get(p);

		final int N = ps.mXs.size();
		float lastX=0, lastY=0;
		boolean haveLast = false;
		boolean drawn = false;
		mPaint.setARGB(255, 128, 255, 255);
		for (int i=0; i<N; i++) {
		float x = ps.mXs.get(i);
		float y = ps.mYs.get(i);
		if (Float.isNaN(x)) {
		haveLast = false;
		continue;
		}
		if (haveLast) {
		canvas.drawLine(lastX, lastY, x, y, mPathPaint);
		canvas.drawPoint(lastX, lastY, mPaint);
		drawn = true;
		}
		lastX = x;
		lastY = y;
		haveLast = true;
		}

		if (drawn) {
		if (ps.mVelocity != null) {
		mPaint.setARGB(255, 255, 64, 128);
		float xVel = ps.mVelocity.getXVelocity() * (1000/60);
		float yVel = ps.mVelocity.getYVelocity() * (1000/60);
		canvas.drawLine(lastX, lastY, lastX+xVel, lastY+yVel, mPaint);
		} else {
		canvas.drawPoint(lastX, lastY, mPaint);
		}
		}
		}
		}
		}

		public void addTouchEvent(MotionEvent event) {
		synchronized (mPointers) {
		int action = event.getAction();

		//Log.i("Pointer", "Motion: action=0x" + Integer.toHexString(action)
		// + " pointers=" + event.getPointerCount());

		int NP = mPointers.size();

		//mRect.set(0, 0, getWidth(), mHeaderBottom+1);
		//invalidate(mRect);
		//if (mCurDown) {
		// mRect.set(mCurX-mCurWidth-3, mCurY-mCurWidth-3,
		// mCurX+mCurWidth+3, mCurY+mCurWidth+3);
		//} else {
		// mRect.setEmpty();
		//}
		if (action == MotionEvent.ACTION_DOWN) {
		for (int p=0; p<NP; p++) {
		final PointerState ps = mPointers.get(p);
		ps.mXs.clear();
		ps.mYs.clear();
		ps.mVelocity = VelocityTracker.obtain();
		ps.mCurDown = false;
		}
		mPointers.get(0).mCurDown = true;
		mMaxNumPointers = 0;
		if (mPrintCoords) {
		Log.i("Pointer", "Pointer 1: DOWN");
		}
		}

		if ((action&MotionEvent.ACTION_MASK) == MotionEvent.ACTION_POINTER_DOWN) {
		final int index = (action&MotionEvent.ACTION_POINTER_INDEX_MASK)
		>> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
		final int id = event.getPointerId(index);
		while (NP <= id) {
		PointerState ps = new PointerState();
		ps.mVelocity = VelocityTracker.obtain();
		mPointers.add(ps);
		NP++;
		}
		final PointerState ps = mPointers.get(id);
		ps.mVelocity = VelocityTracker.obtain();
		ps.mCurDown = true;
		if (mPrintCoords) {
		Log.i("Pointer", "Pointer " + (id+1) + ": DOWN");
		}
		}

		final int NI = event.getPointerCount();

		mCurDown = action != MotionEvent.ACTION_UP
		&& action != MotionEvent.ACTION_CANCEL;
		mCurNumPointers = mCurDown ? NI : 0;
		if (mMaxNumPointers < mCurNumPointers) {
		mMaxNumPointers = mCurNumPointers;
		}

		for (int i=0; i<NI; i++) {
		final int id = event.getPointerId(i);
		final PointerState ps = mPointers.get(id);
		ps.mVelocity.addMovement(event);
		ps.mVelocity.computeCurrentVelocity(1);
		final int N = event.getHistorySize();
		for (int j=0; j<N; j++) {
		if (mPrintCoords) {
		Log.i("Pointer", "Pointer " + (id+1) + ": ("
		+ event.getHistoricalX(i, j)
		+ ", " + event.getHistoricalY(i, j) + ")"
		+ " Prs=" + event.getHistoricalPressure(i, j)
		+ " Size=" + event.getHistoricalSize(i, j));
		}
		ps.mXs.add(event.getHistoricalX(i, j));
		ps.mYs.add(event.getHistoricalY(i, j));
		}
		if (mPrintCoords) {
		Log.i("Pointer", "Pointer " + (id+1) + ": ("
		+ event.getX(i) + ", " + event.getY(i) + ")"
		+ " Prs=" + event.getPressure(i)
		+ " Size=" + event.getSize(i));
		}
		ps.mXs.add(event.getX(i));
		ps.mYs.add(event.getY(i));
		ps.mCurX = (int)event.getX(i);
		ps.mCurY = (int)event.getY(i);
		//Log.i("Pointer", "Pointer #" + p + ": (" + ps.mCurX
		// + "," + ps.mCurY + ")");
		ps.mCurPressure = event.getPressure(i);
		ps.mCurSize = event.getSize(i);
		ps.mCurWidth = (int)(ps.mCurSize*(getWidth()/3));
		}

		if ((action&MotionEvent.ACTION_MASK) == MotionEvent.ACTION_POINTER_UP) {
		final int index = (action&MotionEvent.ACTION_POINTER_INDEX_MASK)
		>> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
		final int id = event.getPointerId(index);
		final PointerState ps = mPointers.get(id);
		ps.mXs.add(Float.NaN);
		ps.mYs.add(Float.NaN);
		ps.mCurDown = false;
		if (mPrintCoords) {
		Log.i("Pointer", "Pointer " + (id+1) + ": UP");
		}
		}

		if (action == MotionEvent.ACTION_UP) {
		for (int i=0; i<NI; i++) {
		final int id = event.getPointerId(i);
		final PointerState ps = mPointers.get(id);
		if (ps.mCurDown) {
		ps.mCurDown = false;
		if (mPrintCoords) {
		Log.i("Pointer", "Pointer " + (id+1) + ": UP");
		}
		}
		}
		}

		//if (mCurDown) {
		// mRect.union(mCurX-mCurWidth-3, mCurY-mCurWidth-3,
		// mCurX+mCurWidth+3, mCurY+mCurWidth+3);
		//}
		//invalidate(mRect);
		postInvalidate();
		}
		}

		@Override
		public boolean onTouchEvent(MotionEvent event) {
		addTouchEvent(event);
		return true;
		}
		}

include/surfaceflinger/ISurfaceFlingerClient.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -61,6 +61,7 @@ public:

		virtual sp<ISurface> createSurface( surface_data_t* data,
		int pid,
		const String8& name,
		DisplayID display,
		uint32_t w,
		uint32_t h,

include/surfaceflinger/SurfaceComposerClient.h

+11 −0

Original line number	Diff line number	Diff line
		@@ -65,6 +65,7 @@ public:
		//! Create a surface
		sp<SurfaceControl> createSurface(
		int pid, // pid of the process the surface is for
		const String8& name,// name of the surface
		DisplayID display, // Display to create this surface on
		uint32_t w, // width in pixel
		uint32_t h, // height in pixel
		@@ -72,6 +73,16 @@ public:
		uint32_t flags = 0 // usage flags
		);

		sp<SurfaceControl> createSurface(
		int pid, // pid of the process the surface is for
		DisplayID display, // Display to create this surface on
		uint32_t w, // width in pixel
		uint32_t h, // height in pixel
		PixelFormat format, // pixel-format desired
		uint32_t flags = 0 // usage flags
		);


		// ------------------------------------------------------------------------
		// Composer parameters
		// All composer parameters must be changed within a transaction

include/utils/ResourceTypes.h

+7 −6

Original line number	Diff line number	Diff line
		@@ -944,8 +944,9 @@ struct ResTable_config
		enum {
		// uiMode bits for the mode type.
		MASK_UI_MODE_TYPE = 0x0f,
		UI_MODE_TYPE_NORMAL = 0x00,
		UI_MODE_TYPE_CAR = 0x01,
		UI_MODE_TYPE_ANY = 0x00,
		UI_MODE_TYPE_NORMAL = 0x01,
		UI_MODE_TYPE_CAR = 0x02,

		// uiMode bits for the night switch.
		MASK_UI_MODE_NIGHT = 0x30,
		@@ -1086,7 +1087,7 @@ struct ResTable_config
		}
		}

		if (screenConfig \|\| o.screenConfig) {
		if (screenLayout \|\| o.screenLayout) {
		if (((screenLayout^o.screenLayout) & MASK_SCREENSIZE) != 0) {
		if (!(screenLayout & MASK_SCREENSIZE)) return false;
		if (!(o.screenLayout & MASK_SCREENSIZE)) return true;
		@@ -1102,7 +1103,7 @@ struct ResTable_config
		if (!o.orientation) return true;
		}

		if (screenConfig \|\| o.screenConfig) {
		if (uiMode \|\| o.uiMode) {
		if (((uiMode^o.uiMode) & MASK_UI_MODE_TYPE) != 0) {
		if (!(uiMode & MASK_UI_MODE_TYPE)) return false;
		if (!(o.uiMode & MASK_UI_MODE_TYPE)) return true;
		@@ -1203,7 +1204,7 @@ struct ResTable_config
		}
		}

		if (screenConfig \|\| o.screenConfig) {
		if (screenLayout \|\| o.screenLayout) {
		if (((screenLayout^o.screenLayout) & MASK_SCREENSIZE) != 0
		&& (requested->screenLayout & MASK_SCREENSIZE)) {
		return (screenLayout & MASK_SCREENSIZE);
		@@ -1218,7 +1219,7 @@ struct ResTable_config
		return (orientation);
		}

		if (screenConfig \|\| o.screenConfig) {
		if (uiMode \|\| o.uiMode) {
		if (((uiMode^o.uiMode) & MASK_UI_MODE_TYPE) != 0
		&& (requested->uiMode & MASK_UI_MODE_TYPE)) {
		return (uiMode & MASK_UI_MODE_TYPE);