Merge "Fix multicast API" (d7a374f6) · Commits · e / os / android_frameworks_base

core/jni/android_net_wifi_Wifi.cpp

+46 −14

Original line number	Diff line number	Diff line
		@@ -315,26 +315,56 @@ static jboolean android_net_wifi_stopDriverCommand(JNIEnv* env, jobject)
		return doBooleanCommand("OK", "DRIVER STOP");
		}

		static jboolean android_net_wifi_startPacketFiltering(JNIEnv* env, jobject)
		/*
		Multicast filtering rules work as follows:

		The driver can filter multicast (v4 and/or v6) and broadcast packets when in
		a power optimized mode (typically when screen goes off).

		In order to prevent the driver from filtering the multicast/broadcast packets, we have to
		add a DRIVER RXFILTER-ADD rule followed by DRIVER RXFILTER-START to make the rule effective

		DRIVER RXFILTER-ADD Num
		where Num = 0 - Unicast, 1 - Broadcast, 2 - Mutil4 or 3 - Multi6

		and DRIVER RXFILTER-START

		In order to stop the usage of these rules, we do

		DRIVER RXFILTER-STOP
		DRIVER RXFILTER-REMOVE Num
		where Num is as described for RXFILTER-ADD

		The SETSUSPENDOPT driver command overrides the filtering rules
		*/

		static jboolean android_net_wifi_startMultiV4Filtering(JNIEnv* env, jobject)
		{
		return doBooleanCommand("OK", "DRIVER RXFILTER-ADD 0")
		&& doBooleanCommand("OK", "DRIVER RXFILTER-ADD 1")
		&& doBooleanCommand("OK", "DRIVER RXFILTER-ADD 3")
		return doBooleanCommand("OK", "DRIVER RXFILTER-STOP")
		&& doBooleanCommand("OK", "DRIVER RXFILTER-REMOVE 2")
		&& doBooleanCommand("OK", "DRIVER RXFILTER-START");
		}

		static jboolean android_net_wifi_stopPacketFiltering(JNIEnv* env, jobject)
		static jboolean android_net_wifi_stopMultiV4Filtering(JNIEnv* env, jobject)
		{
		jboolean result = doBooleanCommand("OK", "DRIVER RXFILTER-STOP");
		if (result) {
		(void)doBooleanCommand("OK", "DRIVER RXFILTER-REMOVE 3");
		(void)doBooleanCommand("OK", "DRIVER RXFILTER-REMOVE 1");
		(void)doBooleanCommand("OK", "DRIVER RXFILTER-REMOVE 0");
		return doBooleanCommand("OK", "DRIVER RXFILTER-ADD 2")
		&& doBooleanCommand("OK", "DRIVER RXFILTER-START");
		}

		return result;
		static jboolean android_net_wifi_startMultiV6Filtering(JNIEnv* env, jobject)
		{
		return doBooleanCommand("OK", "DRIVER RXFILTER-STOP")
		&& doBooleanCommand("OK", "DRIVER RXFILTER-REMOVE 3")
		&& doBooleanCommand("OK", "DRIVER RXFILTER-START");
		}

		static jboolean android_net_wifi_stopMultiV6Filtering(JNIEnv* env, jobject)
		{
		return doBooleanCommand("OK", "DRIVER RXFILTER-ADD 3")
		&& doBooleanCommand("OK", "DRIVER RXFILTER-START");
		}


		static jint android_net_wifi_getRssiHelper(const char *cmd)
		{
		char reply[BUF_SIZE];
		@@ -545,8 +575,10 @@ static JNINativeMethod gWifiMethods[] = {
		{ "setScanModeCommand", "(Z)Z", (void*) android_net_wifi_setScanModeCommand },
		{ "startDriverCommand", "()Z", (void*) android_net_wifi_startDriverCommand },
		{ "stopDriverCommand", "()Z", (void*) android_net_wifi_stopDriverCommand },
		{ "startPacketFiltering", "()Z", (void*) android_net_wifi_startPacketFiltering },
		{ "stopPacketFiltering", "()Z", (void*) android_net_wifi_stopPacketFiltering },
		{ "startFilteringMulticastV4Packets", "()Z", (void*) android_net_wifi_startMultiV4Filtering},
		{ "stopFilteringMulticastV4Packets", "()Z", (void*) android_net_wifi_stopMultiV4Filtering},
		{ "startFilteringMulticastV6Packets", "()Z", (void*) android_net_wifi_startMultiV6Filtering},
		{ "stopFilteringMulticastV6Packets", "()Z", (void*) android_net_wifi_stopMultiV6Filtering},
		{ "setPowerModeCommand", "(I)Z", (void*) android_net_wifi_setPowerModeCommand },
		{ "getPowerModeCommand", "()I", (void*) android_net_wifi_getPowerModeCommand },
		{ "setBandCommand", "(I)Z", (void*) android_net_wifi_setBandCommand},

services/java/com/android/server/WifiService.java

+4 −4

Original line number	Diff line number	Diff line
		@@ -1461,7 +1461,7 @@ public class WifiService extends IWifiManager.Stub {
		if (mMulticasters.size() != 0) {
		return;
		} else {
		mWifiStateMachine.startPacketFiltering();
		mWifiStateMachine.startFilteringMulticastV4Packets();
		}
		}
		}
		@@ -1472,11 +1472,11 @@ public class WifiService extends IWifiManager.Stub {
		synchronized (mMulticasters) {
		mMulticastEnabled++;
		mMulticasters.add(new Multicaster(tag, binder));
		// Note that we could call stopPacketFiltering only when
		// Note that we could call stopFilteringMulticastV4Packets only when
		// our new size == 1 (first call), but this function won't
		// be called often and by making the stopPacket call each
		// time we're less fragile and self-healing.
		mWifiStateMachine.stopPacketFiltering();
		mWifiStateMachine.stopFilteringMulticastV4Packets();
		}

		int uid = Binder.getCallingUid();
		@@ -1513,7 +1513,7 @@ public class WifiService extends IWifiManager.Stub {
		removed.unlinkDeathRecipient();
		}
		if (mMulticasters.size() == 0) {
		mWifiStateMachine.startPacketFiltering();
		mWifiStateMachine.startFilteringMulticastV4Packets();
		}

		Long ident = Binder.clearCallingIdentity();

wifi/java/android/net/wifi/WifiNative.java

+17 −5

Original line number	Diff line number	Diff line
		@@ -104,18 +104,30 @@ public class WifiNative {

		public native static boolean stopDriverCommand();


		/**
		* Start filtering out Multicast V4 packets
		* @return {@code true} if the operation succeeded, {@code false} otherwise
		*/
		public native static boolean startFilteringMulticastV4Packets();

		/**
		* Stop filtering out Multicast V4 packets.
		* @return {@code true} if the operation succeeded, {@code false} otherwise
		*/
		public native static boolean stopFilteringMulticastV4Packets();

		/**
		* Start filtering out multicast packets, to reduce battery consumption
		* that would result from processing them, only to discard them.
		* Start filtering out Multicast V6 packets
		* @return {@code true} if the operation succeeded, {@code false} otherwise
		*/
		public native static boolean startPacketFiltering();
		public native static boolean startFilteringMulticastV6Packets();

		/**
		* Stop filtering out multicast packets.
		* Stop filtering out Multicast V6 packets.
		* @return {@code true} if the operation succeeded, {@code false} otherwise
		*/
		public native static boolean stopPacketFiltering();
		public native static boolean stopFilteringMulticastV6Packets();

		public native static boolean setPowerModeCommand(int mode);

wifi/java/android/net/wifi/WifiStateMachine.java

+55 −11

Original line number	Diff line number	Diff line
		@@ -82,6 +82,7 @@ import java.net.InetAddress;
		import java.util.ArrayList;
		import java.util.List;
		import java.util.concurrent.atomic.AtomicInteger;
		import java.util.concurrent.atomic.AtomicBoolean;
		import java.util.regex.Pattern;

		/**
		@@ -160,6 +161,9 @@ public class WifiStateMachine extends StateMachine {
		/* Tracks current frequency mode */
		private AtomicInteger mFrequencyBand = new AtomicInteger(WifiManager.WIFI_FREQUENCY_BAND_AUTO);

		/* Tracks if we are filtering Multicast v4 packets. Default is to filter. */
		private AtomicBoolean mFilteringMulticastV4Packets = new AtomicBoolean(true);

		// Channel for sending replies.
		private AsyncChannel mReplyChannel = new AsyncChannel();

		@@ -285,6 +289,11 @@ public class WifiStateMachine extends StateMachine {
		static final int CMD_START_PACKET_FILTERING = BASE + 84;
		/* Clear packet filter */
		static final int CMD_STOP_PACKET_FILTERING = BASE + 85;

		/* arg1 values to CMD_STOP_PACKET_FILTERING and CMD_START_PACKET_FILTERING */
		static final int MULTICAST_V6 = 1;
		static final int MULTICAST_V4 = 0;

		/* Connect to a specified network (network id
		* or WifiConfiguration) This involves increasing
		* the priority of the network, enabling the network
		@@ -868,17 +877,33 @@ public class WifiStateMachine extends StateMachine {
		}

		/**
		* Start packet filtering
		* Start filtering Multicast v4 packets
		*/
		public void startFilteringMulticastV4Packets() {
		mFilteringMulticastV4Packets.set(true);
		sendMessage(obtainMessage(CMD_START_PACKET_FILTERING, MULTICAST_V4, 0));
		}

		/**
		* Stop filtering Multicast v4 packets
		*/
		public void stopFilteringMulticastV4Packets() {
		mFilteringMulticastV4Packets.set(false);
		sendMessage(obtainMessage(CMD_STOP_PACKET_FILTERING, MULTICAST_V4, 0));
		}

		/**
		* Start filtering Multicast v4 packets
		*/
		public void startPacketFiltering() {
		sendMessage(CMD_START_PACKET_FILTERING);
		public void startFilteringMulticastV6Packets() {
		sendMessage(obtainMessage(CMD_START_PACKET_FILTERING, MULTICAST_V6, 0));
		}

		/**
		* Stop packet filtering
		* Stop filtering Multicast v4 packets
		*/
		public void stopPacketFiltering() {
		sendMessage(CMD_STOP_PACKET_FILTERING);
		public void stopFilteringMulticastV6Packets() {
		sendMessage(obtainMessage(CMD_STOP_PACKET_FILTERING, MULTICAST_V6, 0));
		}

		/**
		@@ -2074,9 +2099,6 @@ public class WifiStateMachine extends StateMachine {

		WifiConfigStore.initialize(mContext);

		//TODO: initialize and fix multicast filtering
		//mWM.initializeMulticastFiltering();

		sendSupplicantConnectionChangedBroadcast(true);
		transitionTo(mDriverStartedState);
		break;
		@@ -2359,6 +2381,16 @@ public class WifiStateMachine extends StateMachine {
		/* initialize network state */
		setNetworkDetailedState(DetailedState.DISCONNECTED);

		/* Remove any filtering on Multicast v6 at start */
		WifiNative.stopFilteringMulticastV6Packets();

		/* Reset Multicast v4 filtering state */
		if (mFilteringMulticastV4Packets.get()) {
		WifiNative.startFilteringMulticastV4Packets();
		} else {
		WifiNative.stopFilteringMulticastV4Packets();
		}

		if (mIsScanMode) {
		WifiNative.setScanResultHandlingCommand(SCAN_ONLY_MODE);
		WifiNative.disconnectCommand();
		@@ -2419,10 +2451,22 @@ public class WifiStateMachine extends StateMachine {
		mWakeLock.release();
		break;
		case CMD_START_PACKET_FILTERING:
		WifiNative.startPacketFiltering();
		if (message.arg1 == MULTICAST_V6) {
		WifiNative.startFilteringMulticastV6Packets();
		} else if (message.arg1 == MULTICAST_V4) {
		WifiNative.startFilteringMulticastV4Packets();
		} else {
		Log.e(TAG, "Illegal arugments to CMD_START_PACKET_FILTERING");
		}
		break;
		case CMD_STOP_PACKET_FILTERING:
		WifiNative.stopPacketFiltering();
		if (message.arg1 == MULTICAST_V6) {
		WifiNative.stopFilteringMulticastV6Packets();
		} else if (message.arg1 == MULTICAST_V4) {
		WifiNative.stopFilteringMulticastV4Packets();
		} else {
		Log.e(TAG, "Illegal arugments to CMD_STOP_PACKET_FILTERING");
		}
		break;
		default:
		return NOT_HANDLED;