Merge "[NS04] Introduce Network Offers and their callbacks"

        provider.setProviderId(NetworkProvider.ID_NONE);

    }

    /**

     * Register or update a network offer with ConnectivityService.

     *

     * ConnectivityService keeps track of offers made by the various providers and matches

     * them to networking requests made by apps or the system. The provider supplies a score

     * and the capabilities of the network it might be able to bring up ; these act as filters

     * used by ConnectivityService to only send those requests that can be fulfilled by the

     * provider.

     *

     * The provider is under no obligation to be able to bring up the network it offers at any

     * given time. Instead, this mechanism is meant to limit requests received by providers

     * to those they actually have a chance to fulfill, as providers don't have a way to compare

     * the quality of the network satisfying a given request to their own offer.

     *

     * An offer can be updated by calling this again with the same callback object. This is

     * similar to calling unofferNetwork and offerNetwork again, but will only update the

     * provider with the changes caused by the changes in the offer.

     *

     * @param provider The provider making this offer.

     * @param score The prospective score of the network.

     * @param caps The prospective capabilities of the network.

     * @param callback The callback to call when this offer is needed or unneeded.

     * @hide

     */

    @RequiresPermission(anyOf = {

            NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK,

            android.Manifest.permission.NETWORK_FACTORY})

    public void offerNetwork(@NonNull final NetworkProvider provider,

            @NonNull final NetworkScore score, @NonNull final NetworkCapabilities caps,

            @NonNull final INetworkOfferCallback callback) {

        try {

            mService.offerNetwork(Objects.requireNonNull(provider.getMessenger(), "null messenger"),

                    Objects.requireNonNull(score, "null score"),

                    Objects.requireNonNull(caps, "null caps"),

                    Objects.requireNonNull(callback, "null callback"));

        } catch (RemoteException e) {

            throw e.rethrowFromSystemServer();

        }

    }

    /**

     * Withdraw a network offer made with {@link #offerNetwork}.

     *

     * @param callback The callback passed at registration time. This must be the same object

     *                 that was passed to {@link #offerNetwork}

     * @hide

     */

    public void unofferNetwork(@NonNull final INetworkOfferCallback callback) {

        try {

            mService.unofferNetwork(Objects.requireNonNull(callback));

        } catch (RemoteException e) {

            throw e.rethrowFromSystemServer();

        }

    }

    /** @hide exposed via the NetworkProvider class. */

    @RequiresPermission(anyOf = {

            NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK,

import android.net.INetworkAgent;

import android.net.IOnCompleteListener;

import android.net.INetworkActivityListener;

import android.net.INetworkOfferCallback;

import android.net.IQosCallback;

import android.net.ISocketKeepaliveCallback;

import android.net.LinkProperties;

            in IOnCompleteListener listener);

    int getRestrictBackgroundStatusByCaller();

    void offerNetwork(in Messenger messenger, in NetworkScore score,

            in NetworkCapabilities caps, in INetworkOfferCallback callback);

    void unofferNetwork(in INetworkOfferCallback callback);

}

/*

 * 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.net.NetworkRequest;

/**

 * A callback registered with connectivity by network providers together with

 * a NetworkOffer.

 *

 * When the offer is needed to satisfy some application or system component,

 * connectivity will call onOfferNeeded on this callback. When this happens,

 * the provider should try and bring up the network.

 *

 * When the offer is no longer needed, for example because the application has

 * withdrawn the request or if the request is being satisfied by a network

 * that this offer will never be able to beat, connectivity calls

 * onOfferUnneeded. When this happens, the provider should stop trying to

 * bring up the network, or tear it down if it has already been brought up.

 *

 * When NetworkProvider#offerNetwork is called, the provider can expect to

 * immediately receive all requests that can be fulfilled by that offer and

 * are not already satisfied by a better network. It is possible no such

 * request is currently outstanding, because no requests have been made that

 * can be satisfied by this offer, or because all such requests are already

 * satisfied by a better network.

 * onOfferNeeded can be called at any time after registration and until the

 * offer is withdrawn with NetworkProvider#unofferNetwork is called. This

 * typically happens when a new network request is filed by an application,

 * or when the network satisfying a request disconnects and this offer now

 * stands a chance to be the best network for it.

 *

 * @hide

 */

