Revert "Move Wifi services to a new git project" (f1182c9c) · Commits · e / os / android_frameworks_base

core/jni/Android.mk

+1 −0

Original line number	Diff line number	Diff line
		@@ -75,6 +75,7 @@ LOCAL_SRC_FILES:= \
		android_net_LocalSocketImpl.cpp \
		android_net_NetUtils.cpp \
		android_net_TrafficStats.cpp \
		android_net_wifi_WifiNative.cpp \
		android_nio_utils.cpp \
		android_text_format_Time.cpp \
		android_util_AssetManager.cpp \

core/jni/AndroidRuntime.cpp

+2 −0

Original line number	Diff line number	Diff line
		@@ -148,6 +148,7 @@ extern int register_android_os_MemoryFile(JNIEnv* env);
		extern int register_android_net_LocalSocketImpl(JNIEnv* env);
		extern int register_android_net_NetworkUtils(JNIEnv* env);
		extern int register_android_net_TrafficStats(JNIEnv* env);
		extern int register_android_net_wifi_WifiNative(JNIEnv* env);
		extern int register_android_text_AndroidCharacter(JNIEnv *env);
		extern int register_android_text_AndroidBidi(JNIEnv *env);
		extern int register_android_opengl_classes(JNIEnv *env);
		@@ -1185,6 +1186,7 @@ static const RegJNIRec gRegJNI[] = {
		REG_JNI(register_android_net_LocalSocketImpl),
		REG_JNI(register_android_net_NetworkUtils),
		REG_JNI(register_android_net_TrafficStats),
		REG_JNI(register_android_net_wifi_WifiNative),
		REG_JNI(register_android_os_MemoryFile),
		REG_JNI(register_com_android_internal_os_ZygoteInit),
		REG_JNI(register_android_hardware_Camera),

core/jni/android_net_wifi_WifiNative.cpp

0 → 100644

+173 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2008, 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.
		*/

		#define LOG_TAG "wifi"

		#include "jni.h"
		#include <ScopedUtfChars.h>
		#include <utils/misc.h>
		#include <android_runtime/AndroidRuntime.h>
		#include <utils/Log.h>
		#include <utils/String16.h>

		#include "wifi.h"

		#define REPLY_BUF_SIZE 4096 // wpa_supplicant's maximum size.
		#define EVENT_BUF_SIZE 2048

		namespace android {

		static jint DBG = false;

		static bool doCommand(JNIEnv* env, jstring javaCommand,
		char* reply, size_t reply_len) {
		ScopedUtfChars command(env, javaCommand);
		if (command.c_str() == NULL) {
		return false; // ScopedUtfChars already threw on error.
		}

		if (DBG) {
		ALOGD("doCommand: %s", command.c_str());
		}

		--reply_len; // Ensure we have room to add NUL termination.
		if (::wifi_command(command.c_str(), reply, &reply_len) != 0) {
		return false;
		}

		// Strip off trailing newline.
		if (reply_len > 0 && reply[reply_len-1] == '\n') {
		reply[reply_len-1] = '\0';
		} else {
		reply[reply_len] = '\0';
		}
		return true;
		}

		static jint doIntCommand(JNIEnv* env, jstring javaCommand) {
		char reply[REPLY_BUF_SIZE];
		if (!doCommand(env, javaCommand, reply, sizeof(reply))) {
		return -1;
		}
		return static_cast<jint>(atoi(reply));
		}

		static jboolean doBooleanCommand(JNIEnv* env, jstring javaCommand) {
		char reply[REPLY_BUF_SIZE];
		if (!doCommand(env, javaCommand, reply, sizeof(reply))) {
		return JNI_FALSE;
		}
		return (strcmp(reply, "OK") == 0);
		}

		// Send a command to the supplicant, and return the reply as a String.
		static jstring doStringCommand(JNIEnv* env, jstring javaCommand) {
		char reply[REPLY_BUF_SIZE];
		if (!doCommand(env, javaCommand, reply, sizeof(reply))) {
		return NULL;
		}
		return env->NewStringUTF(reply);
		}

		static jboolean android_net_wifi_isDriverLoaded(JNIEnv* env, jobject)
		{
		return (::is_wifi_driver_loaded() == 1);
		}

		static jboolean android_net_wifi_loadDriver(JNIEnv* env, jobject)
		{
		return (::wifi_load_driver() == 0);
		}

		static jboolean android_net_wifi_unloadDriver(JNIEnv* env, jobject)
		{
		return (::wifi_unload_driver() == 0);
		}

		static jboolean android_net_wifi_startSupplicant(JNIEnv* env, jobject, jboolean p2pSupported)
		{
		return (::wifi_start_supplicant(p2pSupported) == 0);
		}

		static jboolean android_net_wifi_killSupplicant(JNIEnv* env, jobject, jboolean p2pSupported)
		{
		return (::wifi_stop_supplicant(p2pSupported) == 0);
		}

		static jboolean android_net_wifi_connectToSupplicant(JNIEnv* env, jobject)
		{
		return (::wifi_connect_to_supplicant() == 0);
		}

		static void android_net_wifi_closeSupplicantConnection(JNIEnv* env, jobject)
		{
		::wifi_close_supplicant_connection();
		}

		static jstring android_net_wifi_waitForEvent(JNIEnv* env, jobject)
		{
		char buf[EVENT_BUF_SIZE];
		int nread = ::wifi_wait_for_event(buf, sizeof buf);
		if (nread > 0) {
		return env->NewStringUTF(buf);
		} else {
		return NULL;
		}
		}

		static jboolean android_net_wifi_doBooleanCommand(JNIEnv* env, jobject, jstring javaCommand) {
		return doBooleanCommand(env, javaCommand);
		}

		static jint android_net_wifi_doIntCommand(JNIEnv* env, jobject, jstring javaCommand) {
		return doIntCommand(env, javaCommand);
		}

		static jstring android_net_wifi_doStringCommand(JNIEnv* env, jobject, jstring javaCommand) {
		return doStringCommand(env,javaCommand);
		}



		// ----------------------------------------------------------------------------

		/*
		* JNI registration.
		*/
		static JNINativeMethod gWifiMethods[] = {
		/* name, signature, funcPtr */

		{ "loadDriver", "()Z", (void *)android_net_wifi_loadDriver },
		{ "isDriverLoaded", "()Z", (void *)android_net_wifi_isDriverLoaded },
		{ "unloadDriver", "()Z", (void *)android_net_wifi_unloadDriver },
		{ "startSupplicant", "(Z)Z", (void *)android_net_wifi_startSupplicant },
		{ "killSupplicant", "(Z)Z", (void *)android_net_wifi_killSupplicant },
		{ "connectToSupplicantNative", "()Z", (void *)android_net_wifi_connectToSupplicant },
		{ "closeSupplicantConnectionNative", "()V",
		(void *)android_net_wifi_closeSupplicantConnection },
		{ "waitForEventNative", "()Ljava/lang/String;", (void*)android_net_wifi_waitForEvent },
		{ "doBooleanCommandNative", "(Ljava/lang/String;)Z", (void*)android_net_wifi_doBooleanCommand },
		{ "doIntCommandNative", "(Ljava/lang/String;)I", (void*)android_net_wifi_doIntCommand },
		{ "doStringCommandNative", "(Ljava/lang/String;)Ljava/lang/String;",
		(void*) android_net_wifi_doStringCommand },
		};

		int register_android_net_wifi_WifiNative(JNIEnv* env) {
		return AndroidRuntime::registerNativeMethods(env,
		"com/android/server/wifi/WifiNative", gWifiMethods, NELEM(gWifiMethods));
		}

		}; // namespace android

services/core/java/com/android/server/SystemServer.java

+13 −4

Original line number	Diff line number	Diff line
		@@ -77,6 +77,8 @@ import com.android.server.twilight.TwilightManager;
		import com.android.server.twilight.TwilightService;
		import com.android.server.usb.UsbService;
		import com.android.server.wallpaper.WallpaperManagerService;
		import com.android.server.wifi.WifiService;
		import com.android.server.wifi.p2p.WifiP2pService;
		import com.android.server.wm.WindowManagerService;

		import dalvik.system.VMRuntime;
		@@ -159,6 +161,8 @@ class ServerThread {
		NetworkStatsService networkStats = null;
		NetworkPolicyManagerService networkPolicy = null;
		ConnectivityService connectivity = null;
		WifiP2pService wifiP2p = null;
		WifiService wifi = null;
		NsdService serviceDiscovery= null;
		IPackageManager pm = null;
		Context context = null;
		@@ -511,14 +515,16 @@ class ServerThread {

		try {
		Slog.i(TAG, "Wi-Fi P2pService");
		systemServiceManager.startService("com.android.server.wifi.p2p.WifiP2pService");
		wifiP2p = new WifiP2pService(context);
		ServiceManager.addService(Context.WIFI_P2P_SERVICE, wifiP2p);
		} catch (Throwable e) {
		reportWtf("starting Wi-Fi P2pService", e);
		}

		try {
		Slog.i(TAG, "Wi-Fi Service");
		systemServiceManager.startService("com.android.server.wifi.WifiService");
		wifi = new WifiService(context);
		ServiceManager.addService(Context.WIFI_SERVICE, wifi);
		} catch (Throwable e) {
		reportWtf("starting Wi-Fi Service", e);
		}
		@@ -530,6 +536,9 @@ class ServerThread {
		ServiceManager.addService(Context.CONNECTIVITY_SERVICE, connectivity);
		networkStats.bindConnectivityManager(connectivity);
		networkPolicy.bindConnectivityManager(connectivity);

		wifiP2p.connectivityServiceReady();
		wifi.checkAndStartWifi();
		} catch (Throwable e) {
		reportWtf("starting Connectivity Service", e);
		}

services/core/java/com/android/server/wifi/NetworkUpdateResult.java

0 → 100644

+70 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 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 static android.net.wifi.WifiConfiguration.INVALID_NETWORK_ID;

		class NetworkUpdateResult {
		int netId;
		boolean ipChanged;
		boolean proxyChanged;
		boolean isNewNetwork = false;

		public NetworkUpdateResult(int id) {
		netId = id;
		ipChanged = false;
		proxyChanged = false;
		}

		public NetworkUpdateResult(boolean ip, boolean proxy) {
		netId = INVALID_NETWORK_ID;
		ipChanged = ip;
		proxyChanged = proxy;
		}

		public void setNetworkId(int id) {
		netId = id;
		}

		public int getNetworkId() {
		return netId;
		}

		public void setIpChanged(boolean ip) {
		ipChanged = ip;
		}

		public boolean hasIpChanged() {
		return ipChanged;
		}

		public void setProxyChanged(boolean proxy) {
		proxyChanged = proxy;
		}

		public boolean hasProxyChanged() {
		return proxyChanged;
		}

		public boolean isNewNetwork() {
		return isNewNetwork;
		}

		public void setIsNewNetwork(boolean isNew) {
		isNewNetwork = isNew;
		}
		}