/*
 * Copyright (C) 2012 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.server;

import static android.content.Context.BIND_AUTO_CREATE;
import static android.content.Context.BIND_NOT_FOREGROUND;
import static android.content.Context.BIND_NOT_VISIBLE;
import static android.content.pm.PackageManager.GET_META_DATA;
import static android.content.pm.PackageManager.MATCH_DIRECT_BOOT_AUTO;
import static android.content.pm.PackageManager.MATCH_DIRECT_BOOT_AWARE;
import static android.content.pm.PackageManager.MATCH_DIRECT_BOOT_UNAWARE;
import static android.content.pm.PackageManager.MATCH_SYSTEM_ONLY;

import android.annotation.BoolRes;
import android.annotation.Nullable;
import android.annotation.StringRes;
import android.annotation.UserIdInt;
import android.app.ActivityManager;
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.ResolveInfo;
import android.content.res.Resources;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.os.RemoteException;
import android.os.UserHandle;
import android.util.Log;

import com.android.internal.content.PackageMonitor;
import com.android.internal.util.Preconditions;

import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * Maintains a binding to the best service that matches the given intent information. Bind and
 * unbind callbacks, as well as all binder operations, will all be run on the given handler.
 */
public class ServiceWatcher implements ServiceConnection {

    private static final String TAG = "ServiceWatcher";
    private static final boolean D = Log.isLoggable(TAG, Log.DEBUG);

    private static final String EXTRA_SERVICE_VERSION = "serviceVersion";
    private static final String EXTRA_SERVICE_IS_MULTIUSER = "serviceIsMultiuser";

    private static final long BLOCKING_BINDER_TIMEOUT_MS = 30 * 1000;

    /** Function to run on binder interface. */
    public interface BinderRunner {
        /** Called to run client code with the binder. */
        void run(IBinder binder) throws RemoteException;
    }

    /**
     * Function to run on binder interface.
     * @param <T> Type to return.
     */
    public interface BlockingBinderRunner<T> {
        /** Called to run client code with the binder. */
        T run(IBinder binder) throws RemoteException;
    }

    /**
     * Information on the service ServiceWatcher has selected as the best option for binding.
     */
    public static final class ServiceInfo implements Comparable<ServiceInfo> {

        public static final ServiceInfo NONE = new ServiceInfo(Integer.MIN_VALUE, null,
                UserHandle.USER_NULL);

        public final int version;
        @Nullable public final ComponentName component;
        @UserIdInt public final int userId;

        ServiceInfo(ResolveInfo resolveInfo, int currentUserId) {
            Preconditions.checkArgument(resolveInfo.serviceInfo.getComponentName() != null);

            Bundle metadata = resolveInfo.serviceInfo.metaData;
            boolean isMultiuser;
            if (metadata != null) {
                version = metadata.getInt(EXTRA_SERVICE_VERSION, Integer.MIN_VALUE);
                isMultiuser = metadata.getBoolean(EXTRA_SERVICE_IS_MULTIUSER, false);
            } else {
                version = Integer.MIN_VALUE;
                isMultiuser = false;
            }

            component = resolveInfo.serviceInfo.getComponentName();
            userId = isMultiuser ? UserHandle.USER_SYSTEM : currentUserId;
        }

        private ServiceInfo(int version, @Nullable ComponentName component, int userId) {
            Preconditions.checkArgument(component != null || version == Integer.MIN_VALUE);
            this.version = version;
            this.component = component;
            this.userId = userId;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (!(o instanceof ServiceInfo)) {
                return false;
            }
            ServiceInfo that = (ServiceInfo) o;
            return version == that.version && userId == that.userId
                    && Objects.equals(component, that.component);
        }

        @Override
        public int hashCode() {
            return Objects.hash(version, component, userId);
        }

