it = result.iterator();
+ while(it.hasNext()) {
+ TimerObj timer = it.next();
+ if (!timer.isInUse()) {
+ it.remove();
+ }
+ }
+ return result;
+ }
+}
diff --git a/_DeskClock/src/com/android/deskclock/widget/ActionableToastBar.java b/_DeskClock/src/com/android/deskclock/widget/ActionableToastBar.java
new file mode 100644
index 000000000..2e498b5d8
--- /dev/null
+++ b/_DeskClock/src/com/android/deskclock/widget/ActionableToastBar.java
@@ -0,0 +1,232 @@
+/*
+ * 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.deskclock.widget;
+
+import android.animation.Animator;
+import android.animation.AnimatorInflater;
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.View;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import com.android.deskclock.R;
+
+/**
+ * A custom {@link View} that exposes an action to the user.
+ *
+ * This is a copy of packages/apps/UnifiedEmail/src/com/android/mail/ui/ActionableToastBar.java
+ * with minor modifications.
+ */
+public class ActionableToastBar extends LinearLayout {
+ private boolean mHidden = false;
+ private Animator mShowAnimation;
+ private Animator mHideAnimation;
+ private final int mBottomMarginSizeInConversation;
+
+ /** Icon for the description. */
+ private ImageView mActionDescriptionIcon;
+ /** The clickable view */
+ private View mActionButton;
+ /** Icon for the action button. */
+ private View mActionIcon;
+ /** The view that contains the description. */
+ private TextView mActionDescriptionView;
+ /** The view that contains the text for the action button. */
+ private TextView mActionText;
+ //private ToastBarOperation mOperation;
+
+ public ActionableToastBar(Context context) {
+ this(context, null);
+ }
+
+ public ActionableToastBar(Context context, AttributeSet attrs) {
+ this(context, attrs, 0);
+ }
+
+ public ActionableToastBar(Context context, AttributeSet attrs, int defStyle) {
+ super(context, attrs, defStyle);
+ mBottomMarginSizeInConversation = context.getResources().getDimensionPixelSize(
+ R.dimen.toast_bar_bottom_margin_in_conversation);
+ LayoutInflater.from(context).inflate(R.layout.actionable_toast_row, this, true);
+ }
+
+ @Override
+ protected void onFinishInflate() {
+ super.onFinishInflate();
+
+ mActionDescriptionIcon = (ImageView) findViewById(R.id.description_icon);
+ mActionDescriptionView = (TextView) findViewById(R.id.description_text);
+ mActionButton = findViewById(R.id.action_button);
+ mActionIcon = findViewById(R.id.action_icon);
+ mActionText = (TextView) findViewById(R.id.action_text);
+ }
+
+ /**
+ * Tells the view that it will be appearing in the conversation pane
+ * and should adjust its layout parameters accordingly.
+ * @param isInConversationMode true if the view will be shown in the conversation view
+ */
+ public void setConversationMode(boolean isInConversationMode) {
+ final FrameLayout.LayoutParams params = (FrameLayout.LayoutParams) getLayoutParams();
+ params.bottomMargin = isInConversationMode ? mBottomMarginSizeInConversation : 0;
+ setLayoutParams(params);
+ }
+
+ /**
+ * Displays the toast bar and makes it visible. Allows the setting of
+ * parameters to customize the display.
+ * @param listener performs some action when the action button is clicked
+ * @param descriptionIconResourceId resource ID for the description icon or
+ * 0 if no icon should be shown
+ * @param descriptionText a description text to show in the toast bar
+ * @param showActionIcon if true, the action button icon should be shown
+ * @param actionTextResource resource ID for the text to show in the action button
+ * @param replaceVisibleToast if true, this toast should replace any currently visible toast.
+ * Otherwise, skip showing this toast.
+ */
+ public void show(final ActionClickedListener listener, int descriptionIconResourceId,
+ CharSequence descriptionText, boolean showActionIcon, int actionTextResource,
+ boolean replaceVisibleToast) {
+
+ if (!mHidden && !replaceVisibleToast) {
+ return;
+ }
+
+ mActionButton.setOnClickListener(new OnClickListener() {
+ @Override
+ public void onClick(View widget) {
+ if (listener != null) {
+ listener.onActionClicked();
+ }
+ hide(true);
+ }
+ });
+
+ // Set description icon.
+ if (descriptionIconResourceId == 0) {
+ mActionDescriptionIcon.setVisibility(GONE);
+ } else {
+ mActionDescriptionIcon.setVisibility(VISIBLE);
+ mActionDescriptionIcon.setImageResource(descriptionIconResourceId);
+ }
+
+ mActionDescriptionView.setText(descriptionText);
+ mActionIcon.setVisibility(showActionIcon ? VISIBLE : GONE);
+ mActionText.setText(actionTextResource);
+
+ mHidden = false;
+ getShowAnimation().start();
+ }
+
+ /**
+ * Hides the view and resets the state.
+ */
+ public void hide(boolean animate) {
+ // Prevent multiple call to hide.
+ // Also prevent hiding if show animation is going on.
+ if (!mHidden && !getShowAnimation().isRunning()) {
+ mHidden = true;
+ if (getVisibility() == View.VISIBLE) {
+ mActionDescriptionView.setText("");
+ mActionButton.setOnClickListener(null);
+ // Hide view once it's clicked.
+ if (animate) {
+ getHideAnimation().start();
+ } else {
+ setAlpha(0);
+ setVisibility(View.GONE);
+ }
+ }
+ }
+ }
+
+ private Animator getShowAnimation() {
+ if (mShowAnimation == null) {
+ mShowAnimation = AnimatorInflater.loadAnimator(getContext(),
+ R.anim.fade_in);
+ mShowAnimation.addListener(new Animator.AnimatorListener() {
+ @Override
+ public void onAnimationStart(Animator animation) {
+ setVisibility(View.VISIBLE);
+ }
+ @Override
+ public void onAnimationEnd(Animator animation) {
+ // There is a tiny change that and hide animation could have finished right
+ // before the show animation finished. In that case, the hide will mark the
+ // view as GONE. We need to make sure the last one wins.
+ setVisibility(View.VISIBLE);
+ }
+ @Override
+ public void onAnimationCancel(Animator animation) {
+ }
+ @Override
+ public void onAnimationRepeat(Animator animation) {
+ }
+ });
+ mShowAnimation.setTarget(this);
+ }
+ return mShowAnimation;
+ }
+
+ private Animator getHideAnimation() {
+ if (mHideAnimation == null) {
+ mHideAnimation = AnimatorInflater.loadAnimator(getContext(),
+ R.anim.fade_out);
+ mHideAnimation.addListener(new Animator.AnimatorListener() {
+ @Override
+ public void onAnimationStart(Animator animation) {
+ }
+ @Override
+ public void onAnimationRepeat(Animator animation) {
+ }
+ @Override
+ public void onAnimationEnd(Animator animation) {
+ setVisibility(View.GONE);
+ }
+ @Override
+ public void onAnimationCancel(Animator animation) {
+ }
+ });
+ mHideAnimation.setTarget(this);
+ }
+ return mHideAnimation;
+ }
+
+ public boolean isEventInToastBar(MotionEvent event) {
+ if (!isShown()) {
+ return false;
+ }
+ int[] xy = new int[2];
+ float x = event.getX();
+ float y = event.getY();
+ getLocationOnScreen(xy);
+ return (x > xy[0] && x < (xy[0] + getWidth()) && y > xy[1] && y < xy[1] + getHeight());
+ }
+
+ /**
+ * Classes that wish to perform some action when the action button is clicked
+ * should implement this interface.
+ */
+ public interface ActionClickedListener {
+ public void onActionClicked();
+ }
+}
diff --git a/_DeskClock/src/com/android/deskclock/widget/EllipsizeLayout.java b/_DeskClock/src/com/android/deskclock/widget/EllipsizeLayout.java
new file mode 100644
index 000000000..2976f82b6
--- /dev/null
+++ b/_DeskClock/src/com/android/deskclock/widget/EllipsizeLayout.java
@@ -0,0 +1,73 @@
+package com.android.deskclock.widget;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.View;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+/**
+ * When this layout is in the Horizontal orientation and one and only one child
+ * is a TextView with a non-null android:ellipsize, this layout will reduce
+ * android:maxWidth of that TextView to ensure the other children are within the
+ * layout. This layout has no effect if the children have weights.
+ */
+public class EllipsizeLayout extends LinearLayout {
+
+ public EllipsizeLayout(Context context) {
+ this(context, null);
+ }
+
+ public EllipsizeLayout(Context context, AttributeSet attrs) {
+ super(context, attrs);
+ }
+
+ @Override
+ protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+ if (getOrientation() == HORIZONTAL
+ && (MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.EXACTLY)) {
+ int totalLength = 0;
+ boolean outOfSpec = false;
+ TextView ellipView = null;
+ final int count = getChildCount();
+
+ for (int ii = 0; ii < count && !outOfSpec; ++ii) {
+ final View child = getChildAt(ii);
+ if (child != null && child.getVisibility() != GONE) {
+ if (child instanceof TextView) {
+ final TextView tv = (TextView) child;
+ if (tv.getEllipsize() != null) {
+ if (ellipView == null) {
+ ellipView = tv;
+ // clear maxWidth on mEllipView before measure
+ ellipView.setMaxWidth(Integer.MAX_VALUE);
+ } else {
+ // TODO: support multiple android:ellipsize
+ outOfSpec = true;
+ }
+ }
+ }
+ final LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child
+ .getLayoutParams();
+ outOfSpec |= (lp.weight > 0f);
+ measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);
+ totalLength += child.getMeasuredWidth() + lp.leftMargin + lp.rightMargin;
+ }
+ }
+ outOfSpec |= (ellipView == null) || (totalLength == 0);
+ final int parentWidth = MeasureSpec.getSize(widthMeasureSpec);
+
+ if (!outOfSpec && totalLength > parentWidth) {
+ int maxWidth = ellipView.getMeasuredWidth() - (totalLength - parentWidth);
+ // TODO: Respect android:minWidth (easy with @TargetApi(16))
+ int minWidth = 0;
+ if (maxWidth < minWidth) {
+ maxWidth = minWidth;
+ }
+ ellipView.setMaxWidth(maxWidth);
+ }
+ }
+
+ super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+ }
+}
diff --git a/_DeskClock/src/com/android/deskclock/widget/multiwaveview/Ease.java b/_DeskClock/src/com/android/deskclock/widget/multiwaveview/Ease.java
new file mode 100644
index 000000000..3074026c6
--- /dev/null
+++ b/_DeskClock/src/com/android/deskclock/widget/multiwaveview/Ease.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2011 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.deskclock.widget.multiwaveview;
+
+import android.animation.TimeInterpolator;
+
+class Ease {
+ private static final float DOMAIN = 1.0f;
+ private static final float DURATION = 1.0f;
+ private static final float START = 0.0f;
+
+ static class Linear {
+ public static final TimeInterpolator easeNone = new TimeInterpolator() {
+ public float getInterpolation(float input) {
+ return input;
+ }
+ };
+ }
+
+ static class Cubic {
+ public static final TimeInterpolator easeIn = new TimeInterpolator() {
+ public float getInterpolation(float input) {
+ return DOMAIN*(input/=DURATION)*input*input + START;
+ }
+ };
+ public static final TimeInterpolator easeOut = new TimeInterpolator() {
+ public float getInterpolation(float input) {
+ return DOMAIN*((input=input/DURATION-1)*input*input + 1) + START;
+ }
+ };
+ public static final TimeInterpolator easeInOut = new TimeInterpolator() {
+ public float getInterpolation(float input) {
+ return ((input/=DURATION/2) < 1.0f) ?
+ (DOMAIN/2*input*input*input + START)
+ : (DOMAIN/2*((input-=2)*input*input + 2) + START);
+ }
+ };
+ }
+
+ static class Quad {
+ public static final TimeInterpolator easeIn = new TimeInterpolator() {
+ public float getInterpolation (float input) {
+ return DOMAIN*(input/=DURATION)*input + START;
+ }
+ };
+ public static final TimeInterpolator easeOut = new TimeInterpolator() {
+ public float getInterpolation(float input) {
+ return -DOMAIN *(input/=DURATION)*(input-2) + START;
+ }
+ };
+ public static final TimeInterpolator easeInOut = new TimeInterpolator() {
+ public float getInterpolation(float input) {
+ return ((input/=DURATION/2) < 1) ?
+ (DOMAIN/2*input*input + START)
+ : (-DOMAIN/2 * ((--input)*(input-2) - 1) + START);
+ }
+ };
+ }
+
+ static class Quart {
+ public static final TimeInterpolator easeIn = new TimeInterpolator() {
+ public float getInterpolation(float input) {
+ return DOMAIN*(input/=DURATION)*input*input*input + START;
+ }
+ };
+ public static final TimeInterpolator easeOut = new TimeInterpolator() {
+ public float getInterpolation(float input) {
+ return -DOMAIN * ((input=input/DURATION-1)*input*input*input - 1) + START;
+ }
+ };
+ public static final TimeInterpolator easeInOut = new TimeInterpolator() {
+ public float getInterpolation(float input) {
+ return ((input/=DURATION/2) < 1) ?
+ (DOMAIN/2*input*input*input*input + START)
+ : (-DOMAIN/2 * ((input-=2)*input*input*input - 2) + START);
+ }
+ };
+ }
+
+ static class Quint {
+ public static final TimeInterpolator easeIn = new TimeInterpolator() {
+ public float getInterpolation(float input) {
+ return DOMAIN*(input/=DURATION)*input*input*input*input + START;
+ }
+ };
+ public static final TimeInterpolator easeOut = new TimeInterpolator() {
+ public float getInterpolation(float input) {
+ return DOMAIN*((input=input/DURATION-1)*input*input*input*input + 1) + START;
+ }
+ };
+ public static final TimeInterpolator easeInOut = new TimeInterpolator() {
+ public float getInterpolation(float input) {
+ return ((input/=DURATION/2) < 1) ?
+ (DOMAIN/2*input*input*input*input*input + START)
+ : (DOMAIN/2*((input-=2)*input*input*input*input + 2) + START);
+ }
+ };
+ }
+
+ static class Sine {
+ public static final TimeInterpolator easeIn = new TimeInterpolator() {
+ public float getInterpolation(float input) {
+ return -DOMAIN * (float) Math.cos(input/DURATION * (Math.PI/2)) + DOMAIN + START;
+ }
+ };
+ public static final TimeInterpolator easeOut = new TimeInterpolator() {
+ public float getInterpolation(float input) {
+ return DOMAIN * (float) Math.sin(input/DURATION * (Math.PI/2)) + START;
+ }
+ };
+ public static final TimeInterpolator easeInOut = new TimeInterpolator() {
+ public float getInterpolation(float input) {
+ return -DOMAIN/2 * ((float)Math.cos(Math.PI*input/DURATION) - 1.0f) + START;
+ }
+ };
+ }
+
+}
diff --git a/_DeskClock/src/com/android/deskclock/widget/multiwaveview/GlowPadView.java b/_DeskClock/src/com/android/deskclock/widget/multiwaveview/GlowPadView.java
new file mode 100644
index 000000000..b296f4c77
--- /dev/null
+++ b/_DeskClock/src/com/android/deskclock/widget/multiwaveview/GlowPadView.java
@@ -0,0 +1,1261 @@
+/*
+ * 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.deskclock.widget.multiwaveview;
+
+import java.util.ArrayList;
+
+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.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.AccessibilityManager;
+
+import com.android.deskclock.R;
+
+/**
+ * This is a copy of com.android.internal.widget.multiwaveview.GlowPadView with minor changes
+ * to remove dependencies on private api's.
+ *
+ * Contains changes up to If296b60af2421bfa1a9a082e608ba77b2392a218
+ *
+ * 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 = 1350;
+ 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 mTargetDrawables = new ArrayList();
+ private AnimationBundle mWaveAnimations = new AnimationBundle();
+ private AnimationBundle mTargetAnimations = new AnimationBundle();
+ private AnimationBundle mGlowAnimations = new AnimationBundle();
+ private ArrayList mTargetDescriptions;
+ private ArrayList 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 mSnapMargin = 0.0f;
+ private boolean mDragging;
+ private int mNewTargetResources;
+
+ private class AnimationBundle extends ArrayList {
+ 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;
+ private int mPointerId;
+
+ 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);
+ mSnapMargin = a.getDimension(R.styleable.GlowPadView_snapMargin, mSnapMargin);
+ mVibrationDuration = a.getInt(R.styleable.GlowPadView_vibrationDuration,
+ mVibrationDuration);
+ mFeedbackCount = a.getInt(R.styleable.GlowPadView_feedbackCount,
+ mFeedbackCount);
+ TypedValue handle = a.peekValue(R.styleable.GlowPadView_handleDrawable);
+ mHandleDrawable = new TargetDrawable(res, handle != null ? handle.resourceId : 0, 2);
+ mHandleDrawable.setState(TargetDrawable.STATE_INACTIVE);
+ mOuterRing = new TargetDrawable(res,
+ getResourceId(a, R.styleable.GlowPadView_outerRingDrawable), 1);
+
+ 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, R.styleable.LinearLayout);
+ mGravity = a.getInt(R.styleable.GlowPadView_android_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, "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);
+
+ final AccessibilityManager accessibilityManager =
+ (AccessibilityManager) getContext().getSystemService(
+ Context.ACCESSIBILITY_SERVICE);
+ if (accessibilityManager.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 loadDrawableArray(int resourceId) {
+ Resources res = getContext().getResources();
+ TypedArray array = res.obtainTypedArray(resourceId);
+ final int count = array.length();
+ ArrayList drawables = new ArrayList(count);
+ for (int i = 0; i < count; i++) {
+ TypedValue value = array.peekValue(i);
+ TargetDrawable target = new TargetDrawable(res, value != null ? value.resourceId : 0, 3);
+ drawables.add(target);
+ }
+ array.recycle();
+ return drawables;
+ }
+
+ private void internalSetTargetResources(int resourceId) {
+ final ArrayList 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) {
+ boolean doWaveAnimation = true;
+ final AnimationBundle waveAnimations = mWaveAnimations;
+
+ // Don't do a wave if there's already one in progress
+ if (waveAnimations.size() > 0 && waveAnimations.get(0).animator.isRunning()) {
+ long t = waveAnimations.get(0).animator.getCurrentPlayTime();
+ if (t < WAVE_ANIMATION_DURATION/2) {
+ doWaveAnimation = false;
+ }
+ }
+
+ if (doWaveAnimation) {
+ 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.Quad.easeOut,
+ "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, 0.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.getActionMasked();
+ boolean handled = false;
+ switch (action) {
+ case MotionEvent.ACTION_POINTER_DOWN:
+ 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_POINTER_UP:
+ 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) {
+ int actionIndex = event.getActionIndex();
+ float eventX = event.getX(actionIndex);
+ float eventY = event.getY(actionIndex);
+ switchToState(STATE_START, eventX, eventY);
+ if (!trySwitchToFirstTouchState(eventX, eventY)) {
+ mDragging = false;
+ } else {
+ mPointerId = event.getPointerId(actionIndex);
+ updateGlowPosition(eventX, eventY);
+ }
+ }
+
+ private void handleUp(MotionEvent event) {
+ if (DEBUG && mDragging) Log.v(TAG, "** Handle RELEASE");
+ int actionIndex = event.getActionIndex();
+ if (event.getPointerId(actionIndex) == mPointerId) {
+ switchToState(STATE_FINISH, event.getX(actionIndex), event.getY(actionIndex));
+ }
+ }
+
+ 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.
+
+ int actionIndex = event.findPointerIndex(mPointerId);
+ actionIndex = actionIndex == -1 ? 0 : actionIndex;
+ switchToState(STATE_FINISH, event.getX(actionIndex), event.getY(actionIndex));
+ }
+
+ private void handleMove(MotionEvent event) {
+ int activeTarget = -1;
+ final int historySize = event.getHistorySize();
+ ArrayList targets = mTargetDrawables;
+ int ntargets = targets.size();
+ float x = 0.0f;
+ float y = 0.0f;
+ int actionIndex = event.findPointerIndex(mPointerId);
+
+ if (actionIndex == -1) {
+ return; // no data for this pointer
+ }
+
+ for (int k = 0; k < historySize + 1; k++) {
+ float eventX = k < historySize ? event.getHistoricalX(actionIndex, k)
+ : event.getX(actionIndex);
+ float eventY = k < historySize ? event.getHistoricalY(actionIndex, k)
+ :event.getY(actionIndex);
+ // 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;
+ double angleRad = Math.atan2(-ty, tx);
+
+ if (!mDragging) {
+ trySwitchToFirstTouchState(eventX, eventY);
+ }
+
+ if (mDragging) {
+ // For multiple targets, snap to the one that matches
+ final float snapRadius = mOuterRadius - mSnapMargin;
+ final float snapDistance2 = snapRadius * snapRadius;
+ // Find first target in range
+ for (int i = 0; i < ntargets; i++) {
+ TargetDrawable target = targets.get(i);
+
+ double targetMinRad = (i - 0.5) * 2 * Math.PI / ntargets;
+ double targetMaxRad = (i + 0.5) * 2 * Math.PI / ntargets;
+ if (target.isEnabled()) {
+ boolean angleMatches =
+ (angleRad > targetMinRad && angleRad <= targetMaxRad) ||
+ (angleRad + 2 * Math.PI > targetMinRad &&
+ angleRad + 2 * Math.PI <= targetMaxRad);
+ if (angleMatches && (dist2(tx, ty) > snapDistance2)) {
+ activeTarget = i;
+ }
+ }
+ }
+ }
+ x = limitX;
+ y = limitY;
+ }
+
+ if (!mDragging) {
+ return;
+ }
+
+ if (activeTarget != -1) {
+ switchToState(STATE_SNAP, x,y);
+ updateGlowPosition(x, y);
+ } else {
+ switchToState(STATE_TRACKING, x, y);
+ updateGlowPosition(x, y);
+ }
+
+ if (mActiveTarget != activeTarget) {
+ // Defocus the old target
+ if (mActiveTarget != -1) {
+ TargetDrawable target = targets.get(mActiveTarget);
+ target.setState(TargetDrawable.STATE_INACTIVE);
+ }
+ // Focus the new target
+ if (activeTarget != -1) {
+ TargetDrawable target = targets.get(activeTarget);
+ target.setState(TargetDrawable.STATE_FOCUSED);
+ final AccessibilityManager accessibilityManager =
+ (AccessibilityManager) getContext().getSystemService(
+ Context.ACCESSIBILITY_SERVICE);
+ if (accessibilityManager.isEnabled()) {
+ String targetContentDescription = getTargetDescription(activeTarget);
+ announceForAccessibility(targetContentDescription);
+ }
+ }
+ }
+ mActiveTarget = activeTarget;
+ }
+
+ @Override
+ public boolean onHoverEvent(MotionEvent event) {
+ final AccessibilityManager accessibilityManager =
+ (AccessibilityManager) getContext().getSystemService(
+ Context.ACCESSIBILITY_SERVICE);
+ if (accessibilityManager.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);
+ }
+ super.onHoverEvent(event);
+ return true;
+ }
+
+ /**
+ * 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 (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 = getLayoutDirection();
+ 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 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;
+ final AccessibilityManager accessibilityManager =
+ (AccessibilityManager) getContext().getSystemService(
+ Context.ACCESSIBILITY_SERVICE);
+ if (accessibilityManager.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) {
+ announceForAccessibility(utterance.toString());
+ }
+ }
+
+ 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 loadDescriptions(int resourceId) {
+ TypedArray array = getContext().getResources().obtainTypedArray(resourceId);
+ final int count = array.length();
+ ArrayList targetContentDescriptions = new ArrayList(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 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;
+
+ boolean replaced = false;
+ if (component != null) {
+ try {
+ PackageManager packageManager = getContext().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);
+ replaced = 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);
+ }
+ }
+ if (!replaced) {
+ // Restore the original drawable
+ replaceTargetDrawables(getContext().getResources(), existingResId, existingResId);
+ }
+ return replaced;
+ }
+}
diff --git a/_DeskClock/src/com/android/deskclock/widget/multiwaveview/PointCloud.java b/_DeskClock/src/com/android/deskclock/widget/multiwaveview/PointCloud.java
new file mode 100644
index 000000000..c1b0c1ac8
--- /dev/null
+++ b/_DeskClock/src/com/android/deskclock/widget/multiwaveview/PointCloud.java
@@ -0,0 +1,236 @@
+/*
+ * 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.deskclock.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 mPointCloud = new ArrayList();
+ 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.25f * glowDistance / glowManager.radius);
+ glowAlpha = glowManager.alpha * max(0.0f, (float) Math.pow(cosf, 10.0f));
+ }
+
+ // Compute contribution from Wave
+ float radius = hypot(point.x, point.y);
+ float distanceToWaveRing = (radius - waveManager.radius);
+ float waveAlpha = 0.0f;
+ if (distanceToWaveRing < waveManager.width * 0.5f && distanceToWaveRing < 0.0f) {
+ float cosf = FloatMath.cos(PI * 0.25f * distanceToWaveRing / waveManager.width);
+ waveAlpha = waveManager.alpha * max(0.0f, (float) Math.pow(cosf, 20.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 points = mPointCloud;
+ 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 + mCenterX;
+ final float py = point.y + mCenterY;
+ int alpha = getAlphaForPoint(point);
+
+ if (alpha == 0) continue;
+
+ if (mDrawable != null) {
+ canvas.save(Canvas.MATRIX_SAVE_FLAG);
+ final float cx = mDrawable.getIntrinsicWidth() * 0.5f;
+ final float cy = mDrawable.getIntrinsicHeight() * 0.5f;
+ final float s = pointSize / MAX_POINT_SIZE;
+ canvas.scale(s, s, px, py);
+ canvas.translate(px - cx, py - cy);
+ mDrawable.setAlpha(alpha);
+ mDrawable.draw(canvas);
+ canvas.restore();
+ } else {
+ mPaint.setAlpha(alpha);
+ canvas.drawCircle(px, py, pointSize, mPaint);
+ }
+ }
+ canvas.restore();
+ }
+
+}
diff --git a/_DeskClock/src/com/android/deskclock/widget/multiwaveview/TargetDrawable.java b/_DeskClock/src/com/android/deskclock/widget/multiwaveview/TargetDrawable.java
new file mode 100644
index 000000000..d6a207a18
--- /dev/null
+++ b/_DeskClock/src/com/android/deskclock/widget/multiwaveview/TargetDrawable.java
@@ -0,0 +1,267 @@
+/*
+ * Copyright (C) 2011 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.deskclock.widget.multiwaveview;
+
+import android.content.res.Resources;
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.StateListDrawable;
+import android.util.Log;
+
+public class TargetDrawable {
+ private static final String TAG = "TargetDrawable";
+ private static final boolean DEBUG = false;
+
+ public static final int[] STATE_ACTIVE =
+ { android.R.attr.state_enabled, android.R.attr.state_active };
+ public static final int[] STATE_INACTIVE =
+ { android.R.attr.state_enabled, -android.R.attr.state_active };
+ public static final int[] STATE_FOCUSED =
+ { android.R.attr.state_enabled, -android.R.attr.state_active,
+ android.R.attr.state_focused };
+
+ private float mTranslationX = 0.0f;
+ private float mTranslationY = 0.0f;
+ private float mPositionX = 0.0f;
+ private float mPositionY = 0.0f;
+ private float mScaleX = 1.0f;
+ private float mScaleY = 1.0f;
+ private float mAlpha = 1.0f;
+ private Drawable mDrawable;
+ private boolean mEnabled = true;
+ private final int mResourceId;
+ private int mNumDrawables = 1;
+
+ /* package */ static class DrawableWithAlpha extends Drawable {
+ private float mAlpha = 1.0f;
+ private Drawable mRealDrawable;
+ public DrawableWithAlpha(Drawable realDrawable) {
+ mRealDrawable = realDrawable;
+ }
+ public void setAlpha(float alpha) {
+ mAlpha = alpha;
+ }
+ public float getAlpha() {
+ return mAlpha;
+ }
+ public void draw(Canvas canvas) {
+ mRealDrawable.setAlpha((int) Math.round(mAlpha * 255f));
+ mRealDrawable.draw(canvas);
+ }
+ @Override
+ public void setAlpha(int alpha) {
+ mRealDrawable.setAlpha(alpha);
+ }
+ @Override
+ public void setColorFilter(ColorFilter cf) {
+ mRealDrawable.setColorFilter(cf);
+ }
+ @Override
+ public int getOpacity() {
+ return mRealDrawable.getOpacity();
+ }
+ }
+
+ /**
+ * This is changed from the framework version to pass in the number of drawables in the
+ * container. The framework version relies on private api's to get the count from
+ * StateListDrawable.
+ *
+ * @param res
+ * @param resId
+ * @param count The number of drawables in the resource.
+ */
+ public TargetDrawable(Resources res, int resId, int count) {
+ mResourceId = resId;
+ setDrawable(res, resId);
+ mNumDrawables = count;
+ }
+
+ public void setDrawable(Resources res, int resId) {
+ // Note we explicitly don't set mResourceId to resId since we allow the drawable to be
+ // swapped at runtime and want to re-use the existing resource id for identification.
+ Drawable drawable = resId == 0 ? null : res.getDrawable(resId);
+ // Mutate the drawable so we can animate shared drawable properties.
+ mDrawable = drawable != null ? drawable.mutate() : null;
+ resizeDrawables();
+ setState(STATE_INACTIVE);
+ }
+
+ public TargetDrawable(TargetDrawable other) {
+ mResourceId = other.mResourceId;
+ // Mutate the drawable so we can animate shared drawable properties.
+ mDrawable = other.mDrawable != null ? other.mDrawable.mutate() : null;
+ resizeDrawables();
+ setState(STATE_INACTIVE);
+ }
+
+ public void setState(int [] state) {
+ if (mDrawable instanceof StateListDrawable) {
+ StateListDrawable d = (StateListDrawable) mDrawable;
+ d.setState(state);
+ }
+ }
+
+ /**
+ * Returns true if the drawable is a StateListDrawable and is in the focused state.
+ *
+ * @return
+ */
+ public boolean isActive() {
+ if (mDrawable instanceof StateListDrawable) {
+ StateListDrawable d = (StateListDrawable) mDrawable;
+ int[] states = d.getState();
+ for (int i = 0; i < states.length; i++) {
+ if (states[i] == android.R.attr.state_focused) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Returns true if this target is enabled. Typically an enabled target contains a valid
+ * drawable in a valid state. Currently all targets with valid drawables are valid.
+ *
+ * @return
+ */
+ public boolean isEnabled() {
+ return mDrawable != null && mEnabled;
+ }
+
+ /**
+ * Makes drawables in a StateListDrawable all the same dimensions.
+ * If not a StateListDrawable, then justs sets the bounds to the intrinsic size of the
+ * drawable.
+ */
+ private void resizeDrawables() {
+ if (mDrawable instanceof StateListDrawable) {
+ StateListDrawable d = (StateListDrawable) mDrawable;
+ int maxWidth = 0;
+ int maxHeight = 0;
+
+ for (int i = 0; i < mNumDrawables; i++) {
+ d.selectDrawable(i);
+ Drawable childDrawable = d.getCurrent();
+ maxWidth = Math.max(maxWidth, childDrawable.getIntrinsicWidth());
+ maxHeight = Math.max(maxHeight, childDrawable.getIntrinsicHeight());
+ }
+
+ if (DEBUG) Log.v(TAG, "union of childDrawable rects " + d + " to: "
+ + maxWidth + "x" + maxHeight);
+ d.setBounds(0, 0, maxWidth, maxHeight);
+
+ for (int i = 0; i < mNumDrawables; i++) {
+ d.selectDrawable(i);
+ Drawable childDrawable = d.getCurrent();
+ if (DEBUG) Log.v(TAG, "sizing drawable " + childDrawable + " to: "
+ + maxWidth + "x" + maxHeight);
+ childDrawable.setBounds(0, 0, maxWidth, maxHeight);
+ }
+ } else if (mDrawable != null) {
+ mDrawable.setBounds(0, 0,
+ mDrawable.getIntrinsicWidth(), mDrawable.getIntrinsicHeight());
+ }
+ }
+
+ public void setX(float x) {
+ mTranslationX = x;
+ }
+
+ public void setY(float y) {
+ mTranslationY = y;
+ }
+
+ public void setScaleX(float x) {
+ mScaleX = x;
+ }
+
+ public void setScaleY(float y) {
+ mScaleY = y;
+ }
+
+ public void setAlpha(float alpha) {
+ mAlpha = alpha;
+ }
+
+ public float getX() {
+ return mTranslationX;
+ }
+
+ public float getY() {
+ return mTranslationY;
+ }
+
+ public float getScaleX() {
+ return mScaleX;
+ }
+
+ public float getScaleY() {
+ return mScaleY;
+ }
+
+ public float getAlpha() {
+ return mAlpha;
+ }
+
+ public void setPositionX(float x) {
+ mPositionX = x;
+ }
+
+ public void setPositionY(float y) {
+ mPositionY = y;
+ }
+
+ public float getPositionX() {
+ return mPositionX;
+ }
+
+ public float getPositionY() {
+ return mPositionY;
+ }
+
+ public int getWidth() {
+ return mDrawable != null ? mDrawable.getIntrinsicWidth() : 0;
+ }
+
+ public int getHeight() {
+ return mDrawable != null ? mDrawable.getIntrinsicHeight() : 0;
+ }
+
+ public void draw(Canvas canvas) {
+ if (mDrawable == null || !mEnabled) {
+ return;
+ }
+ canvas.save(Canvas.MATRIX_SAVE_FLAG);
+ canvas.scale(mScaleX, mScaleY, mPositionX, mPositionY);
+ canvas.translate(mTranslationX + mPositionX, mTranslationY + mPositionY);
+ canvas.translate(-0.5f * getWidth(), -0.5f * getHeight());
+ mDrawable.setAlpha((int) Math.round(mAlpha * 255f));
+ mDrawable.draw(canvas);
+ canvas.restore();
+ }
+
+ public void setEnabled(boolean enabled) {
+ mEnabled = enabled;
+ }
+
+ public int getResourceId() {
+ return mResourceId;
+ }
+}
diff --git a/_DeskClock/src/com/android/deskclock/widget/multiwaveview/Tweener.java b/_DeskClock/src/com/android/deskclock/widget/multiwaveview/Tweener.java
new file mode 100644
index 000000000..1672cfd37
--- /dev/null
+++ b/_DeskClock/src/com/android/deskclock/widget/multiwaveview/Tweener.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2011 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.deskclock.widget.multiwaveview;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map.Entry;
+
+import android.animation.Animator;
+import android.animation.Animator.AnimatorListener;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ObjectAnimator;
+import android.animation.PropertyValuesHolder;
+import android.animation.TimeInterpolator;
+import android.animation.ValueAnimator.AnimatorUpdateListener;
+import android.util.Log;
+
+class Tweener {
+ private static final String TAG = "Tweener";
+ private static final boolean DEBUG = false;
+
+ ObjectAnimator animator;
+ private static HashMap sTweens = new HashMap();
+
+ public Tweener(ObjectAnimator anim) {
+ animator = anim;
+ }
+
+ private static void remove(Animator animator) {
+ Iterator> iter = sTweens.entrySet().iterator();
+ while (iter.hasNext()) {
+ Entry entry = iter.next();
+ if (entry.getValue().animator == animator) {
+ if (DEBUG) Log.v(TAG, "Removing tweener " + sTweens.get(entry.getKey())
+ + " sTweens.size() = " + sTweens.size());
+ iter.remove();
+ break; // an animator can only be attached to one object
+ }
+ }
+ }
+
+ public static Tweener to(Object object, long duration, Object... vars) {
+ long delay = 0;
+ AnimatorUpdateListener updateListener = null;
+ AnimatorListener listener = null;
+ TimeInterpolator interpolator = null;
+
+ // Iterate through arguments and discover properties to animate
+ ArrayList props = new ArrayList(vars.length/2);
+ for (int i = 0; i < vars.length; i+=2) {
+ if (!(vars[i] instanceof String)) {
+ throw new IllegalArgumentException("Key must be a string: " + vars[i]);
+ }
+ String key = (String) vars[i];
+ Object value = vars[i+1];
+
+ if ("simultaneousTween".equals(key)) {
+ // TODO
+ } else if ("ease".equals(key)) {
+ interpolator = (TimeInterpolator) value; // TODO: multiple interpolators?
+ } else if ("onUpdate".equals(key) || "onUpdateListener".equals(key)) {
+ updateListener = (AnimatorUpdateListener) value;
+ } else if ("onComplete".equals(key) || "onCompleteListener".equals(key)) {
+ listener = (AnimatorListener) value;
+ } else if ("delay".equals(key)) {
+ delay = ((Number) value).longValue();
+ } else if ("syncWith".equals(key)) {
+ // TODO
+ } else if (value instanceof float[]) {
+ props.add(PropertyValuesHolder.ofFloat(key,
+ ((float[])value)[0], ((float[])value)[1]));
+ } else if (value instanceof int[]) {
+ props.add(PropertyValuesHolder.ofInt(key,
+ ((int[])value)[0], ((int[])value)[1]));
+ } else if (value instanceof Number) {
+ float floatValue = ((Number)value).floatValue();
+ props.add(PropertyValuesHolder.ofFloat(key, floatValue));
+ } else {
+ throw new IllegalArgumentException(
+ "Bad argument for key \"" + key + "\" with value " + value.getClass());
+ }
+ }
+
+ // Re-use existing tween, if present
+ Tweener tween = sTweens.get(object);
+ ObjectAnimator anim = null;
+ if (tween == null) {
+ anim = ObjectAnimator.ofPropertyValuesHolder(object,
+ props.toArray(new PropertyValuesHolder[props.size()]));
+ tween = new Tweener(anim);
+ sTweens.put(object, tween);
+ if (DEBUG) Log.v(TAG, "Added new Tweener " + tween);
+ } else {
+ anim = sTweens.get(object).animator;
+ replace(props, object); // Cancel all animators for given object
+ }
+
+ if (interpolator != null) {
+ anim.setInterpolator(interpolator);
+ }
+
+ // Update animation with properties discovered in loop above
+ anim.setStartDelay(delay);
+ anim.setDuration(duration);
+ if (updateListener != null) {
+ anim.removeAllUpdateListeners(); // There should be only one
+ anim.addUpdateListener(updateListener);
+ }
+ if (listener != null) {
+ anim.removeAllListeners(); // There should be only one.
+ anim.addListener(listener);
+ }
+ anim.addListener(mCleanupListener);
+
+ return tween;
+ }
+
+ Tweener from(Object object, long duration, Object... vars) {
+ // TODO: for v of vars
+ // toVars[v] = object[v]
+ // object[v] = vars[v]
+ return Tweener.to(object, duration, vars);
+ }
+
+ // Listener to watch for completed animations and remove them.
+ private static AnimatorListener mCleanupListener = new AnimatorListenerAdapter() {
+
+ @Override
+ public void onAnimationEnd(Animator animation) {
+ remove(animation);
+ }
+
+ @Override
+ public void onAnimationCancel(Animator animation) {
+ remove(animation);
+ }
+ };
+
+ public static void reset() {
+ if (DEBUG) {
+ Log.v(TAG, "Reset()");
+ if (sTweens.size() > 0) {
+ Log.v(TAG, "Cleaning up " + sTweens.size() + " animations");
+ }
+ }
+ sTweens.clear();
+ }
+
+ private static void replace(ArrayList props, Object... args) {
+ for (final Object killobject : args) {
+ Tweener tween = sTweens.get(killobject);
+ if (tween != null) {
+ tween.animator.cancel();
+ if (props != null) {
+ tween.animator.setValues(
+ props.toArray(new PropertyValuesHolder[props.size()]));
+ } else {
+ sTweens.remove(tween);
+ }
+ }
+ }
+ }
+}
diff --git a/_DeskClock/src/com/android/deskclock/widget/swipeablelistview/LogTag.java b/_DeskClock/src/com/android/deskclock/widget/swipeablelistview/LogTag.java
new file mode 100644
index 000000000..cf5f5845b
--- /dev/null
+++ b/_DeskClock/src/com/android/deskclock/widget/swipeablelistview/LogTag.java
@@ -0,0 +1,30 @@
+/*
+ * 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.deskclock.widget.swipeablelistview;
+
+public class LogTag {
+
+ private static String LOG_TAG = "AlarmClock";
+
+ /**
+ * Get the log tag to apply to logging.
+ */
+ public static String getLogTag() {
+ return LOG_TAG;
+ }
+
+}
diff --git a/_DeskClock/src/com/android/deskclock/widget/swipeablelistview/LogUtils.java b/_DeskClock/src/com/android/deskclock/widget/swipeablelistview/LogUtils.java
new file mode 100644
index 000000000..d81be05b0
--- /dev/null
+++ b/_DeskClock/src/com/android/deskclock/widget/swipeablelistview/LogUtils.java
@@ -0,0 +1,344 @@
+/*
+ * 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.deskclock.widget.swipeablelistview;
+
+import java.util.regex.Pattern;
+
+import android.text.TextUtils;
+import android.util.Log;
+
+public class LogUtils {
+
+ public static final String TAG = "AlarmClock";
+
+ // "GMT" + "+" or "-" + 4 digits
+ private static final Pattern DATE_CLEANUP_PATTERN_WRONG_TIMEZONE =
+ Pattern.compile("GMT([-+]\\d{4})$");
+
+ /**
+ * Priority constant for the println method; use LogUtils.v.
+ */
+ public static final int VERBOSE = Log.VERBOSE;
+
+ /**
+ * Priority constant for the println method; use LogUtils.d.
+ */
+ public static final int DEBUG = Log.DEBUG;
+
+ /**
+ * Priority constant for the println method; use LogUtils.i.
+ */
+ public static final int INFO = Log.INFO;
+
+ /**
+ * Priority constant for the println method; use LogUtils.w.
+ */
+ public static final int WARN = Log.WARN;
+
+ /**
+ * Priority constant for the println method; use LogUtils.e.
+ */
+ public static final int ERROR = Log.ERROR;
+
+ /**
+ * Used to enable/disable logging that we don't want included in
+ * production releases.
+ */
+ private static final int MAX_ENABLED_LOG_LEVEL = ERROR;
+
+ private static Boolean sDebugLoggingEnabledForTests = null;
+
+ /**
+ * Enable debug logging for unit tests.
+ */
+ //@VisibleForTesting
+ static void setDebugLoggingEnabledForTests(boolean enabled) {
+ sDebugLoggingEnabledForTests = Boolean.valueOf(enabled);
+ }
+
+ /**
+ * Returns true if the build configuration prevents debug logging.
+ */
+ //@VisibleForTesting
+ public static boolean buildPreventsDebugLogging() {
+ return MAX_ENABLED_LOG_LEVEL > VERBOSE;
+ }
+
+ /**
+ * Returns a boolean indicating whether debug logging is enabled.
+ */
+ protected static boolean isDebugLoggingEnabled(String tag) {
+ if (buildPreventsDebugLogging()) {
+ return false;
+ }
+ if (sDebugLoggingEnabledForTests != null) {
+ return sDebugLoggingEnabledForTests.booleanValue();
+ }
+ return Log.isLoggable(tag, Log.DEBUG);
+ }
+
+ /**
+ * Checks to see whether or not a log for the specified tag is loggable at the specified level.
+ */
+ public static boolean isLoggable(String tag, int level) {
+ if (MAX_ENABLED_LOG_LEVEL > level) {
+ return false;
+ }
+ return Log.isLoggable(tag, level);
+ }
+
+ /**
+ * Send a {@link #VERBOSE} log message.
+ * @param tag Used to identify the source of a log message. It usually identifies
+ * the class or activity where the log call occurs.
+ * @param format the format string (see {@link java.util.Formatter#format})
+ * @param args
+ * the list of arguments passed to the formatter. If there are
+ * more arguments than required by {@code format},
+ * additional arguments are ignored.
+ */
+ public static int v(String tag, String format, Object... args) {
+ if (isLoggable(tag, VERBOSE)) {
+ return Log.v(tag, String.format(format, args));
+ }
+ return 0;
+ }
+
+ /**
+ * Send a {@link #VERBOSE} log message.
+ * @param tag Used to identify the source of a log message. It usually identifies
+ * the class or activity where the log call occurs.
+ * @param tr An exception to log
+ * @param format the format string (see {@link java.util.Formatter#format})
+ * @param args
+ * the list of arguments passed to the formatter. If there are
+ * more arguments than required by {@code format},
+ * additional arguments are ignored.
+ */
+ public static int v(String tag, Throwable tr, String format, Object... args) {
+ if (isLoggable(tag, VERBOSE)) {
+ return Log.v(tag, String.format(format, args), tr);
+ }
+ return 0;
+ }
+
+ /**
+ * Send a {@link #DEBUG} log message.
+ * @param tag Used to identify the source of a log message. It usually identifies
+ * the class or activity where the log call occurs.
+ * @param format the format string (see {@link java.util.Formatter#format})
+ * @param args
+ * the list of arguments passed to the formatter. If there are
+ * more arguments than required by {@code format},
+ * additional arguments are ignored.
+ */
+ public static int d(String tag, String format, Object... args) {
+ if (isLoggable(tag, DEBUG)) {
+ return Log.d(tag, String.format(format, args));
+ }
+ return 0;
+ }
+
+ /**
+ * Send a {@link #DEBUG} log message.
+ * @param tag Used to identify the source of a log message. It usually identifies
+ * the class or activity where the log call occurs.
+ * @param tr An exception to log
+ * @param format the format string (see {@link java.util.Formatter#format})
+ * @param args
+ * the list of arguments passed to the formatter. If there are
+ * more arguments than required by {@code format},
+ * additional arguments are ignored.
+ */
+ public static int d(String tag, Throwable tr, String format, Object... args) {
+ if (isLoggable(tag, DEBUG)) {
+ return Log.d(tag, String.format(format, args), tr);
+ }
+ return 0;
+ }
+
+ /**
+ * Send a {@link #INFO} log message.
+ * @param tag Used to identify the source of a log message. It usually identifies
+ * the class or activity where the log call occurs.
+ * @param format the format string (see {@link java.util.Formatter#format})
+ * @param args
+ * the list of arguments passed to the formatter. If there are
+ * more arguments than required by {@code format},
+ * additional arguments are ignored.
+ */
+ public static int i(String tag, String format, Object... args) {
+ if (isLoggable(tag, INFO)) {
+ return Log.i(tag, String.format(format, args));
+ }
+ return 0;
+ }
+
+ /**
+ * Send a {@link #INFO} log message.
+ * @param tag Used to identify the source of a log message. It usually identifies
+ * the class or activity where the log call occurs.
+ * @param tr An exception to log
+ * @param format the format string (see {@link java.util.Formatter#format})
+ * @param args
+ * the list of arguments passed to the formatter. If there are
+ * more arguments than required by {@code format},
+ * additional arguments are ignored.
+ */
+ public static int i(String tag, Throwable tr, String format, Object... args) {
+ if (isLoggable(tag, INFO)) {
+ return Log.i(tag, String.format(format, args), tr);
+ }
+ return 0;
+ }
+
+ /**
+ * Send a {@link #WARN} log message.
+ * @param tag Used to identify the source of a log message. It usually identifies
+ * the class or activity where the log call occurs.
+ * @param format the format string (see {@link java.util.Formatter#format})
+ * @param args
+ * the list of arguments passed to the formatter. If there are
+ * more arguments than required by {@code format},
+ * additional arguments are ignored.
+ */
+ public static int w(String tag, String format, Object... args) {
+ if (isLoggable(tag, WARN)) {
+ return Log.w(tag, String.format(format, args));
+ }
+ return 0;
+ }
+
+ /**
+ * Send a {@link #WARN} log message.
+ * @param tag Used to identify the source of a log message. It usually identifies
+ * the class or activity where the log call occurs.
+ * @param tr An exception to log
+ * @param format the format string (see {@link java.util.Formatter#format})
+ * @param args
+ * the list of arguments passed to the formatter. If there are
+ * more arguments than required by {@code format},
+ * additional arguments are ignored.
+ */
+ public static int w(String tag, Throwable tr, String format, Object... args) {
+ if (isLoggable(tag, WARN)) {
+ return Log.w(tag, String.format(format, args), tr);
+ }
+ return 0;
+ }
+
+ /**
+ * Send a {@link #ERROR} log message.
+ * @param tag Used to identify the source of a log message. It usually identifies
+ * the class or activity where the log call occurs.
+ * @param format the format string (see {@link java.util.Formatter#format})
+ * @param args
+ * the list of arguments passed to the formatter. If there are
+ * more arguments than required by {@code format},
+ * additional arguments are ignored.
+ */
+ public static int e(String tag, String format, Object... args) {
+ if (isLoggable(tag, ERROR)) {
+ return Log.e(tag, String.format(format, args));
+ }
+ return 0;
+ }
+
+ /**
+ * Send a {@link #ERROR} log message.
+ * @param tag Used to identify the source of a log message. It usually identifies
+ * the class or activity where the log call occurs.
+ * @param tr An exception to log
+ * @param format the format string (see {@link java.util.Formatter#format})
+ * @param args
+ * the list of arguments passed to the formatter. If there are
+ * more arguments than required by {@code format},
+ * additional arguments are ignored.
+ */
+ public static int e(String tag, Throwable tr, String format, Object... args) {
+ if (isLoggable(tag, ERROR)) {
+ return Log.e(tag, String.format(format, args), tr);
+ }
+ return 0;
+ }
+
+ /**
+ * What a Terrible Failure: Report a condition that should never happen.
+ * The error will always be logged at level ASSERT with the call stack.
+ * Depending on system configuration, a report may be added to the
+ * {@link android.os.DropBoxManager} and/or the process may be terminated
+ * immediately with an error dialog.
+ * @param tag Used to identify the source of a log message. It usually identifies
+ * the class or activity where the log call occurs.
+ * @param format the format string (see {@link java.util.Formatter#format})
+ * @param args
+ * the list of arguments passed to the formatter. If there are
+ * more arguments than required by {@code format},
+ * additional arguments are ignored.
+ */
+ public static int wtf(String tag, String format, Object... args) {
+ return Log.wtf(tag, String.format(format, args), new Error());
+ }
+
+ /**
+ * What a Terrible Failure: Report a condition that should never happen.
+ * The error will always be logged at level ASSERT with the call stack.
+ * Depending on system configuration, a report may be added to the
+ * {@link android.os.DropBoxManager} and/or the process may be terminated
+ * immediately with an error dialog.
+ * @param tag Used to identify the source of a log message. It usually identifies
+ * the class or activity where the log call occurs.
+ * @param tr An exception to log
+ * @param format the format string (see {@link java.util.Formatter#format})
+ * @param args
+ * the list of arguments passed to the formatter. If there are
+ * more arguments than required by {@code format},
+ * additional arguments are ignored.
+ */
+ public static int wtf(String tag, Throwable tr, String format, Object... args) {
+ return Log.wtf(tag, String.format(format, args), tr);
+ }
+
+
+ /**
+ * Try to make a date MIME(RFC 2822/5322)-compliant.
+ *
+ * It fixes:
+ * - "Thu, 10 Dec 09 15:08:08 GMT-0700" to "Thu, 10 Dec 09 15:08:08 -0700"
+ * (4 digit zone value can't be preceded by "GMT")
+ * We got a report saying eBay sends a date in this format
+ */
+ public static String cleanUpMimeDate(String date) {
+ if (TextUtils.isEmpty(date)) {
+ return date;
+ }
+ date = DATE_CLEANUP_PATTERN_WRONG_TIMEZONE.matcher(date).replaceFirst("$1");
+ return date;
+ }
+
+
+ public static String byteToHex(int b) {
+ return byteToHex(new StringBuilder(), b).toString();
+ }
+
+ public static StringBuilder byteToHex(StringBuilder sb, int b) {
+ b &= 0xFF;
+ sb.append("0123456789ABCDEF".charAt(b >> 4));
+ sb.append("0123456789ABCDEF".charAt(b & 0xF));
+ return sb;
+ }
+
+}
diff --git a/_DeskClock/src/com/android/deskclock/widget/swipeablelistview/SwipeHelper.java b/_DeskClock/src/com/android/deskclock/widget/swipeablelistview/SwipeHelper.java
new file mode 100644
index 000000000..8aeafb724
--- /dev/null
+++ b/_DeskClock/src/com/android/deskclock/widget/swipeablelistview/SwipeHelper.java
@@ -0,0 +1,483 @@
+/*
+ * Copyright (C) 2012 Google Inc.
+ * Licensed to 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.deskclock.widget.swipeablelistview;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ObjectAnimator;
+import android.animation.ValueAnimator;
+import android.animation.ValueAnimator.AnimatorUpdateListener;
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.RectF;
+import android.util.Log;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.View;
+import android.view.animation.LinearInterpolator;
+
+import com.android.deskclock.R;
+
+/**
+ * Copy of packages/apps/UnifiedEmail - com.android.mail.ui.SwipeHelper with changes.
+ */
+public class SwipeHelper {
+ static final String TAG = "com.android.systemui.SwipeHelper";
+ private static final boolean DEBUG_INVALIDATE = false;
+ private static final boolean CONSTRAIN_SWIPE = true;
+ private static final boolean FADE_OUT_DURING_SWIPE = true;
+ private static final boolean DISMISS_IF_SWIPED_FAR_ENOUGH = true;
+ private static final boolean LOG_SWIPE_DISMISS_VELOCITY = false; // STOPSHIP - DEBUG ONLY
+
+ public static final int X = 0;
+ public static final int Y = 1;
+
+ private static LinearInterpolator sLinearInterpolator = new LinearInterpolator();
+
+ private static int SWIPE_ESCAPE_VELOCITY = -1;
+ private static int DEFAULT_ESCAPE_ANIMATION_DURATION;
+ private static int MAX_ESCAPE_ANIMATION_DURATION;
+ private static int MAX_DISMISS_VELOCITY;
+ private static int SNAP_ANIM_LEN;
+ private static int DISMISS_ANIMATION_DURATION;
+ private static int SWIPE_SCROLL_SLOP;
+ private static float MIN_SWIPE;
+ private static float MIN_VERT;
+ private static float MIN_LOCK;
+
+ public static float ALPHA_FADE_START = 0f; // fraction of thumbnail width
+ // where fade starts
+ static final float ALPHA_FADE_END = 0.7f; // fraction of thumbnail width
+ // beyond which alpha->0
+ private static final float FACTOR = 1.2f;
+
+ private static final int PROTECTION_PADDING = 50;
+
+ private float mMinAlpha = 0.3f;
+
+ private float mPagingTouchSlop;
+ private final Callback mCallback;
+ private final int mSwipeDirection;
+ private final VelocityTracker mVelocityTracker;
+
+ private float mInitialTouchPosX;
+ private boolean mDragging;
+ private View mCurrView;
+ private View mCurrAnimView;
+ private boolean mCanCurrViewBeDimissed;
+ private float mDensityScale;
+ private float mLastY;
+ private float mInitialTouchPosY;
+
+ private float mStartAlpha;
+ private boolean mProtected = false;
+
+ public SwipeHelper(Context context, int swipeDirection, Callback callback, float densityScale,
+ float pagingTouchSlop) {
+ mCallback = callback;
+ mSwipeDirection = swipeDirection;
+ mVelocityTracker = VelocityTracker.obtain();
+ mDensityScale = densityScale;
+ mPagingTouchSlop = pagingTouchSlop;
+ if (SWIPE_ESCAPE_VELOCITY == -1) {
+ Resources res = context.getResources();
+ SWIPE_ESCAPE_VELOCITY = res.getInteger(R.integer.swipe_escape_velocity);
+ DEFAULT_ESCAPE_ANIMATION_DURATION = res.getInteger(R.integer.escape_animation_duration);
+ MAX_ESCAPE_ANIMATION_DURATION = res.getInteger(R.integer.max_escape_animation_duration);
+ MAX_DISMISS_VELOCITY = res.getInteger(R.integer.max_dismiss_velocity);
+ SNAP_ANIM_LEN = res.getInteger(R.integer.snap_animation_duration);
+ DISMISS_ANIMATION_DURATION = res.getInteger(R.integer.dismiss_animation_duration);
+ SWIPE_SCROLL_SLOP = res.getInteger(R.integer.swipe_scroll_slop);
+ MIN_SWIPE = res.getDimension(R.dimen.min_swipe);
+ MIN_VERT = res.getDimension(R.dimen.min_vert);
+ MIN_LOCK = res.getDimension(R.dimen.min_lock);
+ }
+ }
+
+ public void setDensityScale(float densityScale) {
+ mDensityScale = densityScale;
+ }
+
+ public void setPagingTouchSlop(float pagingTouchSlop) {
+ mPagingTouchSlop = pagingTouchSlop;
+ }
+
+ private float getVelocity(VelocityTracker vt) {
+ return mSwipeDirection == X ? vt.getXVelocity() :
+ vt.getYVelocity();
+ }
+
+ private ObjectAnimator createTranslationAnimation(View v, float newPos) {
+ ObjectAnimator anim = ObjectAnimator.ofFloat(v,
+ mSwipeDirection == X ? "translationX" : "translationY", newPos);
+ return anim;
+ }
+
+ private ObjectAnimator createDismissAnimation(View v, float newPos, int duration) {
+ ObjectAnimator anim = createTranslationAnimation(v, newPos);
+ anim.setInterpolator(sLinearInterpolator);
+ anim.setDuration(duration);
+ return anim;
+ }
+
+ private float getPerpendicularVelocity(VelocityTracker vt) {
+ return mSwipeDirection == X ? vt.getYVelocity() :
+ vt.getXVelocity();
+ }
+
+ private void setTranslation(View v, float translate) {
+ if (mSwipeDirection == X) {
+ v.setTranslationX(translate);
+ } else {
+ v.setTranslationY(translate);
+ }
+ }
+
+ private float getSize(View v) {
+ return mSwipeDirection == X ? v.getMeasuredWidth() :
+ v.getMeasuredHeight();
+ }
+
+ public void setMinAlpha(float minAlpha) {
+ mMinAlpha = minAlpha;
+ }
+
+ private float getAlphaForOffset(View view) {
+ float viewSize = getSize(view);
+ final float fadeSize = ALPHA_FADE_END * viewSize;
+ float result = mStartAlpha;
+ float pos = view.getTranslationX();
+ if (pos >= viewSize * ALPHA_FADE_START) {
+ result = mStartAlpha - (pos - viewSize * ALPHA_FADE_START) / fadeSize;
+ } else if (pos < viewSize * (mStartAlpha - ALPHA_FADE_START)) {
+ result = mStartAlpha + (viewSize * ALPHA_FADE_START + pos) / fadeSize;
+ }
+ return Math.max(mMinAlpha, result);
+ }
+
+ // invalidate the view's own bounds all the way up the view hierarchy
+ public static void invalidateGlobalRegion(View view) {
+ invalidateGlobalRegion(
+ view,
+ new RectF(view.getLeft(), view.getTop(), view.getRight(), view.getBottom()));
+ }
+
+ // invalidate a rectangle relative to the view's coordinate system all the way up the view
+ // hierarchy
+ public static void invalidateGlobalRegion(View view, RectF childBounds) {
+ //childBounds.offset(view.getTranslationX(), view.getTranslationY());
+ if (DEBUG_INVALIDATE)
+ Log.v(TAG, "-------------");
+ while (view.getParent() != null && view.getParent() instanceof View) {
+ view = (View) view.getParent();
+ view.getMatrix().mapRect(childBounds);
+ view.invalidate((int) Math.floor(childBounds.left),
+ (int) Math.floor(childBounds.top),
+ (int) Math.ceil(childBounds.right),
+ (int) Math.ceil(childBounds.bottom));
+ if (DEBUG_INVALIDATE) {
+ Log.v(TAG, "INVALIDATE(" + (int) Math.floor(childBounds.left)
+ + "," + (int) Math.floor(childBounds.top)
+ + "," + (int) Math.ceil(childBounds.right)
+ + "," + (int) Math.ceil(childBounds.bottom));
+ }
+ }
+ }
+
+ public boolean onInterceptTouchEvent(MotionEvent ev) {
+ final int action = ev.getAction();
+ switch (action) {
+ case MotionEvent.ACTION_DOWN:
+ mLastY = ev.getY();
+ mDragging = false;
+ mCurrView = mCallback.getChildAtPosition(ev);
+ mVelocityTracker.clear();
+ if (mCurrView != null) {
+
+ View button = mCurrView.findViewById(R.id.onoff);
+
+ // Find raw top and left positions for button.
+ int left = button.getLeft();
+ int top = button.getTop();
+ View parent = (View) button.getParent();
+ while (parent != null) {
+ left += parent.getLeft();
+ top += parent.getTop();
+ if (parent.getParent() == parent.getRootView()) {
+ parent = null;
+ } else {
+ parent = (View) parent.getParent();
+ }
+ }
+
+ // Add protection.
+ int bottom = top + button.getHeight() + PROTECTION_PADDING;
+ top -= PROTECTION_PADDING;
+ left -= PROTECTION_PADDING;
+
+ float rawX = ev.getRawX();
+ float rawY = ev.getRawY();
+
+ // Check if we are in the protected no-op area.
+ if (rawX > left && rawY > top && rawY < bottom) {
+ mProtected = true;
+ } else {
+ mProtected = false;
+ }
+
+ mCurrAnimView = mCallback.getChildContentView(mCurrView);
+ mStartAlpha = mCurrAnimView.getAlpha();
+ mCanCurrViewBeDimissed = mCallback.canChildBeDismissed(mCurrView);
+ mVelocityTracker.addMovement(ev);
+ mInitialTouchPosX = ev.getX();
+ mInitialTouchPosY = ev.getY();
+ }
+ break;
+ case MotionEvent.ACTION_MOVE:
+ if (mCurrView != null) {
+ // Check the movement direction.
+ if (mLastY >= 0 && !mDragging) {
+ float currY = ev.getY();
+ float currX = ev.getX();
+ float deltaY = Math.abs(currY - mInitialTouchPosY);
+ float deltaX = Math.abs(currX - mInitialTouchPosX);
+ if (deltaY > SWIPE_SCROLL_SLOP && deltaY > (FACTOR * deltaX)) {
+ mLastY = ev.getY();
+ mCallback.onScroll();
+ return false;
+ }
+ }
+ mVelocityTracker.addMovement(ev);
+ float pos = ev.getX();
+ float delta = pos - mInitialTouchPosX;
+ if (Math.abs(delta) > mPagingTouchSlop) {
+ mCallback.onBeginDrag(mCallback.getChildContentView(mCurrView));
+ mDragging = true;
+ mInitialTouchPosX = ev.getX() - mCurrAnimView.getTranslationX();
+ mInitialTouchPosY = ev.getY();
+ }
+ }
+ mLastY = ev.getY();
+ break;
+ case MotionEvent.ACTION_UP:
+ case MotionEvent.ACTION_CANCEL:
+ mDragging = false;
+ mCurrView = null;
+ mCurrAnimView = null;
+ mLastY = -1;
+ break;
+ }
+ return mDragging;
+ }
+
+ /**
+ * @param view The view to be dismissed
+ * @param velocity The desired pixels/second speed at which the view should
+ * move
+ */
+ private void dismissChild(final View view, float velocity) {
+ final View animView = mCallback.getChildContentView(view);
+ final boolean canAnimViewBeDismissed = mCallback.canChildBeDismissed(view);
+ float newPos = determinePos(animView, velocity);
+ int duration = determineDuration(animView, newPos, velocity);
+
+ animView.setLayerType(View.LAYER_TYPE_HARDWARE, null);
+ ObjectAnimator anim = createDismissAnimation(animView, newPos, duration);
+ anim.addListener(new AnimatorListenerAdapter() {
+ @Override
+ public void onAnimationEnd(Animator animation) {
+ mCallback.onChildDismissed(mCurrView);
+ animView.setLayerType(View.LAYER_TYPE_NONE, null);
+ }
+ });
+ anim.addUpdateListener(new AnimatorUpdateListener() {
+ @Override
+ public void onAnimationUpdate(ValueAnimator animation) {
+ if (FADE_OUT_DURING_SWIPE && canAnimViewBeDismissed) {
+ animView.setAlpha(getAlphaForOffset(animView));
+ }
+ invalidateGlobalRegion(animView);
+ }
+ });
+ anim.start();
+ }
+
+ private int determineDuration(View animView, float newPos, float velocity) {
+ int duration = MAX_ESCAPE_ANIMATION_DURATION;
+ if (velocity != 0) {
+ duration = Math
+ .min(duration,
+ (int) (Math.abs(newPos - animView.getTranslationX()) * 1000f / Math
+ .abs(velocity)));
+ } else {
+ duration = DEFAULT_ESCAPE_ANIMATION_DURATION;
+ }
+ return duration;
+ }
+
+ private float determinePos(View animView, float velocity) {
+ float newPos = 0;
+ if (velocity < 0 || (velocity == 0 && animView.getTranslationX() < 0)
+ // if we use the Menu to dismiss an item in landscape, animate up
+ || (velocity == 0 && animView.getTranslationX() == 0 && mSwipeDirection == Y)) {
+ newPos = -getSize(animView);
+ } else {
+ newPos = getSize(animView);
+ }
+ return newPos;
+ }
+
+ public void snapChild(final View view, float velocity) {
+ final View animView = mCallback.getChildContentView(view);
+ final boolean canAnimViewBeDismissed = mCallback.canChildBeDismissed(view);
+ ObjectAnimator anim = createTranslationAnimation(animView, 0);
+ int duration = SNAP_ANIM_LEN;
+ anim.setDuration(duration);
+ anim.addUpdateListener(new AnimatorUpdateListener() {
+ @Override
+ public void onAnimationUpdate(ValueAnimator animation) {
+ if (FADE_OUT_DURING_SWIPE && canAnimViewBeDismissed) {
+ animView.setAlpha(getAlphaForOffset(animView));
+ }
+ invalidateGlobalRegion(animView);
+ }
+ });
+ anim.addListener(new Animator.AnimatorListener() {
+ @Override
+ public void onAnimationStart(Animator animation) {
+ }
+ @Override
+ public void onAnimationEnd(Animator animation) {
+ animView.setAlpha(mStartAlpha);
+ mCallback.onDragCancelled(mCurrView);
+ }
+ @Override
+ public void onAnimationCancel(Animator animation) {
+ }
+ @Override
+ public void onAnimationRepeat(Animator animation) {
+ }
+ });
+ anim.start();
+ }
+
+ public boolean onTouchEvent(MotionEvent ev) {
+ if (!mDragging || mProtected) {
+ return false;
+ }
+ mVelocityTracker.addMovement(ev);
+ final int action = ev.getAction();
+ switch (action) {
+ case MotionEvent.ACTION_OUTSIDE:
+ case MotionEvent.ACTION_MOVE:
+ if (mCurrView != null) {
+ float deltaX = ev.getX() - mInitialTouchPosX;
+ float deltaY = Math.abs(ev.getY() - mInitialTouchPosY);
+ // If the user has gone vertical and not gone horizontalish AT
+ // LEAST minBeforeLock, switch to scroll. Otherwise, cancel
+ // the swipe.
+ if (!mDragging && deltaY > MIN_VERT && (Math.abs(deltaX)) < MIN_LOCK
+ && deltaY > (FACTOR * Math.abs(deltaX))) {
+ mCallback.onScroll();
+ return false;
+ }
+ float minDistance = MIN_SWIPE;
+ if (Math.abs(deltaX) < minDistance) {
+ // Don't start the drag until at least X distance has
+ // occurred.
+ return true;
+ }
+ // don't let items that can't be dismissed be dragged more
+ // than maxScrollDistance
+ if (CONSTRAIN_SWIPE && !mCallback.canChildBeDismissed(mCurrView)) {
+ float size = getSize(mCurrAnimView);
+ float maxScrollDistance = 0.15f * size;
+ if (Math.abs(deltaX) >= size) {
+ deltaX = deltaX > 0 ? maxScrollDistance : -maxScrollDistance;
+ } else {
+ deltaX = maxScrollDistance
+ * (float) Math.sin((deltaX / size) * (Math.PI / 2));
+ }
+ }
+ setTranslation(mCurrAnimView, deltaX);
+ if (FADE_OUT_DURING_SWIPE && mCanCurrViewBeDimissed) {
+ mCurrAnimView.setAlpha(getAlphaForOffset(mCurrAnimView));
+ }
+ invalidateGlobalRegion(mCallback.getChildContentView(mCurrView));
+ }
+ break;
+ case MotionEvent.ACTION_UP:
+ case MotionEvent.ACTION_CANCEL:
+ if (mCurrView != null) {
+ float maxVelocity = MAX_DISMISS_VELOCITY * mDensityScale;
+ mVelocityTracker.computeCurrentVelocity(1000 /* px/sec */, maxVelocity);
+ float escapeVelocity = SWIPE_ESCAPE_VELOCITY * mDensityScale;
+ float velocity = getVelocity(mVelocityTracker);
+ float perpendicularVelocity = getPerpendicularVelocity(mVelocityTracker);
+
+ // Decide whether to dismiss the current view
+ // Tweak constants below as required to prevent erroneous
+ // swipe/dismiss
+ float translation = Math.abs(mCurrAnimView.getTranslationX());
+ float currAnimViewSize = getSize(mCurrAnimView);
+ // Long swipe = translation of .4 * width
+ boolean childSwipedFarEnough = DISMISS_IF_SWIPED_FAR_ENOUGH
+ && translation > 0.4 * currAnimViewSize;
+ // Fast swipe = > escapeVelocity and translation of .1 *
+ // width
+ boolean childSwipedFastEnough = (Math.abs(velocity) > escapeVelocity)
+ && (Math.abs(velocity) > Math.abs(perpendicularVelocity))
+ && (velocity > 0) == (mCurrAnimView.getTranslationX() > 0)
+ && translation > 0.05 * currAnimViewSize;
+ if (LOG_SWIPE_DISMISS_VELOCITY) {
+ Log.v(TAG, "Swipe/Dismiss: " + velocity + "/" + escapeVelocity + "/"
+ + perpendicularVelocity + ", x: " + translation + "/"
+ + currAnimViewSize);
+ }
+
+ boolean dismissChild = mCallback.canChildBeDismissed(mCurrView)
+ && (childSwipedFastEnough || childSwipedFarEnough);
+
+ if (dismissChild) {
+ dismissChild(mCurrView, childSwipedFastEnough ? velocity : 0f);
+ } else {
+ snapChild(mCurrView, velocity);
+ }
+ }
+ break;
+ }
+ return true;
+ }
+
+ public interface Callback {
+ View getChildAtPosition(MotionEvent ev);
+
+ View getChildContentView(View v);
+
+ void onScroll();
+
+ boolean canChildBeDismissed(View v);
+
+ void onBeginDrag(View v);
+
+ void onChildDismissed(View v);
+
+ void onDragCancelled(View v);
+
+ }
+}
diff --git a/_DeskClock/src/com/android/deskclock/widget/swipeablelistview/SwipeLayout.java b/_DeskClock/src/com/android/deskclock/widget/swipeablelistview/SwipeLayout.java
new file mode 100644
index 000000000..03e0c94d2
--- /dev/null
+++ b/_DeskClock/src/com/android/deskclock/widget/swipeablelistview/SwipeLayout.java
@@ -0,0 +1,49 @@
+/*
+ * 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.deskclock.widget.swipeablelistview;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.widget.LinearLayout;
+
+/**
+ * Layout which always handles the touch event.
+ *
+ * This is needed by the SwipeableListView onInterceptTouchEvent()
+ *
+ */
+public class SwipeLayout extends LinearLayout {
+
+ public SwipeLayout(Context context) {
+ super(context);
+ }
+
+ public SwipeLayout(Context context, AttributeSet attrs) {
+ super(context, attrs);
+ }
+
+ public SwipeLayout(Context context, AttributeSet attrs, int defStyle) {
+ super(context, attrs, defStyle);
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent ev) {
+ super.onTouchEvent(ev);
+ return true;
+ }
+}
diff --git a/_DeskClock/src/com/android/deskclock/widget/swipeablelistview/SwipeableListView.java b/_DeskClock/src/com/android/deskclock/widget/swipeablelistview/SwipeableListView.java
new file mode 100644
index 000000000..38293be02
--- /dev/null
+++ b/_DeskClock/src/com/android/deskclock/widget/swipeablelistview/SwipeableListView.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) 2012 Google Inc.
+ * Licensed to 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.deskclock.widget.swipeablelistview;
+
+import android.content.Context;
+import android.content.res.Configuration;
+import android.graphics.Rect;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewConfiguration;
+import android.widget.ListView;
+
+import com.android.deskclock.widget.swipeablelistview.SwipeHelper.Callback;
+
+/**
+ * Copy of packages/apps/UnifiedEmail - com.android.mail.ui.Swipeable with changes.
+ */
+public class SwipeableListView extends ListView implements Callback {
+ private SwipeHelper mSwipeHelper;
+ private boolean mEnableSwipe = false;
+
+ public static final String LOG_TAG = LogTag.getLogTag();
+
+ private OnItemSwipeListener mOnItemSwipeListener;
+
+ public SwipeableListView(Context context) {
+ this(context, null);
+ }
+
+ public SwipeableListView(Context context, AttributeSet attrs) {
+ this(context, attrs, -1);
+ }
+
+ public SwipeableListView(Context context, AttributeSet attrs, int defStyle) {
+ super(context, attrs, defStyle);
+ float densityScale = getResources().getDisplayMetrics().density;
+ float pagingTouchSlop = ViewConfiguration.get(context).getScaledPagingTouchSlop();
+ mSwipeHelper = new SwipeHelper(context, SwipeHelper.X, this, densityScale,
+ pagingTouchSlop);
+ setItemsCanFocus(true);
+ }
+
+ @Override
+ protected void onConfigurationChanged(Configuration newConfig) {
+ super.onConfigurationChanged(newConfig);
+ float densityScale = getResources().getDisplayMetrics().density;
+ mSwipeHelper.setDensityScale(densityScale);
+ float pagingTouchSlop = ViewConfiguration.get(getContext()).getScaledPagingTouchSlop();
+ mSwipeHelper.setPagingTouchSlop(pagingTouchSlop);
+ }
+
+ @Override
+ protected void onFocusChanged(boolean gainFocus, int direction, Rect previouslyFocusedRect) {
+ LogUtils.d(Utils.VIEW_DEBUGGING_TAG,
+ "START CLF-ListView.onFocusChanged layoutRequested=%s root.layoutRequested=%s",
+ isLayoutRequested(), getRootView().isLayoutRequested());
+ super.onFocusChanged(gainFocus, direction, previouslyFocusedRect);
+ LogUtils.d(Utils.VIEW_DEBUGGING_TAG, new Error(),
+ "FINISH CLF-ListView.onFocusChanged layoutRequested=%s root.layoutRequested=%s",
+ isLayoutRequested(), getRootView().isLayoutRequested());
+ }
+
+ @Override
+ public void requestLayout() {
+ Utils.checkRequestLayout(this);
+ super.requestLayout();
+ }
+
+ /**
+ * Enable swipe gestures.
+ */
+ public void enableSwipe(boolean enable) {
+ mEnableSwipe = enable;
+ }
+
+ public boolean isSwipeEnabled() {
+ return mEnableSwipe;
+ }
+
+ public void setOnItemSwipeListener(OnItemSwipeListener listener) {
+ mOnItemSwipeListener = listener;
+ }
+
+ @Override
+ public boolean onInterceptTouchEvent(MotionEvent ev) {
+ if (mEnableSwipe) {
+ return mSwipeHelper.onInterceptTouchEvent(ev) || super.onInterceptTouchEvent(ev);
+ } else {
+ return super.onInterceptTouchEvent(ev);
+ }
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent ev) {
+ if (mEnableSwipe) {
+ return mSwipeHelper.onTouchEvent(ev) || super.onTouchEvent(ev);
+ } else {
+ return super.onTouchEvent(ev);
+ }
+ }
+
+ @Override
+ public View getChildAtPosition(MotionEvent ev) {
+ // find the view under the pointer, accounting for GONE views
+ final int count = getChildCount();
+ int touchY = (int) ev.getY();
+ int childIdx = 0;
+ View slidingChild;
+ for (; childIdx < count; childIdx++) {
+ slidingChild = getChildAt(childIdx);
+ if (slidingChild.getVisibility() == GONE) {
+ continue;
+ }
+ if (touchY >= slidingChild.getTop() && touchY <= slidingChild.getBottom()) {
+ return slidingChild;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public View getChildContentView(View view) {
+ return view;
+ }
+
+ @Override
+ public void onScroll() {
+ }
+
+ @Override
+ public boolean canChildBeDismissed(View v) {
+ return true;
+ }
+
+ @Override
+ public void onChildDismissed(final View v) {
+ if (v != null) {
+ if (mOnItemSwipeListener != null) {
+ mOnItemSwipeListener.onSwipe(v);
+ }
+ }
+ }
+
+ @Override
+ public void onDragCancelled(View v) {
+ }
+
+ private void redraw(View v) {
+ int start = getFirstVisiblePosition();
+ for (int i=start, j = getLastVisiblePosition(); i <= j; i++) {
+ if (v == getItemAtPosition(i)) {
+ View view = getChildAt(i-start);
+ getAdapter().getView(i, view, this);
+ }
+ }
+ }
+
+ @Override
+ public void onBeginDrag(View v) {
+ // We do this so the underlying ScrollView knows that it won't get
+ // the chance to intercept events anymore
+ requestDisallowInterceptTouchEvent(true);
+ }
+
+ public interface OnItemSwipeListener {
+ public void onSwipe(View view);
+ }
+}
diff --git a/_DeskClock/src/com/android/deskclock/widget/swipeablelistview/Utils.java b/_DeskClock/src/com/android/deskclock/widget/swipeablelistview/Utils.java
new file mode 100644
index 000000000..37e89c7f9
--- /dev/null
+++ b/_DeskClock/src/com/android/deskclock/widget/swipeablelistview/Utils.java
@@ -0,0 +1,46 @@
+/*
+ * 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.deskclock.widget.swipeablelistview;
+
+import android.view.View;
+
+public class Utils {
+
+ public static final String VIEW_DEBUGGING_TAG = "AlarmClock";
+
+ public static void checkRequestLayout(View v) {
+ boolean inLayout = false;
+ final View root = v.getRootView();
+
+ if (root == null || v.isLayoutRequested()) {
+ return;
+ }
+
+ final Error e = new Error();
+ for (StackTraceElement ste : e.getStackTrace()) {
+ if ("android.view.ViewGroup".equals(ste.getClassName())
+ && "layout".equals(ste.getMethodName())) {
+ inLayout = true;
+ break;
+ }
+ }
+ if (inLayout && !v.isLayoutRequested()) {
+ LogUtils.i(VIEW_DEBUGGING_TAG,
+ e, "WARNING: in requestLayout during layout pass, view=%s", v);
+ }
+ }
+}
diff --git a/_DeskClock/src/com/android/deskclock/worldclock/Cities.java b/_DeskClock/src/com/android/deskclock/worldclock/Cities.java
new file mode 100644
index 000000000..dd7eafcf8
--- /dev/null
+++ b/_DeskClock/src/com/android/deskclock/worldclock/Cities.java
@@ -0,0 +1,75 @@
+/*
+ * 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.deskclock.worldclock;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+
+import android.content.SharedPreferences;
+import android.util.Log;
+
+public class Cities {
+
+ public static final String WORLDCLOCK_UPDATE_INTENT = "com.android.deskclock.worldclock.update";
+ private static final String NUMBER_OF_CITIES = "number_of_cities";
+
+
+ public static void saveCitiesToSharedPrefs(
+ SharedPreferences prefs, HashMap cities) {
+ SharedPreferences.Editor editor = prefs.edit();
+ editor.putInt(NUMBER_OF_CITIES, cities.size());
+ Collection col = cities.values();
+ Iterator i = col.iterator();
+ int count = 0;
+ while(i.hasNext()) {
+ CityObj c = i.next();
+ c.saveCityToSharedPrefs(editor, count);
+ count ++;
+ }
+ editor.apply();
+ }
+
+ public static HashMap readCitiesFromSharedPrefs(SharedPreferences prefs) {
+ int size = prefs.getInt(NUMBER_OF_CITIES, -1);
+ HashMap c = new HashMap ();
+ if (size > 0) {
+ for (int i = 0; i < size; i++) {
+ CityObj o = new CityObj(prefs, i);
+ if (o.mCityName != null && o.mTimeZone != null) {
+ c.put(o.mCityId, o);
+ }
+ }
+ }
+ return c;
+ }
+
+ private static void dumpCities(SharedPreferences prefs, String title) {
+ int size = prefs.getInt(NUMBER_OF_CITIES, -1);
+ Log.d("Cities","Selected Cities List " + title);
+ Log.d("Cities","Number of cities " + size);
+ HashMap c = new HashMap ();
+ if (size > 0) {
+ for (int i = 0; i < size; i++) {
+ CityObj o = new CityObj(prefs, i);
+ if (o.mCityName != null && o.mTimeZone != null) {
+ Log.d("Cities","Name " + o.mCityName + " tz " + o.mTimeZone);
+ }
+ }
+ }
+ }
+}
diff --git a/_DeskClock/src/com/android/deskclock/worldclock/CitiesActivity.java b/_DeskClock/src/com/android/deskclock/worldclock/CitiesActivity.java
new file mode 100644
index 000000000..69145925d
--- /dev/null
+++ b/_DeskClock/src/com/android/deskclock/worldclock/CitiesActivity.java
@@ -0,0 +1,328 @@
+/*
+ * 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.deskclock.worldclock;
+
+import java.text.Collator;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.TimeZone;
+
+import android.app.ActionBar;
+import android.app.Activity;
+import android.content.ActivityNotFoundException;
+import android.content.Context;
+import android.content.Intent;
+import android.content.res.Resources;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.text.format.DateFormat;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.CheckBox;
+import android.widget.CompoundButton;
+import android.widget.CompoundButton.OnCheckedChangeListener;
+import android.widget.ListView;
+import android.widget.SectionIndexer;
+import android.widget.TextView;
+
+import com.android.deskclock.Alarms;
+import com.android.deskclock.DeskClock;
+import com.android.deskclock.Log;
+import com.android.deskclock.R;
+import com.android.deskclock.SettingsActivity;
+import com.android.deskclock.Utils;
+
+/**
+ * Cities chooser for the world clock
+ */
+public class CitiesActivity extends Activity implements OnCheckedChangeListener, View.OnClickListener {
+
+ /** This must be false for production. If true, turns on logging,
+ test code, etc. */
+ static final boolean DEBUG = false;
+ static final String TAG = "CitiesActivity";
+
+ private LayoutInflater mFactory;
+ private ListView mCitiesList;
+ private CityAdapter mAdapter;
+ private HashMap mUserSelectedCities;
+ private Calendar mCalendar;
+ private final Collator mCollator = Collator.getInstance();
+
+
+/***
+* Adapter for a list of cities with the respected time zone.
+* The Adapter sorts the list alphabetically and create an indexer.
+***/
+
+ private class CityAdapter extends BaseAdapter implements SectionIndexer {
+ private static final String DELETED_ENTRY = "C0";
+ private Object [] mAllTheCitiesList; // full list of the cities
+ private final HashMap mSelectedCitiesList; // Selected cities by the use
+ private final LayoutInflater mInflater;
+ private boolean mIs24HoursMode; // AM/PM or 24 hours mode
+ private Object [] mSectionHeaders;
+ private Object [] mSectionPositions;
+
+ public CityAdapter(
+ Context context, HashMap selectedList, LayoutInflater factory) {
+ super();
+ loadCitiesDataBase(context);
+ mSelectedCitiesList = selectedList;
+ mInflater = factory;
+ mCalendar = Calendar.getInstance();
+ mCalendar.setTimeInMillis(System.currentTimeMillis());
+ set24HoursMode(context);
+ }
+
+ @Override
+ public int getCount() {
+ return mAllTheCitiesList.length;
+ }
+
+ @Override
+ public Object getItem(int p) {
+ if (p >=0 && p < mAllTheCitiesList.length) {
+ return mAllTheCitiesList [p];
+ }
+ return null;
+ }
+
+ @Override
+ public long getItemId(int p) {
+ return p;
+ }
+
+ @Override
+ public boolean isEnabled(int p) {
+ return ((CityObj)mAllTheCitiesList[p]).mCityId != null;
+ }
+
+ @Override
+ public View getView(int position, View view, ViewGroup parent) {
+ if (position < 0 || position >= mAllTheCitiesList.length) {
+ return null;
+ }
+ CityObj c = (CityObj)mAllTheCitiesList [position];
+ // Header view (A CityObj with nothing but the first letter as the name
+ if (c.mCityId == null) {
+ if (view == null || view.findViewById(R.id.header) == null) {
+ view = mInflater.inflate(R.layout.city_list_header, parent, false);
+ }
+ TextView header = (TextView)view.findViewById(R.id.header);
+ header.setText(c.mCityName);
+ } else { // City view
+ // Make sure to recycle a City view only
+ if (view == null || view.findViewById(R.id.city_name) == null) {
+ view = mInflater.inflate(R.layout.city_list_item, parent, false);
+ }
+ view.setOnClickListener(CitiesActivity.this);
+ TextView name = (TextView)view.findViewById(R.id.city_name);
+ TextView tz = (TextView)view.findViewById(R.id.city_time);
+ CheckBox cb = (CheckBox)view.findViewById(R.id.city_onoff);
+ cb.setTag(c);
+ cb.setChecked(mSelectedCitiesList.containsKey(c.mCityId));
+ cb.setOnCheckedChangeListener(CitiesActivity.this);
+ mCalendar.setTimeZone(TimeZone.getTimeZone(c.mTimeZone));
+ tz.setText(DateFormat.format(mIs24HoursMode ? "k:mm" : "h:mmaa", mCalendar));
+ name.setText(c.mCityName);
+ }
+ return view;
+ }
+
+ public void set24HoursMode(Context c) {
+ mIs24HoursMode = Alarms.get24HourMode(c);
+ notifyDataSetChanged();
+ }
+
+ private void loadCitiesDataBase(Context c) {
+ Resources r = c.getResources();
+ // Read strings array of name,timezone, id
+ // make sure the list are the same length
+ String [] cities = r.getStringArray(R.array.cities_names);
+ String [] timezones = r.getStringArray(R.array.cities_tz);
+ String [] ids = r.getStringArray(R.array.cities_id);
+ if (cities.length != timezones.length || ids.length != cities.length) {
+ Log.wtf("City lists sizes are not the same, cannot use the data");
+ return;
+ }
+ CityObj[] tempList = new CityObj [cities.length];
+ for (int i = 0; i < cities.length; i++) {
+ tempList[i] = new CityObj(cities[i], timezones[i], ids[i]);
+ }
+ // Sort alphabetically
+ Arrays.sort(tempList, new Comparator () {
+ @Override
+ public int compare(CityObj c1, CityObj c2) {
+ return mCollator.compare(c1.mCityName, c2.mCityName);
+ }
+ });
+ //Create section indexer and add headers to the cities list
+ String val = null;
+ ArrayList sections = new ArrayList ();
+ ArrayList positions = new ArrayList ();
+ ArrayList items = new ArrayList();
+ int count = 0;
+ for (int i = 0; i < tempList.length; i++) {
+ CityObj city = tempList[i];
+ if (city.mCityId.equals(DELETED_ENTRY)) {
+ continue;
+ }
+ if (!city.mCityName.substring(0, 1).equals(val)) {
+ val = city.mCityName.substring(0, 1);
+ sections.add((new String(val)).toUpperCase());
+ positions.add(count);
+ // Add a header
+ items.add(new CityObj(val, null, null));
+ count++;
+ }
+ items.add(city);
+ count++;
+ }
+ mSectionHeaders = sections.toArray();
+ mSectionPositions = positions.toArray();
+ mAllTheCitiesList = items.toArray();
+ }
+
+ @Override
+ public int getPositionForSection(int section) {
+ return (Integer) mSectionPositions[section];
+ }
+
+ @Override
+ public int getSectionForPosition(int p) {
+ for (int i = 0; i < mSectionPositions.length - 1; i++) {
+ if (p >= (Integer)mSectionPositions[i] && p < (Integer)mSectionPositions[i + 1]) {
+ return i;
+ }
+ }
+ if (p >= (Integer)mSectionPositions[mSectionPositions.length - 1]) {
+ return mSectionPositions.length - 1;
+ }
+ return 0;
+ }
+
+ @Override
+ public Object[] getSections() {
+ return mSectionHeaders;
+ }
+ }
+
+
+ @Override
+ protected void onCreate(Bundle icicle) {
+ super.onCreate(icicle);
+ mFactory = LayoutInflater.from(this);
+ updateLayout();
+ }
+
+ private void updateLayout() {
+ setContentView(R.layout.cities_activity);
+ mCitiesList = (ListView) findViewById(R.id.cities_list);
+ mCitiesList.setFastScrollAlwaysVisible(true);
+ mCitiesList.setScrollBarStyle(View.SCROLLBARS_INSIDE_INSET);
+ mCitiesList.setFastScrollEnabled(true);
+ mUserSelectedCities = Cities.readCitiesFromSharedPrefs(
+ PreferenceManager.getDefaultSharedPreferences(this));
+ mAdapter = new CityAdapter(this, mUserSelectedCities, mFactory);
+ mCitiesList.setAdapter(mAdapter);
+ ActionBar actionBar = getActionBar();
+ if (actionBar != null) {
+ actionBar.setDisplayOptions(ActionBar.DISPLAY_HOME_AS_UP, ActionBar.DISPLAY_HOME_AS_UP);
+ }
+ }
+
+ @Override
+ public void onResume() {
+ super.onResume();
+ if (mAdapter != null) {
+ mAdapter.set24HoursMode(this);
+ }
+ }
+
+
+ @Override
+ public void onPause() {
+ super.onPause();
+ Cities.saveCitiesToSharedPrefs(PreferenceManager.getDefaultSharedPreferences(this),
+ mUserSelectedCities);
+ Intent i = new Intent(Cities.WORLDCLOCK_UPDATE_INTENT);
+ sendBroadcast(i);
+ }
+
+ @Override
+ public boolean onOptionsItemSelected(MenuItem item) {
+ switch (item.getItemId()) {
+ case R.id.menu_item_settings:
+ startActivity(new Intent(this, SettingsActivity.class));
+ return true;
+ case R.id.menu_item_help:
+ Intent i = item.getIntent();
+ if (i != null) {
+ try {
+ startActivity(i);
+ } catch (ActivityNotFoundException e) {
+ // No activity found to match the intent - ignore
+ }
+ }
+ return true;
+ case android.R.id.home:
+ Intent intent = new Intent(this, DeskClock.class);
+ intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
+ startActivity(intent);
+ return true;
+ default:
+ break;
+ }
+ return super.onOptionsItemSelected(item);
+ }
+
+ @Override
+ public boolean onCreateOptionsMenu(Menu menu) {
+ getMenuInflater().inflate(R.menu.cities_menu, menu);
+ MenuItem help = menu.findItem(R.id.menu_item_help);
+ if (help != null) {
+ Utils.prepareHelpMenuItem(this, help);
+ }
+ return super.onCreateOptionsMenu(menu);
+ }
+
+ @Override
+ public void onCheckedChanged(CompoundButton b, boolean checked) {
+ CityObj c = (CityObj)b.getTag();
+ if (checked) {
+ mUserSelectedCities.put(c.mCityId, c);
+ } else {
+ mUserSelectedCities.remove(c.mCityId);
+ }
+ }
+
+ @Override
+ public void onClick(View v) {
+ CompoundButton b = (CompoundButton)v.findViewById(R.id.city_onoff);
+ boolean checked = b.isChecked();
+ onCheckedChanged(b, checked);
+ b.setChecked(!checked);
+ }
+}
diff --git a/_DeskClock/src/com/android/deskclock/worldclock/CityObj.java b/_DeskClock/src/com/android/deskclock/worldclock/CityObj.java
new file mode 100644
index 000000000..75fad54ac
--- /dev/null
+++ b/_DeskClock/src/com/android/deskclock/worldclock/CityObj.java
@@ -0,0 +1,59 @@
+/*
+ * 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.deskclock.worldclock;
+
+import android.content.SharedPreferences;
+
+public class CityObj {
+
+ private static final String CITY_NAME = "city_name_";
+ private static final String CITY_TIME_ZONE = "city_tz_";
+ private static final String CITY_ID = "city_id_";
+
+ public String mCityName;
+ public String mTimeZone;
+ public String mCityId;
+
+ public CityObj(String name, String timezone, String id) {
+ mCityName = name;
+ mTimeZone = timezone;
+ mCityId = id;
+ }
+
+ @Override
+ public String toString() {
+ return "CityObj{" +
+ "name=" + mCityName +
+ ", timezone=" + mTimeZone +
+ ", id=" + mCityId +
+ '}';
+ }
+
+
+ public CityObj(SharedPreferences prefs, int index) {
+ mCityName = prefs.getString(CITY_NAME + index, null);
+ mTimeZone = prefs.getString(CITY_TIME_ZONE + index, null);
+ mCityId = prefs.getString(CITY_ID + index, null);
+ }
+
+ public void saveCityToSharedPrefs(SharedPreferences.Editor editor, int index) {
+ editor.putString (CITY_NAME + index, mCityName);
+ editor.putString (CITY_TIME_ZONE + index, mTimeZone);
+ editor.putString (CITY_ID + index, mCityId);
+ }
+
+}
diff --git a/_DeskClock/src/com/android/deskclock/worldclock/WorldClockAdapter.java b/_DeskClock/src/com/android/deskclock/worldclock/WorldClockAdapter.java
new file mode 100644
index 000000000..12e3c5fa1
--- /dev/null
+++ b/_DeskClock/src/com/android/deskclock/worldclock/WorldClockAdapter.java
@@ -0,0 +1,237 @@
+/*
+ * 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.deskclock.worldclock;
+
+import java.text.Collator;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.Locale;
+import java.util.TimeZone;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.preference.PreferenceManager;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.TextView;
+
+import com.android.deskclock.AnalogClock;
+import com.android.deskclock.DigitalClock;
+import com.android.deskclock.R;
+import com.android.deskclock.SettingsActivity;
+
+public class WorldClockAdapter extends BaseAdapter {
+ protected Object [] mCitiesList;
+ private final LayoutInflater mInflater;
+ private final Context mContext;
+ private String mClockStyle;
+ private final Collator mCollator = Collator.getInstance();
+
+ public WorldClockAdapter(Context context) {
+ super();
+ mContext = context;
+ loadData(context);
+ mInflater = LayoutInflater.from(context);
+ }
+
+ public void reloadData(Context context) {
+ loadData(context);
+ notifyDataSetChanged();
+ }
+
+ public void loadData(Context context) {
+ SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(mContext);
+ mClockStyle = prefs.getString(SettingsActivity.KEY_CLOCK_STYLE,
+ mContext.getResources().getString(R.string.default_clock_style));
+ mCitiesList = Cities.readCitiesFromSharedPrefs(prefs).values().toArray();
+ sortList();
+ mCitiesList = addHomeCity();
+ }
+
+ /***
+ * Adds the home city as the first item of the adapter if the feature is on and the device time
+ * zone is different from the home time zone that was set by the user.
+ * return the list of cities.
+ */
+ private Object[] addHomeCity() {
+ if (needHomeCity()) {
+ SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(mContext);
+ String homeTZ = sharedPref.getString(SettingsActivity.KEY_HOME_TZ, "");
+ CityObj c = new CityObj(
+ mContext.getResources().getString(R.string.home_label), homeTZ, null);
+ Object[] temp = new Object[mCitiesList.length + 1];
+ temp[0] = c;
+ for (int i = 0; i < mCitiesList.length; i++) {
+ temp[i + 1] = mCitiesList[i];
+ }
+ return temp;
+ } else {
+ return mCitiesList;
+ }
+ }
+
+ public boolean needHomeCity() {
+ SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(mContext);
+ if (sharedPref.getBoolean(SettingsActivity.KEY_AUTO_HOME_CLOCK, false)) {
+ String homeTZ = sharedPref.getString(
+ SettingsActivity.KEY_HOME_TZ, TimeZone.getDefault().getID());
+ final Date now = new Date();
+ return TimeZone.getTimeZone(homeTZ).getOffset(now.getTime())
+ != TimeZone.getDefault().getOffset(now.getTime());
+ } else {
+ return false;
+ }
+ }
+
+ public boolean hasHomeCity() {
+ return (mCitiesList != null) && mCitiesList.length > 0
+ && ((CityObj) mCitiesList[0]).mCityId == null;
+ }
+
+ private void sortList() {
+ final Date now = new Date();
+
+ // Sort by the Offset from GMT taking DST into account
+ // and if the same sort by City Name
+ Arrays.sort(mCitiesList, new Comparator