1 files changed, 181 insertions, 0 deletions
diff --git a/v1/src/main/java/com/xtremelabs/robolectric/shadows/ShadowWifiManager.java b/v1/src/main/java/com/xtremelabs/robolectric/shadows/ShadowWifiManager.java
new file mode 100644
index 000000000..95fbdde53
--- /dev/null
+++ b/v1/src/main/java/com/xtremelabs/robolectric/shadows/ShadowWifiManager.java
@@ -0,0 +1,181 @@
+package com.xtremelabs.robolectric.shadows;
+
+import android.net.wifi.ScanResult;
+import android.net.wifi.WifiConfiguration;
+import android.net.wifi.WifiInfo;
+import android.net.wifi.WifiManager;
+import android.util.Pair;
+import com.xtremelabs.robolectric.Robolectric;
+import com.xtremelabs.robolectric.internal.Implementation;
+import com.xtremelabs.robolectric.internal.Implements;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import static com.xtremelabs.robolectric.Robolectric.shadowOf;
+
+@SuppressWarnings({"UnusedDeclaration"})
+@Implements(WifiManager.class)
+public class ShadowWifiManager {
+    private static float sSignalLevelInPercent=1f;
+    private boolean accessWifiStatePermission = true;
+    private boolean wifiEnabled = true;
+    private WifiInfo wifiInfo;
+    private List<ScanResult> scanResults;
+    private Map<Integer, WifiConfiguration> networkIdToConfiguredNetworks = new LinkedHashMap<Integer, WifiConfiguration>();
+    public boolean wasSaved;
+    private Pair<Integer, Boolean> lastEnabledNetwork;
+
+    @Implementation
+    public boolean setWifiEnabled(boolean wifiEnabled) {
+        checkAccessWifiStatePermission();
+        this.wifiEnabled = wifiEnabled;
+        return true;
+    }
+
+    @Implementation
+    public boolean isWifiEnabled() {
+        checkAccessWifiStatePermission();
+        return wifiEnabled;
+    }
+
+    @Implementation
+    public WifiInfo getConnectionInfo() {
+        checkAccessWifiStatePermission();
+        if (wifiInfo == null) {
+            wifiInfo = Robolectric.newInstanceOf(WifiInfo.class);
+        }
+        return wifiInfo;
+    }
+
+    @Implementation
+    public List<ScanResult> getScanResults() {
+        return scanResults;
+    }
+
+    @Implementation
+    public List<WifiConfiguration> getConfiguredNetworks() {
+        final ArrayList<WifiConfiguration> wifiConfigurations = new ArrayList<WifiConfiguration>();
+        for (WifiConfiguration wifiConfiguration : networkIdToConfiguredNetworks.values()) {
+            wifiConfigurations.add(wifiConfiguration);
+        }
+        return wifiConfigurations;
+    }
+
+    @Implementation
+    public int addNetwork(WifiConfiguration config) {
+        int networkId = networkIdToConfiguredNetworks.size();
+        config.networkId = -1;
+        networkIdToConfiguredNetworks.put(networkId, makeCopy(config, networkId));
+        return networkId;
+    }
+
+    private WifiConfiguration makeCopy(WifiConfiguration config, int networkId) {
+        WifiConfiguration copy = shadowOf(config).copy();
+        copy.networkId = networkId;
+        return copy;
+    }
+
+
+    @Implementation
+    public int updateNetwork(WifiConfiguration config) {
+        if (config == null || config.networkId < 0) {
+            return -1;
+        }
+        networkIdToConfiguredNetworks.put(config.networkId, makeCopy(config, config.networkId));
+        return config.networkId;
+    }
+
+    @Implementation
+    public boolean saveConfiguration() {
+        wasSaved = true;
+        return true;
+    }
+
+    @Implementation
+    public boolean enableNetwork(int netId, boolean disableOthers) {
+        lastEnabledNetwork = new Pair<Integer, Boolean>(netId, disableOthers);
+        return true;
+    }
+
+    @Implementation
+    public WifiManager.WifiLock createWifiLock(int lockType, java.lang.String tag) {
+        return Robolectric.newInstanceOf(WifiManager.WifiLock.class);
+    }
+
+    @Implementation
+    public WifiManager.WifiLock createWifiLock(java.lang.String tag) {
+        return createWifiLock(WifiManager.WIFI_MODE_FULL, tag);
+    }
+    
+    @Implementation
+    public static int calculateSignalLevel (int rssi, int numLevels)
+    {
+        return (int)(sSignalLevelInPercent*(numLevels-1));
+    }
+    
+    public static void setSignalLevelInPercent(float level) {
+        if (level < 0 || level > 1) {
+            throw new IllegalArgumentException(
+                    "level needs to be between 0 and 1");
+        }
+        sSignalLevelInPercent = level;
+    }
+
+    public void setAccessWifiStatePermission(boolean accessWifiStatePermission) {
+        this.accessWifiStatePermission = accessWifiStatePermission;
+    }
+
+    private void checkAccessWifiStatePermission() {
+        if (!accessWifiStatePermission) {
+            throw new SecurityException();
+        }
+    }
+
+    public void setScanResults(List<ScanResult> scanResults) {
+        this.scanResults = scanResults;
+    }
+
+    public Pair<Integer, Boolean> getLastEnabledNetwork() {
+        return lastEnabledNetwork;
+    }
+
+
+    @Implements(WifiManager.WifiLock.class)
+    public static class ShadowWifiLock {
+        private int refCount;
+        private boolean refCounted = true;
+        private boolean locked;
+        public static final int MAX_ACTIVE_LOCKS = 50;
+
+        @Implementation
+        public synchronized void acquire() {
+            if (refCounted) {
+                if (++refCount >= MAX_ACTIVE_LOCKS) throw new UnsupportedOperationException("Exceeded maximum number of wifi locks");
+            } else {
+                locked = true;
+            }
+        }
+
+        @Implementation
+        public synchronized void release() {
+            if (refCounted) {
+                if (--refCount < 0) throw new RuntimeException("WifiLock under-locked");
+            } else {
+                locked = false;
+            }
+        }
+
+        @Implementation
+        public synchronized boolean isHeld() {
+            return refCounted ? refCount > 0 : locked;
+        }
+
+        @Implementation
+        public void setReferenceCounted(boolean refCounted) {
+            this.refCounted = refCounted;
+        }
+    }
+}