From 3458009bcdc70b7a64dfa4f2fda28ced091adaa7 Mon Sep 17 00:00:00 2001 From: Craig Mautner Date: Wed, 11 Jul 2012 14:37:39 -0700 Subject: Handle keyguard visibility states separately. DO NOT MERGE Previous to this change the forceHiding variable was a boolean. This change recognizes the different configurations of the keyguard by defining separate states for forceHiding and testing for window visibility differently in each state. Fixes bug 6786114. Change-Id: I3460c45ea6da772a4ff76bb016de7aa4b051a673 --- .../java/com/android/server/wm/WindowAnimator.java | 29 +++++++++++++++++----- 1 file changed, 23 insertions(+), 6 deletions(-) diff --git a/services/java/com/android/server/wm/WindowAnimator.java b/services/java/com/android/server/wm/WindowAnimator.java index db3b2bd..62cf711 100644 --- a/services/java/com/android/server/wm/WindowAnimator.java +++ b/services/java/com/android/server/wm/WindowAnimator.java @@ -32,6 +32,13 @@ import java.util.ArrayList; public class WindowAnimator { private static final String TAG = "WindowAnimator"; + // mForceHiding states. + private static final int KEYGUARD_NOT_SHOWN = 0; + private static final int KEYGUARD_ANIMATING_IN = 1; + private static final int KEYGUARD_SHOWN = 2; + private static final int KEYGUARD_ANIMATING_OUT = 3; + int mForceHiding; + final WindowManagerService mService; final Context mContext; final WindowManagerPolicy mPolicy; @@ -39,7 +46,6 @@ public class WindowAnimator { ArrayList mWinAnimators = new ArrayList(); boolean mAnimating; - boolean mForceHiding; WindowState mWindowAnimationBackground; int mWindowAnimationBackgroundColor; int mAdjResult; @@ -279,8 +285,16 @@ public class WindowAnimator { } mService.mFocusMayChange = true; } - if (win.isReadyForDisplay() && winAnimator.mAnimationIsEntrance) { - mForceHiding = true; + if (win.isReadyForDisplay()) { + if (nowAnimating) { + if (winAnimator.mAnimationIsEntrance) { + mForceHiding = KEYGUARD_ANIMATING_IN; + } else { + mForceHiding = KEYGUARD_ANIMATING_OUT; + } + } else { + mForceHiding = KEYGUARD_SHOWN; + } } if (WindowManagerService.DEBUG_VISIBILITY) Slog.v(TAG, "Force hide " + mForceHiding @@ -292,9 +306,12 @@ public class WindowAnimator { + " hidden=" + win.mRootToken.hidden + " anim=" + win.mWinAnimator.mAnimation); } else if (mPolicy.canBeForceHidden(win, win.mAttrs)) { + final boolean hideWhenLocked = + (winAnimator.mAttrFlags & FLAG_SHOW_WHEN_LOCKED) == 0; final boolean changed; - if (mForceHiding && (!winAnimator.isAnimating() - || (winAnimator.mAttrFlags & FLAG_SHOW_WHEN_LOCKED) == 0)) { + if (((mForceHiding == KEYGUARD_ANIMATING_IN) + && (!winAnimator.isAnimating() || hideWhenLocked)) + || ((mForceHiding == KEYGUARD_SHOWN) && hideWhenLocked)) { changed = win.hideLw(false, false); if (WindowManagerService.DEBUG_VISIBILITY && changed) Slog.v(TAG, "Now policy hidden: " + win); @@ -411,7 +428,7 @@ public class WindowAnimator { } private void performAnimationsLocked() { - mForceHiding = false; + mForceHiding = KEYGUARD_NOT_SHOWN; mDetachedWallpaper = null; mWindowAnimationBackground = null; mWindowAnimationBackgroundColor = 0; -- cgit v1.1 From f48658aa174c36e0c2c1c96fd64303b085ec324a Mon Sep 17 00:00:00 2001 From: Wink Saville Date: Wed, 20 Jun 2012 23:47:40 -0700 Subject: When reconnecting disassociate dc and apnContext. This is done in onActionIntentReconnectAlarm, which is called when retrying after an error, by setting the ApnContext.DataConnection & DataConnctionAc to null which intern clears the DataConnection.mApnList. With the mApnList cleared DataConnection.mRefCount will not be incremented because the DC will not be found by findReadyDataConnection. Thus fixing at least one cause of 6529189. Bug: 6529189 Change-Id: I40ff1966f6fbd2f69e97d77b9db7122e4c5b992f --- .../com/android/internal/telephony/gsm/GsmDataConnectionTracker.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/telephony/java/com/android/internal/telephony/gsm/GsmDataConnectionTracker.java b/telephony/java/com/android/internal/telephony/gsm/GsmDataConnectionTracker.java index 83fc9c1..ed67759 100644 --- a/telephony/java/com/android/internal/telephony/gsm/GsmDataConnectionTracker.java +++ b/telephony/java/com/android/internal/telephony/gsm/GsmDataConnectionTracker.java @@ -157,6 +157,8 @@ public final class GsmDataConnectionTracker extends DataConnectionTracker { if (dcac != null) { for (ApnContext apnContext : dcac.getApnListSync()) { + apnContext.setDataConnectionAc(null); + apnContext.setDataConnection(null); apnContext.setReason(reason); if (apnContext.getState() == State.FAILED) { apnContext.setState(State.IDLE); -- cgit v1.1 From f186b07b463447707117e2b54fc02f7ed30d6e43 Mon Sep 17 00:00:00 2001 From: Wink Saville Date: Thu, 28 Jun 2012 09:34:41 -0700 Subject: Preserve retryCount when retrying. Bug: 6529189 Change-Id: I743aed08aa161d91899aeb2ccacffcd224e48c0a --- .../com/android/internal/telephony/ApnContext.java | 22 +++++- .../android/internal/telephony/DataConnection.java | 8 +++ .../internal/telephony/DataConnectionTracker.java | 6 +- .../android/internal/telephony/RetryManager.java | 14 ++-- .../telephony/gsm/GsmDataConnectionTracker.java | 78 ++++++++++++++++------ 5 files changed, 100 insertions(+), 28 deletions(-) diff --git a/telephony/java/com/android/internal/telephony/ApnContext.java b/telephony/java/com/android/internal/telephony/ApnContext.java index 3a3044e..9746398 100644 --- a/telephony/java/com/android/internal/telephony/ApnContext.java +++ b/telephony/java/com/android/internal/telephony/ApnContext.java @@ -50,6 +50,8 @@ public class ApnContext { String mReason; + int mRetryCount; + /** * user/app requested connection on this APN */ @@ -64,6 +66,7 @@ public class ApnContext { mApnType = apnType; mState = DataConnectionTracker.State.IDLE; setReason(Phone.REASON_DATA_ENABLED); + setRetryCount(0); mDataEnabled = new AtomicBoolean(false); mDependencyMet = new AtomicBoolean(true); mWaitingApnsPermanentFailureCountDown = new AtomicInteger(0); @@ -182,6 +185,21 @@ public class ApnContext { return mReason; } + public synchronized void setRetryCount(int retryCount) { + if (DBG) { + log("setRetryCount: " + retryCount); + } + mRetryCount = retryCount; + DataConnection dc = mDataConnection; + if (dc != null) { + dc.setRetryCount(retryCount); + } + } + + public synchronized int getRetryCount() { + return mRetryCount; + } + public boolean isReady() { return mDataEnabled.get() && mDependencyMet.get(); } @@ -214,8 +232,8 @@ public class ApnContext { return "{mApnType=" + mApnType + " mState=" + getState() + " mWaitingApns=" + mWaitingApns + " mWaitingApnsPermanentFailureCountDown=" + mWaitingApnsPermanentFailureCountDown + " mApnSetting=" + mApnSetting + " mDataConnectionAc=" + mDataConnectionAc + - " mReason=" + mReason + " mDataEnabled=" + mDataEnabled + - " mDependencyMet=" + mDependencyMet + "}"; + " mReason=" + mReason + " mRetryCount=" + mRetryCount + + " mDataEnabled=" + mDataEnabled + " mDependencyMet=" + mDependencyMet + "}"; } protected void log(String s) { diff --git a/telephony/java/com/android/internal/telephony/DataConnection.java b/telephony/java/com/android/internal/telephony/DataConnection.java index cc4adfd..3f7e71e 100644 --- a/telephony/java/com/android/internal/telephony/DataConnection.java +++ b/telephony/java/com/android/internal/telephony/DataConnection.java @@ -426,6 +426,14 @@ public abstract class DataConnection extends StateMachine { } /** + * set retry manager retryCount + */ + public void setRetryCount(int retryCount) { + if (DBG) log("setRetryCount: " + retryCount); + mRetryMgr.setRetryCount(retryCount); + } + + /** * @return retry manager retryTimer */ public int getRetryTimer() { diff --git a/telephony/java/com/android/internal/telephony/DataConnectionTracker.java b/telephony/java/com/android/internal/telephony/DataConnectionTracker.java index 588515b..0dee7a1 100644 --- a/telephony/java/com/android/internal/telephony/DataConnectionTracker.java +++ b/telephony/java/com/android/internal/telephony/DataConnectionTracker.java @@ -303,7 +303,8 @@ public abstract class DataConnectionTracker extends Handler { new HashMap(); /** Phone.APN_TYPE_* ===> ApnContext */ - protected ConcurrentHashMap mApnContexts; + protected ConcurrentHashMap mApnContexts = + new ConcurrentHashMap(); /* Currently active APN */ protected ApnSetting mActiveApn; @@ -1203,6 +1204,9 @@ public abstract class DataConnectionTracker extends Handler { } protected void resetAllRetryCounts() { + for (ApnContext ac : mApnContexts.values()) { + ac.setRetryCount(0); + } for (DataConnection dc : mDataConnections.values()) { dc.resetRetryCount(); } diff --git a/telephony/java/com/android/internal/telephony/RetryManager.java b/telephony/java/com/android/internal/telephony/RetryManager.java index ae451b9..250d99e 100644 --- a/telephony/java/com/android/internal/telephony/RetryManager.java +++ b/telephony/java/com/android/internal/telephony/RetryManager.java @@ -73,7 +73,7 @@ import java.util.ArrayList; * {@hide} */ public class RetryManager { - static public final String LOG_TAG = "RetryManager"; + static public final String LOG_TAG = "GSM"; static public final boolean DBG = true; static public final boolean VDBG = false; @@ -304,7 +304,6 @@ public class RetryManager { /** * Set retry count to the specified value - * and turns off retrying forever. */ public void setRetryCount(int count) { mRetryCount = count; @@ -316,11 +315,18 @@ public class RetryManager { mRetryCount = 0; } - mRetryForever = false; if (DBG) log("setRetryCount: " + mRetryCount); } /** + * Set retry forever to the specified value + */ + public void setRetryForever(boolean retryForever) { + mRetryForever = retryForever; + if (DBG) log("setRetryForever: " + mRetryForever); + } + + /** * Clear the data-retry counter */ public void resetRetryCount() { @@ -399,6 +405,6 @@ public class RetryManager { } private void log(String s) { - Log.d(LOG_TAG, s); + Log.d(LOG_TAG, "[RM] " + s); } } diff --git a/telephony/java/com/android/internal/telephony/gsm/GsmDataConnectionTracker.java b/telephony/java/com/android/internal/telephony/gsm/GsmDataConnectionTracker.java index ed67759..6b863a7 100644 --- a/telephony/java/com/android/internal/telephony/gsm/GsmDataConnectionTracker.java +++ b/telephony/java/com/android/internal/telephony/gsm/GsmDataConnectionTracker.java @@ -134,6 +134,8 @@ public final class GsmDataConnectionTracker extends DataConnectionTracker { private static final String INTENT_RECONNECT_ALARM = "com.android.internal.telephony.gprs-reconnect"; private static final String INTENT_RECONNECT_ALARM_EXTRA_TYPE = "reconnect_alarm_extra_type"; + private static final String INTENT_RECONNECT_ALARM_EXTRA_RETRY_COUNT = + "reconnect_alaram_extra_retry_count"; private static final String INTENT_DATA_STALL_ALARM = "com.android.internal.telephony.gprs-data-stall"; @@ -148,18 +150,23 @@ public final class GsmDataConnectionTracker extends DataConnectionTracker { @Override protected void onActionIntentReconnectAlarm(Intent intent) { - if (DBG) log("GPRS reconnect alarm. Previous state was " + mState); - String reason = intent.getStringExtra(INTENT_RECONNECT_ALARM_EXTRA_REASON); int connectionId = intent.getIntExtra(INTENT_RECONNECT_ALARM_EXTRA_TYPE, -1); + int retryCount = intent.getIntExtra(INTENT_RECONNECT_ALARM_EXTRA_RETRY_COUNT, 0); DataConnectionAc dcac= mDataConnectionAsyncChannels.get(connectionId); + if (DBG) { + log("onActionIntentReconnectAlarm: mState=" + mState + " reason=" + reason + + " connectionId=" + connectionId + " retryCount=" + retryCount); + } + if (dcac != null) { for (ApnContext apnContext : dcac.getApnListSync()) { apnContext.setDataConnectionAc(null); apnContext.setDataConnection(null); apnContext.setReason(reason); + apnContext.setRetryCount(retryCount); if (apnContext.getState() == State.FAILED) { apnContext.setState(State.IDLE); } @@ -207,7 +214,6 @@ public final class GsmDataConnectionTracker extends DataConnectionTracker { p.getContext().getContentResolver().registerContentObserver( Telephony.Carriers.CONTENT_URI, true, mApnObserver); - mApnContexts = new ConcurrentHashMap(); initApnContextsAndDataConnection(); broadcastMessenger(); } @@ -674,10 +680,15 @@ public final class GsmDataConnectionTracker extends DataConnectionTracker { break; } } - configureRetry(dcac.dataConnection, hasDefault); + configureRetry(dcac.dataConnection, hasDefault, 0); } } + // Be sure retry counts for Apncontexts and DC's are sync'd. + // When DCT/ApnContexts are refactored and we cleanup retrying + // this won't be needed. + resetAllRetryCounts(); + // Only check for default APN state for (ApnContext apnContext : mApnContexts.values()) { if (apnContext.getState() == State.FAILED) { @@ -1078,7 +1089,8 @@ public final class GsmDataConnectionTracker extends DataConnectionTracker { // configure retry count if no other Apn is using the same connection. if (refCount == 0) { - configureRetry(dc, apn.canHandleType(Phone.APN_TYPE_DEFAULT)); + configureRetry(dc, apn.canHandleType(Phone.APN_TYPE_DEFAULT), + apnContext.getRetryCount()); } apnContext.setDataConnectionAc(dcac); apnContext.setDataConnection(dc); @@ -1330,7 +1342,7 @@ public final class GsmDataConnectionTracker extends DataConnectionTracker { startNetStatPoll(); startDataStallAlarm(DATA_STALL_NOT_SUSPECTED); // reset reconnect timer - apnContext.getDataConnection().resetRetryCount(); + apnContext.setRetryCount(0); } // TODO: For multiple Active APNs not exactly sure how to do this. @@ -1601,6 +1613,10 @@ public final class GsmDataConnectionTracker extends DataConnectionTracker { loge("reconnectAfterFail: apnContext == null, impossible"); return; } + if (DBG) { + log("reconnectAfterFail: lastFailCause=" + lastFailCauseCode + + " retryOverride=" + retryOverride + " apnContext=" + apnContext); + } if ((apnContext.getState() == State.FAILED) && (apnContext.getDataConnection() != null)) { if (!apnContext.getDataConnection().isRetryNeeded()) { @@ -1616,7 +1632,7 @@ public final class GsmDataConnectionTracker extends DataConnectionTracker { if (DBG) log("reconnectAfterFail: activate failed, Reregistering to network"); mReregisterOnReconnectFailure = true; mPhone.getServiceStateTracker().reRegisterNetwork(null); - apnContext.getDataConnection().resetRetryCount(); + apnContext.setRetryCount(0); return; } } @@ -1627,6 +1643,11 @@ public final class GsmDataConnectionTracker extends DataConnectionTracker { if (nextReconnectDelay < 0) { nextReconnectDelay = apnContext.getDataConnection().getRetryTimer(); apnContext.getDataConnection().increaseRetryCount(); + if (DBG) { + log("reconnectAfterFail: increaseRetryCount=" + + apnContext.getDataConnection().getRetryCount() + + " nextReconnectDelay=" + nextReconnectDelay); + } } startAlarmForReconnect(nextReconnectDelay, apnContext); @@ -1643,16 +1664,11 @@ public final class GsmDataConnectionTracker extends DataConnectionTracker { private void startAlarmForReconnect(int delay, ApnContext apnContext) { - if (DBG) { - log("Schedule alarm for reconnect: activate failed. Scheduling next attempt for " - + (delay / 1000) + "s"); - } - DataConnectionAc dcac = apnContext.getDataConnectionAc(); if ((dcac == null) || (dcac.dataConnection == null)) { // should not happen, but just in case. - loge("null dcac or dc."); + loge("startAlarmForReconnect: null dcac or dc."); return; } @@ -1661,12 +1677,29 @@ public final class GsmDataConnectionTracker extends DataConnectionTracker { Intent intent = new Intent(INTENT_RECONNECT_ALARM + '.' + dcac.dataConnection.getDataConnectionId()); - intent.putExtra(INTENT_RECONNECT_ALARM_EXTRA_REASON, apnContext.getReason()); - intent.putExtra(INTENT_RECONNECT_ALARM_EXTRA_TYPE, - dcac.dataConnection.getDataConnectionId()); + String reason = apnContext.getReason(); + intent.putExtra(INTENT_RECONNECT_ALARM_EXTRA_REASON, reason); + int connectionId = dcac.dataConnection.getDataConnectionId(); + intent.putExtra(INTENT_RECONNECT_ALARM_EXTRA_TYPE, connectionId); + + // TODO: Until a real fix is created, which probably entails pushing + // retires into the DC itself, this fix gets the retry count and + // puts it in the reconnect alarm. When the reconnect alarm fires + // onActionIntentReconnectAlarm is called which will use the value saved + // here and save it in the ApnContext and send the EVENT_CONNECT message + // which invokes setupData. Then setupData will use the value in the ApnContext + // and to tell the DC to set the retry count in the retry manager. + int retryCount = dcac.dataConnection.getRetryCount(); + intent.putExtra(INTENT_RECONNECT_ALARM_EXTRA_RETRY_COUNT, retryCount); + + if (DBG) { + log("startAlarmForReconnect: next attempt in " + (delay / 1000) + "s" + + " reason='" + reason + "' connectionId=" + connectionId + + " retryCount=" + retryCount); + } PendingIntent alarmIntent = PendingIntent.getBroadcast (mPhone.getContext(), 0, - intent, 0); + intent, PendingIntent.FLAG_UPDATE_CURRENT); dcac.setReconnectIntentSync(alarmIntent); am.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime() + delay, alarmIntent); @@ -1942,9 +1975,7 @@ public final class GsmDataConnectionTracker extends DataConnectionTracker { // Make sure our reconnect delay starts at the initial value // next time the radio comes on - for (DataConnection dc : mDataConnections.values()) { - dc.resetRetryCount(); - } + resetAllRetryCounts(); mReregisterOnReconnectFailure = false; if (mPhone.getSimulatedRadioControl() != null) { @@ -2287,7 +2318,11 @@ public final class GsmDataConnectionTracker extends DataConnectionTracker { return conn; } - private void configureRetry(DataConnection dc, boolean forDefault) { + private void configureRetry(DataConnection dc, boolean forDefault, int retryCount) { + if (DBG) { + log("configureRetry: forDefault=" + forDefault + " retryCount=" + retryCount + + " dc=" + dc); + } if (dc == null) return; if (!dc.configureRetry(getReryConfig(forDefault))) { @@ -2307,6 +2342,7 @@ public final class GsmDataConnectionTracker extends DataConnectionTracker { } } } + dc.setRetryCount(retryCount); } private void destroyDataConnections() { -- cgit v1.1