| Methods Summary |
|---|
| private void | animateShowingPublic(long delay, long duration)
final View source = mShowingPublic ? mPrivateLayout : mPublicLayout;
View target = mShowingPublic ? mPublicLayout : mPrivateLayout;
source.setVisibility(View.VISIBLE);
target.setVisibility(View.VISIBLE);
target.setAlpha(0f);
source.animate().cancel();
target.animate().cancel();
source.animate()
.alpha(0f)
.setStartDelay(delay)
.setDuration(duration)
.withEndAction(new Runnable() {
@Override
public void run() {
source.setVisibility(View.INVISIBLE);
}
});
target.animate()
.alpha(1f)
.setStartDelay(delay)
.setDuration(duration);
|
| public void | applyExpansionToLayout()Apply an expansion state to the layout.
boolean expand = isExpanded();
if (expand && mExpandable) {
setActualHeight(mMaxExpandHeight);
} else {
setActualHeight(mRowMinHeight);
}
|
| protected boolean | filterMotionEvent(android.view.MotionEvent event)
return mIsHeadsUp || super.filterMotionEvent(event);
|
| public int | getIntrinsicHeight()
if (isUserLocked()) {
return getActualHeight();
}
boolean inExpansionState = isExpanded();
if (!inExpansionState) {
// not expanded, so we return the collapsed size
return mRowMinHeight;
}
return mShowingPublicForIntrinsicHeight ? mRowMinHeight : getMaxExpandHeight();
|
| public int | getMaxExpandHeight()
return mShowingPublicForIntrinsicHeight ? mRowMinHeight : mMaxExpandHeight;
|
| public int | getMaxHeight()
NotificationContentView showingLayout = getShowingLayout();
return showingLayout.getMaxHeight();
|
| public int | getMinHeight()
NotificationContentView showingLayout = getShowingLayout();
return showingLayout.getMinHeight();
|
| private NotificationContentView | getShowingLayout()
return mShowingPublic ? mPublicLayout : mPrivateLayout;
|
| public android.service.notification.StatusBarNotification | getStatusBarNotification()
return mStatusBarNotification;
|
| public boolean | hasUserChangedExpansion()
return mHasUserChangedExpansion;
|
| public boolean | isClearable()
return mStatusBarNotification != null && mStatusBarNotification.isClearable();
|
| public boolean | isContentExpandable()
NotificationContentView showingLayout = getShowingLayout();
return showingLayout.isContentExpandable();
|
| public boolean | isExpandable()
return mExpandable;
|
| private boolean | isExpanded()Check whether the view state is currently expanded. This is given by the system in {@link
#setSystemExpanded(boolean)} and can be overridden by user expansion or
collapsing in {@link #setUserExpanded(boolean)}. Note that the visual appearance of this
view can differ from this state, if layout params are modified from outside.
return !mExpansionDisabled
&& (!hasUserChangedExpansion() && isSystemExpanded() || isUserExpanded());
|
| public boolean | isMaxExpandHeightInitialized()
return mMaxExpandHeight != 0;
|
| public boolean | isSystemExpanded()
return mIsSystemExpanded;
|
| public boolean | isUserExpanded()
return mUserExpanded;
|
| public boolean | isUserLocked()
return mUserLocked;
|
| private void | logExpansionEvent(boolean userAction, boolean wasExpanded)
final boolean nowExpanded = isExpanded();
if (wasExpanded != nowExpanded && mLogger != null) {
mLogger.logNotificationExpansion(mLoggingKey, userAction, nowExpanded) ;
}
|
| public void | notifyContentUpdated()
mPublicLayout.notifyContentUpdated();
mPrivateLayout.notifyContentUpdated();
|
| protected void | onFinishInflate()
super.onFinishInflate();
mPublicLayout = (NotificationContentView) findViewById(R.id.expandedPublic);
mPrivateLayout = (NotificationContentView) findViewById(R.id.expanded);
ViewStub gutsStub = (ViewStub) findViewById(R.id.notification_guts_stub);
gutsStub.setOnInflateListener(new ViewStub.OnInflateListener() {
@Override
public void onInflate(ViewStub stub, View inflated) {
mGuts = (NotificationGuts) inflated;
mGuts.setClipTopAmount(getClipTopAmount());
mGuts.setActualHeight(getActualHeight());
}
});
mVetoButton = findViewById(R.id.veto);
|
| protected void | onLayout(boolean changed, int left, int top, int right, int bottom)
super.onLayout(changed, left, top, right, bottom);
boolean updateExpandHeight = mMaxExpandHeight == 0 && !mWasReset;
updateMaxExpandHeight();
if (updateExpandHeight) {
applyExpansionToLayout();
}
mWasReset = false;
|
| public boolean | onRequestSendAccessibilityEvent(android.view.View child, android.view.accessibility.AccessibilityEvent event)
if (super.onRequestSendAccessibilityEvent(child, event)) {
// Add a record for the entire layout since its content is somehow small.
// The event comes from a leaf view that is interacted with.
AccessibilityEvent record = AccessibilityEvent.obtain();
onInitializeAccessibilityEvent(record);
dispatchPopulateAccessibilityEvent(record);
event.appendRecord(record);
return true;
}
return false;
|
| public void | reset()Resets this view so it can be re-used for an updated notification.
super.reset();
mRowMinHeight = 0;
final boolean wasExpanded = isExpanded();
mRowMaxHeight = 0;
mExpandable = false;
mHasUserChangedExpansion = false;
mUserLocked = false;
mShowingPublic = false;
mSensitive = false;
mShowingPublicInitialized = false;
mIsSystemExpanded = false;
mExpansionDisabled = false;
mPublicLayout.reset(mIsHeadsUp);
mPrivateLayout.reset(mIsHeadsUp);
resetHeight();
logExpansionEvent(false, wasExpanded);
|
| public void | resetHeight()
if (mIsHeadsUp) {
resetActualHeight();
}
mMaxExpandHeight = 0;
mWasReset = true;
onHeightReset();
requestLayout();
|
| public void | resetUserExpansion()
mHasUserChangedExpansion = false;
mUserExpanded = false;
|
| public void | setActualHeight(int height, boolean notifyListeners)
mPrivateLayout.setActualHeight(height);
mPublicLayout.setActualHeight(height);
if (mGuts != null) {
mGuts.setActualHeight(height);
}
invalidate();
super.setActualHeight(height, notifyListeners);
|
| public void | setClipTopAmount(int clipTopAmount)
super.setClipTopAmount(clipTopAmount);
mPrivateLayout.setClipTopAmount(clipTopAmount);
mPublicLayout.setClipTopAmount(clipTopAmount);
if (mGuts != null) {
mGuts.setClipTopAmount(clipTopAmount);
}
|
| public void | setDark(boolean dark, boolean fade, long delay)
super.setDark(dark, fade, delay);
final NotificationContentView showing = getShowingLayout();
if (showing != null) {
showing.setDark(dark, fade, delay);
}
|
| public void | setExpandable(boolean expandable)
mExpandable = expandable;
|
| public void | setExpansionDisabled(boolean expansionDisabled)
if (expansionDisabled != mExpansionDisabled) {
final boolean wasExpanded = isExpanded();
mExpansionDisabled = expansionDisabled;
logExpansionEvent(false, wasExpanded);
if (wasExpanded != isExpanded()) {
notifyHeightChanged();
}
}
|
| public void | setExpansionLogger(com.android.systemui.statusbar.ExpandableNotificationRow$ExpansionLogger logger, java.lang.String key)
mLogger = logger;
mLoggingKey = key;
|
| public void | setHeadsUp(boolean isHeadsUp)
mIsHeadsUp = isHeadsUp;
|
| public void | setHeightRange(int rowMinHeight, int rowMaxHeight)
mRowMinHeight = rowMinHeight;
mRowMaxHeight = rowMaxHeight;
|
| public void | setHideSensitive(boolean hideSensitive, boolean animated, long delay, long duration)
boolean oldShowingPublic = mShowingPublic;
mShowingPublic = mSensitive && hideSensitive;
if (mShowingPublicInitialized && mShowingPublic == oldShowingPublic) {
return;
}
// bail out if no public version
if (mPublicLayout.getChildCount() == 0) return;
if (!animated) {
mPublicLayout.animate().cancel();
mPrivateLayout.animate().cancel();
mPublicLayout.setAlpha(1f);
mPrivateLayout.setAlpha(1f);
mPublicLayout.setVisibility(mShowingPublic ? View.VISIBLE : View.INVISIBLE);
mPrivateLayout.setVisibility(mShowingPublic ? View.INVISIBLE : View.VISIBLE);
} else {
animateShowingPublic(delay, duration);
}
updateVetoButton();
mShowingPublicInitialized = true;
|
| public void | setHideSensitiveForIntrinsicHeight(boolean hideSensitive)
mShowingPublicForIntrinsicHeight = mSensitive && hideSensitive;
|
| public void | setIconAnimationRunning(boolean running)
setIconAnimationRunning(running, mPublicLayout);
setIconAnimationRunning(running, mPrivateLayout);
|
| private void | setIconAnimationRunning(boolean running, NotificationContentView layout)
if (layout != null) {
View contractedChild = layout.getContractedChild();
View expandedChild = layout.getExpandedChild();
setIconAnimationRunningForChild(running, contractedChild);
setIconAnimationRunningForChild(running, expandedChild);
}
|
| private void | setIconAnimationRunningForChild(boolean running, android.view.View child)
if (child != null) {
ImageView icon = (ImageView) child.findViewById(com.android.internal.R.id.icon);
setIconRunning(icon, running);
ImageView rightIcon = (ImageView) child.findViewById(
com.android.internal.R.id.right_icon);
setIconRunning(rightIcon, running);
}
|
| private void | setIconRunning(android.widget.ImageView imageView, boolean running)
if (imageView != null) {
Drawable drawable = imageView.getDrawable();
if (drawable instanceof AnimationDrawable) {
AnimationDrawable animationDrawable = (AnimationDrawable) drawable;
if (running) {
animationDrawable.start();
} else {
animationDrawable.stop();
}
} else if (drawable instanceof AnimatedVectorDrawable) {
AnimatedVectorDrawable animationDrawable = (AnimatedVectorDrawable) drawable;
if (running) {
animationDrawable.start();
} else {
animationDrawable.stop();
}
}
}
|
| public void | setSensitive(boolean sensitive)
mSensitive = sensitive;
|
| public void | setStatusBarNotification(android.service.notification.StatusBarNotification statusBarNotification)
mStatusBarNotification = statusBarNotification;
updateVetoButton();
|
| public void | setSystemExpanded(boolean expand)Set this notification to be expanded by the system.
if (expand != mIsSystemExpanded) {
final boolean wasExpanded = isExpanded();
mIsSystemExpanded = expand;
notifyHeightChanged();
logExpansionEvent(false, wasExpanded);
}
|
| public void | setUserExpanded(boolean userExpanded)Set this notification to be expanded by the user
if (userExpanded && !mExpandable) return;
final boolean wasExpanded = isExpanded();
mHasUserChangedExpansion = true;
mUserExpanded = userExpanded;
logExpansionEvent(true, wasExpanded);
|
| public void | setUserLocked(boolean userLocked)
mUserLocked = userLocked;
|
| private void | updateMaxExpandHeight()
int intrinsicBefore = getIntrinsicHeight();
mMaxExpandHeight = mPrivateLayout.getMaxHeight();
if (intrinsicBefore != getIntrinsicHeight()) {
notifyHeightChanged();
}
|
| private void | updateVetoButton()
// public versions cannot be dismissed
mVetoButton.setVisibility(isClearable() && !mShowingPublic ? View.VISIBLE : View.GONE);
|
