packages/SystemUI/src/com/android/keyguard/KeyguardSliceView.java - platform/frameworks/base - Gitiles

 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License
  */

 package com.android.keyguard;

 import android.animation.LayoutTransition;
 import android.animation.ObjectAnimator;
 import android.animation.PropertyValuesHolder;
 import android.annotation.ColorInt;
 import android.app.PendingIntent;
 import android.arch.lifecycle.LiveData;
 import android.arch.lifecycle.Observer;
 import android.content.Context;
 import android.graphics.Color;
 import android.graphics.drawable.Drawable;
 import android.net.Uri;
 import android.provider.Settings;
 import android.text.Layout;
 import android.text.TextUtils;
 import android.text.TextUtils.TruncateAt;
 import android.util.AttributeSet;
 import android.util.Log;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.animation.Animation;
 import android.widget.Button;
 import android.widget.LinearLayout;
 import android.widget.TextView;

 import com.android.internal.annotations.VisibleForTesting;
 import com.android.internal.graphics.ColorUtils;
 import com.android.settingslib.Utils;
 import com.android.systemui.Dependency;
 import com.android.systemui.Interpolators;
 import com.android.systemui.R;
 import com.android.systemui.keyguard.KeyguardSliceProvider;
 import com.android.systemui.statusbar.AlphaOptimizedTextView;
 import com.android.systemui.statusbar.policy.ConfigurationController;
 import com.android.systemui.tuner.TunerService;
 import com.android.systemui.util.wakelock.KeepAwakeAnimationListener;

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.function.Consumer;

 import androidx.slice.Slice;
 import androidx.slice.SliceItem;
 import androidx.slice.SliceViewManager;
 import androidx.slice.core.SliceQuery;
 import androidx.slice.widget.ListContent;
 import androidx.slice.widget.RowContent;
 import androidx.slice.widget.SliceLiveData;

 /**
  * View visible under the clock on the lock screen and AoD.
  */
 public class KeyguardSliceView extends LinearLayout implements View.OnClickListener,
         Observer<Slice>, TunerService.Tunable, ConfigurationController.ConfigurationListener {

     private static final String TAG = "KeyguardSliceView";
     public static final int DEFAULT_ANIM_DURATION = 550;

     private final HashMap<View, PendingIntent> mClickActions;
     private Uri mKeyguardSliceUri;
     @VisibleForTesting
     TextView mTitle;
     private Row mRow;
     private int mTextColor;
     private float mDarkAmount = 0;

     private LiveData<Slice> mLiveData;
     private int mIconSize;
     /**
      * Runnable called whenever the view contents change.
      */
     private Runnable mContentChangeListener;
     private boolean mHasHeader;
     private Slice mSlice;
     private boolean mPulsing;

     public KeyguardSliceView(Context context) {
         this(context, null, 0);
     }

     public KeyguardSliceView(Context context, AttributeSet attrs) {
         this(context, attrs, 0);
     }

     public KeyguardSliceView(Context context, AttributeSet attrs, int defStyle) {
         super(context, attrs, defStyle);

         TunerService tunerService = Dependency.get(TunerService.class);
         tunerService.addTunable(this, Settings.Secure.KEYGUARD_SLICE_URI);

         mClickActions = new HashMap<>();

         LayoutTransition transition = new LayoutTransition();
         transition.setStagger(LayoutTransition.CHANGE_APPEARING, DEFAULT_ANIM_DURATION / 2);
         transition.setDuration(LayoutTransition.APPEARING, DEFAULT_ANIM_DURATION);
         transition.setDuration(LayoutTransition.DISAPPEARING, DEFAULT_ANIM_DURATION / 2);
         transition.disableTransitionType(LayoutTransition.CHANGE_APPEARING);
         transition.disableTransitionType(LayoutTransition.CHANGE_DISAPPEARING);
         transition.setInterpolator(LayoutTransition.APPEARING, Interpolators.FAST_OUT_SLOW_IN);
         transition.setInterpolator(LayoutTransition.DISAPPEARING, Interpolators.ALPHA_OUT);
         transition.setAnimateParentHierarchy(false);
         transition.addTransitionListener(new SliceViewTransitionListener());
         setLayoutTransition(transition);
     }

     @Override
     protected void onFinishInflate() {
         super.onFinishInflate();
         mTitle = findViewById(R.id.title);
         mRow = findViewById(R.id.row);
         mTextColor = Utils.getColorAttr(mContext, R.attr.wallpaperTextColor);
     }

     @Override
     protected void onAttachedToWindow() {
         super.onAttachedToWindow();

         // Make sure we always have the most current slice
         mLiveData.observeForever(this);
         Dependency.get(ConfigurationController.class).addCallback(this);
     }

     @Override
     protected void onDetachedFromWindow() {
         super.onDetachedFromWindow();

         mLiveData.removeObserver(this);
         Dependency.get(ConfigurationController.class).removeCallback(this);
     }

     private void showSlice() {
         if (mPulsing || mSlice == null) {
             mTitle.setVisibility(GONE);
             mRow.setVisibility(GONE);
             if (mContentChangeListener != null) {
                 mContentChangeListener.run();
             }
             return;
         }

         ListContent lc = new ListContent(getContext(), mSlice);
         mHasHeader = lc.hasHeader();
         List<SliceItem> subItems = new ArrayList<SliceItem>();
         for (int i = 0; i < lc.getRowItems().size(); i++) {
             SliceItem subItem = lc.getRowItems().get(i);
             String itemUri = subItem.getSlice().getUri().toString();
             // Filter out the action row
             if (!KeyguardSliceProvider.KEYGUARD_ACTION_URI.equals(itemUri)) {
                 subItems.add(subItem);
             }
         }
         if (!mHasHeader) {
             mTitle.setVisibility(GONE);
         } else {
             mTitle.setVisibility(VISIBLE);

             // If there's a header it'll be the first subitem
             RowContent header = new RowContent(getContext(), subItems.get(0),
                     true /* showStartItem */);
             SliceItem mainTitle = header.getTitleItem();
             CharSequence title = mainTitle != null ? mainTitle.getText() : null;
             mTitle.setText(title);
         }

         mClickActions.clear();
         final int subItemsCount = subItems.size();
         final int blendedColor = getTextColor();
         final int startIndex = mHasHeader ? 1 : 0; // First item is header; skip it
         mRow.setVisibility(subItemsCount > 0 ? VISIBLE : GONE);
         for (int i = startIndex; i < subItemsCount; i++) {
             SliceItem item = subItems.get(i);
             RowContent rc = new RowContent(getContext(), item, true /* showStartItem */);
             final Uri itemTag = item.getSlice().getUri();
             // Try to reuse the view if already exists in the layout
             KeyguardSliceButton button = mRow.findViewWithTag(itemTag);
             if (button == null) {
                 button = new KeyguardSliceButton(mContext);
                 button.setTextColor(blendedColor);
                 button.setTag(itemTag);
                 final int viewIndex = i - (mHasHeader ? 1 : 0);
                 mRow.addView(button, viewIndex);
             }

             PendingIntent pendingIntent = null;
             if (rc.getPrimaryAction() != null) {
                 pendingIntent = rc.getPrimaryAction().getAction();
             }
             mClickActions.put(button, pendingIntent);

             final SliceItem titleItem = rc.getTitleItem();
             button.setText(titleItem == null ? null : titleItem.getText());
             button.setContentDescription(rc.getContentDescription());

             Drawable iconDrawable = null;
             SliceItem icon = SliceQuery.find(item.getSlice(),
                     android.app.slice.SliceItem.FORMAT_IMAGE);
             if (icon != null) {
                 iconDrawable = icon.getIcon().loadDrawable(mContext);
                 final int width = (int) (iconDrawable.getIntrinsicWidth()
                         / (float) iconDrawable.getIntrinsicHeight() * mIconSize);
                 iconDrawable.setBounds(0, 0, Math.max(width, 1), mIconSize);
             }
             button.setCompoundDrawables(iconDrawable, null, null, null);
             button.setOnClickListener(this);
             button.setClickable(pendingIntent != null);
         }

         // Removing old views
         for (int i = 0; i < mRow.getChildCount(); i++) {
             View child = mRow.getChildAt(i);
             if (!mClickActions.containsKey(child)) {
                 mRow.removeView(child);
                 i--;
             }
         }

         if (mContentChangeListener != null) {
             mContentChangeListener.run();
         }
     }

     public void setPulsing(boolean pulsing, boolean animate) {
         mPulsing = pulsing;
         LayoutTransition transition = getLayoutTransition();
         if (!animate) {
             setLayoutTransition(null);
         }
         showSlice();
         if (!animate) {
             setLayoutTransition(transition);
         }
     }

     /**
      * Breaks a string in 2 lines where both have similar character count
      * but first line is always longer.
      *
      * @param charSequence Original text.
      * @return Optimal string.
      */
     private static CharSequence findBestLineBreak(CharSequence charSequence) {
         if (TextUtils.isEmpty(charSequence)) {
             return charSequence;
         }

         String source = charSequence.toString();
         // Ignore if there is only 1 word,
         // or if line breaks were manually set.
         if (source.contains("\n") || !source.contains(" ")) {
             return source;
         }

         final String[] words = source.split(" ");
         final StringBuilder optimalString = new StringBuilder(source.length());
         int current = 0;
         while (optimalString.length() < source.length() - optimalString.length()) {
             optimalString.append(words[current]);
             if (current < words.length - 1) {
                 optimalString.append(" ");
             }
             current++;
         }
         optimalString.append("\n");
         for (int i = current; i < words.length; i++) {
             optimalString.append(words[i]);
             if (current < words.length - 1) {
                 optimalString.append(" ");
             }
         }

         return optimalString.toString();
     }

     public void setDarkAmount(float darkAmount) {
         mDarkAmount = darkAmount;
         mRow.setDarkAmount(darkAmount);
         updateTextColors();
     }

     private void updateTextColors() {
         final int blendedColor = getTextColor();
         mTitle.setTextColor(blendedColor);
         int childCount = mRow.getChildCount();
         for (int i = 0; i < childCount; i++) {
             View v = mRow.getChildAt(i);
             if (v instanceof Button) {
                 ((Button) v).setTextColor(blendedColor);
             }
         }
     }

     @Override
     public void onClick(View v) {
         final PendingIntent action = mClickActions.get(v);
         if (action != null) {
             try {
                 action.send();
             } catch (PendingIntent.CanceledException e) {
                 Log.i(TAG, "Pending intent cancelled, nothing to launch", e);
             }
         }
     }

     /**
      * Runnable that gets invoked every time the title or the row visibility changes.
      * @param contentChangeListener The listener.
      */
     public void setContentChangeListener(Runnable contentChangeListener) {
         mContentChangeListener = contentChangeListener;
     }

     public boolean hasHeader() {
         return mHasHeader;
     }

     /**
      * LiveData observer lifecycle.
      * @param slice the new slice content.
      */
     @Override
     public void onChanged(Slice slice) {
         mSlice = slice;
         showSlice();
     }

     @Override
     public void onTuningChanged(String key, String newValue) {
         setupUri(newValue);
     }

     public void setupUri(String uriString) {
         if (uriString == null) {
             uriString = KeyguardSliceProvider.KEYGUARD_SLICE_URI;
         }

         boolean wasObserving = false;
         if (mLiveData != null && mLiveData.hasActiveObservers()) {
             wasObserving = true;
             mLiveData.removeObserver(this);
         }

         mKeyguardSliceUri = Uri.parse(uriString);
         mLiveData = SliceLiveData.fromUri(mContext, mKeyguardSliceUri);

         if (wasObserving) {
             mLiveData.observeForever(this);
         }
     }

     @VisibleForTesting
     int getTextColor() {
         return ColorUtils.blendARGB(mTextColor, Color.WHITE, mDarkAmount);
     }

     @VisibleForTesting
     void setTextColor(@ColorInt int textColor) {
         mTextColor = textColor;
         updateTextColors();
     }

     @Override
     public void onDensityOrFontScaleChanged() {
         mIconSize = mContext.getResources().getDimensionPixelSize(R.dimen.widget_icon_size);
     }

     public void refresh() {
         Slice slice = SliceViewManager.getInstance(getContext()).bindSlice(mKeyguardSliceUri);
         onChanged(slice);
     }

     public static class Row extends LinearLayout {

         /**
          * This view is visible in AOD, which means that the device will sleep if we
          * don't hold a wake lock. We want to enter doze only after all views have reached
          * their desired positions.
          */
         private final Animation.AnimationListener mKeepAwakeListener;
         private float mDarkAmount;

         public Row(Context context) {
             this(context, null);
         }

         public Row(Context context, AttributeSet attrs) {
             this(context, attrs, 0);
         }

         public Row(Context context, AttributeSet attrs, int defStyleAttr) {
             this(context, attrs, defStyleAttr, 0);
         }

         public Row(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
             super(context, attrs, defStyleAttr, defStyleRes);
             mKeepAwakeListener = new KeepAwakeAnimationListener(mContext);
         }

         @Override
         protected void onFinishInflate() {
             LayoutTransition transition = new LayoutTransition();
             transition.setDuration(DEFAULT_ANIM_DURATION);

             PropertyValuesHolder left = PropertyValuesHolder.ofInt("left", 0, 1);
             PropertyValuesHolder right = PropertyValuesHolder.ofInt("right", 0, 1);
             ObjectAnimator changeAnimator = ObjectAnimator.ofPropertyValuesHolder((Object) null,
                     left, right);
             transition.setAnimator(LayoutTransition.CHANGE_APPEARING, changeAnimator);
             transition.setAnimator(LayoutTransition.CHANGE_DISAPPEARING, changeAnimator);
             transition.setInterpolator(LayoutTransition.CHANGE_APPEARING,
                     Interpolators.ACCELERATE_DECELERATE);
             transition.setInterpolator(LayoutTransition.CHANGE_DISAPPEARING,
                     Interpolators.ACCELERATE_DECELERATE);
             transition.setStartDelay(LayoutTransition.CHANGE_APPEARING, DEFAULT_ANIM_DURATION);
             transition.setStartDelay(LayoutTransition.CHANGE_DISAPPEARING, DEFAULT_ANIM_DURATION);

             ObjectAnimator appearAnimator = ObjectAnimator.ofFloat(null, "alpha", 0f, 1f);
             transition.setAnimator(LayoutTransition.APPEARING, appearAnimator);
             transition.setInterpolator(LayoutTransition.APPEARING, Interpolators.ALPHA_IN);

             ObjectAnimator disappearAnimator = ObjectAnimator.ofFloat(null, "alpha", 1f, 0f);
             transition.setInterpolator(LayoutTransition.DISAPPEARING, Interpolators.ALPHA_OUT);
             transition.setDuration(LayoutTransition.DISAPPEARING, DEFAULT_ANIM_DURATION / 4);
             transition.setAnimator(LayoutTransition.DISAPPEARING, disappearAnimator);

             transition.setAnimateParentHierarchy(false);
             setLayoutTransition(transition);
         }

         @Override
         protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
             int width = MeasureSpec.getSize(widthMeasureSpec);
             int childCount = getChildCount();
             for (int i = 0; i < childCount; i++) {
                 View child = getChildAt(i);
                 if (child instanceof KeyguardSliceButton) {
                     ((KeyguardSliceButton) child).setMaxWidth(width / childCount);
                 }
             }
             super.onMeasure(widthMeasureSpec, heightMeasureSpec);
         }

         public void setDarkAmount(float darkAmount) {
             boolean isAwake = darkAmount != 0;
             boolean wasAwake = mDarkAmount != 0;
             if (isAwake == wasAwake) {
                 return;
             }
             mDarkAmount = darkAmount;
             setLayoutAnimationListener(isAwake ? null : mKeepAwakeListener);
         }

         @Override
         public boolean hasOverlappingRendering() {
             return false;
         }
     }

     /**
      * Representation of an item that appears under the clock on main keyguard message.
      */
     @VisibleForTesting
     static class KeyguardSliceButton extends Button implements
             ConfigurationController.ConfigurationListener {

         public KeyguardSliceButton(Context context) {
             super(context, null /* attrs */, 0 /* styleAttr */,
                     com.android.keyguard.R.style.TextAppearance_Keyguard_Secondary);
             onDensityOrFontScaleChanged();
             setEllipsize(TruncateAt.END);
         }

         @Override
         protected void onAttachedToWindow() {
             super.onAttachedToWindow();
             Dependency.get(ConfigurationController.class).addCallback(this);
         }

         @Override
         protected void onDetachedFromWindow() {
             super.onDetachedFromWindow();
             Dependency.get(ConfigurationController.class).removeCallback(this);
         }

         @Override
         public void onDensityOrFontScaleChanged() {
             updatePadding();
         }

         @Override
         public void setText(CharSequence text, BufferType type) {
             super.setText(text, type);
             updatePadding();
         }

         private void updatePadding() {
             boolean hasText = !TextUtils.isEmpty(getText());
             int horizontalPadding = (int) getContext().getResources()
                     .getDimension(R.dimen.widget_horizontal_padding) / 2;
             setPadding(horizontalPadding, 0, horizontalPadding * (hasText ? 1 : -1), 0);
             setCompoundDrawablePadding((int) mContext.getResources()
                     .getDimension(R.dimen.widget_icon_padding));
         }

         @Override
         public void setTextColor(int color) {
             super.setTextColor(color);
             updateDrawableColors();
         }

         @Override
         public void setCompoundDrawables(Drawable left, Drawable top, Drawable right,
                 Drawable bottom) {
             super.setCompoundDrawables(left, top, right, bottom);
             updateDrawableColors();
             updatePadding();
         }

         private void updateDrawableColors() {
             final int color = getCurrentTextColor();
             for (Drawable drawable : getCompoundDrawables()) {
                 if (drawable != null) {
                     drawable.setTint(color);
                 }
             }
         }
     }

     /**
      * A text view that will split its contents in 2 lines when possible.
      */
     static class TitleView extends AlphaOptimizedTextView {

         public TitleView(Context context) {
             super(context);
         }

         public TitleView(Context context, AttributeSet attrs) {
             super(context, attrs);
         }

         public TitleView(Context context, AttributeSet attrs, int defStyleAttr) {
             super(context, attrs, defStyleAttr);
         }

         public TitleView(Context context, AttributeSet attrs, int defStyleAttr,
                 int defStyleRes) {
             super(context, attrs, defStyleAttr, defStyleRes);
         }

         @Override
         protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
             super.onMeasure(widthMeasureSpec, heightMeasureSpec);

             Layout layout = getLayout();
             int lineCount = layout.getLineCount();
             boolean ellipsizing = layout.getEllipsisCount(lineCount - 1) != 0;
             if (lineCount > 0 && !ellipsizing) {
                 CharSequence title = getText();
                 CharSequence bestLineBreak = findBestLineBreak(title);
                 if (!TextUtils.equals(title, bestLineBreak)) {
                     setText(bestLineBreak);
                     super.onMeasure(widthMeasureSpec, heightMeasureSpec);
                 }
             }
         }
     }

     private class SliceViewTransitionListener implements LayoutTransition.TransitionListener {
         @Override
         public void startTransition(LayoutTransition transition, ViewGroup container, View view,
                 int transitionType) {
             switch (transitionType) {
                 case  LayoutTransition.APPEARING:
                     int translation = getResources().getDimensionPixelSize(
                             R.dimen.pulsing_notification_appear_translation);
                     view.setTranslationY(translation);
                     view.animate()
                             .translationY(0)
                             .setDuration(DEFAULT_ANIM_DURATION)
                             .setInterpolator(Interpolators.ALPHA_IN)
                             .start();
                     break;
                 case LayoutTransition.DISAPPEARING:
                     if (view == mTitle) {
                         // Translate the view to the inverse of its height, so the layout event
                         // won't misposition it.
                         LayoutParams params = (LayoutParams) mTitle.getLayoutParams();
                         int margin = params.topMargin + params.bottomMargin;
                         mTitle.setTranslationY(-mTitle.getHeight() - margin);
                     }
                     break;
             }
         }

         @Override
         public void endTransition(LayoutTransition transition, ViewGroup container, View view,
                 int transitionType) {

         }
     }
 }
	/*
	* Copyright (C) 2017 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License
	*/

	package com.android.keyguard;

	import android.animation.LayoutTransition;
	import android.animation.ObjectAnimator;
	import android.animation.PropertyValuesHolder;
	import android.annotation.ColorInt;
	import android.app.PendingIntent;
	import android.arch.lifecycle.LiveData;
	import android.arch.lifecycle.Observer;
	import android.content.Context;
	import android.graphics.Color;
	import android.graphics.drawable.Drawable;
	import android.net.Uri;
	import android.provider.Settings;
	import android.text.Layout;
	import android.text.TextUtils;
	import android.text.TextUtils.TruncateAt;
	import android.util.AttributeSet;
	import android.util.Log;
	import android.view.View;
	import android.view.ViewGroup;
	import android.view.animation.Animation;
	import android.widget.Button;
	import android.widget.LinearLayout;
	import android.widget.TextView;

	import com.android.internal.annotations.VisibleForTesting;
	import com.android.internal.graphics.ColorUtils;
	import com.android.settingslib.Utils;
	import com.android.systemui.Dependency;
	import com.android.systemui.Interpolators;
	import com.android.systemui.R;
	import com.android.systemui.keyguard.KeyguardSliceProvider;
	import com.android.systemui.statusbar.AlphaOptimizedTextView;
	import com.android.systemui.statusbar.policy.ConfigurationController;
	import com.android.systemui.tuner.TunerService;
	import com.android.systemui.util.wakelock.KeepAwakeAnimationListener;

	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.function.Consumer;

	import androidx.slice.Slice;
	import androidx.slice.SliceItem;
	import androidx.slice.SliceViewManager;
	import androidx.slice.core.SliceQuery;
	import androidx.slice.widget.ListContent;
	import androidx.slice.widget.RowContent;
	import androidx.slice.widget.SliceLiveData;

	/**
	* View visible under the clock on the lock screen and AoD.
	*/
	public class KeyguardSliceView extends LinearLayout implements View.OnClickListener,
	Observer<Slice>, TunerService.Tunable, ConfigurationController.ConfigurationListener {

	private static final String TAG = "KeyguardSliceView";
	public static final int DEFAULT_ANIM_DURATION = 550;

	private final HashMap<View, PendingIntent> mClickActions;
	private Uri mKeyguardSliceUri;
	@VisibleForTesting
	TextView mTitle;
	private Row mRow;
	private int mTextColor;
	private float mDarkAmount = 0;

	private LiveData<Slice> mLiveData;
	private int mIconSize;
	/**
	* Runnable called whenever the view contents change.
	*/
	private Runnable mContentChangeListener;
	private boolean mHasHeader;
	private Slice mSlice;
	private boolean mPulsing;

	public KeyguardSliceView(Context context) {
	this(context, null, 0);
	}

	public KeyguardSliceView(Context context, AttributeSet attrs) {
	this(context, attrs, 0);
	}

	public KeyguardSliceView(Context context, AttributeSet attrs, int defStyle) {
	super(context, attrs, defStyle);

	TunerService tunerService = Dependency.get(TunerService.class);
	tunerService.addTunable(this, Settings.Secure.KEYGUARD_SLICE_URI);

	mClickActions = new HashMap<>();

	LayoutTransition transition = new LayoutTransition();
	transition.setStagger(LayoutTransition.CHANGE_APPEARING, DEFAULT_ANIM_DURATION / 2);
	transition.setDuration(LayoutTransition.APPEARING, DEFAULT_ANIM_DURATION);
	transition.setDuration(LayoutTransition.DISAPPEARING, DEFAULT_ANIM_DURATION / 2);
	transition.disableTransitionType(LayoutTransition.CHANGE_APPEARING);
	transition.disableTransitionType(LayoutTransition.CHANGE_DISAPPEARING);
	transition.setInterpolator(LayoutTransition.APPEARING, Interpolators.FAST_OUT_SLOW_IN);
	transition.setInterpolator(LayoutTransition.DISAPPEARING, Interpolators.ALPHA_OUT);
	transition.setAnimateParentHierarchy(false);
	transition.addTransitionListener(new SliceViewTransitionListener());
	setLayoutTransition(transition);
	}

	@Override
	protected void onFinishInflate() {
	super.onFinishInflate();
	mTitle = findViewById(R.id.title);
	mRow = findViewById(R.id.row);
	mTextColor = Utils.getColorAttr(mContext, R.attr.wallpaperTextColor);
	}

	@Override
	protected void onAttachedToWindow() {
	super.onAttachedToWindow();

	// Make sure we always have the most current slice
	mLiveData.observeForever(this);
	Dependency.get(ConfigurationController.class).addCallback(this);
	}

	@Override
	protected void onDetachedFromWindow() {
	super.onDetachedFromWindow();

	mLiveData.removeObserver(this);
	Dependency.get(ConfigurationController.class).removeCallback(this);
	}

	private void showSlice() {
	if (mPulsing \|\| mSlice == null) {
	mTitle.setVisibility(GONE);
	mRow.setVisibility(GONE);
	if (mContentChangeListener != null) {
	mContentChangeListener.run();
	}
	return;
	}

	ListContent lc = new ListContent(getContext(), mSlice);
	mHasHeader = lc.hasHeader();
	List<SliceItem> subItems = new ArrayList<SliceItem>();
	for (int i = 0; i < lc.getRowItems().size(); i++) {
	SliceItem subItem = lc.getRowItems().get(i);
	String itemUri = subItem.getSlice().getUri().toString();
	// Filter out the action row
	if (!KeyguardSliceProvider.KEYGUARD_ACTION_URI.equals(itemUri)) {
	subItems.add(subItem);
	}
	}
	if (!mHasHeader) {
	mTitle.setVisibility(GONE);
	} else {
	mTitle.setVisibility(VISIBLE);

	// If there's a header it'll be the first subitem
	RowContent header = new RowContent(getContext(), subItems.get(0),
	true /* showStartItem */);
	SliceItem mainTitle = header.getTitleItem();
	CharSequence title = mainTitle != null ? mainTitle.getText() : null;
	mTitle.setText(title);
	}

	mClickActions.clear();
	final int subItemsCount = subItems.size();
	final int blendedColor = getTextColor();
	final int startIndex = mHasHeader ? 1 : 0; // First item is header; skip it
	mRow.setVisibility(subItemsCount > 0 ? VISIBLE : GONE);
	for (int i = startIndex; i < subItemsCount; i++) {
	SliceItem item = subItems.get(i);
	RowContent rc = new RowContent(getContext(), item, true /* showStartItem */);
	final Uri itemTag = item.getSlice().getUri();
	// Try to reuse the view if already exists in the layout
	KeyguardSliceButton button = mRow.findViewWithTag(itemTag);
	if (button == null) {
	button = new KeyguardSliceButton(mContext);
	button.setTextColor(blendedColor);
	button.setTag(itemTag);
	final int viewIndex = i - (mHasHeader ? 1 : 0);
	mRow.addView(button, viewIndex);
	}

	PendingIntent pendingIntent = null;
	if (rc.getPrimaryAction() != null) {
	pendingIntent = rc.getPrimaryAction().getAction();
	}
	mClickActions.put(button, pendingIntent);

	final SliceItem titleItem = rc.getTitleItem();
	button.setText(titleItem == null ? null : titleItem.getText());
	button.setContentDescription(rc.getContentDescription());

	Drawable iconDrawable = null;
	SliceItem icon = SliceQuery.find(item.getSlice(),
	android.app.slice.SliceItem.FORMAT_IMAGE);
	if (icon != null) {
	iconDrawable = icon.getIcon().loadDrawable(mContext);
	final int width = (int) (iconDrawable.getIntrinsicWidth()
	/ (float) iconDrawable.getIntrinsicHeight() * mIconSize);
	iconDrawable.setBounds(0, 0, Math.max(width, 1), mIconSize);
	}
	button.setCompoundDrawables(iconDrawable, null, null, null);
	button.setOnClickListener(this);
	button.setClickable(pendingIntent != null);
	}

	// Removing old views
	for (int i = 0; i < mRow.getChildCount(); i++) {
	View child = mRow.getChildAt(i);
	if (!mClickActions.containsKey(child)) {
	mRow.removeView(child);
	i--;
	}
	}

	if (mContentChangeListener != null) {
	mContentChangeListener.run();
	}
	}

	public void setPulsing(boolean pulsing, boolean animate) {
	mPulsing = pulsing;
	LayoutTransition transition = getLayoutTransition();
	if (!animate) {
	setLayoutTransition(null);
	}
	showSlice();
	if (!animate) {
	setLayoutTransition(transition);
	}
	}

	/**
	* Breaks a string in 2 lines where both have similar character count
	* but first line is always longer.
	*
	* @param charSequence Original text.
	* @return Optimal string.
	*/
	private static CharSequence findBestLineBreak(CharSequence charSequence) {
	if (TextUtils.isEmpty(charSequence)) {
	return charSequence;
	}

	String source = charSequence.toString();
	// Ignore if there is only 1 word,
	// or if line breaks were manually set.
	if (source.contains("\n") \|\| !source.contains(" ")) {
	return source;
	}

	final String[] words = source.split(" ");
	final StringBuilder optimalString = new StringBuilder(source.length());
	int current = 0;
	while (optimalString.length() < source.length() - optimalString.length()) {
	optimalString.append(words[current]);
	if (current < words.length - 1) {
	optimalString.append(" ");
	}
	current++;
	}
	optimalString.append("\n");
	for (int i = current; i < words.length; i++) {
	optimalString.append(words[i]);
	if (current < words.length - 1) {
	optimalString.append(" ");
	}
	}

	return optimalString.toString();
	}

	public void setDarkAmount(float darkAmount) {
	mDarkAmount = darkAmount;
	mRow.setDarkAmount(darkAmount);
	updateTextColors();
	}

	private void updateTextColors() {
	final int blendedColor = getTextColor();
	mTitle.setTextColor(blendedColor);
	int childCount = mRow.getChildCount();
	for (int i = 0; i < childCount; i++) {
	View v = mRow.getChildAt(i);
	if (v instanceof Button) {
	((Button) v).setTextColor(blendedColor);
	}
	}
	}

	@Override
	public void onClick(View v) {
	final PendingIntent action = mClickActions.get(v);
	if (action != null) {
	try {
	action.send();
	} catch (PendingIntent.CanceledException e) {
	Log.i(TAG, "Pending intent cancelled, nothing to launch", e);
	}
	}
	}

	/**
	* Runnable that gets invoked every time the title or the row visibility changes.
	* @param contentChangeListener The listener.
	*/
	public void setContentChangeListener(Runnable contentChangeListener) {
	mContentChangeListener = contentChangeListener;
	}

	public boolean hasHeader() {
	return mHasHeader;
	}

	/**
	* LiveData observer lifecycle.
	* @param slice the new slice content.
	*/
	@Override
	public void onChanged(Slice slice) {
	mSlice = slice;
	showSlice();
	}

	@Override
	public void onTuningChanged(String key, String newValue) {
	setupUri(newValue);
	}

	public void setupUri(String uriString) {
	if (uriString == null) {
	uriString = KeyguardSliceProvider.KEYGUARD_SLICE_URI;
	}

	boolean wasObserving = false;
	if (mLiveData != null && mLiveData.hasActiveObservers()) {
	wasObserving = true;
	mLiveData.removeObserver(this);
	}

	mKeyguardSliceUri = Uri.parse(uriString);
	mLiveData = SliceLiveData.fromUri(mContext, mKeyguardSliceUri);

	if (wasObserving) {
	mLiveData.observeForever(this);
	}
	}

	@VisibleForTesting
	int getTextColor() {
	return ColorUtils.blendARGB(mTextColor, Color.WHITE, mDarkAmount);
	}

	@VisibleForTesting
	void setTextColor(@ColorInt int textColor) {
	mTextColor = textColor;
	updateTextColors();
	}

	@Override
	public void onDensityOrFontScaleChanged() {
	mIconSize = mContext.getResources().getDimensionPixelSize(R.dimen.widget_icon_size);
	}

	public void refresh() {
	Slice slice = SliceViewManager.getInstance(getContext()).bindSlice(mKeyguardSliceUri);
	onChanged(slice);
	}

	public static class Row extends LinearLayout {

	/**
	* This view is visible in AOD, which means that the device will sleep if we
	* don't hold a wake lock. We want to enter doze only after all views have reached
	* their desired positions.
	*/
	private final Animation.AnimationListener mKeepAwakeListener;
	private float mDarkAmount;

	public Row(Context context) {
	this(context, null);
	}

	public Row(Context context, AttributeSet attrs) {
	this(context, attrs, 0);
	}

	public Row(Context context, AttributeSet attrs, int defStyleAttr) {
	this(context, attrs, defStyleAttr, 0);
	}

	public Row(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
	super(context, attrs, defStyleAttr, defStyleRes);
	mKeepAwakeListener = new KeepAwakeAnimationListener(mContext);
	}

	@Override
	protected void onFinishInflate() {
	LayoutTransition transition = new LayoutTransition();
	transition.setDuration(DEFAULT_ANIM_DURATION);

	PropertyValuesHolder left = PropertyValuesHolder.ofInt("left", 0, 1);
	PropertyValuesHolder right = PropertyValuesHolder.ofInt("right", 0, 1);
	ObjectAnimator changeAnimator = ObjectAnimator.ofPropertyValuesHolder((Object) null,
	left, right);
	transition.setAnimator(LayoutTransition.CHANGE_APPEARING, changeAnimator);
	transition.setAnimator(LayoutTransition.CHANGE_DISAPPEARING, changeAnimator);
	transition.setInterpolator(LayoutTransition.CHANGE_APPEARING,
	Interpolators.ACCELERATE_DECELERATE);
	transition.setInterpolator(LayoutTransition.CHANGE_DISAPPEARING,
	Interpolators.ACCELERATE_DECELERATE);
	transition.setStartDelay(LayoutTransition.CHANGE_APPEARING, DEFAULT_ANIM_DURATION);
	transition.setStartDelay(LayoutTransition.CHANGE_DISAPPEARING, DEFAULT_ANIM_DURATION);

	ObjectAnimator appearAnimator = ObjectAnimator.ofFloat(null, "alpha", 0f, 1f);
	transition.setAnimator(LayoutTransition.APPEARING, appearAnimator);
	transition.setInterpolator(LayoutTransition.APPEARING, Interpolators.ALPHA_IN);

	ObjectAnimator disappearAnimator = ObjectAnimator.ofFloat(null, "alpha", 1f, 0f);
	transition.setInterpolator(LayoutTransition.DISAPPEARING, Interpolators.ALPHA_OUT);
	transition.setDuration(LayoutTransition.DISAPPEARING, DEFAULT_ANIM_DURATION / 4);
	transition.setAnimator(LayoutTransition.DISAPPEARING, disappearAnimator);

	transition.setAnimateParentHierarchy(false);
	setLayoutTransition(transition);
	}

	@Override
	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
	int width = MeasureSpec.getSize(widthMeasureSpec);
	int childCount = getChildCount();
	for (int i = 0; i < childCount; i++) {
	View child = getChildAt(i);
	if (child instanceof KeyguardSliceButton) {
	((KeyguardSliceButton) child).setMaxWidth(width / childCount);
	}
	}
	super.onMeasure(widthMeasureSpec, heightMeasureSpec);
	}

	public void setDarkAmount(float darkAmount) {
	boolean isAwake = darkAmount != 0;
	boolean wasAwake = mDarkAmount != 0;
	if (isAwake == wasAwake) {
	return;
	}
	mDarkAmount = darkAmount;
	setLayoutAnimationListener(isAwake ? null : mKeepAwakeListener);
	}

	@Override
	public boolean hasOverlappingRendering() {
	return false;
	}
	}

	/**
	* Representation of an item that appears under the clock on main keyguard message.
	*/
	@VisibleForTesting
	static class KeyguardSliceButton extends Button implements
	ConfigurationController.ConfigurationListener {

	public KeyguardSliceButton(Context context) {
	super(context, null /* attrs /, 0 / styleAttr */,
	com.android.keyguard.R.style.TextAppearance_Keyguard_Secondary);
	onDensityOrFontScaleChanged();
	setEllipsize(TruncateAt.END);
	}

	@Override
	protected void onAttachedToWindow() {
	super.onAttachedToWindow();
	Dependency.get(ConfigurationController.class).addCallback(this);
	}

	@Override
	protected void onDetachedFromWindow() {
	super.onDetachedFromWindow();
	Dependency.get(ConfigurationController.class).removeCallback(this);
	}

	@Override
	public void onDensityOrFontScaleChanged() {
	updatePadding();
	}

	@Override
	public void setText(CharSequence text, BufferType type) {
	super.setText(text, type);
	updatePadding();
	}

	private void updatePadding() {
	boolean hasText = !TextUtils.isEmpty(getText());
	int horizontalPadding = (int) getContext().getResources()
	.getDimension(R.dimen.widget_horizontal_padding) / 2;
	setPadding(horizontalPadding, 0, horizontalPadding * (hasText ? 1 : -1), 0);
	setCompoundDrawablePadding((int) mContext.getResources()
	.getDimension(R.dimen.widget_icon_padding));
	}

	@Override
	public void setTextColor(int color) {
	super.setTextColor(color);
	updateDrawableColors();
	}

	@Override
	public void setCompoundDrawables(Drawable left, Drawable top, Drawable right,
	Drawable bottom) {
	super.setCompoundDrawables(left, top, right, bottom);
	updateDrawableColors();
	updatePadding();
	}

	private void updateDrawableColors() {
	final int color = getCurrentTextColor();
	for (Drawable drawable : getCompoundDrawables()) {
	if (drawable != null) {
	drawable.setTint(color);
	}
	}
	}
	}

	/**
	* A text view that will split its contents in 2 lines when possible.
	*/
	static class TitleView extends AlphaOptimizedTextView {

	public TitleView(Context context) {
	super(context);
	}

	public TitleView(Context context, AttributeSet attrs) {
	super(context, attrs);
	}

	public TitleView(Context context, AttributeSet attrs, int defStyleAttr) {
	super(context, attrs, defStyleAttr);
	}

	public TitleView(Context context, AttributeSet attrs, int defStyleAttr,
	int defStyleRes) {
	super(context, attrs, defStyleAttr, defStyleRes);
	}

	@Override
	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
	super.onMeasure(widthMeasureSpec, heightMeasureSpec);

	Layout layout = getLayout();
	int lineCount = layout.getLineCount();
	boolean ellipsizing = layout.getEllipsisCount(lineCount - 1) != 0;
	if (lineCount > 0 && !ellipsizing) {
	CharSequence title = getText();
	CharSequence bestLineBreak = findBestLineBreak(title);
	if (!TextUtils.equals(title, bestLineBreak)) {
	setText(bestLineBreak);
	super.onMeasure(widthMeasureSpec, heightMeasureSpec);
	}
	}
	}
	}

	private class SliceViewTransitionListener implements LayoutTransition.TransitionListener {
	@Override
	public void startTransition(LayoutTransition transition, ViewGroup container, View view,
	int transitionType) {
	switch (transitionType) {
	case LayoutTransition.APPEARING:
	int translation = getResources().getDimensionPixelSize(
	R.dimen.pulsing_notification_appear_translation);
	view.setTranslationY(translation);
	view.animate()
	.translationY(0)
	.setDuration(DEFAULT_ANIM_DURATION)
	.setInterpolator(Interpolators.ALPHA_IN)
	.start();
	break;
	case LayoutTransition.DISAPPEARING:
	if (view == mTitle) {
	// Translate the view to the inverse of its height, so the layout event
	// won't misposition it.
	LayoutParams params = (LayoutParams) mTitle.getLayoutParams();
	int margin = params.topMargin + params.bottomMargin;
	mTitle.setTranslationY(-mTitle.getHeight() - margin);
	}
	break;
	}
	}

	@Override
	public void endTransition(LayoutTransition transition, ViewGroup container, View view,
	int transitionType) {

	}
	}
	}