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
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
|
/*
* Copyright (C) 2006 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 android.net;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import java.util.HashMap;
import java.util.Iterator;
/**
* A wrapper for a broadcast receiver that provides network connectivity
* state information, independent of network type (mobile, Wi-Fi, etc.).
* {@hide}
*/
public class NetworkConnectivityListener {
private static final String TAG = "NetworkConnectivityListener";
private static final boolean DBG = false;
private Context mContext;
private HashMap<Handler, Integer> mHandlers = new HashMap<Handler, Integer>();
private State mState;
private boolean mListening;
private String mReason;
private boolean mIsFailover;
/** Network connectivity information */
private NetworkInfo mNetworkInfo;
/**
* In case of a Disconnect, the connectivity manager may have
* already established, or may be attempting to establish, connectivity
* with another network. If so, {@code mOtherNetworkInfo} will be non-null.
*/
private NetworkInfo mOtherNetworkInfo;
private ConnectivityBroadcastReceiver mReceiver;
private class ConnectivityBroadcastReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (!action.equals(ConnectivityManager.CONNECTIVITY_ACTION) ||
mListening == false) {
Log.w(TAG, "onReceived() called with " + mState.toString() + " and " + intent);
return;
}
boolean noConnectivity =
intent.getBooleanExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, false);
if (noConnectivity) {
mState = State.NOT_CONNECTED;
} else {
mState = State.CONNECTED;
}
mNetworkInfo = (NetworkInfo)
intent.getParcelableExtra(ConnectivityManager.EXTRA_NETWORK_INFO);
mOtherNetworkInfo = (NetworkInfo)
intent.getParcelableExtra(ConnectivityManager.EXTRA_OTHER_NETWORK_INFO);
mReason = intent.getStringExtra(ConnectivityManager.EXTRA_REASON);
mIsFailover =
intent.getBooleanExtra(ConnectivityManager.EXTRA_IS_FAILOVER, false);
if (DBG) {
Log.d(TAG, "onReceive(): mNetworkInfo=" + mNetworkInfo + " mOtherNetworkInfo = "
+ (mOtherNetworkInfo == null ? "[none]" : mOtherNetworkInfo +
" noConn=" + noConnectivity) + " mState=" + mState.toString());
}
// Notifiy any handlers.
Iterator<Handler> it = mHandlers.keySet().iterator();
while (it.hasNext()) {
Handler target = it.next();
Message message = Message.obtain(target, mHandlers.get(target));
target.sendMessage(message);
}
}
};
public enum State {
UNKNOWN,
/** This state is returned if there is connectivity to any network **/
CONNECTED,
/**
* This state is returned if there is no connectivity to any network. This is set
* to true under two circumstances:
* <ul>
* <li>When connectivity is lost to one network, and there is no other available
* network to attempt to switch to.</li>
* <li>When connectivity is lost to one network, and the attempt to switch to
* another network fails.</li>
*/
NOT_CONNECTED
}
/**
* Create a new NetworkConnectivityListener.
*/
public NetworkConnectivityListener() {
mState = State.UNKNOWN;
mReceiver = new ConnectivityBroadcastReceiver();
}
/**
* This method starts listening for network connectivity state changes.
* @param context
*/
public synchronized void startListening(Context context) {
if (!mListening) {
mContext = context;
IntentFilter filter = new IntentFilter();
filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
context.registerReceiver(mReceiver, filter);
mListening = true;
}
}
/**
* This method stops this class from listening for network changes.
*/
public synchronized void stopListening() {
if (mListening) {
mContext.unregisterReceiver(mReceiver);
mContext = null;
mNetworkInfo = null;
mOtherNetworkInfo = null;
mIsFailover = false;
mReason = null;
mListening = false;
}
}
/**
* This methods registers a Handler to be called back onto with the specified what code when
* the network connectivity state changes.
*
* @param target The target handler.
* @param what The what code to be used when posting a message to the handler.
*/
public void registerHandler(Handler target, int what) {
mHandlers.put(target, what);
}
/**
* This methods unregisters the specified Handler.
* @param target
*/
public void unregisterHandler(Handler target) {
mHandlers.remove(target);
}
public State getState() {
return mState;
}
/**
* Return the NetworkInfo associated with the most recent connectivity event.
* @return {@code NetworkInfo} for the network that had the most recent connectivity event.
*/
public NetworkInfo getNetworkInfo() {
return mNetworkInfo;
}
/**
* If the most recent connectivity event was a DISCONNECT, return
* any information supplied in the broadcast about an alternate
* network that might be available. If this returns a non-null
* value, then another broadcast should follow shortly indicating
* whether connection to the other network succeeded.
*
* @return NetworkInfo
*/
public NetworkInfo getOtherNetworkInfo() {
return mOtherNetworkInfo;
}
/**
* Returns true if the most recent event was for an attempt to switch over to
* a new network following loss of connectivity on another network.
* @return {@code true} if this was a failover attempt, {@code false} otherwise.
*/
public boolean isFailover() {
return mIsFailover;
}
/**
* An optional reason for the connectivity state change may have been supplied.
* This returns it.
* @return the reason for the state change, if available, or {@code null}
* otherwise.
*/
public String getReason() {
return mReason;
}
}
|
