Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e1c836c4 authored by Isaac Katzenelson's avatar Isaac Katzenelson Committed by Automerger Merge Worker
Browse files

Merge "Add getters to SharedConnectivityService" into udc-dev am: 32520630

parents 91176843 32520630
Loading
Loading
Loading
Loading
+5 −0
Original line number Diff line number Diff line
@@ -10075,6 +10075,11 @@ package android.net.wifi.sharedconnectivity.app {
    method public boolean connectTetherNetwork(@NonNull android.net.wifi.sharedconnectivity.app.TetherNetwork);
    method public boolean disconnectTetherNetwork(@NonNull android.net.wifi.sharedconnectivity.app.TetherNetwork);
    method public boolean forgetKnownNetwork(@NonNull android.net.wifi.sharedconnectivity.app.KnownNetwork);
    method @Nullable public android.net.wifi.sharedconnectivity.app.KnownNetworkConnectionStatus getKnownNetworkConnectionStatus();
    method @NonNull public java.util.List<android.net.wifi.sharedconnectivity.app.KnownNetwork> getKnownNetworks();
    method @Nullable public android.net.wifi.sharedconnectivity.app.SharedConnectivitySettingsState getSettingsState();
    method @Nullable public android.net.wifi.sharedconnectivity.app.TetherNetworkConnectionStatus getTetherNetworkConnectionStatus();
    method @NonNull public java.util.List<android.net.wifi.sharedconnectivity.app.TetherNetwork> getTetherNetworks();
    method public void registerCallback(@NonNull java.util.concurrent.Executor, @NonNull android.net.wifi.sharedconnectivity.app.SharedConnectivityClientCallback);
    method public boolean unregisterCallback(@NonNull android.net.wifi.sharedconnectivity.app.SharedConnectivityClientCallback);
  }
+103 −3
Original line number Diff line number Diff line
@@ -192,9 +192,9 @@ public class SharedConnectivityManager {
                mService = ISharedConnectivityService.Stub.asInterface(service);
                if (!mCallbackProxyCache.isEmpty()) {
                    synchronized (mCallbackProxyCache) {
                        mCallbackProxyCache.keySet().forEach(callback -> {
                            registerCallbackInternal(callback, mCallbackProxyCache.get(callback));
                        });
                        mCallbackProxyCache.keySet().forEach(callback ->
                                registerCallbackInternal(
                                        callback, mCallbackProxyCache.get(callback)));
                        mCallbackProxyCache.clear();
                    }
                }
@@ -418,4 +418,104 @@ public class SharedConnectivityManager {
        }
        return true;
    }

    /**
     * Gets the list of tether networks the user can select to connect to.
     *
     * @return Returns a {@link List} of {@link TetherNetwork} objects, empty list on failure.
     */
    @NonNull
    public List<TetherNetwork> getTetherNetworks() {
        if (mService == null) {
            return List.of();
        }

        try {
            return mService.getTetherNetworks();
        } catch (RemoteException e) {
            Log.e(TAG, "Exception in getTetherNetworks", e);
        }
        return List.of();
    }

    /**
     * Gets the list of known networks the user can select to connect to.
     *
     * @return Returns a {@link List} of {@link KnownNetwork} objects, empty list on failure.
     */
    @NonNull
    public List<KnownNetwork> getKnownNetworks() {
        if (mService == null) {
            return List.of();
        }

        try {
            return mService.getKnownNetworks();
        } catch (RemoteException e) {
            Log.e(TAG, "Exception in getKnownNetworks", e);
        }
        return List.of();
    }

    /**
     * Gets the shared connectivity settings state.
     *
     * @return Returns a {@link SharedConnectivitySettingsState} object with the state, null on
     * failure.
     */
    @Nullable
    public SharedConnectivitySettingsState getSettingsState() {
        if (mService == null) {
            return null;
        }

        try {
            return mService.getSettingsState();
        } catch (RemoteException e) {
            Log.e(TAG, "Exception in getSettingsState", e);
        }
        return null;
    }

    /**
     * Gets the connection status of the tether network the user selected to connect to.
     *
     * @return Returns a {@link TetherNetworkConnectionStatus} object with the connection status,
     * null on failure. If no connection is active the status will be
     * {@link TetherNetworkConnectionStatus#CONNECTION_STATUS_UNKNOWN}.
     */
    @Nullable
    public TetherNetworkConnectionStatus getTetherNetworkConnectionStatus() {
        if (mService == null) {
            return null;
        }

        try {
            return mService.getTetherNetworkConnectionStatus();
        } catch (RemoteException e) {
            Log.e(TAG, "Exception in getTetherNetworkConnectionStatus", e);
        }
        return null;
    }

    /**
     * Gets the connection status of the known network the user selected to connect to.
     *
     * @return Returns a {@link KnownNetworkConnectionStatus} object with the connection status,
     * null on failure. If no connection is active the status will be
     * {@link KnownNetworkConnectionStatus#CONNECTION_STATUS_UNKNOWN}.
     */
    @Nullable
    public KnownNetworkConnectionStatus getKnownNetworkConnectionStatus() {
        if (mService == null) {
            return null;
        }

        try {
            return mService.getKnownNetworkConnectionStatus();
        } catch (RemoteException e) {
            Log.e(TAG, "Exception in getKnownNetworkConnectionStatus", e);
        }
        return null;
    }
}
+8 −0
Original line number Diff line number Diff line
@@ -18,6 +18,9 @@ package android.net.wifi.sharedconnectivity.service;

