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

Commit 38df280a authored by Jason Monk's avatar Jason Monk
Browse files

Rework how pinning works 

pin/unpin don't require special permissions, just permissions to the
slice, and they stop when the app dies.

Test: uiservicestests
Change-Id: I1d1b6afc7e5577091e55c9cbb58f56337b470acf
parent 8aca4f00

core/java/android/app/slice/ISliceManager.aidl

+2 −6
Original line number Diff line number Diff line
@@ -16,17 +16,13 @@ 


package android.app.slice;



import android.app.slice.ISliceListener;

import android.app.slice.SliceSpec;

import android.net.Uri;



/** @hide */

interface ISliceManager {

    void addSliceListener(in Uri uri, String pkg, in ISliceListener listener,

            in SliceSpec[] specs);

    void removeSliceListener(in Uri uri, String pkg, in ISliceListener listener);

    void pinSlice(String pkg, in Uri uri, in SliceSpec[] specs);

    void unpinSlice(String pkg, in Uri uri);

    void pinSlice(String pkg, in Uri uri, in SliceSpec[] specs, in IBinder token);

    void unpinSlice(String pkg, in Uri uri, in IBinder token);

    boolean hasSliceAccess(String pkg);

    SliceSpec[] getPinnedSpecs(in Uri uri, String pkg);

