1 /* 2 * Copyright 2021 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.internal.telephony.data; 18 19 import android.annotation.CurrentTimeMillisLong; 20 import android.annotation.ElapsedRealtimeLong; 21 import android.annotation.NonNull; 22 import android.annotation.Nullable; 23 import android.net.NetworkAgent; 24 import android.net.NetworkCapabilities; 25 import android.os.SystemClock; 26 import android.telephony.AccessNetworkConstants; 27 import android.telephony.AccessNetworkConstants.AccessNetworkType; 28 import android.telephony.AccessNetworkConstants.RadioAccessNetworkType; 29 import android.telephony.AccessNetworkConstants.TransportType; 30 import android.telephony.Annotation.DataActivityType; 31 import android.telephony.Annotation.NetCapability; 32 import android.telephony.Annotation.NetworkType; 33 import android.telephony.Annotation.ValidationStatus; 34 import android.telephony.TelephonyManager; 35 import android.telephony.data.ApnSetting; 36 import android.telephony.data.ApnSetting.ApnType; 37 import android.telephony.data.DataCallResponse; 38 import android.telephony.data.DataCallResponse.LinkStatus; 39 import android.telephony.data.DataProfile; 40 import android.telephony.ims.feature.ImsFeature; 41 import android.util.ArrayMap; 42 43 import com.android.internal.telephony.data.DataNetworkController.NetworkRequestList; 44 45 import java.text.SimpleDateFormat; 46 import java.util.ArrayList; 47 import java.util.Arrays; 48 import java.util.Collection; 49 import java.util.Collections; 50 import java.util.Comparator; 51 import java.util.List; 52 import java.util.Locale; 53 import java.util.Map; 54 import java.util.Set; 55 import java.util.stream.Collectors; 56 57 /** 58 * This class contains all the utility methods used by telephony data stack. 59 */ 60 public class DataUtils { 61 /** The time format for converting time to readable string. */ 62 private static final SimpleDateFormat TIME_FORMAT = 63 new SimpleDateFormat("HH:mm:ss.SSS", Locale.US); 64 65 /** 66 * Get the network capability from the string. 67 * 68 * @param capabilityString The capability in string format 69 * @return The network capability. -1 if not found. 70 */ getNetworkCapabilityFromString( @onNull String capabilityString)71 public static @NetCapability int getNetworkCapabilityFromString( 72 @NonNull String capabilityString) { 73 switch (capabilityString.toUpperCase(Locale.ROOT)) { 74 case "MMS": return NetworkCapabilities.NET_CAPABILITY_MMS; 75 case "SUPL": return NetworkCapabilities.NET_CAPABILITY_SUPL; 76 case "DUN": return NetworkCapabilities.NET_CAPABILITY_DUN; 77 case "FOTA": return NetworkCapabilities.NET_CAPABILITY_FOTA; 78 case "IMS": return NetworkCapabilities.NET_CAPABILITY_IMS; 79 case "CBS": return NetworkCapabilities.NET_CAPABILITY_CBS; 80 case "XCAP": return NetworkCapabilities.NET_CAPABILITY_XCAP; 81 case "EIMS": return NetworkCapabilities.NET_CAPABILITY_EIMS; 82 case "INTERNET": return NetworkCapabilities.NET_CAPABILITY_INTERNET; 83 case "MCX": return NetworkCapabilities.NET_CAPABILITY_MCX; 84 case "VSIM": return NetworkCapabilities.NET_CAPABILITY_VSIM; 85 case "BIP" : return NetworkCapabilities.NET_CAPABILITY_BIP; 86 case "ENTERPRISE": return NetworkCapabilities.NET_CAPABILITY_ENTERPRISE; 87 case "PRIORITIZE_BANDWIDTH": 88 return NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_BANDWIDTH; 89 case "PRIORITIZE_LATENCY": 90 return NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY; 91 default: 92 return -1; 93 } 94 } 95 96 /** 97 * Get Set of network capabilities from string joined by {@code |}, space is ignored. 98 * If input string contains unknown capability or malformatted(e.g. empty string), -1 is 99 * included in the returned set. 100 * 101 * @param capabilitiesString capability strings joined by {@code |} 102 * @return Set of capabilities 103 */ getNetworkCapabilitiesFromString( @onNull String capabilitiesString)104 public static @NetCapability Set<Integer> getNetworkCapabilitiesFromString( 105 @NonNull String capabilitiesString) { 106 // e.g. "IMS|" is not allowed 107 if (!capabilitiesString.matches("(\\s*[a-zA-Z]+\\s*)(\\|\\s*[a-zA-Z]+\\s*)*")) { 108 return Collections.singleton(-1); 109 } 110 return Arrays.stream(capabilitiesString.split("\\s*\\|\\s*")) 111 .map(String::trim) 112 .map(DataUtils::getNetworkCapabilityFromString) 113 .collect(Collectors.toSet()); 114 } 115 116 /** 117 * Convert a network capability to string. 118 * 119 * This is for debugging and logging purposes only. 120 * 121 * @param netCap Network capability. 122 * @return Network capability in string format. 123 */ networkCapabilityToString(@etCapability int netCap)124 public static @NonNull String networkCapabilityToString(@NetCapability int netCap) { 125 switch (netCap) { 126 case NetworkCapabilities.NET_CAPABILITY_MMS: return "MMS"; 127 case NetworkCapabilities.NET_CAPABILITY_SUPL: return "SUPL"; 128 case NetworkCapabilities.NET_CAPABILITY_DUN: return "DUN"; 129 case NetworkCapabilities.NET_CAPABILITY_FOTA: return "FOTA"; 130 case NetworkCapabilities.NET_CAPABILITY_IMS: return "IMS"; 131 case NetworkCapabilities.NET_CAPABILITY_CBS: return "CBS"; 132 case NetworkCapabilities.NET_CAPABILITY_WIFI_P2P: return "WIFI_P2P"; 133 case NetworkCapabilities.NET_CAPABILITY_IA: return "IA"; 134 case NetworkCapabilities.NET_CAPABILITY_RCS: return "RCS"; 135 case NetworkCapabilities.NET_CAPABILITY_XCAP: return "XCAP"; 136 case NetworkCapabilities.NET_CAPABILITY_EIMS: return "EIMS"; 137 case NetworkCapabilities.NET_CAPABILITY_NOT_METERED: return "NOT_METERED"; 138 case NetworkCapabilities.NET_CAPABILITY_INTERNET: return "INTERNET"; 139 case NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED: return "NOT_RESTRICTED"; 140 case NetworkCapabilities.NET_CAPABILITY_TRUSTED: return "TRUSTED"; 141 case NetworkCapabilities.NET_CAPABILITY_NOT_VPN: return "NOT_VPN"; 142 case NetworkCapabilities.NET_CAPABILITY_VALIDATED: return "VALIDATED"; 143 case NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL: return "CAPTIVE_PORTAL"; 144 case NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING: return "NOT_ROAMING"; 145 case NetworkCapabilities.NET_CAPABILITY_FOREGROUND: return "FOREGROUND"; 146 case NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED: return "NOT_CONGESTED"; 147 case NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED: return "NOT_SUSPENDED"; 148 case NetworkCapabilities.NET_CAPABILITY_OEM_PAID: return "OEM_PAID"; 149 case NetworkCapabilities.NET_CAPABILITY_MCX: return "MCX"; 150 case NetworkCapabilities.NET_CAPABILITY_PARTIAL_CONNECTIVITY: 151 return "PARTIAL_CONNECTIVITY"; 152 case NetworkCapabilities.NET_CAPABILITY_TEMPORARILY_NOT_METERED: 153 return "TEMPORARILY_NOT_METERED"; 154 case NetworkCapabilities.NET_CAPABILITY_OEM_PRIVATE: return "OEM_PRIVATE"; 155 case NetworkCapabilities.NET_CAPABILITY_VEHICLE_INTERNAL: return "VEHICLE_INTERNAL"; 156 case NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED: return "NOT_VCN_MANAGED"; 157 case NetworkCapabilities.NET_CAPABILITY_ENTERPRISE: return "ENTERPRISE"; 158 case NetworkCapabilities.NET_CAPABILITY_VSIM: return "VSIM"; 159 case NetworkCapabilities.NET_CAPABILITY_BIP: return "BIP"; 160 case NetworkCapabilities.NET_CAPABILITY_HEAD_UNIT: return "HEAD_UNIT"; 161 case NetworkCapabilities.NET_CAPABILITY_MMTEL: return "MMTEL"; 162 case NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY: 163 return "PRIORITIZE_LATENCY"; 164 case NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_BANDWIDTH: 165 return "PRIORITIZE_BANDWIDTH"; 166 default: 167 return "Unknown(" + netCap + ")"; 168 } 169 } 170 171 /** 172 * Convert network capabilities to string. 173 * 174 * This is for debugging and logging purposes only. 175 * 176 * @param netCaps Network capabilities. 177 * @return Network capabilities in string format. 178 */ networkCapabilitiesToString( @etCapability @ullable Collection<Integer> netCaps)179 public static @NonNull String networkCapabilitiesToString( 180 @NetCapability @Nullable Collection<Integer> netCaps) { 181 if (netCaps == null || netCaps.isEmpty()) return ""; 182 return "[" + netCaps.stream() 183 .map(DataUtils::networkCapabilityToString) 184 .collect(Collectors.joining("|")) + "]"; 185 } 186 187 /** 188 * Convert network capabilities to string. 189 * 190 * This is for debugging and logging purposes only. 191 * 192 * @param netCaps Network capabilities. 193 * @return Network capabilities in string format. 194 */ networkCapabilitiesToString(@etCapability int[] netCaps)195 public static @NonNull String networkCapabilitiesToString(@NetCapability int[] netCaps) { 196 if (netCaps == null) return ""; 197 return "[" + Arrays.stream(netCaps) 198 .mapToObj(DataUtils::networkCapabilityToString) 199 .collect(Collectors.joining("|")) + "]"; 200 } 201 202 /** 203 * Convert the validation status to string. 204 * 205 * @param status The validation status. 206 * @return The validation status in string format. 207 */ validationStatusToString(@alidationStatus int status)208 public static @NonNull String validationStatusToString(@ValidationStatus int status) { 209 switch (status) { 210 case NetworkAgent.VALIDATION_STATUS_VALID: return "VALID"; 211 case NetworkAgent.VALIDATION_STATUS_NOT_VALID: return "INVALID"; 212 default: return "UNKNOWN(" + status + ")"; 213 } 214 } 215 216 /** 217 * Convert network capability into APN type. 218 * 219 * @param networkCapability Network capability. 220 * @return APN type. 221 */ networkCapabilityToApnType(@etCapability int networkCapability)222 public static @ApnType int networkCapabilityToApnType(@NetCapability int networkCapability) { 223 switch (networkCapability) { 224 case NetworkCapabilities.NET_CAPABILITY_MMS: 225 return ApnSetting.TYPE_MMS; 226 case NetworkCapabilities.NET_CAPABILITY_SUPL: 227 return ApnSetting.TYPE_SUPL; 228 case NetworkCapabilities.NET_CAPABILITY_DUN: 229 return ApnSetting.TYPE_DUN; 230 case NetworkCapabilities.NET_CAPABILITY_FOTA: 231 return ApnSetting.TYPE_FOTA; 232 case NetworkCapabilities.NET_CAPABILITY_IMS: 233 return ApnSetting.TYPE_IMS; 234 case NetworkCapabilities.NET_CAPABILITY_CBS: 235 return ApnSetting.TYPE_CBS; 236 case NetworkCapabilities.NET_CAPABILITY_XCAP: 237 return ApnSetting.TYPE_XCAP; 238 case NetworkCapabilities.NET_CAPABILITY_EIMS: 239 return ApnSetting.TYPE_EMERGENCY; 240 case NetworkCapabilities.NET_CAPABILITY_INTERNET: 241 return ApnSetting.TYPE_DEFAULT; 242 case NetworkCapabilities.NET_CAPABILITY_MCX: 243 return ApnSetting.TYPE_MCX; 244 case NetworkCapabilities.NET_CAPABILITY_IA: 245 return ApnSetting.TYPE_IA; 246 case NetworkCapabilities.NET_CAPABILITY_ENTERPRISE: 247 return ApnSetting.TYPE_ENTERPRISE; 248 case NetworkCapabilities.NET_CAPABILITY_VSIM: 249 return ApnSetting.TYPE_VSIM; 250 case NetworkCapabilities.NET_CAPABILITY_BIP: 251 return ApnSetting.TYPE_BIP; 252 default: 253 return ApnSetting.TYPE_NONE; 254 } 255 } 256 257 /** 258 * Convert APN type to capability. 259 * 260 * @param apnType APN type. 261 * @return Network capability. 262 */ apnTypeToNetworkCapability(@pnType int apnType)263 public static @NetCapability int apnTypeToNetworkCapability(@ApnType int apnType) { 264 switch (apnType) { 265 case ApnSetting.TYPE_MMS: 266 return NetworkCapabilities.NET_CAPABILITY_MMS; 267 case ApnSetting.TYPE_SUPL: 268 return NetworkCapabilities.NET_CAPABILITY_SUPL; 269 case ApnSetting.TYPE_DUN: 270 return NetworkCapabilities.NET_CAPABILITY_DUN; 271 case ApnSetting.TYPE_FOTA: 272 return NetworkCapabilities.NET_CAPABILITY_FOTA; 273 case ApnSetting.TYPE_IMS: 274 return NetworkCapabilities.NET_CAPABILITY_IMS; 275 case ApnSetting.TYPE_CBS: 276 return NetworkCapabilities.NET_CAPABILITY_CBS; 277 case ApnSetting.TYPE_XCAP: 278 return NetworkCapabilities.NET_CAPABILITY_XCAP; 279 case ApnSetting.TYPE_EMERGENCY: 280 return NetworkCapabilities.NET_CAPABILITY_EIMS; 281 case ApnSetting.TYPE_DEFAULT: 282 return NetworkCapabilities.NET_CAPABILITY_INTERNET; 283 case ApnSetting.TYPE_MCX: 284 return NetworkCapabilities.NET_CAPABILITY_MCX; 285 case ApnSetting.TYPE_IA: 286 return NetworkCapabilities.NET_CAPABILITY_IA; 287 case ApnSetting.TYPE_BIP: 288 return NetworkCapabilities.NET_CAPABILITY_BIP; 289 case ApnSetting.TYPE_VSIM: 290 return NetworkCapabilities.NET_CAPABILITY_VSIM; 291 case ApnSetting.TYPE_ENTERPRISE: 292 return NetworkCapabilities.NET_CAPABILITY_ENTERPRISE; 293 default: 294 return -1; 295 } 296 } 297 298 /** 299 * Convert network type to access network type. 300 * 301 * @param networkType The network type. 302 * @return The access network type. 303 */ networkTypeToAccessNetworkType( @etworkType int networkType)304 public static @RadioAccessNetworkType int networkTypeToAccessNetworkType( 305 @NetworkType int networkType) { 306 switch (networkType) { 307 case TelephonyManager.NETWORK_TYPE_GPRS: 308 case TelephonyManager.NETWORK_TYPE_EDGE: 309 case TelephonyManager.NETWORK_TYPE_GSM: 310 return AccessNetworkType.GERAN; 311 case TelephonyManager.NETWORK_TYPE_UMTS: 312 case TelephonyManager.NETWORK_TYPE_HSDPA: 313 case TelephonyManager.NETWORK_TYPE_HSPAP: 314 case TelephonyManager.NETWORK_TYPE_HSUPA: 315 case TelephonyManager.NETWORK_TYPE_HSPA: 316 case TelephonyManager.NETWORK_TYPE_TD_SCDMA: 317 return AccessNetworkType.UTRAN; 318 case TelephonyManager.NETWORK_TYPE_CDMA: 319 case TelephonyManager.NETWORK_TYPE_EVDO_0: 320 case TelephonyManager.NETWORK_TYPE_EVDO_A: 321 case TelephonyManager.NETWORK_TYPE_EVDO_B: 322 case TelephonyManager.NETWORK_TYPE_1xRTT: 323 case TelephonyManager.NETWORK_TYPE_EHRPD: 324 return AccessNetworkType.CDMA2000; 325 case TelephonyManager.NETWORK_TYPE_LTE: 326 case TelephonyManager.NETWORK_TYPE_LTE_CA: 327 return AccessNetworkType.EUTRAN; 328 case TelephonyManager.NETWORK_TYPE_IWLAN: 329 return AccessNetworkType.IWLAN; 330 case TelephonyManager.NETWORK_TYPE_NR: 331 return AccessNetworkType.NGRAN; 332 default: 333 return AccessNetworkType.UNKNOWN; 334 } 335 } 336 337 /** 338 * Convert the elapsed time to the current time with readable time format. 339 * 340 * @param elapsedTime The elapsed time retrieved from {@link SystemClock#elapsedRealtime()}. 341 * @return The string format time. 342 */ elapsedTimeToString(@lapsedRealtimeLong long elapsedTime)343 public static @NonNull String elapsedTimeToString(@ElapsedRealtimeLong long elapsedTime) { 344 return (elapsedTime != 0) ? systemTimeToString(System.currentTimeMillis() 345 - SystemClock.elapsedRealtime() + elapsedTime) : "never"; 346 } 347 348 /** 349 * Convert the system time to the human readable format. 350 * 351 * @param systemTime The system time retrieved from {@link System#currentTimeMillis()}. 352 * @return The string format time. 353 */ systemTimeToString(@urrentTimeMillisLong long systemTime)354 public static @NonNull String systemTimeToString(@CurrentTimeMillisLong long systemTime) { 355 return (systemTime != 0) ? TIME_FORMAT.format(systemTime) : "never"; 356 } 357 358 /** 359 * Convert the IMS feature to string. 360 * 361 * @param imsFeature IMS feature. 362 * @return IMS feature in string format. 363 */ imsFeatureToString(@msFeature.FeatureType int imsFeature)364 public static @NonNull String imsFeatureToString(@ImsFeature.FeatureType int imsFeature) { 365 switch (imsFeature) { 366 case ImsFeature.FEATURE_MMTEL: return "MMTEL"; 367 case ImsFeature.FEATURE_RCS: return "RCS"; 368 default: 369 return "Unknown(" + imsFeature + ")"; 370 } 371 } 372 373 /** 374 * Get the highest priority supported network capability from the specified data profile. 375 * 376 * @param dataConfigManager The data config that contains network priority information. 377 * @param dataProfile The data profile 378 * @return The highest priority network capability. -1 if cannot find one. 379 */ getHighestPriorityNetworkCapabilityFromDataProfile( @onNull DataConfigManager dataConfigManager, @NonNull DataProfile dataProfile)380 public static @NetCapability int getHighestPriorityNetworkCapabilityFromDataProfile( 381 @NonNull DataConfigManager dataConfigManager, @NonNull DataProfile dataProfile) { 382 if (dataProfile.getApnSetting() == null 383 || dataProfile.getApnSetting().getApnTypes().isEmpty()) return -1; 384 return dataProfile.getApnSetting().getApnTypes().stream() 385 .map(DataUtils::apnTypeToNetworkCapability) 386 .sorted(Comparator.comparing(dataConfigManager::getNetworkCapabilityPriority) 387 .reversed()) 388 .collect(Collectors.toList()) 389 .get(0); 390 } 391 392 /** 393 * Group the network requests into several list that contains the same network capabilities. 394 * 395 * @param networkRequestList The provided network requests. 396 * @return The network requests after grouping. 397 */ getGroupedNetworkRequestList( @onNull NetworkRequestList networkRequestList)398 public static @NonNull List<NetworkRequestList> getGroupedNetworkRequestList( 399 @NonNull NetworkRequestList networkRequestList) { 400 // Key is the capabilities set. 401 Map<Set<Integer>, NetworkRequestList> requestsMap = new ArrayMap<>(); 402 for (TelephonyNetworkRequest networkRequest : networkRequestList) { 403 requestsMap.computeIfAbsent(Arrays.stream(networkRequest.getCapabilities()) 404 .boxed().collect(Collectors.toSet()), 405 v -> new NetworkRequestList()).add(networkRequest); 406 } 407 List<NetworkRequestList> requests = new ArrayList<>(); 408 // Create separate groups for enterprise requests with different enterprise IDs. 409 for (NetworkRequestList requestList : requestsMap.values()) { 410 List<TelephonyNetworkRequest> enterpriseRequests = requestList.stream() 411 .filter(request -> 412 request.hasCapability(NetworkCapabilities.NET_CAPABILITY_ENTERPRISE)) 413 .collect(Collectors.toList()); 414 if (enterpriseRequests.isEmpty()) { 415 requests.add(requestList); 416 continue; 417 } 418 // Key is the enterprise ID 419 Map<Integer, NetworkRequestList> enterpriseRequestsMap = new ArrayMap<>(); 420 for (TelephonyNetworkRequest request : enterpriseRequests) { 421 enterpriseRequestsMap.computeIfAbsent(request.getCapabilityDifferentiator(), 422 v -> new NetworkRequestList()).add(request); 423 } 424 requests.addAll(enterpriseRequestsMap.values()); 425 } 426 // Sort the requests so the network request list with higher priority will be at the front. 427 return requests.stream() 428 .sorted((list1, list2) -> Integer.compare( 429 list2.get(0).getPriority(), list1.get(0).getPriority())) 430 .collect(Collectors.toList()); 431 } 432 433 /** 434 * Get the target transport from source transport. This is only used for handover between 435 * IWLAN and cellular scenario. 436 * 437 * @param sourceTransport The source transport. 438 * @return The target transport. 439 */ getTargetTransport(@ransportType int sourceTransport)440 public static @TransportType int getTargetTransport(@TransportType int sourceTransport) { 441 return sourceTransport == AccessNetworkConstants.TRANSPORT_TYPE_WWAN 442 ? AccessNetworkConstants.TRANSPORT_TYPE_WLAN 443 : AccessNetworkConstants.TRANSPORT_TYPE_WWAN; 444 } 445 446 /** 447 * Get the source transport from target transport. This is only used for handover between 448 * IWLAN and cellular scenario. 449 * 450 * @param targetTransport The target transport. 451 * @return The source transport. 452 */ getSourceTransport(@ransportType int targetTransport)453 public static @TransportType int getSourceTransport(@TransportType int targetTransport) { 454 return targetTransport == AccessNetworkConstants.TRANSPORT_TYPE_WWAN 455 ? AccessNetworkConstants.TRANSPORT_TYPE_WLAN 456 : AccessNetworkConstants.TRANSPORT_TYPE_WWAN; 457 } 458 459 /** 460 * Convert link status to string. 461 * 462 * @param linkStatus The link status. 463 * @return The link status in string format. 464 */ linkStatusToString(@inkStatus int linkStatus)465 public static @NonNull String linkStatusToString(@LinkStatus int linkStatus) { 466 switch (linkStatus) { 467 case DataCallResponse.LINK_STATUS_UNKNOWN: return "UNKNOWN"; 468 case DataCallResponse.LINK_STATUS_INACTIVE: return "INACTIVE"; 469 case DataCallResponse.LINK_STATUS_ACTIVE: return "ACTIVE"; 470 case DataCallResponse.LINK_STATUS_DORMANT: return "DORMANT"; 471 default: return "UNKNOWN(" + linkStatus + ")"; 472 } 473 } 474 475 /** 476 * Check if access network type is valid. 477 * 478 * @param accessNetworkType The access network type to check. 479 * @return {@code true} if the access network type is valid. 480 */ isValidAccessNetwork(@adioAccessNetworkType int accessNetworkType)481 public static boolean isValidAccessNetwork(@RadioAccessNetworkType int accessNetworkType) { 482 switch (accessNetworkType) { 483 case AccessNetworkType.GERAN: 484 case AccessNetworkType.UTRAN: 485 case AccessNetworkType.EUTRAN: 486 case AccessNetworkType.CDMA2000: 487 case AccessNetworkType.IWLAN: 488 case AccessNetworkType.NGRAN: 489 return true; 490 default: 491 return false; 492 } 493 } 494 495 /** 496 * Convert data activity to string. 497 * 498 * @param dataActivity The data activity. 499 * @return The data activity in string format. 500 */ dataActivityToString(@ataActivityType int dataActivity)501 public static @NonNull String dataActivityToString(@DataActivityType int dataActivity) { 502 switch (dataActivity) { 503 case TelephonyManager.DATA_ACTIVITY_NONE: return "NONE"; 504 case TelephonyManager.DATA_ACTIVITY_IN: return "IN"; 505 case TelephonyManager.DATA_ACTIVITY_OUT: return "OUT"; 506 case TelephonyManager.DATA_ACTIVITY_INOUT: return "INOUT"; 507 case TelephonyManager.DATA_ACTIVITY_DORMANT: return "DORMANT"; 508 default: return "UNKNOWN(" + dataActivity + ")"; 509 } 510 } 511 } 512