import android.net.wifi.sharedconnectivity.app.KnownNetwork;
import android.net.wifi.sharedconnectivity.app.TetherNetwork;
import android.net.wifi.sharedconnectivity.app.KnownNetworkConnectionStatus;
import android.net.wifi.sharedconnectivity.app.SharedConnectivitySettingsState;
import android.net.wifi.sharedconnectivity.app.TetherNetworkConnectionStatus;
import android.net.wifi.sharedconnectivity.service.ISharedConnectivityCallback;

/*
@@ -30,4 +33,9 @@ interface ISharedConnectivityService {
    void disconnectTetherNetwork(in TetherNetwork network);
    void connectKnownNetwork(in KnownNetwork network);
    void forgetKnownNetwork(in KnownNetwork network);
    List<TetherNetwork> getTetherNetworks();
    List<KnownNetwork> getKnownNetworks();
    SharedConnectivitySettingsState getSettingsState();
    TetherNetworkConnectionStatus getTetherNetworkConnectionStatus();
    KnownNetworkConnectionStatus getKnownNetworkConnectionStatus();
}
+42 −12
Original line number Diff line number Diff line
@@ -33,6 +33,7 @@ import android.net.wifi.sharedconnectivity.app.SharedConnectivityManager;
import android.net.wifi.sharedconnectivity.app.SharedConnectivitySettingsState;
import android.net.wifi.sharedconnectivity.app.TetherNetwork;
import android.net.wifi.sharedconnectivity.app.TetherNetworkConnectionStatus;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.RemoteException;
@@ -68,9 +69,17 @@ public abstract class SharedConnectivityService extends Service {

    private List<TetherNetwork> mTetherNetworks = Collections.emptyList();
    private List<KnownNetwork> mKnownNetworks = Collections.emptyList();
    private SharedConnectivitySettingsState mSettingsState;
    private TetherNetworkConnectionStatus mTetherNetworkConnectionStatus;
    private KnownNetworkConnectionStatus mKnownNetworkConnectionStatus;
    private SharedConnectivitySettingsState mSettingsState =
            new SharedConnectivitySettingsState.Builder().setInstantTetherEnabled(false)
                    .setExtras(Bundle.EMPTY).build();
    private TetherNetworkConnectionStatus mTetherNetworkConnectionStatus =
            new TetherNetworkConnectionStatus.Builder()
                    .setStatus(TetherNetworkConnectionStatus.CONNECTION_STATUS_UNKNOWN)
                    .setExtras(Bundle.EMPTY).build();
    private KnownNetworkConnectionStatus mKnownNetworkConnectionStatus =
            new KnownNetworkConnectionStatus.Builder()
                    .setStatus(KnownNetworkConnectionStatus.CONNECTION_STATUS_UNKNOWN)
                    .setExtras(Bundle.EMPTY).build();

    private final class DeathRecipient implements IBinder.DeathRecipient {
        ISharedConnectivityCallback mCallback;
@@ -128,6 +137,36 @@ public abstract class SharedConnectivityService extends Service {
                mHandler.post(() -> onForgetKnownNetwork(network));
            }

            @Override
            public List<TetherNetwork> getTetherNetworks() {
                checkPermissions();
                return mTetherNetworks;
            }

            @Override
            public List<KnownNetwork> getKnownNetworks() {
                checkPermissions();
                return mKnownNetworks;
            }

            @Override
            public SharedConnectivitySettingsState getSettingsState() {
                checkPermissions();
                return mSettingsState;
            }

            @Override
            public TetherNetworkConnectionStatus getTetherNetworkConnectionStatus() {
                checkPermissions();
                return mTetherNetworkConnectionStatus;
            }

            @Override
            public KnownNetworkConnectionStatus getKnownNetworkConnectionStatus() {
                checkPermissions();
                return mKnownNetworkConnectionStatus;
            }

            @RequiresPermission(anyOf = {android.Manifest.permission.NETWORK_SETTINGS,
                    android.Manifest.permission.NETWORK_SETUP_WIZARD})
            /**
@@ -155,15 +194,6 @@ public abstract class SharedConnectivityService extends Service {
    public void onBind() {}

    private void onRegisterCallback(ISharedConnectivityCallback callback) {
        // Listener gets triggered on first register using cashed data
        if (!notifyTetherNetworkUpdate(callback) || !notifyKnownNetworkUpdate(callback)
                || !notifySettingsStateUpdate(callback)
                || !notifyTetherNetworkConnectionStatusChanged(callback)
                || !notifyKnownNetworkConnectionStatusChanged(callback)) {
            if (DEBUG) Log.w(TAG, "Failed to notify client");
            return;
        }

        DeathRecipient deathRecipient = new DeathRecipient(callback);
        try {
            callback.asBinder().linkToDeath(deathRecipient, 0);
+202 −0

File changed.

Preview size limit exceeded, changes collapsed.

Loading