Merge "🐙" into oc-dev
diff --git a/packages/EasterEgg/Android.mk b/packages/EasterEgg/Android.mk
index df081f4..d4c1e70 100644
--- a/packages/EasterEgg/Android.mk
+++ b/packages/EasterEgg/Android.mk
@@ -5,6 +5,7 @@
LOCAL_STATIC_JAVA_LIBRARIES := \
android-support-v4 \
android-support-v13 \
+ android-support-dynamic-animation \
android-support-v7-recyclerview \
android-support-v7-preference \
android-support-v7-appcompat \
diff --git a/packages/EasterEgg/AndroidManifest.xml b/packages/EasterEgg/AndroidManifest.xml
index fbc2386..14861c26 100644
--- a/packages/EasterEgg/AndroidManifest.xml
+++ b/packages/EasterEgg/AndroidManifest.xml
@@ -19,12 +19,25 @@
android:versionCode="1"
android:versionName="1.0">
- <uses-sdk android:minSdkVersion="24" />
+ <uses-sdk android:minSdkVersion="26" />
<uses-permission android:name="android.permission.SUBSTITUTE_NOTIFICATION_APP_NAME" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<application android:label="@string/app_name" android:icon="@drawable/icon">
+
+ <activity android:name=".octo.Ocquarium"
+ android:theme="@android:style/Theme.DeviceDefault.NoActionBar.Fullscreen"
+ android:label="@string/app_name">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN"/>
+ <category android:name="android.intent.category.DEFAULT" />
+ <category android:name="com.android.internal.category.PLATLOGO" />
+ </intent-filter>
+ </activity>
+
+ <!-- Android N lives on inside Android O... -->
+
<!-- Long press the QS tile to get here -->
<activity android:name=".neko.NekoLand"
android:theme="@android:style/Theme.Material.NoActionBar"
@@ -57,7 +70,6 @@
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
<category android:name="android.intent.category.DEFAULT" />
- <category android:name="com.android.internal.category.PLATLOGO" />
</intent-filter>
</activity>
diff --git a/packages/EasterEgg/res/drawable/icon.xml b/packages/EasterEgg/res/drawable/icon.xml
index defa83a..5ce9e51 100644
--- a/packages/EasterEgg/res/drawable/icon.xml
+++ b/packages/EasterEgg/res/drawable/icon.xml
@@ -1,5 +1,5 @@
<!--
-Copyright (C) 2016 The Android Open Source Project
+Copyright (C) 2017 The Android Open Source Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -14,24 +14,27 @@
limitations under the License.
-->
<vector xmlns:android="http://schemas.android.com/apk/res/android"
- android:width="512dp"
- android:height="512dp"
+ android:width="48dp"
+ android:height="48dp"
android:viewportWidth="48.0"
android:viewportHeight="48.0">
<path
- android:fillColor="#FF7E5BBF"
- android:pathData="M32.0,12.5l0.0,28.0l12.0,-5.0l0.0,-28.0z"/>
+ android:pathData="M25.0,25.0m-20.5,0.0a20.5,20.5,0,1,1,41.0,0.0a20.5,20.5,0,1,1,-41.0,0.0"
+ android:fillAlpha="0.066"
+ android:fillColor="#000000"/>
<path
- android:fillColor="#FF7E5BBF"
- android:pathData="M4.0,40.5l12.0,-5.0l0.0,-11.0l-12.0,-12.0z"/>
+ android:pathData="M24.0,24.0m-20.0,0.0a20.0,20.0,0,1,1,40.0,0.0a20.0,20.0,0,1,1,-40.0,0.0"
+ android:fillColor="#283593"/>
<path
- android:fillColor="#40000000"
- android:pathData="M44.0,35.5l-12.0,-12.0l0.0,-4.0z"/>
+ android:pathData="M44,24.2010101 L33.9004889,14.101499 L14.101499,33.9004889 L24.2010101,44 C29.2525804,43.9497929 34.2887564,41.9975027 38.1431296,38.1431296 C41.9975027,34.2887564 43.9497929,29.2525804 44,24.2010101 Z"
+ android:fillColor="#1a237e"/>
<path
- android:fillColor="#40000000"
- android:pathData="M4.0,12.5l12.0,12.0l0.0,4.0z"/>
+ android:pathData="M24.0,24.0m-14.0,0.0a14.0,14.0,0,1,1,28.0,0.0a14.0,14.0,0,1,1,-28.0,0.0"
+ android:fillColor="#5c6bc0"/>
<path
- android:fillColor="#FF55C4F5"
- android:pathData="M32.0,23.5l-16.0,-16.0l-12.0,5.0l0.0,0.0l12.0,12.0l16.0,16.0l12.0,-5.0l0.0,0.0z"/>
+ android:pathData="M37.7829445,26.469236 L29.6578482,18.3441397 L18.3441397,29.6578482 L26.469236,37.7829445 C29.1911841,37.2979273 31.7972024,36.0037754 33.9004889,33.9004889 C36.0037754,31.7972024 37.2979273,29.1911841 37.7829445,26.469236 Z"
+ android:fillColor="#3f51b5"/>
+ <path
+ android:pathData="M24.0,24.0m-8.0,0.0a8.0,8.0,0,1,1,16.0,0.0a8.0,8.0,0,1,1,-16.0,0.0"
+ android:fillColor="#FFFFFF"/>
</vector>
-
diff --git a/packages/EasterEgg/res/drawable/octo_bg.xml b/packages/EasterEgg/res/drawable/octo_bg.xml
new file mode 100644
index 0000000..1e46cf4
--- /dev/null
+++ b/packages/EasterEgg/res/drawable/octo_bg.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+ <gradient android:angle="-90"
+ android:startColor="#FF205090"
+ android:endColor="#FF001040"
+ android:type="linear"
+ />
+</shape>
\ No newline at end of file
diff --git a/packages/EasterEgg/src/com/android/egg/octo/Ocquarium.java b/packages/EasterEgg/src/com/android/egg/octo/Ocquarium.java
new file mode 100644
index 0000000..bbbdf80
--- /dev/null
+++ b/packages/EasterEgg/src/com/android/egg/octo/Ocquarium.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package com.android.egg.octo;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+
+import com.android.egg.R;
+
+public class Ocquarium extends Activity {
+ ImageView mImageView;
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ final float dp = getResources().getDisplayMetrics().density;
+
+ getWindow().setBackgroundDrawableResource(R.drawable.octo_bg);
+
+ FrameLayout bg = new FrameLayout(this);
+ setContentView(bg);
+ bg.setAlpha(0f);
+ bg.animate().setStartDelay(500).setDuration(5000).alpha(1f).start();
+
+ mImageView = new ImageView(this);
+ bg.addView(mImageView, new FrameLayout.LayoutParams(
+ ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
+
+ final OctopusDrawable octo = new OctopusDrawable(getApplicationContext());
+ octo.setSizePx((int) (OctopusDrawable.randfrange(40f,180f) * dp));
+ mImageView.setImageDrawable(octo);
+ octo.startDrift();
+
+ mImageView.setOnTouchListener(new View.OnTouchListener() {
+ boolean touching;
+ @Override
+ public boolean onTouch(View view, MotionEvent motionEvent) {
+ switch (motionEvent.getActionMasked()) {
+ case MotionEvent.ACTION_DOWN:
+ if (octo.hitTest(motionEvent.getX(), motionEvent.getY())) {
+ touching = true;
+ octo.stopDrift();
+ }
+ break;
+ case MotionEvent.ACTION_MOVE:
+ if (touching) {
+ octo.moveTo(motionEvent.getX(), motionEvent.getY());
+ }
+ break;
+ case MotionEvent.ACTION_UP:
+ case MotionEvent.ACTION_CANCEL:
+ touching = false;
+ octo.startDrift();
+ break;
+ }
+ return true;
+ }
+ });
+ }
+}
diff --git a/packages/EasterEgg/src/com/android/egg/octo/OctopusDrawable.java b/packages/EasterEgg/src/com/android/egg/octo/OctopusDrawable.java
new file mode 100644
index 0000000..5dde6e1
--- /dev/null
+++ b/packages/EasterEgg/src/com/android/egg/octo/OctopusDrawable.java
@@ -0,0 +1,436 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package com.android.egg.octo;
+
+import android.animation.TimeAnimator;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.DashPathEffect;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.PixelFormat;
+import android.graphics.PointF;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.support.animation.DynamicAnimation;
+import android.support.animation.SpringForce;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.animation.SpringAnimation;
+import android.support.animation.FloatValueHolder;
+
+public class OctopusDrawable extends Drawable {
+ private static float BASE_SCALE = 100f;
+ public static boolean PATH_DEBUG = false;
+
+ private static int BODY_COLOR = 0xFF101010;
+ private static int ARM_COLOR = 0xFF101010;
+ private static int ARM_COLOR_BACK = 0xFF000000;
+ private static int EYE_COLOR = 0xFF808080;
+
+ private static int[] BACK_ARMS = {1, 3, 4, 6};
+ private static int[] FRONT_ARMS = {0, 2, 5, 7};
+
+ private Paint mPaint = new Paint();
+ private Arm[] mArms = new Arm[8];
+ final PointF point = new PointF();
+ private int mSizePx = 100;
+ final Matrix M = new Matrix();
+ final Matrix M_inv = new Matrix();
+ private TimeAnimator mDriftAnimation;
+ private boolean mBlinking;
+ private float[] ptmp = new float[2];
+ private float[] scaledBounds = new float[2];
+
+ public static float randfrange(float a, float b) {
+ return (float) (Math.random()*(b-a) + a);
+ }
+ public static float clamp(float v, float a, float b) {
+ return v<a?a:v>b?b:v;
+ }
+
+ public OctopusDrawable(Context context) {
+ float dp = context.getResources().getDisplayMetrics().density;
+ setSizePx((int) (100*dp));
+ mPaint.setAntiAlias(true);
+ for (int i=0; i<mArms.length; i++) {
+ final float bias = (float)i/(mArms.length-1) - 0.5f;
+ mArms[i] = new Arm(
+ 0,0, // arm will be repositioned on moveTo
+ 10f*bias + randfrange(0,20f), randfrange(20f,50f),
+ 40f*bias+randfrange(-60f,60f), randfrange(30f, 80f),
+ randfrange(-40f,40f), randfrange(-80f,40f),
+ 14f, 2f);
+ }
+ }
+
+ public void setSizePx(int size) {
+ mSizePx = size;
+ M.setScale(mSizePx/BASE_SCALE, mSizePx/BASE_SCALE);
+ // TaperedPathStroke.setMinStep(20f*BASE_SCALE/mSizePx); // nice little floaty circles
+ TaperedPathStroke.setMinStep(8f*BASE_SCALE/mSizePx); // classic tentacles
+ M.invert(M_inv);
+ }
+
+ public void startDrift() {
+ if (mDriftAnimation == null) {
+ mDriftAnimation = new TimeAnimator();
+ mDriftAnimation.setTimeListener(new TimeAnimator.TimeListener() {
+ float MAX_VY = 35f;
+ float JUMP_VY = -100f;
+ float MAX_VX = 15f;
+ private float ax = 0f, ay = 30f;
+ private float vx, vy;
+ long nextjump = 0;
+ long unblink = 0;
+ @Override
+ public void onTimeUpdate(TimeAnimator timeAnimator, long t, long dt) {
+ float t_sec = 0.001f * t;
+ float dt_sec = 0.001f * dt;
+ if (t > nextjump) {
+ vy = JUMP_VY;
+ nextjump = t + (long) randfrange(5000, 10000);
+ }
+ if (unblink > 0 && t > unblink) {
+ setBlinking(false);
+ unblink = 0;
+ } else if (Math.random() < 0.001f) {
+ setBlinking(true);
+ unblink = t + 200;
+ }
+
+ ax = (float) (MAX_VX * Math.sin(t_sec*.25f));
+
+ vx = clamp(vx + dt_sec * ax, -MAX_VX, MAX_VX);
+ vy = clamp(vy + dt_sec * ay, -100*MAX_VY, MAX_VY);
+
+ // oob check
+ if (point.y - BASE_SCALE/2 > scaledBounds[1]) {
+ vy = JUMP_VY;
+ } else if (point.y + BASE_SCALE < 0) {
+ vy = MAX_VY;
+ }
+
+ point.x = clamp(point.x + dt_sec * vx, 0, scaledBounds[0]);
+ point.y = point.y + dt_sec * vy;
+
+ repositionArms();
+ }
+ });
+ }
+ mDriftAnimation.start();
+ }
+
+ public void stopDrift() {
+ mDriftAnimation.cancel();
+ }
+
+ @Override
+ public void onBoundsChange(Rect bounds) {
+ final float w = bounds.width();
+ final float h = bounds.height();
+
+ lockArms(true);
+ moveTo(w/2, h/2);
+ lockArms(false);
+
+ scaledBounds[0] = w;
+ scaledBounds[1] = h;
+ M_inv.mapPoints(scaledBounds);
+ }
+
+ // real pixel coordinates
+ public void moveTo(float x, float y) {
+ point.x = x;
+ point.y = y;
+ mapPointF(M_inv, point);
+ repositionArms();
+ }
+
+ public boolean hitTest(float x, float y) {
+ ptmp[0] = x;
+ ptmp[1] = y;
+ M_inv.mapPoints(ptmp);
+ return Math.hypot(ptmp[0] - point.x, ptmp[1] - point.y) < BASE_SCALE/2;
+ }
+
+ private void lockArms(boolean l) {
+ for (Arm arm : mArms) {
+ arm.setLocked(l);
+ }
+ }
+ private void repositionArms() {
+ for (int i=0; i<mArms.length; i++) {
+ final float bias = (float)i/(mArms.length-1) - 0.5f;
+ mArms[i].setAnchor(
+ point.x+bias*30f,point.y+26f);
+ }
+ invalidateSelf();
+ }
+
+ private void drawPupil(Canvas canvas, float x, float y, float size, boolean open,
+ Paint pt) {
+ final float r = open ? size*.33f : size * .1f;
+ canvas.drawRoundRect(x - size, y - r, x + size, y + r, r, r, pt);
+ }
+
+ @Override
+ public void draw(@NonNull Canvas canvas) {
+ canvas.save();
+ {
+ canvas.concat(M);
+
+ // arms behind
+ mPaint.setColor(ARM_COLOR_BACK);
+ for (int i : BACK_ARMS) {
+ mArms[i].draw(canvas, mPaint);
+ }
+
+ // head/body/thing
+ mPaint.setColor(EYE_COLOR);
+ canvas.drawCircle(point.x, point.y, 36f, mPaint);
+ mPaint.setColor(BODY_COLOR);
+ canvas.save();
+ {
+ canvas.clipOutRect(point.x - 61f, point.y + 8f,
+ point.x + 61f, point.y + 12f);
+ canvas.drawOval(point.x-40f,point.y-60f,point.x+40f,point.y+40f, mPaint);
+ }
+ canvas.restore();
+
+ // eyes
+ mPaint.setColor(EYE_COLOR);
+ if (mBlinking) {
+ drawPupil(canvas, point.x - 16f, point.y - 12f, 6f, false, mPaint);
+ drawPupil(canvas, point.x + 16f, point.y - 12f, 6f, false, mPaint);
+ } else {
+ canvas.drawCircle(point.x - 16f, point.y - 12f, 6f, mPaint);
+ canvas.drawCircle(point.x + 16f, point.y - 12f, 6f, mPaint);
+ }
+
+ // too much?
+ if (false) {
+ mPaint.setColor(0xFF000000);
+ drawPupil(canvas, point.x - 16f, point.y - 12f, 5f, true, mPaint);
+ drawPupil(canvas, point.x + 16f, point.y - 12f, 5f, true, mPaint);
+ }
+
+ // arms in front
+ mPaint.setColor(ARM_COLOR);
+ for (int i : FRONT_ARMS) {
+ mArms[i].draw(canvas, mPaint);
+ }
+
+ if (PATH_DEBUG) for (Arm arm : mArms) {
+ arm.drawDebug(canvas);
+ }
+ }
+ canvas.restore();
+ }
+
+ public void setBlinking(boolean b) {
+ mBlinking = b;
+ invalidateSelf();
+ }
+
+ @Override
+ public void setAlpha(int i) {
+ }
+
+ @Override
+ public void setColorFilter(@Nullable ColorFilter colorFilter) {
+
+ }
+
+ @Override
+ public int getOpacity() {
+ return PixelFormat.TRANSLUCENT;
+ }
+
+ static Path pathMoveTo(Path p, PointF pt) {
+ p.moveTo(pt.x, pt.y);
+ return p;
+ }
+ static Path pathQuadTo(Path p, PointF p1, PointF p2) {
+ p.quadTo(p1.x, p1.y, p2.x, p2.y);
+ return p;
+ }
+
+ static void mapPointF(Matrix m, PointF point) {
+ float[] p = new float[2];
+ p[0] = point.x;
+ p[1] = point.y;
+ m.mapPoints(p);
+ point.x = p[0];
+ point.y = p[1];
+ }
+
+ private class Link // he come to town
+ implements DynamicAnimation.OnAnimationUpdateListener {
+ final FloatValueHolder[] coords = new FloatValueHolder[2];
+ final SpringAnimation[] anims = new SpringAnimation[coords.length];
+ private float dx, dy;
+ private boolean locked = false;
+ Link next;
+
+ Link(int index, float x1, float y1, float dx, float dy) {
+ coords[0] = new FloatValueHolder(x1);
+ coords[1] = new FloatValueHolder(y1);
+ this.dx = dx;
+ this.dy = dy;
+ for (int i=0; i<coords.length; i++) {
+ anims[i] = new SpringAnimation(coords[i]);
+ anims[i].setSpring(new SpringForce()
+ .setDampingRatio(SpringForce.DAMPING_RATIO_LOW_BOUNCY)
+ .setStiffness(
+ index == 0 ? SpringForce.STIFFNESS_LOW
+ : index == 1 ? SpringForce.STIFFNESS_VERY_LOW
+ : SpringForce.STIFFNESS_VERY_LOW/2)
+ .setFinalPosition(0f));
+ anims[i].addUpdateListener(this);
+ }
+ }
+ public void setLocked(boolean locked) {
+ this.locked = locked;
+ }
+ public PointF start() {
+ return new PointF(coords[0].getValue(), coords[1].getValue());
+ }
+ public PointF end() {
+ return new PointF(coords[0].getValue()+dx,coords[1].getValue()+dy);
+ }
+ public PointF mid() {
+ return new PointF(
+ 0.5f*dx+(coords[0].getValue()),
+ 0.5f*dy+(coords[1].getValue()));
+ }
+ public void animateTo(PointF target) {
+ if (locked) {
+ setStart(target.x, target.y);
+ } else {
+ anims[0].animateToFinalPosition(target.x);
+ anims[1].animateToFinalPosition(target.y);
+ }
+ }
+ @Override
+ public void onAnimationUpdate(DynamicAnimation dynamicAnimation, float v, float v1) {
+ if (next != null) {
+ next.animateTo(end());
+ }
+ OctopusDrawable.this.invalidateSelf();
+ }
+
+ public void setStart(float x, float y) {
+ coords[0].setValue(x);
+ coords[1].setValue(y);
+ onAnimationUpdate(null, 0, 0);
+ }
+ }
+
+ private class Arm {
+ final Link link1, link2, link3;
+ float max, min;
+
+ public Arm(float x, float y, float dx1, float dy1, float dx2, float dy2, float dx3, float dy3,
+ float max, float min) {
+ link1 = new Link(0, x, y, dx1, dy1);
+ link2 = new Link(1, x+dx1, y+dy1, dx2, dy2);
+ link3 = new Link(2, x+dx1+dx2, y+dy1+dy2, dx3, dy3);
+ link1.next = link2;
+ link2.next = link3;
+
+ link1.setLocked(true);
+ link2.setLocked(false);
+ link3.setLocked(false);
+
+ this.max = max;
+ this.min = min;
+ }
+
+ // when the arm is locked, it moves rigidly, without physics
+ public void setLocked(boolean locked) {
+ link2.setLocked(locked);
+ link3.setLocked(locked);
+ }
+
+ private void setAnchor(float x, float y) {
+ link1.setStart(x,y);
+ }
+
+ public Path getPath() {
+ Path p = new Path();
+ pathMoveTo(p, link1.start());
+ pathQuadTo(p, link2.start(), link2.mid());
+ pathQuadTo(p, link2.end(), link3.end());
+ return p;
+ }
+
+ public void draw(@NonNull Canvas canvas, Paint pt) {
+ final Path p = getPath();
+ TaperedPathStroke.drawPath(canvas, p, max, min, pt);
+ }
+
+ private final Paint dpt = new Paint();
+ public void drawDebug(Canvas canvas) {
+ dpt.setStyle(Paint.Style.STROKE);
+ dpt.setStrokeWidth(0.75f);
+ dpt.setStrokeCap(Paint.Cap.ROUND);
+
+ dpt.setAntiAlias(true);
+ dpt.setColor(0xFF336699);
+
+ final Path path = getPath();
+ canvas.drawPath(path, dpt);
+
+ dpt.setColor(0xFFFFFF00);
+
+ dpt.setPathEffect(new DashPathEffect(new float[] {2f, 2f}, 0f));
+
+ canvas.drawLines(new float[] {
+ link1.end().x, link1.end().y,
+ link2.start().x, link2.start().y,
+
+ link2.end().x, link2.end().y,
+ link3.start().x, link3.start().y,
+ }, dpt);
+ dpt.setPathEffect(null);
+
+ dpt.setColor(0xFF00CCFF);
+
+ canvas.drawLines(new float[] {
+ link1.start().x, link1.start().y,
+ link1.end().x, link1.end().y,
+
+ link2.start().x, link2.start().y,
+ link2.end().x, link2.end().y,
+
+ link3.start().x, link3.start().y,
+ link3.end().x, link3.end().y,
+ }, dpt);
+
+ dpt.setColor(0xFFCCEEFF);
+ canvas.drawCircle(link2.start().x, link2.start().y, 2f, dpt);
+ canvas.drawCircle(link3.start().x, link3.start().y, 2f, dpt);
+
+ dpt.setStyle(Paint.Style.FILL_AND_STROKE);
+ canvas.drawCircle(link1.start().x, link1.start().y, 2f, dpt);
+ canvas.drawCircle(link2.mid().x, link2.mid().y, 2f, dpt);
+ canvas.drawCircle(link3.end().x, link3.end().y, 2f, dpt);
+ }
+
+ }
+}
diff --git a/packages/EasterEgg/src/com/android/egg/octo/TaperedPathStroke.java b/packages/EasterEgg/src/com/android/egg/octo/TaperedPathStroke.java
new file mode 100644
index 0000000..e014fbc
--- /dev/null
+++ b/packages/EasterEgg/src/com/android/egg/octo/TaperedPathStroke.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package com.android.egg.octo;
+
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.PathMeasure;
+import android.os.Debug;
+
+import java.util.Arrays;
+
+public class TaperedPathStroke {
+ static float sMinStepPx = 4f;
+ static PathMeasure pm = new PathMeasure();
+ static float[] pos = {0,0};
+ static float[] tan = {0,0};
+ static float lerp(float t, float a, float b) {
+ return a + t*(b-a);
+ }
+ public static void setMinStep(float px) {
+ sMinStepPx = px;
+ }
+
+ // it's the variable-width brush algorithm from the Markers app, basically
+ public static void drawPath(Canvas c, Path p, float r1, float r2, Paint pt) {
+ pm.setPath(p,false);
+ final float len = pm.getLength();
+ float t=0;
+ boolean last=false;
+ while (true) {
+ if (t>=len) {
+ t=len;
+ last=true;
+ }
+ pm.getPosTan(t, pos, tan);
+ float r = len > 0 ? lerp(t/len, r1, r2) : r1;
+ c.drawCircle(pos[0], pos[1], r, pt);
+ t += Math.max(r*0.25f, sMinStepPx); // walk forward 1/4 radius, not too small though
+ if (last) break;
+ }
+ }
+}