        @Override
        public int compareTo(ServiceInfo that) {
            // ServiceInfos with higher version numbers always win (having a version number >
            // MIN_VALUE implies having a non-null component). if version numbers are equal, a
            // non-null component wins over a null component. if the version numbers are equal and
            // both components exist then we prefer components that work for all users vs components
            // that only work for a single user at a time. otherwise everything's equal.
            int ret = Integer.compare(version, that.version);
            if (ret == 0) {
                if (component == null && that.component != null) {
                    ret = -1;
                } else if (component != null && that.component == null) {
                    ret = 1;
                } else {
                    if (userId != UserHandle.USER_SYSTEM && that.userId == UserHandle.USER_SYSTEM) {
                        ret = -1;
                    } else if (userId == UserHandle.USER_SYSTEM
                            && that.userId != UserHandle.USER_SYSTEM) {
                        ret = 1;
                    }
                }
            }
            return ret;
        }

        @Override
        public String toString() {
            if (component == null) {
                return "none";
            } else {
                return component.toShortString() + "@" + version + "[u" + userId + "]";
            }
        }
    }

    private final Context mContext;
    private final Handler mHandler;
    private final Intent mIntent;

    @Nullable private final BinderRunner mOnBind;
    @Nullable private final Runnable mOnUnbind;

    // read/write from handler thread only
    private int mCurrentUserId;

    // write from handler thread only, read anywhere
    private volatile ServiceInfo mServiceInfo;
    private volatile IBinder mBinder;

    public ServiceWatcher(Context context, Handler handler, String action,
            @Nullable BinderRunner onBind, @Nullable Runnable onUnbind,
            @BoolRes int enableOverlayResId, @StringRes int nonOverlayPackageResId) {
        mContext = context;
        mHandler = FgThread.getHandler();
        mIntent = new Intent(Objects.requireNonNull(action));

        Resources resources = context.getResources();
        boolean enableOverlay = resources.getBoolean(enableOverlayResId);
        if (!enableOverlay) {
            mIntent.setPackage(resources.getString(nonOverlayPackageResId));
        }

        mOnBind = onBind;
        mOnUnbind = onUnbind;

        mCurrentUserId = UserHandle.USER_NULL;

        mServiceInfo = ServiceInfo.NONE;
        mBinder = null;
    }

