1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
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;
}
}
}
|
