Bubbling up some of these great new colors. (28f8033d) · Commits · e / os / android_frameworks_base

core/java/com/android/internal/app/PlatLogoActivity.java

+229 −247

Original line number	Original line	Diff line number	Diff line
	@@ -16,9 +16,9 @@

	package com.android.internal.app;		package com.android.internal.app;

			import static android.graphics.PixelFormat.TRANSLUCENT;

	import android.animation.ObjectAnimator;		import android.animation.ObjectAnimator;
	import android.annotation.NonNull;
	import android.annotation.Nullable;
	import android.app.ActionBar;		import android.app.ActionBar;
	import android.app.Activity;		import android.app.Activity;
	import android.content.ActivityNotFoundException;		import android.content.ActivityNotFoundException;
	@@ -26,22 +26,21 @@ import android.content.ContentResolver;
	import android.content.Context;		import android.content.Context;
	import android.content.Intent;		import android.content.Intent;
	import android.graphics.Canvas;		import android.graphics.Canvas;
	import android.graphics.Color;
	import android.graphics.ColorFilter;		import android.graphics.ColorFilter;
	import android.graphics.LinearGradient;
	import android.graphics.Paint;		import android.graphics.Paint;
	import android.graphics.PixelFormat;
	import android.graphics.Rect;		import android.graphics.Rect;
	import android.graphics.Shader;
	import android.graphics.drawable.Drawable;		import android.graphics.drawable.Drawable;
	import android.os.Bundle;		import android.os.Bundle;
	import android.provider.Settings;		import android.provider.Settings;
	import android.util.AttributeSet;		import android.util.DisplayMetrics;
	import android.util.Log;		import android.util.Log;
			import android.view.Gravity;
	import android.view.HapticFeedbackConstants;		import android.view.HapticFeedbackConstants;
	import android.view.MotionEvent;		import android.view.MotionEvent;
	import android.view.View;		import android.view.View;
	import android.view.animation.PathInterpolator;		import android.view.animation.DecelerateInterpolator;
			import android.view.animation.OvershootInterpolator;
			import android.widget.AnalogClock;
	import android.widget.FrameLayout;		import android.widget.FrameLayout;
	import android.widget.ImageView;		import android.widget.ImageView;

	@@ -49,17 +48,22 @@ import com.android.internal.R;

	import org.json.JSONObject;		import org.json.JSONObject;

			import java.time.Clock;
			import java.time.Instant;
			import java.time.ZoneId;
			import java.time.ZonedDateTime;

	/**		/**
	* @hide		* @hide
	*/		*/
	public class PlatLogoActivity extends Activity {		public class PlatLogoActivity extends Activity {
	private static final boolean WRITE_SETTINGS = true;		private static final String TAG = "PlatLogoActivity";

	private static final String R_EGG_UNLOCK_SETTING = "egg_mode_r";

	private static final int UNLOCK_TRIES = 3;		private static final String S_EGG_UNLOCK_SETTING = "egg_mode_s";

	BigDialView mDialView;		private SettableAnalogClock mClock;
			private ImageView mLogo;
			private BubblesDrawable mBg;

	@Override		@Override
	protected void onPause() {		protected void onPause() {
	@@ -69,42 +73,81 @@ public class PlatLogoActivity extends Activity {
	@Override		@Override
	protected void onCreate(Bundle savedInstanceState) {		protected void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);		super.onCreate(savedInstanceState);
	final float dp = getResources().getDisplayMetrics().density;

	getWindow().getDecorView().setSystemUiVisibility(
	View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION \| View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
	getWindow().setNavigationBarColor(0);		getWindow().setNavigationBarColor(0);
	getWindow().setStatusBarColor(0);		getWindow().setStatusBarColor(0);

	final ActionBar ab = getActionBar();		final ActionBar ab = getActionBar();
	if (ab != null) ab.hide();		if (ab != null) ab.hide();

	mDialView = new BigDialView(this, null);
	if (Settings.System.getLong(getContentResolver(),
	R_EGG_UNLOCK_SETTING, 0) == 0) {
	mDialView.setUnlockTries(UNLOCK_TRIES);
	} else {
	mDialView.setUnlockTries(0);
	}

	final FrameLayout layout = new FrameLayout(this);		final FrameLayout layout = new FrameLayout(this);
	layout.setBackgroundColor(0xFFFF0000);
	layout.addView(mDialView, FrameLayout.LayoutParams.MATCH_PARENT,		mClock = new SettableAnalogClock(this);
	FrameLayout.LayoutParams.MATCH_PARENT);
			final DisplayMetrics dm = getResources().getDisplayMetrics();
			final float dp = dm.density;
			final int minSide = Math.min(dm.widthPixels, dm.heightPixels);
			final int widgetSize = (int) (minSide * 0.75);
			final FrameLayout.LayoutParams lp = new FrameLayout.LayoutParams(widgetSize, widgetSize);
			lp.gravity = Gravity.CENTER;
			layout.addView(mClock, lp);

			mLogo = new ImageView(this);
			mLogo.setVisibility(View.GONE);
			mLogo.setImageResource(R.drawable.platlogo);
			layout.addView(mLogo, lp);

			mBg = new BubblesDrawable();
			mBg.setLevel(0);
			mBg.avoid = widgetSize / 2;
			mBg.padding = 0.5f * dp;
			mBg.minR = 1 * dp;
			layout.setBackground(mBg);

	setContentView(layout);		setContentView(layout);
	}		}

			private boolean shouldWriteSettings() {
			return getPackageName().equals("android");
			}

	private void launchNextStage(boolean locked) {		private void launchNextStage(boolean locked) {
			mClock.animate()
			.alpha(0f).scaleX(0.5f).scaleY(0.5f)
			.withEndAction(() -> mClock.setVisibility(View.GONE))
			.start();

			mLogo.setAlpha(0f);
			mLogo.setScaleX(0.5f);
			mLogo.setScaleY(0.5f);
			mLogo.setVisibility(View.VISIBLE);
			mLogo.animate()
			.alpha(1f)
			.scaleX(1f)
			.scaleY(1f)
			.setInterpolator(new OvershootInterpolator())
			.start();

			mLogo.postDelayed(() -> {
			final ObjectAnimator anim = ObjectAnimator.ofInt(mBg, "level", 0, 10000);
			anim.setInterpolator(new DecelerateInterpolator(1f));
			anim.start();
			},
			500
			);

	final ContentResolver cr = getContentResolver();		final ContentResolver cr = getContentResolver();

	try {		try {
	if (WRITE_SETTINGS) {		if (shouldWriteSettings()) {
			Log.v(TAG, "Saving egg unlock=" + locked);
			syncTouchPressure();
	Settings.System.putLong(cr,		Settings.System.putLong(cr,
	R_EGG_UNLOCK_SETTING,		S_EGG_UNLOCK_SETTING,
	locked ? 0 : System.currentTimeMillis());		locked ? 0 : System.currentTimeMillis());
	}		}
	} catch (RuntimeException e) {		} catch (RuntimeException e) {
	Log.e("com.android.internal.app.PlatLogoActivity", "Can't write settings", e);		Log.e(TAG, "Can't write settings", e);
	}		}

	try {		try {
	@@ -151,7 +194,7 @@ public class PlatLogoActivity extends Activity {
	if (mPressureMax >= 0) {		if (mPressureMax >= 0) {
	touchData.put("min", mPressureMin);		touchData.put("min", mPressureMin);
	touchData.put("max", mPressureMax);		touchData.put("max", mPressureMax);
	if (WRITE_SETTINGS) {		if (shouldWriteSettings()) {
	Settings.System.putString(getContentResolver(), TOUCH_STATS,		Settings.System.putString(getContentResolver(), TOUCH_STATS,
	touchData.toString());		touchData.toString());
	}		}
	@@ -173,44 +216,35 @@ public class PlatLogoActivity extends Activity {
	super.onStop();		super.onStop();
	}		}

	class BigDialView extends ImageView {		/**
	private static final int COLOR_GREEN = 0xff3ddc84;		* Subclass of AnalogClock that allows the user to flip up the glass and adjust the hands.
	private static final int COLOR_BLUE = 0xff4285f4;		*/
	private static final int COLOR_NAVY = 0xff073042;		public class SettableAnalogClock extends AnalogClock {
	private static final int COLOR_ORANGE = 0xfff86734;		private int mOverrideHour = -1;
	private static final int COLOR_CHARTREUSE = 0xffeff7cf;		private int mOverrideMinute = -1;
	private static final int COLOR_LIGHTBLUE = 0xffd7effe;		private boolean mOverride = false;

	private static final int STEPS = 11;
	private static final float VALUE_CHANGE_MAX = 1f / STEPS;

	private BigDialDrawable mDialDrawable;
	private boolean mWasLocked;

	BigDialView(Context context, @Nullable AttributeSet attrs) {
	super(context, attrs);
	init();
	}

	BigDialView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
	super(context, attrs, defStyleAttr);
	init();
	}

	BigDialView(Context context, @Nullable AttributeSet attrs, int defStyleAttr,
	int defStyleRes) {
	super(context, attrs, defStyleAttr, defStyleRes);
	init();
	}

	private void init() {		public SettableAnalogClock(Context context) {
	mDialDrawable = new BigDialDrawable();		super(context);
	setImageDrawable(mDialDrawable);
	}		}

	@Override		@Override
	public void onDraw(Canvas c) {		protected Instant now() {
	super.onDraw(c);		final Instant realNow = super.now();
			final ZoneId tz = Clock.systemDefaultZone().getZone();
			final ZonedDateTime zdTime = realNow.atZone(tz);
			if (mOverride) {
			if (mOverrideHour < 0) {
			mOverrideHour = zdTime.getHour();
			}
			return Clock.fixed(zdTime
			.withHour(mOverrideHour)
			.withMinute(mOverrideMinute)
			.withSecond(0)
			.toInstant(), tz).instant();
			} else {
			return realNow;
			}
	}		}

	double toPositiveDegrees(double rad) {		double toPositiveDegrees(double rad) {
	@@ -221,226 +255,174 @@ public class PlatLogoActivity extends Activity {
	public boolean onTouchEvent(MotionEvent ev) {		public boolean onTouchEvent(MotionEvent ev) {
	switch (ev.getActionMasked()) {		switch (ev.getActionMasked()) {
	case MotionEvent.ACTION_DOWN:		case MotionEvent.ACTION_DOWN:
	mWasLocked = mDialDrawable.isLocked();		mOverride = true;
	// pass through		// pass through
	case MotionEvent.ACTION_MOVE:		case MotionEvent.ACTION_MOVE:
			measureTouchPressure(ev);

	float x = ev.getX();		float x = ev.getX();
	float y = ev.getY();		float y = ev.getY();
	float cx = (getLeft() + getRight()) / 2f;		float cx = getWidth() / 2f;
	float cy = (getTop() + getBottom()) / 2f;		float cy = getHeight() / 2f;
	float angle = (float) toPositiveDegrees(Math.atan2(x - cx, y - cy));		float angle = (float) toPositiveDegrees(Math.atan2(x - cx, y - cy));
	final int oldLevel = mDialDrawable.getUserLevel();
	mDialDrawable.touchAngle(angle);		int minutes = (75 - (int) (angle / 6)) % 60;
	final int newLevel = mDialDrawable.getUserLevel();		int minuteDelta = minutes - mOverrideMinute;
	if (oldLevel != newLevel) {		if (minuteDelta != 0) {
	performHapticFeedback(newLevel == STEPS		if (Math.abs(minuteDelta) > 45 && mOverrideHour >= 0) {
	? HapticFeedbackConstants.CONFIRM		int hourDelta = (minuteDelta < 0) ? 1 : -1;
	: HapticFeedbackConstants.CLOCK_TICK);		mOverrideHour = (mOverrideHour + 24 + hourDelta) % 24;
			}
			mOverrideMinute = minutes;
			if (mOverrideMinute == 0) {
			performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
			if (getScaleX() == 1f) {
			setScaleX(1.05f);
			setScaleY(1.05f);
			animate().scaleX(1f).scaleY(1f).setDuration(150).start();
			}
			} else {
			performHapticFeedback(HapticFeedbackConstants.CLOCK_TICK);
	}		}

			onTimeChanged();
			postInvalidate();
			}

	return true;		return true;
	case MotionEvent.ACTION_UP:		case MotionEvent.ACTION_UP:
	if (mWasLocked != mDialDrawable.isLocked()) {		if (mOverrideMinute == 0 && (mOverrideHour % 12) == 0) {
	launchNextStage(mDialDrawable.isLocked());		Log.v(TAG, "12:00 let's gooooo");
			performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
			launchNextStage(false);
	}		}
	return true;		return true;
	}		}
	return false;		return false;
	}		}

	@Override
	public boolean performClick() {
	if (mDialDrawable.getUserLevel() < STEPS - 1) {
	mDialDrawable.setUserLevel(mDialDrawable.getUserLevel() + 1);
	performHapticFeedback(HapticFeedbackConstants.CLOCK_TICK);
	}
	return true;
	}		}

	void setUnlockTries(int tries) {		static class Bubble {
	mDialDrawable.setUnlockTries(tries);		public float x, y, r;
			public int color;
	}		}

	private class BigDialDrawable extends Drawable {		class BubblesDrawable extends Drawable {
	public final int STEPS = 10;		private static final int MAX_BUBBS = 2000;
	private int mUnlockTries = 0;
	final Paint mPaint = new Paint();
	final Drawable mEleven;
	private boolean mNightMode;
	private float mValue = 0f;
	float mElevenAnim = 0f;
	ObjectAnimator mElevenShowAnimator = ObjectAnimator.ofFloat(this, "elevenAnim", 0f,
	1f).setDuration(300);
	ObjectAnimator mElevenHideAnimator = ObjectAnimator.ofFloat(this, "elevenAnim", 1f,
	0f).setDuration(500);

	BigDialDrawable() {		private final int[] mColorIds = {
	mNightMode = getContext().getResources().getConfiguration().isNightModeActive();		android.R.color.system_accent1_400,
	mEleven = getContext().getDrawable(R.drawable.ic_number11);		android.R.color.system_accent1_500,
	mElevenShowAnimator.setInterpolator(new PathInterpolator(0.4f, 0f, 0.2f, 1f));		android.R.color.system_accent1_600,
	mElevenHideAnimator.setInterpolator(new PathInterpolator(0.8f, 0.2f, 0.6f, 1f));
	}

	public void setUnlockTries(int count) {
	if (mUnlockTries != count) {
	mUnlockTries = count;
	setValue(getValue());
	invalidateSelf();
	}
	}

	boolean isLocked() {		android.R.color.system_accent2_400,
	return mUnlockTries > 0;		android.R.color.system_accent2_500,
	}		android.R.color.system_accent2_600,
			};

	public void setValue(float v) {		private int[] mColors = new int[mColorIds.length];
	// until the dial is "unlocked", you can't turn it all the way to 11
	final float max = isLocked() ? 1f - 1f / STEPS : 1f;
	mValue = v < 0f ? 0f : v > max ? max : v;
	invalidateSelf();
	}

	public float getValue() {		private final Bubble[] mBubbs = new Bubble[MAX_BUBBS];
	return mValue;		private int mNumBubbs;
	}

	public int getUserLevel() {		private final Paint mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
	return Math.round(getValue() * STEPS - 0.25f);
	}

	public void setUserLevel(int i) {		public float avoid = 0f;
	setValue(getValue() + ((float) i) / STEPS);		public float padding = 0f;
	}		public float minR = 0f;

	public float getElevenAnim() {		BubblesDrawable() {
	return mElevenAnim;		for (int i = 0; i < mColorIds.length; i++) {
			mColors[i] = getColor(mColorIds[i]);
	}		}
			for (int j = 0; j < mBubbs.length; j++) {
	public void setElevenAnim(float f) {		mBubbs[j] = new Bubble();
	if (mElevenAnim != f) {
	mElevenAnim = f;
	invalidateSelf();
	}		}
	}		}

	@Override		@Override
	public void draw(@NonNull Canvas canvas) {		public void draw(Canvas canvas) {
	final Rect bounds = getBounds();		final float f = getLevel() / 10000f;
	final int w = bounds.width();
	final int h = bounds.height();
	final float w2 = w / 2f;
	final float h2 = h / 2f;
	final float radius = w / 4f;

	canvas.drawColor(mNightMode ? COLOR_NAVY : COLOR_LIGHTBLUE);

	canvas.save();
	canvas.rotate(45, w2, h2);
	canvas.clipRect(w2, h2 - radius, Math.min(w, h), h2 + radius);
	final int gradientColor = mNightMode ? 0x60000020 : (0x10FFFFFF & COLOR_NAVY);
	mPaint.setShader(
	new LinearGradient(w2, h2, Math.min(w, h), h2, gradientColor,
	0x00FFFFFF & gradientColor, Shader.TileMode.CLAMP));
	mPaint.setColor(Color.BLACK);
	canvas.drawPaint(mPaint);
	mPaint.setShader(null);
	canvas.restore();

	mPaint.setStyle(Paint.Style.FILL);		mPaint.setStyle(Paint.Style.FILL);
	mPaint.setColor(COLOR_GREEN);		int drawn = 0;
			for (int j = 0; j < mNumBubbs; j++) {
	canvas.drawCircle(w2, h2, radius, mPaint);		if (mBubbs[j].color == 0 \|\| mBubbs[j].r == 0) continue;
			mPaint.setColor(mBubbs[j].color);
	mPaint.setColor(mNightMode ? COLOR_LIGHTBLUE : COLOR_NAVY);		canvas.drawCircle(mBubbs[j].x, mBubbs[j].y, mBubbs[j].r * f, mPaint);
	final float cx = w * 0.85f;		drawn++;
	for (int i = 0; i < STEPS; i++) {
	final float f = (float) i / STEPS;
	canvas.save();
	final float angle = valueToAngle(f);
	canvas.rotate(-angle, w2, h2);
	canvas.drawCircle(cx, h2, (i <= getUserLevel()) ? 20 : 5, mPaint);
	canvas.restore();
	}

	if (mElevenAnim > 0f) {
	final int color = COLOR_ORANGE;
	final int size2 = (int) ((0.5 + 0.5f * mElevenAnim) * w / 14);
	final float cx11 = cx + size2 / 4f;
	mEleven.setBounds((int) cx11 - size2, (int) h2 - size2,
	(int) cx11 + size2, (int) h2 + size2);
	final int alpha = 0xFFFFFF \| ((int) clamp(0xFF * 2 * mElevenAnim, 0, 0xFF)
	<< 24);
	mEleven.setTint(alpha & color);
	mEleven.draw(canvas);
	}		}

	// don't want to use the rounded value here since the quantization will be visible
	final float angle = valueToAngle(mValue);

	// it's easier to draw at far-right and rotate backwards
	canvas.rotate(-angle, w2, h2);
	mPaint.setColor(Color.WHITE);
	final float dimple = w2 / 12f;
	canvas.drawCircle(w - radius - dimple * 2, h2, dimple, mPaint);
	}		}

	float clamp(float x, float a, float b) {		@Override
	return x < a ? a : x > b ? b : x;		protected boolean onLevelChange(int level) {
	}		invalidateSelf();
			return true;
	float angleToValue(float a) {
	return 1f - clamp(a / (360 - 45), 0f, 1f);
	}

	// rotation: min is at 4:30, max is at 3:00
	float valueToAngle(float v) {
	return (1f - v) * (360 - 45);
	}

	public void touchAngle(float a) {
	final int oldUserLevel = getUserLevel();
	final float newValue = angleToValue(a);
	// this is how we prevent the knob from snapping from max back to min, or from
	// jumping around wherever the user presses. The new value must be pretty close
	// to the
	// previous one.
	if (Math.abs(newValue - getValue()) < VALUE_CHANGE_MAX) {
	setValue(newValue);

	if (isLocked() && oldUserLevel != STEPS - 1 && getUserLevel() == STEPS - 1) {
	mUnlockTries--;
	} else if (!isLocked() && getUserLevel() == 0) {
	mUnlockTries = UNLOCK_TRIES;
	}		}

	if (!isLocked()) {		@Override
	if (getUserLevel() == STEPS && mElevenAnim != 1f		protected void onBoundsChange(Rect bounds) {
	&& !mElevenShowAnimator.isRunning()) {		super.onBoundsChange(bounds);
	mElevenHideAnimator.cancel();		randomize();
	mElevenShowAnimator.start();		}
	} else if (getUserLevel() != STEPS && mElevenAnim == 1f
	&& !mElevenHideAnimator.isRunning()) {		private void randomize() {
	mElevenShowAnimator.cancel();		final float w = getBounds().width();
	mElevenHideAnimator.start();		final float h = getBounds().height();
			final float maxR = Math.min(w, h) / 3f;
			mNumBubbs = 0;
			if (avoid > 0f) {
			mBubbs[mNumBubbs].x = w / 2f;
			mBubbs[mNumBubbs].y = h / 2f;
			mBubbs[mNumBubbs].r = avoid;
			mBubbs[mNumBubbs].color = 0;
			mNumBubbs++;
			}
			for (int j = 0; j < MAX_BUBBS; j++) {
			// a simple but time-tested bubble-packing algorithm:
			// 1. pick a spot
			// 2. shrink the bubble until it is no longer overlapping any other bubble
			// 3. if the bubble hasn't popped, keep it
			int tries = 5;
			while (tries-- > 0) {
			float x = (float) Math.random() * w;
			float y = (float) Math.random() * h;
			float r = Math.min(Math.min(x, w - x), Math.min(y, h - y));

			// shrink radius to fit other bubbs
			for (int i = 0; i < mNumBubbs; i++) {
			r = (float) Math.min(r,
			Math.hypot(x - mBubbs[i].x, y - mBubbs[i].y) - mBubbs[i].r
			- padding);
			if (r < minR) break;
			}

			if (r >= minR) {
			// we have found a spot for this bubble to live, let's save it and move on
			r = Math.min(maxR, r);

			mBubbs[mNumBubbs].x = x;
			mBubbs[mNumBubbs].y = y;
			mBubbs[mNumBubbs].r = r;
			mBubbs[mNumBubbs].color = mColors[(int) (Math.random() * mColors.length)];
			mNumBubbs++;
			break;
	}		}
	}		}
	}		}
			Log.v(TAG, String.format("successfully placed %d bubbles (%d%%)",
			mNumBubbs, (int) (100f * mNumBubbs / MAX_BUBBS)));
	}		}

	@Override		@Override
	public void setAlpha(int i) {		public void setAlpha(int alpha) { }
	}

	@Override		@Override
	public void setColorFilter(@Nullable ColorFilter colorFilter) {		public void setColorFilter(ColorFilter colorFilter) { }
	}

	@Override		@Override
	public int getOpacity() {		public int getOpacity() {
	return PixelFormat.TRANSLUCENT;		return TRANSLUCENT;
	}
	}		}
	}		}
	}



			}

core/res/AndroidManifest.xml

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -5902,8 +5902,8 @@
	android:process=":ui">		android:process=":ui">
	</activity>		</activity>
	<activity android:name="com.android.internal.app.PlatLogoActivity"		<activity android:name="com.android.internal.app.PlatLogoActivity"
	android:theme="@style/Theme.DeviceDefault.DayNight"		android:theme="@style/Theme.DeviceDefault.Wallpaper.NoTitleBar"
	android:configChanges="orientation\|keyboardHidden"		android:configChanges="orientation\|screenSize\|screenLayout\|keyboardHidden"
	android:icon="@drawable/platlogo"		android:icon="@drawable/platlogo"
	android:process=":ui">		android:process=":ui">
	</activity>		</activity>

core/res/res/drawable-nodpi/platlogo.xml

+34 −48

File changed.

Preview size limit exceeded, changes collapsed.