Merge "Respawn app_main if ADDR_COMPAT_LAYOUT is not set" into jb-mr2-dev
diff --git a/cmds/am/src/com/android/commands/am/Am.java b/cmds/am/src/com/android/commands/am/Am.java
index 9fa7dbb..1c02960 100644
--- a/cmds/am/src/com/android/commands/am/Am.java
+++ b/cmds/am/src/com/android/commands/am/Am.java
@@ -63,6 +63,7 @@
private int mRepeat = 0;
private int mUserId;
+ private String mReceiverPermission;
private String mProfileFile;
@@ -332,6 +333,8 @@
mStartFlags |= ActivityManager.START_FLAG_OPENGL_TRACES;
} else if (opt.equals("--user")) {
mUserId = parseUserArg(nextArgRequired());
+ } else if (opt.equals("--receiver-permission")) {
+ mReceiverPermission = nextArgRequired();
} else {
System.err.println("Error: Unknown option: " + opt);
return null;
@@ -608,7 +611,7 @@
Intent intent = makeIntent(UserHandle.USER_ALL);
IntentReceiver receiver = new IntentReceiver();
System.out.println("Broadcasting: " + intent);
- mAm.broadcastIntent(null, intent, null, receiver, 0, null, null, null,
+ mAm.broadcastIntent(null, intent, null, receiver, 0, null, null, mReceiverPermission,
android.app.AppOpsManager.OP_NONE, true, false, mUserId);
receiver.waitForFinish();
}
@@ -1408,6 +1411,7 @@
"am broadcast: send a broadcast Intent. Options are:\n" +
" --user <USER_ID> | all | current: Specify which user to send to; if not\n" +
" specified then send to all users.\n" +
+ " --receiver-permission <PERMISSION>: Require receiver to hold permission.\n" +
"\n" +
"am instrument: start an Instrumentation. Typically this target <COMPONENT>\n" +
" is the form <TEST_PACKAGE>/<RUNNER_CLASS>. Options are:\n" +
diff --git a/core/java/android/accounts/AccountManager.java b/core/java/android/accounts/AccountManager.java
index 6aac723..f8b7a0c 100644
--- a/core/java/android/accounts/AccountManager.java
+++ b/core/java/android/accounts/AccountManager.java
@@ -18,9 +18,11 @@
import android.app.Activity;
import android.content.Intent;
+import android.content.ComponentName;
import android.content.Context;
import android.content.IntentFilter;
import android.content.BroadcastReceiver;
+import android.content.res.Resources;
import android.database.SQLException;
import android.os.Bundle;
import android.os.Handler;
@@ -44,6 +46,7 @@
import java.util.HashMap;
import java.util.Map;
+import com.android.internal.R;
import com.google.android.collect.Maps;
/**
@@ -1777,8 +1780,11 @@
};
// have many accounts, launch the chooser
Intent intent = new Intent();
- intent.setClassName("android",
- "android.accounts.ChooseAccountActivity");
+ ComponentName componentName = ComponentName.unflattenFromString(
+ Resources.getSystem().getString(
+ R.string.config_chooseAccountActivity));
+ intent.setClassName(componentName.getPackageName(),
+ componentName.getClassName());
intent.putExtra(KEY_ACCOUNTS, accounts);
intent.putExtra(KEY_ACCOUNT_MANAGER_RESPONSE,
new AccountManagerResponse(chooseResponse));
@@ -1934,7 +1940,10 @@
String[] addAccountRequiredFeatures,
Bundle addAccountOptions) {
Intent intent = new Intent();
- intent.setClassName("android", "android.accounts.ChooseTypeAndAccountActivity");
+ ComponentName componentName = ComponentName.unflattenFromString(
+ Resources.getSystem().getString(R.string.config_chooseTypeAndAccountActivity));
+ intent.setClassName(componentName.getPackageName(),
+ componentName.getClassName());
intent.putExtra(ChooseTypeAndAccountActivity.EXTRA_ALLOWABLE_ACCOUNTS_ARRAYLIST,
allowableAccounts);
intent.putExtra(ChooseTypeAndAccountActivity.EXTRA_ALLOWABLE_ACCOUNT_TYPES_STRING_ARRAY,
diff --git a/core/java/android/app/PendingIntent.java b/core/java/android/app/PendingIntent.java
index 37804e9..20114cc 100644
--- a/core/java/android/app/PendingIntent.java
+++ b/core/java/android/app/PendingIntent.java
@@ -261,6 +261,7 @@
context.getContentResolver()) : null;
try {
intent.setAllowFds(false);
+ intent.migrateExtraStreamToClipData();
IIntentSender target =
ActivityManagerNative.getDefault().getIntentSender(
ActivityManager.INTENT_SENDER_ACTIVITY, packageName,
@@ -285,6 +286,7 @@
context.getContentResolver()) : null;
try {
intent.setAllowFds(false);
+ intent.migrateExtraStreamToClipData();
IIntentSender target =
ActivityManagerNative.getDefault().getIntentSender(
ActivityManager.INTENT_SENDER_ACTIVITY, packageName,
diff --git a/core/java/android/content/CursorLoader.java b/core/java/android/content/CursorLoader.java
index 4e89dec..5d7d677 100644
--- a/core/java/android/content/CursorLoader.java
+++ b/core/java/android/content/CursorLoader.java
@@ -68,7 +68,7 @@
try {
// Ensure the cursor window is filled.
cursor.getCount();
- registerContentObserver(cursor, mObserver);
+ cursor.registerContentObserver(mObserver);
} catch (RuntimeException ex) {
cursor.close();
throw ex;
@@ -93,14 +93,6 @@
}
}
- /**
- * Registers an observer to get notifications from the content provider
- * when the cursor needs to be refreshed.
- */
- void registerContentObserver(Cursor cursor, ContentObserver observer) {
- cursor.registerContentObserver(mObserver);
- }
-
/* Runs on the UI thread */
@Override
public void deliverResult(Cursor cursor) {
diff --git a/core/java/android/inputmethodservice/IInputMethodWrapper.java b/core/java/android/inputmethodservice/IInputMethodWrapper.java
index 2d67875..d59c7b8 100644
--- a/core/java/android/inputmethodservice/IInputMethodWrapper.java
+++ b/core/java/android/inputmethodservice/IInputMethodWrapper.java
@@ -284,6 +284,12 @@
flags, resultReceiver));
}
+ @Override
+ public void removeSoftInputMessages() {
+ mCaller.removeMessages(DO_SHOW_SOFT_INPUT);
+ mCaller.removeMessages(DO_HIDE_SOFT_INPUT);
+ }
+
public void changeInputMethodSubtype(InputMethodSubtype subtype) {
mCaller.executeOrSendMessage(mCaller.obtainMessageO(DO_CHANGE_INPUTMETHOD_SUBTYPE,
subtype));
diff --git a/core/java/android/net/DhcpStateMachine.java b/core/java/android/net/DhcpStateMachine.java
index f140282..518dd4b 100644
--- a/core/java/android/net/DhcpStateMachine.java
+++ b/core/java/android/net/DhcpStateMachine.java
@@ -50,7 +50,7 @@
public class DhcpStateMachine extends StateMachine {
private static final String TAG = "DhcpStateMachine";
- private static final boolean DBG = false;
+ private static final boolean DBG = true;
/* A StateMachine that controls the DhcpStateMachine */
diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java
index 266d0d3..d251ca2 100644
--- a/core/java/android/provider/Settings.java
+++ b/core/java/android/provider/Settings.java
@@ -4784,6 +4784,13 @@
public static final String WIFI_ON = "wifi_on";
/**
+ * Setting to allow scans to be enabled even wifi is turned off for connectivity.
+ * @hide
+ */
+ public static final String WIFI_SCAN_ALWAYS_AVAILABLE =
+ "wifi_scan_always_enabled";
+
+ /**
* Used to save the Wifi_ON state prior to tethering.
* This state will be checked to restore Wifi after
* the user turns off tethering.
@@ -5345,6 +5352,7 @@
WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON,
WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY,
WIFI_WATCHDOG_POOR_NETWORK_TEST_ENABLED,
+ WIFI_SCAN_ALWAYS_AVAILABLE,
WIFI_NUM_OPEN_NETWORKS_KEPT,
EMERGENCY_TONE,
CALL_AUTO_RETRY,
diff --git a/core/java/com/android/internal/util/Protocol.java b/core/java/com/android/internal/util/Protocol.java
index 7c2b1b5..91b109e 100644
--- a/core/java/com/android/internal/util/Protocol.java
+++ b/core/java/com/android/internal/util/Protocol.java
@@ -45,6 +45,7 @@
public static final int BASE_WIFI_P2P_SERVICE = 0x00023000;
public static final int BASE_WIFI_MONITOR = 0x00024000;
public static final int BASE_WIFI_MANAGER = 0x00025000;
+ public static final int BASE_WIFI_CONTROLLER = 0x00026000;
public static final int BASE_DHCP = 0x00030000;
public static final int BASE_DATA_CONNECTION = 0x00040000;
public static final int BASE_DATA_CONNECTION_AC = 0x00041000;
diff --git a/core/java/com/android/internal/util/StateMachine.java b/core/java/com/android/internal/util/StateMachine.java
index e547f23..2cdd579 100644
--- a/core/java/com/android/internal/util/StateMachine.java
+++ b/core/java/com/android/internal/util/StateMachine.java
@@ -1549,6 +1549,24 @@
*
* @param what is assigned to Message.what
* @param arg1 is assigned to Message.arg1
+ * @return A Message object from the global pool
+ */
+ public final Message obtainMessage(int what, int arg1) {
+ // use this obtain so we don't match the obtain(h, what, Object) method
+ return Message.obtain(mSmHandler, what, arg1, 0);
+ }
+
+ /**
+ * Get a message and set Message.target state machine handler,
+ * what, arg1 and arg2
+ *
+ * Note: The handler can be null if the state machine has quit,
+ * which means target will be null and may cause a AndroidRuntimeException
+ * in MessageQueue#enqueMessage if sent directly or if sent using
+ * StateMachine#sendMessage the message will just be ignored.
+ *
+ * @param what is assigned to Message.what
+ * @param arg1 is assigned to Message.arg1
* @param arg2 is assigned to Message.arg2
* @return A Message object from the global pool
*/
@@ -1606,6 +1624,32 @@
*
* Message is ignored if state machine has quit.
*/
+ public final void sendMessage(int what, int arg1) {
+ // mSmHandler can be null if the state machine has quit.
+ SmHandler smh = mSmHandler;
+ if (smh == null) return;
+
+ smh.sendMessage(obtainMessage(what, arg1));
+ }
+
+ /**
+ * Enqueue a message to this state machine.
+ *
+ * Message is ignored if state machine has quit.
+ */
+ public final void sendMessage(int what, int arg1, int arg2) {
+ // mSmHandler can be null if the state machine has quit.
+ SmHandler smh = mSmHandler;
+ if (smh == null) return;
+
+ smh.sendMessage(obtainMessage(what, arg1, arg2));
+ }
+
+ /**
+ * Enqueue a message to this state machine.
+ *
+ * Message is ignored if state machine has quit.
+ */
public final void sendMessage(int what, int arg1, int arg2, Object obj) {
// mSmHandler can be null if the state machine has quit.
SmHandler smh = mSmHandler;
@@ -1658,6 +1702,32 @@
*
* Message is ignored if state machine has quit.
*/
+ public final void sendMessageDelayed(int what, int arg1, long delayMillis) {
+ // mSmHandler can be null if the state machine has quit.
+ SmHandler smh = mSmHandler;
+ if (smh == null) return;
+
+ smh.sendMessageDelayed(obtainMessage(what, arg1), delayMillis);
+ }
+
+ /**
+ * Enqueue a message to this state machine after a delay.
+ *
+ * Message is ignored if state machine has quit.
+ */
+ public final void sendMessageDelayed(int what, int arg1, int arg2, long delayMillis) {
+ // mSmHandler can be null if the state machine has quit.
+ SmHandler smh = mSmHandler;
+ if (smh == null) return;
+
+ smh.sendMessageDelayed(obtainMessage(what, arg1, arg2), delayMillis);
+ }
+
+ /**
+ * Enqueue a message to this state machine after a delay.
+ *
+ * Message is ignored if state machine has quit.
+ */
public final void sendMessageDelayed(int what, int arg1, int arg2, Object obj,
long delayMillis) {
// mSmHandler can be null if the state machine has quit.
@@ -1686,6 +1756,20 @@
*
* Message is ignored if state machine has quit.
*/
+ protected final void sendMessageAtFrontOfQueue(int what) {
+ // mSmHandler can be null if the state machine has quit.
+ SmHandler smh = mSmHandler;
+ if (smh == null) return;
+
+ smh.sendMessageAtFrontOfQueue(obtainMessage(what));
+ }
+
+ /**
+ * Enqueue a message to the front of the queue for this state machine.
+ * Protected, may only be called by instances of StateMachine.
+ *
+ * Message is ignored if state machine has quit.
+ */
protected final void sendMessageAtFrontOfQueue(int what, Object obj) {
// mSmHandler can be null if the state machine has quit.
SmHandler smh = mSmHandler;
@@ -1700,12 +1784,27 @@
*
* Message is ignored if state machine has quit.
*/
- protected final void sendMessageAtFrontOfQueue(int what) {
+ protected final void sendMessageAtFrontOfQueue(int what, int arg1) {
// mSmHandler can be null if the state machine has quit.
SmHandler smh = mSmHandler;
if (smh == null) return;
- smh.sendMessageAtFrontOfQueue(obtainMessage(what));
+ smh.sendMessageAtFrontOfQueue(obtainMessage(what, arg1));
+ }
+
+
+ /**
+ * Enqueue a message to the front of the queue for this state machine.
+ * Protected, may only be called by instances of StateMachine.
+ *
+ * Message is ignored if state machine has quit.
+ */
+ protected final void sendMessageAtFrontOfQueue(int what, int arg1, int arg2) {
+ // mSmHandler can be null if the state machine has quit.
+ SmHandler smh = mSmHandler;
+ if (smh == null) return;
+
+ smh.sendMessageAtFrontOfQueue(obtainMessage(what, arg1, arg2));
}
/**
diff --git a/core/java/com/android/internal/view/IInputMethod.aidl b/core/java/com/android/internal/view/IInputMethod.aidl
index c7fcab8..c2a7fc7 100644
--- a/core/java/com/android/internal/view/IInputMethod.aidl
+++ b/core/java/com/android/internal/view/IInputMethod.aidl
@@ -33,26 +33,28 @@
* Service).
* {@hide}
*/
-oneway interface IInputMethod {
- void attachToken(IBinder token);
+interface IInputMethod {
+ oneway void attachToken(IBinder token);
- void bindInput(in InputBinding binding);
+ oneway void bindInput(in InputBinding binding);
- void unbindInput();
+ oneway void unbindInput();
- void startInput(in IInputContext inputContext, in EditorInfo attribute);
+ oneway void startInput(in IInputContext inputContext, in EditorInfo attribute);
- void restartInput(in IInputContext inputContext, in EditorInfo attribute);
+ oneway void restartInput(in IInputContext inputContext, in EditorInfo attribute);
- void createSession(IInputMethodCallback callback);
+ oneway void createSession(IInputMethodCallback callback);
- void setSessionEnabled(IInputMethodSession session, boolean enabled);
+ oneway void setSessionEnabled(IInputMethodSession session, boolean enabled);
- void revokeSession(IInputMethodSession session);
+ oneway void revokeSession(IInputMethodSession session);
- void showSoftInput(int flags, in ResultReceiver resultReceiver);
+ oneway void showSoftInput(int flags, in ResultReceiver resultReceiver);
- void hideSoftInput(int flags, in ResultReceiver resultReceiver);
+ oneway void hideSoftInput(int flags, in ResultReceiver resultReceiver);
- void changeInputMethodSubtype(in InputMethodSubtype subtype);
+ void removeSoftInputMessages();
+
+ oneway void changeInputMethodSubtype(in InputMethodSubtype subtype);
}
diff --git a/core/res/AndroidManifest.xml b/core/res/AndroidManifest.xml
index 8a53cc3..5a1c0f8 100644
--- a/core/res/AndroidManifest.xml
+++ b/core/res/AndroidManifest.xml
@@ -169,6 +169,7 @@
<protected-broadcast android:name="android.intent.action.EXTERNAL_APPLICATIONS_UNAVAILABLE" />
<protected-broadcast android:name="android.intent.action.AIRPLANE_MODE" />
<protected-broadcast android:name="android.intent.action.ADVANCED_SETTINGS" />
+ <protected-broadcast android:name="android.intent.action.BUGREPORT_FINISHED" />
<protected-broadcast android:name="android.intent.action.ACTION_IDLE_MAINTENANCE_START" />
<protected-broadcast android:name="android.intent.action.ACTION_IDLE_MAINTENANCE_END" />
diff --git a/core/res/res/values/config.xml b/core/res/res/values/config.xml
index ccdddd8..6a8407f 100644
--- a/core/res/res/values/config.xml
+++ b/core/res/res/values/config.xml
@@ -1031,4 +1031,14 @@
<!-- Flag indicating if the speed up audio on mt call code should be executed -->
<bool name="config_speed_up_audio_on_mt_calls">false</bool>
+
+ <!-- Class name of the framework account picker activity.
+ Can be customized for other product types -->
+ <string name="config_chooseAccountActivity"
+ >android/android.accounts.ChooseAccountActivity</string>
+ <!-- Class name of the account type and account picker activity.
+ Can be customized for other product types -->
+ <string name="config_chooseTypeAndAccountActivity"
+ >android/android.accounts.ChooseTypeAndAccountActivity</string>
+
</resources>
diff --git a/core/res/res/values/symbols.xml b/core/res/res/values/symbols.xml
index 140ff70..d57d56a 100644
--- a/core/res/res/values/symbols.xml
+++ b/core/res/res/values/symbols.xml
@@ -863,6 +863,9 @@
<java-symbol type="string" name="media_route_status_available" />
<java-symbol type="string" name="media_route_status_not_available" />
<java-symbol type="string" name="owner_name" />
+ <java-symbol type="string" name="config_chooseAccountActivity" />
+ <java-symbol type="string" name="config_chooseTypeAndAccountActivity" />
+
<java-symbol type="plurals" name="abbrev_in_num_days" />
<java-symbol type="plurals" name="abbrev_in_num_hours" />
diff --git a/media/java/android/media/IAudioService.aidl b/media/java/android/media/IAudioService.aidl
index 312c252..efa8089 100644
--- a/media/java/android/media/IAudioService.aidl
+++ b/media/java/android/media/IAudioService.aidl
@@ -120,14 +120,14 @@
oneway void dispatchMediaKeyEvent(in KeyEvent keyEvent);
void dispatchMediaKeyEventUnderWakelock(in KeyEvent keyEvent);
- oneway void registerMediaButtonIntent(in PendingIntent pi, in ComponentName c);
+ void registerMediaButtonIntent(in PendingIntent pi, in ComponentName c);
oneway void unregisterMediaButtonIntent(in PendingIntent pi, in ComponentName c);
oneway void registerMediaButtonEventReceiverForCalls(in ComponentName c);
oneway void unregisterMediaButtonEventReceiverForCalls();
- int registerRemoteControlClient(in PendingIntent mediaIntent,
- in IRemoteControlClient rcClient, in String callingPackageName);
+ int registerRemoteControlClient(in PendingIntent mediaIntent,
+ in IRemoteControlClient rcClient, in String callingPackageName);
oneway void unregisterRemoteControlClient(in PendingIntent mediaIntent,
in IRemoteControlClient rcClient);
diff --git a/packages/Shell/Android.mk b/packages/Shell/Android.mk
index f993ab5..fc4c0f5 100644
--- a/packages/Shell/Android.mk
+++ b/packages/Shell/Android.mk
@@ -5,6 +5,8 @@
LOCAL_SRC_FILES := $(call all-subdir-java-files)
+LOCAL_STATIC_JAVA_LIBRARIES := android-support-v4
+
LOCAL_PACKAGE_NAME := Shell
LOCAL_CERTIFICATE := platform
diff --git a/packages/Shell/AndroidManifest.xml b/packages/Shell/AndroidManifest.xml
index b42db45..ffb4c20 100644
--- a/packages/Shell/AndroidManifest.xml
+++ b/packages/Shell/AndroidManifest.xml
@@ -68,7 +68,32 @@
<uses-permission android:name="android.permission.INTERACT_ACROSS_USERS_FULL" />
<uses-permission android:name="android.permission.MANAGE_USERS" />
<uses-permission android:name="android.permission.BLUETOOTH_STACK" />
-
- <application android:hasCode="false" android:label="@string/app_label">
+ <uses-permission android:name="android.permission.GET_ACCOUNTS" />
+
+ <application android:label="@string/app_label">
+ <provider
+ android:name="android.support.v4.content.FileProvider"
+ android:authorities="com.android.shell"
+ android:grantUriPermissions="true"
+ android:exported="false">
+ <meta-data
+ android:name="android.support.FILE_PROVIDER_PATHS"
+ android:resource="@xml/file_provider_paths" />
+ </provider>
+
+ <activity
+ android:name=".BugreportWarningActivity"
+ android:theme="@*android:style/Theme.Holo.Dialog.Alert"
+ android:finishOnCloseSystemDialogs="true"
+ android:excludeFromRecents="true"
+ android:exported="false" />
+
+ <receiver
+ android:name=".BugreportReceiver"
+ android:permission="android.permission.DUMP">
+ <intent-filter>
+ <action android:name="android.intent.action.BUGREPORT_FINISHED" />
+ </intent-filter>
+ </receiver>
</application>
</manifest>
diff --git a/packages/Shell/res/layout/confirm_repeat.xml b/packages/Shell/res/layout/confirm_repeat.xml
new file mode 100644
index 0000000..dc250d6
--- /dev/null
+++ b/packages/Shell/res/layout/confirm_repeat.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2013 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.
+-->
+
+<LinearLayout
+ xmlns:android="http://schemas.android.com/apk/res/android"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:paddingStart="16dip"
+ android:paddingEnd="16dip"
+ android:paddingTop="8dip"
+ android:paddingBottom="16dip"
+ android:orientation="vertical">
+ <TextView
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:text="@string/bugreport_confirm"
+ android:paddingBottom="16dip"
+ style="?android:attr/textAppearanceMedium" />
+ <CheckBox
+ android:id="@android:id/checkbox"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:text="@string/bugreport_confirm_repeat" />
+</LinearLayout>
diff --git a/packages/Shell/res/values/strings.xml b/packages/Shell/res/values/strings.xml
index 50610d5..e5606c7 100644
--- a/packages/Shell/res/values/strings.xml
+++ b/packages/Shell/res/values/strings.xml
@@ -16,4 +16,14 @@
<resources>
<string name="app_label">Shell</string>
+
+ <!-- Title of notification indicating a bugreport has been successfully captured. [CHAR LIMIT=50] -->
+ <string name="bugreport_finished_title">Bug report captured</string>
+ <!-- Text of notification indicating that touching will share the captured bugreport. [CHAR LIMIT=100] -->
+ <string name="bugreport_finished_text">Touch to share your bug report</string>
+
+ <!-- Body of dialog informing user about contents of a bugreport. [CHAR LIMIT=NONE] -->
+ <string name="bugreport_confirm">Bug reports contain data from the system\'s various log files, including personal and private information. Only share bug reports with apps and people you trust.</string>
+ <!-- Checkbox that indicates this dialog should be shown again when the next bugreport is taken. [CHAR LIMIT=50] -->
+ <string name="bugreport_confirm_repeat">Show this message next time</string>
</resources>
diff --git a/packages/Shell/res/xml/file_provider_paths.xml b/packages/Shell/res/xml/file_provider_paths.xml
new file mode 100644
index 0000000..225c757
--- /dev/null
+++ b/packages/Shell/res/xml/file_provider_paths.xml
@@ -0,0 +1,3 @@
+<paths xmlns:android="http://schemas.android.com/apk/res/android">
+ <files-path name="bugreports" path="bugreports/" />
+</paths>
diff --git a/packages/Shell/src/com/android/shell/BugreportPrefs.java b/packages/Shell/src/com/android/shell/BugreportPrefs.java
new file mode 100644
index 0000000..3748e89
--- /dev/null
+++ b/packages/Shell/src/com/android/shell/BugreportPrefs.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2013 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.shell;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+/**
+ * Preferences related to bug reports.
+ */
+public class BugreportPrefs {
+ private static final String PREFS_BUGREPORT = "bugreports";
+
+ private static final String KEY_WARNING_STATE = "warning-state";
+
+ public static final int STATE_UNKNOWN = 0;
+ public static final int STATE_SHOW = 1;
+ public static final int STATE_HIDE = 2;
+
+ public static int getWarningState(Context context, int def) {
+ final SharedPreferences prefs = context.getSharedPreferences(
+ PREFS_BUGREPORT, Context.MODE_PRIVATE);
+ return prefs.getInt(KEY_WARNING_STATE, def);
+ }
+
+ public static void setWarningState(Context context, int value) {
+ final SharedPreferences prefs = context.getSharedPreferences(
+ PREFS_BUGREPORT, Context.MODE_PRIVATE);
+ prefs.edit().putInt(KEY_WARNING_STATE, value).apply();
+ }
+}
diff --git a/packages/Shell/src/com/android/shell/BugreportReceiver.java b/packages/Shell/src/com/android/shell/BugreportReceiver.java
new file mode 100644
index 0000000..3b1ebf4
--- /dev/null
+++ b/packages/Shell/src/com/android/shell/BugreportReceiver.java
@@ -0,0 +1,198 @@
+/*
+ * Copyright (C) 2013 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.shell;
+
+import static com.android.shell.BugreportPrefs.STATE_SHOW;
+import static com.android.shell.BugreportPrefs.getWarningState;
+
+import android.accounts.Account;
+import android.accounts.AccountManager;
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.AsyncTask;
+import android.os.SystemProperties;
+import android.support.v4.content.FileProvider;
+import android.util.Log;
+import android.util.Patterns;
+
+import com.google.android.collect.Lists;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+
+/**
+ * Receiver that handles finished bugreports, usually by attaching them to an
+ * {@link Intent#ACTION_SEND}.
+ */
+public class BugreportReceiver extends BroadcastReceiver {
+ private static final String TAG = "Shell";
+
+ private static final String AUTHORITY = "com.android.shell";
+
+ private static final String EXTRA_BUGREPORT = "android.intent.extra.BUGREPORT";
+ private static final String EXTRA_SCREENSHOT = "android.intent.extra.SCREENSHOT";
+
+ /**
+ * Number of bugreports to retain before deleting the oldest; 4 reports and
+ * 4 screenshots are roughly 17MB of disk space.
+ */
+ private static final int NUM_OLD_FILES = 8;
+
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ final File bugreportFile = getFileExtra(intent, EXTRA_BUGREPORT);
+ final File screenshotFile = getFileExtra(intent, EXTRA_SCREENSHOT);
+
+ // Files are kept on private storage, so turn into Uris that we can
+ // grant temporary permissions for.
+ final Uri bugreportUri = FileProvider.getUriForFile(context, AUTHORITY, bugreportFile);
+ final Uri screenshotUri = FileProvider.getUriForFile(context, AUTHORITY, screenshotFile);
+
+ Intent sendIntent = buildSendIntent(context, bugreportUri, screenshotUri);
+ Intent notifIntent;
+
+ // Send through warning dialog by default
+ if (getWarningState(context, STATE_SHOW) == STATE_SHOW) {
+ notifIntent = buildWarningIntent(context, sendIntent);
+ } else {
+ notifIntent = sendIntent;
+ }
+ notifIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+
+ final Notification.Builder builder = new Notification.Builder(context);
+ builder.setSmallIcon(com.android.internal.R.drawable.stat_sys_adb);
+ builder.setContentTitle(context.getString(R.string.bugreport_finished_title));
+ builder.setContentText(context.getString(R.string.bugreport_finished_text));
+ builder.setContentIntent(PendingIntent.getActivity(
+ context, 0, notifIntent, PendingIntent.FLAG_CANCEL_CURRENT));
+ builder.setAutoCancel(true);
+ NotificationManager.from(context).notify(TAG, 0, builder.build());
+
+ // Clean up older bugreports in background
+ final PendingResult result = goAsync();
+ new AsyncTask<Void, Void, Void>() {
+ @Override
+ protected Void doInBackground(Void... params) {
+ deleteOlderFiles(bugreportFile.getParentFile(), NUM_OLD_FILES);
+ result.finish();
+ return null;
+ }
+ }.execute();
+ }
+
+ private static Intent buildWarningIntent(Context context, Intent sendIntent) {
+ final Intent intent = new Intent(context, BugreportWarningActivity.class);
+ intent.putExtra(Intent.EXTRA_INTENT, sendIntent);
+ return intent;
+ }
+
+ /**
+ * Build {@link Intent} that can be used to share the given bugreport.
+ */
+ private static Intent buildSendIntent(Context context, Uri bugreportUri, Uri screenshotUri) {
+ final Intent intent = new Intent(Intent.ACTION_SEND_MULTIPLE);
+ intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+ intent.addCategory(Intent.CATEGORY_DEFAULT);
+ intent.setType("application/vnd.android.bugreport");
+
+ intent.putExtra(Intent.EXTRA_SUBJECT, bugreportUri.getLastPathSegment());
+ intent.putExtra(Intent.EXTRA_TEXT, SystemProperties.get("ro.build.description"));
+
+ final ArrayList<Uri> attachments = Lists.newArrayList(bugreportUri, screenshotUri);
+ intent.putParcelableArrayListExtra(Intent.EXTRA_STREAM, attachments);
+
+ final Account sendToAccount = findSendToAccount(context);
+ if (sendToAccount != null) {
+ intent.putExtra(Intent.EXTRA_EMAIL, new String[] { sendToAccount.name });
+ }
+
+ return intent;
+ }
+
+ /**
+ * Find the best matching {@link Account} based on build properties.
+ */
+ private static Account findSendToAccount(Context context) {
+ final AccountManager am = (AccountManager) context.getSystemService(
+ Context.ACCOUNT_SERVICE);
+
+ String preferredDomain = SystemProperties.get("sendbug.preferred.domain");
+ if (!preferredDomain.startsWith("@")) {
+ preferredDomain = "@" + preferredDomain;
+ }
+
+ final Account[] accounts = am.getAccounts();
+ Account foundAccount = null;
+ for (Account account : accounts) {
+ if (Patterns.EMAIL_ADDRESS.matcher(account.name).matches()) {
+ if (!preferredDomain.isEmpty()) {
+ // if we have a preferred domain and it matches, return; otherwise keep
+ // looking
+ if (account.name.endsWith(preferredDomain)) {
+ return account;
+ } else {
+ foundAccount = account;
+ }
+ // if we don't have a preferred domain, just return since it looks like
+ // an email address
+ } else {
+ return account;
+ }
+ }
+ }
+ return foundAccount;
+ }
+
+ /**
+ * Delete the oldest files in given directory until only the requested
+ * number remain.
+ */
+ private static void deleteOlderFiles(File dir, int retainNum) {
+ final File[] files = dir.listFiles();
+ if (files == null) return;
+
+ Arrays.sort(files, new ModifiedComparator());
+ for (int i = retainNum; i < files.length; i++) {
+ Log.d(TAG, "Deleting old file " + files[i]);
+ files[i].delete();
+ }
+ }
+
+ private static class ModifiedComparator implements Comparator<File> {
+ @Override
+ public int compare(File lhs, File rhs) {
+ return (int) (rhs.lastModified() - lhs.lastModified());
+ }
+ }
+
+ private static File getFileExtra(Intent intent, String key) {
+ final String path = intent.getStringExtra(key);
+ if (path != null) {
+ return new File(path);
+ } else {
+ return null;
+ }
+ }
+
+}
diff --git a/packages/Shell/src/com/android/shell/BugreportWarningActivity.java b/packages/Shell/src/com/android/shell/BugreportWarningActivity.java
new file mode 100644
index 0000000..a1d879a
--- /dev/null
+++ b/packages/Shell/src/com/android/shell/BugreportWarningActivity.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2013 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.shell;
+
+import static com.android.shell.BugreportPrefs.STATE_HIDE;
+import static com.android.shell.BugreportPrefs.STATE_SHOW;
+import static com.android.shell.BugreportPrefs.STATE_UNKNOWN;
+import static com.android.shell.BugreportPrefs.getWarningState;
+import static com.android.shell.BugreportPrefs.setWarningState;
+
+import android.app.AlertDialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.widget.CheckBox;
+
+import com.android.internal.app.AlertActivity;
+import com.android.internal.app.AlertController;
+
+/**
+ * Dialog that warns about contents of a bugreport.
+ */
+public class BugreportWarningActivity extends AlertActivity
+ implements DialogInterface.OnClickListener {
+
+ private Intent mSendIntent;
+ private CheckBox mConfirmRepeat;
+
+ @Override
+ public void onCreate(Bundle icicle) {
+ super.onCreate(icicle);
+
+ mSendIntent = getIntent().getParcelableExtra(Intent.EXTRA_INTENT);
+
+ // We need to touch the extras to unpack them so they get migrated to
+ // ClipData correctly.
+ mSendIntent.hasExtra(Intent.EXTRA_STREAM);
+
+ final AlertController.AlertParams ap = mAlertParams;
+ ap.mView = LayoutInflater.from(this).inflate(R.layout.confirm_repeat, null);
+ ap.mPositiveButtonText = getString(android.R.string.ok);
+ ap.mNegativeButtonText = getString(android.R.string.cancel);
+ ap.mPositiveButtonListener = this;
+ ap.mNegativeButtonListener = this;
+
+ mConfirmRepeat = (CheckBox) ap.mView.findViewById(android.R.id.checkbox);
+ mConfirmRepeat.setChecked(getWarningState(this, STATE_UNKNOWN) == STATE_SHOW);
+
+ setupAlert();
+ }
+
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ if (which == AlertDialog.BUTTON_POSITIVE) {
+ // Remember confirm state, and launch target
+ setWarningState(this, mConfirmRepeat.isChecked() ? STATE_SHOW : STATE_HIDE);
+ startActivity(mSendIntent);
+ }
+
+ finish();
+ }
+}
diff --git a/packages/SystemUI/src/com/android/systemui/ImageWallpaper.java b/packages/SystemUI/src/com/android/systemui/ImageWallpaper.java
index 29b2a5c..627235f 100644
--- a/packages/SystemUI/src/com/android/systemui/ImageWallpaper.java
+++ b/packages/SystemUI/src/com/android/systemui/ImageWallpaper.java
@@ -632,6 +632,30 @@
GLUtils.getEGLErrorString(mEgl.eglGetError()));
}
+ int attribs[] = {
+ EGL_WIDTH, 1,
+ EGL_HEIGHT, 1,
+ EGL_NONE
+ };
+ EGLSurface tmpSurface = mEgl.eglCreatePbufferSurface(mEglDisplay, mEglConfig, attribs);
+ mEgl.eglMakeCurrent(mEglDisplay, tmpSurface, tmpSurface, mEglContext);
+
+ int[] maxSize = new int[1];
+ Rect frame = surfaceHolder.getSurfaceFrame();
+ glGetIntegerv(GL_MAX_TEXTURE_SIZE, maxSize, 0);
+
+ mEgl.eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+ mEgl.eglDestroySurface(mEglDisplay, tmpSurface);
+
+ if(frame.width() > maxSize[0] || frame.height() > maxSize[0]) {
+ mEgl.eglDestroyContext(mEglDisplay, mEglContext);
+ mEgl.eglTerminate(mEglDisplay);
+ Log.e(GL_LOG_TAG, "requested texture size " +
+ frame.width() + "x" + frame.height() + " exceeds the support maximum of " +
+ maxSize[0] + "x" + maxSize[0]);
+ return false;
+ }
+
mEglSurface = mEgl.eglCreateWindowSurface(mEglDisplay, mEglConfig, surfaceHolder, null);
if (mEglSurface == null || mEglSurface == EGL_NO_SURFACE) {
int error = mEgl.eglGetError();
@@ -649,20 +673,6 @@
GLUtils.getEGLErrorString(mEgl.eglGetError()));
}
- int[] maxSize = new int[1];
- Rect frame = surfaceHolder.getSurfaceFrame();
- glGetIntegerv(GL_MAX_TEXTURE_SIZE, maxSize, 0);
- if(frame.width() > maxSize[0] || frame.height() > maxSize[0]) {
- mEgl.eglDestroySurface(mEglDisplay, mEglSurface);
- mEgl.eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
- mEgl.eglDestroyContext(mEglDisplay, mEglContext);
- mEgl.eglTerminate(mEglDisplay);
- Log.e(GL_LOG_TAG, "requested texture size " +
- frame.width() + "x" + frame.height() + " exceeds the support maximum of " +
- maxSize[0] + "x" + maxSize[0]);
- return false;
- }
-
return true;
}
diff --git a/policy/src/com/android/internal/policy/impl/keyguard/KeyguardHostView.java b/policy/src/com/android/internal/policy/impl/keyguard/KeyguardHostView.java
index 06f06b5..78d7caa 100644
--- a/policy/src/com/android/internal/policy/impl/keyguard/KeyguardHostView.java
+++ b/policy/src/com/android/internal/policy/impl/keyguard/KeyguardHostView.java
@@ -310,9 +310,7 @@
mKeyguardSelectorView = (KeyguardSelectorView) findViewById(R.id.keyguard_selector_view);
mViewStateManager.setSecurityViewContainer(mSecurityViewContainer);
- if (!(mContext instanceof Activity)) {
- setSystemUiVisibility(getSystemUiVisibility() | View.STATUS_BAR_DISABLE_BACK);
- }
+ setBackButtonEnabled(false);
addDefaultWidgets();
@@ -329,6 +327,13 @@
updateSecurityViews();
}
+ private void setBackButtonEnabled(boolean enabled) {
+ if (mContext instanceof Activity) return; // always enabled in activity mode
+ setSystemUiVisibility(enabled ?
+ getSystemUiVisibility() & ~View.STATUS_BAR_DISABLE_BACK :
+ getSystemUiVisibility() | View.STATUS_BAR_DISABLE_BACK);
+ }
+
private boolean shouldEnableAddWidget() {
return numWidgets() < MAX_WIDGETS && mUserSetupCompleted;
}
@@ -907,6 +912,10 @@
// Discard current runnable if we're switching back to the selector view
setOnDismissAction(null);
}
+ if (securityMode == SecurityMode.Account && !mLockPatternUtils.isPermanentlyLocked()) {
+ // we're showing account as a backup, provide a way to get back to primary
+ setBackButtonEnabled(true);
+ }
mCurrentSecuritySelection = securityMode;
}
@@ -1579,6 +1588,12 @@
}
public boolean handleBackKey() {
+ if (mCurrentSecuritySelection == SecurityMode.Account) {
+ // go back to primary screen and re-disable back
+ setBackButtonEnabled(false);
+ showPrimarySecurityScreen(false /*turningOff*/);
+ return true;
+ }
if (mCurrentSecuritySelection != SecurityMode.None) {
mCallback.dismiss(false);
return true;
diff --git a/services/java/com/android/server/InputMethodManagerService.java b/services/java/com/android/server/InputMethodManagerService.java
index d0048bf..14841af 100644
--- a/services/java/com/android/server/InputMethodManagerService.java
+++ b/services/java/com/android/server/InputMethodManagerService.java
@@ -1199,7 +1199,7 @@
mCurId = info.getId();
mCurToken = new Binder();
try {
- if (DEBUG) Slog.v(TAG, "Adding window token: " + mCurToken);
+ if (true || DEBUG) Slog.v(TAG, "Adding window token: " + mCurToken);
mIWindowManager.addWindowToken(mCurToken,
WindowManager.LayoutParams.TYPE_INPUT_METHOD);
} catch (RemoteException e) {
@@ -1237,14 +1237,21 @@
public void onServiceConnected(ComponentName name, IBinder service) {
synchronized (mMethodMap) {
if (mCurIntent != null && name.equals(mCurIntent.getComponent())) {
+ IInputMethod prevMethod = mCurMethod;
mCurMethod = IInputMethod.Stub.asInterface(service);
if (mCurToken == null) {
Slog.w(TAG, "Service connected without a token!");
unbindCurrentMethodLocked(false, false);
return;
}
- // Remove commands relating to the previous service. Otherwise WindowManagerService
- // will reject the command because the token attached to these messages is invalid.
+ // Remove messages relating to the previous service. Otherwise WindowManagerService
+ // will throw a BadTokenException because the old token is being removed.
+ if (prevMethod != null) {
+ try {
+ prevMethod.removeSoftInputMessages();
+ } catch (RemoteException e) {
+ }
+ }
mCaller.removeMessages(MSG_SHOW_SOFT_INPUT);
mCaller.removeMessages(MSG_HIDE_SOFT_INPUT);
if (true || DEBUG) Slog.v(TAG, "Initiating attach with token: " + mCurToken);
@@ -2309,8 +2316,7 @@
try {
if (true || DEBUG) Slog.v(TAG, "Calling " + args.arg1 + ".showSoftInput("
+ msg.arg1 + ", " + args.arg2 + ")");
- ((IInputMethod)args.arg1).showSoftInput(msg.arg1,
- (ResultReceiver)args.arg2);
+ ((IInputMethod)args.arg1).showSoftInput(msg.arg1, (ResultReceiver)args.arg2);
} catch (RemoteException e) {
}
args.recycle();
@@ -2320,8 +2326,7 @@
try {
if (true || DEBUG) Slog.v(TAG, "Calling " + args.arg1 + ".hideSoftInput(0, "
+ args.arg2 + ")");
- ((IInputMethod)args.arg1).hideSoftInput(0,
- (ResultReceiver)args.arg2);
+ ((IInputMethod)args.arg1).hideSoftInput(0, (ResultReceiver)args.arg2);
} catch (RemoteException e) {
}
args.recycle();
diff --git a/services/java/com/android/server/wifi/README.txt b/services/java/com/android/server/wifi/README.txt
new file mode 100644
index 0000000..c03bff5
--- /dev/null
+++ b/services/java/com/android/server/wifi/README.txt
@@ -0,0 +1,12 @@
+WifiService: Implements the IWifiManager 3rd party API. The API and the device state information (screen on/off, battery state, sleep policy) go as input into the WifiController which tracks high level states as to whether STA or AP mode is operational and controls the WifiStateMachine to handle bringup and shut down.
+
+WifiController: Acts as a controller to the WifiStateMachine based on various inputs (API and device state). Runs on the same thread created in WifiService.
+
+WifiSettingsStore: Tracks the various settings (wifi toggle, airplane toggle, tethering toggle, scan mode toggle) and provides API to figure if wifi should be turned on or off.
+
+WifiTrafficPoller: Polls traffic on wifi and notifies apps listening on it.
+
+WifiNotificationController: Controls whether the open network notification is displayed or not based on the scan results.
+
+WifiStateMachine: Tracks the various states on STA and AP connectivity and handles bring up and shut down.
+
diff --git a/services/java/com/android/server/wifi/WifiController.java b/services/java/com/android/server/wifi/WifiController.java
new file mode 100644
index 0000000..4d7c434
--- /dev/null
+++ b/services/java/com/android/server/wifi/WifiController.java
@@ -0,0 +1,626 @@
+/*
+ * Copyright (C) 2013 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.server.wifi;
+
+import android.app.AlarmManager;
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.database.ContentObserver;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import android.net.wifi.WifiConfiguration;
+import android.net.wifi.WifiManager;
+import static android.net.wifi.WifiManager.WIFI_MODE_FULL;
+import static android.net.wifi.WifiManager.WIFI_MODE_FULL_HIGH_PERF;
+import static android.net.wifi.WifiManager.WIFI_MODE_SCAN_ONLY;
+import android.net.wifi.WifiStateMachine;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.os.WorkSource;
+import android.provider.Settings;
+import android.util.Slog;
+
+import com.android.internal.util.Protocol;
+import com.android.internal.util.State;
+import com.android.internal.util.StateMachine;
+import com.android.server.wifi.WifiService.LockList;
+
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+
+class WifiController extends StateMachine {
+ private static final String TAG = "WifiController";
+ private static final boolean DBG = false;
+ private Context mContext;
+ private boolean mScreenOff;
+ private boolean mDeviceIdle;
+ private int mPluggedType;
+ private int mStayAwakeConditions;
+ private long mIdleMillis;
+ private int mSleepPolicy;
+
+ private AlarmManager mAlarmManager;
+ private PendingIntent mIdleIntent;
+ private static final int IDLE_REQUEST = 0;
+
+ /**
+ * See {@link Settings.Global#WIFI_IDLE_MS}. This is the default value if a
+ * Settings.Global value is not present. This timeout value is chosen as
+ * the approximate point at which the battery drain caused by Wi-Fi
+ * being enabled but not active exceeds the battery drain caused by
+ * re-establishing a connection to the mobile data network.
+ */
+ private static final long DEFAULT_IDLE_MS = 15 * 60 * 1000; /* 15 minutes */
+
+ NetworkInfo mNetworkInfo = new NetworkInfo(ConnectivityManager.TYPE_WIFI, 0, "WIFI", "");
+
+ private static final String ACTION_DEVICE_IDLE =
+ "com.android.server.WifiManager.action.DEVICE_IDLE";
+
+ /* References to values tracked in WifiService */
+ final WifiStateMachine mWifiStateMachine;
+ final WifiSettingsStore mSettingsStore;
+ final LockList mLocks;
+
+ /**
+ * Temporary for computing UIDS that are responsible for starting WIFI.
+ * Protected by mWifiStateTracker lock.
+ */
+ private final WorkSource mTmpWorkSource = new WorkSource();
+
+ private static final int BASE = Protocol.BASE_WIFI_CONTROLLER;
+
+ static final int CMD_EMERGENCY_MODE_CHANGED = BASE + 1;
+ static final int CMD_SCREEN_ON = BASE + 2;
+ static final int CMD_SCREEN_OFF = BASE + 3;
+ static final int CMD_BATTERY_CHANGED = BASE + 4;
+ static final int CMD_DEVICE_IDLE = BASE + 5;
+ static final int CMD_LOCKS_CHANGED = BASE + 6;
+ static final int CMD_SCAN_ALWAYS_MODE_CHANGED = BASE + 7;
+ static final int CMD_WIFI_TOGGLED = BASE + 8;
+ static final int CMD_AIRPLANE_TOGGLED = BASE + 9;
+ static final int CMD_SET_AP = BASE + 10;
+
+ private DefaultState mDefaultState = new DefaultState();
+ private StaEnabledState mStaEnabledState = new StaEnabledState();
+ private ApStaDisabledState mApStaDisabledState = new ApStaDisabledState();
+ private StaDisabledWithScanState mStaDisabledWithScanState = new StaDisabledWithScanState();
+ private ApEnabledState mApEnabledState = new ApEnabledState();
+ private DeviceActiveState mDeviceActiveState = new DeviceActiveState();
+ private DeviceInactiveState mDeviceInactiveState = new DeviceInactiveState();
+ private ScanOnlyLockHeldState mScanOnlyLockHeldState = new ScanOnlyLockHeldState();
+ private FullLockHeldState mFullLockHeldState = new FullLockHeldState();
+ private FullHighPerfLockHeldState mFullHighPerfLockHeldState = new FullHighPerfLockHeldState();
+ private NoLockHeldState mNoLockHeldState = new NoLockHeldState();
+ private EcmState mEcmState = new EcmState();
+
+ WifiController(Context context, WifiService service, Looper looper) {
+ super(TAG, looper);
+ mContext = context;
+ mWifiStateMachine = service.mWifiStateMachine;
+ mSettingsStore = service.mSettingsStore;
+ mLocks = service.mLocks;
+
+ mAlarmManager = (AlarmManager)mContext.getSystemService(Context.ALARM_SERVICE);
+ Intent idleIntent = new Intent(ACTION_DEVICE_IDLE, null);
+ mIdleIntent = PendingIntent.getBroadcast(mContext, IDLE_REQUEST, idleIntent, 0);
+
+ addState(mDefaultState);
+ addState(mApStaDisabledState, mDefaultState);
+ addState(mStaEnabledState, mDefaultState);
+ addState(mDeviceActiveState, mStaEnabledState);
+ addState(mDeviceInactiveState, mStaEnabledState);
+ addState(mScanOnlyLockHeldState, mDeviceInactiveState);
+ addState(mFullLockHeldState, mDeviceInactiveState);
+ addState(mFullHighPerfLockHeldState, mDeviceInactiveState);
+ addState(mNoLockHeldState, mDeviceInactiveState);
+ addState(mStaDisabledWithScanState, mDefaultState);
+ addState(mApEnabledState, mDefaultState);
+ addState(mEcmState, mDefaultState);
+ setInitialState(mApStaDisabledState);
+ setLogRecSize(25);
+ setLogOnlyTransitions(true);
+
+ IntentFilter filter = new IntentFilter();
+ filter.addAction(ACTION_DEVICE_IDLE);
+ filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
+ mContext.registerReceiver(
+ new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ String action = intent.getAction();
+ if (action.equals(ACTION_DEVICE_IDLE)) {
+ sendMessage(CMD_DEVICE_IDLE);
+ } else if (action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
+ mNetworkInfo = (NetworkInfo) intent.getParcelableExtra(
+ WifiManager.EXTRA_NETWORK_INFO);
+ }
+ }
+ },
+ new IntentFilter(filter));
+
+ initializeAndRegisterForSettingsChange(looper);
+ }
+
+ private void initializeAndRegisterForSettingsChange(Looper looper) {
+ Handler handler = new Handler(looper);
+ readStayAwakeConditions();
+ registerForStayAwakeModeChange(handler);
+ readWifiIdleTime();
+ registerForWifiIdleTimeChange(handler);
+ readStayAwakeConditions();
+ registerForWifiSleepPolicyChange(handler);
+ }
+
+ private void readStayAwakeConditions() {
+ mStayAwakeConditions = Settings.Global.getInt(mContext.getContentResolver(),
+ Settings.Global.STAY_ON_WHILE_PLUGGED_IN, 0);
+ }
+
+ private void readWifiIdleTime() {
+ mIdleMillis = Settings.Global.getLong(mContext.getContentResolver(),
+ Settings.Global.WIFI_IDLE_MS, DEFAULT_IDLE_MS);
+ }
+
+ private void readWifiSleepPolicy() {
+ mSleepPolicy = Settings.Global.getInt(mContext.getContentResolver(),
+ Settings.Global.WIFI_SLEEP_POLICY,
+ Settings.Global.WIFI_SLEEP_POLICY_NEVER);
+ }
+
+ /**
+ * Observes settings changes to scan always mode.
+ */
+ private void registerForStayAwakeModeChange(Handler handler) {
+ ContentObserver contentObserver = new ContentObserver(handler) {
+ @Override
+ public void onChange(boolean selfChange) {
+ readStayAwakeConditions();
+ }
+ };
+
+ mContext.getContentResolver().registerContentObserver(
+ Settings.Global.getUriFor(Settings.Global.STAY_ON_WHILE_PLUGGED_IN),
+ false, contentObserver);
+ }
+
+ /**
+ * Observes settings changes to scan always mode.
+ */
+ private void registerForWifiIdleTimeChange(Handler handler) {
+ ContentObserver contentObserver = new ContentObserver(handler) {
+ @Override
+ public void onChange(boolean selfChange) {
+ readWifiIdleTime();
+ }
+ };
+
+ mContext.getContentResolver().registerContentObserver(
+ Settings.Global.getUriFor(Settings.Global.WIFI_IDLE_MS),
+ false, contentObserver);
+ }
+
+ /**
+ * Observes changes to wifi sleep policy
+ */
+ private void registerForWifiSleepPolicyChange(Handler handler) {
+ ContentObserver contentObserver = new ContentObserver(handler) {
+ @Override
+ public void onChange(boolean selfChange) {
+ readWifiSleepPolicy();
+ }
+ };
+ mContext.getContentResolver().registerContentObserver(
+ Settings.Global.getUriFor(Settings.Global.WIFI_SLEEP_POLICY),
+ false, contentObserver);
+ }
+
+ /**
+ * Determines whether the Wi-Fi chipset should stay awake or be put to
+ * sleep. Looks at the setting for the sleep policy and the current
+ * conditions.
+ *
+ * @see #shouldDeviceStayAwake(int)
+ */
+ private boolean shouldWifiStayAwake(int pluggedType) {
+ if (mSleepPolicy == Settings.Global.WIFI_SLEEP_POLICY_NEVER) {
+ // Never sleep
+ return true;
+ } else if ((mSleepPolicy == Settings.Global.WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED) &&
+ (pluggedType != 0)) {
+ // Never sleep while plugged, and we're plugged
+ return true;
+ } else {
+ // Default
+ return shouldDeviceStayAwake(pluggedType);
+ }
+ }
+
+ /**
+ * Determine whether the bit value corresponding to {@code pluggedType} is set in
+ * the bit string mStayAwakeConditions. This determines whether the device should
+ * stay awake based on the current plugged type.
+ *
+ * @param pluggedType the type of plug (USB, AC, or none) for which the check is
+ * being made
+ * @return {@code true} if {@code pluggedType} indicates that the device is
+ * supposed to stay awake, {@code false} otherwise.
+ */
+ private boolean shouldDeviceStayAwake(int pluggedType) {
+ return (mStayAwakeConditions & pluggedType) != 0;
+ }
+
+ private void updateBatteryWorkSource() {
+ mTmpWorkSource.clear();
+ if (mDeviceIdle) {
+ mLocks.updateWorkSource(mTmpWorkSource);
+ }
+ mWifiStateMachine.updateBatteryWorkSource(mTmpWorkSource);
+ }
+
+ class DefaultState extends State {
+ @Override
+ public boolean processMessage(Message msg) {
+ switch (msg.what) {
+ case CMD_SCREEN_ON:
+ mAlarmManager.cancel(mIdleIntent);
+ mScreenOff = false;
+ mDeviceIdle = false;
+ updateBatteryWorkSource();
+ break;
+ case CMD_SCREEN_OFF:
+ mScreenOff = true;
+ /*
+ * Set a timer to put Wi-Fi to sleep, but only if the screen is off
+ * AND the "stay on while plugged in" setting doesn't match the
+ * current power conditions (i.e, not plugged in, plugged in to USB,
+ * or plugged in to AC).
+ */
+ if (!shouldWifiStayAwake(mPluggedType)) {
+ //Delayed shutdown if wifi is connected
+ if (mNetworkInfo.getDetailedState() ==
+ NetworkInfo.DetailedState.CONNECTED) {
+ if (DBG) Slog.d(TAG, "set idle timer: " + mIdleMillis + " ms");
+ mAlarmManager.set(AlarmManager.RTC_WAKEUP,
+ System.currentTimeMillis() + mIdleMillis, mIdleIntent);
+ } else {
+ sendMessage(CMD_DEVICE_IDLE);
+ }
+ }
+ break;
+ case CMD_DEVICE_IDLE:
+ mDeviceIdle = true;
+ updateBatteryWorkSource();
+ break;
+ case CMD_BATTERY_CHANGED:
+ /*
+ * Set a timer to put Wi-Fi to sleep, but only if the screen is off
+ * AND we are transitioning from a state in which the device was supposed
+ * to stay awake to a state in which it is not supposed to stay awake.
+ * If "stay awake" state is not changing, we do nothing, to avoid resetting
+ * the already-set timer.
+ */
+ int pluggedType = msg.arg1;
+ if (DBG) Slog.d(TAG, "battery changed pluggedType: " + pluggedType);
+ if (mScreenOff && shouldWifiStayAwake(mPluggedType) &&
+ !shouldWifiStayAwake(pluggedType)) {
+ long triggerTime = System.currentTimeMillis() + mIdleMillis;
+ if (DBG) Slog.d(TAG, "set idle timer for " + mIdleMillis + "ms");
+ mAlarmManager.set(AlarmManager.RTC_WAKEUP, triggerTime, mIdleIntent);
+ }
+
+ mPluggedType = pluggedType;
+ break;
+ case CMD_SET_AP:
+ case CMD_SCAN_ALWAYS_MODE_CHANGED:
+ case CMD_LOCKS_CHANGED:
+ case CMD_WIFI_TOGGLED:
+ case CMD_AIRPLANE_TOGGLED:
+ case CMD_EMERGENCY_MODE_CHANGED:
+ break;
+ default:
+ throw new RuntimeException("WifiController.handleMessage " + msg.what);
+ }
+ return HANDLED;
+ }
+
+ }
+
+ class ApStaDisabledState extends State {
+ @Override
+ public void enter() {
+ mWifiStateMachine.setSupplicantRunning(false);
+ }
+ @Override
+ public boolean processMessage(Message msg) {
+ switch (msg.what) {
+ case CMD_WIFI_TOGGLED:
+ case CMD_AIRPLANE_TOGGLED:
+ if (mSettingsStore.isWifiToggleEnabled()) {
+ if (mDeviceIdle == false) {
+ transitionTo(mDeviceActiveState);
+ } else {
+ checkLocksAndTransitionWhenDeviceIdle();
+ }
+ }
+ break;
+ case CMD_SCAN_ALWAYS_MODE_CHANGED:
+ if (mSettingsStore.isScanAlwaysAvailable()) {
+ transitionTo(mStaDisabledWithScanState);
+ }
+ break;
+ case CMD_SET_AP:
+ if (msg.arg1 == 1) {
+ mWifiStateMachine.setHostApRunning((WifiConfiguration) msg.obj,
+ true);
+ transitionTo(mApEnabledState);
+ }
+ break;
+ default:
+ return NOT_HANDLED;
+ }
+ return HANDLED;
+ }
+
+ }
+
+ class StaEnabledState extends State {
+ @Override
+ public void enter() {
+ mWifiStateMachine.setSupplicantRunning(true);
+ }
+ @Override
+ public boolean processMessage(Message msg) {
+ switch (msg.what) {
+ case CMD_WIFI_TOGGLED:
+ if (! mSettingsStore.isWifiToggleEnabled()) {
+ if (mSettingsStore.isScanAlwaysAvailable()) {
+ transitionTo(mStaDisabledWithScanState);
+ } else {
+ transitionTo(mApStaDisabledState);
+ }
+ }
+ break;
+ case CMD_AIRPLANE_TOGGLED:
+ /* When wi-fi is turned off due to airplane,
+ * disable entirely (including scan)
+ */
+ if (! mSettingsStore.isWifiToggleEnabled()) {
+ transitionTo(mApStaDisabledState);
+ }
+ break;
+ case CMD_EMERGENCY_MODE_CHANGED:
+ if (msg.arg1 == 1) {
+ transitionTo(mEcmState);
+ break;
+ }
+ default:
+ return NOT_HANDLED;
+
+ }
+ return HANDLED;
+ }
+ }
+
+ class StaDisabledWithScanState extends State {
+ @Override
+ public void enter() {
+ mWifiStateMachine.setSupplicantRunning(true);
+ mWifiStateMachine.setOperationalMode(WifiStateMachine.SCAN_ONLY_WITH_WIFI_OFF_MODE);
+ mWifiStateMachine.setDriverStart(true);
+ }
+
+ @Override
+ public boolean processMessage(Message msg) {
+ switch (msg.what) {
+ case CMD_WIFI_TOGGLED:
+ if (mSettingsStore.isWifiToggleEnabled()) {
+ if (mDeviceIdle == false) {
+ transitionTo(mDeviceActiveState);
+ } else {
+ checkLocksAndTransitionWhenDeviceIdle();
+ }
+ }
+ break;
+ case CMD_AIRPLANE_TOGGLED:
+ if (mSettingsStore.isAirplaneModeOn() &&
+ ! mSettingsStore.isWifiToggleEnabled()) {
+ transitionTo(mApStaDisabledState);
+ }
+ case CMD_SCAN_ALWAYS_MODE_CHANGED:
+ if (! mSettingsStore.isScanAlwaysAvailable()) {
+ transitionTo(mApStaDisabledState);
+ }
+ break;
+ case CMD_SET_AP:
+ // Before starting tethering, turn off supplicant for scan mode
+ if (msg.arg1 == 1) {
+ deferMessage(msg);
+ transitionTo(mApStaDisabledState);
+ }
+ break;
+ default:
+ return NOT_HANDLED;
+ }
+ return HANDLED;
+ }
+ }
+
+ class ApEnabledState extends State {
+ @Override
+ public boolean processMessage(Message msg) {
+ switch (msg.what) {
+ case CMD_AIRPLANE_TOGGLED:
+ if (mSettingsStore.isAirplaneModeOn()) {
+ mWifiStateMachine.setHostApRunning(null, false);
+ transitionTo(mApStaDisabledState);
+ }
+ break;
+ case CMD_SET_AP:
+ if (msg.arg1 == 0) {
+ mWifiStateMachine.setHostApRunning(null, false);
+ transitionTo(mApStaDisabledState);
+ }
+ break;
+ default:
+ return NOT_HANDLED;
+ }
+ return HANDLED;
+ }
+ }
+
+ class EcmState extends State {
+ @Override
+ public void enter() {
+ mWifiStateMachine.setSupplicantRunning(false);
+ }
+
+ @Override
+ public boolean processMessage(Message msg) {
+ if (msg.what == CMD_EMERGENCY_MODE_CHANGED && msg.arg1 == 0) {
+ if (mSettingsStore.isWifiToggleEnabled()) {
+ if (mDeviceIdle == false) {
+ transitionTo(mDeviceActiveState);
+ } else {
+ checkLocksAndTransitionWhenDeviceIdle();
+ }
+ } else if (mSettingsStore.isScanAlwaysAvailable()) {
+ transitionTo(mStaDisabledWithScanState);
+ } else {
+ transitionTo(mApStaDisabledState);
+ }
+ return HANDLED;
+ } else {
+ return NOT_HANDLED;
+ }
+ }
+ }
+
+ /* Parent: StaEnabledState */
+ class DeviceActiveState extends State {
+ @Override
+ public void enter() {
+ mWifiStateMachine.setOperationalMode(WifiStateMachine.CONNECT_MODE);
+ mWifiStateMachine.setDriverStart(true);
+ mWifiStateMachine.setHighPerfModeEnabled(false);
+ }
+
+ @Override
+ public boolean processMessage(Message msg) {
+ if (msg.what == CMD_DEVICE_IDLE) {
+ checkLocksAndTransitionWhenDeviceIdle();
+ // We let default state handle the rest of work
+ }
+ return NOT_HANDLED;
+ }
+ }
+
+ /* Parent: StaEnabledState */
+ class DeviceInactiveState extends State {
+ @Override
+ public boolean processMessage(Message msg) {
+ switch (msg.what) {
+ case CMD_LOCKS_CHANGED:
+ checkLocksAndTransitionWhenDeviceIdle();
+ updateBatteryWorkSource();
+ return HANDLED;
+ case CMD_SCREEN_ON:
+ transitionTo(mDeviceActiveState);
+ // More work in default state
+ return NOT_HANDLED;
+ default:
+ return NOT_HANDLED;
+ }
+ }
+ }
+
+ /* Parent: DeviceInactiveState. Device is inactive, but an app is holding a scan only lock. */
+ class ScanOnlyLockHeldState extends State {
+ @Override
+ public void enter() {
+ mWifiStateMachine.setOperationalMode(WifiStateMachine.SCAN_ONLY_MODE);
+ mWifiStateMachine.setDriverStart(true);
+ }
+ }
+
+ /* Parent: DeviceInactiveState. Device is inactive, but an app is holding a full lock. */
+ class FullLockHeldState extends State {
+ @Override
+ public void enter() {
+ mWifiStateMachine.setOperationalMode(WifiStateMachine.CONNECT_MODE);
+ mWifiStateMachine.setDriverStart(true);
+ mWifiStateMachine.setHighPerfModeEnabled(false);
+ }
+ }
+
+ /* Parent: DeviceInactiveState. Device is inactive, but an app is holding a high perf lock. */
+ class FullHighPerfLockHeldState extends State {
+ @Override
+ public void enter() {
+ mWifiStateMachine.setOperationalMode(WifiStateMachine.CONNECT_MODE);
+ mWifiStateMachine.setDriverStart(true);
+ mWifiStateMachine.setHighPerfModeEnabled(true);
+ }
+ }
+
+ /* Parent: DeviceInactiveState. Device is inactive and no app is holding a wifi lock. */
+ class NoLockHeldState extends State {
+ @Override
+ public void enter() {
+ mWifiStateMachine.setDriverStart(false);
+ }
+ }
+
+ private void checkLocksAndTransitionWhenDeviceIdle() {
+ if (mLocks.hasLocks()) {
+ switch (mLocks.getStrongestLockMode()) {
+ case WIFI_MODE_FULL:
+ transitionTo(mFullLockHeldState);
+ break;
+ case WIFI_MODE_FULL_HIGH_PERF:
+ transitionTo(mFullHighPerfLockHeldState);
+ break;
+ case WIFI_MODE_SCAN_ONLY:
+ transitionTo(mScanOnlyLockHeldState);
+ break;
+ default:
+ loge("Illegal lock " + mLocks.getStrongestLockMode());
+ }
+ } else {
+ if (mSettingsStore.isScanAlwaysAvailable()) {
+ transitionTo(mScanOnlyLockHeldState);
+ } else {
+ transitionTo(mNoLockHeldState);
+ }
+ }
+ }
+
+ @Override
+ public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
+ super.dump(fd, pw, args);
+
+ pw.println("mScreenOff " + mScreenOff);
+ pw.println("mDeviceIdle " + mDeviceIdle);
+ pw.println("mPluggedType " + mPluggedType);
+ pw.println("mIdleMillis " + mIdleMillis);
+ pw.println("mSleepPolicy " + mSleepPolicy);
+ }
+}
diff --git a/services/java/com/android/server/wifi/WifiService.java b/services/java/com/android/server/wifi/WifiService.java
index d675822..bc6bdaf 100644
--- a/services/java/com/android/server/wifi/WifiService.java
+++ b/services/java/com/android/server/wifi/WifiService.java
@@ -17,15 +17,14 @@
package com.android.server.wifi;
import android.app.ActivityManager;
-import android.app.AlarmManager;
import android.app.AppOpsManager;
-import android.app.PendingIntent;
import android.bluetooth.BluetoothAdapter;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
+import android.database.ContentObserver;
import android.net.wifi.IWifiManager;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiInfo;
@@ -33,12 +32,9 @@
import android.net.wifi.WifiStateMachine;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiWatchdogStateMachine;
-import android.net.ConnectivityManager;
import android.net.DhcpInfo;
import android.net.DhcpResults;
import android.net.LinkAddress;
-import android.net.NetworkInfo;
-import android.net.NetworkInfo.DetailedState;
import android.net.NetworkUtils;
import android.net.RouteInfo;
import android.os.Binder;
@@ -63,39 +59,35 @@
import java.util.ArrayList;
import java.util.List;
+import com.android.internal.R;
import com.android.internal.app.IBatteryStats;
import com.android.internal.telephony.TelephonyIntents;
import com.android.internal.util.AsyncChannel;
import com.android.server.am.BatteryStatsService;
-import com.android.internal.R;
-
+import static com.android.server.wifi.WifiController.CMD_AIRPLANE_TOGGLED;
+import static com.android.server.wifi.WifiController.CMD_BATTERY_CHANGED;
+import static com.android.server.wifi.WifiController.CMD_EMERGENCY_MODE_CHANGED;
+import static com.android.server.wifi.WifiController.CMD_LOCKS_CHANGED;
+import static com.android.server.wifi.WifiController.CMD_SCAN_ALWAYS_MODE_CHANGED;
+import static com.android.server.wifi.WifiController.CMD_SCREEN_OFF;
+import static com.android.server.wifi.WifiController.CMD_SCREEN_ON;
+import static com.android.server.wifi.WifiController.CMD_SET_AP;
+import static com.android.server.wifi.WifiController.CMD_WIFI_TOGGLED;
/**
* WifiService handles remote WiFi operation requests by implementing
* the IWifiManager interface.
*
* @hide
*/
-//TODO: Clean up multiple locks and implement WifiService
-// as a SM to track soft AP/client/adhoc bring up based
-// on device idle state, airplane mode and boot.
-
public final class WifiService extends IWifiManager.Stub {
private static final String TAG = "WifiService";
private static final boolean DBG = false;
- private final WifiStateMachine mWifiStateMachine;
+ final WifiStateMachine mWifiStateMachine;
private final Context mContext;
- private AlarmManager mAlarmManager;
- private PendingIntent mIdleIntent;
- private static final int IDLE_REQUEST = 0;
- private boolean mScreenOff;
- private boolean mDeviceIdle;
- private boolean mEmergencyCallbackMode = false;
- private int mPluggedType;
-
- private final LockList mLocks = new LockList();
+ final LockList mLocks = new LockList();
// some wifi lock statistics
private int mFullHighPerfLocksAcquired;
private int mFullHighPerfLocksReleased;
@@ -119,19 +111,7 @@
/* Polls traffic stats and notifies clients */
private WifiTrafficPoller mTrafficPoller;
/* Tracks the persisted states for wi-fi & airplane mode */
- private WifiSettingsStore mSettingsStore;
-
- /**
- * See {@link Settings.Global#WIFI_IDLE_MS}. This is the default value if a
- * Settings.Global value is not present. This timeout value is chosen as
- * the approximate point at which the battery drain caused by Wi-Fi
- * being enabled but not active exceeds the battery drain caused by
- * re-establishing a connection to the mobile data network.
- */
- private static final long DEFAULT_IDLE_MS = 15 * 60 * 1000; /* 15 minutes */
-
- private static final String ACTION_DEVICE_IDLE =
- "com.android.server.WifiManager.action.DEVICE_IDLE";
+ final WifiSettingsStore mSettingsStore;
/* The work source (UID) that triggered the current WIFI scan, synchronized
* on this */
@@ -139,8 +119,6 @@
private boolean mIsReceiverRegistered = false;
- NetworkInfo mNetworkInfo = new NetworkInfo(ConnectivityManager.TYPE_WIFI, 0, "WIFI", "");
-
/**
* Asynchronous channel to WifiStateMachine
*/
@@ -195,7 +173,7 @@
break;
}
default: {
- Slog.d(TAG, "WifiServicehandler.handleMessage ignoring msg=" + msg);
+ Slog.d(TAG, "ClientHandler.handleMessage ignoring msg=" + msg);
break;
}
}
@@ -243,11 +221,6 @@
}
WifiStateMachineHandler mWifiStateMachineHandler;
- /**
- * Temporary for computing UIDS that are responsible for starting WIFI.
- * Protected by mWifiStateTracker lock.
- */
- private final WorkSource mTmpWorkSource = new WorkSource();
private WifiWatchdogStateMachine mWifiWatchdogStateMachine;
public WifiService(Context context) {
@@ -260,20 +233,24 @@
mBatteryStats = BatteryStatsService.getService();
mAppOps = (AppOpsManager)context.getSystemService(Context.APP_OPS_SERVICE);
- mAlarmManager = (AlarmManager)mContext.getSystemService(Context.ALARM_SERVICE);
- Intent idleIntent = new Intent(ACTION_DEVICE_IDLE, null);
- mIdleIntent = PendingIntent.getBroadcast(mContext, IDLE_REQUEST, idleIntent, 0);
-
mNotificationController = new WifiNotificationController(mContext, mWifiStateMachine);
mTrafficPoller = new WifiTrafficPoller(mContext, mInterfaceName);
mSettingsStore = new WifiSettingsStore(mContext);
+ HandlerThread wifiThread = new HandlerThread("WifiService");
+ wifiThread.start();
+ mClientHandler = new ClientHandler(wifiThread.getLooper());
+ mWifiStateMachineHandler = new WifiStateMachineHandler(wifiThread.getLooper());
+ mWifiController = new WifiController(mContext, this, wifiThread.getLooper());
+ mWifiController.start();
+
+ registerForScanModeChange();
mContext.registerReceiver(
new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (mSettingsStore.handleAirplaneModeToggled()) {
- updateWifiState();
+ mWifiController.sendMessage(CMD_AIRPLANE_TOGGLED);
}
}
},
@@ -289,13 +266,10 @@
}
}
}, new IntentFilter(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION));
-
- HandlerThread wifiThread = new HandlerThread("WifiService");
- wifiThread.start();
- mClientHandler = new ClientHandler(wifiThread.getLooper());
- mWifiStateMachineHandler = new WifiStateMachineHandler(wifiThread.getLooper());
}
+ private WifiController mWifiController;
+
/** Tell battery stats about a new WIFI scan */
private void noteScanStart() {
WorkSource scanWorkSource = null;
@@ -342,7 +316,7 @@
*/
public void checkAndStartWifi() {
/* Check if wi-fi needs to be enabled */
- boolean wifiEnabled = mSettingsStore.shouldWifiBeEnabled();
+ boolean wifiEnabled = mSettingsStore.isWifiToggleEnabled();
Slog.i(TAG, "WifiService starting up with Wi-Fi " +
(wifiEnabled ? "enabled" : "disabled"));
@@ -430,11 +404,7 @@
Binder.restoreCallingIdentity(ident);
}
- if (enable) {
- reportStartWorkSource();
- }
-
- mWifiStateMachine.setWifiEnabled(enable);
+ mWifiController.sendMessage(CMD_WIFI_TOGGLED);
if (enable) {
if (!mIsReceiverRegistered) {
@@ -470,7 +440,7 @@
*/
public void setWifiApEnabled(WifiConfiguration wifiConfig, boolean enabled) {
enforceChangePermission();
- mWifiStateMachine.setWifiApEnabled(wifiConfig, enabled);
+ mWifiController.obtainMessage(CMD_SET_AP, enabled ? 1 : 0, 0, wifiConfig).sendToTarget();
}
/**
@@ -507,6 +477,26 @@
}
/**
+ * @param enable {@code true} to enable, {@code false} to disable.
+ * @return {@code true} if the enable/disable operation was
+ * started or is already in the queue.
+ */
+ public boolean isScanningAlwaysAvailable() {
+ // TODO: implement
+ return true;
+ }
+
+ /**
+ * @param enable {@code true} to enable, {@code false} to disable.
+ * @return {@code true} if the enable/disable operation was
+ * started or is already in the queue.
+ */
+ public void setScanningAlwaysAvailable(boolean enable) {
+ // TODO: implement
+ }
+
+
+ /**
* see {@link android.net.wifi.WifiManager#disconnect()}
*/
public void disconnect() {
@@ -777,7 +767,7 @@
* of WifiLock & device idle status unless wifi enabled status is toggled
*/
- mWifiStateMachine.setDriverStart(true, mEmergencyCallbackMode);
+ mWifiStateMachine.setDriverStart(true);
mWifiStateMachine.reconnectCommand();
}
@@ -796,7 +786,7 @@
* TODO: if a stop is issued, wifi is brought up only by startWifi
* unless wifi enabled status is toggled
*/
- mWifiStateMachine.setDriverStart(false, mEmergencyCallbackMode);
+ mWifiStateMachine.setDriverStart(false);
}
/**
@@ -848,175 +838,39 @@
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
-
- long idleMillis =
- Settings.Global.getLong(mContext.getContentResolver(),
- Settings.Global.WIFI_IDLE_MS, DEFAULT_IDLE_MS);
- int stayAwakeConditions =
- Settings.Global.getInt(mContext.getContentResolver(),
- Settings.Global.STAY_ON_WHILE_PLUGGED_IN, 0);
if (action.equals(Intent.ACTION_SCREEN_ON)) {
- if (DBG) {
- Slog.d(TAG, "ACTION_SCREEN_ON");
- }
- mAlarmManager.cancel(mIdleIntent);
- mScreenOff = false;
- setDeviceIdleAndUpdateWifi(false);
+ mWifiController.sendMessage(CMD_SCREEN_ON);
} else if (action.equals(Intent.ACTION_SCREEN_OFF)) {
- if (DBG) {
- Slog.d(TAG, "ACTION_SCREEN_OFF");
- }
- mScreenOff = true;
- /*
- * Set a timer to put Wi-Fi to sleep, but only if the screen is off
- * AND the "stay on while plugged in" setting doesn't match the
- * current power conditions (i.e, not plugged in, plugged in to USB,
- * or plugged in to AC).
- */
- if (!shouldWifiStayAwake(stayAwakeConditions, mPluggedType)) {
- //Delayed shutdown if wifi is connected
- if (mNetworkInfo.getDetailedState() == DetailedState.CONNECTED) {
- if (DBG) Slog.d(TAG, "setting ACTION_DEVICE_IDLE: " + idleMillis + " ms");
- mAlarmManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis()
- + idleMillis, mIdleIntent);
- } else {
- setDeviceIdleAndUpdateWifi(true);
- }
- }
- } else if (action.equals(ACTION_DEVICE_IDLE)) {
- setDeviceIdleAndUpdateWifi(true);
+ mWifiController.sendMessage(CMD_SCREEN_OFF);
} else if (action.equals(Intent.ACTION_BATTERY_CHANGED)) {
- /*
- * Set a timer to put Wi-Fi to sleep, but only if the screen is off
- * AND we are transitioning from a state in which the device was supposed
- * to stay awake to a state in which it is not supposed to stay awake.
- * If "stay awake" state is not changing, we do nothing, to avoid resetting
- * the already-set timer.
- */
int pluggedType = intent.getIntExtra("plugged", 0);
- if (DBG) {
- Slog.d(TAG, "ACTION_BATTERY_CHANGED pluggedType: " + pluggedType);
- }
- if (mScreenOff && shouldWifiStayAwake(stayAwakeConditions, mPluggedType) &&
- !shouldWifiStayAwake(stayAwakeConditions, pluggedType)) {
- long triggerTime = System.currentTimeMillis() + idleMillis;
- if (DBG) {
- Slog.d(TAG, "setting ACTION_DEVICE_IDLE timer for " + idleMillis + "ms");
- }
- mAlarmManager.set(AlarmManager.RTC_WAKEUP, triggerTime, mIdleIntent);
- }
-
- mPluggedType = pluggedType;
+ mWifiController.sendMessage(CMD_BATTERY_CHANGED, pluggedType, 0, null);
} else if (action.equals(BluetoothAdapter.ACTION_CONNECTION_STATE_CHANGED)) {
int state = intent.getIntExtra(BluetoothAdapter.EXTRA_CONNECTION_STATE,
BluetoothAdapter.STATE_DISCONNECTED);
mWifiStateMachine.sendBluetoothAdapterStateChange(state);
} else if (action.equals(TelephonyIntents.ACTION_EMERGENCY_CALLBACK_MODE_CHANGED)) {
- mEmergencyCallbackMode = intent.getBooleanExtra("phoneinECMState", false);
- updateWifiState();
+ boolean emergencyMode = intent.getBooleanExtra("phoneinECMState", false);
+ mWifiController.sendMessage(CMD_EMERGENCY_MODE_CHANGED, emergencyMode ? 1 : 0, 0);
}
}
-
- /**
- * Determines whether the Wi-Fi chipset should stay awake or be put to
- * sleep. Looks at the setting for the sleep policy and the current
- * conditions.
- *
- * @see #shouldDeviceStayAwake(int, int)
- */
- private boolean shouldWifiStayAwake(int stayAwakeConditions, int pluggedType) {
- //Never sleep as long as the user has not changed the settings
- int wifiSleepPolicy = Settings.Global.getInt(mContext.getContentResolver(),
- Settings.Global.WIFI_SLEEP_POLICY,
- Settings.Global.WIFI_SLEEP_POLICY_NEVER);
-
- if (wifiSleepPolicy == Settings.Global.WIFI_SLEEP_POLICY_NEVER) {
- // Never sleep
- return true;
- } else if ((wifiSleepPolicy == Settings.Global.WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED) &&
- (pluggedType != 0)) {
- // Never sleep while plugged, and we're plugged
- return true;
- } else {
- // Default
- return shouldDeviceStayAwake(stayAwakeConditions, pluggedType);
- }
- }
-
- /**
- * Determine whether the bit value corresponding to {@code pluggedType} is set in
- * the bit string {@code stayAwakeConditions}. Because a {@code pluggedType} value
- * of {@code 0} isn't really a plugged type, but rather an indication that the
- * device isn't plugged in at all, there is no bit value corresponding to a
- * {@code pluggedType} value of {@code 0}. That is why we shift by
- * {@code pluggedType - 1} instead of by {@code pluggedType}.
- * @param stayAwakeConditions a bit string specifying which "plugged types" should
- * keep the device (and hence Wi-Fi) awake.
- * @param pluggedType the type of plug (USB, AC, or none) for which the check is
- * being made
- * @return {@code true} if {@code pluggedType} indicates that the device is
- * supposed to stay awake, {@code false} otherwise.
- */
- private boolean shouldDeviceStayAwake(int stayAwakeConditions, int pluggedType) {
- return (stayAwakeConditions & pluggedType) != 0;
- }
};
- private void setDeviceIdleAndUpdateWifi(boolean deviceIdle) {
- mDeviceIdle = deviceIdle;
- reportStartWorkSource();
- updateWifiState();
- }
-
- private synchronized void reportStartWorkSource() {
- mTmpWorkSource.clear();
- if (mDeviceIdle) {
- for (int i=0; i<mLocks.mList.size(); i++) {
- mTmpWorkSource.add(mLocks.mList.get(i).mWorkSource);
+ /**
+ * Observes settings changes to scan always mode.
+ */
+ private void registerForScanModeChange() {
+ ContentObserver contentObserver = new ContentObserver(null) {
+ @Override
+ public void onChange(boolean selfChange) {
+ mSettingsStore.handleWifiScanAlwaysAvailableToggled();
+ mWifiController.sendMessage(CMD_SCAN_ALWAYS_MODE_CHANGED);
}
- }
- mWifiStateMachine.updateBatteryWorkSource(mTmpWorkSource);
- }
+ };
- private void updateWifiState() {
- boolean lockHeld = mLocks.hasLocks();
- int strongestLockMode = WifiManager.WIFI_MODE_FULL;
- boolean wifiShouldBeStarted;
-
- if (mEmergencyCallbackMode) {
- wifiShouldBeStarted = false;
- } else {
- wifiShouldBeStarted = !mDeviceIdle || lockHeld;
- }
-
- if (lockHeld) {
- strongestLockMode = mLocks.getStrongestLockMode();
- }
- /* If device is not idle, lockmode cannot be scan only */
- if (!mDeviceIdle && strongestLockMode == WifiManager.WIFI_MODE_SCAN_ONLY) {
- strongestLockMode = WifiManager.WIFI_MODE_FULL;
- }
-
- /* Disable tethering when airplane mode is enabled */
- if (mSettingsStore.isAirplaneModeOn()) {
- mWifiStateMachine.setWifiApEnabled(null, false);
- }
-
- if (mSettingsStore.shouldWifiBeEnabled()) {
- if (wifiShouldBeStarted) {
- reportStartWorkSource();
- mWifiStateMachine.setWifiEnabled(true);
- mWifiStateMachine.setScanOnlyMode(
- strongestLockMode == WifiManager.WIFI_MODE_SCAN_ONLY);
- mWifiStateMachine.setDriverStart(true, mEmergencyCallbackMode);
- mWifiStateMachine.setHighPerfModeEnabled(strongestLockMode
- == WifiManager.WIFI_MODE_FULL_HIGH_PERF);
- } else {
- mWifiStateMachine.setDriverStart(false, mEmergencyCallbackMode);
- }
- } else {
- mWifiStateMachine.setWifiEnabled(false);
- }
+ mContext.getContentResolver().registerContentObserver(
+ Settings.Global.getUriFor(Settings.Global.WIFI_SCAN_ALWAYS_AVAILABLE),
+ false, contentObserver);
}
private void registerForBroadcasts() {
@@ -1024,7 +878,7 @@
intentFilter.addAction(Intent.ACTION_SCREEN_ON);
intentFilter.addAction(Intent.ACTION_SCREEN_OFF);
intentFilter.addAction(Intent.ACTION_BATTERY_CHANGED);
- intentFilter.addAction(ACTION_DEVICE_IDLE);
+ intentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
intentFilter.addAction(BluetoothAdapter.ACTION_CONNECTION_STATE_CHANGED);
intentFilter.addAction(TelephonyIntents.ACTION_EMERGENCY_CALLBACK_MODE_CHANGED);
mContext.registerReceiver(mReceiver, intentFilter);
@@ -1043,12 +897,9 @@
pw.println("Stay-awake conditions: " +
Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.STAY_ON_WHILE_PLUGGED_IN, 0));
- pw.println("mScreenOff " + mScreenOff);
- pw.println("mDeviceIdle " + mDeviceIdle);
- pw.println("mPluggedType " + mPluggedType);
- pw.println("mEmergencyCallbackMode " + mEmergencyCallbackMode);
pw.println("mMulticastEnabled " + mMulticastEnabled);
pw.println("mMulticastDisabled " + mMulticastDisabled);
+ mWifiController.dump(fd, pw, args);
mSettingsStore.dump(fd, pw, args);
mNotificationController.dump(fd, pw, args);
mTrafficPoller.dump(fd, pw, args);
@@ -1099,18 +950,18 @@
}
}
- private class LockList {
+ class LockList {
private List<WifiLock> mList;
private LockList() {
mList = new ArrayList<WifiLock>();
}
- private synchronized boolean hasLocks() {
+ synchronized boolean hasLocks() {
return !mList.isEmpty();
}
- private synchronized int getStrongestLockMode() {
+ synchronized int getStrongestLockMode() {
if (mList.isEmpty()) {
return WifiManager.WIFI_MODE_FULL;
}
@@ -1126,6 +977,12 @@
return WifiManager.WIFI_MODE_SCAN_ONLY;
}
+ synchronized void updateWorkSource(WorkSource ws) {
+ for (int i = 0; i < mLocks.mList.size(); i++) {
+ ws.add(mLocks.mList.get(i).mWorkSource);
+ }
+ }
+
private void addLock(WifiLock lock) {
if (findLockByBinder(lock.mBinder) < 0) {
mList.add(lock);
@@ -1145,9 +1002,10 @@
private int findLockByBinder(IBinder binder) {
int size = mList.size();
- for (int i = size - 1; i >= 0; i--)
+ for (int i = size - 1; i >= 0; i--) {
if (mList.get(i).mBinder == binder)
return i;
+ }
return -1;
}
@@ -1231,12 +1089,7 @@
++mScanLocksAcquired;
break;
}
-
- // Be aggressive about adding new locks into the accounted state...
- // we want to over-report rather than under-report.
- reportStartWorkSource();
-
- updateWifiState();
+ mWifiController.sendMessage(CMD_LOCKS_CHANGED);
return true;
} catch (RemoteException e) {
return false;
@@ -1303,11 +1156,8 @@
++mScanLocksReleased;
break;
}
+ mWifiController.sendMessage(CMD_LOCKS_CHANGED);
}
-
- // TODO - should this only happen if you hadLock?
- updateWifiState();
-
} catch (RemoteException e) {
} finally {
Binder.restoreCallingIdentity(ident);
diff --git a/services/java/com/android/server/wifi/WifiSettingsStore.java b/services/java/com/android/server/wifi/WifiSettingsStore.java
index d7c8752..3ff8061 100644
--- a/services/java/com/android/server/wifi/WifiSettingsStore.java
+++ b/services/java/com/android/server/wifi/WifiSettingsStore.java
@@ -37,7 +37,11 @@
private int mPersistWifiState = WIFI_DISABLED;
/* Tracks current airplane mode state */
private boolean mAirplaneModeOn = false;
- /* Tracks whether wifi is enabled from WifiStateMachine's perspective */
+
+ /* Tracks the setting of scan being available even when wi-fi is turned off
+ */
+ private boolean mScanAlwaysAvailable;
+
private final Context mContext;
/* Tracks if we have checked the saved wi-fi state after boot */
@@ -47,9 +51,10 @@
mContext = context;
mAirplaneModeOn = getPersistedAirplaneModeOn();
mPersistWifiState = getPersistedWifiState();
+ mScanAlwaysAvailable = getPersistedScanAlwaysAvailable();
}
- synchronized boolean shouldWifiBeEnabled() {
+ synchronized boolean isWifiToggleEnabled() {
if (!mCheckSavedStateAtBoot) {
mCheckSavedStateAtBoot = true;
if (testAndClearWifiSavedState()) return true;
@@ -70,6 +75,10 @@
return mAirplaneModeOn;
}
+ synchronized boolean isScanAlwaysAvailable() {
+ return mScanAlwaysAvailable;
+ }
+
synchronized boolean handleWifiToggled(boolean wifiEnabled) {
// Can Wi-Fi be toggled in airplane mode ?
if (mAirplaneModeOn && !isAirplaneToggleable()) {
@@ -114,6 +123,10 @@
return true;
}
+ synchronized void handleWifiScanAlwaysAvailableToggled() {
+ mScanAlwaysAvailable = getPersistedScanAlwaysAvailable();
+ }
+
void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
pw.println("mPersistWifiState " + mPersistWifiState);
pw.println("mAirplaneModeOn " + mAirplaneModeOn);
@@ -175,4 +188,10 @@
return Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.AIRPLANE_MODE_ON, 0) == 1;
}
+
+ private boolean getPersistedScanAlwaysAvailable() {
+ return Settings.Global.getInt(mContext.getContentResolver(),
+ Settings.Global.WIFI_SCAN_ALWAYS_AVAILABLE,
+ 0) == 1;
+ }
}
diff --git a/tests/AppLaunch/src/com/android/tests/applaunch/AppLaunch.java b/tests/AppLaunch/src/com/android/tests/applaunch/AppLaunch.java
index fbdd333..dffb617 100644
--- a/tests/AppLaunch/src/com/android/tests/applaunch/AppLaunch.java
+++ b/tests/AppLaunch/src/com/android/tests/applaunch/AppLaunch.java
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2012 The Android Open Source Project
+ * Copyright (C) 2013 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.
@@ -32,6 +32,7 @@
import android.test.InstrumentationTestRunner;
import android.util.Log;
+import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
@@ -48,16 +49,22 @@
public class AppLaunch extends InstrumentationTestCase {
private static final int JOIN_TIMEOUT = 10000;
- private static final String TAG = "AppLaunch";
+ private static final String TAG = AppLaunch.class.getSimpleName();
private static final String KEY_APPS = "apps";
+ private static final String KEY_LAUNCH_ITERATIONS = "launch_iterations";
+ private static final int INITIAL_LAUNCH_IDLE_TIMEOUT = 7500; //7.5s to allow app to idle
+ private static final int POST_LAUNCH_IDLE_TIMEOUT = 750; //750ms idle for non initial launches
+ private static final int BETWEEN_LAUNCH_SLEEP_TIMEOUT = 2000; //2s between launching apps
private Map<String, Intent> mNameToIntent;
private Map<String, String> mNameToProcess;
private Map<String, String> mNameToResultKey;
-
+ private Map<String, Long> mNameToLaunchTime;
private IActivityManager mAm;
+ private int mLaunchIterations = 10;
+ private Bundle mResult = new Bundle();
- public void testMeasureStartUpTime() throws RemoteException {
+ public void testMeasureStartUpTime() throws RemoteException, NameNotFoundException {
InstrumentationTestRunner instrumentation =
(InstrumentationTestRunner)getInstrumentation();
Bundle args = instrumentation.getArguments();
@@ -66,25 +73,59 @@
createMappings();
parseArgs(args);
- Bundle results = new Bundle();
+ // do initial app launch, without force stopping
for (String app : mNameToResultKey.keySet()) {
- try {
- startApp(app, results);
- sleep(750);
- closeApp(app);
- sleep(2000);
- } catch (NameNotFoundException e) {
- Log.i(TAG, "Application " + app + " not found");
+ long launchTime = startApp(app, false);
+ if (launchTime <=0 ) {
+ mNameToLaunchTime.put(app, -1L);
+ // simply pass the app if launch isn't successful
+ // error should have already been logged by startApp
+ continue;
}
-
+ sleep(INITIAL_LAUNCH_IDLE_TIMEOUT);
+ closeApp(app, false);
+ sleep(BETWEEN_LAUNCH_SLEEP_TIMEOUT);
}
- instrumentation.sendStatus(0, results);
+ // do the real app launch now
+ for (int i = 0; i < mLaunchIterations; i++) {
+ for (String app : mNameToResultKey.keySet()) {
+ long totalLaunchTime = mNameToLaunchTime.get(app);
+ long launchTime = 0;
+ if (totalLaunchTime < 0) {
+ // skip if the app has previous failures
+ continue;
+ }
+ launchTime = startApp(app, true);
+ if (launchTime <= 0) {
+ // if it fails once, skip the rest of the launches
+ mNameToLaunchTime.put(app, -1L);
+ continue;
+ }
+ totalLaunchTime += launchTime;
+ mNameToLaunchTime.put(app, totalLaunchTime);
+ sleep(POST_LAUNCH_IDLE_TIMEOUT);
+ closeApp(app, true);
+ sleep(BETWEEN_LAUNCH_SLEEP_TIMEOUT);
+ }
+ }
+ for (String app : mNameToResultKey.keySet()) {
+ long totalLaunchTime = mNameToLaunchTime.get(app);
+ if (totalLaunchTime != -1) {
+ mResult.putDouble(mNameToResultKey.get(app),
+ ((double) totalLaunchTime) / mLaunchIterations);
+ }
+ }
+ instrumentation.sendStatus(0, mResult);
}
private void parseArgs(Bundle args) {
mNameToResultKey = new LinkedHashMap<String, String>();
+ mNameToLaunchTime = new HashMap<String, Long>();
+ String launchIterations = args.getString(KEY_LAUNCH_ITERATIONS);
+ if (launchIterations != null) {
+ mLaunchIterations = Integer.parseInt(launchIterations);
+ }
String appList = args.getString(KEY_APPS);
-
if (appList == null)
return;
@@ -97,6 +138,7 @@
}
mNameToResultKey.put(parts[0], parts[1]);
+ mNameToLaunchTime.put(parts[0], 0L);
}
}
@@ -118,23 +160,26 @@
| Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
startIntent.setClassName(ri.activityInfo.packageName,
ri.activityInfo.name);
- mNameToIntent.put(ri.loadLabel(pm).toString(), startIntent);
- mNameToProcess.put(ri.loadLabel(pm).toString(),
- ri.activityInfo.processName);
+ String appName = ri.loadLabel(pm).toString();
+ if (appName != null) {
+ mNameToIntent.put(appName, startIntent);
+ mNameToProcess.put(appName, ri.activityInfo.processName);
+ }
}
}
}
- private void startApp(String appName, Bundle results)
+ private long startApp(String appName, boolean forceStopBeforeLaunch)
throws NameNotFoundException, RemoteException {
Log.i(TAG, "Starting " + appName);
Intent startIntent = mNameToIntent.get(appName);
if (startIntent == null) {
Log.w(TAG, "App does not exist: " + appName);
- return;
+ mResult.putString(mNameToResultKey.get(appName), "App does not exist");
+ return -1;
}
- AppLaunchRunnable runnable = new AppLaunchRunnable(startIntent);
+ AppLaunchRunnable runnable = new AppLaunchRunnable(startIntent, forceStopBeforeLaunch);
Thread t = new Thread(runnable);
t.start();
try {
@@ -143,27 +188,38 @@
// ignore
}
WaitResult result = runnable.getResult();
- if(t.isAlive() || (result != null && result.result != ActivityManager.START_SUCCESS)) {
+ // report error if any of the following is true:
+ // * launch thread is alive
+ // * result is not null, but:
+ // * result is not START_SUCESS
+ // * or in case of no force stop, result is not TASK_TO_FRONT either
+ if (t.isAlive() || (result != null
+ && ((result.result != ActivityManager.START_SUCCESS)
+ && (!forceStopBeforeLaunch
+ && result.result != ActivityManager.START_TASK_TO_FRONT)))) {
Log.w(TAG, "Assuming app " + appName + " crashed.");
- reportError(appName, mNameToProcess.get(appName), results);
- return;
+ reportError(appName, mNameToProcess.get(appName));
+ return -1;
}
- results.putString(mNameToResultKey.get(appName), String.valueOf(result.thisTime));
+ return result.thisTime;
}
- private void closeApp(String appName) {
+ private void closeApp(String appName, boolean forceStopApp) {
Intent homeIntent = new Intent(Intent.ACTION_MAIN);
homeIntent.addCategory(Intent.CATEGORY_HOME);
homeIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
| Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
getInstrumentation().getContext().startActivity(homeIntent);
- Intent startIntent = mNameToIntent.get(appName);
- if (startIntent != null) {
- String packageName = startIntent.getComponent().getPackageName();
- try {
- mAm.forceStopPackage(packageName, UserHandle.USER_CURRENT);
- } catch (RemoteException e) {
- Log.w(TAG, "Error closing app", e);
+ sleep(POST_LAUNCH_IDLE_TIMEOUT);
+ if (forceStopApp) {
+ Intent startIntent = mNameToIntent.get(appName);
+ if (startIntent != null) {
+ String packageName = startIntent.getComponent().getPackageName();
+ try {
+ mAm.forceStopPackage(packageName, UserHandle.USER_CURRENT);
+ } catch (RemoteException e) {
+ Log.w(TAG, "Error closing app", e);
+ }
}
}
}
@@ -176,7 +232,7 @@
}
}
- private void reportError(String appName, String processName, Bundle results) {
+ private void reportError(String appName, String processName) {
ActivityManager am = (ActivityManager) getInstrumentation()
.getContext().getSystemService(Context.ACTIVITY_SERVICE);
List<ProcessErrorStateInfo> crashes = am.getProcessesInErrorState();
@@ -186,12 +242,12 @@
continue;
Log.w(TAG, appName + " crashed: " + crash.shortMsg);
- results.putString(mNameToResultKey.get(appName), crash.shortMsg);
+ mResult.putString(mNameToResultKey.get(appName), crash.shortMsg);
return;
}
}
- results.putString(mNameToResultKey.get(appName),
+ mResult.putString(mNameToResultKey.get(appName),
"Crashed for unknown reason");
Log.w(TAG, appName
+ " not found in process list, most likely it is crashed");
@@ -200,8 +256,11 @@
private class AppLaunchRunnable implements Runnable {
private Intent mLaunchIntent;
private IActivityManager.WaitResult mResult;
- public AppLaunchRunnable(Intent intent) {
+ private boolean mForceStopBeforeLaunch;
+
+ public AppLaunchRunnable(Intent intent, boolean forceStopBeforeLaunch) {
mLaunchIntent = intent;
+ mForceStopBeforeLaunch = forceStopBeforeLaunch;
}
public IActivityManager.WaitResult getResult() {
@@ -211,7 +270,9 @@
public void run() {
try {
String packageName = mLaunchIntent.getComponent().getPackageName();
- mAm.forceStopPackage(packageName, UserHandle.USER_CURRENT);
+ if (mForceStopBeforeLaunch) {
+ mAm.forceStopPackage(packageName, UserHandle.USER_CURRENT);
+ }
String mimeType = mLaunchIntent.getType();
if (mimeType == null && mLaunchIntent.getData() != null
&& "content".equals(mLaunchIntent.getData().getScheme())) {
diff --git a/wifi/java/android/net/wifi/IWifiManager.aidl b/wifi/java/android/net/wifi/IWifiManager.aidl
index bef5824..e0684fb 100644
--- a/wifi/java/android/net/wifi/IWifiManager.aidl
+++ b/wifi/java/android/net/wifi/IWifiManager.aidl
@@ -71,6 +71,10 @@
DhcpInfo getDhcpInfo();
+ boolean isScanningAlwaysAvailable();
+
+ void setScanningAlwaysAvailable(boolean enable);
+
boolean acquireWifiLock(IBinder lock, int lockType, String tag, in WorkSource ws);
void updateWifiLockWorkSource(IBinder lock, in WorkSource ws);
diff --git a/wifi/java/android/net/wifi/WifiConfigStore.java b/wifi/java/android/net/wifi/WifiConfigStore.java
index eb2f74c..2385c24 100644
--- a/wifi/java/android/net/wifi/WifiConfigStore.java
+++ b/wifi/java/android/net/wifi/WifiConfigStore.java
@@ -395,6 +395,23 @@
return ret;
}
+ void disableAllNetworks() {
+ boolean networkDisabled = false;
+ for(WifiConfiguration config : mConfiguredNetworks.values()) {
+ if(config != null && config.status != Status.DISABLED) {
+ if(mWifiNative.disableNetwork(config.networkId)) {
+ networkDisabled = true;
+ config.status = Status.DISABLED;
+ } else {
+ loge("Disable network failed on " + config.networkId);
+ }
+ }
+ }
+
+ if (networkDisabled) {
+ sendConfiguredNetworksChangedBroadcast();
+ }
+ }
/**
* Disable a network. Note that there is no saveConfig operation.
* @param netId network to be disabled
diff --git a/wifi/java/android/net/wifi/WifiStateMachine.java b/wifi/java/android/net/wifi/WifiStateMachine.java
index ed5d22c..8cdfe03 100644
--- a/wifi/java/android/net/wifi/WifiStateMachine.java
+++ b/wifi/java/android/net/wifi/WifiStateMachine.java
@@ -134,7 +134,12 @@
private boolean mEnableBackgroundScan = false;
private int mRssiPollToken = 0;
private int mReconnectCount = 0;
- private boolean mIsScanMode = false;
+ /* 3 operational states for STA operation: CONNECT_MODE, SCAN_ONLY_MODE, SCAN_ONLY_WIFI_OFF_MODE
+ * In CONNECT_MODE, the STA can scan and connect to an access point
+ * In SCAN_ONLY_MODE, the STA can only scan for access points
+ * In SCAN_ONLY_WIFI_OFF_MODE, the STA can only scan for access points with wifi toggle being off
+ */
+ private int mOperationalMode = CONNECT_MODE;
private boolean mScanResultIsPending = false;
/* Tracks if state machine has received any screen state change broadcast yet.
* We can miss one of these at boot.
@@ -285,8 +290,8 @@
/* Supplicant commands after driver start*/
/* Initiate a scan */
static final int CMD_START_SCAN = BASE + 71;
- /* Set scan mode. CONNECT_MODE or SCAN_ONLY_MODE */
- static final int CMD_SET_SCAN_MODE = BASE + 72;
+ /* Set operational mode. CONNECT, SCAN ONLY, SCAN_ONLY with Wi-Fi off mode */
+ static final int CMD_SET_OPERATIONAL_MODE = BASE + 72;
/* Disconnect from a network */
static final int CMD_DISCONNECT = BASE + 73;
/* Reconnect to a network */
@@ -342,16 +347,13 @@
public static final int CMD_DISABLE_P2P_REQ = BASE + 132;
public static final int CMD_DISABLE_P2P_RSP = BASE + 133;
- private static final int CONNECT_MODE = 1;
- private static final int SCAN_ONLY_MODE = 2;
+ public static final int CONNECT_MODE = 1;
+ public static final int SCAN_ONLY_MODE = 2;
+ public static final int SCAN_ONLY_WITH_WIFI_OFF_MODE = 3;
private static final int SUCCESS = 1;
private static final int FAILURE = -1;
- /* Phone in emergency call back mode */
- private static final int IN_ECM_STATE = 1;
- private static final int NOT_IN_ECM_STATE = 0;
-
/**
* The maximum number of times we will retry a connection to an access point
* for which we have failed in acquiring an IP address from DHCP. A value of
@@ -496,9 +498,6 @@
*/
private final AtomicInteger mWifiApState = new AtomicInteger(WIFI_AP_STATE_DISABLED);
- private final AtomicInteger mLastEnableUid = new AtomicInteger(Process.myUid());
- private final AtomicInteger mLastApEnableUid = new AtomicInteger(Process.myUid());
-
private static final int SCAN_REQUEST = 0;
private static final String ACTION_START_SCAN =
"com.android.server.WifiManager.action.START_SCAN";
@@ -623,7 +622,7 @@
@Override
public void onReceive(Context context, Intent intent) {
int counter = intent.getIntExtra(DELAYED_STOP_COUNTER, 0);
- sendMessage(obtainMessage(CMD_DELAYED_STOP_DRIVER, counter, 0));
+ sendMessage(CMD_DELAYED_STOP_DRIVER, counter, 0);
}
},
new IntentFilter(ACTION_DELAYED_DRIVER_STOP));
@@ -714,8 +713,7 @@
/**
* TODO: doc
*/
- public void setWifiEnabled(boolean enable) {
- mLastEnableUid.set(Binder.getCallingUid());
+ public void setSupplicantRunning(boolean enable) {
if (enable) {
sendMessage(CMD_START_SUPPLICANT);
} else {
@@ -726,10 +724,9 @@
/**
* TODO: doc
*/
- public void setWifiApEnabled(WifiConfiguration wifiConfig, boolean enable) {
- mLastApEnableUid.set(Binder.getCallingUid());
+ public void setHostApRunning(WifiConfiguration wifiConfig, boolean enable) {
if (enable) {
- sendMessage(obtainMessage(CMD_START_AP, wifiConfig));
+ sendMessage(CMD_START_AP, wifiConfig);
} else {
sendMessage(CMD_STOP_AP);
}
@@ -818,27 +815,23 @@
/**
* TODO: doc
*/
- public void setDriverStart(boolean enable, boolean ecm) {
+ public void setDriverStart(boolean enable) {
if (enable) {
sendMessage(CMD_START_DRIVER);
} else {
- sendMessage(obtainMessage(CMD_STOP_DRIVER, ecm ? IN_ECM_STATE : NOT_IN_ECM_STATE, 0));
+ sendMessage(CMD_STOP_DRIVER);
}
}
public void captivePortalCheckComplete() {
- sendMessage(obtainMessage(CMD_CAPTIVE_CHECK_COMPLETE));
+ sendMessage(CMD_CAPTIVE_CHECK_COMPLETE);
}
/**
* TODO: doc
*/
- public void setScanOnlyMode(boolean enable) {
- if (enable) {
- sendMessage(obtainMessage(CMD_SET_SCAN_MODE, SCAN_ONLY_MODE, 0));
- } else {
- sendMessage(obtainMessage(CMD_SET_SCAN_MODE, CONNECT_MODE, 0));
- }
+ public void setOperationalMode(int mode) {
+ sendMessage(CMD_SET_OPERATIONAL_MODE, mode, 0);
}
/**
@@ -941,7 +934,7 @@
* @param bssid BSSID of the network
*/
public void addToBlacklist(String bssid) {
- sendMessage(obtainMessage(CMD_BLACKLIST_NETWORK, bssid));
+ sendMessage(CMD_BLACKLIST_NETWORK, bssid);
}
/**
@@ -949,15 +942,15 @@
*
*/
public void clearBlacklist() {
- sendMessage(obtainMessage(CMD_CLEAR_BLACKLIST));
+ sendMessage(CMD_CLEAR_BLACKLIST);
}
public void enableRssiPolling(boolean enabled) {
- sendMessage(obtainMessage(CMD_ENABLE_RSSI_POLL, enabled ? 1 : 0, 0));
+ sendMessage(CMD_ENABLE_RSSI_POLL, enabled ? 1 : 0, 0);
}
public void enableBackgroundScanCommand(boolean enabled) {
- sendMessage(obtainMessage(CMD_ENABLE_BACKGROUND_SCAN, enabled ? 1 : 0, 0));
+ sendMessage(CMD_ENABLE_BACKGROUND_SCAN, enabled ? 1 : 0, 0);
}
public void enableAllNetworks() {
@@ -969,7 +962,7 @@
*/
public void startFilteringMulticastV4Packets() {
mFilteringMulticastV4Packets.set(true);
- sendMessage(obtainMessage(CMD_START_PACKET_FILTERING, MULTICAST_V4, 0));
+ sendMessage(CMD_START_PACKET_FILTERING, MULTICAST_V4, 0);
}
/**
@@ -977,21 +970,21 @@
*/
public void stopFilteringMulticastV4Packets() {
mFilteringMulticastV4Packets.set(false);
- sendMessage(obtainMessage(CMD_STOP_PACKET_FILTERING, MULTICAST_V4, 0));
+ sendMessage(CMD_STOP_PACKET_FILTERING, MULTICAST_V4, 0);
}
/**
* Start filtering Multicast v4 packets
*/
public void startFilteringMulticastV6Packets() {
- sendMessage(obtainMessage(CMD_START_PACKET_FILTERING, MULTICAST_V6, 0));
+ sendMessage(CMD_START_PACKET_FILTERING, MULTICAST_V6, 0);
}
/**
* Stop filtering Multicast v4 packets
*/
public void stopFilteringMulticastV6Packets() {
- sendMessage(obtainMessage(CMD_STOP_PACKET_FILTERING, MULTICAST_V6, 0));
+ sendMessage(CMD_STOP_PACKET_FILTERING, MULTICAST_V6, 0);
}
/**
@@ -1001,7 +994,7 @@
* @param enable true if enable, false otherwise
*/
public void setHighPerfModeEnabled(boolean enable) {
- sendMessage(obtainMessage(CMD_SET_HIGH_PERF_MODE, enable ? 1 : 0, 0));
+ sendMessage(CMD_SET_HIGH_PERF_MODE, enable ? 1 : 0, 0);
}
/**
@@ -1015,7 +1008,7 @@
Settings.Global.WIFI_COUNTRY_CODE,
countryCode);
}
- sendMessage(obtainMessage(CMD_SET_COUNTRY_CODE, countryCode));
+ sendMessage(CMD_SET_COUNTRY_CODE, countryCode);
}
/**
@@ -1029,7 +1022,7 @@
Settings.Global.WIFI_FREQUENCY_BAND,
band);
}
- sendMessage(obtainMessage(CMD_SET_FREQUENCY_BAND, band, 0));
+ sendMessage(CMD_SET_FREQUENCY_BAND, band, 0);
}
/**
@@ -1050,7 +1043,7 @@
* Send a message indicating bluetooth adapter connection state changed
*/
public void sendBluetoothAdapterStateChange(int state) {
- sendMessage(obtainMessage(CMD_BLUETOOTH_ADAPTER_STATE_CHANGE, state, 0));
+ sendMessage(CMD_BLUETOOTH_ADAPTER_STATE_CHANGE, state, 0);
}
/**
@@ -1114,7 +1107,7 @@
pw.println("mLastBssid " + mLastBssid);
pw.println("mLastNetworkId " + mLastNetworkId);
pw.println("mReconnectCount " + mReconnectCount);
- pw.println("mIsScanMode " + mIsScanMode);
+ pw.println("mOperationalMode " + mOperationalMode);
pw.println("mUserWantsSuspendOpt " + mUserWantsSuspendOpt);
pw.println("mSuspendOptNeedsDisabled " + mSuspendOptNeedsDisabled);
pw.println("Supplicant status " + mWifiNative.status());
@@ -1136,11 +1129,11 @@
if (screenOn) enableAllNetworks();
if (mUserWantsSuspendOpt.get()) {
if (screenOn) {
- sendMessage(obtainMessage(CMD_SET_SUSPEND_OPT_ENABLED, 0, 0));
+ sendMessage(CMD_SET_SUSPEND_OPT_ENABLED, 0, 0);
} else {
//Allow 2s for suspend optimizations to be set
mSuspendWakeLock.acquire(2000);
- sendMessage(obtainMessage(CMD_SET_SUSPEND_OPT_ENABLED, 1, 0));
+ sendMessage(CMD_SET_SUSPEND_OPT_ENABLED, 1, 0);
}
}
mScreenBroadcastReceived.set(true);
@@ -1914,7 +1907,7 @@
case WifiMonitor.WPS_OVERLAP_EVENT:
case CMD_BLACKLIST_NETWORK:
case CMD_CLEAR_BLACKLIST:
- case CMD_SET_SCAN_MODE:
+ case CMD_SET_OPERATIONAL_MODE:
case CMD_SET_COUNTRY_CODE:
case CMD_SET_FREQUENCY_BAND:
case CMD_RSSI_POLL:
@@ -1929,6 +1922,7 @@
case WifiWatchdogStateMachine.POOR_LINK_DETECTED:
case WifiWatchdogStateMachine.GOOD_LINK_DETECTED:
case CMD_NO_NETWORKS_PERIODIC_SCAN:
+ case CMD_DISABLE_P2P_RSP:
break;
case DhcpStateMachine.CMD_ON_QUIT:
mDhcpStateMachine = null;
@@ -1942,8 +1936,8 @@
}
break;
case WifiMonitor.DRIVER_HUNG_EVENT:
- setWifiEnabled(false);
- setWifiEnabled(true);
+ setSupplicantRunning(false);
+ setSupplicantRunning(true);
break;
case WifiManager.CONNECT_NETWORK:
replyToMessage(message, WifiManager.CONNECT_NETWORK_FAILED,
@@ -2143,7 +2137,7 @@
case CMD_STOP_AP:
case CMD_START_DRIVER:
case CMD_STOP_DRIVER:
- case CMD_SET_SCAN_MODE:
+ case CMD_SET_OPERATIONAL_MODE:
case CMD_SET_COUNTRY_CODE:
case CMD_SET_FREQUENCY_BAND:
case CMD_START_PACKET_FILTERING:
@@ -2160,8 +2154,6 @@
class SupplicantStartedState extends State {
@Override
public void enter() {
- /* Initialize for connect mode operation at start */
- mIsScanMode = false;
/* Wifi is available as long as we have a connection to supplicant */
mNetworkInfo.setIsAvailable(true);
@@ -2176,7 +2168,6 @@
}
@Override
public boolean processMessage(Message message) {
- WifiConfiguration config;
switch(message.what) {
case CMD_STOP_SUPPLICANT: /* Supplicant stopped by user */
if (mP2pSupported) {
@@ -2206,87 +2197,13 @@
boolean ok = mWifiNative.ping();
replyToMessage(message, message.what, ok ? SUCCESS : FAILURE);
break;
- case CMD_ADD_OR_UPDATE_NETWORK:
- config = (WifiConfiguration) message.obj;
- replyToMessage(message, CMD_ADD_OR_UPDATE_NETWORK,
- mWifiConfigStore.addOrUpdateNetwork(config));
- break;
- case CMD_REMOVE_NETWORK:
- ok = mWifiConfigStore.removeNetwork(message.arg1);
- replyToMessage(message, message.what, ok ? SUCCESS : FAILURE);
- break;
- case CMD_ENABLE_NETWORK:
- ok = mWifiConfigStore.enableNetwork(message.arg1, message.arg2 == 1);
- replyToMessage(message, message.what, ok ? SUCCESS : FAILURE);
- break;
- case CMD_ENABLE_ALL_NETWORKS:
- long time = android.os.SystemClock.elapsedRealtime();
- if (time - mLastEnableAllNetworksTime > MIN_INTERVAL_ENABLE_ALL_NETWORKS_MS) {
- mWifiConfigStore.enableAllNetworks();
- mLastEnableAllNetworksTime = time;
- }
- break;
- case WifiManager.DISABLE_NETWORK:
- if (mWifiConfigStore.disableNetwork(message.arg1,
- WifiConfiguration.DISABLED_UNKNOWN_REASON) == true) {
- replyToMessage(message, WifiManager.DISABLE_NETWORK_SUCCEEDED);
- } else {
- replyToMessage(message, WifiManager.DISABLE_NETWORK_FAILED,
- WifiManager.ERROR);
- }
- break;
- case CMD_BLACKLIST_NETWORK:
- mWifiNative.addToBlacklist((String)message.obj);
- break;
- case CMD_CLEAR_BLACKLIST:
- mWifiNative.clearBlacklist();
- break;
- case CMD_SAVE_CONFIG:
- ok = mWifiConfigStore.saveConfig();
- replyToMessage(message, CMD_SAVE_CONFIG, ok ? SUCCESS : FAILURE);
-
- // Inform the backup manager about a data change
- IBackupManager ibm = IBackupManager.Stub.asInterface(
- ServiceManager.getService(Context.BACKUP_SERVICE));
- if (ibm != null) {
- try {
- ibm.dataChanged("com.android.providers.settings");
- } catch (Exception e) {
- // Try again later
- }
- }
- break;
- case CMD_GET_CONFIGURED_NETWORKS:
- replyToMessage(message, message.what,
- mWifiConfigStore.getConfiguredNetworks());
- break;
/* Cannot start soft AP while in client mode */
case CMD_START_AP:
loge("Failed to start soft AP with a running supplicant");
setWifiApState(WIFI_AP_STATE_FAILED);
break;
- case CMD_SET_SCAN_MODE:
- mIsScanMode = (message.arg1 == SCAN_ONLY_MODE);
- break;
- case WifiManager.SAVE_NETWORK:
- config = (WifiConfiguration) message.obj;
- NetworkUpdateResult result = mWifiConfigStore.saveNetwork(config);
- if (result.getNetworkId() != WifiConfiguration.INVALID_NETWORK_ID) {
- replyToMessage(message, WifiManager.SAVE_NETWORK_SUCCEEDED);
- } else {
- loge("Failed to save network");
- replyToMessage(message, WifiManager.SAVE_NETWORK_FAILED,
- WifiManager.ERROR);
- }
- break;
- case WifiManager.FORGET_NETWORK:
- if (mWifiConfigStore.forgetNetwork(message.arg1)) {
- replyToMessage(message, WifiManager.FORGET_NETWORK_SUCCEEDED);
- } else {
- loge("Failed to forget network");
- replyToMessage(message, WifiManager.FORGET_NETWORK_FAILED,
- WifiManager.ERROR);
- }
+ case CMD_SET_OPERATIONAL_MODE:
+ mOperationalMode = message.arg1;
break;
default:
return NOT_HANDLED;
@@ -2344,7 +2261,7 @@
case CMD_STOP_AP:
case CMD_START_DRIVER:
case CMD_STOP_DRIVER:
- case CMD_SET_SCAN_MODE:
+ case CMD_SET_OPERATIONAL_MODE:
case CMD_SET_COUNTRY_CODE:
case CMD_SET_FREQUENCY_BAND:
case CMD_START_PACKET_FILTERING:
@@ -2452,7 +2369,7 @@
mWifiNative.stopFilteringMulticastV4Packets();
}
- if (mIsScanMode) {
+ if (mOperationalMode != CONNECT_MODE) {
mWifiNative.disconnect();
transitionTo(mScanModeState);
} else {
@@ -2510,8 +2427,8 @@
case CMD_STOP_DRIVER:
int mode = message.arg1;
- /* Already doing a delayed stop && not in ecm state */
- if (mInDelayedStop && mode != IN_ECM_STATE) {
+ /* Already doing a delayed stop */
+ if (mInDelayedStop) {
if (DBG) log("Already in delayed stop");
break;
}
@@ -2519,20 +2436,15 @@
mDelayedStopCounter++;
if (DBG) log("Delayed stop message " + mDelayedStopCounter);
- if (mode == IN_ECM_STATE) {
- /* send a shut down immediately */
- sendMessage(obtainMessage(CMD_DELAYED_STOP_DRIVER, mDelayedStopCounter, 0));
- } else {
- /* send regular delayed shut down */
- Intent driverStopIntent = new Intent(ACTION_DELAYED_DRIVER_STOP, null);
- driverStopIntent.putExtra(DELAYED_STOP_COUNTER, mDelayedStopCounter);
- mDriverStopIntent = PendingIntent.getBroadcast(mContext,
- DRIVER_STOP_REQUEST, driverStopIntent,
- PendingIntent.FLAG_UPDATE_CURRENT);
+ /* send regular delayed shut down */
+ Intent driverStopIntent = new Intent(ACTION_DELAYED_DRIVER_STOP, null);
+ driverStopIntent.putExtra(DELAYED_STOP_COUNTER, mDelayedStopCounter);
+ mDriverStopIntent = PendingIntent.getBroadcast(mContext,
+ DRIVER_STOP_REQUEST, driverStopIntent,
+ PendingIntent.FLAG_UPDATE_CURRENT);
- mAlarmManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis()
- + mDriverStopDelayMs, mDriverStopIntent);
- }
+ mAlarmManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis()
+ + mDriverStopDelayMs, mDriverStopIntent);
break;
case CMD_START_DRIVER:
if (mInDelayedStop) {
@@ -2638,7 +2550,7 @@
case CMD_STOP_AP:
case CMD_START_DRIVER:
case CMD_STOP_DRIVER:
- case CMD_SET_SCAN_MODE:
+ case CMD_SET_OPERATIONAL_MODE:
case CMD_SET_COUNTRY_CODE:
case CMD_SET_FREQUENCY_BAND:
case CMD_START_PACKET_FILTERING:
@@ -2713,30 +2625,42 @@
}
class ScanModeState extends State {
+ private int mLastOperationMode;
+ @Override
+ public void enter() {
+ mWifiConfigStore.disableAllNetworks();
+ mLastOperationMode = mOperationalMode;
+ if (mLastOperationMode == SCAN_ONLY_WITH_WIFI_OFF_MODE) {
+ mWifiP2pChannel.sendMessage(CMD_DISABLE_P2P_REQ);
+ setWifiState(WIFI_STATE_DISABLED);
+ }
+ }
+ @Override
+ public void exit() {
+ if (mLastOperationMode == SCAN_ONLY_WITH_WIFI_OFF_MODE) {
+ setWifiState(WIFI_STATE_ENABLED);
+ mWifiP2pChannel.sendMessage(CMD_ENABLE_P2P);
+ }
+ mWifiConfigStore.enableAllNetworks();
+ mWifiNative.reconnect();
+ }
@Override
public boolean processMessage(Message message) {
switch(message.what) {
- case CMD_SET_SCAN_MODE:
- if (message.arg1 == SCAN_ONLY_MODE) {
- /* Ignore */
- return HANDLED;
- } else {
- mWifiNative.reconnect();
- mIsScanMode = false;
+ case CMD_SET_OPERATIONAL_MODE:
+ if (message.arg1 == CONNECT_MODE) {
+ mOperationalMode = CONNECT_MODE;
transitionTo(mDisconnectedState);
+ } else {
+ // Nothing to do
+ return HANDLED;
}
break;
+ // Handle scan. All the connection related commands are
+ // handled only in ConnectModeState
case CMD_START_SCAN:
startScanNative(WifiNative.SCAN_WITHOUT_CONNECTION_SETUP);
break;
- /* Ignore */
- case CMD_DISCONNECT:
- case CMD_RECONNECT:
- case CMD_REASSOCIATE:
- case WifiMonitor.SUPPLICANT_STATE_CHANGE_EVENT:
- case WifiMonitor.NETWORK_CONNECTION_EVENT:
- case WifiMonitor.NETWORK_DISCONNECTION_EVENT:
- break;
default:
return NOT_HANDLED;
}
@@ -2747,7 +2671,8 @@
class ConnectModeState extends State {
@Override
public boolean processMessage(Message message) {
- StateChangeResult stateChangeResult;
+ WifiConfiguration config;
+ boolean ok;
switch(message.what) {
case WifiMonitor.AUTHENTICATION_FAILURE_EVENT:
mSupplicantStateTracker.sendMessage(WifiMonitor.AUTHENTICATION_FAILURE_EVENT);
@@ -2787,6 +2712,60 @@
mTemporarilyDisconnectWifi = false;
}
break;
+ case CMD_ADD_OR_UPDATE_NETWORK:
+ config = (WifiConfiguration) message.obj;
+ replyToMessage(message, CMD_ADD_OR_UPDATE_NETWORK,
+ mWifiConfigStore.addOrUpdateNetwork(config));
+ break;
+ case CMD_REMOVE_NETWORK:
+ ok = mWifiConfigStore.removeNetwork(message.arg1);
+ replyToMessage(message, message.what, ok ? SUCCESS : FAILURE);
+ break;
+ case CMD_ENABLE_NETWORK:
+ ok = mWifiConfigStore.enableNetwork(message.arg1, message.arg2 == 1);
+ replyToMessage(message, message.what, ok ? SUCCESS : FAILURE);
+ break;
+ case CMD_ENABLE_ALL_NETWORKS:
+ long time = android.os.SystemClock.elapsedRealtime();
+ if (time - mLastEnableAllNetworksTime > MIN_INTERVAL_ENABLE_ALL_NETWORKS_MS) {
+ mWifiConfigStore.enableAllNetworks();
+ mLastEnableAllNetworksTime = time;
+ }
+ break;
+ case WifiManager.DISABLE_NETWORK:
+ if (mWifiConfigStore.disableNetwork(message.arg1,
+ WifiConfiguration.DISABLED_UNKNOWN_REASON) == true) {
+ replyToMessage(message, WifiManager.DISABLE_NETWORK_SUCCEEDED);
+ } else {
+ replyToMessage(message, WifiManager.DISABLE_NETWORK_FAILED,
+ WifiManager.ERROR);
+ }
+ break;
+ case CMD_BLACKLIST_NETWORK:
+ mWifiNative.addToBlacklist((String)message.obj);
+ break;
+ case CMD_CLEAR_BLACKLIST:
+ mWifiNative.clearBlacklist();
+ break;
+ case CMD_SAVE_CONFIG:
+ ok = mWifiConfigStore.saveConfig();
+ replyToMessage(message, CMD_SAVE_CONFIG, ok ? SUCCESS : FAILURE);
+
+ // Inform the backup manager about a data change
+ IBackupManager ibm = IBackupManager.Stub.asInterface(
+ ServiceManager.getService(Context.BACKUP_SERVICE));
+ if (ibm != null) {
+ try {
+ ibm.dataChanged("com.android.providers.settings");
+ } catch (Exception e) {
+ // Try again later
+ }
+ }
+ break;
+ case CMD_GET_CONFIGURED_NETWORKS:
+ replyToMessage(message, message.what,
+ mWifiConfigStore.getConfiguredNetworks());
+ break;
/* Do a redundant disconnect without transition */
case CMD_DISCONNECT:
mWifiNative.disconnect();
@@ -2804,7 +2783,7 @@
* For an existing network, a network id is passed
*/
int netId = message.arg1;
- WifiConfiguration config = (WifiConfiguration) message.obj;
+ config = (WifiConfiguration) message.obj;
/* Save the network config */
if (config != null) {
@@ -2826,26 +2805,46 @@
break;
}
break;
+ case WifiManager.SAVE_NETWORK:
+ config = (WifiConfiguration) message.obj;
+ NetworkUpdateResult result = mWifiConfigStore.saveNetwork(config);
+ if (result.getNetworkId() != WifiConfiguration.INVALID_NETWORK_ID) {
+ replyToMessage(message, WifiManager.SAVE_NETWORK_SUCCEEDED);
+ } else {
+ loge("Failed to save network");
+ replyToMessage(message, WifiManager.SAVE_NETWORK_FAILED,
+ WifiManager.ERROR);
+ }
+ break;
+ case WifiManager.FORGET_NETWORK:
+ if (mWifiConfigStore.forgetNetwork(message.arg1)) {
+ replyToMessage(message, WifiManager.FORGET_NETWORK_SUCCEEDED);
+ } else {
+ loge("Failed to forget network");
+ replyToMessage(message, WifiManager.FORGET_NETWORK_FAILED,
+ WifiManager.ERROR);
+ }
+ break;
case WifiManager.START_WPS:
WpsInfo wpsInfo = (WpsInfo) message.obj;
- WpsResult result;
+ WpsResult wpsResult;
switch (wpsInfo.setup) {
case WpsInfo.PBC:
- result = mWifiConfigStore.startWpsPbc(wpsInfo);
+ wpsResult = mWifiConfigStore.startWpsPbc(wpsInfo);
break;
case WpsInfo.KEYPAD:
- result = mWifiConfigStore.startWpsWithPinFromAccessPoint(wpsInfo);
+ wpsResult = mWifiConfigStore.startWpsWithPinFromAccessPoint(wpsInfo);
break;
case WpsInfo.DISPLAY:
- result = mWifiConfigStore.startWpsWithPinFromDevice(wpsInfo);
+ wpsResult = mWifiConfigStore.startWpsWithPinFromDevice(wpsInfo);
break;
default:
- result = new WpsResult(Status.FAILURE);
+ wpsResult = new WpsResult(Status.FAILURE);
loge("Invalid setup for WPS");
break;
}
- if (result.status == Status.SUCCESS) {
- replyToMessage(message, WifiManager.START_WPS_SUCCEEDED, result);
+ if (wpsResult.status == Status.SUCCESS) {
+ replyToMessage(message, WifiManager.START_WPS_SUCCEEDED, wpsResult);
transitionTo(mWpsRunningState);
} else {
loge("Failed to start WPS with config " + wpsInfo.toString());
@@ -2881,7 +2880,7 @@
public void enter() {
mRssiPollToken++;
if (mEnableRssiPolling) {
- sendMessage(obtainMessage(CMD_RSSI_POLL, mRssiPollToken, 0));
+ sendMessage(CMD_RSSI_POLL, mRssiPollToken, 0);
}
}
@@ -2915,8 +2914,8 @@
transitionTo(mDisconnectingState);
}
break;
- case CMD_SET_SCAN_MODE:
- if (message.arg1 == SCAN_ONLY_MODE) {
+ case CMD_SET_OPERATIONAL_MODE:
+ if (message.arg1 != CONNECT_MODE) {
sendMessage(CMD_DISCONNECT);
deferMessage(message);
}
@@ -3152,8 +3151,8 @@
@Override
public boolean processMessage(Message message) {
switch (message.what) {
- case CMD_SET_SCAN_MODE:
- if (message.arg1 == SCAN_ONLY_MODE) {
+ case CMD_SET_OPERATIONAL_MODE:
+ if (message.arg1 != CONNECT_MODE) {
deferMessage(message);
}
break;
@@ -3259,11 +3258,9 @@
++mPeriodicScanToken, 0), mSupplicantScanIntervalMs);
ret = NOT_HANDLED;
break;
- case CMD_SET_SCAN_MODE:
- if (message.arg1 == SCAN_ONLY_MODE) {
- //Supplicant disconnect to prevent further connects
- mWifiNative.disconnect();
- mIsScanMode = true;
+ case CMD_SET_OPERATIONAL_MODE:
+ if (message.arg1 != CONNECT_MODE) {
+ mOperationalMode = message.arg1;
transitionTo(mScanModeState);
}
break;
@@ -3396,7 +3393,7 @@
* or put the state machine out of connect mode
*/
case CMD_STOP_DRIVER:
- case CMD_SET_SCAN_MODE:
+ case CMD_SET_OPERATIONAL_MODE:
case WifiManager.CONNECT_NETWORK:
case CMD_ENABLE_NETWORK:
case CMD_RECONNECT:
@@ -3459,7 +3456,7 @@
case CMD_STOP_AP:
case CMD_START_DRIVER:
case CMD_STOP_DRIVER:
- case CMD_SET_SCAN_MODE:
+ case CMD_SET_OPERATIONAL_MODE:
case CMD_SET_COUNTRY_CODE:
case CMD_SET_FREQUENCY_BAND:
case CMD_START_PACKET_FILTERING:
@@ -3547,7 +3544,8 @@
if (message.arg1 == mTetherToken) {
loge("Failed to get tether update, shutdown soft access point");
transitionTo(mSoftApStartedState);
- sendMessage(CMD_STOP_AP);
+ // Needs to be first thing handled
+ sendMessageAtFrontOfQueue(CMD_STOP_AP);
}
break;
case CMD_START_SUPPLICANT:
@@ -3556,7 +3554,7 @@
case CMD_STOP_AP:
case CMD_START_DRIVER:
case CMD_STOP_DRIVER:
- case CMD_SET_SCAN_MODE:
+ case CMD_SET_OPERATIONAL_MODE:
case CMD_SET_COUNTRY_CODE:
case CMD_SET_FREQUENCY_BAND:
case CMD_START_PACKET_FILTERING:
@@ -3578,7 +3576,7 @@
TetherStateChange stateChange = (TetherStateChange) message.obj;
if (!isWifiTethered(stateChange.active)) {
loge("Tethering reports wifi as untethered!, shut down soft Ap");
- setWifiApEnabled(null, false);
+ setHostApRunning(null, false);
}
return HANDLED;
case CMD_STOP_AP:
@@ -3612,13 +3610,15 @@
if (isWifiTethered(stateChange.active)) break;
transitionTo(mSoftApStartedState);
- sendMessage(CMD_STOP_AP);
+ // Needs to be first thing handled
+ sendMessageAtFrontOfQueue(CMD_STOP_AP);
break;
case CMD_TETHER_NOTIFICATION_TIMED_OUT:
if (message.arg1 == mTetherToken) {
loge("Failed to get tether update, force stop access point");
transitionTo(mSoftApStartedState);
- sendMessage(CMD_STOP_AP);
+ // Needs to be first thing handled
+ sendMessageAtFrontOfQueue(CMD_STOP_AP);
}
break;
case CMD_START_SUPPLICANT:
@@ -3627,7 +3627,7 @@
case CMD_STOP_AP:
case CMD_START_DRIVER:
case CMD_STOP_DRIVER:
- case CMD_SET_SCAN_MODE:
+ case CMD_SET_OPERATIONAL_MODE:
case CMD_SET_COUNTRY_CODE:
case CMD_SET_FREQUENCY_BAND:
case CMD_START_PACKET_FILTERING:
diff --git a/wifi/java/android/net/wifi/WifiWatchdogStateMachine.java b/wifi/java/android/net/wifi/WifiWatchdogStateMachine.java
index 53e6b51..eb47a4a 100644
--- a/wifi/java/android/net/wifi/WifiWatchdogStateMachine.java
+++ b/wifi/java/android/net/wifi/WifiWatchdogStateMachine.java
@@ -587,8 +587,9 @@
break;
case EVENT_WIFI_RADIO_STATE_CHANGE:
- if ((Integer) msg.obj == WifiManager.WIFI_STATE_DISABLING)
+ if (msg.arg1 == WifiManager.WIFI_STATE_DISABLING) {
transitionTo(mNotConnectedState);
+ }
break;
default: