common/device/android/net/NetworkFactoryImpl.java - platform/frameworks/libs/net - Git at Google

 /*
  * Copyright (C) 2021 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.annotation.NonNull;
 import android.annotation.Nullable;
 import android.content.Context;
 import android.net.NetworkProvider.NetworkOfferCallback;
 import android.os.Looper;
 import android.os.Message;

 import java.io.FileDescriptor;
 import java.io.PrintWriter;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.concurrent.Executor;

 /**
  * A NetworkFactory is an entity that creates NetworkAgent objects.
  * The bearers register with ConnectivityService using {@link #register} and
  * their factory will start receiving scored NetworkRequests.  NetworkRequests
  * can be filtered 3 ways: by NetworkCapabilities, by score and more complexly by
  * overridden function.  All of these can be dynamic - changing NetworkCapabilities
  * or score forces re-evaluation of all current requests.
  *
  * If any requests pass the filter some overrideable functions will be called.
  * If the bearer only cares about very simple start/stopNetwork callbacks, those
  * functions can be overridden.  If the bearer needs more interaction, it can
  * override addNetworkRequest and removeNetworkRequest which will give it each
  * request that passes their current filters.
  * @hide
  **/
 // TODO(b/187083878): factor out common code between this and NetworkFactoryLegacyImpl
 class NetworkFactoryImpl extends NetworkFactoryLegacyImpl {
     private static final boolean DBG = NetworkFactory.DBG;
     private static final boolean VDBG = NetworkFactory.VDBG;

     // A score that will win against everything, so that score filtering will let all requests
     // through
     // TODO : remove this and replace with an API to listen to all requests.
     @NonNull
     private static final NetworkScore INVINCIBLE_SCORE =
             new NetworkScore.Builder().setLegacyInt(1000).build();

     // TODO(b/187082970): Replace CMD_* with Handler.post(() -> { ... }) since all the CMDs do is to
     //  run the tasks asynchronously on the Handler thread.

     /**
      * Pass a network request to the bearer.  If the bearer believes it can
      * satisfy the request it should connect to the network and create a
      * NetworkAgent.  Once the NetworkAgent is fully functional it will
      * register itself with ConnectivityService using registerNetworkAgent.
      * If the bearer cannot immediately satisfy the request (no network,
      * user disabled the radio, lower-scored network) it should remember
      * any NetworkRequests it may be able to satisfy in the future.  It may
      * disregard any that it will never be able to service, for example
      * those requiring a different bearer.
      * msg.obj = NetworkRequest
      */
     // TODO : this and CANCEL_REQUEST are only used by telephony tests. Replace it in the tests
     // and remove them and the associated code.
     private static final int CMD_REQUEST_NETWORK = NetworkFactory.CMD_REQUEST_NETWORK;

     /**
      * Cancel a network request
      * msg.obj = NetworkRequest
      */
     private static final int CMD_CANCEL_REQUEST = NetworkFactory.CMD_CANCEL_REQUEST;

     /**
      * Internally used to set our best-guess score.
      * msg.obj = new score
      */
     private static final int CMD_SET_SCORE = 3;

     /**
      * Internally used to set our current filter for coarse bandwidth changes with
      * technology changes.
      * msg.obj = new filter
      */
     private static final int CMD_SET_FILTER = 4;

     /**
      * Internally used to send the network offer associated with this factory.
      * No arguments, will read from members
      */
     private static final int CMD_OFFER_NETWORK = 5;

     /**
      * Internally used to send the request to listen to all requests.
      * No arguments, will read from members
      */
     private static final int CMD_LISTEN_TO_ALL_REQUESTS = 6;

     private final Map<NetworkRequest, NetworkRequestInfo> mNetworkRequests =
             new LinkedHashMap<>();

     @NonNull private NetworkScore mScore = new NetworkScore.Builder().setLegacyInt(0).build();

     private final NetworkOfferCallback mRequestCallback = new NetworkOfferCallback() {
         @Override
         public void onNetworkNeeded(@NonNull final NetworkRequest request) {
             handleAddRequest(request);
         }

         @Override
         public void onNetworkUnneeded(@NonNull final NetworkRequest request) {
             handleRemoveRequest(request);
         }
     };
     @NonNull private final Executor mExecutor = command -> post(command);


     // Ideally the filter argument would be non-null, but null has historically meant to see
     // no requests and telephony passes null.
     NetworkFactoryImpl(NetworkFactory parent, Looper looper, Context context,
             @Nullable final NetworkCapabilities filter) {
         super(parent, looper, context,
                 null != filter ? filter :
                         NetworkCapabilities.Builder.withoutDefaultCapabilities().build());
     }

     /* Registers this NetworkFactory with the system. May only be called once per factory. */
     @Override public void register(final String logTag) {
         register(logTag, false);
     }

     /**
      * Registers this NetworkFactory with the system ignoring the score filter. This will let
      * the factory always see all network requests matching its capabilities filter.
      * May only be called once per factory.
      */
     @Override public void registerIgnoringScore(final String logTag) {
         register(logTag, true);
     }

     private void register(final String logTag, final boolean listenToAllRequests) {
         if (mProvider != null) {
             throw new IllegalStateException("A NetworkFactory must only be registered once");
         }
         if (DBG) mParent.log("Registering NetworkFactory");

         mProvider = new NetworkProvider(mContext, NetworkFactoryImpl.this.getLooper(), logTag) {
             @Override
             public void onNetworkRequested(@NonNull NetworkRequest request, int score,
                     int servingProviderId) {
                 handleAddRequest(request);
             }

             @Override
             public void onNetworkRequestWithdrawn(@NonNull NetworkRequest request) {
                 handleRemoveRequest(request);
             }
         };

         ((ConnectivityManager) mContext.getSystemService(
                 Context.CONNECTIVITY_SERVICE)).registerNetworkProvider(mProvider);

         // The mScore and mCapabilityFilter members can only be accessed on the handler thread.
         // TODO : offer a separate API to listen to all requests instead
         if (listenToAllRequests) {
             sendMessage(obtainMessage(CMD_LISTEN_TO_ALL_REQUESTS));
         } else {
             sendMessage(obtainMessage(CMD_OFFER_NETWORK));
         }
     }

     private void handleOfferNetwork(@NonNull final NetworkScore score) {
         mProvider.registerNetworkOffer(score, mCapabilityFilter, mExecutor, mRequestCallback);
     }

     @Override
     public void handleMessage(Message msg) {
         switch (msg.what) {
             case CMD_REQUEST_NETWORK: {
                 handleAddRequest((NetworkRequest) msg.obj);
                 break;
             }
             case CMD_CANCEL_REQUEST: {
                 handleRemoveRequest((NetworkRequest) msg.obj);
                 break;
             }
             case CMD_SET_SCORE: {
                 handleSetScore((NetworkScore) msg.obj);
                 break;
             }
             case CMD_SET_FILTER: {
                 handleSetFilter((NetworkCapabilities) msg.obj);
                 break;
             }
             case CMD_OFFER_NETWORK: {
                 handleOfferNetwork(mScore);
                 break;
             }
             case CMD_LISTEN_TO_ALL_REQUESTS: {
                 handleOfferNetwork(INVINCIBLE_SCORE);
                 break;
             }
         }
     }

     private static class NetworkRequestInfo {
         @NonNull public final NetworkRequest request;
         public boolean requested; // do we have a request outstanding, limited by score

         NetworkRequestInfo(@NonNull final NetworkRequest request) {
             this.request = request;
             this.requested = false;
         }

         @Override
         public String toString() {
             return "{" + request + ", requested=" + requested + "}";
         }
     }

     /**
      * Add a NetworkRequest that the bearer may want to attempt to satisfy.
      * @see #CMD_REQUEST_NETWORK
      *
      * @param request the request to handle.
      */
     private void handleAddRequest(@NonNull final NetworkRequest request) {
         NetworkRequestInfo n = mNetworkRequests.get(request);
         if (n == null) {
             if (DBG) mParent.log("got request " + request);
             n = new NetworkRequestInfo(request);
             mNetworkRequests.put(n.request, n);
         } else {
             if (VDBG) mParent.log("handle existing request " + request);
         }
         if (VDBG) mParent.log("  my score=" + mScore + ", my filter=" + mCapabilityFilter);

         if (mParent.acceptRequest(request)) {
             n.requested = true;
             mParent.needNetworkFor(request);
         }
     }

     private void handleRemoveRequest(NetworkRequest request) {
         NetworkRequestInfo n = mNetworkRequests.get(request);
         if (n != null) {
             mNetworkRequests.remove(request);
             if (n.requested) mParent.releaseNetworkFor(n.request);
         }
     }

     private void handleSetScore(@NonNull final NetworkScore score) {
         if (mScore.equals(score)) return;
         mScore = score;
         mParent.reevaluateAllRequests();
     }

     private void handleSetFilter(@NonNull final NetworkCapabilities netCap) {
         if (netCap.equals(mCapabilityFilter)) return;
         mCapabilityFilter = netCap;
         mParent.reevaluateAllRequests();
     }

     @Override public final void reevaluateAllRequests() {
         if (mProvider == null) return;
         mProvider.registerNetworkOffer(mScore, mCapabilityFilter, mExecutor, mRequestCallback);
     }

     /**
      * @deprecated this method was never part of the API (system or public) and is only added
      *   for migration of existing clients.
      */
     @Deprecated
     public void setScoreFilter(final int score) {
         setScoreFilter(new NetworkScore.Builder().setLegacyInt(score).build());
     }

     /**
      * Set a score filter for this factory.
      *
      * This should include the transports the factory knows its networks will have, and
      * an optimistic view of the attributes it may have. This does not commit the factory
      * to being able to bring up such a network ; it only lets it avoid hearing about
      * requests that it has no chance of fulfilling.
      *
      * @param score the filter
      */
     @Override public void setScoreFilter(@NonNull final NetworkScore score) {
         sendMessage(obtainMessage(CMD_SET_SCORE, score));
     }

     @Override public void setCapabilityFilter(NetworkCapabilities netCap) {
         sendMessage(obtainMessage(CMD_SET_FILTER, new NetworkCapabilities(netCap)));
     }

     @Override public int getRequestCount() {
         return mNetworkRequests.size();
     }

     @Override public void dump(FileDescriptor fd, PrintWriter writer, String[] args) {
         writer.println(toString());
         for (NetworkRequestInfo n : mNetworkRequests.values()) {
             writer.println("  " + n);
         }
     }

     @Override public String toString() {
         return "providerId="
                 + mProvider.getProviderId() + ", ScoreFilter="
                 + mScore + ", Filter=" + mCapabilityFilter + ", requests="
                 + mNetworkRequests.size();
     }
 }
	/*
	* Copyright (C) 2021 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.annotation.NonNull;
	import android.annotation.Nullable;
	import android.content.Context;
	import android.net.NetworkProvider.NetworkOfferCallback;
	import android.os.Looper;
	import android.os.Message;

	import java.io.FileDescriptor;
	import java.io.PrintWriter;
	import java.util.LinkedHashMap;
	import java.util.Map;
	import java.util.concurrent.Executor;

	/**
	* A NetworkFactory is an entity that creates NetworkAgent objects.
	* The bearers register with ConnectivityService using {@link #register} and
	* their factory will start receiving scored NetworkRequests. NetworkRequests
	* can be filtered 3 ways: by NetworkCapabilities, by score and more complexly by
	* overridden function. All of these can be dynamic - changing NetworkCapabilities
	* or score forces re-evaluation of all current requests.
	*
	* If any requests pass the filter some overrideable functions will be called.
	* If the bearer only cares about very simple start/stopNetwork callbacks, those
	* functions can be overridden. If the bearer needs more interaction, it can
	* override addNetworkRequest and removeNetworkRequest which will give it each
	* request that passes their current filters.
	* @hide
	**/
	// TODO(b/187083878): factor out common code between this and NetworkFactoryLegacyImpl
	class NetworkFactoryImpl extends NetworkFactoryLegacyImpl {
	private static final boolean DBG = NetworkFactory.DBG;
	private static final boolean VDBG = NetworkFactory.VDBG;

	// A score that will win against everything, so that score filtering will let all requests
	// through
	// TODO : remove this and replace with an API to listen to all requests.
	@NonNull
	private static final NetworkScore INVINCIBLE_SCORE =
	new NetworkScore.Builder().setLegacyInt(1000).build();

	// TODO(b/187082970): Replace CMD_* with Handler.post(() -> { ... }) since all the CMDs do is to
	// run the tasks asynchronously on the Handler thread.

	/**
	* Pass a network request to the bearer. If the bearer believes it can
	* satisfy the request it should connect to the network and create a
	* NetworkAgent. Once the NetworkAgent is fully functional it will
	* register itself with ConnectivityService using registerNetworkAgent.
	* If the bearer cannot immediately satisfy the request (no network,
	* user disabled the radio, lower-scored network) it should remember
	* any NetworkRequests it may be able to satisfy in the future. It may
	* disregard any that it will never be able to service, for example
	* those requiring a different bearer.
	* msg.obj = NetworkRequest
	*/
	// TODO : this and CANCEL_REQUEST are only used by telephony tests. Replace it in the tests
	// and remove them and the associated code.
	private static final int CMD_REQUEST_NETWORK = NetworkFactory.CMD_REQUEST_NETWORK;

	/**
	* Cancel a network request
	* msg.obj = NetworkRequest
	*/
	private static final int CMD_CANCEL_REQUEST = NetworkFactory.CMD_CANCEL_REQUEST;

	/**
	* Internally used to set our best-guess score.
	* msg.obj = new score
	*/
	private static final int CMD_SET_SCORE = 3;

	/**
	* Internally used to set our current filter for coarse bandwidth changes with
	* technology changes.
	* msg.obj = new filter
	*/
	private static final int CMD_SET_FILTER = 4;

	/**
	* Internally used to send the network offer associated with this factory.
	* No arguments, will read from members
	*/
	private static final int CMD_OFFER_NETWORK = 5;

	/**
	* Internally used to send the request to listen to all requests.
	* No arguments, will read from members
	*/
	private static final int CMD_LISTEN_TO_ALL_REQUESTS = 6;

	private final Map<NetworkRequest, NetworkRequestInfo> mNetworkRequests =
	new LinkedHashMap<>();

	@NonNull private NetworkScore mScore = new NetworkScore.Builder().setLegacyInt(0).build();

	private final NetworkOfferCallback mRequestCallback = new NetworkOfferCallback() {
	@Override
	public void onNetworkNeeded(@NonNull final NetworkRequest request) {
	handleAddRequest(request);
	}

	@Override
	public void onNetworkUnneeded(@NonNull final NetworkRequest request) {
	handleRemoveRequest(request);
	}
	};
	@NonNull private final Executor mExecutor = command -> post(command);


	// Ideally the filter argument would be non-null, but null has historically meant to see
	// no requests and telephony passes null.
	NetworkFactoryImpl(NetworkFactory parent, Looper looper, Context context,
	@Nullable final NetworkCapabilities filter) {
	super(parent, looper, context,
	null != filter ? filter :
	NetworkCapabilities.Builder.withoutDefaultCapabilities().build());
	}

	/* Registers this NetworkFactory with the system. May only be called once per factory. */
	@Override public void register(final String logTag) {
	register(logTag, false);
	}

	/**
	* Registers this NetworkFactory with the system ignoring the score filter. This will let
	* the factory always see all network requests matching its capabilities filter.
	* May only be called once per factory.
	*/
	@Override public void registerIgnoringScore(final String logTag) {
	register(logTag, true);
	}

	private void register(final String logTag, final boolean listenToAllRequests) {
	if (mProvider != null) {
	throw new IllegalStateException("A NetworkFactory must only be registered once");
	}
	if (DBG) mParent.log("Registering NetworkFactory");

	mProvider = new NetworkProvider(mContext, NetworkFactoryImpl.this.getLooper(), logTag) {
	@Override
	public void onNetworkRequested(@NonNull NetworkRequest request, int score,
	int servingProviderId) {
	handleAddRequest(request);
	}

	@Override
	public void onNetworkRequestWithdrawn(@NonNull NetworkRequest request) {
	handleRemoveRequest(request);
	}
	};

	((ConnectivityManager) mContext.getSystemService(
	Context.CONNECTIVITY_SERVICE)).registerNetworkProvider(mProvider);

	// The mScore and mCapabilityFilter members can only be accessed on the handler thread.
	// TODO : offer a separate API to listen to all requests instead
	if (listenToAllRequests) {
	sendMessage(obtainMessage(CMD_LISTEN_TO_ALL_REQUESTS));
	} else {
	sendMessage(obtainMessage(CMD_OFFER_NETWORK));
	}
	}

	private void handleOfferNetwork(@NonNull final NetworkScore score) {
	mProvider.registerNetworkOffer(score, mCapabilityFilter, mExecutor, mRequestCallback);
	}

	@Override
	public void handleMessage(Message msg) {
	switch (msg.what) {
	case CMD_REQUEST_NETWORK: {
	handleAddRequest((NetworkRequest) msg.obj);
	break;
	}
	case CMD_CANCEL_REQUEST: {
	handleRemoveRequest((NetworkRequest) msg.obj);
	break;
	}
	case CMD_SET_SCORE: {
	handleSetScore((NetworkScore) msg.obj);
	break;
	}
	case CMD_SET_FILTER: {
	handleSetFilter((NetworkCapabilities) msg.obj);
	break;
	}
	case CMD_OFFER_NETWORK: {
	handleOfferNetwork(mScore);
	break;
	}
	case CMD_LISTEN_TO_ALL_REQUESTS: {
	handleOfferNetwork(INVINCIBLE_SCORE);
	break;
	}
	}
	}

	private static class NetworkRequestInfo {
	@NonNull public final NetworkRequest request;
	public boolean requested; // do we have a request outstanding, limited by score

	NetworkRequestInfo(@NonNull final NetworkRequest request) {
	this.request = request;
	this.requested = false;
	}

	@Override
	public String toString() {
	return "{" + request + ", requested=" + requested + "}";
	}
	}

	/**
	* Add a NetworkRequest that the bearer may want to attempt to satisfy.
	* @see #CMD_REQUEST_NETWORK
	*
	* @param request the request to handle.
	*/
	private void handleAddRequest(@NonNull final NetworkRequest request) {
	NetworkRequestInfo n = mNetworkRequests.get(request);
	if (n == null) {
	if (DBG) mParent.log("got request " + request);
	n = new NetworkRequestInfo(request);
	mNetworkRequests.put(n.request, n);
	} else {
	if (VDBG) mParent.log("handle existing request " + request);
	}
	if (VDBG) mParent.log(" my score=" + mScore + ", my filter=" + mCapabilityFilter);

	if (mParent.acceptRequest(request)) {
	n.requested = true;
	mParent.needNetworkFor(request);
	}
	}

	private void handleRemoveRequest(NetworkRequest request) {
	NetworkRequestInfo n = mNetworkRequests.get(request);
	if (n != null) {
	mNetworkRequests.remove(request);
	if (n.requested) mParent.releaseNetworkFor(n.request);
	}
	}

	private void handleSetScore(@NonNull final NetworkScore score) {
	if (mScore.equals(score)) return;
	mScore = score;
	mParent.reevaluateAllRequests();
	}

	private void handleSetFilter(@NonNull final NetworkCapabilities netCap) {
	if (netCap.equals(mCapabilityFilter)) return;
	mCapabilityFilter = netCap;
	mParent.reevaluateAllRequests();
	}

	@Override public final void reevaluateAllRequests() {
	if (mProvider == null) return;
	mProvider.registerNetworkOffer(mScore, mCapabilityFilter, mExecutor, mRequestCallback);
	}

	/**
	* @deprecated this method was never part of the API (system or public) and is only added
	* for migration of existing clients.
	*/
	@Deprecated
	public void setScoreFilter(final int score) {
	setScoreFilter(new NetworkScore.Builder().setLegacyInt(score).build());
	}

	/**
	* Set a score filter for this factory.
	*
	* This should include the transports the factory knows its networks will have, and
	* an optimistic view of the attributes it may have. This does not commit the factory
	* to being able to bring up such a network ; it only lets it avoid hearing about
	* requests that it has no chance of fulfilling.
	*
	* @param score the filter
	*/
	@Override public void setScoreFilter(@NonNull final NetworkScore score) {
	sendMessage(obtainMessage(CMD_SET_SCORE, score));
	}

	@Override public void setCapabilityFilter(NetworkCapabilities netCap) {
	sendMessage(obtainMessage(CMD_SET_FILTER, new NetworkCapabilities(netCap)));
	}

	@Override public int getRequestCount() {
	return mNetworkRequests.size();
	}

	@Override public void dump(FileDescriptor fd, PrintWriter writer, String[] args) {
	writer.println(toString());
	for (NetworkRequestInfo n : mNetworkRequests.values()) {
	writer.println(" " + n);
	}
	}

	@Override public String toString() {
	return "providerId="
	+ mProvider.getProviderId() + ", ScoreFilter="
	+ mScore + ", Filter=" + mCapabilityFilter + ", requests="
	+ mNetworkRequests.size();
	}
	}