diff options
Diffstat (limited to 'core/java')
20 files changed, 1592 insertions, 72 deletions
diff --git a/core/java/android/app/ContextImpl.java b/core/java/android/app/ContextImpl.java index 4c35a8c..b902550 100644 --- a/core/java/android/app/ContextImpl.java +++ b/core/java/android/app/ContextImpl.java @@ -55,6 +55,7 @@ import android.location.ICountryDetector; import android.location.ILocationManager; import android.location.LocationManager; import android.media.AudioManager; +import android.media.MediaRouter; import android.net.ConnectivityManager; import android.net.IConnectivityManager; import android.net.INetworkPolicyManager; @@ -288,6 +289,11 @@ class ContextImpl extends Context { return new AudioManager(ctx); }}); + registerService(MEDIA_ROUTER_SERVICE, new ServiceFetcher() { + public Object createService(ContextImpl ctx) { + return new MediaRouter(ctx); + }}); + registerService(CLIPBOARD_SERVICE, new ServiceFetcher() { public Object createService(ContextImpl ctx) { return new ClipboardManager(ctx.getOuterContext(), diff --git a/core/java/android/app/MediaRouteActionProvider.java b/core/java/android/app/MediaRouteActionProvider.java index 301b125..5fe08ec 100644 --- a/core/java/android/app/MediaRouteActionProvider.java +++ b/core/java/android/app/MediaRouteActionProvider.java @@ -33,11 +33,12 @@ public class MediaRouteActionProvider extends ActionProvider { private MediaRouteButton mView; private int mRouteTypes; private final RouterCallback mRouterCallback = new RouterCallback(); + private View.OnClickListener mExtendedSettingsListener; public MediaRouteActionProvider(Context context) { super(context); mContext = context; - mRouter = MediaRouter.forApplication(context); + mRouter = (MediaRouter) context.getSystemService(Context.MEDIA_ROUTER_SERVICE); // Start with live audio by default. // TODO Update this when new route types are added; segment by API level @@ -76,6 +77,7 @@ public class MediaRouteActionProvider extends ActionProvider { mView = new MediaRouteButton(mContext); mMenuItem.setVisible(mRouter.getRouteCount() > 1); mView.setRouteTypes(mRouteTypes); + mView.setExtendedSettingsClickListener(mExtendedSettingsListener); return mView; } @@ -85,14 +87,21 @@ public class MediaRouteActionProvider extends ActionProvider { return true; } + public void setExtendedSettingsClickListener(View.OnClickListener listener) { + mExtendedSettingsListener = listener; + if (mView != null) { + mView.setExtendedSettingsClickListener(listener); + } + } + private class RouterCallback extends MediaRouter.SimpleCallback { @Override - public void onRouteAdded(int type, RouteInfo info) { + public void onRouteAdded(MediaRouter router, RouteInfo info) { mMenuItem.setVisible(mRouter.getRouteCount() > 1); } @Override - public void onRouteRemoved(int type, RouteInfo info) { + public void onRouteRemoved(MediaRouter router, RouteInfo info) { mMenuItem.setVisible(mRouter.getRouteCount() > 1); } } diff --git a/core/java/android/app/MediaRouteButton.java b/core/java/android/app/MediaRouteButton.java index 3aabd5d..385241c 100644 --- a/core/java/android/app/MediaRouteButton.java +++ b/core/java/android/app/MediaRouteButton.java @@ -43,6 +43,8 @@ public class MediaRouteButton extends View { private int mMinWidth; private int mMinHeight; + private OnClickListener mExtendedSettingsClickListener; + private static final int[] ACTIVATED_STATE_SET = { R.attr.state_activated }; @@ -58,7 +60,7 @@ public class MediaRouteButton extends View { public MediaRouteButton(Context context, AttributeSet attrs, int defStyleAttr) { super(context, attrs, defStyleAttr); - mRouter = MediaRouter.forApplication(context); + mRouter = (MediaRouter)context.getSystemService(Context.MEDIA_ROUTER_SERVICE); TypedArray a = context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.MediaRouteButton, defStyleAttr, 0); @@ -260,24 +262,29 @@ public class MediaRouteButton extends View { mRemoteIndicator.draw(canvas); } + public void setExtendedSettingsClickListener(OnClickListener listener) { + // TODO: if dialog is already open, propagate so that it updates live. + mExtendedSettingsClickListener = listener; + } + private class MediaRouteCallback extends MediaRouter.SimpleCallback { @Override - public void onRouteSelected(int type, RouteInfo info) { + public void onRouteSelected(MediaRouter router, int type, RouteInfo info) { updateRemoteIndicator(); } @Override - public void onRouteUnselected(int type, RouteInfo info) { + public void onRouteUnselected(MediaRouter router, int type, RouteInfo info) { updateRemoteIndicator(); } @Override - public void onRouteAdded(int type, RouteInfo info) { + public void onRouteAdded(MediaRouter router, RouteInfo info) { updateRouteCount(); } @Override - public void onRouteRemoved(int type, RouteInfo info) { + public void onRouteRemoved(MediaRouter router, RouteInfo info) { updateRouteCount(); } } diff --git a/core/java/android/app/Notification.java b/core/java/android/app/Notification.java index caade70..ec35a3f 100644 --- a/core/java/android/app/Notification.java +++ b/core/java/android/app/Notification.java @@ -911,7 +911,7 @@ public class Notification implements Parcelable * </pre> */ public static class Builder { - private static final int MAX_ACTION_BUTTONS = 2; + private static final int MAX_ACTION_BUTTONS = 3; private Context mContext; diff --git a/core/java/android/content/Context.java b/core/java/android/content/Context.java index 4c169d3..7588cda 100644 --- a/core/java/android/content/Context.java +++ b/core/java/android/content/Context.java @@ -1528,6 +1528,8 @@ public abstract class Context { * @see android.net.wifi.WifiManager * @see #AUDIO_SERVICE * @see android.media.AudioManager + * @see #MEDIA_ROUTER_SERVICE + * @see android.media.MediaRouter * @see #TELEPHONY_SERVICE * @see android.telephony.TelephonyManager * @see #INPUT_METHOD_SERVICE @@ -1778,7 +1780,6 @@ public abstract class Context { */ public static final String NSD_SERVICE = "servicediscovery"; - /** * Use with {@link #getSystemService} to retrieve a * {@link android.media.AudioManager} for handling management of volume, @@ -1791,6 +1792,16 @@ public abstract class Context { /** * Use with {@link #getSystemService} to retrieve a + * {@link android.media.MediaRouter} for controlling and managing + * routing of media. + * + * @see #getSystemService + * @see android.media.MediaRouter + */ + public static final String MEDIA_ROUTER_SERVICE = "media_router"; + + /** + * Use with {@link #getSystemService} to retrieve a * {@link android.telephony.TelephonyManager} for handling management the * telephony features of the device. * diff --git a/core/java/android/content/pm/IPackageManager.aidl b/core/java/android/content/pm/IPackageManager.aidl index 70c0c48..90b4247 100644 --- a/core/java/android/content/pm/IPackageManager.aidl +++ b/core/java/android/content/pm/IPackageManager.aidl @@ -376,4 +376,7 @@ interface IPackageManager { void setPermissionEnforced(String permission, boolean enforced); boolean isPermissionEnforced(String permission); + + /** Reflects current DeviceStorageMonitorService state */ + boolean isStorageLow(); } diff --git a/core/java/android/content/pm/PackageParser.java b/core/java/android/content/pm/PackageParser.java index b9811c8..f8898c1 100644 --- a/core/java/android/content/pm/PackageParser.java +++ b/core/java/android/content/pm/PackageParser.java @@ -127,9 +127,13 @@ public class PackageParser { */ public static final PackageParser.SplitPermissionInfo SPLIT_PERMISSIONS[] = new PackageParser.SplitPermissionInfo[] { + // READ_EXTERNAL_STORAGE is always required when an app requests + // WRITE_EXTERNAL_STORAGE, because we can't have an app that has + // write access without read access. The hack here with the target + // target SDK version ensures that this grant is always done. new PackageParser.SplitPermissionInfo(android.Manifest.permission.WRITE_EXTERNAL_STORAGE, new String[] { android.Manifest.permission.READ_EXTERNAL_STORAGE }, - android.os.Build.VERSION_CODES.JELLY_BEAN), + android.os.Build.VERSION_CODES.CUR_DEVELOPMENT+1), new PackageParser.SplitPermissionInfo(android.Manifest.permission.READ_CONTACTS, new String[] { android.Manifest.permission.READ_CALL_LOG }, android.os.Build.VERSION_CODES.JELLY_BEAN), diff --git a/core/java/android/text/Layout.java b/core/java/android/text/Layout.java index c453a5d..12f16fd 100644 --- a/core/java/android/text/Layout.java +++ b/core/java/android/text/Layout.java @@ -456,6 +456,7 @@ public abstract class Layout { final int top = Math.max(dtop, 0); final int bottom = Math.min(getLineTop(getLineCount()), dbottom); + if (top >= bottom) return TextUtils.packRangeInLong(0, -1); return TextUtils.packRangeInLong(getLineForVertical(top), getLineForVertical(bottom)); } diff --git a/core/java/android/text/style/StyleSpan.java b/core/java/android/text/style/StyleSpan.java index deed737..8e6147c 100644 --- a/core/java/android/text/style/StyleSpan.java +++ b/core/java/android/text/style/StyleSpan.java @@ -98,7 +98,6 @@ public class StyleSpan extends MetricAffectingSpan implements ParcelableSpan { } int fake = want & ~tf.getStyle(); - fake |= tf.getStyle() & Typeface.BOLD; if ((fake & Typeface.BOLD) != 0) { paint.setFakeBoldText(true); diff --git a/core/java/android/text/style/TextAppearanceSpan.java b/core/java/android/text/style/TextAppearanceSpan.java index abd02cf..ecbf4bc 100644 --- a/core/java/android/text/style/TextAppearanceSpan.java +++ b/core/java/android/text/style/TextAppearanceSpan.java @@ -235,7 +235,6 @@ public class TextAppearanceSpan extends MetricAffectingSpan implements Parcelabl } int fake = style & ~tf.getStyle(); - fake |= tf.getStyle() & Typeface.BOLD; if ((fake & Typeface.BOLD) != 0) { ds.setFakeBoldText(true); diff --git a/core/java/android/text/style/TypefaceSpan.java b/core/java/android/text/style/TypefaceSpan.java index 3d74ed0..f194060 100644 --- a/core/java/android/text/style/TypefaceSpan.java +++ b/core/java/android/text/style/TypefaceSpan.java @@ -82,7 +82,6 @@ public class TypefaceSpan extends MetricAffectingSpan implements ParcelableSpan Typeface tf = Typeface.create(family, oldStyle); int fake = oldStyle & ~tf.getStyle(); - fake |= tf.getStyle() & Typeface.BOLD; if ((fake & Typeface.BOLD) != 0) { paint.setFakeBoldText(true); diff --git a/core/java/android/view/AccessibilityIterators.java b/core/java/android/view/AccessibilityIterators.java index 2a7dc18..17ce4f6 100644 --- a/core/java/android/view/AccessibilityIterators.java +++ b/core/java/android/view/AccessibilityIterators.java @@ -70,20 +70,19 @@ public final class AccessibilityIterators { implements ComponentCallbacks { private static CharacterTextSegmentIterator sInstance; - private final Context mAppContext; + private Locale mLocale; protected BreakIterator mImpl; - public static CharacterTextSegmentIterator getInstance(Context context) { + public static CharacterTextSegmentIterator getInstance(Locale locale) { if (sInstance == null) { - sInstance = new CharacterTextSegmentIterator(context); + sInstance = new CharacterTextSegmentIterator(locale); } return sInstance; } - private CharacterTextSegmentIterator(Context context) { - mAppContext = context.getApplicationContext(); - Locale locale = mAppContext.getResources().getConfiguration().locale; + private CharacterTextSegmentIterator(Locale locale) { + mLocale = locale; onLocaleChanged(locale); ViewRootImpl.addConfigCallback(this); } @@ -148,10 +147,9 @@ public final class AccessibilityIterators { @Override public void onConfigurationChanged(Configuration newConfig) { - Configuration oldConfig = mAppContext.getResources().getConfiguration(); - final int changed = oldConfig.diff(newConfig); - if ((changed & ActivityInfo.CONFIG_LOCALE) != 0) { - Locale locale = newConfig.locale; + Locale locale = newConfig.locale; + if (!mLocale.equals(locale)) { + mLocale = locale; onLocaleChanged(locale); } } @@ -169,15 +167,15 @@ public final class AccessibilityIterators { static class WordTextSegmentIterator extends CharacterTextSegmentIterator { private static WordTextSegmentIterator sInstance; - public static WordTextSegmentIterator getInstance(Context context) { + public static WordTextSegmentIterator getInstance(Locale locale) { if (sInstance == null) { - sInstance = new WordTextSegmentIterator(context); + sInstance = new WordTextSegmentIterator(locale); } return sInstance; } - private WordTextSegmentIterator(Context context) { - super(context); + private WordTextSegmentIterator(Locale locale) { + super(locale); } @Override diff --git a/core/java/android/view/Choreographer.java b/core/java/android/view/Choreographer.java index aaa081c..78dc86f 100644 --- a/core/java/android/view/Choreographer.java +++ b/core/java/android/view/Choreographer.java @@ -103,6 +103,11 @@ public final class Choreographer { private static final boolean USE_FRAME_TIME = SystemProperties.getBoolean( "debug.choreographer.frametime", true); + // Set a limit to warn about skipped frames. + // Skipped frames imply jank. + private static final int SKIPPED_FRAME_WARNING_LIMIT = SystemProperties.getInt( + "debug.choreographer.skipwarning", 30); + private static final long NANOS_PER_MS = 1000000; private static final int MSG_DO_FRAME = 0; @@ -486,13 +491,18 @@ public final class Choreographer { startNanos = System.nanoTime(); final long jitterNanos = startNanos - frameTimeNanos; if (jitterNanos >= mFrameIntervalNanos) { + final long skippedFrames = jitterNanos / mFrameIntervalNanos; + if (skippedFrames >= SKIPPED_FRAME_WARNING_LIMIT) { + Log.i(TAG, "Skipped " + skippedFrames + " frames! " + + "The application may be doing too much work on its main thread."); + } final long lastFrameOffset = jitterNanos % mFrameIntervalNanos; if (DEBUG) { Log.d(TAG, "Missed vsync by " + (jitterNanos * 0.000001f) + " ms " + "which is more than the frame interval of " + (mFrameIntervalNanos * 0.000001f) + " ms! " - + "Setting frame time to " + (lastFrameOffset * 0.000001f) - + " ms in the past."); + + "Skipping " + skippedFrames + " frames and setting frame " + + "time to " + (lastFrameOffset * 0.000001f) + " ms in the past."); } frameTimeNanos = startNanos - lastFrameOffset; } @@ -500,7 +510,7 @@ public final class Choreographer { if (frameTimeNanos < mLastFrameTimeNanos) { if (DEBUG) { Log.d(TAG, "Frame time appears to be going backwards. May be due to a " - + "previously skipped frame. Waiting for next vsync"); + + "previously skipped frame. Waiting for next vsync."); } scheduleVsyncLocked(); return; @@ -658,6 +668,7 @@ public final class Choreographer { private final class FrameDisplayEventReceiver extends DisplayEventReceiver implements Runnable { + private boolean mHavePendingVsync; private long mTimestampNanos; private int mFrame; @@ -672,6 +683,21 @@ public final class Choreographer { // the message queue. If there are no messages in the queue with timestamps // earlier than the frame time, then the vsync event will be processed immediately. // Otherwise, messages that predate the vsync event will be handled first. + long now = System.nanoTime(); + if (timestampNanos > now) { + Log.w(TAG, "Frame time is " + ((timestampNanos - now) * 0.000001f) + + " ms in the future! Check that graphics HAL is generating vsync " + + "timestamps using the correct timebase."); + timestampNanos = now; + } + + if (mHavePendingVsync) { + Log.w(TAG, "Already have a pending vsync event. There should only be " + + "one at a time."); + } else { + mHavePendingVsync = true; + } + mTimestampNanos = timestampNanos; mFrame = frame; Message msg = Message.obtain(mHandler, this); @@ -681,6 +707,7 @@ public final class Choreographer { @Override public void run() { + mHavePendingVsync = false; doFrame(mTimestampNanos, mFrame); } } diff --git a/core/java/android/view/View.java b/core/java/android/view/View.java index f005eeb..816b631 100644 --- a/core/java/android/view/View.java +++ b/core/java/android/view/View.java @@ -6957,7 +6957,8 @@ public class View implements Drawable.Callback, Drawable.Callback2, KeyEvent.Cal CharSequence text = getIterableTextForAccessibility(); if (text != null && text.length() > 0) { CharacterTextSegmentIterator iterator = - CharacterTextSegmentIterator.getInstance(mContext); + CharacterTextSegmentIterator.getInstance( + mContext.getResources().getConfiguration().locale); iterator.initialize(text.toString()); return iterator; } @@ -6966,7 +6967,8 @@ public class View implements Drawable.Callback, Drawable.Callback2, KeyEvent.Cal CharSequence text = getIterableTextForAccessibility(); if (text != null && text.length() > 0) { WordTextSegmentIterator iterator = - WordTextSegmentIterator.getInstance(mContext); + WordTextSegmentIterator.getInstance( + mContext.getResources().getConfiguration().locale); iterator.initialize(text.toString()); return iterator; } diff --git a/core/java/android/view/ViewRootImpl.java b/core/java/android/view/ViewRootImpl.java index b5fff8a..cdc51d1 100644 --- a/core/java/android/view/ViewRootImpl.java +++ b/core/java/android/view/ViewRootImpl.java @@ -229,6 +229,7 @@ public final class ViewRootImpl implements ViewParent, boolean mWindowsAnimating; boolean mIsDrawing; int mLastSystemUiVisibility; + int mClientWindowLayoutFlags; // Pool of queued input events. private static final int MAX_QUEUED_INPUT_EVENT_POOL_SIZE = 10; @@ -485,6 +486,8 @@ public final class ViewRootImpl implements ViewParent, mFallbackEventHandler.setView(view); mWindowAttributes.copyFrom(attrs); attrs = mWindowAttributes; + // Keep track of the actual window flags supplied by the client. + mClientWindowLayoutFlags = attrs.flags; setAccessibilityFocusedHost(null); @@ -671,6 +674,7 @@ public final class ViewRootImpl implements ViewParent, } public boolean attachFunctor(int functor) { + //noinspection SimplifiableIfStatement if (mAttachInfo.mHardwareRenderer != null && mAttachInfo.mHardwareRenderer.isEnabled()) { return mAttachInfo.mHardwareRenderer.attachFunctor(mAttachInfo, functor); } @@ -678,7 +682,7 @@ public final class ViewRootImpl implements ViewParent, } public void detachFunctor(int functor) { - if (mAttachInfo.mHardwareRenderer != null && mAttachInfo.mHardwareRenderer.isEnabled()) { + if (mAttachInfo.mHardwareRenderer != null) { mAttachInfo.mHardwareRenderer.detachFunctor(functor); } } @@ -759,6 +763,8 @@ public final class ViewRootImpl implements ViewParent, void setLayoutParams(WindowManager.LayoutParams attrs, boolean newView) { synchronized (this) { int oldSoftInputMode = mWindowAttributes.softInputMode; + // Keep track of the actual window flags supplied by the client. + mClientWindowLayoutFlags = attrs.flags; // preserve compatible window flag if exists. int compatibleWindowFlag = mWindowAttributes.flags & WindowManager.LayoutParams.FLAG_COMPATIBLE_WINDOW; @@ -767,7 +773,9 @@ public final class ViewRootImpl implements ViewParent, attrs.subtreeSystemUiVisibility = mWindowAttributes.subtreeSystemUiVisibility; mWindowAttributesChangesFlag = mWindowAttributes.copyFrom(attrs); mWindowAttributes.flags |= compatibleWindowFlag; - + + applyKeepScreenOnFlag(mWindowAttributes); + if (newView) { mSoftInputMode = attrs.softInputMode; requestLayout(); @@ -999,6 +1007,18 @@ public final class ViewRootImpl implements ViewParent, } } + private void applyKeepScreenOnFlag(WindowManager.LayoutParams params) { + // Update window's global keep screen on flag: if a view has requested + // that the screen be kept on, then it is always set; otherwise, it is + // set to whatever the client last requested for the global state. + if (mAttachInfo.mKeepScreenOn) { + params.flags |= WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON; + } else { + params.flags = (params.flags&~WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON) + | (mClientWindowLayoutFlags&WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON); + } + } + private boolean collectViewAttributes() { final View.AttachInfo attachInfo = mAttachInfo; if (attachInfo.mRecomputeGlobalAttributes) { @@ -1016,9 +1036,7 @@ public final class ViewRootImpl implements ViewParent, || attachInfo.mSystemUiVisibility != oldVis || attachInfo.mHasSystemUiListeners != oldHasSystemUiListeners) { WindowManager.LayoutParams params = mWindowAttributes; - if (attachInfo.mKeepScreenOn) { - params.flags |= WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON; - } + applyKeepScreenOnFlag(params); params.subtreeSystemUiVisibility = attachInfo.mSystemUiVisibility; params.hasSystemUiListeners = attachInfo.mHasSystemUiListeners; mView.dispatchWindowSystemUiVisiblityChanged(attachInfo.mSystemUiVisibility); diff --git a/core/java/android/widget/Switch.java b/core/java/android/widget/Switch.java index 39bc7c2..471f259 100644 --- a/core/java/android/widget/Switch.java +++ b/core/java/android/widget/Switch.java @@ -259,12 +259,10 @@ public class Switch extends CompoundButton { // now compute what (if any) algorithmic styling is needed int typefaceStyle = tf != null ? tf.getStyle() : 0; int need = style & ~typefaceStyle; - need |= typefaceStyle & Typeface.BOLD; mTextPaint.setFakeBoldText((need & Typeface.BOLD) != 0); mTextPaint.setTextSkewX((need & Typeface.ITALIC) != 0 ? -0.25f : 0); } else { - int typefaceStyle = tf != null ? tf.getStyle() : 0; - mTextPaint.setFakeBoldText((typefaceStyle & Typeface.BOLD) != 0); + mTextPaint.setFakeBoldText(false); mTextPaint.setTextSkewX(0); setSwitchTypeface(tf); } diff --git a/core/java/android/widget/TextView.java b/core/java/android/widget/TextView.java index 464a527..01617da 100644 --- a/core/java/android/widget/TextView.java +++ b/core/java/android/widget/TextView.java @@ -1237,12 +1237,10 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener // now compute what (if any) algorithmic styling is needed int typefaceStyle = tf != null ? tf.getStyle() : 0; int need = style & ~typefaceStyle; - need |= typefaceStyle & Typeface.BOLD; // keep bold in mTextPaint.setFakeBoldText((need & Typeface.BOLD) != 0); mTextPaint.setTextSkewX((need & Typeface.ITALIC) != 0 ? -0.25f : 0); } else { - int typefaceStyle = tf != null ? tf.getStyle() : 0; - mTextPaint.setFakeBoldText((typefaceStyle & Typeface.BOLD) != 0); + mTextPaint.setFakeBoldText(false); mTextPaint.setTextSkewX(0); setTypeface(tf); } diff --git a/core/java/com/android/internal/widget/multiwaveview/GlowPadView.java b/core/java/com/android/internal/widget/multiwaveview/GlowPadView.java new file mode 100644 index 0000000..5096be6 --- /dev/null +++ b/core/java/com/android/internal/widget/multiwaveview/GlowPadView.java @@ -0,0 +1,1226 @@ +/* + * Copyright (C) 2012 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.internal.widget.multiwaveview; + +import android.animation.Animator; +import android.animation.Animator.AnimatorListener; +import android.animation.AnimatorListenerAdapter; +import android.animation.TimeInterpolator; +import android.animation.ValueAnimator; +import android.animation.ValueAnimator.AnimatorUpdateListener; +import android.content.ComponentName; +import android.content.Context; +import android.content.pm.PackageManager; +import android.content.pm.PackageManager.NameNotFoundException; +import android.content.res.Resources; +import android.content.res.TypedArray; +import android.graphics.Canvas; +import android.graphics.RectF; +import android.graphics.drawable.Drawable; +import android.os.Bundle; +import android.os.Vibrator; +import android.text.TextUtils; +import android.util.AttributeSet; +import android.util.Log; +import android.util.TypedValue; +import android.view.Gravity; +import android.view.MotionEvent; +import android.view.View; +import android.view.accessibility.AccessibilityEvent; +import android.view.accessibility.AccessibilityManager; + +import com.android.internal.R; + +import java.util.ArrayList; + +/** + * A re-usable widget containing a center, outer ring and wave animation. + */ +public class GlowPadView extends View { + private static final String TAG = "GlowPadView"; + private static final boolean DEBUG = false; + + // Wave state machine + private static final int STATE_IDLE = 0; + private static final int STATE_START = 1; + private static final int STATE_FIRST_TOUCH = 2; + private static final int STATE_TRACKING = 3; + private static final int STATE_SNAP = 4; + private static final int STATE_FINISH = 5; + + // Animation properties. + private static final float SNAP_MARGIN_DEFAULT = 20.0f; // distance to ring before we snap to it + + public interface OnTriggerListener { + int NO_HANDLE = 0; + int CENTER_HANDLE = 1; + public void onGrabbed(View v, int handle); + public void onReleased(View v, int handle); + public void onTrigger(View v, int target); + public void onGrabbedStateChange(View v, int handle); + public void onFinishFinalAnimation(); + } + + // Tuneable parameters for animation + private static final int WAVE_ANIMATION_DURATION = 1200; + private static final int RETURN_TO_HOME_DELAY = 1200; + private static final int RETURN_TO_HOME_DURATION = 200; + private static final int HIDE_ANIMATION_DELAY = 200; + private static final int HIDE_ANIMATION_DURATION = 200; + private static final int SHOW_ANIMATION_DURATION = 200; + private static final int SHOW_ANIMATION_DELAY = 50; + private static final int INITIAL_SHOW_HANDLE_DURATION = 200; + private static final int REVEAL_GLOW_DELAY = 0; + private static final int REVEAL_GLOW_DURATION = 0; + + private static final float TAP_RADIUS_SCALE_ACCESSIBILITY_ENABLED = 1.3f; + private static final float TARGET_SCALE_EXPANDED = 1.0f; + private static final float TARGET_SCALE_COLLAPSED = 0.8f; + private static final float RING_SCALE_EXPANDED = 1.0f; + private static final float RING_SCALE_COLLAPSED = 0.5f; + + private ArrayList<TargetDrawable> mTargetDrawables = new ArrayList<TargetDrawable>(); + private AnimationBundle mWaveAnimations = new AnimationBundle(); + private AnimationBundle mTargetAnimations = new AnimationBundle(); + private AnimationBundle mGlowAnimations = new AnimationBundle(); + private ArrayList<String> mTargetDescriptions; + private ArrayList<String> mDirectionDescriptions; + private OnTriggerListener mOnTriggerListener; + private TargetDrawable mHandleDrawable; + private TargetDrawable mOuterRing; + private Vibrator mVibrator; + + private int mFeedbackCount = 3; + private int mVibrationDuration = 0; + private int mGrabbedState; + private int mActiveTarget = -1; + private float mGlowRadius; + private float mWaveCenterX; + private float mWaveCenterY; + private int mMaxTargetHeight; + private int mMaxTargetWidth; + + private float mOuterRadius = 0.0f; + private float mHitRadius = 0.0f; + private float mSnapMargin = 0.0f; + private boolean mDragging; + private int mNewTargetResources; + + private class AnimationBundle extends ArrayList<Tweener> { + private static final long serialVersionUID = 0xA84D78726F127468L; + private boolean mSuspended; + + public void start() { + if (mSuspended) return; // ignore attempts to start animations + final int count = size(); + for (int i = 0; i < count; i++) { + Tweener anim = get(i); + anim.animator.start(); + } + } + + public void cancel() { + final int count = size(); + for (int i = 0; i < count; i++) { + Tweener anim = get(i); + anim.animator.cancel(); + } + clear(); + } + + public void stop() { + final int count = size(); + for (int i = 0; i < count; i++) { + Tweener anim = get(i); + anim.animator.end(); + } + clear(); + } + + public void setSuspended(boolean suspend) { + mSuspended = suspend; + } + }; + + private AnimatorListener mResetListener = new AnimatorListenerAdapter() { + public void onAnimationEnd(Animator animator) { + switchToState(STATE_IDLE, mWaveCenterX, mWaveCenterY); + dispatchOnFinishFinalAnimation(); + } + }; + + private AnimatorListener mResetListenerWithPing = new AnimatorListenerAdapter() { + public void onAnimationEnd(Animator animator) { + ping(); + switchToState(STATE_IDLE, mWaveCenterX, mWaveCenterY); + dispatchOnFinishFinalAnimation(); + } + }; + + private AnimatorUpdateListener mUpdateListener = new AnimatorUpdateListener() { + public void onAnimationUpdate(ValueAnimator animation) { + invalidate(); + } + }; + + private boolean mAnimatingTargets; + private AnimatorListener mTargetUpdateListener = new AnimatorListenerAdapter() { + public void onAnimationEnd(Animator animator) { + if (mNewTargetResources != 0) { + internalSetTargetResources(mNewTargetResources); + mNewTargetResources = 0; + hideTargets(false, false); + } + mAnimatingTargets = false; + } + }; + private int mTargetResourceId; + private int mTargetDescriptionsResourceId; + private int mDirectionDescriptionsResourceId; + private boolean mAlwaysTrackFinger; + private int mHorizontalInset; + private int mVerticalInset; + private int mGravity = Gravity.TOP; + private boolean mInitialLayout = true; + private Tweener mBackgroundAnimator; + private PointCloud mPointCloud; + private float mInnerRadius; + + public GlowPadView(Context context) { + this(context, null); + } + + public GlowPadView(Context context, AttributeSet attrs) { + super(context, attrs); + Resources res = context.getResources(); + + TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.GlowPadView); + mInnerRadius = a.getDimension(R.styleable.GlowPadView_innerRadius, mInnerRadius); + mOuterRadius = a.getDimension(R.styleable.GlowPadView_outerRadius, mOuterRadius); + mHitRadius = a.getDimension(R.styleable.GlowPadView_hitRadius, mHitRadius); + mSnapMargin = a.getDimension(R.styleable.GlowPadView_snapMargin, mSnapMargin); + mVibrationDuration = a.getInt(R.styleable.GlowPadView_vibrationDuration, + mVibrationDuration); + mFeedbackCount = a.getInt(R.styleable.GlowPadView_feedbackCount, + mFeedbackCount); + mHandleDrawable = new TargetDrawable(res, + a.peekValue(R.styleable.GlowPadView_handleDrawable).resourceId); + mHandleDrawable.setState(TargetDrawable.STATE_INACTIVE); + mOuterRing = new TargetDrawable(res, + getResourceId(a, R.styleable.GlowPadView_outerRingDrawable)); + + mAlwaysTrackFinger = a.getBoolean(R.styleable.GlowPadView_alwaysTrackFinger, false); + + int pointId = getResourceId(a, R.styleable.GlowPadView_pointDrawable); + Drawable pointDrawable = pointId != 0 ? res.getDrawable(pointId) : null; + mGlowRadius = a.getDimension(R.styleable.GlowPadView_glowRadius, 0.0f); + + TypedValue outValue = new TypedValue(); + + // Read array of target drawables + if (a.getValue(R.styleable.GlowPadView_targetDrawables, outValue)) { + internalSetTargetResources(outValue.resourceId); + } + if (mTargetDrawables == null || mTargetDrawables.size() == 0) { + throw new IllegalStateException("Must specify at least one target drawable"); + } + + // Read array of target descriptions + if (a.getValue(R.styleable.GlowPadView_targetDescriptions, outValue)) { + final int resourceId = outValue.resourceId; + if (resourceId == 0) { + throw new IllegalStateException("Must specify target descriptions"); + } + setTargetDescriptionsResourceId(resourceId); + } + + // Read array of direction descriptions + if (a.getValue(R.styleable.GlowPadView_directionDescriptions, outValue)) { + final int resourceId = outValue.resourceId; + if (resourceId == 0) { + throw new IllegalStateException("Must specify direction descriptions"); + } + setDirectionDescriptionsResourceId(resourceId); + } + + a.recycle(); + + // Use gravity attribute from LinearLayout + a = context.obtainStyledAttributes(attrs, android.R.styleable.LinearLayout); + mGravity = a.getInt(android.R.styleable.LinearLayout_gravity, Gravity.TOP); + a.recycle(); + + setVibrateEnabled(mVibrationDuration > 0); + + assignDefaultsIfNeeded(); + + mPointCloud = new PointCloud(pointDrawable); + mPointCloud.makePointCloud(mInnerRadius, mOuterRadius); + mPointCloud.glowManager.setRadius(mGlowRadius); + } + + private int getResourceId(TypedArray a, int id) { + TypedValue tv = a.peekValue(id); + return tv == null ? 0 : tv.resourceId; + } + + private void dump() { + Log.v(TAG, "Outer Radius = " + mOuterRadius); + Log.v(TAG, "HitRadius = " + mHitRadius); + Log.v(TAG, "SnapMargin = " + mSnapMargin); + Log.v(TAG, "FeedbackCount = " + mFeedbackCount); + Log.v(TAG, "VibrationDuration = " + mVibrationDuration); + Log.v(TAG, "GlowRadius = " + mGlowRadius); + Log.v(TAG, "WaveCenterX = " + mWaveCenterX); + Log.v(TAG, "WaveCenterY = " + mWaveCenterY); + } + + public void suspendAnimations() { + mWaveAnimations.setSuspended(true); + mTargetAnimations.setSuspended(true); + mGlowAnimations.setSuspended(true); + } + + public void resumeAnimations() { + mWaveAnimations.setSuspended(false); + mTargetAnimations.setSuspended(false); + mGlowAnimations.setSuspended(false); + mWaveAnimations.start(); + mTargetAnimations.start(); + mGlowAnimations.start(); + } + + @Override + protected int getSuggestedMinimumWidth() { + // View should be large enough to contain the background + handle and + // target drawable on either edge. + return (int) (Math.max(mOuterRing.getWidth(), 2 * mOuterRadius) + mMaxTargetWidth); + } + + @Override + protected int getSuggestedMinimumHeight() { + // View should be large enough to contain the unlock ring + target and + // target drawable on either edge + return (int) (Math.max(mOuterRing.getHeight(), 2 * mOuterRadius) + mMaxTargetHeight); + } + + private int resolveMeasured(int measureSpec, int desired) + { + int result = 0; + int specSize = MeasureSpec.getSize(measureSpec); + switch (MeasureSpec.getMode(measureSpec)) { + case MeasureSpec.UNSPECIFIED: + result = desired; + break; + case MeasureSpec.AT_MOST: + result = Math.min(specSize, desired); + break; + case MeasureSpec.EXACTLY: + default: + result = specSize; + } + return result; + } + + @Override + protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { + final int minimumWidth = getSuggestedMinimumWidth(); + final int minimumHeight = getSuggestedMinimumHeight(); + int computedWidth = resolveMeasured(widthMeasureSpec, minimumWidth); + int computedHeight = resolveMeasured(heightMeasureSpec, minimumHeight); + computeInsets((computedWidth - minimumWidth), (computedHeight - minimumHeight)); + setMeasuredDimension(computedWidth, computedHeight); + } + + private void switchToState(int state, float x, float y) { + switch (state) { + case STATE_IDLE: + deactivateTargets(); + hideGlow(0, 0, 0.0f, null); + startBackgroundAnimation(0, 0.0f); + mHandleDrawable.setState(TargetDrawable.STATE_INACTIVE); + mHandleDrawable.setAlpha(1.0f); + break; + + case STATE_START: + startBackgroundAnimation(0, 0.0f); + break; + + case STATE_FIRST_TOUCH: + mHandleDrawable.setAlpha(0.0f); + deactivateTargets(); + showTargets(true); + startBackgroundAnimation(INITIAL_SHOW_HANDLE_DURATION, 1.0f); + setGrabbedState(OnTriggerListener.CENTER_HANDLE); + if (AccessibilityManager.getInstance(mContext).isEnabled()) { + announceTargets(); + } + break; + + case STATE_TRACKING: + mHandleDrawable.setAlpha(0.0f); + showGlow(REVEAL_GLOW_DURATION , REVEAL_GLOW_DELAY, 1.0f, null); + break; + + case STATE_SNAP: + // TODO: Add transition states (see list_selector_background_transition.xml) + mHandleDrawable.setAlpha(0.0f); + showGlow(REVEAL_GLOW_DURATION , REVEAL_GLOW_DELAY, 0.0f, null); + break; + + case STATE_FINISH: + doFinish(); + break; + } + } + + private void showGlow(int duration, int delay, float finalAlpha, + AnimatorListener finishListener) { + mGlowAnimations.cancel(); + mGlowAnimations.add(Tweener.to(mPointCloud.glowManager, duration, + "ease", Ease.Cubic.easeIn, + "delay", delay, + "alpha", finalAlpha, + "onUpdate", mUpdateListener, + "onComplete", finishListener)); + mGlowAnimations.start(); + } + + private void hideGlow(int duration, int delay, float finalAlpha, + AnimatorListener finishListener) { + mGlowAnimations.cancel(); + mGlowAnimations.add(Tweener.to(mPointCloud.glowManager, duration, + "ease", Ease.Quart.easeOut, + "delay", delay, + "alpha", finalAlpha, + "x", 0.0f, + "y", 0.0f, + "onUpdate", mUpdateListener, + "onComplete", finishListener)); + mGlowAnimations.start(); + } + + private void deactivateTargets() { + final int count = mTargetDrawables.size(); + for (int i = 0; i < count; i++) { + TargetDrawable target = mTargetDrawables.get(i); + target.setState(TargetDrawable.STATE_INACTIVE); + } + mActiveTarget = -1; + } + + /** + * Dispatches a trigger event to listener. Ignored if a listener is not set. + * @param whichTarget the target that was triggered. + */ + private void dispatchTriggerEvent(int whichTarget) { + vibrate(); + if (mOnTriggerListener != null) { + mOnTriggerListener.onTrigger(this, whichTarget); + } + } + + private void dispatchOnFinishFinalAnimation() { + if (mOnTriggerListener != null) { + mOnTriggerListener.onFinishFinalAnimation(); + } + } + + private void doFinish() { + final int activeTarget = mActiveTarget; + final boolean targetHit = activeTarget != -1; + + if (targetHit) { + if (DEBUG) Log.v(TAG, "Finish with target hit = " + targetHit); + + highlightSelected(activeTarget); + + // Inform listener of any active targets. Typically only one will be active. + hideGlow(RETURN_TO_HOME_DURATION, RETURN_TO_HOME_DELAY, 0.0f, mResetListener); + dispatchTriggerEvent(activeTarget); + if (!mAlwaysTrackFinger) { + // Force ring and targets to finish animation to final expanded state + mTargetAnimations.stop(); + } + } else { + // Animate handle back to the center based on current state. + hideGlow(HIDE_ANIMATION_DURATION, 0, 0.0f, mResetListenerWithPing); + hideTargets(true, false); + } + + setGrabbedState(OnTriggerListener.NO_HANDLE); + } + + private void highlightSelected(int activeTarget) { + // Highlight the given target and fade others + mTargetDrawables.get(activeTarget).setState(TargetDrawable.STATE_ACTIVE); + hideUnselected(activeTarget); + } + + private void hideUnselected(int active) { + for (int i = 0; i < mTargetDrawables.size(); i++) { + if (i != active) { + mTargetDrawables.get(i).setAlpha(0.0f); + } + } + } + + private void hideTargets(boolean animate, boolean expanded) { + mTargetAnimations.cancel(); + // Note: these animations should complete at the same time so that we can swap out + // the target assets asynchronously from the setTargetResources() call. + mAnimatingTargets = animate; + final int duration = animate ? HIDE_ANIMATION_DURATION : 0; + final int delay = animate ? HIDE_ANIMATION_DELAY : 0; + + final float targetScale = expanded ? TARGET_SCALE_EXPANDED : TARGET_SCALE_COLLAPSED; + final int length = mTargetDrawables.size(); + final TimeInterpolator interpolator = Ease.Cubic.easeOut; + for (int i = 0; i < length; i++) { + TargetDrawable target = mTargetDrawables.get(i); + target.setState(TargetDrawable.STATE_INACTIVE); + mTargetAnimations.add(Tweener.to(target, duration, + "ease", interpolator, + "alpha", 0.0f, + "scaleX", targetScale, + "scaleY", targetScale, + "delay", delay, + "onUpdate", mUpdateListener)); + } + + final float ringScaleTarget = expanded ? RING_SCALE_EXPANDED : RING_SCALE_COLLAPSED; + mTargetAnimations.add(Tweener.to(mOuterRing, duration, + "ease", interpolator, + "alpha", 0.0f, + "scaleX", ringScaleTarget, + "scaleY", ringScaleTarget, + "delay", delay, + "onUpdate", mUpdateListener, + "onComplete", mTargetUpdateListener)); + + mTargetAnimations.start(); + } + + private void showTargets(boolean animate) { + mTargetAnimations.stop(); + mAnimatingTargets = animate; + final int delay = animate ? SHOW_ANIMATION_DELAY : 0; + final int duration = animate ? SHOW_ANIMATION_DURATION : 0; + final int length = mTargetDrawables.size(); + for (int i = 0; i < length; i++) { + TargetDrawable target = mTargetDrawables.get(i); + target.setState(TargetDrawable.STATE_INACTIVE); + mTargetAnimations.add(Tweener.to(target, duration, + "ease", Ease.Cubic.easeOut, + "alpha", 1.0f, + "scaleX", 1.0f, + "scaleY", 1.0f, + "delay", delay, + "onUpdate", mUpdateListener)); + } + mTargetAnimations.add(Tweener.to(mOuterRing, duration, + "ease", Ease.Cubic.easeOut, + "alpha", 1.0f, + "scaleX", 1.0f, + "scaleY", 1.0f, + "delay", delay, + "onUpdate", mUpdateListener, + "onComplete", mTargetUpdateListener)); + + mTargetAnimations.start(); + } + + private void vibrate() { + if (mVibrator != null) { + mVibrator.vibrate(mVibrationDuration); + } + } + + private ArrayList<TargetDrawable> loadDrawableArray(int resourceId) { + Resources res = getContext().getResources(); + TypedArray array = res.obtainTypedArray(resourceId); + final int count = array.length(); + ArrayList<TargetDrawable> drawables = new ArrayList<TargetDrawable>(count); + for (int i = 0; i < count; i++) { + TypedValue value = array.peekValue(i); + TargetDrawable target = new TargetDrawable(res, value != null ? value.resourceId : 0); + drawables.add(target); + } + array.recycle(); + return drawables; + } + + private void internalSetTargetResources(int resourceId) { + final ArrayList<TargetDrawable> targets = loadDrawableArray(resourceId); + mTargetDrawables = targets; + mTargetResourceId = resourceId; + + int maxWidth = mHandleDrawable.getWidth(); + int maxHeight = mHandleDrawable.getHeight(); + final int count = targets.size(); + for (int i = 0; i < count; i++) { + TargetDrawable target = targets.get(i); + maxWidth = Math.max(maxWidth, target.getWidth()); + maxHeight = Math.max(maxHeight, target.getHeight()); + } + if (mMaxTargetWidth != maxWidth || mMaxTargetHeight != maxHeight) { + mMaxTargetWidth = maxWidth; + mMaxTargetHeight = maxHeight; + requestLayout(); // required to resize layout and call updateTargetPositions() + } else { + updateTargetPositions(mWaveCenterX, mWaveCenterY); + updatePointCloudPosition(mWaveCenterX, mWaveCenterY); + } + } + + /** + * Loads an array of drawables from the given resourceId. + * + * @param resourceId + */ + public void setTargetResources(int resourceId) { + if (mAnimatingTargets) { + // postpone this change until we return to the initial state + mNewTargetResources = resourceId; + } else { + internalSetTargetResources(resourceId); + } + } + + public int getTargetResourceId() { + return mTargetResourceId; + } + + /** + * Sets the resource id specifying the target descriptions for accessibility. + * + * @param resourceId The resource id. + */ + public void setTargetDescriptionsResourceId(int resourceId) { + mTargetDescriptionsResourceId = resourceId; + if (mTargetDescriptions != null) { + mTargetDescriptions.clear(); + } + } + + /** + * Gets the resource id specifying the target descriptions for accessibility. + * + * @return The resource id. + */ + public int getTargetDescriptionsResourceId() { + return mTargetDescriptionsResourceId; + } + + /** + * Sets the resource id specifying the target direction descriptions for accessibility. + * + * @param resourceId The resource id. + */ + public void setDirectionDescriptionsResourceId(int resourceId) { + mDirectionDescriptionsResourceId = resourceId; + if (mDirectionDescriptions != null) { + mDirectionDescriptions.clear(); + } + } + + /** + * Gets the resource id specifying the target direction descriptions. + * + * @return The resource id. + */ + public int getDirectionDescriptionsResourceId() { + return mDirectionDescriptionsResourceId; + } + + /** + * Enable or disable vibrate on touch. + * + * @param enabled + */ + public void setVibrateEnabled(boolean enabled) { + if (enabled && mVibrator == null) { + mVibrator = (Vibrator) getContext().getSystemService(Context.VIBRATOR_SERVICE); + } else { + mVibrator = null; + } + } + + /** + * Starts wave animation. + * + */ + public void ping() { + if (mFeedbackCount > 0) { + startWaveAnimation(); + } + } + + private void stopAndHideWaveAnimation() { + mWaveAnimations.cancel(); + mPointCloud.waveManager.setAlpha(0.0f); + } + + private void startWaveAnimation() { + mWaveAnimations.cancel(); + mPointCloud.waveManager.setAlpha(1.0f); + mPointCloud.waveManager.setRadius(mHandleDrawable.getWidth()/2.0f); + mWaveAnimations.add(Tweener.to(mPointCloud.waveManager, WAVE_ANIMATION_DURATION, + "ease", Ease.Linear.easeNone, + "delay", 0, + "radius", 2.0f * mOuterRadius, + "onUpdate", mUpdateListener, + "onComplete", + new AnimatorListenerAdapter() { + public void onAnimationEnd(Animator animator) { + mPointCloud.waveManager.setRadius(0.0f); + mPointCloud.waveManager.setAlpha(0.0f); + } + })); + mWaveAnimations.start(); + } + + /** + * Resets the widget to default state and cancels all animation. If animate is 'true', will + * animate objects into place. Otherwise, objects will snap back to place. + * + * @param animate + */ + public void reset(boolean animate) { + mGlowAnimations.stop(); + mTargetAnimations.stop(); + startBackgroundAnimation(0, 0.0f); + stopAndHideWaveAnimation(); + hideTargets(animate, false); + hideGlow(0, 0, 1.0f, null); + Tweener.reset(); + } + + private void startBackgroundAnimation(int duration, float alpha) { + final Drawable background = getBackground(); + if (mAlwaysTrackFinger && background != null) { + if (mBackgroundAnimator != null) { + mBackgroundAnimator.animator.cancel(); + } + mBackgroundAnimator = Tweener.to(background, duration, + "ease", Ease.Cubic.easeIn, + "alpha", (int)(255.0f * alpha), + "delay", SHOW_ANIMATION_DELAY); + mBackgroundAnimator.animator.start(); + } + } + + @Override + public boolean onTouchEvent(MotionEvent event) { + final int action = event.getAction(); + boolean handled = false; + switch (action) { + case MotionEvent.ACTION_DOWN: + if (DEBUG) Log.v(TAG, "*** DOWN ***"); + handleDown(event); + handleMove(event); + handled = true; + break; + + case MotionEvent.ACTION_MOVE: + if (DEBUG) Log.v(TAG, "*** MOVE ***"); + handleMove(event); + handled = true; + break; + + case MotionEvent.ACTION_UP: + if (DEBUG) Log.v(TAG, "*** UP ***"); + handleMove(event); + handleUp(event); + handled = true; + break; + + case MotionEvent.ACTION_CANCEL: + if (DEBUG) Log.v(TAG, "*** CANCEL ***"); + handleMove(event); + handleCancel(event); + handled = true; + break; + } + invalidate(); + return handled ? true : super.onTouchEvent(event); + } + + private void updateGlowPosition(float x, float y) { + mPointCloud.glowManager.setX(x); + mPointCloud.glowManager.setY(y); + } + + private void handleDown(MotionEvent event) { + float eventX = event.getX(); + float eventY = event.getY(); + switchToState(STATE_START, eventX, eventY); + if (!trySwitchToFirstTouchState(eventX, eventY)) { + mDragging = false; + } else { + updateGlowPosition(eventX, eventY); + } + } + + private void handleUp(MotionEvent event) { + if (DEBUG && mDragging) Log.v(TAG, "** Handle RELEASE"); + switchToState(STATE_FINISH, event.getX(), event.getY()); + } + + private void handleCancel(MotionEvent event) { + if (DEBUG && mDragging) Log.v(TAG, "** Handle CANCEL"); + + // We should drop the active target here but it interferes with + // moving off the screen in the direction of the navigation bar. At some point we may + // want to revisit how we handle this. For now we'll allow a canceled event to + // activate the current target. + + // mActiveTarget = -1; // Drop the active target if canceled. + + switchToState(STATE_FINISH, event.getX(), event.getY()); + } + + private void handleMove(MotionEvent event) { + int activeTarget = -1; + final int historySize = event.getHistorySize(); + ArrayList<TargetDrawable> targets = mTargetDrawables; + int ntargets = targets.size(); + final boolean singleTarget = ntargets == 1; + float x = 0.0f; + float y = 0.0f; + for (int k = 0; k < historySize + 1; k++) { + float eventX = k < historySize ? event.getHistoricalX(k) : event.getX(); + float eventY = k < historySize ? event.getHistoricalY(k) : event.getY(); + // tx and ty are relative to wave center + float tx = eventX - mWaveCenterX; + float ty = eventY - mWaveCenterY; + float touchRadius = (float) Math.sqrt(dist2(tx, ty)); + final float scale = touchRadius > mOuterRadius ? mOuterRadius / touchRadius : 1.0f; + float limitX = tx * scale; + float limitY = ty * scale; + + if (!mDragging) { + trySwitchToFirstTouchState(eventX, eventY); + } + + if (mDragging) { + if (singleTarget) { + // Snap to outer ring if there's only one target + float snapRadius = mOuterRadius - mSnapMargin; + if (touchRadius > snapRadius) { + activeTarget = 0; + } + } else { + // For more than one target, snap to the closest one less than hitRadius away. + float best = Float.MAX_VALUE; + final float hitRadius2 = mHitRadius * mHitRadius; + // Find first target in range + for (int i = 0; i < ntargets; i++) { + TargetDrawable target = targets.get(i); + float dx = limitX - target.getX(); + float dy = limitY - target.getY(); + float dist2 = dx*dx + dy*dy; + if (target.isEnabled() && dist2 < hitRadius2 && dist2 < best) { + activeTarget = i; + best = dist2; + } + } + } + } + x = limitX; + y = limitY; + } + + if (!mDragging) { + return; + } + + if (activeTarget != -1) { + switchToState(STATE_SNAP, x,y); + TargetDrawable target = targets.get(activeTarget); + final float newX = singleTarget ? x : target.getX(); + final float newY = singleTarget ? y : target.getY(); + updateGlowPosition(newX, newY); + } else { + switchToState(STATE_TRACKING, x, y); + updateGlowPosition(x, y); + } + + if (mActiveTarget != activeTarget) { + // Defocus the old target + if (mActiveTarget != -1) { + TargetDrawable target = targets.get(mActiveTarget); + if (target.hasState(TargetDrawable.STATE_FOCUSED)) { + target.setState(TargetDrawable.STATE_INACTIVE); + } + } + // Focus the new target + if (activeTarget != -1) { + TargetDrawable target = targets.get(activeTarget); + if (target.hasState(TargetDrawable.STATE_FOCUSED)) { + target.setState(TargetDrawable.STATE_FOCUSED); + } + if (AccessibilityManager.getInstance(mContext).isEnabled()) { + String targetContentDescription = getTargetDescription(activeTarget); + announceText(targetContentDescription); + } + } + } + mActiveTarget = activeTarget; + } + + @Override + public boolean onHoverEvent(MotionEvent event) { + if (AccessibilityManager.getInstance(mContext).isTouchExplorationEnabled()) { + final int action = event.getAction(); + switch (action) { + case MotionEvent.ACTION_HOVER_ENTER: + event.setAction(MotionEvent.ACTION_DOWN); + break; + case MotionEvent.ACTION_HOVER_MOVE: + event.setAction(MotionEvent.ACTION_MOVE); + break; + case MotionEvent.ACTION_HOVER_EXIT: + event.setAction(MotionEvent.ACTION_UP); + break; + } + onTouchEvent(event); + event.setAction(action); + } + return super.onHoverEvent(event); + } + + /** + * Sets the current grabbed state, and dispatches a grabbed state change + * event to our listener. + */ + private void setGrabbedState(int newState) { + if (newState != mGrabbedState) { + if (newState != OnTriggerListener.NO_HANDLE) { + vibrate(); + } + mGrabbedState = newState; + if (mOnTriggerListener != null) { + if (newState == OnTriggerListener.NO_HANDLE) { + mOnTriggerListener.onReleased(this, OnTriggerListener.CENTER_HANDLE); + } else { + mOnTriggerListener.onGrabbed(this, OnTriggerListener.CENTER_HANDLE); + } + mOnTriggerListener.onGrabbedStateChange(this, newState); + } + } + } + + private boolean trySwitchToFirstTouchState(float x, float y) { + final float tx = x - mWaveCenterX; + final float ty = y - mWaveCenterY; + if (mAlwaysTrackFinger || dist2(tx,ty) <= getScaledGlowRadiusSquared()) { + if (DEBUG) Log.v(TAG, "** Handle HIT"); + switchToState(STATE_FIRST_TOUCH, x, y); + updateGlowPosition(tx, ty); + mDragging = true; + return true; + } + return false; + } + + private void assignDefaultsIfNeeded() { + if (mOuterRadius == 0.0f) { + mOuterRadius = Math.max(mOuterRing.getWidth(), mOuterRing.getHeight())/2.0f; + } + if (mHitRadius == 0.0f) { + // Use the radius of inscribed circle of the first target. + mHitRadius = mTargetDrawables.get(0).getWidth() / 2.0f; + } + if (mSnapMargin == 0.0f) { + mSnapMargin = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, + SNAP_MARGIN_DEFAULT, getContext().getResources().getDisplayMetrics()); + } + if (mInnerRadius == 0.0f) { + mInnerRadius = mHandleDrawable.getWidth() / 10.0f; + } + } + + private void computeInsets(int dx, int dy) { + final int layoutDirection = getResolvedLayoutDirection(); + final int absoluteGravity = Gravity.getAbsoluteGravity(mGravity, layoutDirection); + + switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) { + case Gravity.LEFT: + mHorizontalInset = 0; + break; + case Gravity.RIGHT: + mHorizontalInset = dx; + break; + case Gravity.CENTER_HORIZONTAL: + default: + mHorizontalInset = dx / 2; + break; + } + switch (absoluteGravity & Gravity.VERTICAL_GRAVITY_MASK) { + case Gravity.TOP: + mVerticalInset = 0; + break; + case Gravity.BOTTOM: + mVerticalInset = dy; + break; + case Gravity.CENTER_VERTICAL: + default: + mVerticalInset = dy / 2; + break; + } + } + + @Override + protected void onLayout(boolean changed, int left, int top, int right, int bottom) { + super.onLayout(changed, left, top, right, bottom); + final int width = right - left; + final int height = bottom - top; + + // Target placement width/height. This puts the targets on the greater of the ring + // width or the specified outer radius. + final float placementWidth = Math.max(mOuterRing.getWidth(), 2 * mOuterRadius); + final float placementHeight = Math.max(mOuterRing.getHeight(), 2 * mOuterRadius); + float newWaveCenterX = mHorizontalInset + + Math.max(width, mMaxTargetWidth + placementWidth) / 2; + float newWaveCenterY = mVerticalInset + + Math.max(height, + mMaxTargetHeight + placementHeight) / 2; + + if (mInitialLayout) { + stopAndHideWaveAnimation(); + hideTargets(false, false); + mInitialLayout = false; + } + + mOuterRing.setPositionX(newWaveCenterX); + mOuterRing.setPositionY(newWaveCenterY); + + mHandleDrawable.setPositionX(newWaveCenterX); + mHandleDrawable.setPositionY(newWaveCenterY); + + updateTargetPositions(newWaveCenterX, newWaveCenterY); + updatePointCloudPosition(newWaveCenterX, newWaveCenterY); + updateGlowPosition(newWaveCenterX, newWaveCenterY); + + mWaveCenterX = newWaveCenterX; + mWaveCenterY = newWaveCenterY; + + if (DEBUG) dump(); + } + + private void updateTargetPositions(float centerX, float centerY) { + // Reposition the target drawables if the view changed. + ArrayList<TargetDrawable> targets = mTargetDrawables; + final int size = targets.size(); + final float alpha = (float) (-2.0f * Math.PI / size); + for (int i = 0; i < size; i++) { + final TargetDrawable targetIcon = targets.get(i); + final float angle = alpha * i; + targetIcon.setPositionX(centerX); + targetIcon.setPositionY(centerY); + targetIcon.setX(mOuterRadius * (float) Math.cos(angle)); + targetIcon.setY(mOuterRadius * (float) Math.sin(angle)); + } + } + + private void updatePointCloudPosition(float centerX, float centerY) { + mPointCloud.setCenter(centerX, centerY); + } + + @Override + protected void onDraw(Canvas canvas) { + mPointCloud.draw(canvas); + mOuterRing.draw(canvas); + final int ntargets = mTargetDrawables.size(); + for (int i = 0; i < ntargets; i++) { + TargetDrawable target = mTargetDrawables.get(i); + if (target != null) { + target.draw(canvas); + } + } + mHandleDrawable.draw(canvas); + } + + public void setOnTriggerListener(OnTriggerListener listener) { + mOnTriggerListener = listener; + } + + private float square(float d) { + return d * d; + } + + private float dist2(float dx, float dy) { + return dx*dx + dy*dy; + } + + private float getScaledGlowRadiusSquared() { + final float scaledTapRadius; + if (AccessibilityManager.getInstance(mContext).isEnabled()) { + scaledTapRadius = TAP_RADIUS_SCALE_ACCESSIBILITY_ENABLED * mGlowRadius; + } else { + scaledTapRadius = mGlowRadius; + } + return square(scaledTapRadius); + } + + private void announceTargets() { + StringBuilder utterance = new StringBuilder(); + final int targetCount = mTargetDrawables.size(); + for (int i = 0; i < targetCount; i++) { + String targetDescription = getTargetDescription(i); + String directionDescription = getDirectionDescription(i); + if (!TextUtils.isEmpty(targetDescription) + && !TextUtils.isEmpty(directionDescription)) { + String text = String.format(directionDescription, targetDescription); + utterance.append(text); + } + if (utterance.length() > 0) { + announceText(utterance.toString()); + } + } + } + + private void announceText(String text) { + setContentDescription(text); + sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_FOCUSED); + setContentDescription(null); + } + + private String getTargetDescription(int index) { + if (mTargetDescriptions == null || mTargetDescriptions.isEmpty()) { + mTargetDescriptions = loadDescriptions(mTargetDescriptionsResourceId); + if (mTargetDrawables.size() != mTargetDescriptions.size()) { + Log.w(TAG, "The number of target drawables must be" + + " equal to the number of target descriptions."); + return null; + } + } + return mTargetDescriptions.get(index); + } + + private String getDirectionDescription(int index) { + if (mDirectionDescriptions == null || mDirectionDescriptions.isEmpty()) { + mDirectionDescriptions = loadDescriptions(mDirectionDescriptionsResourceId); + if (mTargetDrawables.size() != mDirectionDescriptions.size()) { + Log.w(TAG, "The number of target drawables must be" + + " equal to the number of direction descriptions."); + return null; + } + } + return mDirectionDescriptions.get(index); + } + + private ArrayList<String> loadDescriptions(int resourceId) { + TypedArray array = getContext().getResources().obtainTypedArray(resourceId); + final int count = array.length(); + ArrayList<String> targetContentDescriptions = new ArrayList<String>(count); + for (int i = 0; i < count; i++) { + String contentDescription = array.getString(i); + targetContentDescriptions.add(contentDescription); + } + array.recycle(); + return targetContentDescriptions; + } + + public int getResourceIdForTarget(int index) { + final TargetDrawable drawable = mTargetDrawables.get(index); + return drawable == null ? 0 : drawable.getResourceId(); + } + + public void setEnableTarget(int resourceId, boolean enabled) { + for (int i = 0; i < mTargetDrawables.size(); i++) { + final TargetDrawable target = mTargetDrawables.get(i); + if (target.getResourceId() == resourceId) { + target.setEnabled(enabled); + break; // should never be more than one match + } + } + } + + /** + * Gets the position of a target in the array that matches the given resource. + * @param resourceId + * @return the index or -1 if not found + */ + public int getTargetPosition(int resourceId) { + for (int i = 0; i < mTargetDrawables.size(); i++) { + final TargetDrawable target = mTargetDrawables.get(i); + if (target.getResourceId() == resourceId) { + return i; // should never be more than one match + } + } + return -1; + } + + private boolean replaceTargetDrawables(Resources res, int existingResourceId, + int newResourceId) { + if (existingResourceId == 0 || newResourceId == 0) { + return false; + } + + boolean result = false; + final ArrayList<TargetDrawable> drawables = mTargetDrawables; + final int size = drawables.size(); + for (int i = 0; i < size; i++) { + final TargetDrawable target = drawables.get(i); + if (target != null && target.getResourceId() == existingResourceId) { + target.setDrawable(res, newResourceId); + result = true; + } + } + + if (result) { + requestLayout(); // in case any given drawable's size changes + } + + return result; + } + + /** + * Searches the given package for a resource to use to replace the Drawable on the + * target with the given resource id + * @param component of the .apk that contains the resource + * @param name of the metadata in the .apk + * @param existingResId the resource id of the target to search for + * @return true if found in the given package and replaced at least one target Drawables + */ + public boolean replaceTargetDrawablesIfPresent(ComponentName component, String name, + int existingResId) { + if (existingResId == 0) return false; + + try { + PackageManager packageManager = mContext.getPackageManager(); + // Look for the search icon specified in the activity meta-data + Bundle metaData = packageManager.getActivityInfo( + component, PackageManager.GET_META_DATA).metaData; + if (metaData != null) { + int iconResId = metaData.getInt(name); + if (iconResId != 0) { + Resources res = packageManager.getResourcesForActivity(component); + return replaceTargetDrawables(res, existingResId, iconResId); + } + } + } catch (NameNotFoundException e) { + Log.w(TAG, "Failed to swap drawable; " + + component.flattenToShortString() + " not found", e); + } catch (Resources.NotFoundException nfe) { + Log.w(TAG, "Failed to swap drawable from " + + component.flattenToShortString(), nfe); + } + return false; + } +} diff --git a/core/java/com/android/internal/widget/multiwaveview/MultiWaveView.java b/core/java/com/android/internal/widget/multiwaveview/MultiWaveView.java index 89dbd1b..afeac00 100644 --- a/core/java/com/android/internal/widget/multiwaveview/MultiWaveView.java +++ b/core/java/com/android/internal/widget/multiwaveview/MultiWaveView.java @@ -117,8 +117,6 @@ public class MultiWaveView extends View { private float mWaveCenterY; private int mMaxTargetHeight; private int mMaxTargetWidth; - private float mHorizontalOffset; - private float mVerticalOffset; private float mOuterRadius = 0.0f; private float mHitRadius = 0.0f; @@ -215,9 +213,6 @@ public class MultiWaveView extends View { TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.MultiWaveView); mOuterRadius = a.getDimension(R.styleable.MultiWaveView_outerRadius, mOuterRadius); -// mHorizontalOffset = a.getDimension(R.styleable.MultiWaveView_horizontalOffset, -// mHorizontalOffset); -// mVerticalOffset = a.getDimension(R.styleable.MultiWaveView_verticalOffset, mVerticalOffset); mHitRadius = a.getDimension(R.styleable.MultiWaveView_hitRadius, mHitRadius); mSnapMargin = a.getDimension(R.styleable.MultiWaveView_snapMargin, mSnapMargin); mVibrationDuration = a.getInt(R.styleable.MultiWaveView_vibrationDuration, @@ -230,7 +225,6 @@ public class MultiWaveView extends View { mOuterRing = new TargetDrawable(res, a.peekValue(R.styleable.MultiWaveView_waveDrawable).resourceId); mAlwaysTrackFinger = a.getBoolean(R.styleable.MultiWaveView_alwaysTrackFinger, false); - mGravity = a.getInt(R.styleable.MultiWaveView_gravity, Gravity.TOP); // Read array of chevron drawables TypedValue outValue = new TypedValue(); @@ -244,24 +238,6 @@ public class MultiWaveView extends View { } } - // Support old-style chevron specification if new specification not found - if (mChevronDrawables.size() == 0) { - final int chevronResIds[] = { - R.styleable.MultiWaveView_rightChevronDrawable, - R.styleable.MultiWaveView_topChevronDrawable, - R.styleable.MultiWaveView_leftChevronDrawable, - R.styleable.MultiWaveView_bottomChevronDrawable - }; - - for (int i = 0; i < chevronResIds.length; i++) { - TypedValue typedValue = a.peekValue(chevronResIds[i]); - for (int k = 0; k < mFeedbackCount; k++) { - mChevronDrawables.add( - typedValue != null ? new TargetDrawable(res, typedValue.resourceId) : null); - } - } - } - // Read array of target drawables if (a.getValue(R.styleable.MultiWaveView_targetDrawables, outValue)) { internalSetTargetResources(outValue.resourceId); @@ -289,6 +265,12 @@ public class MultiWaveView extends View { } a.recycle(); + + // Use gravity attribute from LinearLayout + a = context.obtainStyledAttributes(attrs, android.R.styleable.LinearLayout); + mGravity = a.getInt(android.R.styleable.LinearLayout_gravity, Gravity.TOP); + a.recycle(); + setVibrateEnabled(mVibrationDuration > 0); assignDefaultsIfNeeded(); } @@ -302,8 +284,6 @@ public class MultiWaveView extends View { Log.v(TAG, "TapRadius = " + mTapRadius); Log.v(TAG, "WaveCenterX = " + mWaveCenterX); Log.v(TAG, "WaveCenterY = " + mWaveCenterY); - Log.v(TAG, "HorizontalOffset = " + mHorizontalOffset); - Log.v(TAG, "VerticalOffset = " + mVerticalOffset); } public void suspendAnimations() { @@ -1042,9 +1022,9 @@ public class MultiWaveView extends View { // width or the specified outer radius. final float placementWidth = Math.max(mOuterRing.getWidth(), 2 * mOuterRadius); final float placementHeight = Math.max(mOuterRing.getHeight(), 2 * mOuterRadius); - float newWaveCenterX = mHorizontalOffset + mHorizontalInset + float newWaveCenterX = mHorizontalInset + Math.max(width, mMaxTargetWidth + placementWidth) / 2; - float newWaveCenterY = mVerticalOffset + mVerticalInset + float newWaveCenterY = mVerticalInset + Math.max(height, + mMaxTargetHeight + placementHeight) / 2; if (mInitialLayout) { diff --git a/core/java/com/android/internal/widget/multiwaveview/PointCloud.java b/core/java/com/android/internal/widget/multiwaveview/PointCloud.java new file mode 100644 index 0000000..2ef8c78 --- /dev/null +++ b/core/java/com/android/internal/widget/multiwaveview/PointCloud.java @@ -0,0 +1,235 @@ +/* + * Copyright (C) 2012 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.internal.widget.multiwaveview; + +import java.util.ArrayList; + +import android.graphics.Canvas; +import android.graphics.Color; +import android.graphics.Paint; +import android.graphics.drawable.Drawable; +import android.util.FloatMath; +import android.util.Log; + +public class PointCloud { + private static final float MIN_POINT_SIZE = 2.0f; + private static final float MAX_POINT_SIZE = 4.0f; + private static final int INNER_POINTS = 8; + private static final String TAG = "PointCloud"; + private ArrayList<Point> mPointCloud = new ArrayList<Point>(); + private Drawable mDrawable; + private float mCenterX; + private float mCenterY; + private Paint mPaint; + private float mScale = 1.0f; + private static final float PI = (float) Math.PI; + + // These allow us to have multiple concurrent animations. + WaveManager waveManager = new WaveManager(); + GlowManager glowManager = new GlowManager(); + private float mOuterRadius; + + public class WaveManager { + private float radius = 50; + private float width = 200.0f; // TODO: Make configurable + private float alpha = 0.0f; + public void setRadius(float r) { + radius = r; + } + + public float getRadius() { + return radius; + } + + public void setAlpha(float a) { + alpha = a; + } + + public float getAlpha() { + return alpha; + } + }; + + public class GlowManager { + private float x; + private float y; + private float radius = 0.0f; + private float alpha = 0.0f; + + public void setX(float x1) { + x = x1; + } + + public float getX() { + return x; + } + + public void setY(float y1) { + y = y1; + } + + public float getY() { + return y; + } + + public void setAlpha(float a) { + alpha = a; + } + + public float getAlpha() { + return alpha; + } + + public void setRadius(float r) { + radius = r; + } + + public float getRadius() { + return radius; + } + } + + class Point { + float x; + float y; + float radius; + + public Point(float x2, float y2, float r) { + x = (float) x2; + y = (float) y2; + radius = r; + } + } + + public PointCloud(Drawable drawable) { + mPaint = new Paint(); + mPaint.setFilterBitmap(true); + mPaint.setColor(Color.rgb(255, 255, 255)); // TODO: make configurable + mPaint.setAntiAlias(true); + mPaint.setDither(true); + + mDrawable = drawable; + if (mDrawable != null) { + drawable.setBounds(0, 0, drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight()); + } + } + + public void setCenter(float x, float y) { + mCenterX = x; + mCenterY = y; + } + + public void makePointCloud(float innerRadius, float outerRadius) { + if (innerRadius == 0) { + Log.w(TAG, "Must specify an inner radius"); + return; + } + mOuterRadius = outerRadius; + mPointCloud.clear(); + final float pointAreaRadius = (outerRadius - innerRadius); + final float ds = (2.0f * PI * innerRadius / INNER_POINTS); + final int bands = (int) Math.round(pointAreaRadius / ds); + final float dr = pointAreaRadius / bands; + float r = innerRadius; + for (int b = 0; b <= bands; b++, r += dr) { + float circumference = 2.0f * PI * r; + final int pointsInBand = (int) (circumference / ds); + float eta = PI/2.0f; + float dEta = 2.0f * PI / pointsInBand; + for (int i = 0; i < pointsInBand; i++) { + float x = r * FloatMath.cos(eta); + float y = r * FloatMath.sin(eta); + eta += dEta; + mPointCloud.add(new Point(x, y, r)); + } + } + } + + public void setScale(float scale) { + mScale = scale; + } + + public float getScale() { + return mScale; + } + + private static float hypot(float x, float y) { + return FloatMath.sqrt(x*x + y*y); + } + + private static float max(float a, float b) { + return a > b ? a : b; + } + + public int getAlphaForPoint(Point point) { + // Contribution from positional glow + float glowDistance = hypot(glowManager.x - point.x, glowManager.y - point.y); + float glowAlpha = 0.0f; + if (glowDistance < glowManager.radius) { + float cosf = FloatMath.cos(PI * 0.5f * glowDistance / glowManager.radius); + glowAlpha = glowManager.alpha * max(0.0f, (float) Math.pow(cosf, 0.5f)); + } + + // Compute contribution from Wave + float radius = hypot(point.x, point.y); + float distanceToWaveRing = Math.abs(radius - waveManager.radius); + float waveAlpha = 0.0f; + if (distanceToWaveRing < waveManager.width * 0.5f) { + float cosf = FloatMath.cos(PI * 0.5f * distanceToWaveRing / waveManager.width); + waveAlpha = waveManager.alpha * max(0.0f, (float) Math.pow(cosf, 15.0f)); + } + + return (int) (max(glowAlpha, waveAlpha) * 255); + } + + private float interp(float min, float max, float f) { + return min + (max - min) * f; + } + + public void draw(Canvas canvas) { + ArrayList<Point> points = mPointCloud; + final float cx = mDrawable != null ? (-mDrawable.getIntrinsicWidth() / 2) : 0; + final float cy = mDrawable != null ? (-mDrawable.getIntrinsicHeight() / 2) : 0; + canvas.save(Canvas.MATRIX_SAVE_FLAG); + canvas.scale(mScale, mScale, mCenterX, mCenterY); + for (int i = 0; i < points.size(); i++) { + Point point = points.get(i); + final float pointSize = interp(MAX_POINT_SIZE, MIN_POINT_SIZE, + point.radius / mOuterRadius); + final float px = point.x + cx + mCenterX; + final float py = point.y + cy + mCenterY; + int alpha = getAlphaForPoint(point); + + if (alpha == 0) continue; + + if (mDrawable != null) { + canvas.save(Canvas.MATRIX_SAVE_FLAG); + float s = pointSize / MAX_POINT_SIZE; + canvas.scale(s, s, px, py); + canvas.translate(px, py); + mDrawable.setAlpha(alpha); + mDrawable.draw(canvas); + canvas.restore(); + } else { + mPaint.setAlpha(alpha); + canvas.drawCircle(px, py, pointSize, mPaint); + } + } + canvas.restore(); + } + +} |