| Methods Summary |
|---|
| private void | addDefaultStatusWidget(int index)
LayoutInflater inflater = LayoutInflater.from(mContext);
View statusWidget = inflater.inflate(R.layout.keyguard_status_view, null, true);
mAppWidgetContainer.addWidget(statusWidget, index);
|
| private void | addDefaultWidgets()
if (!mSafeModeEnabled && !widgetsDisabled()) {
LayoutInflater inflater = LayoutInflater.from(mContext);
View addWidget = inflater.inflate(R.layout.keyguard_add_widget, this, false);
mAppWidgetContainer.addWidget(addWidget, 0);
View addWidgetButton = addWidget.findViewById(R.id.keyguard_add_widget_view);
addWidgetButton.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// Pass in an invalid widget id... the picker will allocate an ID for us
getActivityLauncher().launchWidgetPicker(AppWidgetManager.INVALID_APPWIDGET_ID);
}
});
}
// We currently disable cameras in safe mode because we support loading 3rd party
// cameras we can't trust. TODO: plumb safe mode into camera creation code and only
// inflate system-provided camera?
if (!mSafeModeEnabled && !cameraDisabledByDpm() && mUserSetupCompleted
&& mContext.getResources().getBoolean(R.bool.kg_enable_camera_default_widget)) {
View cameraWidget = CameraWidgetFrame.create(mContext, mCameraWidgetCallbacks,
getActivityLauncher());
if (cameraWidget != null) {
mAppWidgetContainer.addWidget(cameraWidget);
}
}
|
| void | addWidget(android.appwidget.AppWidgetHostView view, int pageIndex)
mAppWidgetContainer.addWidget(view, pageIndex);
|
| private boolean | addWidget(int appId, int pageIndex, boolean updateDbIfFailed)
AppWidgetProviderInfo appWidgetInfo = mAppWidgetManager.getAppWidgetInfo(appId);
if (appWidgetInfo != null) {
AppWidgetHostView view = mAppWidgetHost.createView(mContext, appId, appWidgetInfo);
addWidget(view, pageIndex);
return true;
} else {
if (updateDbIfFailed) {
Log.w(TAG, "*** AppWidgetInfo for app widget id " + appId + " was null for user"
+ mUserId + ", deleting");
mAppWidgetHost.deleteAppWidgetId(appId);
mLockPatternUtils.removeAppWidget(appId);
}
return false;
}
|
| private void | addWidgetsFromSettings()
if (mSafeModeEnabled || widgetsDisabled()) {
addDefaultStatusWidget(0);
return;
}
int insertionIndex = getInsertPageIndex();
// Add user-selected widget
final int[] widgets = mLockPatternUtils.getAppWidgets();
if (widgets == null) {
Log.d(TAG, "Problem reading widgets");
} else {
for (int i = widgets.length -1; i >= 0; i--) {
if (widgets[i] == LockPatternUtils.ID_DEFAULT_STATUS_WIDGET) {
addDefaultStatusWidget(insertionIndex);
} else {
// We add the widgets from left to right, starting after the first page after
// the add page. We count down, since the order will be persisted from right
// to left, starting after camera.
addWidget(widgets[i], insertionIndex, true);
}
}
}
|
| private int | allocateIdForDefaultAppWidget()
int appWidgetId;
Resources res = getContext().getResources();
ComponentName defaultAppWidget = new ComponentName(
res.getString(R.string.widget_default_package_name),
res.getString(R.string.widget_default_class_name));
// Note: we don't support configuring the widget
appWidgetId = mAppWidgetHost.allocateAppWidgetId();
try {
mAppWidgetManager.bindAppWidgetId(appWidgetId, defaultAppWidget);
} catch (IllegalArgumentException e) {
Log.e(TAG, "Error when trying to bind default AppWidget: " + e);
mAppWidgetHost.deleteAppWidgetId(appWidgetId);
appWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID;
}
return appWidgetId;
|
| private boolean | cameraDisabledByDpm()
return mCameraDisabled
|| (mDisabledFeatures & DevicePolicyManager.KEYGUARD_DISABLE_SECURE_CAMERA) != 0;
|
| public void | checkAppWidgetConsistency()
final int childCount = mAppWidgetContainer.getChildCount();
boolean widgetPageExists = false;
for (int i = 0; i < childCount; i++) {
if (mAppWidgetContainer.isWidgetPage(i)) {
widgetPageExists = true;
break;
}
}
if (!widgetPageExists) {
final int insertPageIndex = getInsertPageIndex();
final boolean userAddedWidgetsEnabled = !widgetsDisabled();
boolean addedDefaultAppWidget = false;
if (!mSafeModeEnabled) {
if (userAddedWidgetsEnabled) {
int appWidgetId = allocateIdForDefaultAppWidget();
if (appWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID) {
addedDefaultAppWidget = addWidget(appWidgetId, insertPageIndex, true);
}
} else {
// note: even if widgetsDisabledByDpm() returns true, we still bind/create
// the default appwidget if possible
int appWidgetId = mLockPatternUtils.getFallbackAppWidgetId();
if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {
appWidgetId = allocateIdForDefaultAppWidget();
if (appWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID) {
mLockPatternUtils.writeFallbackAppWidgetId(appWidgetId);
}
}
if (appWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID) {
addedDefaultAppWidget = addWidget(appWidgetId, insertPageIndex, false);
if (!addedDefaultAppWidget) {
mAppWidgetHost.deleteAppWidgetId(appWidgetId);
mLockPatternUtils.writeFallbackAppWidgetId(
AppWidgetManager.INVALID_APPWIDGET_ID);
}
}
}
}
// Use the built-in status/clock view if we can't inflate the default widget
if (!addedDefaultAppWidget) {
addDefaultStatusWidget(insertPageIndex);
}
// trigger DB updates only if user-added widgets are enabled
if (!mSafeModeEnabled && userAddedWidgetsEnabled) {
mAppWidgetContainer.onAddView(
mAppWidgetContainer.getChildAt(insertPageIndex), insertPageIndex);
}
}
|
| public void | cleanUp()
// Make sure we let go of all widgets and their package contexts promptly. If we don't do
// this, and the associated application is uninstalled, it can cause a soft reboot.
int count = mAppWidgetContainer.getChildCount();
for (int i = 0; i < count; i++) {
KeyguardWidgetFrame frame = mAppWidgetContainer.getWidgetPageAt(i);
frame.removeAllViews();
}
getSecurityContainer().onPause(); // clean up any actions in progress
|
| private void | cleanupAppWidgetIds()
if (mSafeModeEnabled || widgetsDisabled()) return;
// Clean up appWidgetIds that are bound to lockscreen, but not actually used
// This is only to clean up after another bug: we used to not call
// deleteAppWidgetId when a user manually deleted a widget in keyguard. This code
// shouldn't have to run more than once per user. AppWidgetProviders rely on callbacks
// that are triggered by deleteAppWidgetId, which is why we're doing this
int[] appWidgetIdsInKeyguardSettings = mLockPatternUtils.getAppWidgets();
int[] appWidgetIdsBoundToHost = mAppWidgetHost.getAppWidgetIds();
for (int i = 0; i < appWidgetIdsBoundToHost.length; i++) {
int appWidgetId = appWidgetIdsBoundToHost[i];
if (!contains(appWidgetIdsInKeyguardSettings, appWidgetId)) {
Log.d(TAG, "Found a appWidgetId that's not being used by keyguard, deleting id "
+ appWidgetId);
mAppWidgetHost.deleteAppWidgetId(appWidgetId);
}
}
|
| public void | clearAppWidgetToShow()
mAppWidgetToShow = AppWidgetManager.INVALID_APPWIDGET_ID;
|
| private static boolean | contains(int[] array, int target)
for (int value : array) {
if (value == target) {
return true;
}
}
return false;
|
| public boolean | dismiss(boolean authenticated)
boolean finished = super.dismiss(authenticated);
if (!finished) {
mViewStateManager.showBouncer(true);
// Enter full screen mode if we're in SIM or Account screen
SecurityMode securityMode = getSecurityContainer().getSecurityMode();
boolean isFullScreen = getResources().getBoolean(R.bool.kg_sim_puk_account_full_screen);
boolean isSimOrAccount = securityMode == SecurityMode.SimPin
|| securityMode == SecurityMode.SimPuk
|| securityMode == SecurityMode.Account;
mAppWidgetContainer.setVisibility(
isSimOrAccount && isFullScreen ? View.GONE : View.VISIBLE);
// Don't show camera or search in navbar when SIM or Account screen is showing
setSystemUiVisibility(isSimOrAccount ?
(getSystemUiVisibility() | View.STATUS_BAR_DISABLE_SEARCH)
: (getSystemUiVisibility() & ~View.STATUS_BAR_DISABLE_SEARCH));
if (mSlidingChallengeLayout != null) {
mSlidingChallengeLayout.setChallengeInteractive(!isFullScreen);
}
}
return finished;
|
| private void | enableUserSelectorIfNecessary()
final UserManager um = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
if (um == null) {
Throwable t = new Throwable();
t.fillInStackTrace();
Log.e(TAG, "user service is null.", t);
return;
}
// if there are multiple users, we need to enable to multi-user switcher
if (!um.isUserSwitcherEnabled()) {
return;
}
final View multiUserView = findViewById(R.id.keyguard_user_selector);
if (multiUserView == null) {
if (DEBUG) Log.d(TAG, "can't find user_selector in layout.");
return;
}
if (multiUserView instanceof KeyguardMultiUserSelectorView) {
mKeyguardMultiUserSelectorView = (KeyguardMultiUserSelectorView) multiUserView;
mKeyguardMultiUserSelectorView.setVisibility(View.VISIBLE);
mKeyguardMultiUserSelectorView.addUsers(um.getUsers(true));
UserSwitcherCallback callback = new UserSwitcherCallback() {
@Override
public void hideSecurityView(int duration) {
getSecurityContainer().animate().alpha(0).setDuration(duration);
}
@Override
public void showSecurityView() {
getSecurityContainer().setAlpha(1.0f);
}
@Override
public void showUnlockHint() {
if (getSecurityContainer() != null) {
getSecurityContainer().showUsabilityHint();
}
}
@Override
public void userActivity() {
if (mViewMediatorCallback != null) {
mViewMediatorCallback.userActivity();
}
}
};
mKeyguardMultiUserSelectorView.setCallback(callback);
} else {
Throwable t = new Throwable();
t.fillInStackTrace();
if (multiUserView == null) {
Log.e(TAG, "could not find the user_selector.", t);
} else {
Log.e(TAG, "user_selector is the wrong type.", t);
}
}
|
| private boolean | ensureTransportPresentOrRemoved(int state)Examines the current state and adds the transport to the widget pager when the state changes.
Showing the initial transport and keeping it around is a bit tricky because the signals
coming from music players aren't always clear. Here's how the states are handled:
{@link TRANSPORT_GONE} means we have no reason to show the transport - remove it if present.
{@link TRANSPORT_INVISIBLE} means we have potential to show the transport because a music
player is registered but not currently playing music (or we don't know the state yet). The
code adds it conditionally on play state.
{@link #TRANSPORT_VISIBLE} means a music player is active and transport should be showing.
Once the transport is showing, we always show it until keyguard is dismissed. This state is
maintained by onSave/RestoreInstanceState(). This state is cleared in
{@link KeyguardViewManager#hide} when keyguard is dismissed, which causes the transport to be
gone when keyguard is restarted until we get an update with the current state.
final boolean showing = getWidgetPosition(R.id.keyguard_transport_control) != -1;
final boolean visible = state == TRANSPORT_VISIBLE;
final boolean shouldBeVisible = state == TRANSPORT_INVISIBLE && isMusicPlaying(state);
if (!showing && (visible || shouldBeVisible)) {
// insert to left of camera if it exists, otherwise after right-most widget
int lastWidget = mAppWidgetContainer.getChildCount() - 1;
int position = 0; // handle no widget case
if (lastWidget >= 0) {
position = mAppWidgetContainer.isCameraPage(lastWidget) ?
lastWidget : lastWidget + 1;
}
if (DEBUGXPORT) Log.v(TAG, "add transport at " + position);
mAppWidgetContainer.addWidget(getOrCreateTransportControl(), position);
return true;
} else if (showing && state == TRANSPORT_GONE) {
if (DEBUGXPORT) Log.v(TAG, "remove transport");
mAppWidgetContainer.removeWidget(getOrCreateTransportControl());
mTransportControl = null;
KeyguardUpdateMonitor.getInstance(getContext()).dispatchSetBackground(null);
}
return false;
|
| private CameraWidgetFrame | findCameraPage()
for (int i = mAppWidgetContainer.getChildCount() - 1; i >= 0; i--) {
if (mAppWidgetContainer.isCameraPage(i)) {
return (CameraWidgetFrame) mAppWidgetContainer.getChildAt(i);
}
}
return null;
|
| protected boolean | fitSystemWindows(android.graphics.Rect insets)
setInsets(insets);
return true;
|
| private int | getAppropriateWidgetPage(int musicTransportState)
// assumes at least one widget (besides camera + add)
if (mAppWidgetToShow != AppWidgetManager.INVALID_APPWIDGET_ID) {
final int childCount = mAppWidgetContainer.getChildCount();
for (int i = 0; i < childCount; i++) {
if (mAppWidgetContainer.getWidgetPageAt(i).getContentAppWidgetId()
== mAppWidgetToShow) {
return i;
}
}
mAppWidgetToShow = AppWidgetManager.INVALID_APPWIDGET_ID;
}
// if music playing, show transport
if (musicTransportState == TRANSPORT_VISIBLE) {
if (DEBUG) Log.d(TAG, "Music playing, show transport");
return mAppWidgetContainer.getWidgetPageIndex(getOrCreateTransportControl());
}
// else show the right-most widget (except for camera)
int rightMost = mAppWidgetContainer.getChildCount() - 1;
if (mAppWidgetContainer.isCameraPage(rightMost)) {
rightMost--;
}
if (DEBUG) Log.d(TAG, "Show right-most page " + rightMost);
return rightMost;
|
| private int | getDisabledFeatures(android.app.admin.DevicePolicyManager dpm)
int disabledFeatures = DevicePolicyManager.KEYGUARD_DISABLE_FEATURES_NONE;
if (dpm != null) {
final int currentUser = mLockPatternUtils.getCurrentUser();
disabledFeatures = dpm.getKeyguardDisabledFeatures(null, currentUser);
}
return disabledFeatures;
|
| private void | getInitialTransportState()
DisplayClientState dcs = KeyguardUpdateMonitor.getInstance(mContext)
.getCachedDisplayClientState();
mTransportState = (dcs.clearing ? TRANSPORT_GONE :
(isMusicPlaying(dcs.playbackState) ? TRANSPORT_VISIBLE : TRANSPORT_INVISIBLE));
if (DEBUGXPORT) Log.v(TAG, "Initial transport state: "
+ mTransportState + ", pbstate=" + dcs.playbackState);
|
| private int | getInsertPageIndex()
View addWidget = mAppWidgetContainer.findViewById(R.id.keyguard_add_widget);
int insertionIndex = mAppWidgetContainer.indexOfChild(addWidget);
if (insertionIndex < 0) {
insertionIndex = 0; // no add widget page found
} else {
insertionIndex++; // place after add widget
}
return insertionIndex;
|
| private KeyguardTransportControlView | getOrCreateTransportControl()Create KeyguardTransportControlView on demand.
if (mTransportControl == null) {
LayoutInflater inflater = LayoutInflater.from(mContext);
mTransportControl = (KeyguardTransportControlView)
inflater.inflate(R.layout.keyguard_transport_control_view, this, false);
mTransportControl.setTransportControlCallback(new TransportControlCallback() {
public void userActivity() {
mViewMediatorCallback.userActivity();
}
});
}
return mTransportControl;
|
| public long | getUserActivityTimeout()
// Currently only considering user activity timeouts needed by widgets.
// Could also take into account longer timeouts for certain security views.
if (mAppWidgetContainer != null) {
return mAppWidgetContainer.getUserActivityTimeout();
}
return -1;
|
| private int | getWidgetPosition(int id)
final KeyguardWidgetPager appWidgetContainer = mAppWidgetContainer;
final int children = appWidgetContainer.getChildCount();
for (int i = 0; i < children; i++) {
final View content = appWidgetContainer.getWidgetPageAt(i).getContent();
if (content != null && content.getId() == id) {
return i;
} else if (content == null) {
// Attempt to track down bug #8886916
Log.w(TAG, "*** Null content at " + "i=" + i + ",id=" + id + ",N=" + children);
}
}
return -1;
|
| public void | goToWidget(int appWidgetId)
mAppWidgetToShow = appWidgetId;
mSwitchPageRunnable.run();
|
| boolean | isMusicPage(int pageIndex)
return pageIndex >= 0 && pageIndex == getWidgetPosition(R.id.keyguard_transport_control);
|
| private static final boolean | isMusicPlaying(int playbackState)
// This should agree with the list in AudioService.isPlaystateActive()
switch (playbackState) {
case RemoteControlClient.PLAYSTATE_PLAYING:
case RemoteControlClient.PLAYSTATE_BUFFERING:
case RemoteControlClient.PLAYSTATE_FAST_FORWARDING:
case RemoteControlClient.PLAYSTATE_REWINDING:
case RemoteControlClient.PLAYSTATE_SKIPPING_BACKWARDS:
case RemoteControlClient.PLAYSTATE_SKIPPING_FORWARDS:
return true;
default:
return false;
}
|
| private void | maybeEnableAddButton()
if (!shouldEnableAddWidget()) {
mAppWidgetContainer.setAddWidgetEnabled(false);
}
|
| private int | numWidgets()
final int childCount = mAppWidgetContainer.getChildCount();
int widgetCount = 0;
for (int i = 0; i < childCount; i++) {
if (mAppWidgetContainer.isWidgetPage(i)) {
widgetCount++;
}
}
return widgetCount;
|
| protected void | onAttachedToWindow()
super.onAttachedToWindow();
mAppWidgetHost.startListening();
KeyguardUpdateMonitor.getInstance(mContext).registerCallback(mUpdateMonitorCallbacks);
|
| protected void | onCreateOptions(android.os.Bundle options)
if (options != null) {
int widgetToShow = options.getInt(LockPatternUtils.KEYGUARD_SHOW_APPWIDGET,
AppWidgetManager.INVALID_APPWIDGET_ID);
if (widgetToShow != AppWidgetManager.INVALID_APPWIDGET_ID) {
goToWidget(widgetToShow);
}
}
|
| protected void | onDetachedFromWindow()
super.onDetachedFromWindow();
mAppWidgetHost.stopListening();
KeyguardUpdateMonitor.getInstance(mContext).removeCallback(mUpdateMonitorCallbacks);
|
| public void | onExternalMotionEvent(android.view.MotionEvent event)
mAppWidgetContainer.handleExternalCameraEvent(event);
|
| protected void | onFinishInflate()
super.onFinishInflate();
// Grab instances of and make any necessary changes to the main layouts. Create
// view state manager and wire up necessary listeners / callbacks.
View deleteDropTarget = findViewById(R.id.keyguard_widget_pager_delete_target);
mAppWidgetContainer = (KeyguardWidgetPager) findViewById(R.id.app_widget_container);
mAppWidgetContainer.setVisibility(VISIBLE);
mAppWidgetContainer.setCallbacks(mWidgetCallbacks);
mAppWidgetContainer.setDeleteDropTarget(deleteDropTarget);
mAppWidgetContainer.setMinScale(0.5f);
mSlidingChallengeLayout = (SlidingChallengeLayout) findViewById(R.id.sliding_layout);
if (mSlidingChallengeLayout != null) {
mSlidingChallengeLayout.setOnChallengeScrolledListener(mViewStateManager);
}
mAppWidgetContainer.setViewStateManager(mViewStateManager);
mAppWidgetContainer.setLockPatternUtils(mLockPatternUtils);
mMultiPaneChallengeLayout =
(MultiPaneChallengeLayout) findViewById(R.id.multi_pane_challenge);
ChallengeLayout challenge = mSlidingChallengeLayout != null ? mSlidingChallengeLayout :
mMultiPaneChallengeLayout;
challenge.setOnBouncerStateChangedListener(mViewStateManager);
mAppWidgetContainer.setBouncerAnimationDuration(challenge.getBouncerAnimationDuration());
mViewStateManager.setPagedView(mAppWidgetContainer);
mViewStateManager.setChallengeLayout(challenge);
mViewStateManager.setSecurityViewContainer(getSecurityContainer());
if (KeyguardUpdateMonitor.getInstance(mContext).hasBootCompleted()) {
updateAndAddWidgets();
} else {
// We can't add widgets until after boot completes because AppWidgetHost may try
// to contact the providers. Do it later.
mPostBootCompletedRunnable = new Runnable() {
@Override
public void run() {
updateAndAddWidgets();
}
};
}
getSecurityContainer().updateSecurityViews(mViewStateManager.isBouncing());
enableUserSelectorIfNecessary();
|
| public void | onPause()
super.onPause();
// We use mAppWidgetToShow to show a particular widget after you add it-- once the screen
// turns off we reset that behavior
clearAppWidgetToShow();
if (KeyguardUpdateMonitor.getInstance(mContext).hasBootCompleted()) {
checkAppWidgetConsistency();
}
CameraWidgetFrame cameraPage = findCameraPage();
if (cameraPage != null) {
cameraPage.onScreenTurnedOff();
}
|
| public void | onRestoreInstanceState(android.os.Parcelable state)
if (!(state instanceof SavedState)) {
super.onRestoreInstanceState(state);
return;
}
SavedState ss = (SavedState) state;
super.onRestoreInstanceState(ss.getSuperState());
mTransportState = (ss.transportState);
mAppWidgetToShow = ss.appWidgetToShow;
setInsets(ss.insets);
if (DEBUG) Log.d(TAG, "onRestoreInstanceState, transport=" + mTransportState);
mSwitchPageRunnable.run();
|
| public void | onResume()
super.onResume();
if (mViewStateManager != null) {
mViewStateManager.showUsabilityHints();
}
|
| public android.os.Parcelable | onSaveInstanceState()
if (DEBUG) Log.d(TAG, "onSaveInstanceState, tstate=" + mTransportState);
Parcelable superState = super.onSaveInstanceState();
SavedState ss = new SavedState(superState);
// If the transport is showing, force it to show it on restore.
final boolean showing = mTransportControl != null
&& mAppWidgetContainer.getWidgetPageIndex(mTransportControl) >= 0;
ss.transportState = showing ? TRANSPORT_VISIBLE : mTransportState;
ss.appWidgetToShow = mAppWidgetToShow;
ss.insets.set(mInsets);
return ss;
|
| public boolean | onTouchEvent(android.view.MotionEvent ev)
boolean result = super.onTouchEvent(ev);
mTempRect.set(0, 0, 0, 0);
offsetRectIntoDescendantCoords(getSecurityContainer(), mTempRect);
ev.offsetLocation(mTempRect.left, mTempRect.top);
result = getSecurityContainer().dispatchTouchEvent(ev) || result;
ev.offsetLocation(-mTempRect.left, -mTempRect.top);
return result;
|
| public void | onUserActivityTimeoutChanged()
if (mViewMediatorCallback != null) {
mViewMediatorCallback.onUserActivityTimeoutChanged();
}
|
| public void | onUserSwitching(boolean switching)
if (!switching && mKeyguardMultiUserSelectorView != null) {
mKeyguardMultiUserSelectorView.finalizeActiveUserView(false);
}
|
| public void | onWindowFocusChanged(boolean hasWindowFocus)
super.onWindowFocusChanged(hasWindowFocus);
if (DEBUG) Log.d(TAG, "Window is " + (hasWindowFocus ? "focused" : "unfocused"));
if (hasWindowFocus && mShowSecurityWhenReturn) {
SlidingChallengeLayout slider =
(SlidingChallengeLayout) findViewById(R.id.sliding_layout);
if (slider != null) {
slider.setHandleAlpha(1);
slider.showChallenge(true);
}
mShowSecurityWhenReturn = false;
}
|
| private void | setInsets(android.graphics.Rect insets)
mInsets.set(insets);
if (mSlidingChallengeLayout != null) mSlidingChallengeLayout.setInsets(mInsets);
if (mMultiPaneChallengeLayout != null) mMultiPaneChallengeLayout.setInsets(mInsets);
final CameraWidgetFrame cameraWidget = findCameraPage();
if (cameraWidget != null) cameraWidget.setInsets(mInsets);
|
| public void | setLockPatternUtils(com.android.internal.widget.LockPatternUtils utils)
super.setLockPatternUtils(utils);
getSecurityContainer().updateSecurityViews(mViewStateManager.isBouncing());
|
| private boolean | shouldEnableAddWidget()
return numWidgets() < MAX_WIDGETS && mUserSetupCompleted;
|
| private void | showAppropriateWidgetPage()
final int state = mTransportState;
final boolean transportAdded = ensureTransportPresentOrRemoved(state);
final int pageToShow = getAppropriateWidgetPage(state);
if (!transportAdded) {
mAppWidgetContainer.setCurrentPage(pageToShow);
} else if (state == TRANSPORT_VISIBLE) {
// If the transport was just added, we need to wait for layout to happen before
// we can set the current page.
post(new Runnable() {
@Override
public void run() {
mAppWidgetContainer.setCurrentPage(pageToShow);
}
});
}
|
| protected void | showBouncer(boolean show)
super.showBouncer(show);
mViewStateManager.showBouncer(show);
|
| private void | updateAndAddWidgets()
cleanupAppWidgetIds();
addDefaultWidgets();
addWidgetsFromSettings();
maybeEnableAddButton();
checkAppWidgetConsistency();
// Don't let the user drag the challenge down if widgets are disabled.
if (mSlidingChallengeLayout != null) {
mSlidingChallengeLayout.setEnableChallengeDragging(!widgetsDisabled());
}
// Select the appropriate page
mSwitchPageRunnable.run();
// This needs to be called after the pages are all added.
mViewStateManager.showUsabilityHints();
|
| public void | userActivity()
if (mViewMediatorCallback != null) {
mViewMediatorCallback.userActivity();
}
|
| private boolean | widgetsDisabled()
boolean disabledByLowRamDevice = ActivityManager.isLowRamDeviceStatic();
boolean disabledByDpm =
(mDisabledFeatures & DevicePolicyManager.KEYGUARD_DISABLE_WIDGETS_ALL) != 0;
boolean disabledByUser = !mLockPatternUtils.getWidgetsEnabled();
return disabledByLowRamDevice || disabledByDpm || disabledByUser;
|
