/**
* http://developer.android.com/training/monitoring-device-state/connectivity-monitoring.html
* http://developer.android.com/training/basics/network-ops/managing.html
*
* @param context
* @return
*/
public static boolean isNetworkAvailable(final Context context, final boolean mobile) {
boolean available = false;
try {
final ConnectivityManager connectivitymanager =
(ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
final NetworkInfo networkinfo = connectivitymanager.getActiveNetworkInfo();
if ((networkinfo != null) && networkinfo.isConnectedOrConnecting()) {
switch (networkinfo.getType()) {
case ConnectivityManager.TYPE_WIFI:
case ConnectivityManager.TYPE_WIMAX:
case ConnectivityManager.TYPE_ETHERNET:
available = true;
break;
case ConnectivityManager.TYPE_MOBILE:
if (mobile) {
available = true;
}
break;
}
}
} catch (Throwable x) {
DBG.m(x);
}
return available;
}
/**
* Record the roaming status of the device, and if it is a change from the previous status, send a
* notification to any listeners.
*
* @param isRoaming {@code true} if the device is now roaming, {@code false} if it is no longer
* roaming.
*/
protected void setRoamingStatus(boolean isRoaming) {
if (isRoaming != mNetworkInfo.isRoaming()) {
mNetworkInfo.setRoaming(isRoaming);
Message msg = mTarget.obtainMessage(EVENT_ROAMING_CHANGED, mNetworkInfo);
msg.sendToTarget();
}
}
public NetworkInfo getNetworkInfo() {
if (FeatureOption.MTK_GEMINI_SUPPORT) {
getPhoneService(true);
/*
* If the phone process has crashed in the past, we'll get a
* RemoteException and need to re-reference the service.
*/
for (int retry = 0; retry < 2; retry++) {
if (mPhoneService == null) {
loge("Ignoring feature request because could not acquire PhoneService");
break;
}
try {
/**
* M: update availabe info due to it may not correct when we received from
* ACTION_ANY_DATA_CONNECTION_STATE_CHANGED
*/
mNetworkInfo.setIsAvailable(mPhoneService.isDataConnectivityPossible());
log("getNetworkInfo: updated IsAvailable=" + mNetworkInfo.isAvailable());
} catch (RemoteException e) {
if (retry == 0) getPhoneService(true);
}
}
}
return mNetworkInfo;
}
/**
* Re-enable mobile data connectivity after a {@link #teardown()}.
*
* @param radioNum 0:sim1, 1:sim2
*/
public boolean reconnectGemini(int radioNum) {
boolean retValue = false; // false: failed, true: network is connecting or connected
// reset teardown flag
setTeardownRequested(false);
switch (setEnableApnGemini(mApnType, true, radioNum)) {
case PhoneConstants.APN_ALREADY_ACTIVE:
// need to set self to CONNECTING so the below message is handled.
// TODO: need to notify the app
retValue = true;
break;
case PhoneConstants.APN_REQUEST_STARTED:
// set IDLE here , avoid the following second FAILED not sent out
if (!mNetworkInfo.isConnectedOrConnecting()) {
mNetworkInfo.setDetailedState(DetailedState.IDLE, null, null);
}
retValue = true;
break;
case PhoneConstants.APN_REQUEST_FAILED:
case PhoneConstants.APN_TYPE_NOT_AVAILABLE:
break;
default:
loge("Error in reconnect - unexpected response.");
break;
}
return retValue;
}
protected void setSubtype(int subtype, String subtypeName) {
if (mNetworkInfo.isConnected()) {
int oldSubtype = mNetworkInfo.getSubtype();
if (subtype != oldSubtype) {
mNetworkInfo.setSubtype(subtype, subtypeName);
Message msg =
mTarget.obtainMessage(EVENT_NETWORK_SUBTYPE_CHANGED, oldSubtype, 0, mNetworkInfo);
msg.sendToTarget();
}
}
}
public static boolean netIsAvailable(Context context) {
NetworkInfo netInfo;
ConnectivityManager connMgr =
(ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
netInfo = connMgr.getActiveNetworkInfo();
if (netInfo == null) {
return false;
}
return netInfo.isConnected();
}
@RequestMapping(
value = "/network",
produces = {MediaType.APPLICATION_JSON_VALUE})
public NetworkInfo checkNetworkAccess(
@RequestParam(value = "targetIp") String pingIp,
@RequestParam(value = "targetUrl") String pingUrl) {
LOGGER.info("pingIp: {} - pingUrl: {}", pingIp, pingUrl);
NetworkInfo networkInfo =
new NetworkInfoBuilder().setPingIp(pingIp).setUrlPing(pingUrl).build();
return networkInfo.status();
}
private EthernetDataTracker() {
mNetworkInfo = new NetworkInfo(ConnectivityManager.TYPE_ETHERNET, 0, NETWORKTYPE, "");
mLinkProperties = new LinkProperties();
mLinkCapabilities = new LinkCapabilities();
mLinkUp = false;
mNetworkInfo.setIsAvailable(false);
setTeardownRequested(false);
}
private void interfaceRemoved(String iface) {
if (!iface.equals(mIface)) return;
Log.d(TAG, "Removing " + iface);
NetworkUtils.stopDhcp(mIface);
mLinkProperties.clear();
mNetworkInfo.setIsAvailable(false);
mNetworkInfo.setDetailedState(DetailedState.DISCONNECTED, null, null);
Message msg = mCsHandler.obtainMessage(EVENT_CONFIGURATION_CHANGED, mNetworkInfo);
msg.sendToTarget();
msg = mCsHandler.obtainMessage(EVENT_STATE_CHANGED, mNetworkInfo);
msg.sendToTarget();
mIface = "";
}
/**
* Record the detailed state of a network, and if it is a change from the previous state, send a
* notification to any listeners.
*
* @param state the new @{code DetailedState}
* @param reason a {@code String} indicating a reason for the state change, if one was supplied.
* May be {@code null}.
* @param extraInfo optional {@code String} providing extra information about the state change
*/
private void setDetailedState(NetworkInfo.DetailedState state, String reason, String extraInfo) {
if (DBG)
log("setDetailed state, old =" + mNetworkInfo.getDetailedState() + " and new state=" + state);
if (state != mNetworkInfo.getDetailedState()) {
boolean wasConnecting = (mNetworkInfo.getState() == NetworkInfo.State.CONNECTING);
String lastReason = mNetworkInfo.getReason();
/*
* If a reason was supplied when the CONNECTING state was entered, and no
* reason was supplied for entering the CONNECTED state, then retain the
* reason that was supplied when going to CONNECTING.
*/
if (wasConnecting
&& state == NetworkInfo.DetailedState.CONNECTED
&& reason == null
&& lastReason != null) reason = lastReason;
mNetworkInfo.setDetailedState(state, reason, extraInfo);
Message msg = mTarget.obtainMessage(EVENT_STATE_CHANGED, new NetworkInfo(mNetworkInfo));
msg.sendToTarget();
}
}
public void removeDefaultRoute() {
if (mInterfaceName != null && mDefaultRouteSet == true) {
if (DBG) {
Log.d(
TAG,
"removeDefaultRoute for " + mNetworkInfo.getTypeName() + " (" + mInterfaceName + ")");
}
NetworkUtils.removeDefaultRoute(mInterfaceName);
mDefaultRouteSet = false;
}
}
/**
* Record the detailed state of a network, and if it is a change from the previous state, send a
* notification to any listeners.
*
* @param state the new @{code DetailedState}
* @param reason a {@code String} indicating a reason for the state change, if one was supplied.
* May be {@code null}.
* @param extraInfo optional {@code String} providing extra information about the state change
* @param simId 0 for sim1 and 1 for sim2
*/
public void setDetailedStateGemini(
NetworkInfo.DetailedState state, String reason, String extraInfo, int simId) {
if (DBG)
log(
"setDetailed state, old ="
+ mNetworkInfo.getDetailedState()
+ " and new state="
+ state
+ " simId is "
+ simId);
if (state != mNetworkInfo.getDetailedState()) {
boolean wasConnecting = (mNetworkInfo.getState() == NetworkInfo.State.CONNECTING);
String lastReason = mNetworkInfo.getReason();
/*
* If a reason was supplied when the CONNECTING state was entered, and no
* reason was supplied for entering the CONNECTED state, then retain the
* reason that was supplied when going to CONNECTING.
*/
if (wasConnecting
&& state == NetworkInfo.DetailedState.CONNECTED
&& reason == null
&& lastReason != null) reason = lastReason;
mNetworkInfo.setDetailedStateGemini(state, reason, extraInfo, simId);
Message msg = mTarget.obtainMessage(EVENT_STATE_CHANGED, mNetworkInfo);
msg.sendToTarget();
} else if (reason != null
&& (reason.equals(PhoneConstants.REASON_NO_SUCH_PDP)
|| reason.equals(Phone.REASON_APN_FAILED))
&& state == DetailedState.DISCONNECTED) {
mNetworkInfo.setDetailedStateGemini(state, reason, extraInfo, simId);
Message msg = mTarget.obtainMessage(EVENT_STATE_CHANGED, mNetworkInfo);
msg.sendToTarget();
}
}
private void interfaceAdded(String iface) {
if (!iface.matches(sIfaceMatch)) return;
Log.d(TAG, "Adding " + iface);
synchronized (mIface) {
if (!mIface.isEmpty()) return;
mIface = iface;
}
mNetworkInfo.setIsAvailable(true);
Message msg = mCsHandler.obtainMessage(EVENT_CONFIGURATION_CHANGED, mNetworkInfo);
msg.sendToTarget();
runDhcp();
}
public void addDefaultRoute() {
if ((mInterfaceName != null) && (mDefaultGatewayAddr != 0) && mDefaultRouteSet == false) {
if (DBG) {
Log.d(
TAG,
"addDefaultRoute for "
+ mNetworkInfo.getTypeName()
+ " ("
+ mInterfaceName
+ "), GatewayAddr="
+ mDefaultGatewayAddr);
}
NetworkUtils.setDefaultRoute(mInterfaceName, mDefaultGatewayAddr);
mDefaultRouteSet = true;
}
}
public void removePrivateDnsRoutes() {
// TODO - we should do this explicitly but the NetUtils api doesnt
// support this yet - must remove all. No worse than before
if (mInterfaceName != null && mPrivateDnsRouteSet) {
if (DBG) {
Log.d(
TAG,
"removePrivateDnsRoutes for "
+ mNetworkInfo.getTypeName()
+ " ("
+ mInterfaceName
+ ")");
}
NetworkUtils.removeHostRoutes(mInterfaceName);
mPrivateDnsRouteSet = false;
}
}
/**
* Re-enable mobile data connectivity after a {@link #teardown()}. TODO - make async and always
* get a notification?
*/
public boolean reconnect() {
boolean retValue = false; // connected or expect to be?
setTeardownRequested(false);
switch (setEnableApn(mApnType, true)) {
case Phone.APN_ALREADY_ACTIVE:
// need to set self to CONNECTING so the below message is handled.
retValue = true;
break;
case Phone.APN_REQUEST_STARTED:
// set IDLE here , avoid the following second FAILED not sent out
mNetworkInfo.setDetailedState(DetailedState.IDLE, null, null);
retValue = true;
break;
case Phone.APN_REQUEST_FAILED:
case Phone.APN_TYPE_NOT_AVAILABLE:
break;
default:
loge("Error in reconnect - unexpected response.");
break;
}
return retValue;
}
/** Return the system properties name associated with the tcp buffer sizes for this network. */
public String getTcpBufferSizesPropName() {
int netType;
String networkTypeStr = "unknown";
TelephonyManager tm = new TelephonyManager(mContext);
// TODO We have to edit the parameter for getNetworkType regarding CDMA
if (FeatureOption.MTK_GEMINI_SUPPORT != true) {
netType = tm.getNetworkType();
} else {
netType = tm.getNetworkTypeGemini(mNetworkInfo.getSimId());
}
// TODO We have to edit the parameter for getNetworkType regarding CDMA
switch (netType) {
case TelephonyManager.NETWORK_TYPE_GPRS:
networkTypeStr = "gprs";
break;
case TelephonyManager.NETWORK_TYPE_EDGE:
networkTypeStr = "edge";
break;
case TelephonyManager.NETWORK_TYPE_UMTS:
networkTypeStr = "umts";
break;
case TelephonyManager.NETWORK_TYPE_HSDPA:
networkTypeStr = "hsdpa";
break;
case TelephonyManager.NETWORK_TYPE_HSUPA:
networkTypeStr = "hsupa";
break;
case TelephonyManager.NETWORK_TYPE_HSPA:
networkTypeStr = "hspa";
break;
case TelephonyManager.NETWORK_TYPE_HSPAP:
networkTypeStr = "hspap";
break;
case TelephonyManager.NETWORK_TYPE_CDMA:
networkTypeStr = "cdma";
break;
case TelephonyManager.NETWORK_TYPE_1xRTT:
networkTypeStr = "1xrtt";
break;
case TelephonyManager.NETWORK_TYPE_EVDO_0:
networkTypeStr = "evdo";
break;
case TelephonyManager.NETWORK_TYPE_EVDO_A:
networkTypeStr = "evdo";
break;
case TelephonyManager.NETWORK_TYPE_EVDO_B:
networkTypeStr = "evdo";
break;
case TelephonyManager.NETWORK_TYPE_IDEN:
networkTypeStr = "iden";
break;
case TelephonyManager.NETWORK_TYPE_LTE:
networkTypeStr = "lte";
break;
case TelephonyManager.NETWORK_TYPE_EHRPD:
networkTypeStr = "ehrpd";
break;
default:
loge("unknown network type: " + tm.getNetworkType());
}
return "net.tcp.buffersize." + networkTypeStr;
}
/** Report whether data connectivity is possible. */
public boolean isAvailable() {
return mNetworkInfo.isAvailable();
}
public void run() {
int i,
j,
storedValues,
sleepTime = 3000,
timeoutCtr = 0,
lastFlags = -1,
trackCnt = 0,
lastLocMethod = -5;
String bssid;
WMapEntry currEntry;
DataOutputStream out;
FileInputStream in;
while (running) {
try {
if (scanData.getNoGPSExitInterval() > 0) {
if (System.currentTimeMillis() > lastGPSTime + scanData.getNoGPSExitInterval()) {
break;
}
}
if (ScanService.scanData.getThreadMode() == OWMapAtAndroid.THREAD_MODE_UPLOAD) {
if ((m_uploadThread != null) && (m_uploadThread.isUploading()))
OWMapAtAndroid.sendMessage(
ScannerHandler.MSG_SIMPLE_ALERT,
0,
0,
getResources().getText(R.string.upload_in_progress));
else m_uploadThread = new UploadThread(scanData, this, SP, false, notification, null);
ScanService.scanData.setThreadMode(OWMapAtAndroid.THREAD_MODE_SCAN);
} else {
if ((posState == 0) && (scanData != null) && (scanData.isScanningEnabled())) {
posState = 1;
timeoutCtr = 0;
if (scanData.getFlags() != lastFlags) {
if ((scanData.getFlags() & OWMapAtAndroid.FLAG_NO_NET_ACCESS) == 0)
scanData.getWifiManager().createWifiLock(WifiManager.WIFI_MODE_FULL, "OpenWLANMap");
else
scanData
.getWifiManager()
.createWifiLock(WifiManager.WIFI_MODE_SCAN_ONLY, "OpenWLANMap");
lastFlags = scanData.getFlags();
}
if ((scanData.getFlags() & OWMapAtAndroid.FLAG_NO_NET_ACCESS) == 0)
myWLocate.wloc_request_position(WLocate.FLAG_NO_IP_LOCATION);
else {
myWLocate.wloc_request_position(
WLocate.FLAG_NO_NET_ACCESS | WLocate.FLAG_NO_IP_LOCATION);
// stopGoogleLocation();
}
} else if (!scanData.isScanningEnabled()) {
try {
trackCnt += 1500;
Thread.sleep(1500);
} catch (InterruptedException ie) {
}
}
if (posState == 1) {
// sleep while waiting for result
try {
trackCnt += 2500;
java.lang.Thread.sleep(2500); // is interrupted from result handler
timeoutCtr++;
if (timeoutCtr > 3) {
timeoutCtr = 0;
posState = 0;
}
} catch (InterruptedException ie) {
}
}
if ((posState == 2) || (posState == 100)) {
loc_info locationInfo;
NetworkInfo mWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
locationInfo = myWLocate.last_location_info();
if (lastLocMethod != locationInfo.lastLocMethod) {
scanData.getmView().setMode(locationInfo.lastLocMethod);
scanData.getmView().postInvalidate();
lastLocMethod = locationInfo.lastLocMethod;
}
if (posState == 100) locationInfo.lastLocMethod = -1;
OWMapAtAndroid.sendMessage(
OWMapAtAndroid.ScannerHandler.MSG_UPD_LOC_STATE,
(int) (lastRadius * 1000),
locationInfo.lastLocMethod,
locationInfo);
if (SP.getBoolean("autoConnect", false)) {
if (!mWifi.isConnected()) {
for (i = 0; i < locationInfo.wifiScanResult.size(); i++) {
ScanResult result;
result = locationInfo.wifiScanResult.get(i);
result.capabilities = result.capabilities.toUpperCase(Locale.US);
if ((isFreeHotspot(result) & WMapEntry.FLAG_IS_FREIFUNK) != 0) {
// auto-connect to this open network
WifiConfiguration wifiConfig = new WifiConfiguration();
wifiConfig.BSSID = result.BSSID;
wifiConfig.priority = 1;
wifiConfig.allowedKeyManagement.set(KeyMgmt.NONE);
wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
wifiConfig.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
wifiConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
wifiConfig.status = WifiConfiguration.Status.ENABLED;
int netId = scanData.getWifiManager().addNetwork(wifiConfig);
scanData.getWifiManager().enableNetwork(netId, true);
}
}
}
}
if ((posValid)
&& (locationInfo.wifiScanResult != null)
&& (locationInfo.wifiScanResult.size() > 0)) {
boolean foundExisting;
for (i = 0; i < locationInfo.wifiScanResult.size(); i++) {
ScanResult result;
result = locationInfo.wifiScanResult.get(i);
bssid = result.BSSID.replace(":", "").replace(".", "").toUpperCase(Locale.US);
if (bssid.equalsIgnoreCase("000000000000")) break;
foundExisting = false;
scanData.getLock().lock();
for (j = 0; j < scanData.getWmapList().size(); j++) {
currEntry = scanData.getWmapList().elementAt(j);
if (currEntry.getBSSID().equalsIgnoreCase(bssid)) {
currEntry.setPos(lastLat, lastLon);
foundExisting = true;
break;
}
}
if (!foundExisting) {
String lowerSSID;
storedValues = scanData.incStoredValues();
scanData.getmView().setValue(storedValues);
scanData.getmView().postInvalidate();
currEntry = new WMapEntry(bssid, result.SSID, lastLat, lastLon, storedValues);
lowerSSID = result.SSID.toLowerCase(Locale.US);
if ((lowerSSID.endsWith("_nomap"))
|| // Google unsubscibe option
(lowerSSID.contains("iphone"))
|| // mobile AP
(lowerSSID.contains("android"))
|| // mobile AP
(lowerSSID.contains("motorola"))
|| // mobile AP
(lowerSSID.contains("deinbus.de"))
|| // WLAN network on board of German bus
(lowerSSID.contains("fernbus"))
|| // WLAN network on board of German bus
(lowerSSID.contains("flixbus"))
|| // WLAN network on board of German bus
(lowerSSID.contains("ecolines"))
|| // WLAN network on board of German bus
(lowerSSID.contains("eurolines_wifi"))
|| // WLAN network on board of German bus
(lowerSSID.contains("contiki-wifi"))
|| // WLAN network on board of bus
(lowerSSID.contains("guest@ms "))
|| // WLAN network on Hurtigruten ships
(lowerSSID.contains("admin@ms "))
|| // WLAN network on Hurtigruten ships
(lowerSSID.contains("nsb_interakti"))
|| // WLAN network in NSB trains
(lowerSSID.equals("southwestwifi"))) // WLAN network on Southwest flights
currEntry.setFlags(currEntry.getFlags() | WMapEntry.FLAG_IS_NOMAP);
else currEntry.setFlags(currEntry.getFlags() | isFreeHotspot(result));
if (isFreeHotspot(currEntry.getFlags())) scanData.incFreeHotspotWLANs();
scanData.getWmapList().add(currEntry);
if ((scanData.getUploadThres() > 0)
&& (storedValues > scanData.getUploadThres())) {
if ((m_uploadThread == null) || (!m_uploadThread.isUploading())) {
if (mWifi.isConnected()) {
m_uploadThread =
new UploadThread(scanData, this, SP, true, notification, mWifi);
}
}
}
}
result.capabilities = result.capabilities.toUpperCase(Locale.US);
scanData.getLock().unlock();
}
}
scanData.getLock().lock();
for (j = 0; j < scanData.getWmapList().size(); j++) {
currEntry = scanData.getWmapList().elementAt(j);
if ((currEntry.getLastUpdate() + OWMapAtAndroid.RECV_TIMEOUT
< System.currentTimeMillis())
&& ((currEntry.getFlags() & WMapEntry.FLAG_IS_VISIBLE) == 0)) {
scanData.getWmapList().remove(j);
if (currEntry.posIsValid()) {
int padBytes = 0, k;
try {
in = scanData.getCtx().openFileInput(OWMapAtAndroid.WSCAN_FILE);
padBytes = in.available() % 28;
in.close();
if (padBytes > 0) padBytes = 28 - padBytes;
} catch (IOException ioe) {
ioe.printStackTrace();
}
try {
out =
new DataOutputStream(
scanData
.getCtx()
.openFileOutput(
OWMapAtAndroid.WSCAN_FILE,
Context.MODE_PRIVATE | Context.MODE_APPEND));
if (padBytes > 0) for (k = 0; k < padBytes; k++) out.writeByte(0);
out.write(currEntry.getBSSID().getBytes(), 0, 12);
if ((currEntry.getFlags() & WMapEntry.FLAG_IS_NOMAP) != 0) {
out.writeDouble(0.0);
out.writeDouble(0.0);
} else {
out.writeDouble(currEntry.getLat());
out.writeDouble(currEntry.getLon());
}
out.close();
} catch (IOException ioe) {
ioe.printStackTrace();
}
if ((currEntry.getFlags()
& (WMapEntry.FLAG_IS_FREIFUNK | WMapEntry.FLAG_IS_NOMAP))
== WMapEntry.FLAG_IS_FREIFUNK) {
padBytes = 0;
try {
in = scanData.getCtx().openFileInput(OWMapAtAndroid.WFREI_FILE);
padBytes = in.available() % 12;
in.close();
if (padBytes > 0) padBytes = 12 - padBytes;
} catch (IOException ioe) {
ioe.printStackTrace();
}
try {
out =
new DataOutputStream(
scanData
.getCtx()
.openFileOutput(
OWMapAtAndroid.WFREI_FILE,
Context.MODE_PRIVATE | Context.MODE_APPEND));
if (padBytes > 0) for (k = 0; k < padBytes; k++) out.writeByte(0);
out.write(currEntry.getBSSID().getBytes(), 0, 12);
out.close();
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
}
}
// flushData(false);
}
scanData.getLock().unlock();
m_lastSpeed = locationInfo.lastSpeed;
if (!SP.getBoolean("adaptiveScanning", true)) sleepTime = 500;
else if (locationInfo.lastSpeed > 90) sleepTime = 350;
else if (locationInfo.lastSpeed < 0)
sleepTime = 1300; // no speed information, may be because of WLAN localisation
else if (locationInfo.lastSpeed < 6) sleepTime = 2500; // user seems to walk
else {
double f;
f = 1.0 - (locationInfo.lastSpeed / 90.0);
sleepTime = (int) ((1000.0 * f) + 350);
}
try {
trackCnt += sleepTime;
java.lang.Thread.sleep(sleepTime); // sleep between scans
} catch (InterruptedException ie) {
}
posState = 0;
}
}
} catch (NullPointerException npe) // in case the parent activity dies too fast
{
npe.printStackTrace();
}
if ((trackCnt > 500000) && (lastLat != 0) && (lastLon != 0)) {
if (SP.getBoolean("track", false)) new UploadPositionTask().execute(null, null, null);
trackCnt = 0;
}
}
onDestroy(); // remove all resources (in case the thread was stopped due to some other reason
}
/** @return true - If are we currently tethered with another device. */
public synchronized boolean isAvailable() {
return mNetworkInfo.isAvailable();
}
@RunWith(Enclosed.class)
public class NemesisBlockMainnetTest {
private static final NetworkInfo NETWORK_INFO = NetworkInfos.getMainNetworkInfo();
private static final NemesisBlockInfo NEMESIS_BLOCK_INFO = NETWORK_INFO.getNemesisBlockInfo();
// users, devs, marketing, contributors + funds (transfer + multisig)
private static final int NUM_NEMESIS_TRANSFER_TRANSACTIONS = 1307 + 21 + 5 + 8 + 6;
private static final int NUM_NEMESIS_TRANSACTIONS = NUM_NEMESIS_TRANSFER_TRANSACTIONS + 6;
private static final Amount EXPECTED_MULTISIG_AGGREGATE_FEE =
Amount.fromNem(2 * (5 + 3 * 4) + 2 * (5 + 3 * 5) + 2 * (5 + 3 * 6));
private static final int EXPECTED_VERSION = 0x68000001;
@BeforeClass
public static void initNetwork() {
NetworkInfos.setDefault(NETWORK_INFO);
}
@AfterClass
public static void resetNetwork() {
NetworkInfos.setDefault(null);
}
private abstract static class AbstractNemesisBlockTest {
// basic
@Test
public void nemesisBlockCanBeCreated() {
// Act:
final Block block = this.loadNemesisBlock();
// Assert:
Assert.assertThat(
block.getSigner().getAddress(), IsEqual.equalTo(NEMESIS_BLOCK_INFO.getAddress()));
Assert.assertThat(block.getType(), IsEqual.equalTo(-1));
Assert.assertThat(block.getVersion(), IsEqual.equalTo(EXPECTED_VERSION));
Assert.assertThat(block.getTimeStamp(), IsEqual.equalTo(TimeInstant.ZERO));
// 2 multisig aggregate transactions
Assert.assertThat(
block.getTotalFee(), IsEqual.equalTo(EXPECTED_MULTISIG_AGGREGATE_FEE.multiply(2)));
Assert.assertThat(block.getPreviousBlockHash(), IsEqual.equalTo(Hash.ZERO));
Assert.assertThat(block.getHeight(), IsEqual.equalTo(BlockHeight.ONE));
Assert.assertThat(block.getTransactions().size(), IsEqual.equalTo(NUM_NEMESIS_TRANSACTIONS));
Assert.assertThat(block.getDifficulty(), IsEqual.equalTo(BlockDifficulty.INITIAL_DIFFICULTY));
Assert.assertThat(block.getGenerationHash(), IsNull.notNullValue());
}
@Test
public void nemesisBlockIsVerifiable() {
// Arrange:
final Block block = this.loadNemesisBlock();
// Assert:
Assert.assertThat(block.verify(), IsEqual.equalTo(true));
}
@Test
public void nemesisTransactionsAreVerifiable() {
// Arrange:
final Block block = this.loadNemesisBlock();
// Assert:
for (final Transaction transaction : block.getTransactions()) {
Assert.assertThat(transaction.verify(), IsEqual.equalTo(true));
}
}
@Test
public void nemesisTransactionsHaveCorrectFees() {
// Arrange:
final Block block = this.loadNemesisBlock();
// Assert:
for (final Transaction transaction : block.getTransactions()) {
final Amount expectedFee =
TransactionTypes.TRANSFER == transaction.getType()
? Amount.ZERO
: NemGlobals.getTransactionFeeCalculator().calculateMinimumFee(transaction);
Assert.assertThat(transaction.getFee(), IsEqual.equalTo(expectedFee));
}
}
@Test
public void nemesisAddressesAreValid() {
// Arrange:
final Block block = this.loadNemesisBlock();
// Act:
final Set<Address> allAddresses =
block
.getTransactions()
.stream()
.flatMap(t -> t.getAccounts().stream().map(Account::getAddress))
.collect(Collectors.toSet());
// Assert:
for (final Address address : allAddresses) {
Assert.assertThat(address.toString(), address.isValid(), IsEqual.equalTo(true));
}
}
@Test
public void nemesisTransactionSignersHavePublicKeys() {
// Arrange:
final Block block = this.loadNemesisBlock();
// Act:
final Set<Address> signerAddresses =
block
.getTransactions()
.stream()
.map(t -> t.getSigner().getAddress())
.collect(Collectors.toSet());
// Assert:
for (final Address address : signerAddresses) {
Assert.assertThat(address.getPublicKey(), IsNull.notNullValue());
}
}
// endregion
// region constants
@Test
public void amountConstantIsConsistentWithNemesisBlock() {
// Act:
Amount totalAmount = Amount.ZERO;
final Block block = this.loadNemesisBlock();
for (final Transaction transaction : block.getTransactions()) {
if (transaction instanceof TransferTransaction) {
totalAmount = totalAmount.add(((TransferTransaction) transaction).getAmount());
}
}
// Assert:
Assert.assertThat(totalAmount, IsEqual.equalTo(NEMESIS_BLOCK_INFO.getAmount()));
}
@Test
public void addressConstantIsConsistentWithNemesisBlock() {
// Arrange:
final Block block = this.loadNemesisBlock();
final Address blockAddress = block.getSigner().getAddress();
// Assert:
Assert.assertThat(blockAddress, IsEqual.equalTo(NEMESIS_BLOCK_INFO.getAddress()));
Assert.assertThat(
blockAddress.getPublicKey(),
IsEqual.equalTo(NEMESIS_BLOCK_INFO.getAddress().getPublicKey()));
Assert.assertThat(blockAddress.getPublicKey(), IsNull.notNullValue());
}
@Test
public void generationHashConstantIsConsistentWithNemesisBlock() {
// Arrange:
final Block block = this.loadNemesisBlock();
// Assert:
Assert.assertThat(
block.getGenerationHash(), IsEqual.equalTo(NEMESIS_BLOCK_INFO.getGenerationHash()));
}
// endregion
protected abstract Block loadNemesisBlock(final MockAccountLookup accountLookup);
protected Block loadNemesisBlock() {
return this.loadNemesisBlock(new MockAccountLookup());
}
}
// region basic
public static class ResourceNemesisBlockTest extends AbstractNemesisBlockTest {
@Override
protected Block loadNemesisBlock(final MockAccountLookup accountLookup) {
return NemesisBlock.fromResource(
NEMESIS_BLOCK_INFO, new DeserializationContext(accountLookup));
}
}
public static class BinaryNemesisBlockTest extends AbstractNemesisBlockTest {
@Test
public void nemesisBlockCannotBeLoadedFromBlobWithIncorrectType() {
// Arrange (set type to 1):
final byte[] buffer = loadNemesisBlockBlobObject();
buffer[0] = 1;
buffer[1] = 0;
buffer[2] = 0;
buffer[3] = 0;
// Act:
ExceptionAssert.assertThrows(
v ->
NemesisBlock.fromBlobObject(
NEMESIS_BLOCK_INFO, buffer, new DeserializationContext(new MockAccountLookup())),
IllegalArgumentException.class);
}
@Test
public void nemesisBlockCannotBeLoadedFromInvalidBlob() {
// Arrange:
final byte[] buffer = loadNemesisBlockBlobObject();
final byte[] badBuffer1 =
ByteBuffer.allocate(3 + buffer.length).put("bad".getBytes()).put(buffer).array();
final byte[] badBuffer2 =
ByteBuffer.allocate(3 + buffer.length)
.put(Arrays.copyOfRange(buffer, 0, 100))
.put("bad".getBytes())
.put(Arrays.copyOfRange(buffer, 100, buffer.length))
.array();
// Act:
ExceptionAssert.assertThrows(
v ->
NemesisBlock.fromBlobObject(
NEMESIS_BLOCK_INFO,
badBuffer1,
new DeserializationContext(new MockAccountLookup())),
IllegalArgumentException.class);
ExceptionAssert.assertThrows(
v ->
NemesisBlock.fromBlobObject(
NEMESIS_BLOCK_INFO,
badBuffer2,
new DeserializationContext(new MockAccountLookup())),
SerializationException.class);
}
@Override
protected Block loadNemesisBlock(final MockAccountLookup accountLookup) {
final byte[] blob = loadNemesisBlockBlobObject();
return NemesisBlock.fromBlobObject(
NEMESIS_BLOCK_INFO, blob, new DeserializationContext(accountLookup));
}
private static byte[] loadNemesisBlockBlobObject() {
try (final InputStream fin =
NemesisBlock.class
.getClassLoader()
.getResourceAsStream(NEMESIS_BLOCK_INFO.getDataFileName())) {
return IOUtils.toByteArray(fin);
} catch (final IOException e) {
throw new IllegalStateException(
"unexpected exception was thrown when parsing nemesis block resource");
}
}
}
}
protected void setDetailedStateInternal(NetworkInfo.DetailedState state) {
mNetworkInfo.setDetailedState(state, null, null);
}
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)) {
// UI update to indicate wifi p2p status.
int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);
if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) {
// Wifi Direct mode is enabled
synCarnet.syncService.setIsWifiP2pEnabled(true);
} else {
synCarnet.syncService.setIsWifiP2pEnabled(false);
synCarnet.syncService.setConnected(false);
progressDialog = synCarnet.syncService.getProgressDialog();
if (progressDialog != null && progressDialog.isShowing()) {
progressDialog.dismiss();
}
Toast.makeText(this.synCarnet, synCarnet.getString(R.string.noWifi), Toast.LENGTH_SHORT)
.show();
}
} else if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) {
// request available peers from the wifi p2p manager. This is an
// asynchronous call and the calling activity is notified with a
// callback on PeerListListener.onPeersAvailable()
if (manager != null) {
if (!synCarnet.syncService.isConnected() && synCarnet.syncService.isWifiP2pEnabled())
manager.requestPeers(channel, peerList);
}
} else if (WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION.equals(action)) {
if (manager == null) {
return;
}
NetworkInfo networkInfo =
(NetworkInfo) intent.getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO);
if (networkInfo.isConnected()) {
WifiP2pGroup group =
(WifiP2pGroup) intent.getParcelableExtra(WifiP2pManager.EXTRA_WIFI_P2P_GROUP);
if (group != null) {
ServiceStatic.setDevice(group.getOwner().deviceName, group.getOwner().deviceAddress);
}
// we are connected with the other device, request connection
// info to find group owner IP
synCarnet.syncService.setConnected(true);
progressDialog = synCarnet.syncService.getProgressDialog();
Toast.makeText(
synCarnet, synCarnet.getString(R.string.connexionSuccessful), Toast.LENGTH_SHORT)
.show();
peerList.setIntent(intent);
manager.requestConnectionInfo(channel, peerList);
if (!displayPeers) {
Toast.makeText(synCarnet, synCarnet.getString(R.string.syncing), Toast.LENGTH_SHORT)
.show();
}
} else {
synCarnet.syncService.setConnected(false);
}
}
}
@Override
public LinkQualityInfo getLinkQualityInfo() {
if (mNetworkInfo == null || mNetworkInfo.getType() == ConnectivityManager.TYPE_NONE) {
// no data available yet; just return
return null;
}
MobileLinkQualityInfo li = new MobileLinkQualityInfo();
li.setNetworkType(mNetworkInfo.getType());
mSamplingDataTracker.setCommonLinkQualityInfoFields(li);
if (mNetworkInfo.getSubtype() != TelephonyManager.NETWORK_TYPE_UNKNOWN) {
li.setMobileNetworkType(mNetworkInfo.getSubtype());
NetworkDataEntry entry = getNetworkDataEntry(mNetworkInfo.getSubtype());
if (entry != null) {
li.setTheoreticalRxBandwidth(entry.downloadBandwidth);
li.setTheoreticalRxBandwidth(entry.uploadBandwidth);
li.setTheoreticalLatency(entry.latency);
}
if (mSignalStrength != null) {
li.setNormalizedSignalStrength(
getNormalizedSignalStrength(li.getMobileNetworkType(), mSignalStrength));
}
}
SignalStrength ss = mSignalStrength;
if (ss != null) {
li.setRssi(ss.getGsmSignalStrength());
li.setGsmErrorRate(ss.getGsmBitErrorRate());
li.setCdmaDbm(ss.getCdmaDbm());
li.setCdmaEcio(ss.getCdmaEcio());
li.setEvdoDbm(ss.getEvdoDbm());
li.setEvdoEcio(ss.getEvdoEcio());
li.setEvdoSnr(ss.getEvdoSnr());
li.setLteSignalStrength(ss.getLteSignalStrength());
li.setLteRsrp(ss.getLteRsrp());
li.setLteRsrq(ss.getLteRsrq());
li.setLteRssnr(ss.getLteRssnr());
li.setLteCqi(ss.getLteCqi());
}
if (VDBG) {
Slog.d(
TAG,
"Returning LinkQualityInfo with"
+ " MobileNetworkType = "
+ String.valueOf(li.getMobileNetworkType())
+ " Theoretical Rx BW = "
+ String.valueOf(li.getTheoreticalRxBandwidth())
+ " gsm Signal Strength = "
+ String.valueOf(li.getRssi())
+ " cdma Signal Strength = "
+ String.valueOf(li.getCdmaDbm())
+ " evdo Signal Strength = "
+ String.valueOf(li.getEvdoDbm())
+ " Lte Signal Strength = "
+ String.valueOf(li.getLteSignalStrength()));
}
return li;
}