oneway interface INetworkOfferCallback {

    /**

     * Informs the registrant that the offer is needed to fulfill this request.

     * @param networkRequest the request to satisfy

     * @param providerId the ID of the provider currently satisfying

     *          this request, or NetworkProvider.ID_NONE if none.

     */

    void onOfferNeeded(in NetworkRequest networkRequest, int providerId);

    /**

     * Informs the registrant that the offer is no longer needed to fulfill this request.

     */

    void onOfferUnneeded(in NetworkRequest networkRequest);

}

import android.os.Messenger;

import android.util.Log;

import com.android.internal.annotations.GuardedBy;

import java.util.ArrayList;

import java.util.concurrent.Executor;

/**

 * Base class for network providers such as telephony or Wi-Fi. NetworkProviders connect the device

 * to networks and makes them available to the core network stack by creating

     */

    @SystemApi

    public NetworkProvider(@NonNull Context context, @NonNull Looper looper, @NonNull String name) {

        Handler handler = new Handler(looper) {

        // TODO (b/174636568) : this class should be able to cache an instance of

        // ConnectivityManager so it doesn't have to fetch it again every time.

        final Handler handler = new Handler(looper) {

            @Override

            public void handleMessage(Message m) {

                switch (m.what) {

    public void declareNetworkRequestUnfulfillable(@NonNull NetworkRequest request) {

        ConnectivityManager.from(mContext).declareNetworkRequestUnfulfillable(request);

    }

    /** @hide */

    // TODO : make @SystemApi when the impl is complete

    public interface NetworkOfferCallback {

        /** Called by the system when this offer is needed to satisfy some networking request. */

        void onOfferNeeded(@NonNull NetworkRequest request, int providerId);

        /** Called by the system when this offer is no longer needed. */

        void onOfferUnneeded(@NonNull NetworkRequest request);

    }

    private class NetworkOfferCallbackProxy extends INetworkOfferCallback.Stub {

        @NonNull public final NetworkOfferCallback callback;

        @NonNull private final Executor mExecutor;

        NetworkOfferCallbackProxy(@NonNull final NetworkOfferCallback callback,

                @NonNull final Executor executor) {

            this.callback = callback;

            this.mExecutor = executor;

        }

        @Override

        public void onOfferNeeded(final @NonNull NetworkRequest request,

                final int providerId) {

            mExecutor.execute(() -> callback.onOfferNeeded(request, providerId));

        }

        @Override

        public void onOfferUnneeded(final @NonNull NetworkRequest request) {

            mExecutor.execute(() -> callback.onOfferUnneeded(request));

        }

    }

    @GuardedBy("mProxies")

    @NonNull private final ArrayList<NetworkOfferCallbackProxy> mProxies = new ArrayList<>();

    // Returns the proxy associated with this callback, or null if none.

    @Nullable

    private NetworkOfferCallbackProxy findProxyForCallback(@NonNull final NetworkOfferCallback cb) {

        synchronized (mProxies) {

            for (final NetworkOfferCallbackProxy p : mProxies) {

                if (p.callback == cb) return p;

            }

        }

        return null;

    }

    /**

     * Register or update an offer for network with the passed caps and score.

     *

     * A NetworkProvider's job is to provide networks. This function is how a provider tells the

     * connectivity stack what kind of network it may provide. The score and caps arguments act

     * as filters that the connectivity stack uses to tell when the offer is necessary. When an

     * offer might be advantageous over existing networks, the provider will receive a call to

     * the associated callback's {@link NetworkOfferCallback#onOfferNeeded} method. The provider

     * should then try to bring up this network. When an offer is no longer needed, the stack

     * will inform the provider by calling {@link NetworkOfferCallback#onOfferUnneeded}. The

     * provider should stop trying to bring up such a network, or disconnect it if it already has

     * one.

     *

     * The stack determines what offers are needed according to what networks are currently

     * available to the system, and what networking requests are made by applications. If an

     * offer looks like it could be a better choice than any existing network for any particular

     * request, that's when the stack decides the offer is needed. If the current networking

     * requests are all satisfied by networks that this offer can't possibly be a better match

     * for, that's when the offer is unneeded. An offer starts off as unneeded ; the provider

     * should not try to bring up the network until {@link NetworkOfferCallback#onOfferNeeded}

     * is called.

     *

     * Note that the offers are non-binding to the providers, in particular because providers

     * often don't know if they will be able to bring up such a network at any given time. For

     * example, no wireless network may be in range when the offer is needed. This is fine and

     * expected ; the provider should simply continue to try to bring up the network and do so

     * if/when it becomes possible. In the mean time, the stack will continue to satisfy requests

     * with the best network currently available, or if none, keep the apps informed that no

     * network can currently satisfy this request. When/if the provider can bring up the network,

     * the connectivity stack will match it against requests, and inform interested apps of the

     * availability of this network. This may, in turn, render the offer of some other provider

     * unneeded if all requests it used to satisfy are now better served by this network.

     *

     * A network can become unneeded for a reason like the above : whether the provider managed

     * to bring up the offered network after it became needed or not, some other provider may

     * bring up a better network than this one, making this offer unneeded. A network may also

     * become unneeded if the application making the request withdrew it (for example, after it

     * is done transferring data, or if the user canceled an operation).

     *

     * The capabilities and score act as filters as to what requests the provider will see.

     * They are not promises, but for best performance, the providers should strive to put

     * as much known information as possible in the offer. For capabilities in particular, it

     * should put all NetworkAgent-managed capabilities a network may have, even if it doesn't

     * have them at first. This applies to INTERNET, for example ; if a provider thinks the

     * network it can bring up for this offer may offer Internet access it should include the

     * INTERNET bit. It's fine if the brought up network ends up not actually having INTERNET.

     *

     * TODO : in the future, to avoid possible infinite loops, there should be constraints on

     * what can be put in capabilities of networks brought up for an offer. If a provider might

     * bring up a network with or without INTERNET, then it should file two offers : this will

     * let it know precisely what networks are needed, so it can avoid bringing up networks that

     * won't actually satisfy requests and remove the risk for bring-up-bring-down loops.

     *

     * @hide

     */

    // TODO : make @SystemApi when the impl is complete

    @RequiresPermission(android.Manifest.permission.NETWORK_FACTORY)

    public void offerNetwork(@NonNull final NetworkScore score,

            @NonNull final NetworkCapabilities caps, @NonNull final Executor executor,

            @NonNull final NetworkOfferCallback callback) {

        NetworkOfferCallbackProxy proxy = null;

        synchronized (mProxies) {

            for (final NetworkOfferCallbackProxy existingProxy : mProxies) {

                if (existingProxy.callback == callback) {

                    proxy = existingProxy;

                    break;

                }

            }

            if (null == proxy) {

                proxy = new NetworkOfferCallbackProxy(callback, executor);

                mProxies.add(proxy);

            }

        }

        mContext.getSystemService(ConnectivityManager.class).offerNetwork(this, score, caps, proxy);

    }

    /**

     * Withdraw a network offer previously made to the networking stack.

     *

     * If a provider can no longer provide a network they offered, it should call this method.

     * An example of usage could be if the hardware necessary to bring up the network was turned

     * off in UI by the user. Note that because offers are never binding, the provider might

     * alternatively decide not to withdraw this offer and simply refuse to bring up the network

     * even when it's needed. However, withdrawing the request is slightly more resource-efficient

     * because the networking stack won't have to compare this offer to exiting networks to see

     * if it could beat any of them, and may be advantageous to the provider's implementation that

     * can rely on no longer receiving callbacks for a network that they can't bring up anyways.

     *

     * @hide

     */

    // TODO : make @SystemApi when the impl is complete

    @RequiresPermission(android.Manifest.permission.NETWORK_FACTORY)

    public void unofferNetwork(final @NonNull NetworkOfferCallback callback) {

        final NetworkOfferCallbackProxy proxy = findProxyForCallback(callback);

        if (null == proxy) return;

        mProxies.remove(proxy);

        mContext.getSystemService(ConnectivityManager.class).unofferNetwork(proxy);

    }

}

        "java/com/android/server/connectivity/NetworkAgentInfo.java",

        "java/com/android/server/connectivity/NetworkDiagnostics.java",

        "java/com/android/server/connectivity/NetworkNotificationManager.java",

        "java/com/android/server/connectivity/NetworkOffer.java",

        "java/com/android/server/connectivity/NetworkRanker.java",

        "java/com/android/server/connectivity/PermissionMonitor.java",

        "java/com/android/server/connectivity/ProxyTracker.java",