android-16.0.0_r2/s

/*
 * Copyright (C) 2023 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 com.android.tv.mdnsoffloadmanager;

import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.ServiceConnection;
import android.content.pm.PackageManager;
import android.content.res.Resources;
import android.net.ConnectivityManager;
import android.net.LinkProperties;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkRequest;
import android.net.nsd.NsdManager;
import android.net.nsd.OffloadEngine;
import android.os.Binder;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
import android.os.Looper;
import android.os.PowerManager;
import android.os.RemoteException;
import android.os.UserHandle;
import android.util.Log;

import androidx.annotation.NonNull;
import androidx.annotation.VisibleForTesting;
import androidx.annotation.WorkerThread;

import com.android.tv.mdnsoffloadmanager.util.HandlerExecutor;
import com.android.tv.mdnsoffloadmanager.util.NsdManagerWrapper;
import com.android.tv.mdnsoffloadmanager.util.WakeLockWrapper;

import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

import device.google.atv.mdns_offload.IMdnsOffload;
import device.google.atv.mdns_offload.IMdnsOffloadManager;
import device.google.atv.mdns_offload.IMdnsOffloadManager.OffloadServiceInfo;

public class MdnsOffloadManagerService extends Service {

    private static final String TAG = MdnsOffloadManagerService.class.getSimpleName();
    private static final int VENDOR_SERVICE_COMPONENT_ID =
            R.string.config_mdnsOffloadVendorServiceComponent;
    private static final int AWAIT_DUMP_SECONDS = 5;
    /** If the service is currently bound. */
    private static boolean mIsBound;

    private final ConnectivityManager.NetworkCallback mNetworkCallback =
            new ConnectivityManagerNetworkCallback();
    private final Map<String, InterfaceOffloadManager> mInterfaceOffloadManagers = new HashMap<>();
    private final Map<String, NsdManagerOffloadEngine> mInterfaceNsdOffloadEngine = new HashMap<>();
    private final Injector mInjector;
    private Handler mHandler;
    private PriorityListManager mPriorityListManager;
    private OffloadIntentStore mOffloadIntentStore;
    private OffloadWriter mOffloadWriter;
    private ConnectivityManager mConnectivityManager;
    private PackageManager mPackageManager;
    private WakeLockWrapper mWakeLock;
    private BroadcastReceiver lowPowerStandbyPolicyReceiver;
    private BroadcastReceiver screenBroadcastReceiver;

    private NsdManagerWrapper mNsdManager;

    public MdnsOffloadManagerService() {
        this(new Injector());
    }

    @VisibleForTesting
    MdnsOffloadManagerService(@NonNull Injector injector) {
        super();
        injector.setContext(this);
        mInjector = injector;
    }

    @VisibleForTesting
    static class Injector {

        private Context mContext = null;
        private Looper mLooper = null;

        void setContext(Context context) {
            mContext = context;
        }

        synchronized Looper getLooper() {
            if (mLooper == null) {
                HandlerThread ht = new HandlerThread("MdnsOffloadManager");
                ht.start();
                mLooper = ht.getLooper();
            }
            return mLooper;
        }

        Resources getResources() {
            return mContext.getResources();
        }

        ConnectivityManager getConnectivityManager() {
            return mContext.getSystemService(ConnectivityManager.class);
        }

        PowerManager.LowPowerStandbyPolicy getLowPowerStandbyPolicy() {
            return mContext.getSystemService(PowerManager.class).getLowPowerStandbyPolicy();
        }

        WakeLockWrapper newWakeLock() {
            return new WakeLockWrapper(
                    mContext.getSystemService(PowerManager.class)
                            .newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG));
        }

        PackageManager getPackageManager() {
            return mContext.getPackageManager();
        }

        boolean isInteractive() {
            return mContext.getSystemService(PowerManager.class).isInteractive();
        }

        boolean bindService(Intent intent, ServiceConnection connection, int flags) {
            return mContext.bindService(intent, connection, flags);
        }

        void unbindService(ServiceConnection connection) {
            if (mIsBound) {
                mContext.unbindService(connection);
            }
            mIsBound = false;
        }

        void registerReceiver(BroadcastReceiver receiver, IntentFilter filter, int flags) {
            mContext.registerReceiver(receiver, filter, flags);
        }

        int getCallingUid() {
            return Binder.getCallingUid();
        }

        NsdManagerWrapper getNsdManager() {
            return new NsdManagerWrapper(mContext.getSystemService(NsdManager.class));
        }
    }

    @Override
    public void onCreate() {
        Log.d(TAG, "onCreate()");
        super.onCreate();
        mHandler = new Handler(mInjector.getLooper());
        mPriorityListManager = new PriorityListManager(mInjector.getResources());
        mOffloadIntentStore = new OffloadIntentStore(mPriorityListManager);
        mOffloadWriter = new OffloadWriter();
        mConnectivityManager = mInjector.getConnectivityManager();
        mPackageManager = mInjector.getPackageManager();
        mWakeLock = mInjector.newWakeLock();
        mNsdManager = mInjector.getNsdManager();
        lowPowerStandbyPolicyReceiver = new LowPowerStandbyPolicyReceiver();
        screenBroadcastReceiver = new ScreenBroadcastReceiver();
        bindVendorService();
        setupScreenBroadcastReceiver();
        setupConnectivityListener();
        setupStandbyPolicyListener();
    }

    @Override
    public void onDestroy() {
        // Unregister the receiver to avoid memory leaks
        unregisterReceiver(lowPowerStandbyPolicyReceiver);
        unregisterReceiver(screenBroadcastReceiver);
        mConnectivityManager.unregisterNetworkCallback(mNetworkCallback);
        mInjector.unbindService(mVendorServiceConnection);
        super.onDestroy();
    }

    private void bindVendorService() {
        String vendorServicePath = mInjector.getResources().getString(VENDOR_SERVICE_COMPONENT_ID);

        if (vendorServicePath.isEmpty()) {
            String msg = "vendorServicePath is empty. Bind cannot proceed.";
            Log.e(TAG, msg);
            throw new IllegalArgumentException(msg);
        }
        ComponentName componentName = ComponentName.unflattenFromString(vendorServicePath);
        if (componentName == null) {
            String msg = "componentName cannot be extracted from vendorServicePath."
                    + " Bind cannot proceed.";
            Log.e(TAG, msg);
            throw new IllegalArgumentException(msg);
        }

        Log.d(TAG, "IMdnsOffloadManager is binding to: " + componentName);

        Intent explicitIntent = new Intent();
        explicitIntent.setComponent(componentName);
        boolean mIsBound = mInjector.bindService(
                explicitIntent, mVendorServiceConnection, Context.BIND_AUTO_CREATE);
        if (!mIsBound) {
            String msg = "Failed to bind to vendor service at {" + vendorServicePath + "}.";
            Log.e(TAG, msg);
            throw new IllegalStateException(msg);
        }
    }

    private void setupScreenBroadcastReceiver() {
        IntentFilter filter = new IntentFilter();
        filter.addAction(Intent.ACTION_SCREEN_ON);
        filter.addAction(Intent.ACTION_SCREEN_OFF);
        mInjector.registerReceiver(screenBroadcastReceiver, filter, 0);
        mHandler.post(() -> mOffloadWriter.setOffloadState(!mInjector.isInteractive()));
    }

    private void setupConnectivityListener() {
        NetworkRequest networkRequest = new NetworkRequest.Builder()
                .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VPN)
                .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
                .addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET)
                .build();
        mConnectivityManager.registerNetworkCallback(networkRequest, mNetworkCallback);
    }

    private void setupStandbyPolicyListener() {
        IntentFilter filter = new IntentFilter();
        filter.addAction(PowerManager.ACTION_LOW_POWER_STANDBY_POLICY_CHANGED);
        mInjector.registerReceiver(lowPowerStandbyPolicyReceiver, filter, 0);
        refreshAppIdAllowlist();
    }

    private void refreshAppIdAllowlist() {
        PowerManager.LowPowerStandbyPolicy standbyPolicy = mInjector.getLowPowerStandbyPolicy();
        Set<Integer> allowedAppIds = standbyPolicy.getExemptPackages()
                .stream()
                .map(pkg -> {
                    try {
                        return mPackageManager.getPackageUid(pkg, 0);
                    } catch (PackageManager.NameNotFoundException e) {
                        Log.w(TAG, "Unable to get UID of package {" + pkg + "}.");
                        return null;
                    }
                })
                .filter(Objects::nonNull)
                .map(UserHandle::getAppId)
                .collect(Collectors.toSet());

        try {
            // Allowlist ourselves, since OffloadEngine in this package is calling the protocol
            // responses API on behalf of NsdManager.
            int selfAppId = UserHandle.getAppId(
                    mPackageManager.getPackageUid("com.android.tv.mdnsoffloadmanager", 0));
            allowedAppIds.add(selfAppId);
        } catch (PackageManager.NameNotFoundException e) {
            throw new IllegalStateException("Failed to retrieve own package ID", e);
        }

        mHandler.post(() -> {
            mOffloadIntentStore.setAppIdAllowlist(allowedAppIds);
            mInterfaceOffloadManagers.values()
                    .forEach(InterfaceOffloadManager::onAppIdAllowlistUpdated);
        });
    }

    @Override
    public IBinder onBind(Intent intent) {
        return mOffloadManagerBinder;
    }

    @Override
    protected void dump(FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strings) {
        CountDownLatch doneSignal = new CountDownLatch(1);
        mHandler.post(() -> {
            dump(printWriter);
            doneSignal.countDown();
        });
        boolean success = false;
        try {
            success = doneSignal.await(AWAIT_DUMP_SECONDS, TimeUnit.SECONDS);
        } catch (InterruptedException ignored) {
        }
        if (!success) {
            Log.e(TAG, "Failed to dump state on handler thread");
        }
    }

    @WorkerThread
    private void dump(PrintWriter writer) {
        mOffloadIntentStore.dump(writer);
        mInterfaceOffloadManagers.values().forEach(manager -> manager.dump(writer));
        mOffloadWriter.dump(writer);
        mOffloadIntentStore.dumpProtocolData(writer);
    }


    final IMdnsOffloadManager.Stub mOffloadManagerBinder = new IMdnsOffloadManager.Stub() {
        @Override
        public int addProtocolResponses(@NonNull String networkInterface,
                                        @NonNull OffloadServiceInfo serviceOffloadData,
                                        @NonNull IBinder clientToken) {
            return MdnsOffloadManagerService.this.addProtocolResponses(
                    networkInterface, serviceOffloadData, clientToken);
        }

        @Override
        public void removeProtocolResponses(int recordKey, @NonNull IBinder clientToken) {
            MdnsOffloadManagerService.this.removeProtocolResponses(recordKey, clientToken);
        }

        @Override
        public void addToPassthroughList(
                @NonNull String networkInterface,
                @NonNull String qname,
                @NonNull IBinder clientToken) {
            Objects.requireNonNull(networkInterface);
            Objects.requireNonNull(qname);
            Objects.requireNonNull(clientToken);
            int callerUid = mInjector.getCallingUid();
            mHandler.post(() -> {
                OffloadIntentStore.PassthroughIntent ptIntent =
                        mOffloadIntentStore.registerPassthroughIntent(
                                networkInterface, qname, clientToken, callerUid);
                IBinder token = ptIntent.mClientToken;
                try {
                    token.linkToDeath(
                            () -> removeFromPassthroughList(
                                    networkInterface, ptIntent.mCanonicalQName, token), 0);
                } catch (RemoteException e) {
                    String msg = "Error while setting a callback for linkToDeath binder {"
                            + token + "} in addToPassthroughList.";
                    Log.e(TAG, msg, e);
                    return;
                }
                getInterfaceOffloadManager(networkInterface).refreshPassthroughList();
            });
        }

        @Override
        public void removeFromPassthroughList(
                @NonNull String networkInterface,
                @NonNull String qname,
                @NonNull IBinder clientToken) {
            Objects.requireNonNull(networkInterface);
            Objects.requireNonNull(qname);
            Objects.requireNonNull(clientToken);
            mHandler.post(() -> {
                boolean removed = mOffloadIntentStore.removePassthroughIntent(qname, clientToken);
                if (removed) {
                    getInterfaceOffloadManager(networkInterface).refreshPassthroughList();
                }
            });
        }

        @Override
        public int getInterfaceVersion() {
            return super.VERSION;
        }

        @Override
        public String getInterfaceHash() {
            return super.HASH;
        }
    };

    int addProtocolResponses(@NonNull String networkInterface,
                             @NonNull OffloadServiceInfo serviceOffloadData,
                             @NonNull IBinder clientToken) {
        Objects.requireNonNull(networkInterface);
        Objects.requireNonNull(serviceOffloadData);
        Objects.requireNonNull(clientToken);
        int callerUid = mInjector.getCallingUid();
        OffloadIntentStore.OffloadIntent offloadIntent =
                mOffloadIntentStore.registerOffloadIntent(
                        networkInterface, serviceOffloadData, clientToken, callerUid);
        try {
            offloadIntent.mClientToken.linkToDeath(
                    () -> removeProtocolResponses(offloadIntent.mRecordKey, clientToken), 0);
        } catch (RemoteException e) {
            String msg = "Error while setting a callback for linkToDeath binder" +
                    " {" + offloadIntent.mClientToken + "} in addProtocolResponses.";
            Log.e(TAG, msg, e);
            return offloadIntent.mRecordKey;
        }
        mHandler.post(() ->
                getInterfaceOffloadManager(networkInterface).refreshProtocolResponses());
        return offloadIntent.mRecordKey;
    }

    void removeProtocolResponses(int recordKey, @NonNull IBinder clientToken) {
        if (recordKey <= 0) {
            throw new IllegalArgumentException("recordKey must be positive");
        }
        Objects.requireNonNull(clientToken);
        mHandler.post(() -> {
            OffloadIntentStore.OffloadIntent offloadIntent =
                    mOffloadIntentStore.getAndRemoveOffloadIntent(recordKey, clientToken);
            if (offloadIntent == null) {
                return;
            }
            getInterfaceOffloadManager(offloadIntent.mNetworkInterface)
                    .refreshProtocolResponses();
        });
    }

    private NsdManagerOffloadEngine getInterfaceNsdOffloadEngine(String networkInterface) {
        if (mInterfaceNsdOffloadEngine.get(networkInterface) == null) {
            NsdManagerOffloadEngine nsdOffloadEngine = new NsdManagerOffloadEngine(
                    this, networkInterface);
            long flags = OffloadEngine.OFFLOAD_TYPE_REPLY
                    | OffloadEngine.OFFLOAD_TYPE_FILTER_QUERIES;
            Executor executor = new HandlerExecutor(mHandler);
            mNsdManager.registerOffloadEngine(networkInterface, flags, 0, executor,
                    nsdOffloadEngine);
            mInterfaceNsdOffloadEngine.put(networkInterface, nsdOffloadEngine);
            return nsdOffloadEngine;
        }
        return mInterfaceNsdOffloadEngine.get(networkInterface);
    }

    private InterfaceOffloadManager getInterfaceOffloadManager(String networkInterface) {
        return mInterfaceOffloadManagers.computeIfAbsent(
                networkInterface,
                iface -> new InterfaceOffloadManager(iface, mOffloadIntentStore, mOffloadWriter));
    }

    private final ServiceConnection mVendorServiceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName className, IBinder service) {
            Log.i(TAG, "IMdnsOffload service bound successfully.");
            IMdnsOffload vendorService = IMdnsOffload.Stub.asInterface(service);
            mHandler.post(() -> {
                mOffloadWriter.setVendorService(vendorService);
                mOffloadWriter.resetAll();
                mInterfaceOffloadManagers.values()
                        .forEach(InterfaceOffloadManager::onVendorServiceConnected);
                mOffloadWriter.applyOffloadState();
            });
        }

        public void onServiceDisconnected(ComponentName className) {
            Log.e(TAG, "IMdnsOffload service has disconnected.");
            mHandler.post(() -> {
                mOffloadWriter.setVendorService(null);
                mInterfaceOffloadManagers.values()
                        .forEach(InterfaceOffloadManager::onVendorServiceDisconnected);
            });
        }
    };

    private class ScreenBroadcastReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            // Note: Screen on/off here is actually historical naming for the overall interactive
            // state of the device:
            // https://developer.android.com/reference/android/os/PowerManager#isInteractive()
            String action = intent.getAction();
            mHandler.post(() -> {
                if (Intent.ACTION_SCREEN_ON.equals(action)) {
                    Log.d(TAG, "SCREEN_ON");
                    mOffloadWriter.setOffloadState(false);
                    mInterfaceOffloadManagers.values().forEach(
                            InterfaceOffloadManager::retrieveAndClearMetrics);
                } else if (Intent.ACTION_SCREEN_OFF.equals(action)) {
                    Log.d(TAG, "SCREEN_OFF");
                    try {
                        mWakeLock.acquire(5000);
                        mOffloadWriter.setOffloadState(true);
                    } finally {
                        Log.d(TAG, "SCREEN_OFF wakelock released");
                        mWakeLock.release();
                    }
                }
            });
        }
    }

    public static class BootCompletedReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            Log.d(TAG, "Initial startup of mDNS offload manager service after boot...");
            Intent serviceIntent = new Intent(context, MdnsOffloadManagerService.class);
            context.startService(serviceIntent);
        }
    }

    private class LowPowerStandbyPolicyReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (!PowerManager.ACTION_LOW_POWER_STANDBY_POLICY_CHANGED.equals(intent.getAction())) {
                return;
            }
            refreshAppIdAllowlist();
        }
    }

    private class ConnectivityManagerNetworkCallback extends ConnectivityManager.NetworkCallback {
        private final Map<Network, LinkProperties> mLinkProperties = new HashMap<>();

        @Override
        public void onLinkPropertiesChanged(
                @NonNull Network network,
                @NonNull LinkProperties linkProperties) {
            mHandler.post(() -> {
                // We only want to know the interface name of a network. This method is
                // called right after onAvailable() or any other important change during the
                // lifecycle of the network.
                String iface = linkProperties.getInterfaceName();
                LinkProperties previousProperties = mLinkProperties.put(network, linkProperties);
                if (previousProperties != null &&
                        !previousProperties.getInterfaceName().equals(iface)) {
                    // This means that the interface changed names, which may happen
                    // but very rarely.
                    onIfaceLost(previousProperties.getInterfaceName());
                }
                onIfaceUpdated(iface);
            });
        }

        @Override
        public void onLost(@NonNull Network network) {
            mHandler.post(() -> {
                // Network object is guaranteed to match a network object from a previous
                // onLinkPropertiesChanged() so the LinkProperties must be available to retrieve
                // the associated iface.
                LinkProperties previousProperties = mLinkProperties.remove(network);
                if (previousProperties == null){
                    Log.w(TAG,"Network "+ network + " lost before being available.");
                    return;
                }
                onIfaceLost(previousProperties.getInterfaceName());
            });
        }

        @WorkerThread
        private void onIfaceUpdated(String iface) {
            // We trigger an onNetworkAvailable even if the existing is the same in case
            // anything needs to be refreshed due to the LinkProperties change.
            getInterfaceNsdOffloadEngine(iface);
            InterfaceOffloadManager offloadManager = getInterfaceOffloadManager(iface);
            offloadManager.onNetworkAvailable();
        }

        @WorkerThread
        private void onIfaceLost(String iface) {
            if (mInterfaceNsdOffloadEngine.containsKey(iface)) {
                NsdManagerOffloadEngine nsdOffloadEngine = getInterfaceNsdOffloadEngine(iface);
                mNsdManager.unregisterOffloadEngine(nsdOffloadEngine);
                nsdOffloadEngine.clearOffloadServices();
                mInterfaceNsdOffloadEngine.remove(iface);
            }
            InterfaceOffloadManager offloadManager = getInterfaceOffloadManager(iface);
            offloadManager.onNetworkLost();
        }
    }


}