com_android_server_wifi_WifiNative.cpp revision e11c2008f9d528b97a1a8176f508800729cd4150 
1/*
2 * Copyright 2008, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "wifi"
18
19#include "jni.h"
20#include <ScopedUtfChars.h>
21#include <utils/misc.h>
22#include <android_runtime/AndroidRuntime.h>
23#include <utils/Log.h>
24#include <utils/String16.h>
25#include <ctype.h>
26#include <sys/socket.h>
27#include <linux/if.h>
28
29#include "wifi.h"
30#include "wifi_hal.h"
31#include "jni_helper.h"
32
33#define REPLY_BUF_SIZE 4096 // wpa_supplicant's maximum size.
34#define EVENT_BUF_SIZE 2048
35
36namespace android {
37
38static jint DBG = false;
39
40static bool doCommand(JNIEnv* env, jstring javaCommand,
41                      char* reply, size_t reply_len) {
42    ScopedUtfChars command(env, javaCommand);
43    if (command.c_str() == NULL) {
44        return false; // ScopedUtfChars already threw on error.
45    }
46
47    if (DBG) {
48        ALOGD("doCommand: %s", command.c_str());
49    }
50
51    --reply_len; // Ensure we have room to add NUL termination.
52    if (::wifi_command(command.c_str(), reply, &reply_len) != 0) {
53        return false;
54    }
55
56    // Strip off trailing newline.
57    if (reply_len > 0 && reply[reply_len-1] == '\n') {
58        reply[reply_len-1] = '\0';
59    } else {
60        reply[reply_len] = '\0';
61    }
62    return true;
63}
64
65static jint doIntCommand(JNIEnv* env, jstring javaCommand) {
66    char reply[REPLY_BUF_SIZE];
67    if (!doCommand(env, javaCommand, reply, sizeof(reply))) {
68        return -1;
69    }
70    return static_cast<jint>(atoi(reply));
71}
72
73static jboolean doBooleanCommand(JNIEnv* env, jstring javaCommand) {
74    char reply[REPLY_BUF_SIZE];
75    if (!doCommand(env, javaCommand, reply, sizeof(reply))) {
76        return JNI_FALSE;
77    }
78    return (strcmp(reply, "OK") == 0);
79}
80
81// Send a command to the supplicant, and return the reply as a String.
82static jstring doStringCommand(JNIEnv* env, jstring javaCommand) {
83    char reply[REPLY_BUF_SIZE];
84    if (!doCommand(env, javaCommand, reply, sizeof(reply))) {
85        return NULL;
86    }
87    return env->NewStringUTF(reply);
88}
89
90static jboolean android_net_wifi_isDriverLoaded(JNIEnv* env, jobject)
91{
92    return (::is_wifi_driver_loaded() == 1);
93}
94
95static jboolean android_net_wifi_loadDriver(JNIEnv* env, jobject)
96{
97    return (::wifi_load_driver() == 0);
98}
99
100static jboolean android_net_wifi_unloadDriver(JNIEnv* env, jobject)
101{
102    return (::wifi_unload_driver() == 0);
103}
104
105static jboolean android_net_wifi_startSupplicant(JNIEnv* env, jobject, jboolean p2pSupported)
106{
107    return (::wifi_start_supplicant(p2pSupported) == 0);
108}
109
110static jboolean android_net_wifi_killSupplicant(JNIEnv* env, jobject, jboolean p2pSupported)
111{
112    return (::wifi_stop_supplicant(p2pSupported) == 0);
113}
114
115static jboolean android_net_wifi_connectToSupplicant(JNIEnv* env, jobject)
116{
117    return (::wifi_connect_to_supplicant() == 0);
118}
119
120static void android_net_wifi_closeSupplicantConnection(JNIEnv* env, jobject)
121{
122    ::wifi_close_supplicant_connection();
123}
124
125static jstring android_net_wifi_waitForEvent(JNIEnv* env, jobject)
126{
127    char buf[EVENT_BUF_SIZE];
128    int nread = ::wifi_wait_for_event(buf, sizeof buf);
129    if (nread > 0) {
130        return env->NewStringUTF(buf);
131    } else {
132        return NULL;
133    }
134}
135
136static jboolean android_net_wifi_doBooleanCommand(JNIEnv* env, jobject, jstring javaCommand) {
137    return doBooleanCommand(env, javaCommand);
138}
139
140static jint android_net_wifi_doIntCommand(JNIEnv* env, jobject, jstring javaCommand) {
141    return doIntCommand(env, javaCommand);
142}
143
144static jstring android_net_wifi_doStringCommand(JNIEnv* env, jobject, jstring javaCommand) {
145    return doStringCommand(env,javaCommand);
146}
147
148/* wifi_hal <==> WifiNative bridge */
149
150static jclass mCls;                             /* saved WifiNative object */
151static JavaVM *mVM;                             /* saved JVM pointer */
152
153static const char *WifiHandleVarName = "sWifiHalHandle";
154static const char *WifiIfaceHandleVarName = "sWifiIfaceHandles";
155static jmethodID OnScanResultsMethodID;
156
157static JNIEnv *getEnv() {
158    JNIEnv *env = NULL;
159    mVM->AttachCurrentThread(&env, NULL);
160    return env;
161}
162
163static wifi_handle getWifiHandle(JNIEnv *env, jclass cls) {
164    return (wifi_handle) getStaticLongField(env, cls, WifiHandleVarName);
165}
166
167static wifi_interface_handle getIfaceHandle(JNIEnv *env, jclass cls, jint index) {
168    return (wifi_interface_handle) getStaticLongArrayField(env, cls, WifiIfaceHandleVarName, index);
169}
170
171static jobject createScanResult(JNIEnv *env, wifi_scan_result *result) {
172
173    // ALOGD("creating scan result");
174
175    jobject scanResult = createObject(env, "android/net/wifi/ScanResult");
176    if (scanResult == NULL) {
177        ALOGE("Error in creating scan result");
178        return NULL;
179    }
180
181    // ALOGD("setting SSID to %s", result.ssid);
182    setStringField(env, scanResult, "SSID", result->ssid);
183
184    char bssid[32];
185    sprintf(bssid, "%02x:%02x:%02x:%02x:%02x:%02x", result->bssid[0], result->bssid[1],
186        result->bssid[2], result->bssid[3], result->bssid[4], result->bssid[5]);
187
188    setStringField(env, scanResult, "BSSID", bssid);
189
190    setIntField(env, scanResult, "level", result->rssi);
191    setIntField(env, scanResult, "frequency", result->channel);
192    setLongField(env, scanResult, "timestamp", result->ts);
193
194    return scanResult;
195}
196
197int set_iface_flags(const char *ifname, int dev_up) {
198    struct ifreq ifr;
199    int ret;
200    int sock = socket(PF_INET, SOCK_DGRAM, 0);
201    if (sock < 0) {
202        ALOGD("Bad socket: %d\n", sock);
203        return -errno;
204    }
205
206    ALOGD("setting interface %s flags (%s)\n", ifname, dev_up ? "UP" : "DOWN");
207
208    memset(&ifr, 0, sizeof(ifr));
209    strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
210
211    ALOGD("reading old value\n");
212
213    if (ioctl(sock, SIOCGIFFLAGS, &ifr) != 0) {
214      ret = errno ? -errno : -999;
215      ALOGD("Could not read interface %s flags: %d\n", ifname, errno);
216      close(sock);
217      return ret;
218    } else {
219      ALOGD("writing new value\n");
220    }
221
222    if (dev_up) {
223      if (ifr.ifr_flags & IFF_UP) {
224        ALOGD("interface %s is already up\n", ifname);
225        close(sock);
226        return 0;
227      }
228      ifr.ifr_flags |= IFF_UP;
229    } else {
230      if (!(ifr.ifr_flags & IFF_UP)) {
231        ALOGD("interface %s is already down\n", ifname);
232        close(sock);
233        return 0;
234      }
235      ifr.ifr_flags &= ~IFF_UP;
236    }
237
238    if (ioctl(sock, SIOCSIFFLAGS, &ifr) != 0) {
239      ALOGD("Could not set interface %s flags \n", ifname);
240      close(sock);
241      return ret;
242    } else {
243      ALOGD("set interface %s flags (%s)\n", ifname, dev_up ? "UP" : "DOWN");
244    }
245    close(sock);
246    return 0;
247}
248
249static jboolean android_net_wifi_toggle_interface(JNIEnv* env, jclass cls, int toggle) {
250    return(set_iface_flags("wlan0", toggle) == 0);
251}
252
253static jboolean android_net_wifi_startHal(JNIEnv* env, jclass cls) {
254    wifi_handle halHandle = getWifiHandle(env, cls);
255    if (halHandle == NULL) {
256        int ret = set_iface_flags("wlan0", 1);
257        if(ret != 0) {
258            return false;
259        }
260        wifi_error res = wifi_initialize(&halHandle);
261        if (res == WIFI_SUCCESS) {
262            setStaticLongField(env, cls, WifiHandleVarName, (jlong)halHandle);
263            ALOGD("Did set static halHandle = %p", halHandle);
264        }
265        env->GetJavaVM(&mVM);
266        mCls = (jclass) env->NewGlobalRef(cls);
267        ALOGD("halHandle = %p, mVM = %p, mCls = %p", halHandle, mVM, mCls);
268        return res == WIFI_SUCCESS;
269    } else {
270        return (set_iface_flags("wlan0", 1) == 0);
271    }
272}
273
274void android_net_wifi_hal_cleaned_up_handler(wifi_handle handle) {
275    ALOGD("In wifi cleaned up handler");
276
277    JNIEnv * env = getEnv();
278    setStaticLongField(env, mCls, WifiHandleVarName, 0);
279    env->DeleteGlobalRef(mCls);
280    mCls = NULL;
281    mVM  = NULL;
282}
283
284static void android_net_wifi_stopHal(JNIEnv* env, jclass cls) {
285    ALOGD("In wifi stop Hal");
286
287    wifi_handle halHandle = getWifiHandle(env, cls);
288    wifi_cleanup(halHandle, android_net_wifi_hal_cleaned_up_handler);
289    set_iface_flags("wlan0", 0);
290}
291
292static void android_net_wifi_waitForHalEvents(JNIEnv* env, jclass cls) {
293
294    ALOGD("waitForHalEvents called, vm = %p, obj = %p, env = %p", mVM, mCls, env);
295
296    wifi_handle halHandle = getWifiHandle(env, cls);
297    wifi_event_loop(halHandle);
298}
299
300static int android_net_wifi_getInterfaces(JNIEnv *env, jclass cls) {
301    int n = 0;
302    wifi_handle halHandle = getWifiHandle(env, cls);
303    wifi_interface_handle *ifaceHandles = NULL;
304    int result = wifi_get_ifaces(halHandle, &n, &ifaceHandles);
305    if (result < 0) {
306        return result;
307    }
308
309    if (n < 0) {
310        THROW(env, "android_net_wifi_getInterfaces no interfaces");
311        return 0;
312    }
313
314    if (ifaceHandles == NULL) {
315       THROW(env, "android_net_wifi_getInterfaces null interface array");
316       return 0;
317    }
318
319    if (n > 8) {
320        THROW(env, "Too many interfaces");
321        return 0;
322    }
323
324    jlongArray array = (env)->NewLongArray(n);
325    if (array == NULL) {
326        THROW(env, "Error in accessing array");
327        return 0;
328    }
329
330    jlong elems[8];
331    for (int i = 0; i < n; i++) {
332        elems[i] = reinterpret_cast<jlong>(ifaceHandles[i]);
333    }
334    env->SetLongArrayRegion(array, 0, n, elems);
335    setStaticLongArrayField(env, cls, WifiIfaceHandleVarName, array);
336
337    return (result < 0) ? result : n;
338}
339
340static jstring android_net_wifi_getInterfaceName(JNIEnv *env, jclass cls, jint i) {
341    char buf[EVENT_BUF_SIZE];
342
343    jlong value = getStaticLongArrayField(env, cls, WifiIfaceHandleVarName, i);
344    wifi_interface_handle handle = (wifi_interface_handle) value;
345    int result = ::wifi_get_iface_name(handle, buf, sizeof(buf));
346    if (result < 0) {
347        return NULL;
348    } else {
349        return env->NewStringUTF(buf);
350    }
351}
352
353
354static void onScanResultsAvailable(wifi_request_id id, unsigned num_results) {
355
356    JNIEnv *env = NULL;
357    mVM->AttachCurrentThread(&env, NULL);
358
359    ALOGD("onScanResultsAvailable called, vm = %p, obj = %p, env = %p", mVM, mCls, env);
360
361    reportEvent(env, mCls, "onScanResultsAvailable", "(I)V", id);
362}
363
364static void onScanEvent(wifi_scan_event event, unsigned status) {
365    JNIEnv *env = NULL;
366    mVM->AttachCurrentThread(&env, NULL);
367
368    ALOGD("onScanStatus called, vm = %p, obj = %p, env = %p", mVM, mCls, env);
369
370    reportEvent(env, mCls, "onScanStatus", "(I)V", status);
371}
372
373static void onFullScanResult(wifi_request_id id, wifi_scan_result *result) {
374
375    JNIEnv *env = NULL;
376    mVM->AttachCurrentThread(&env, NULL);
377
378    ALOGD("onFullScanResult called, vm = %p, obj = %p, env = %p", mVM, mCls, env);
379
380    jobject scanResult = createScanResult(env, result);
381
382    ALOGD("Creating a byte array of length %d", result->ie_length);
383
384    jbyteArray elements = env->NewByteArray(result->ie_length);
385    if (elements == NULL) {
386        ALOGE("Error in allocating array");
387        return;
388    }
389
390    ALOGE("Setting byte array");
391
392    jbyte *bytes = (jbyte *)&(result->ie_data[0]);
393    env->SetByteArrayRegion(elements, 0, result->ie_length, bytes);
394
395    ALOGE("Returning result");
396
397    reportEvent(env, mCls, "onFullScanResult", "(ILandroid/net/wifi/ScanResult;[B)V", id,
398            scanResult, elements);
399
400    env->DeleteLocalRef(scanResult);
401    env->DeleteLocalRef(elements);
402}
403
404static jboolean android_net_wifi_startScan(
405        JNIEnv *env, jclass cls, jint iface, jint id, jobject settings) {
406
407    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
408    ALOGD("starting scan on interface[%d] = %p", iface, handle);
409
410    wifi_scan_cmd_params params;
411    memset(&params, 0, sizeof(params));
412
413    params.base_period = getIntField(env, settings, "base_period_ms");
414    params.max_ap_per_scan = getIntField(env, settings, "max_ap_per_scan");
415    params.report_threshold_percent = getIntField(env, settings, "report_threshold_percent");
416    params.report_threshold_num_scans = getIntField(env, settings, "report_threshold_num_scans");
417
418    ALOGD("Initialized common fields %d, %d, %d, %d", params.base_period, params.max_ap_per_scan,
419            params.report_threshold_percent, params.report_threshold_num_scans);
420
421    const char *bucket_array_type = "[Lcom/android/server/wifi/WifiNative$BucketSettings;";
422    const char *channel_array_type = "[Lcom/android/server/wifi/WifiNative$ChannelSettings;";
423
424    jobjectArray buckets = (jobjectArray)getObjectField(env, settings, "buckets", bucket_array_type);
425    params.num_buckets = getIntField(env, settings, "num_buckets");
426
427    ALOGD("Initialized num_buckets to %d", params.num_buckets);
428
429    for (int i = 0; i < params.num_buckets; i++) {
430        jobject bucket = getObjectArrayField(env, settings, "buckets", bucket_array_type, i);
431
432        params.buckets[i].bucket = getIntField(env, bucket, "bucket");
433        params.buckets[i].band = (wifi_band) getIntField(env, bucket, "band");
434        params.buckets[i].period = getIntField(env, bucket, "period_ms");
435
436        ALOGD("Initialized common bucket fields %d:%d:%d", params.buckets[i].bucket,
437                params.buckets[i].band, params.buckets[i].period);
438
439        int report_events = getIntField(env, bucket, "report_events");
440        params.buckets[i].report_events = report_events;
441
442        ALOGD("Initialized report events to %d", params.buckets[i].report_events);
443
444        jobjectArray channels = (jobjectArray)getObjectField(
445                env, bucket, "channels", channel_array_type);
446
447        params.buckets[i].num_channels = getIntField(env, bucket, "num_channels");
448        ALOGD("Initialized num_channels to %d", params.buckets[i].num_channels);
449
450        for (int j = 0; j < params.buckets[i].num_channels; j++) {
451            jobject channel = getObjectArrayField(env, bucket, "channels", channel_array_type, j);
452
453            params.buckets[i].channels[j].channel = getIntField(env, channel, "frequency");
454            params.buckets[i].channels[j].dwellTimeMs = getIntField(env, channel, "dwell_time_ms");
455
456            bool passive = getBoolField(env, channel, "passive");
457            params.buckets[i].channels[j].passive = (passive ? 1 : 0);
458
459            ALOGD("Initialized channel %d", params.buckets[i].channels[j].channel);
460        }
461    }
462
463    ALOGD("Initialized all fields");
464
465    wifi_scan_result_handler handler;
466    memset(&handler, 0, sizeof(handler));
467    handler.on_scan_results_available = &onScanResultsAvailable;
468    handler.on_full_scan_result = &onFullScanResult;
469    handler.on_scan_event = &onScanEvent;
470
471    return wifi_start_gscan(id, handle, params, handler) == WIFI_SUCCESS;
472}
473
474static jboolean android_net_wifi_stopScan(JNIEnv *env, jclass cls, jint iface, jint id) {
475    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
476    ALOGD("stopping scan on interface[%d] = %p", iface, handle);
477
478    return wifi_stop_gscan(id, handle)  == WIFI_SUCCESS;
479}
480
481static int compare_scan_result_timestamp(const void *v1, const void *v2) {
482    const wifi_scan_result *result1 = static_cast<const wifi_scan_result *>(v1);
483    const wifi_scan_result *result2 = static_cast<const wifi_scan_result *>(v2);
484    return result1->ts - result2->ts;
485}
486
487static jobject android_net_wifi_getScanResults(
488        JNIEnv *env, jclass cls, jint iface, jboolean flush)  {
489
490    wifi_cached_scan_results scan_data[64];
491    int num_scan_data = 64;
492
493    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
494    ALOGD("getting scan results on interface[%d] = %p", iface, handle);
495
496    byte b = flush ? 0 : 0xFF;
497    int result = wifi_get_cached_gscan_results(handle, b, num_scan_data, scan_data, &num_scan_data);
498    if (result == WIFI_SUCCESS) {
499        jobjectArray scanData = createObjectArray(env,
500                "android/net/wifi/WifiScanner$ScanData", num_scan_data);
501        if (scanData == NULL) {
502            ALOGE("Error in allocating array of scanData");
503            return NULL;
504        }
505
506        for (int i = 0; i < num_scan_data; i++) {
507
508            jobject data = createObject(env, "android/net/wifi/WifiScanner$ScanData");
509            if (data == NULL) {
510                ALOGE("Error in allocating scanData");
511                return NULL;
512            }
513
514            setIntField(env, data, "mId", scan_data[i].scan_id);
515            setIntField(env, data, "mFlags", scan_data[i].flags);
516
517            /* sort all scan results by timestamp */
518            qsort(scan_data[i].results, scan_data[i].num_results,
519                    sizeof(wifi_scan_result), compare_scan_result_timestamp);
520
521            jobjectArray scanResults = createObjectArray(env,
522                    "android/net/wifi/ScanResult", scan_data[i].num_results);
523            if (scanResults == NULL) {
524                ALOGE("Error in allocating scanResult array");
525                return NULL;
526            }
527
528            wifi_scan_result *results = scan_data[i].results;
529            for (int j = 0; j < scan_data[i].num_results; j++) {
530
531                jobject scanResult = createObject(env, "android/net/wifi/ScanResult");
532                if (scanResult == NULL) {
533                    ALOGE("Error in creating scan result");
534                    return NULL;
535                }
536
537                setStringField(env, scanResult, "SSID", results[j].ssid);
538
539                char bssid[32];
540                sprintf(bssid, "%02x:%02x:%02x:%02x:%02x:%02x", results[j].bssid[0],
541                        results[j].bssid[1], results[j].bssid[2], results[j].bssid[3],
542                        results[j].bssid[4], results[j].bssid[5]);
543
544                setStringField(env, scanResult, "BSSID", bssid);
545
546                setIntField(env, scanResult, "level", results[j].rssi);
547                setIntField(env, scanResult, "frequency", results[j].channel);
548                setLongField(env, scanResult, "timestamp", results[j].ts);
549
550                env->SetObjectArrayElement(scanResults, j, scanResult);
551                env->DeleteLocalRef(scanResult);
552            }
553
554            setObjectField(env, data, "mResults", "[Landroid/net/wifi/ScanResult;", scanResults);
555            env->SetObjectArrayElement(scanData, i, data);
556        }
557
558        return scanData;
559    } else {
560        return NULL;
561    }
562}
563
564
565static jboolean android_net_wifi_getScanCapabilities(
566        JNIEnv *env, jclass cls, jint iface, jobject capabilities) {
567
568    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
569    ALOGD("getting scan capabilities on interface[%d] = %p", iface, handle);
570
571    wifi_gscan_capabilities c;
572    memset(&c, 0, sizeof(c));
573    int result = wifi_get_gscan_capabilities(handle, &c);
574    if (result != WIFI_SUCCESS) {
575        ALOGD("failed to get capabilities : %d", result);
576        return JNI_FALSE;
577    }
578
579    setIntField(env, capabilities, "max_scan_cache_size", c.max_scan_cache_size);
580    setIntField(env, capabilities, "max_scan_buckets", c.max_scan_buckets);
581    setIntField(env, capabilities, "max_ap_cache_per_scan", c.max_ap_cache_per_scan);
582    setIntField(env, capabilities, "max_rssi_sample_size", c.max_rssi_sample_size);
583    setIntField(env, capabilities, "max_scan_reporting_threshold", c.max_scan_reporting_threshold);
584    setIntField(env, capabilities, "max_hotlist_aps", c.max_hotlist_aps);
585    setIntField(env, capabilities, "max_significant_wifi_change_aps",
586                c.max_significant_wifi_change_aps);
587
588    return JNI_TRUE;
589}
590
591
592static byte parseHexChar(char ch) {
593    if (isdigit(ch))
594        return ch - '0';
595    else if ('A' <= ch && ch <= 'F')
596        return ch - 'A' + 10;
597    else if ('a' <= ch && ch <= 'f')
598        return ch - 'a' + 10;
599    else {
600        ALOGE("invalid character in bssid %c", ch);
601        return 0;
602    }
603}
604
605static byte parseHexByte(const char * &str) {
606    byte b = parseHexChar(str[0]);
607    if (str[1] == ':' || str[1] == '\0') {
608        str += 2;
609        return b;
610    } else {
611        b = b << 4 | parseHexChar(str[1]);
612        str += 3;
613        return b;
614    }
615}
616
617static void parseMacAddress(const char *str, mac_addr addr) {
618    addr[0] = parseHexByte(str);
619    addr[1] = parseHexByte(str);
620    addr[2] = parseHexByte(str);
621    addr[3] = parseHexByte(str);
622    addr[4] = parseHexByte(str);
623    addr[5] = parseHexByte(str);
624}
625
626static bool parseMacAddress(JNIEnv *env, jobject obj, mac_addr addr) {
627    jstring macAddrString = (jstring) getObjectField(
628            env, obj, "bssid", "Ljava/lang/String;");
629
630    if (macAddrString == NULL) {
631        ALOGE("Error getting bssid field");
632        return false;
633    }
634
635    const char *bssid = env->GetStringUTFChars(macAddrString, NULL);
636    if (bssid == NULL) {
637        ALOGE("Error getting bssid");
638        return false;
639    }
640
641    parseMacAddress(bssid, addr);
642    return true;
643}
644
645static void onHotlistApFound(wifi_request_id id,
646        unsigned num_results, wifi_scan_result *results) {
647
648    JNIEnv *env = NULL;
649    mVM->AttachCurrentThread(&env, NULL);
650
651    ALOGD("onHotlistApFound called, vm = %p, obj = %p, env = %p, num_results = %d",
652            mVM, mCls, env, num_results);
653
654    jclass clsScanResult = (env)->FindClass("android/net/wifi/ScanResult");
655    if (clsScanResult == NULL) {
656        ALOGE("Error in accessing class");
657        return;
658    }
659
660    jobjectArray scanResults = env->NewObjectArray(num_results, clsScanResult, NULL);
661    if (scanResults == NULL) {
662        ALOGE("Error in allocating array");
663        return;
664    }
665
666    for (unsigned i = 0; i < num_results; i++) {
667
668        jobject scanResult = createObject(env, "android/net/wifi/ScanResult");
669        if (scanResult == NULL) {
670            ALOGE("Error in creating scan result");
671            return;
672        }
673
674        setStringField(env, scanResult, "SSID", results[i].ssid);
675
676        char bssid[32];
677        sprintf(bssid, "%02x:%02x:%02x:%02x:%02x:%02x", results[i].bssid[0], results[i].bssid[1],
678            results[i].bssid[2], results[i].bssid[3], results[i].bssid[4], results[i].bssid[5]);
679
680        setStringField(env, scanResult, "BSSID", bssid);
681
682        setIntField(env, scanResult, "level", results[i].rssi);
683        setIntField(env, scanResult, "frequency", results[i].channel);
684        setLongField(env, scanResult, "timestamp", results[i].ts);
685
686        env->SetObjectArrayElement(scanResults, i, scanResult);
687
688        ALOGD("Found AP %32s %s", results[i].ssid, bssid);
689    }
690
691    reportEvent(env, mCls, "onHotlistApFound", "(I[Landroid/net/wifi/ScanResult;)V",
692        id, scanResults);
693}
694
695static jboolean android_net_wifi_setHotlist(
696        JNIEnv *env, jclass cls, jint iface, jint id, jobject ap)  {
697
698    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
699    ALOGD("setting hotlist on interface[%d] = %p", iface, handle);
700
701    wifi_bssid_hotlist_params params;
702    memset(&params, 0, sizeof(params));
703
704    jobjectArray array = (jobjectArray) getObjectField(env, ap,
705            "bssidInfos", "[Landroid/net/wifi/WifiScanner$BssidInfo;");
706    params.num_ap = env->GetArrayLength(array);
707
708    if (params.num_ap == 0) {
709        ALOGE("Error in accesing array");
710        return false;
711    }
712
713    for (int i = 0; i < params.num_ap; i++) {
714        jobject objAp = env->GetObjectArrayElement(array, i);
715
716        jstring macAddrString = (jstring) getObjectField(
717                env, objAp, "bssid", "Ljava/lang/String;");
718        if (macAddrString == NULL) {
719            ALOGE("Error getting bssid field");
720            return false;
721        }
722
723        const char *bssid = env->GetStringUTFChars(macAddrString, NULL);
724        if (bssid == NULL) {
725            ALOGE("Error getting bssid");
726            return false;
727        }
728        parseMacAddress(bssid, params.ap[i].bssid);
729
730        mac_addr addr;
731        memcpy(addr, params.ap[i].bssid, sizeof(mac_addr));
732
733        char bssidOut[32];
734        sprintf(bssidOut, "%0x:%0x:%0x:%0x:%0x:%0x", addr[0], addr[1],
735            addr[2], addr[3], addr[4], addr[5]);
736
737        ALOGD("Added bssid %s", bssidOut);
738
739        params.ap[i].low = getIntField(env, objAp, "low");
740        params.ap[i].high = getIntField(env, objAp, "high");
741    }
742
743    wifi_hotlist_ap_found_handler handler;
744    memset(&handler, 0, sizeof(handler));
745
746    handler.on_hotlist_ap_found = &onHotlistApFound;
747    return wifi_set_bssid_hotlist(id, handle, params, handler) == WIFI_SUCCESS;
748}
749
750static jboolean android_net_wifi_resetHotlist(
751        JNIEnv *env, jclass cls, jint iface, jint id)  {
752
753    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
754    ALOGD("resetting hotlist on interface[%d] = %p", iface, handle);
755
756    return wifi_reset_bssid_hotlist(id, handle) == WIFI_SUCCESS;
757}
758
759void onSignificantWifiChange(wifi_request_id id,
760        unsigned num_results, wifi_significant_change_result **results) {
761    JNIEnv *env = NULL;
762    mVM->AttachCurrentThread(&env, NULL);
763
764    ALOGD("onSignificantWifiChange called, vm = %p, obj = %p, env = %p", mVM, mCls, env);
765
766    jclass clsScanResult = (env)->FindClass("android/net/wifi/ScanResult");
767    if (clsScanResult == NULL) {
768        ALOGE("Error in accessing class");
769        return;
770    }
771
772    jobjectArray scanResults = env->NewObjectArray(num_results, clsScanResult, NULL);
773    if (scanResults == NULL) {
774        ALOGE("Error in allocating array");
775        return;
776    }
777
778    for (unsigned i = 0; i < num_results; i++) {
779
780        wifi_significant_change_result result = *(results[i]);
781
782        jobject scanResult = createObject(env, "android/net/wifi/ScanResult");
783        if (scanResult == NULL) {
784            ALOGE("Error in creating scan result");
785            return;
786        }
787
788        // setStringField(env, scanResult, "SSID", results[i].ssid);
789
790        char bssid[32];
791        sprintf(bssid, "%02x:%02x:%02x:%02x:%02x:%02x", result.bssid[0], result.bssid[1],
792            result.bssid[2], result.bssid[3], result.bssid[4], result.bssid[5]);
793
794        setStringField(env, scanResult, "BSSID", bssid);
795
796        setIntField(env, scanResult, "level", result.rssi[0]);
797        setIntField(env, scanResult, "frequency", result.channel);
798        // setLongField(env, scanResult, "timestamp", result.ts);
799
800        env->SetObjectArrayElement(scanResults, i, scanResult);
801    }
802
803    reportEvent(env, mCls, "onSignificantWifiChange", "(I[Landroid/net/wifi/ScanResult;)V",
804        id, scanResults);
805
806}
807
808static jboolean android_net_wifi_trackSignificantWifiChange(
809        JNIEnv *env, jclass cls, jint iface, jint id, jobject settings)  {
810
811    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
812    ALOGD("tracking significant wifi change on interface[%d] = %p", iface, handle);
813
814    wifi_significant_change_params params;
815    memset(&params, 0, sizeof(params));
816
817    params.rssi_sample_size = getIntField(env, settings, "rssiSampleSize");
818    params.lost_ap_sample_size = getIntField(env, settings, "lostApSampleSize");
819    params.min_breaching = getIntField(env, settings, "minApsBreachingThreshold");
820
821    const char *bssid_info_array_type = "[Landroid/net/wifi/WifiScanner$BssidInfo;";
822    jobjectArray bssids = (jobjectArray)getObjectField(
823                env, settings, "bssidInfos", bssid_info_array_type);
824    params.num_ap = env->GetArrayLength(bssids);
825
826    if (params.num_ap == 0) {
827        ALOGE("Error in accessing array");
828        return false;
829    }
830
831    ALOGD("Initialized common fields %d, %d, %d, %d", params.rssi_sample_size,
832            params.lost_ap_sample_size, params.min_breaching, params.num_ap);
833
834    for (int i = 0; i < params.num_ap; i++) {
835        jobject objAp = env->GetObjectArrayElement(bssids, i);
836
837        jstring macAddrString = (jstring) getObjectField(
838                env, objAp, "bssid", "Ljava/lang/String;");
839        if (macAddrString == NULL) {
840            ALOGE("Error getting bssid field");
841            return false;
842        }
843
844        const char *bssid = env->GetStringUTFChars(macAddrString, NULL);
845        if (bssid == NULL) {
846            ALOGE("Error getting bssid");
847            return false;
848        }
849
850        mac_addr addr;
851        parseMacAddress(bssid, addr);
852        memcpy(params.ap[i].bssid, addr, sizeof(mac_addr));
853
854        char bssidOut[32];
855        sprintf(bssidOut, "%02x:%02x:%02x:%02x:%02x:%02x", addr[0], addr[1],
856            addr[2], addr[3], addr[4], addr[5]);
857
858        params.ap[i].low = getIntField(env, objAp, "low");
859        params.ap[i].high = getIntField(env, objAp, "high");
860
861        ALOGD("Added bssid %s, [%04d, %04d]", bssidOut, params.ap[i].low, params.ap[i].high);
862    }
863
864    ALOGD("Added %d bssids", params.num_ap);
865
866    wifi_significant_change_handler handler;
867    memset(&handler, 0, sizeof(handler));
868
869    handler.on_significant_change = &onSignificantWifiChange;
870    return wifi_set_significant_change_handler(id, handle, params, handler) == WIFI_SUCCESS;
871}
872
873static jboolean android_net_wifi_untrackSignificantWifiChange(
874        JNIEnv *env, jclass cls, jint iface, jint id)  {
875
876    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
877    ALOGD("resetting significant wifi change on interface[%d] = %p", iface, handle);
878
879    return wifi_reset_significant_change_handler(id, handle) == WIFI_SUCCESS;
880}
881
882wifi_iface_stat link_stat;
883wifi_radio_stat radio_stat; // L release has support for only one radio
884
885void onLinkStatsResults(wifi_request_id id, wifi_iface_stat *iface_stat,
886         int num_radios, wifi_radio_stat *radio_stats)
887{
888    if (iface_stat != 0) {
889        memcpy(&link_stat, iface_stat, sizeof(wifi_iface_stat));
890    } else {
891        memset(&link_stat, 0, sizeof(wifi_iface_stat));
892    }
893
894    if (num_radios > 0 && radio_stats != 0) {
895        memcpy(&radio_stat, radio_stats, sizeof(wifi_radio_stat));
896    } else {
897        memset(&radio_stat, 0, sizeof(wifi_radio_stat));
898    }
899}
900
901static jobject android_net_wifi_getLinkLayerStats (JNIEnv *env, jclass cls, jint iface)  {
902
903    wifi_stats_result_handler handler;
904    memset(&handler, 0, sizeof(handler));
905    handler.on_link_stats_results = &onLinkStatsResults;
906    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
907    int result = wifi_get_link_stats(0, handle, handler);
908    if (result < 0) {
909        ALOGE("android_net_wifi_getLinkLayerStats: failed to get link statistics\n");
910        return NULL;
911    }
912
913    jobject wifiLinkLayerStats = createObject(env, "android/net/wifi/WifiLinkLayerStats");
914    if (wifiLinkLayerStats == NULL) {
915       ALOGE("Error in allocating wifiLinkLayerStats");
916       return NULL;
917    }
918
919    setIntField(env, wifiLinkLayerStats, "beacon_rx", link_stat.beacon_rx);
920    setIntField(env, wifiLinkLayerStats, "rssi_mgmt", link_stat.rssi_mgmt);
921    setLongField(env, wifiLinkLayerStats, "rxmpdu_be", link_stat.ac[WIFI_AC_BE].rx_mpdu);
922    setLongField(env, wifiLinkLayerStats, "rxmpdu_bk", link_stat.ac[WIFI_AC_BK].rx_mpdu);
923    setLongField(env, wifiLinkLayerStats, "rxmpdu_vi", link_stat.ac[WIFI_AC_VI].rx_mpdu);
924    setLongField(env, wifiLinkLayerStats, "rxmpdu_vo", link_stat.ac[WIFI_AC_VO].rx_mpdu);
925    setLongField(env, wifiLinkLayerStats, "txmpdu_be", link_stat.ac[WIFI_AC_BE].tx_mpdu);
926    setLongField(env, wifiLinkLayerStats, "txmpdu_bk", link_stat.ac[WIFI_AC_BK].tx_mpdu);
927    setLongField(env, wifiLinkLayerStats, "txmpdu_vi", link_stat.ac[WIFI_AC_VI].tx_mpdu);
928    setLongField(env, wifiLinkLayerStats, "txmpdu_vo", link_stat.ac[WIFI_AC_VO].tx_mpdu);
929    setLongField(env, wifiLinkLayerStats, "lostmpdu_be", link_stat.ac[WIFI_AC_BE].mpdu_lost);
930    setLongField(env, wifiLinkLayerStats, "lostmpdu_bk", link_stat.ac[WIFI_AC_BK].mpdu_lost);
931    setLongField(env, wifiLinkLayerStats, "lostmpdu_vi",  link_stat.ac[WIFI_AC_VI].mpdu_lost);
932    setLongField(env, wifiLinkLayerStats, "lostmpdu_vo", link_stat.ac[WIFI_AC_VO].mpdu_lost);
933    setLongField(env, wifiLinkLayerStats, "retries_be", link_stat.ac[WIFI_AC_BE].retries);
934    setLongField(env, wifiLinkLayerStats, "retries_bk", link_stat.ac[WIFI_AC_BK].retries);
935    setLongField(env, wifiLinkLayerStats, "retries_vi", link_stat.ac[WIFI_AC_VI].retries);
936    setLongField(env, wifiLinkLayerStats, "retries_vo", link_stat.ac[WIFI_AC_VO].retries);
937
938
939    setIntField(env, wifiLinkLayerStats, "on_time", radio_stat.on_time);
940    setIntField(env, wifiLinkLayerStats, "tx_time", radio_stat.tx_time);
941    setIntField(env, wifiLinkLayerStats, "rx_time", radio_stat.rx_time);
942    setIntField(env, wifiLinkLayerStats, "on_time_scan", radio_stat.on_time_scan);
943
944    return wifiLinkLayerStats;
945}
946
947static jint android_net_wifi_getSupportedFeatures(JNIEnv *env, jclass cls, jint iface) {
948    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
949    feature_set set = 0;
950
951    wifi_error result = WIFI_SUCCESS;
952    /*
953    set = WIFI_FEATURE_INFRA
954        | WIFI_FEATURE_INFRA_5G
955        | WIFI_FEATURE_HOTSPOT
956        | WIFI_FEATURE_P2P
957        | WIFI_FEATURE_SOFT_AP
958        | WIFI_FEATURE_GSCAN
959        | WIFI_FEATURE_PNO
960        | WIFI_FEATURE_TDLS
961        | WIFI_FEATURE_EPR;
962    */
963
964    result = wifi_get_supported_feature_set(handle, &set);
965    if (result == WIFI_SUCCESS) {
966        /* Temporary workaround for RTT capability */
967        set = set | WIFI_FEATURE_D2AP_RTT;
968        ALOGD("wifi_get_supported_feature_set returned set = 0x%x", set);
969        return set;
970    } else {
971        ALOGD("wifi_get_supported_feature_set returned error = 0x%x", result);
972        return 0;
973    }
974}
975
976static void onRttResults(wifi_request_id id, unsigned num_results, wifi_rtt_result results[]) {
977    JNIEnv *env = NULL;
978    mVM->AttachCurrentThread(&env, NULL);
979
980    ALOGD("onRttResults called, vm = %p, obj = %p, env = %p", mVM, mCls, env);
981
982    jclass clsRttResult = (env)->FindClass("android/net/wifi/RttManager$RttResult");
983    if (clsRttResult == NULL) {
984        ALOGE("Error in accessing class");
985        return;
986    }
987
988    jobjectArray rttResults = env->NewObjectArray(num_results, clsRttResult, NULL);
989    if (rttResults == NULL) {
990        ALOGE("Error in allocating array");
991        return;
992    }
993
994    for (unsigned i = 0; i < num_results; i++) {
995
996        wifi_rtt_result& result = results[i];
997
998        jobject rttResult = createObject(env, "android/net/wifi/RttManager$RttResult");
999        if (rttResult == NULL) {
1000            ALOGE("Error in creating rtt result");
1001            return;
1002        }
1003
1004        char bssid[32];
1005        sprintf(bssid, "%02x:%02x:%02x:%02x:%02x:%02x", result.addr[0], result.addr[1],
1006            result.addr[2], result.addr[3], result.addr[4], result.addr[5]);
1007
1008        setStringField(env, rttResult, "bssid", bssid);
1009        setIntField(env,  rttResult, "status",               result.status);
1010        setIntField(env,  rttResult, "requestType",          result.type);
1011        setLongField(env, rttResult, "ts",                   result.ts);
1012        setIntField(env,  rttResult, "rssi",                 result.rssi);
1013        setIntField(env,  rttResult, "rssi_spread",          result.rssi_spread);
1014        setIntField(env,  rttResult, "tx_rate",              result.tx_rate.bitrate);
1015        setLongField(env, rttResult, "rtt_ns",               result.rtt);
1016        setLongField(env, rttResult, "rtt_sd_ns",            result.rtt_sd);
1017        setLongField(env, rttResult, "rtt_spread_ns",        result.rtt_spread);
1018        setIntField(env,  rttResult, "distance_cm",          result.distance);
1019        setIntField(env,  rttResult, "distance_sd_cm",       result.distance_sd);
1020        setIntField(env,  rttResult, "distance_spread_cm",   result.distance_spread);
1021
1022        env->SetObjectArrayElement(rttResults, i, rttResult);
1023    }
1024
1025    reportEvent(env, mCls, "onRttResults", "(I[Landroid/net/wifi/RttManager$RttResult;)V",
1026        id, rttResults);
1027}
1028
1029const int MaxRttConfigs = 16;
1030
1031static jboolean android_net_wifi_requestRange(
1032        JNIEnv *env, jclass cls, jint iface, jint id, jobject params)  {
1033
1034    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
1035    ALOGD("sending rtt request [%d] = %p", id, handle);
1036
1037    wifi_rtt_config configs[MaxRttConfigs];
1038    memset(&configs, 0, sizeof(configs));
1039
1040    int len = env->GetArrayLength((jobjectArray)params);
1041    if (len > MaxRttConfigs) {
1042        return false;
1043    }
1044
1045    for (int i = 0; i < len; i++) {
1046
1047        jobject param = env->GetObjectArrayElement((jobjectArray)params, i);
1048        if (param == NULL) {
1049            ALOGD("could not get element %d", i);
1050            continue;
1051        }
1052
1053        wifi_rtt_config &config = configs[i];
1054
1055        parseMacAddress(env, param, config.addr);
1056        config.type = (wifi_rtt_type)getIntField(env, param, "requestType");
1057        config.peer = (wifi_peer_type)getIntField(env, param, "deviceType");
1058        config.channel.center_freq = getIntField(env, param, "frequency");
1059        config.channel.width = (wifi_channel_width)getIntField(env, param, "channelWidth");
1060        config.num_frames_per_burst = getIntField(env, param, "num_samples");
1061        config.num_retries_per_measurement_frame = getIntField(env, param, "num_retries");
1062    }
1063
1064    wifi_rtt_event_handler handler;
1065    handler.on_rtt_results = &onRttResults;
1066
1067    return wifi_rtt_range_request(id, handle, len, configs, handler) == WIFI_SUCCESS;
1068}
1069
1070static jboolean android_net_wifi_cancelRange(
1071        JNIEnv *env, jclass cls, jint iface, jint id, jobject params)  {
1072
1073    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
1074    ALOGD("cancelling rtt request [%d] = %p", id, handle);
1075
1076    mac_addr addrs[MaxRttConfigs];
1077    memset(&addrs, 0, sizeof(addrs));
1078
1079    int len = env->GetArrayLength((jobjectArray)params);
1080    if (len > MaxRttConfigs) {
1081        return false;
1082    }
1083
1084    for (int i = 0; i < len; i++) {
1085
1086        jobject param = env->GetObjectArrayElement((jobjectArray)params, i);
1087        if (param == NULL) {
1088            ALOGD("could not get element %d", i);
1089            continue;
1090        }
1091
1092        parseMacAddress(env, param, addrs[i]);
1093    }
1094
1095    return wifi_rtt_range_cancel(id, handle, len, addrs) == WIFI_SUCCESS;
1096}
1097
1098static jboolean android_net_wifi_setScanningMacOui(JNIEnv *env, jclass cls,
1099        jint iface, jbyteArray param)  {
1100
1101    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
1102    ALOGD("setting scan oui %p", handle);
1103
1104    static const unsigned oui_len = 3;          /* OUI is upper 3 bytes of mac_address */
1105    int len = env->GetArrayLength(param);
1106    if (len != oui_len) {
1107        ALOGE("invalid oui length %d", len);
1108        return false;
1109    }
1110
1111    jbyte* bytes = env->GetByteArrayElements(param, NULL);
1112    if (bytes == NULL) {
1113        ALOGE("failed to get array");
1114        return false;
1115    }
1116
1117    return wifi_set_scanning_mac_oui(handle, (byte *)bytes) == WIFI_SUCCESS;
1118}
1119
1120static jintArray android_net_wifi_getValidChannels(JNIEnv *env, jclass cls,
1121        jint iface, jint band)  {
1122
1123    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
1124    ALOGD("getting valid channels %p", handle);
1125
1126    static const int MaxChannels = 64;
1127    wifi_channel channels[64];
1128    int num_channels = 0;
1129    wifi_error result = wifi_get_valid_channels(handle, band, MaxChannels,
1130            channels, &num_channels);
1131
1132    if (result == WIFI_SUCCESS) {
1133        jintArray channelArray = env->NewIntArray(num_channels);
1134        if (channelArray == NULL) {
1135            ALOGE("failed to allocate channel list");
1136            return NULL;
1137        }
1138
1139        env->SetIntArrayRegion(channelArray, 0, num_channels, channels);
1140        return channelArray;
1141    } else {
1142        ALOGE("failed to get channel list : %d", result);
1143        return NULL;
1144    }
1145}
1146
1147static jboolean android_net_wifi_setDfsFlag(JNIEnv *env, jclass cls, jint iface, jboolean dfs) {
1148    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
1149    ALOGD("setting dfs flag to %s, %p", dfs ? "true" : "false", handle);
1150
1151    u32 nodfs = dfs ? 0 : 1;
1152    wifi_error result = wifi_set_nodfs_flag(handle, nodfs);
1153    return result == WIFI_SUCCESS;
1154}
1155
1156// ----------------------------------------------------------------------------
1157
1158/*
1159 * JNI registration.
1160 */
1161static JNINativeMethod gWifiMethods[] = {
1162    /* name, signature, funcPtr */
1163
1164    { "loadDriver", "()Z",  (void *)android_net_wifi_loadDriver },
1165    { "isDriverLoaded", "()Z",  (void *)android_net_wifi_isDriverLoaded },
1166    { "unloadDriver", "()Z",  (void *)android_net_wifi_unloadDriver },
1167    { "startSupplicant", "(Z)Z",  (void *)android_net_wifi_startSupplicant },
1168    { "killSupplicant", "(Z)Z",  (void *)android_net_wifi_killSupplicant },
1169    { "connectToSupplicantNative", "()Z", (void *)android_net_wifi_connectToSupplicant },
1170    { "closeSupplicantConnectionNative", "()V",
1171            (void *)android_net_wifi_closeSupplicantConnection },
1172    { "waitForEventNative", "()Ljava/lang/String;", (void*)android_net_wifi_waitForEvent },
1173    { "doBooleanCommandNative", "(Ljava/lang/String;)Z", (void*)android_net_wifi_doBooleanCommand },
1174    { "doIntCommandNative", "(Ljava/lang/String;)I", (void*)android_net_wifi_doIntCommand },
1175    { "doStringCommandNative", "(Ljava/lang/String;)Ljava/lang/String;",
1176            (void*) android_net_wifi_doStringCommand },
1177    { "startHalNative", "()Z", (void*) android_net_wifi_startHal },
1178    { "stopHalNative", "()V", (void*) android_net_wifi_stopHal },
1179    { "waitForHalEventNative", "()V", (void*) android_net_wifi_waitForHalEvents },
1180    { "getInterfacesNative", "()I", (void*) android_net_wifi_getInterfaces},
1181    { "getInterfaceNameNative", "(I)Ljava/lang/String;", (void*) android_net_wifi_getInterfaceName},
1182    { "getScanCapabilitiesNative", "(ILcom/android/server/wifi/WifiNative$ScanCapabilities;)Z",
1183            (void *) android_net_wifi_getScanCapabilities},
1184    { "startScanNative", "(IILcom/android/server/wifi/WifiNative$ScanSettings;)Z",
1185            (void*) android_net_wifi_startScan},
1186    { "stopScanNative", "(II)Z", (void*) android_net_wifi_stopScan},
1187    { "getScanResultsNative", "(IZ)[Landroid/net/wifi/WifiScanner$ScanData;",
1188            (void *) android_net_wifi_getScanResults},
1189    { "setHotlistNative", "(IILandroid/net/wifi/WifiScanner$HotlistSettings;)Z",
1190            (void*) android_net_wifi_setHotlist},
1191    { "resetHotlistNative", "(II)Z", (void*) android_net_wifi_resetHotlist},
1192    { "trackSignificantWifiChangeNative", "(IILandroid/net/wifi/WifiScanner$WifiChangeSettings;)Z",
1193            (void*) android_net_wifi_trackSignificantWifiChange},
1194    { "untrackSignificantWifiChangeNative", "(II)Z",
1195            (void*) android_net_wifi_untrackSignificantWifiChange},
1196    { "getWifiLinkLayerStatsNative", "(I)Landroid/net/wifi/WifiLinkLayerStats;",
1197            (void*) android_net_wifi_getLinkLayerStats},
1198    { "getSupportedFeatureSetNative", "(I)I",
1199            (void*) android_net_wifi_getSupportedFeatures},
1200    { "requestRangeNative", "(II[Landroid/net/wifi/RttManager$RttParams;)Z",
1201            (void*) android_net_wifi_requestRange},
1202    { "cancelRangeRequestNative", "(II[Landroid/net/wifi/RttManager$RttParams;)Z",
1203            (void*) android_net_wifi_cancelRange},
1204    { "setScanningMacOuiNative", "(I[B)Z",  (void*) android_net_wifi_setScanningMacOui},
1205    { "getChannelsForBandNative", "(II)[I", (void*) android_net_wifi_getValidChannels},
1206    { "setDfsFlagNative",         "(IZ)Z",  (void*) android_net_wifi_setDfsFlag},
1207    { "toggleInterfaceNative",    "(I)Z",  (void*) android_net_wifi_toggle_interface}
1208};
1209
1210int register_android_net_wifi_WifiNative(JNIEnv* env) {
1211    return AndroidRuntime::registerNativeMethods(env,
1212            "com/android/server/wifi/WifiNative", gWifiMethods, NELEM(gWifiMethods));
1213}
1214
1215
1216/* User to register native functions */
1217extern "C"
1218jint Java_com_android_server_wifi_WifiNative_registerNatives(JNIEnv* env, jclass clazz) {
1219    return AndroidRuntime::registerNativeMethods(env,
1220            "com/android/server/wifi/WifiNative", gWifiMethods, NELEM(gWifiMethods));
1221}
1222
1223}; // namespace android
1224