    /**
     * Register this class, which will start the process of determining the best matching service
     * and maintaining a binding to it. Will return false and fail if there are no possible matching
     * services at the time this functions is called.
     */
    public boolean register() {
        if (mContext.getPackageManager().queryIntentServicesAsUser(mIntent,
                MATCH_DIRECT_BOOT_AWARE | MATCH_DIRECT_BOOT_UNAWARE | MATCH_SYSTEM_ONLY,
                UserHandle.USER_SYSTEM).isEmpty()) {
            return false;
        }

        new PackageMonitor() {
            @Override
            public void onPackageUpdateFinished(String packageName, int uid) {
                ServiceWatcher.this.onPackageChanged(packageName);
            }

            @Override
            public void onPackageAdded(String packageName, int uid) {
                ServiceWatcher.this.onPackageChanged(packageName);
            }

            @Override
            public void onPackageRemoved(String packageName, int uid) {
                ServiceWatcher.this.onPackageChanged(packageName);
            }

            @Override
            public boolean onPackageChanged(String packageName, int uid, String[] components) {
                ServiceWatcher.this.onPackageChanged(packageName);
                return super.onPackageChanged(packageName, uid, components);
            }
        }.register(mContext, UserHandle.ALL, true, mHandler);

        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(Intent.ACTION_USER_SWITCHED);
        intentFilter.addAction(Intent.ACTION_USER_UNLOCKED);
        mContext.registerReceiverAsUser(new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                String action = intent.getAction();
                if (action == null) {
                    return;
                }
                int userId = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, UserHandle.USER_NULL);
                if (userId == UserHandle.USER_NULL) {
                    return;
                }

                switch (action) {
                    case Intent.ACTION_USER_SWITCHED:
                        onUserSwitched(userId);
                        break;
                    case Intent.ACTION_USER_UNLOCKED:
                        onUserUnlocked(userId);
                        break;
                    default:
                        break;
                }

            }
        }, UserHandle.ALL, intentFilter, null, mHandler);

        mCurrentUserId = ActivityManager.getCurrentUser();

        mHandler.post(() -> onBestServiceChanged(false));
        return true;
    }

    /**
     * Returns information on the currently selected service.
     */
    public ServiceInfo getBoundService() {
        return mServiceInfo;
    }

    private void onBestServiceChanged(boolean forceRebind) {
        Preconditions.checkState(Looper.myLooper() == mHandler.getLooper());

        List<ResolveInfo> resolveInfos = mContext.getPackageManager().queryIntentServicesAsUser(
                mIntent,
                GET_META_DATA | MATCH_DIRECT_BOOT_AUTO | MATCH_SYSTEM_ONLY,
                mCurrentUserId);

        ServiceInfo bestServiceInfo = ServiceInfo.NONE;
        for (ResolveInfo resolveInfo : resolveInfos) {
            ServiceInfo serviceInfo = new ServiceInfo(resolveInfo, mCurrentUserId);
            if (serviceInfo.compareTo(bestServiceInfo) > 0) {
                bestServiceInfo = serviceInfo;
            }
        }

        if (forceRebind || !bestServiceInfo.equals(mServiceInfo)) {
            rebind(bestServiceInfo);
        }
    }

    private void rebind(ServiceInfo newServiceInfo) {
        Preconditions.checkState(Looper.myLooper() == mHandler.getLooper());

        if (!mServiceInfo.equals(ServiceInfo.NONE)) {
            if (D) {
                Log.i(TAG, "[" + mIntent.getAction() + "] unbinding from " + mServiceInfo);
            }

            mContext.unbindService(this);
            onServiceDisconnected(mServiceInfo.component);
            mServiceInfo = ServiceInfo.NONE;
        }

        mServiceInfo = newServiceInfo;
        if (mServiceInfo.equals(ServiceInfo.NONE)) {
            return;
        }

        Preconditions.checkState(mServiceInfo.component != null);

        if (D) {
            Log.i(TAG, getLogPrefix() + " binding to " + mServiceInfo);
        }

        Intent bindIntent = new Intent(mIntent).setComponent(mServiceInfo.component);
        mContext.bindServiceAsUser(bindIntent, this,
                BIND_AUTO_CREATE | BIND_NOT_FOREGROUND | BIND_NOT_VISIBLE,
                mHandler, UserHandle.of(mServiceInfo.userId));
    }

    @Override
    public final void onServiceConnected(ComponentName component, IBinder binder) {
        Preconditions.checkState(Looper.myLooper() == mHandler.getLooper());
        Preconditions.checkState(mBinder == null);

        if (D) {
            Log.i(TAG, getLogPrefix() + " connected to " + component.toShortString());
        }

        mBinder = binder;
        if (mOnBind != null) {
            try {
                mOnBind.run(binder);
            } catch (RuntimeException | RemoteException e) {
                // binders may propagate some specific non-RemoteExceptions from the other side
                // through the binder as well - we cannot allow those to crash the system server
                Log.e(TAG, getLogPrefix() + " exception running on " + mServiceInfo, e);
            }
        }
    }

    @Override
    public final void onServiceDisconnected(ComponentName component) {
        Preconditions.checkState(Looper.myLooper() == mHandler.getLooper());

        if (mBinder == null) {
            return;
        }

        if (D) {
            Log.i(TAG, getLogPrefix() + " disconnected from " + component.toShortString());
        }

        mBinder = null;
        if (mOnUnbind != null) {
            mOnUnbind.run();
        }
    }

    @Override
    public void onBindingDied(ComponentName component) {
        Preconditions.checkState(Looper.myLooper() == mHandler.getLooper());

        if (D) {
            Log.i(TAG, getLogPrefix() + " " + component.toShortString() + " died");
        }

        onBestServiceChanged(true);
    }

    void onUserSwitched(@UserIdInt int userId) {
        mCurrentUserId = userId;
        onBestServiceChanged(false);
    }

    void onUserUnlocked(@UserIdInt int userId) {
        if (userId == mCurrentUserId) {
            onBestServiceChanged(false);
        }
    }

    void onPackageChanged(String packageName) {
        // force a rebind if the changed package was the currently connected package
        String currentPackageName =
                mServiceInfo.component != null ? mServiceInfo.component.getPackageName() : null;
        onBestServiceChanged(packageName.equals(currentPackageName));
    }

    /**
     * Runs the given function asynchronously if and only if currently connected. Suppresses any
     * RemoteException thrown during execution.
     */
    public final void runOnBinder(BinderRunner runner) {
        mHandler.post(() -> {
            if (mBinder == null) {
                return;
            }

            try {
                runner.run(mBinder);
            } catch (RuntimeException | RemoteException e) {
                // binders may propagate some specific non-RemoteExceptions from the other side
                // through the binder as well - we cannot allow those to crash the system server
                Log.e(TAG, getLogPrefix() + " exception running on " + mServiceInfo, e);
            }
        });
    }

    /**
     * Runs the given function synchronously if currently connected, and returns the default value
     * if not currently connected or if any exception is thrown. Do not obtain any locks within the
     * BlockingBinderRunner, or risk deadlock. The default value will be returned if there is no
     * service connection when this is run, if a RemoteException occurs, or if the operation times
     * out.
     *
     * @deprecated Using this function is an indication that your AIDL API is broken. Calls from
     * system server to outside MUST be one-way, and so cannot return any result, and this
     * method should not be needed or used. Use a separate callback interface to allow outside
     * components to return results back to the system server.
     */
    @Deprecated
    public final <T> T runOnBinderBlocking(BlockingBinderRunner<T> runner, T defaultValue) {
        try {
            return runOnHandlerBlocking(() -> {
                if (mBinder == null) {
                    return defaultValue;
                }

                try {
                    return runner.run(mBinder);
                } catch (RuntimeException | RemoteException e) {
                    // binders may propagate some specific non-RemoteExceptions from the other side
                    // through the binder as well - we cannot allow those to crash the system server
                    Log.e(TAG, getLogPrefix() + " exception running on " + mServiceInfo, e);
                    return defaultValue;
                }
            });
        } catch (InterruptedException | TimeoutException e) {
            return defaultValue;
        }
    }

    private <T> T runOnHandlerBlocking(Callable<T> c)
            throws InterruptedException, TimeoutException {
        if (Looper.myLooper() == mHandler.getLooper()) {
            try {
                return c.call();
            } catch (Exception e) {
                // Function cannot throw exception, this should never happen
                throw new IllegalStateException(e);
            }
        } else {
            FutureTask<T> task = new FutureTask<>(c);
            mHandler.post(task);
            try {
                // timeout will unblock callers, in particular if the caller is a binder thread to
                // help reduce binder contention. this will still result in blocking the handler
                // thread which may result in ANRs, but should make problems slightly more rare.
                // the underlying solution is simply not to use this API at all, but that would
                // require large refactors to very legacy code.
                return task.get(BLOCKING_BINDER_TIMEOUT_MS, TimeUnit.MILLISECONDS);
            } catch (ExecutionException e) {
                // Function cannot throw exception, this should never happen
                throw new IllegalStateException(e);
            }
        }
    }

    private String getLogPrefix() {
        return "[" + mIntent.getAction() + "]";
    }

    @Override
    public String toString() {
        return mServiceInfo.toString();
    }

    /**
     * Dump for debugging.
     */
    public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
        pw.println("service=" + mServiceInfo);
        pw.println("connected=" + (mBinder != null));
    }
}