Merge tag 'android-6.0.1_r22' of https://android.googlesource.com/platform/frameworks/opt/net/wifi into dr15staging/cm-13.0+r22

Android 6.0.1 release 22

Change-Id: I3feacc91c693dba8f11bdc6513f204c9d47f2d18

1 files changed, 119 insertions, 9 deletions

diff --git a/service/java/com/android/server/wifi/WifiNative.java b/service/java/com/android/server/wifi/WifiNative.java
index 14af922d8..84c659dcc 100644
--- a/service/java/com/android/server/wifi/WifiNative.java
+++ b/service/java/com/android/server/wifi/WifiNative.java
@@ -35,7 +35,11 @@ import android.text.TextUtils;
 import android.util.Base64;
 import android.util.LocalLog;
 import android.util.Log;
-
+import android.content.Context;
+import android.content.Intent;
+import android.app.PendingIntent;
+import android.content.IntentFilter;
+import android.content.BroadcastReceiver;
 import com.android.server.connectivity.KeepalivePacketData;
 
 import java.io.ByteArrayOutputStream;
@@ -50,6 +54,7 @@ import java.util.List;
 import java.util.Locale;
 import java.util.zip.Deflater;
 import libcore.util.HexEncoding;
+import android.app.AlarmManager;
 /**
  * Native calls for bring up/shut down of the supplicant daemon and for
  * sending requests to the supplicant daemon
@@ -123,9 +128,18 @@ public class WifiNative {
 
     private native String doStringCommandNative(String command);
 
-    public WifiNative(String interfaceName) {
+    private final Context mContext;
+    private final PnoMonitor mPnoMonitor;
+    public WifiNative(String interfaceName, Context context) {
         mInterfaceName = interfaceName;
+        mContext = context;
         mTAG = "WifiNative-" + interfaceName;
+        if (mContext != null) {
+            mPnoMonitor = new PnoMonitor();
+        } else {
+            mPnoMonitor = null;
+        }
+
         if (!interfaceName.equals("p2p0")) {
             mInterfacePrefix = "IFNAME=" + interfaceName + " ";
         } else {
@@ -134,6 +148,10 @@ public class WifiNative {
         }
     }
 
+    public WifiNative(String interfaceName) {
+        this(interfaceName, null);
+    }
+
     void enableVerboseLogging(int verbose) {
         if (verbose > 0) {
             DBG = true;
@@ -656,14 +674,91 @@ public class WifiNative {
             return doBooleanCommand("DRIVER COUNTRY");
     }
 
+    //PNO Monitor
+    private class PnoMonitor {
+        private static final int MINIMUM_PNO_GAP = 5 * 1000;
+        private static final String ACTION_TOGGLE_PNO =
+            "com.android.server.Wifi.action.TOGGLE_PNO";
+        long mLastPnoChangeTimeStamp = -1L;
+        boolean mExpectedPnoState = false;
+        boolean mCurrentPnoState = false;;
+        boolean mWaitForTimer = false;
+        final Object mPnoLock = new Object();
+        private final AlarmManager mAlarmManager =
+                (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);
+        private final PendingIntent mPnoIntent;
+
+        public PnoMonitor() {
+            Intent intent = new Intent(ACTION_TOGGLE_PNO, null);
+            intent.setPackage("android");
+            mPnoIntent = PendingIntent.getBroadcast(mContext, 0, intent, 0);
+
+            mContext.registerReceiver(
+                new BroadcastReceiver() {
+                    @Override
+                    public void onReceive(Context context, Intent intent) {
+                        synchronized(mPnoLock) {
+                            if (DBG) Log.d(mTAG, "PNO timer expire, PNO should change to " +
+                                    mExpectedPnoState);
+                            if (mCurrentPnoState != mExpectedPnoState) {
+                                if (DBG) Log.d(mTAG, "change PNO from " + mCurrentPnoState + " to "
+                                        + mExpectedPnoState);
+                                boolean ret = setPno(mExpectedPnoState);
+                                if (!ret) {
+                                    Log.e(mTAG, "set PNO failure");
+                                }
+                            } else {
+                                if (DBG) Log.d(mTAG, "Do not change PNO since current is expected");
+                            }
+                            mWaitForTimer = false;
+                        }
+                    }
+                },
+                new IntentFilter(ACTION_TOGGLE_PNO));
+        }
+
+        private boolean setPno(boolean enable) {
+            String cmd = enable ? "SET pno 1" : "SET pno 0";
+            boolean ret = doBooleanCommand(cmd);
+            mLastPnoChangeTimeStamp = System.currentTimeMillis();
+            if (ret) {
+                mCurrentPnoState = enable;
+            }
+            return ret;
+        }
+
+        public boolean enableBackgroundScan(boolean enable) {
+            synchronized(mPnoLock) {
+                if (mWaitForTimer) {
+                    //already has a timer
+                    mExpectedPnoState = enable;
+                    if (DBG) Log.d(mTAG, "update expected PNO to " +  mExpectedPnoState);
+                } else {
+                    if (mCurrentPnoState == enable) {
+                        return true;
+                    }
+                    long timeDifference = System.currentTimeMillis() - mLastPnoChangeTimeStamp;
+                    if (timeDifference >= MINIMUM_PNO_GAP) {
+                        return setPno(enable);
+                    } else {
+                        mExpectedPnoState = enable;
+                        mWaitForTimer = true;
+                        if (DBG) Log.d(mTAG, "start PNO timer with delay:" + timeDifference);
+                        mAlarmManager.set(AlarmManager.RTC_WAKEUP,
+                                System.currentTimeMillis() + timeDifference, mPnoIntent);
+                    }
+                }
+                return true;
+            }
+        }
+    }
+
     public boolean enableBackgroundScan(boolean enable) {
-        boolean ret;
-        if (enable) {
-            ret = doBooleanCommand("SET pno 1");
+        if (mPnoMonitor != null) {
+            return mPnoMonitor.enableBackgroundScan(enable);
         } else {
-            ret = doBooleanCommand("SET pno 0");
+            return false;
         }
-        return ret;
     }
 
     public void enableAutoConnect(boolean enable) {
@@ -781,6 +876,16 @@ public class WifiNative {
         }
     }
 
+    public boolean simAuthFailedResponse(int id) {
+        // should be used with type GSM-AUTH
+        return doBooleanCommand("CTRL-RSP-SIM-" + id + ":GSM-FAIL");
+    }
+
+    public boolean umtsAuthFailedResponse(int id) {
+        // should be used with type UMTS-AUTH
+        return doBooleanCommand("CTRL-RSP-SIM-" + id + ":UMTS-FAIL");
+    }
+
     public boolean simIdentityResponse(int id, String response) {
         synchronized (mLock) {
             return doBooleanCommand("CTRL-RSP-IDENTITY-" + id + ":" + response);
@@ -1673,10 +1778,15 @@ public class WifiNative {
 
     synchronized public static WifiScanner.ScanData[] getScanResults(boolean flush) {
         synchronized (mLock) {
+            WifiScanner.ScanData[] sd = null;
             if (isHalStarted()) {
-                return getScanResultsNative(sWlan0Index, flush);
+                sd = getScanResultsNative(sWlan0Index, flush);
+            }
+
+            if (sd != null) {
+                return sd;
             } else {
-                return null;
+                return new WifiScanner.ScanData[0];
             }
         }
     }