    int checkSlicePermission(in Uri uri, String pkg, int pid, int uid);

core/java/android/app/slice/SliceManager.java

+6 −36
Original line number Diff line number Diff line
@@ -26,8 +26,10 @@ import android.content.Context; 
import android.content.Intent;

import android.content.pm.ResolveInfo;

import android.net.Uri;

import android.os.Binder;

import android.os.Bundle;

import android.os.Handler;

import android.os.IBinder;

import android.os.RemoteException;

import android.os.ServiceManager;

import android.os.ServiceManager.ServiceNotFoundException;
@@ -64,6 +66,7 @@ public class SliceManager { 
    private final Context mContext;

    private final ArrayMap<Pair<Uri, SliceCallback>, ISliceListener> mListenerLookup =

            new ArrayMap<>();

    private final IBinder mToken = new Binder();



    /**

     * Permission denied.
@@ -96,7 +99,6 @@ public class SliceManager { 
    @Deprecated

    public void registerSliceCallback(@NonNull Uri uri, @NonNull SliceCallback callback,

            @NonNull List<SliceSpec> specs) {

        registerSliceCallback(uri, specs, mContext.getMainExecutor(), callback);

    }



    /**
@@ -105,7 +107,6 @@ public class SliceManager { 
    @Deprecated

    public void registerSliceCallback(@NonNull Uri uri, @NonNull SliceCallback callback,

            @NonNull List<SliceSpec> specs, Executor executor) {

        registerSliceCallback(uri, specs, executor, callback);

    }



    /**
@@ -123,7 +124,6 @@ public class SliceManager { 
     */

    public void registerSliceCallback(@NonNull Uri uri, @NonNull List<SliceSpec> specs,

            @NonNull SliceCallback callback) {

        registerSliceCallback(uri, specs, mContext.getMainExecutor(), callback);

    }



    /**
@@ -141,32 +141,7 @@ public class SliceManager { 
     */

    public void registerSliceCallback(@NonNull Uri uri, @NonNull List<SliceSpec> specs,

            @NonNull @CallbackExecutor Executor executor, @NonNull SliceCallback callback) {

        try {

            mService.addSliceListener(uri, mContext.getPackageName(),

                    getListener(uri, callback, new ISliceListener.Stub() {

                        @Override

                        public void onSliceUpdated(Slice s) throws RemoteException {

                            executor.execute(() -> callback.onSliceUpdated(s));

                        }

                    }), specs.toArray(new SliceSpec[specs.size()]));

        } catch (RemoteException e) {

            throw e.rethrowFromSystemServer();

        }

    }



    private ISliceListener getListener(Uri uri, SliceCallback callback,

            ISliceListener listener) {

        Pair<Uri, SliceCallback> key = new Pair<>(uri, callback);

        if (mListenerLookup.containsKey(key)) {

            try {

                mService.removeSliceListener(uri, mContext.getPackageName(),

                        mListenerLookup.get(key));

            } catch (RemoteException e) {

                throw e.rethrowFromSystemServer();

            }

        }

        mListenerLookup.put(key, listener);

        return listener;

    }



    /**
@@ -180,12 +155,7 @@ public class SliceManager { 
     * @see #registerSliceCallback

     */

    public void unregisterSliceCallback(@NonNull Uri uri, @NonNull SliceCallback callback) {

        try {

            mService.removeSliceListener(uri, mContext.getPackageName(),

                    mListenerLookup.remove(new Pair<>(uri, callback)));

        } catch (RemoteException e) {

            throw e.rethrowFromSystemServer();

        }



    }



    /**
@@ -206,7 +176,7 @@ public class SliceManager { 
    public void pinSlice(@NonNull Uri uri, @NonNull List<SliceSpec> specs) {

        try {

            mService.pinSlice(mContext.getPackageName(), uri,

                    specs.toArray(new SliceSpec[specs.size()]));

                    specs.toArray(new SliceSpec[specs.size()]), mToken);

        } catch (RemoteException e) {

            throw e.rethrowFromSystemServer();

        }
@@ -228,7 +198,7 @@ public class SliceManager { 
     */

    public void unpinSlice(@NonNull Uri uri) {

        try {

            mService.unpinSlice(mContext.getPackageName(), uri);

            mService.unpinSlice(mContext.getPackageName(), uri, mToken);

        } catch (RemoteException e) {

            throw e.rethrowFromSystemServer();

        }

services/core/java/com/android/server/slice/PinnedSliceState.java

+11 −119
Original line number Diff line number Diff line
@@ -16,7 +16,6 @@ package com.android.server.slice; 


import static android.app.slice.SliceManager.PERMISSION_GRANTED;



import android.app.slice.ISliceListener;

import android.app.slice.Slice;

import android.app.slice.SliceProvider;

import android.app.slice.SliceSpec;
@@ -106,10 +105,6 @@ public class PinnedSliceState { 
        setSlicePinned(false);

    }



    public void onChange() {

        mService.getHandler().post(this::handleBind);

    }



    private void setSlicePinned(boolean pinned) {

        synchronized (mLock) {

            if (mSlicePinned == pinned) return;
@@ -122,45 +117,23 @@ public class PinnedSliceState { 
        }

    }



    public void addSliceListener(ISliceListener listener, String pkg, SliceSpec[] specs,

            boolean hasPermission) {

    public void pin(String pkg, SliceSpec[] specs, IBinder token) {

        synchronized (mLock) {

            if (mListeners.size() == 0) {

                mService.listen(mUri);

            }

            mListeners.put(token, new ListenerInfo(token, pkg, true,

                    Binder.getCallingUid(), Binder.getCallingPid()));

            try {

                listener.asBinder().linkToDeath(mDeathRecipient, 0);

                token.linkToDeath(mDeathRecipient, 0);

            } catch (RemoteException e) {

            }

            mListeners.put(listener.asBinder(), new ListenerInfo(listener, pkg, hasPermission,

                    Binder.getCallingUid(), Binder.getCallingPid()));

            mergeSpecs(specs);

            setSlicePinned(hasPermission);

        }

    }



    public boolean removeSliceListener(ISliceListener listener) {

        synchronized (mLock) {

            listener.asBinder().unlinkToDeath(mDeathRecipient, 0);

            if (mListeners.containsKey(listener.asBinder()) && mListeners.size() == 1) {

                mService.unlisten(mUri);

            }

            mListeners.remove(listener.asBinder());

        }

        return !hasPinOrListener();

    }



    public void pin(String pkg, SliceSpec[] specs) {

        synchronized (mLock) {

            setSlicePinned(true);

            mPinnedPkgs.add(pkg);

            mergeSpecs(specs);

        }

    }



    public boolean unpin(String pkg) {

    public boolean unpin(String pkg, IBinder token) {

        synchronized (mLock) {

            mPinnedPkgs.remove(pkg);

            token.unlinkToDeath(mDeathRecipient, 0);

            mListeners.remove(token);

        }

        return !hasPinOrListener();

    }
@@ -171,30 +144,6 @@ public class PinnedSliceState { 
        }

    }



    public void recheckPackage(String pkg) {

        synchronized (mLock) {

            for (int i = 0; i < mListeners.size(); i++) {

                ListenerInfo info = mListeners.valueAt(i);

                if (!info.hasPermission && Objects.equals(info.pkg, pkg)) {

                    mService.getHandler().post(() -> {

                        // This bind lets the app itself participate in the permission grant.

                        Slice s = doBind(info);

                        if (mService.checkAccess(info.pkg, mUri, info.callingUid, info.callingPid)

                                == PERMISSION_GRANTED) {

                            info.hasPermission = true;

                            setSlicePinned(true);

                            try {

                                info.listener.onSliceUpdated(s);

                            } catch (RemoteException e) {

                                checkSelfRemove();

                            }

                        }

                    });

                }

            }

        }

    }



    @VisibleForTesting

    public boolean hasPinOrListener() {

        synchronized (mLock) {
@@ -213,7 +162,6 @@ public class PinnedSliceState { 
    private void checkSelfRemove() {

        if (!hasPinOrListener()) {

            // All the listeners died, remove from pinned state.

            mService.unlisten(mUri);

            mService.removePinnedSlice(mUri);

        }

    }
@@ -223,70 +171,14 @@ public class PinnedSliceState { 
        synchronized (mLock) {

            for (int i = mListeners.size() - 1; i >= 0; i--) {

                ListenerInfo l = mListeners.valueAt(i);

                if (!l.listener.asBinder().isBinderAlive()) {

                    mListeners.removeAt(i);

                }

            }

            checkSelfRemove();

        }

    }



    private void handleBind() {

        Slice cachedSlice = doBind(null);

        synchronized (mLock) {

            if (!hasPinOrListener()) return;

            for (int i = mListeners.size() - 1; i >= 0; i--) {

                ListenerInfo info = mListeners.valueAt(i);

                Slice s = cachedSlice;

                if (s == null || s.hasHint(Slice.HINT_CALLER_NEEDED)

                        || !info.hasPermission) {

                    s = doBind(info);

                }

                if (s == null) {

                    mListeners.removeAt(i);

                    continue;

                }

                try {

                    info.listener.onSliceUpdated(s);

                } catch (RemoteException e) {

                    Log.e(TAG, "Unable to notify slice " + mUri, e);

                if (!l.token.isBinderAlive()) {

                    mListeners.removeAt(i);

                    continue;

                }

            }

            checkSelfRemove();

        }

    }



    private Slice doBind(ListenerInfo info) {

        try (ContentProviderClient client = getClient()) {

            if (client == null) return null;

            Bundle extras = new Bundle();

            extras.putParcelable(SliceProvider.EXTRA_BIND_URI, mUri);

            extras.putParcelableArrayList(SliceProvider.EXTRA_SUPPORTED_SPECS,

                    new ArrayList<>(Arrays.asList(mSupportedSpecs)));

            if (info != null) {

                extras.putString(SliceProvider.EXTRA_OVERRIDE_PKG, info.pkg);

                extras.putInt(SliceProvider.EXTRA_OVERRIDE_UID, info.callingUid);

                extras.putInt(SliceProvider.EXTRA_OVERRIDE_PID, info.callingPid);

            }

            final Bundle res;

            try {

                res = client.call(SliceProvider.METHOD_SLICE, null, extras);

            } catch (RemoteException e) {

                Log.e(TAG, "Unable to bind slice " + mUri, e);

                return null;

            }

            if (res == null) return null;

            Bundle.setDefusable(res, true);

            return res.getParcelable(SliceProvider.EXTRA_SLICE);

        } catch (Throwable t) {

            // Calling out of the system process, make sure they don't throw anything at us.

            Log.e(TAG, "Caught throwable while binding " + mUri, t);

            return null;

        }

    }



    private void handleSendPinned() {

        try (ContentProviderClient client = getClient()) {

            if (client == null) return;
@@ -315,15 +207,15 @@ public class PinnedSliceState { 


    private class ListenerInfo {



        private ISliceListener listener;

        private IBinder token;

        private String pkg;

        private boolean hasPermission;

        private int callingUid;

        private int callingPid;



        public ListenerInfo(ISliceListener listener, String pkg, boolean hasPermission,

        public ListenerInfo(IBinder token, String pkg, boolean hasPermission,

                int callingUid, int callingPid) {

            this.listener = listener;

            this.token = token;

            this.pkg = pkg;

            this.hasPermission = hasPermission;

            this.callingUid = callingUid;

services/core/java/com/android/server/slice/SliceManagerService.java

+6 −61
Original line number Diff line number Diff line
@@ -28,7 +28,6 @@ import android.app.ActivityManager; 
import android.app.AppOpsManager;

import android.app.ContentProviderHolder;

import android.app.IActivityManager;

import android.app.slice.ISliceListener;

import android.app.slice.ISliceManager;

import android.app.slice.SliceManager;

import android.app.slice.SliceSpec;
@@ -39,7 +38,6 @@ import android.content.Intent; 
import android.content.IntentFilter;

import android.content.pm.PackageManagerInternal;

import android.content.pm.ResolveInfo;

import android.database.ContentObserver;

import android.net.Uri;

import android.os.Binder;

import android.os.Environment;
@@ -52,7 +50,6 @@ import android.os.UserHandle; 
import android.util.ArrayMap;

import android.util.ArraySet;

import android.util.AtomicFile;

import android.util.Log;

import android.util.Slog;

import android.util.Xml.Encoding;
@@ -94,7 +91,6 @@ public class SliceManagerService extends ISliceManager.Stub { 
    @GuardedBy("mLock")

    private final ArraySet<SliceGrant> mUserGrants = new ArraySet<>();

    private final Handler mHandler;

    private final ContentObserver mObserver;

    @GuardedBy("mSliceAccessFile")

    private final AtomicFile mSliceAccessFile;

    @GuardedBy("mAccessList")
@@ -113,16 +109,6 @@ public class SliceManagerService extends ISliceManager.Stub { 
        mAssistUtils = new AssistUtils(context);

        mHandler = new Handler(looper);



        mObserver = new ContentObserver(mHandler) {

            @Override

            public void onChange(boolean selfChange, Uri uri, int userId) {

                try {

                    getPinnedSlice(maybeAddUserId(uri, userId)).onChange();

                } catch (IllegalStateException e) {

                    Log.e(TAG, "Received change for unpinned slice " + uri, e);

                }

            }

        };

        final File systemDir = new File(Environment.getDataDirectory(), "system");

        mSliceAccessFile = new AtomicFile(new File(systemDir, "slice_access.xml"));

        mAccessList = new SliceFullAccessList(mContext);
@@ -163,40 +149,19 @@ public class SliceManagerService extends ISliceManager.Stub { 


    ///  ----- ISliceManager stuff -----

    @Override

    public void addSliceListener(Uri uri, String pkg, ISliceListener listener, SliceSpec[] specs)

            throws RemoteException {

        verifyCaller(pkg);

        uri = maybeAddUserId(uri, Binder.getCallingUserHandle().getIdentifier());

        enforceCrossUser(pkg, uri);

        getOrCreatePinnedSlice(uri).addSliceListener(listener, pkg, specs,

                checkAccess(pkg, uri, Binder.getCallingUid(), Binder.getCallingUid())

                == PERMISSION_GRANTED);

    }



    @Override

    public void removeSliceListener(Uri uri, String pkg, ISliceListener listener)

            throws RemoteException {

        verifyCaller(pkg);

        uri = maybeAddUserId(uri, Binder.getCallingUserHandle().getIdentifier());

        if (getPinnedSlice(uri).removeSliceListener(listener)) {

            removePinnedSlice(uri);

        }

    }



    @Override

    public void pinSlice(String pkg, Uri uri, SliceSpec[] specs) throws RemoteException {

    public void pinSlice(String pkg, Uri uri, SliceSpec[] specs, IBinder token) throws RemoteException {

        verifyCaller(pkg);

        enforceFullAccess(pkg, "pinSlice", uri);

        enforceAccess(pkg, uri);

        uri = maybeAddUserId(uri, Binder.getCallingUserHandle().getIdentifier());

        getOrCreatePinnedSlice(uri).pin(pkg, specs);

        getOrCreatePinnedSlice(uri).pin(pkg, specs, token);

    }



    @Override

    public void unpinSlice(String pkg, Uri uri) throws RemoteException {

    public void unpinSlice(String pkg, Uri uri, IBinder token) throws RemoteException {

        verifyCaller(pkg);

        enforceFullAccess(pkg, "unpinSlice", uri);

        enforceAccess(pkg, uri);

        uri = maybeAddUserId(uri, Binder.getCallingUserHandle().getIdentifier());

        if (getPinnedSlice(uri).unpin(pkg)) {

        if (getPinnedSlice(uri).unpin(pkg, token)) {

            removePinnedSlice(uri);

        }

    }
@@ -253,11 +218,6 @@ public class SliceManagerService extends ISliceManager.Stub { 
        } finally {

            Binder.restoreCallingIdentity(ident);

        }

        synchronized (mLock) {

            for (PinnedSliceState p : mPinnedSlicesByUri.values()) {

                p.recheckPackage(pkg);

            }

        }

    }



    // Backup/restore interface
@@ -457,21 +417,6 @@ public class SliceManagerService extends ISliceManager.Stub { 
        return cn.getPackageName().equals(pkg);

    }



    public void listen(Uri uri) {

        mContext.getContentResolver().registerContentObserver(uri, true, mObserver);

    }



    public void unlisten(Uri uri) {

        mContext.getContentResolver().unregisterContentObserver(mObserver);

        synchronized (mLock) {

            mPinnedSlicesByUri.forEach((u, s) -> {

                if (s.isListening()) {

                    listen(u);

                }

            });

        }

    }



    private boolean isDefaultHomeApp(String pkg, int userId) {

        String defaultHome = getDefaultHome(userId);

services/tests/uiservicestests/src/com/android/server/slice/PinnedSliceStateTest.java

+10 −167

File changed.

Preview size limit exceeded, changes collapsed.