ConnectivityServiceMock.java revision bc2eba9036e430ea40a47ab708c0386fa567ec9c
1/* 2 * Copyright (C) 2008 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 17package com.android.internal.telephony.mocks; 18 19import static android.Manifest.permission.RECEIVE_DATA_ACTIVITY_CHANGE; 20import static android.net.ConnectivityManager.CONNECTIVITY_ACTION; 21import static android.net.ConnectivityManager.NETID_UNSET; 22import static android.net.ConnectivityManager.TYPE_NONE; 23import static android.net.ConnectivityManager.TYPE_VPN; 24import static android.net.ConnectivityManager.getNetworkTypeName; 25import static android.net.ConnectivityManager.isNetworkTypeValid; 26import static android.net.NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL; 27import static android.net.NetworkCapabilities.NET_CAPABILITY_INTERNET; 28import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_METERED; 29import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED; 30import static android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED; 31import static android.net.NetworkPolicyManager.RULE_ALLOW_ALL; 32import static android.net.NetworkPolicyManager.RULE_REJECT_ALL; 33import static android.net.NetworkPolicyManager.RULE_REJECT_METERED; 34 35import android.annotation.Nullable; 36import android.app.AlarmManager; 37import android.app.BroadcastOptions; 38import android.app.Notification; 39import android.app.NotificationManager; 40import android.app.PendingIntent; 41import android.content.BroadcastReceiver; 42import android.content.ContentResolver; 43import android.content.Context; 44import android.content.Intent; 45import android.content.IntentFilter; 46import android.content.pm.PackageManager; 47import android.content.res.Configuration; 48import android.content.res.Resources; 49import android.database.ContentObserver; 50import android.net.ConnectivityManager; 51import android.net.ConnectivityManager.PacketKeepalive; 52import android.net.IConnectivityManager; 53import android.net.INetworkManagementEventObserver; 54import android.net.INetworkPolicyListener; 55import android.net.INetworkPolicyManager; 56import android.net.INetworkStatsService; 57import android.net.LinkProperties; 58import android.net.LinkProperties.CompareResult; 59import android.net.Network; 60import android.net.NetworkAgent; 61import android.net.NetworkCapabilities; 62import android.net.NetworkConfig; 63import android.net.NetworkInfo; 64import android.net.NetworkInfo.DetailedState; 65import android.net.NetworkMisc; 66import android.net.NetworkQuotaInfo; 67import android.net.NetworkRequest; 68import android.net.NetworkState; 69import android.net.NetworkUtils; 70import android.net.Proxy; 71import android.net.ProxyInfo; 72import android.net.RouteInfo; 73import android.net.UidRange; 74import android.net.Uri; 75import android.os.Binder; 76import android.os.Build; 77import android.os.Bundle; 78import android.os.FileUtils; 79import android.os.Handler; 80import android.os.HandlerThread; 81import android.os.IBinder; 82import android.os.INetworkManagementService; 83import android.os.Looper; 84import android.os.Message; 85import android.os.Messenger; 86import android.os.ParcelFileDescriptor; 87import android.os.PowerManager; 88import android.os.Process; 89import android.os.RemoteException; 90import android.os.ResultReceiver; 91import android.os.SystemClock; 92import android.os.SystemProperties; 93import android.os.UserHandle; 94import android.os.UserManager; 95import android.provider.Settings; 96import android.security.Credentials; 97import android.security.KeyStore; 98import android.telephony.TelephonyManager; 99import android.text.TextUtils; 100import android.util.LocalLog; 101import android.util.LocalLog.ReadOnlyLocalLog; 102import android.util.Pair; 103import android.util.Slog; 104import android.util.SparseArray; 105import android.util.SparseBooleanArray; 106import android.util.SparseIntArray; 107import android.util.Xml; 108 109import com.android.internal.R; 110import com.android.internal.annotations.GuardedBy; 111import com.android.internal.annotations.VisibleForTesting; 112import com.android.internal.net.LegacyVpnInfo; 113import com.android.internal.net.VpnConfig; 114import com.android.internal.net.VpnInfo; 115import com.android.internal.net.VpnProfile; 116import com.android.internal.util.AsyncChannel; 117import com.android.server.connectivity.NetworkAgentInfo; 118import com.android.server.connectivity.NetworkMonitor; 119 120import java.io.File; 121import java.io.FileDescriptor; 122import java.io.FileNotFoundException; 123import java.io.FileReader; 124import java.io.IOException; 125import java.io.PrintWriter; 126import java.net.Inet4Address; 127import java.net.InetAddress; 128import java.net.UnknownHostException; 129import java.util.ArrayDeque; 130import java.util.ArrayList; 131import java.util.Arrays; 132import java.util.Collection; 133import java.util.HashMap; 134import java.util.HashSet; 135import java.util.SortedSet; 136import java.util.TreeSet; 137import java.util.Iterator; 138import java.util.List; 139import java.util.Map; 140import java.util.Objects; 141import java.util.concurrent.atomic.AtomicInteger; 142 143/** 144 * @hide 145 */ 146public class ConnectivityServiceMock extends IConnectivityManager.Stub 147 implements PendingIntent.OnFinished { 148 private static final String TAG = "ConnectivityServiceMock"; 149 private static final boolean DBG = true; 150 private static final boolean VDBG = true; 151 152 /** 153 * used internally when registering NetworkFactories 154 * obj = NetworkFactoryInfo 155 */ 156 private static final int EVENT_REGISTER_NETWORK_FACTORY = 17; 157 158 /** 159 * used internally when registering NetworkAgents 160 * obj = Messenger 161 */ 162 private static final int EVENT_REGISTER_NETWORK_AGENT = 18; 163 164 /** 165 * used to add a network request 166 * includes a NetworkRequestInfo 167 */ 168 private static final int EVENT_REGISTER_NETWORK_REQUEST = 19; 169 170 /** 171 * used to add a network listener - no request 172 * includes a NetworkRequestInfo 173 */ 174 private static final int EVENT_REGISTER_NETWORK_LISTENER = 21; 175 176 /** 177 * used to remove a network request, either a listener or a real request 178 * arg1 = UID of caller 179 * obj = NetworkRequest 180 */ 181 private static final int EVENT_RELEASE_NETWORK_REQUEST = 22; 182 183 /** 184 * used internally when registering NetworkFactories 185 * obj = Messenger 186 */ 187 private static final int EVENT_UNREGISTER_NETWORK_FACTORY = 23; 188 189 190 private final HandlerThread mHandlerThread; 191 /** Handler used for internal events. */ 192 final private InternalHandler mHandler; 193 /** Handler used for incoming {@link NetworkStateTracker} events. */ 194 final private NetworkStateTrackerHandler mTrackerHandler; 195 196 final private Context mContext; 197 198 public ConnectivityServiceMock(Context context) { 199 if (DBG) log("starting up"); 200 201 mContext = context; 202 mHandlerThread = new HandlerThread("ConnectivityServiceMock"); 203 mHandlerThread.start(); 204 mHandler = new InternalHandler(mHandlerThread.getLooper()); 205 mTrackerHandler = new NetworkStateTrackerHandler(mHandlerThread.getLooper()); 206 } 207 208 public void die() { 209 // clean up threads/handlers 210 } 211 212 private class InternalHandler extends Handler { 213 public InternalHandler(Looper looper) { 214 super(looper); 215 } 216 217 @Override 218 public void handleMessage(Message msg) { 219 switch (msg.what) { 220 case EVENT_REGISTER_NETWORK_FACTORY: { 221 handleRegisterNetworkFactory((NetworkFactoryInfo)msg.obj); 222 break; 223 } 224 case EVENT_UNREGISTER_NETWORK_FACTORY: { 225 handleUnregisterNetworkFactory((Messenger)msg.obj); 226 break; 227 } 228 case EVENT_REGISTER_NETWORK_AGENT: { 229 handleRegisterNetworkAgent((NetworkAgentInfo)msg.obj); 230 break; 231 } 232 case EVENT_REGISTER_NETWORK_REQUEST: 233 case EVENT_REGISTER_NETWORK_LISTENER: { 234 handleRegisterNetworkRequest((NetworkRequestInfo) msg.obj); 235 break; 236 } 237 case EVENT_RELEASE_NETWORK_REQUEST: { 238 handleReleaseNetworkRequest((NetworkRequest) msg.obj, msg.arg1); 239 break; 240 } 241 } 242 } 243 } 244 245 private class NetworkStateTrackerHandler extends Handler { 246 public NetworkStateTrackerHandler(Looper looper) { 247 super(looper); 248 } 249 250 @Override 251 public void handleMessage(Message msg) { 252 NetworkInfo info; 253 switch (msg.what) { 254 case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED: { 255 handleAsyncChannelHalfConnect(msg); 256 break; 257 } 258 case AsyncChannel.CMD_CHANNEL_DISCONNECT: { 259 NetworkAgentInfo nai = mNetworkAgentInfos.get(msg.replyTo); 260 if (nai != null) nai.asyncChannel.disconnect(); 261 break; 262 } 263 case AsyncChannel.CMD_CHANNEL_DISCONNECTED: { 264 handleAsyncChannelDisconnected(msg); 265 break; 266 } 267 } 268 } 269 } 270 271 private boolean isRequest(NetworkRequest request) { 272 return mNetworkRequests.get(request).isRequest; 273 } 274 275 private void handleAsyncChannelHalfConnect(Message msg) { 276 AsyncChannel ac = (AsyncChannel) msg.obj; 277 if (mNetworkFactoryInfos.containsKey(msg.replyTo)) { 278 if (msg.arg1 == AsyncChannel.STATUS_SUCCESSFUL) { 279 if (VDBG) log("NetworkFactory connected"); 280 // A network factory has connected. Send it all current NetworkRequests. 281 for (NetworkRequestInfo nri : mNetworkRequests.values()) { 282 if (nri.isRequest == false) continue; 283 //NetworkAgentInfo nai = mNetworkForRequestId.get(nri.request.requestId); 284 NetworkAgentInfo nai = null; 285 ac.sendMessage(android.net.NetworkFactory.CMD_REQUEST_NETWORK, 286 (nai != null ? nai.getCurrentScore() : 0), 0, nri.request); 287 } 288 } else { 289 loge("Error connecting NetworkFactory"); 290 mNetworkFactoryInfos.remove(msg.obj); 291 } 292 } else if (mNetworkAgentInfos.containsKey(msg.replyTo)) { 293 if (msg.arg1 == AsyncChannel.STATUS_SUCCESSFUL) { 294 if (VDBG) log("NetworkAgent connected"); 295 // A network agent has requested a connection. Establish the connection. 296 mNetworkAgentInfos.get(msg.replyTo).asyncChannel. 297 sendMessage(AsyncChannel.CMD_CHANNEL_FULL_CONNECTION); 298 } else { 299 loge("Error connecting NetworkAgent"); 300 NetworkAgentInfo nai = mNetworkAgentInfos.remove(msg.replyTo); 301 //if (nai != null) { 302 // final boolean wasDefault = isDefaultNetwork(nai); 303 // synchronized (mNetworkForNetId) { 304 // mNetworkForNetId.remove(nai.network.netId); 305 // mNetIdInUse.delete(nai.network.netId); 306 // } 307 // // Just in case. 308 // mLegacyTypeTracker.remove(nai, wasDefault); 309 //} 310 } 311 } 312 } 313 314 private void handleAsyncChannelDisconnected(Message msg) { 315 NetworkAgentInfo nai = mNetworkAgentInfos.get(msg.replyTo); 316 if (nai != null) { 317 if (DBG) { 318 log(nai.name() + " got DISCONNECTED, was satisfying " + nai.networkRequests.size()); 319 } 320 // A network agent has disconnected. 321 // TODO - if we move the logic to the network agent (have them disconnect 322 // because they lost all their requests or because their score isn't good) 323 // then they would disconnect organically, report their new state and then 324 // disconnect the channel. 325 //if (nai.networkInfo.isConnected()) { 326 // nai.networkInfo.setDetailedState(NetworkInfo.DetailedState.DISCONNECTED, 327 // null, null); 328 //} 329 //final boolean wasDefault = isDefaultNetwork(nai); 330 //if (wasDefault) { 331 // mDefaultInetConditionPublished = 0; 332 //} 333 //notifyIfacesChanged(); 334 // TODO - we shouldn't send CALLBACK_LOST to requests that can be satisfied 335 // by other networks that are already connected. Perhaps that can be done by 336 // sending all CALLBACK_LOST messages (for requests, not listens) at the end 337 // of rematchAllNetworksAndRequests 338 //notifyNetworkCallbacks(nai, ConnectivityManager.CALLBACK_LOST); 339 //mKeepaliveTracker.handleStopAllKeepalives(nai, 340 // ConnectivityManager.PacketKeepalive.ERROR_INVALID_NETWORK); 341 nai.networkMonitor.sendMessage(NetworkMonitor.CMD_NETWORK_DISCONNECTED); 342 mNetworkAgentInfos.remove(msg.replyTo); 343 //updateClat(null, nai.linkProperties, nai); 344 //synchronized (mNetworkForNetId) { 345 // // Remove the NetworkAgent, but don't mark the netId as 346 // // available until we've told netd to delete it below. 347 // mNetworkForNetId.remove(nai.network.netId); 348 //} 349 // Remove all previously satisfied requests. 350 //for (int i = 0; i < nai.networkRequests.size(); i++) { 351 // NetworkRequest request = nai.networkRequests.valueAt(i); 352 // NetworkAgentInfo currentNetwork = mNetworkForRequestId.get(request.requestId); 353 // if (currentNetwork != null && currentNetwork.network.netId == nai.network.netId) { 354 // mNetworkForRequestId.remove(request.requestId); 355 // sendUpdatedScoreToFactories(request, 0); 356 // } 357 //} 358 //if (nai.networkRequests.get(mDefaultRequest.requestId) != null) { 359 // removeDataActivityTracking(nai); 360 // notifyLockdownVpn(nai); 361 // requestNetworkTransitionWakelock(nai.name()); 362 //} 363 //mLegacyTypeTracker.remove(nai, wasDefault); 364 //rematchAllNetworksAndRequests(null, 0); 365 //if (nai.created) { 366 // // Tell netd to clean up the configuration for this network 367 // // (routing rules, DNS, etc). 368 // // This may be slow as it requires a lot of netd shelling out to ip and 369 // // ip[6]tables to flush routes and remove the incoming packet mark rule, so do it 370 // // after we've rematched networks with requests which should make a potential 371 // // fallback network the default or requested a new network from the 372 // // NetworkFactories, so network traffic isn't interrupted for an unnecessarily 373 // // long time. 374 // try { 375 // mNetd.removeNetwork(nai.network.netId); 376 // } catch (Exception e) { 377 // loge("Exception removing network: " + e); 378 // } 379 //} 380 //synchronized (mNetworkForNetId) { 381 // mNetIdInUse.delete(nai.network.netId); 382 //} 383 } else { 384 NetworkFactoryInfo nfi = mNetworkFactoryInfos.remove(msg.replyTo); 385 if (DBG && nfi != null) log("unregisterNetworkFactory for " + nfi.name); 386 } 387 } 388 389 private void log(String str) { 390 Slog.d(TAG, str); 391 } 392 private void loge(String str) { 393 Slog.e(TAG, str); 394 } 395 396 // NetworkAgentInfo keyed off its connecting messenger 397 // TODO - eval if we can reduce the number of lists/hashmaps/sparsearrays 398 // NOTE: Only should be accessed on ConnectivityServiceThread, except dump(). 399 private final HashMap<Messenger, NetworkAgentInfo> mNetworkAgentInfos = 400 new HashMap<Messenger, NetworkAgentInfo>(); 401 private final HashMap<Messenger, NetworkFactoryInfo> mNetworkFactoryInfos = 402 new HashMap<Messenger, NetworkFactoryInfo>(); 403 private final HashMap<NetworkRequest, NetworkRequestInfo> mNetworkRequests = 404 new HashMap<NetworkRequest, NetworkRequestInfo>(); 405 406 private static class NetworkFactoryInfo { 407 public final String name; 408 public final Messenger messenger; 409 public final AsyncChannel asyncChannel; 410 411 public NetworkFactoryInfo(String name, Messenger messenger, AsyncChannel asyncChannel) { 412 this.name = name; 413 this.messenger = messenger; 414 this.asyncChannel = asyncChannel; 415 } 416 } 417 418 private class NetworkRequestInfo implements IBinder.DeathRecipient { 419 static final boolean REQUEST = true; 420 static final boolean LISTEN = false; 421 422 final NetworkRequest request; 423 final PendingIntent mPendingIntent; 424 boolean mPendingIntentSent; 425 private final IBinder mBinder; 426 final int mPid; 427 final int mUid; 428 final Messenger messenger; 429 final boolean isRequest; 430 431 NetworkRequestInfo(NetworkRequest r, PendingIntent pi, boolean isRequest) { 432 request = r; 433 mPendingIntent = pi; 434 messenger = null; 435 mBinder = null; 436 mPid = getCallingPid(); 437 mUid = getCallingUid(); 438 this.isRequest = isRequest; 439 } 440 441 NetworkRequestInfo(Messenger m, NetworkRequest r, IBinder binder, boolean isRequest) { 442 super(); 443 messenger = m; 444 request = r; 445 mBinder = binder; 446 mPid = getCallingPid(); 447 mUid = getCallingUid(); 448 this.isRequest = isRequest; 449 mPendingIntent = null; 450 451 try { 452 mBinder.linkToDeath(this, 0); 453 } catch (RemoteException e) { 454 binderDied(); 455 } 456 } 457 458 void unlinkDeathRecipient() { 459 if (mBinder != null) { 460 mBinder.unlinkToDeath(this, 0); 461 } 462 } 463 464 public void binderDied() { 465 log("ConnectivityService NetworkRequestInfo binderDied(" + 466 request + ", " + mBinder + ")"); 467 releaseNetworkRequest(request); 468 } 469 470 public String toString() { 471 return (isRequest ? "Request" : "Listen") + 472 " from uid/pid:" + mUid + "/" + mPid + 473 " for " + request + 474 (mPendingIntent == null ? "" : " to trigger " + mPendingIntent); 475 } 476 } 477 478 479 // sequence number of NetworkRequests 480 private int mNextNetworkRequestId = 1; 481 private synchronized int nextNetworkRequestId() { 482 return mNextNetworkRequestId++; 483 } 484 485 @Override 486 public NetworkInfo getActiveNetworkInfo() { 487 throw new RuntimeException("not implemented"); 488 } 489 490 @Override 491 public Network getActiveNetwork() { 492 throw new RuntimeException("not implemented"); 493 } 494 495 public NetworkInfo getActiveNetworkInfoUnfiltered() { 496 throw new RuntimeException("not implemented"); 497 } 498 499 @Override 500 public NetworkInfo getActiveNetworkInfoForUid(int uid) { 501 throw new RuntimeException("not implemented"); 502 } 503 504 @Override 505 public NetworkInfo getNetworkInfo(int networkType) { 506 throw new RuntimeException("not implemented"); 507 } 508 509 @Override 510 public NetworkInfo getNetworkInfoForNetwork(Network network) { 511 throw new RuntimeException("not implemented"); 512 } 513 514 @Override 515 public NetworkInfo[] getAllNetworkInfo() { 516 throw new RuntimeException("not implemented"); 517 } 518 519 @Override 520 public Network getNetworkForType(int networkType) { 521 throw new RuntimeException("not implemented"); 522 } 523 524 @Override 525 public Network[] getAllNetworks() { 526 throw new RuntimeException("not implemented"); 527 } 528 529 @Override 530 public NetworkCapabilities[] getDefaultNetworkCapabilitiesForUser(int userId) { 531 throw new RuntimeException("not implemented"); 532 } 533 534 @Override 535 public boolean isNetworkSupported(int networkType) { 536 throw new RuntimeException("not implemented"); 537 } 538 539 @Override 540 public LinkProperties getActiveLinkProperties() { 541 throw new RuntimeException("not implemented"); 542 } 543 544 @Override 545 public LinkProperties getLinkPropertiesForType(int networkType) { 546 throw new RuntimeException("not implemented"); 547 } 548 549 @Override 550 public LinkProperties getLinkProperties(Network network) { 551 throw new RuntimeException("not implemented"); 552 } 553 554 @Override 555 public NetworkCapabilities getNetworkCapabilities(Network network) { 556 throw new RuntimeException("not implemented"); 557 } 558 559 @Override 560 public NetworkState[] getAllNetworkState() { 561 throw new RuntimeException("not implemented"); 562 } 563 564 @Override 565 public NetworkQuotaInfo getActiveNetworkQuotaInfo() { 566 throw new RuntimeException("not implemented"); 567 } 568 569 @Override 570 public boolean isActiveNetworkMetered() { 571 throw new RuntimeException("not implemented"); 572 } 573 574 public boolean requestRouteToHostAddress(int networkType, byte[] hostAddress) { 575 throw new RuntimeException("not implemented"); 576 } 577 578 @Override 579 public int getRestoreDefaultNetworkDelay(int networkType) { 580 throw new RuntimeException("not implemented"); 581 } 582 583 @Override 584 protected void dump(FileDescriptor fd, PrintWriter writer, String[] args) { 585 throw new RuntimeException("not implemented"); 586 } 587 588 public void setAcceptUnvalidated(Network network, boolean accept, boolean always) { 589 throw new RuntimeException("not implemented"); 590 } 591 592 public int tether(String iface) { 593 throw new RuntimeException("not implemented"); 594 } 595 596 public int untether(String iface) { 597 throw new RuntimeException("not implemented"); 598 } 599 600 public int getLastTetherError(String iface) { 601 throw new RuntimeException("not implemented"); 602 } 603 604 public String[] getTetherableUsbRegexs() { 605 throw new RuntimeException("not implemented"); 606 } 607 608 public String[] getTetherableWifiRegexs() { 609 throw new RuntimeException("not implemented"); 610 } 611 612 public String[] getTetherableBluetoothRegexs() { 613 throw new RuntimeException("not implemented"); 614 } 615 616 public int setUsbTethering(boolean enable) { 617 throw new RuntimeException("not implemented"); 618 } 619 620 public String[] getTetherableIfaces() { 621 throw new RuntimeException("not implemented"); 622 } 623 624 public String[] getTetheredIfaces() { 625 throw new RuntimeException("not implemented"); 626 } 627 628 public String[] getTetheringErroredIfaces() { 629 throw new RuntimeException("not implemented"); 630 } 631 632 public String[] getTetheredDhcpRanges() { 633 throw new RuntimeException("not implemented"); 634 } 635 636 @Override 637 public boolean isTetheringSupported() { 638 throw new RuntimeException("not implemented"); 639 } 640 641// @Override 642// public void startTethering(int type, ResultReceiver receiver, boolean showProvisioningUi) { 643// throw new RuntimeException("not implemented"); 644// } 645 646// @Override 647// public void stopTethering(int type) { 648// throw new RuntimeException("not implemented"); 649// } 650 651 652 public void reportInetCondition(int networkType, int percentage) { 653 throw new RuntimeException("not implemented"); 654 } 655 656 public void reportNetworkConnectivity(Network network, boolean hasConnectivity) { 657 throw new RuntimeException("not implemented"); 658 } 659 660 public ProxyInfo getProxyForNetwork(Network network) { 661 throw new RuntimeException("not implemented"); 662 } 663 664 public void setGlobalProxy(ProxyInfo proxyProperties) { 665 throw new RuntimeException("not implemented"); 666 } 667 668 public ProxyInfo getGlobalProxy() { 669 throw new RuntimeException("not implemented"); 670 } 671 672 @Override 673 public boolean prepareVpn(@Nullable String oldPackage, @Nullable String newPackage, 674 int userId) { 675 throw new RuntimeException("not implemented"); 676 } 677 678 public void setVpnPackageAuthorization(String packageName, int userId, boolean authorized) { 679 throw new RuntimeException("not implemented"); 680 } 681 682 @Override 683 public ParcelFileDescriptor establishVpn(VpnConfig config) { 684 throw new RuntimeException("not implemented"); 685 } 686 687 @Override 688 public void startLegacyVpn(VpnProfile profile) { 689 throw new RuntimeException("not implemented"); 690 } 691 692 @Override 693 public LegacyVpnInfo getLegacyVpnInfo(int userId) { 694 throw new RuntimeException("not implemented"); 695 } 696 697 @Override 698 public VpnInfo[] getAllVpnInfo() { 699 throw new RuntimeException("not implemented"); 700 } 701 702 @Override 703 public VpnConfig getVpnConfig(int userId) { 704 throw new RuntimeException("not implemented"); 705 } 706 707 @Override 708 public boolean updateLockdownVpn() { 709 throw new RuntimeException("not implemented"); 710 } 711 712// @Override 713// public boolean setAlwaysOnVpnPackage(int userId, String packageName) { 714// throw new RuntimeException("not implemented"); 715// } 716 717// @Override 718// public String getAlwaysOnVpnPackage(int userId) { 719// throw new RuntimeException("not implemented"); 720// } 721 722 @Override 723 public int checkMobileProvisioning(int suggestedTimeOutMs) { 724 throw new RuntimeException("not implemented"); 725 } 726 727 @Override 728 public String getMobileProvisioningUrl() { 729 throw new RuntimeException("not implemented"); 730 } 731 732 @Override 733 public void setProvisioningNotificationVisible(boolean visible, int networkType, 734 String action) { 735 throw new RuntimeException("not implemented"); 736 } 737 738 @Override 739 public void setAirplaneMode(boolean enable) { 740 throw new RuntimeException("not implemented"); 741 } 742 743 @Override 744 public NetworkRequest requestNetwork(NetworkCapabilities networkCapabilities, 745 Messenger messenger, int timeoutMs, IBinder binder, int legacyType) { 746 networkCapabilities = new NetworkCapabilities(networkCapabilities); 747 748 if (timeoutMs < 0 || timeoutMs > ConnectivityManager.MAX_NETWORK_REQUEST_TIMEOUT_MS) { 749 throw new IllegalArgumentException("Bad timeout specified"); 750 } 751 752 NetworkRequest networkRequest = new NetworkRequest(networkCapabilities, legacyType, 753 nextNetworkRequestId()); 754 NetworkRequestInfo nri = new NetworkRequestInfo(messenger, networkRequest, binder, 755 NetworkRequestInfo.REQUEST); 756 if (DBG) log("requestNetwork for " + nri); 757 758 mHandler.sendMessage(mHandler.obtainMessage(EVENT_REGISTER_NETWORK_REQUEST, nri)); 759 760 return networkRequest; 761 } 762 763 @Override 764 public boolean requestBandwidthUpdate(Network network) { 765 throw new RuntimeException("not implemented"); 766 } 767 768 769 @Override 770 public NetworkRequest pendingRequestForNetwork(NetworkCapabilities networkCapabilities, 771 PendingIntent operation) { 772 throw new RuntimeException("not implemented"); 773 } 774 775 @Override 776 public void releasePendingNetworkRequest(PendingIntent operation) { 777 throw new RuntimeException("not implemented"); 778 } 779 780 @Override 781 public NetworkRequest listenForNetwork(NetworkCapabilities networkCapabilities, 782 Messenger messenger, IBinder binder) { 783 throw new RuntimeException("not implemented"); 784 } 785 786 @Override 787 public void pendingListenForNetwork(NetworkCapabilities networkCapabilities, 788 PendingIntent operation) { 789 throw new RuntimeException("not implemented"); 790 } 791 792 @Override 793 public void releaseNetworkRequest(NetworkRequest networkRequest) { 794 mHandler.sendMessage(mHandler.obtainMessage(EVENT_RELEASE_NETWORK_REQUEST, getCallingUid(), 795 0, networkRequest)); 796 } 797 798 @Override 799 public void registerNetworkFactory(Messenger messenger, String name) { 800 NetworkFactoryInfo nfi = new NetworkFactoryInfo(name, messenger, new AsyncChannel()); 801 mHandler.sendMessage(mHandler.obtainMessage(EVENT_REGISTER_NETWORK_FACTORY, nfi)); 802 } 803 804 private void handleRegisterNetworkFactory(NetworkFactoryInfo nfi) { 805 if (DBG) log("Got NetworkFactory Messenger for " + nfi.name); 806 mNetworkFactoryInfos.put(nfi.messenger, nfi); 807 nfi.asyncChannel.connect(mContext, mTrackerHandler, nfi.messenger); 808 } 809 810 @Override 811 public void unregisterNetworkFactory(Messenger messenger) { 812 mHandler.sendMessage(mHandler.obtainMessage(EVENT_UNREGISTER_NETWORK_FACTORY, messenger)); 813 } 814 815 private void handleUnregisterNetworkFactory(Messenger messenger) { 816 NetworkFactoryInfo nfi = mNetworkFactoryInfos.remove(messenger); 817 if (nfi == null) { 818 loge("Failed to find Messenger in unregisterNetworkFactory"); 819 return; 820 } 821 if (DBG) log("unregisterNetworkFactory for " + nfi.name); 822 } 823 824 public int registerNetworkAgent(Messenger messenger, NetworkInfo networkInfo, 825 LinkProperties linkProperties, NetworkCapabilities networkCapabilities, 826 int currentScore, NetworkMisc networkMisc) { 827// final NetworkAgentInfo nai = new NetworkAgentInfo(messenger, new AsyncChannel(), 828// new Network(reserveNetId()), new NetworkInfo(networkInfo), new LinkProperties( 829// linkProperties), new NetworkCapabilities(networkCapabilities), currentScore, 830// mContext, mTrackerHandler, new NetworkMisc(networkMisc), mDefaultRequest, this); 831// synchronized (this) { 832// nai.networkMonitor.systemReady = mSystemReady; 833// } 834// mHandler.sendMessage(mHandler.obtainMessage(EVENT_REGISTER_NETWORK_AGENT, nai)); 835// return nai.network.netId; 836 throw new RuntimeException("not implemented"); 837 } 838 839 private void handleRegisterNetworkAgent(NetworkAgentInfo na) { 840 if (VDBG) log("Got NetworkAgent Messenger"); 841// mNetworkAgentInfos.put(na.messenger, na); 842// synchronized (mNetworkForNetId) { 843// mNetworkForNetId.put(na.network.netId, na); 844// } 845// na.asyncChannel.connect(mContext, mTrackerHandler, na.messenger); 846// NetworkInfo networkInfo = na.networkInfo; 847// na.networkInfo = null; 848// updateNetworkInfo(na, networkInfo); 849 } 850 851 852 private void handleRegisterNetworkRequest(NetworkRequestInfo nri) { 853 mNetworkRequests.put(nri.request, nri); 854 if (!nri.isRequest) { 855 for (NetworkAgentInfo network : mNetworkAgentInfos.values()) { 856 if (nri.request.networkCapabilities.hasSignalStrength() && 857 network.satisfiesImmutableCapabilitiesOf(nri.request)) { 858 } 859 } 860 } 861 rematchAllNetworksAndRequests(null, 0); 862 if (nri.isRequest) { 863 sendUpdatedScoreToFactories(nri.request, 0); 864 } 865 } 866 867 private void handleReleaseNetworkRequest(NetworkRequest request, int callingUid) { 868 NetworkRequestInfo nri = mNetworkRequests.get(request); 869 if (nri != null) { 870 if (DBG) log("releasing NetworkRequest " + request); 871 nri.unlinkDeathRecipient(); 872 mNetworkRequests.remove(request); 873 if (nri.isRequest) { 874 // Find all networks that are satisfying this request and remove the request 875 // from their request lists. 876 // TODO - it's my understanding that for a request there is only a single 877 // network satisfying it, so this loop is wasteful 878 //boolean wasKept = false; 879 //for (NetworkAgentInfo nai : mNetworkAgentInfos.values()) { 880 // if (nai.networkRequests.get(nri.request.requestId) != null) { 881 // nai.networkRequests.remove(nri.request.requestId); 882 // if (DBG) { 883 // log(" Removing from current network " + nai.name() + 884 // ", leaving " + nai.networkRequests.size() + 885 // " requests."); 886 // } 887 // if (unneeded(nai)) { 888 // if (DBG) log("no live requests for " + nai.name() + "; disconnecting"); 889 // teardownUnneededNetwork(nai); 890 // } else { 891 // // suspect there should only be one pass through here 892 // // but if any were kept do the check below 893 // wasKept |= true; 894 // } 895 // } 896 //} 897 898 //NetworkAgentInfo nai = mNetworkForRequestId.get(nri.request.requestId); 899 //if (nai != null) { 900 // mNetworkForRequestId.remove(nri.request.requestId); 901 //} 902 // Maintain the illusion. When this request arrived, we might have pretended 903 // that a network connected to serve it, even though the network was already 904 // connected. Now that this request has gone away, we might have to pretend 905 // that the network disconnected. LegacyTypeTracker will generate that 906 // phantom disconnect for this type. 907 //if (nri.request.legacyType != TYPE_NONE && nai != null) { 908 // boolean doRemove = true; 909 // if (wasKept) { 910 // // check if any of the remaining requests for this network are for the 911 // // same legacy type - if so, don't remove the nai 912 // for (int i = 0; i < nai.networkRequests.size(); i++) { 913 // NetworkRequest otherRequest = nai.networkRequests.valueAt(i); 914 // if (otherRequest.legacyType == nri.request.legacyType && 915 // isRequest(otherRequest)) { 916 // if (DBG) log(" still have other legacy request - leaving"); 917 // doRemove = false; 918 // } 919 // } 920 // } 921 // 922 // if (doRemove) { 923 // mLegacyTypeTracker.remove(nri.request.legacyType, nai, false); 924 // } 925 //} 926 927 for (NetworkFactoryInfo nfi : mNetworkFactoryInfos.values()) { 928 nfi.asyncChannel.sendMessage(android.net.NetworkFactory.CMD_CANCEL_REQUEST, 929 nri.request); 930 } 931 } else { 932 // listens don't have a singular affectedNetwork. Check all networks to see 933 // if this listen request applies and remove it. 934 //for (NetworkAgentInfo nai : mNetworkAgentInfos.values()) { 935 // nai.networkRequests.remove(nri.request.requestId); 936 // if (nri.request.networkCapabilities.hasSignalStrength() && 937 // nai.satisfiesImmutableCapabilitiesOf(nri.request)) { 938 // updateSignalStrengthThresholds(nai, "RELEASE", nri.request); 939 // } 940 //} 941 } 942 //callCallbackForRequest(nri, null, ConnectivityManager.CALLBACK_RELEASED); 943 } 944 } 945 946 private void sendUpdatedScoreToFactories(NetworkAgentInfo nai) { 947 for (int i = 0; i < nai.networkRequests.size(); i++) { 948 NetworkRequest nr = nai.networkRequests.valueAt(i); 949 // Don't send listening requests to factories. b/17393458 950 if (!isRequest(nr)) continue; 951 sendUpdatedScoreToFactories(nr, nai.getCurrentScore()); 952 } 953 } 954 955 private void sendUpdatedScoreToFactories(NetworkRequest networkRequest, int score) { 956 if (VDBG) log("sending new Min Network Score(" + score + "): " + networkRequest.toString()); 957 for (NetworkFactoryInfo nfi : mNetworkFactoryInfos.values()) { 958 nfi.asyncChannel.sendMessage(android.net.NetworkFactory.CMD_REQUEST_NETWORK, score, 0, 959 networkRequest); 960 } 961 } 962 963 private void rematchAllNetworksAndRequests(NetworkAgentInfo changed, int oldScore) { 964 } 965 966 @Override 967 public void onSendFinished(PendingIntent pendingIntent, Intent intent, int resultCode, 968 String resultData, Bundle resultExtras) { 969 throw new RuntimeException("not implemented"); 970 } 971 972 @Override 973 public boolean addVpnAddress(String address, int prefixLength) { 974 throw new RuntimeException("not implemented"); 975 } 976 977 @Override 978 public boolean removeVpnAddress(String address, int prefixLength) { 979 throw new RuntimeException("not implemented"); 980 } 981 982 @Override 983 public boolean setUnderlyingNetworksForVpn(Network[] networks) { 984 throw new RuntimeException("not implemented"); 985 } 986 987// @Override 988// public String getCaptivePortalServerUrl() { 989// throw new RuntimeException("not implemented"); 990// } 991 992 @Override 993 public void startNattKeepalive(Network network, int intervalSeconds, Messenger messenger, 994 IBinder binder, String srcAddr, int srcPort, String dstAddr) { 995 throw new RuntimeException("not implemented"); 996 } 997 998 @Override 999 public void stopKeepalive(Network network, int slot) { 1000 throw new RuntimeException("not implemented"); 1001 } 1002 1003 @Override 1004 public void factoryReset() { 1005 throw new RuntimeException("not implemented"); 1006 } 1007 1008 @VisibleForTesting 1009 public NetworkMonitor createNetworkMonitor(Context context, Handler handler, 1010 NetworkAgentInfo nai, NetworkRequest defaultRequest) { 1011 throw new RuntimeException("not implemented"); 1012 } 1013 1014 private NetworkRequest mDefaultRequest = null; 1015 @VisibleForTesting 1016 public synchronized void addDefaultRequest() { 1017 if (mDefaultRequest != null) return; 1018 NetworkCapabilities netCap = new NetworkCapabilities(); 1019 netCap.addCapability(NET_CAPABILITY_INTERNET); 1020 netCap.addCapability(NET_CAPABILITY_NOT_RESTRICTED); 1021 mDefaultRequest = requestNetwork(netCap, null, 0, new Binder(), 1022 ConnectivityManager.TYPE_NONE); 1023 } 1024 1025 @VisibleForTesting 1026 public synchronized void removeDefaultRequest() { 1027 if (mDefaultRequest == null) return; 1028 releaseNetworkRequest(mDefaultRequest); 1029 mDefaultRequest = null; 1030 } 1031 1032 1033} 1034