core/java/android/content/pm/permission/RuntimePermissionPresenter.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2016 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.content.pm.permission;

 import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
 import android.content.pm.ApplicationInfo;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.Message;
 import android.os.RemoteCallback;
 import android.os.RemoteException;
 import android.permissionpresenterservice.RuntimePermissionPresenterService;
 import android.util.Log;
 import com.android.internal.annotations.GuardedBy;
 import com.android.internal.os.SomeArgs;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;

 /**
  * This class provides information about runtime permissions for a specific
  * app or all apps. This information is dedicated for presentation purposes
  * and does not necessarily reflect the individual permissions requested/
  * granted to an app as the platform may be grouping permissions to improve
  * presentation and help the user make an informed choice. For example, all
  * runtime permissions in the same permission group may be presented as a
  * single permission in the UI.
  *
  * @hide
  */
 public final class RuntimePermissionPresenter {
     private static final String TAG = "RuntimePermPresenter";

     /**
      * The key for retrieving the result from the returned bundle.
      *
      * @hide
      */
     public static final String KEY_RESULT =
             "android.content.pm.permission.RuntimePermissionPresenter.key.result";

     /**
      * Listener for delivering a result.
      */
     public static abstract class OnResultCallback {
         /**
          * The result for {@link #getAppPermissions(String, OnResultCallback, Handler)}.
          * @param permissions The permissions list.
          */
         public void onGetAppPermissions(@NonNull
                 List<RuntimePermissionPresentationInfo> permissions) {
             /* do nothing - stub */
         }

         /**
          * The result for {@link #getAppsUsingPermissions(boolean, List)}.
          * @param system Whether to return only the system apps or only the non-system ones.
          * @param apps The apps using runtime permissions.
          */
         public void getAppsUsingPermissions(boolean system, @NonNull List<ApplicationInfo> apps) {
             /* do nothing - stub */
         }
     }

     private static final Object sLock = new Object();

     @GuardedBy("sLock")
     private static RuntimePermissionPresenter sInstance;

     private final RemoteService mRemoteService;

     /**
      * Gets the singleton runtime permission presenter.
      *
      * @param context Context for accessing resources.
      * @return The singleton instance.
      */
     public static RuntimePermissionPresenter getInstance(@NonNull Context context) {
         synchronized (sLock) {
             if (sInstance == null) {
                 sInstance = new RuntimePermissionPresenter(context.getApplicationContext());
             }
             return sInstance;
         }
     }

     private RuntimePermissionPresenter(Context context) {
         mRemoteService = new RemoteService(context);
     }

     /**
      * Gets the runtime permissions for an app.
      *
      * @param packageName The package for which to query.
      * @param callback Callback to receive the result.
      * @param handler Handler on which to invoke the callback.
      */
     public void getAppPermissions(@NonNull String packageName,
             @NonNull OnResultCallback callback, @Nullable Handler handler) {
         SomeArgs args = SomeArgs.obtain();
         args.arg1 = packageName;
         args.arg2 = callback;
         args.arg3 = handler;
         Message message = mRemoteService.obtainMessage(
                 RemoteService.MSG_GET_APP_PERMISSIONS, args);
         mRemoteService.processMessage(message);
     }

     /**
      * Gets the system apps that use runtime permissions. System apps are ones
      * that are considered system for presentation purposes instead of ones
      * that are preinstalled on the system image. System apps are ones that
      * are on the system image, haven't been updated (a.k.a factory apps)
      * that do not have a launcher icon.
      *
      * @param system If true only system apps are returned otherwise only
      *        non-system ones are returned.
      * @param callback Callback to receive the result.
      * @param handler Handler on which to invoke the callback.
      */
     public void getAppsUsingPermissions(boolean system, @NonNull OnResultCallback callback,
             @Nullable Handler handler) {
         SomeArgs args = SomeArgs.obtain();
         args.arg1 = callback;
         args.arg2 = handler;
         args.argi1 = system ? 1 : 0;
         Message message = mRemoteService.obtainMessage(
                 RemoteService.MSG_GET_APPS_USING_PERMISSIONS, args);
         mRemoteService.processMessage(message);
     }

     private static final class RemoteService
             extends Handler implements ServiceConnection {
         private static final long UNBIND_TIMEOUT_MILLIS = 10000;

         public static final int MSG_GET_APP_PERMISSIONS = 1;
         public static final int MSG_GET_APPS_USING_PERMISSIONS = 2;
         public static final int MSG_UNBIND = 3;

         private final Object mLock = new Object();

         private final Context mContext;

         @GuardedBy("mLock")
         private final List<Message> mPendingWork = new ArrayList<>();

         @GuardedBy("mLock")
         private IRuntimePermissionPresenter mRemoteInstance;

         @GuardedBy("mLock")
         private boolean mBound;

         public RemoteService(Context context) {
             super(context.getMainLooper(), null, false);
             mContext = context;
         }

         public void processMessage(Message message) {
             synchronized (mLock) {
                 if (!mBound) {
                     Intent intent = new Intent(
                             RuntimePermissionPresenterService.SERVICE_INTERFACE);
                     intent.setPackage(mContext.getPackageManager()
                             .getPermissionControllerPackageName());
                     mBound = mContext.bindService(intent, this,
                             Context.BIND_AUTO_CREATE);
                 }
                 mPendingWork.add(message);
                 scheduleNextMessageIfNeededLocked();
             }
         }

         @Override
         public void onServiceConnected(ComponentName name, IBinder service) {
             synchronized (mLock) {
                 mRemoteInstance = IRuntimePermissionPresenter.Stub.asInterface(service);
                 scheduleNextMessageIfNeededLocked();
             }
         }

         @Override
         public void onServiceDisconnected(ComponentName name) {
             synchronized (mLock) {
                 mRemoteInstance = null;
             }
         }

         @Override
         public void handleMessage(Message msg) {
             switch (msg.what) {
                 case MSG_GET_APP_PERMISSIONS: {
                     SomeArgs args = (SomeArgs) msg.obj;
                     final String packageName = (String) args.arg1;
                     final OnResultCallback callback = (OnResultCallback) args.arg2;
                     final Handler handler = (Handler) args.arg3;
                     args.recycle();
                     final IRuntimePermissionPresenter remoteInstance;
                     synchronized (mLock) {
                         remoteInstance = mRemoteInstance;
                     }
                     if (remoteInstance == null) {
                         return;
                     }
                     try {
                         remoteInstance.getAppPermissions(packageName,
                                 new RemoteCallback(new RemoteCallback.OnResultListener() {
                             @Override
                             public void onResult(Bundle result) {
                                 final List<RuntimePermissionPresentationInfo> reportedPermissions;
                                 List<RuntimePermissionPresentationInfo> permissions = null;
                                 if (result != null) {
                                     permissions = result.getParcelableArrayList(KEY_RESULT);
                                 }
                                 if (permissions == null) {
                                     permissions = Collections.emptyList();
                                 }
                                 reportedPermissions = permissions;
                                 if (handler != null) {
                                     handler.post(new Runnable() {
                                         @Override
                                         public void run() {
                                             callback.onGetAppPermissions(reportedPermissions);
                                         }
                                     });
                                 } else {
                                     callback.onGetAppPermissions(reportedPermissions);
                                 }
                             }
                         }, this));
                     } catch (RemoteException re) {
                         Log.e(TAG, "Error getting app permissions", re);
                     }
                     scheduleUnbind();
                 } break;

                 case MSG_GET_APPS_USING_PERMISSIONS: {
                     SomeArgs args = (SomeArgs) msg.obj;
                     final OnResultCallback callback = (OnResultCallback) args.arg1;
                     final Handler handler = (Handler) args.arg2;
                     final boolean system = args.argi1 == 1;
                     args.recycle();
                     final IRuntimePermissionPresenter remoteInstance;
                     synchronized (mLock) {
                         remoteInstance = mRemoteInstance;
                     }
                     if (remoteInstance == null) {
                         return;
                     }
                     try {
                         remoteInstance.getAppsUsingPermissions(system, new RemoteCallback(
                                 new RemoteCallback.OnResultListener() {
                             @Override
                             public void onResult(Bundle result) {
                                 final List<ApplicationInfo> reportedApps;
                                 List<ApplicationInfo> apps = null;
                                 if (result != null) {
                                     apps = result.getParcelableArrayList(KEY_RESULT);
                                 }
                                 if (apps == null) {
                                     apps = Collections.emptyList();
                                 }
                                 reportedApps = apps;
                                 if (handler != null) {
                                     handler.post(new Runnable() {
                                         @Override
                                         public void run() {
                                             callback.getAppsUsingPermissions(system, reportedApps);
                                         }
                                     });
                                 } else {
                                     callback.getAppsUsingPermissions(system, reportedApps);
                                 }
                             }
                         }, this));
                     } catch (RemoteException re) {
                         Log.e(TAG, "Error getting apps using permissions", re);
                     }
                     scheduleUnbind();
                 } break;

                 case MSG_UNBIND: {
                     synchronized (mLock) {
                         if (mBound) {
                             mContext.unbindService(this);
                             mBound = false;
                         }
                         mRemoteInstance = null;
                     }
                 } break;
             }

             synchronized (mLock) {
                 scheduleNextMessageIfNeededLocked();
             }
         }

         private void scheduleNextMessageIfNeededLocked() {
             if (mBound && mRemoteInstance != null && !mPendingWork.isEmpty()) {
                 Message nextMessage = mPendingWork.remove(0);
                 sendMessage(nextMessage);
             }
         }

         private void scheduleUnbind() {
             removeMessages(MSG_UNBIND);
             sendEmptyMessageDelayed(MSG_UNBIND, UNBIND_TIMEOUT_MILLIS);
         }
     }
 }
	/*
	* Copyright (C) 2016 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.content.pm.permission;

	import android.annotation.NonNull;
	import android.annotation.Nullable;
	import android.content.ComponentName;
	import android.content.Context;
	import android.content.Intent;
	import android.content.ServiceConnection;
	import android.content.pm.ApplicationInfo;
	import android.os.Bundle;
	import android.os.Handler;
	import android.os.IBinder;
	import android.os.Message;
	import android.os.RemoteCallback;
	import android.os.RemoteException;
	import android.permissionpresenterservice.RuntimePermissionPresenterService;
	import android.util.Log;
	import com.android.internal.annotations.GuardedBy;
	import com.android.internal.os.SomeArgs;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.List;

	/**
	* This class provides information about runtime permissions for a specific
	* app or all apps. This information is dedicated for presentation purposes
	* and does not necessarily reflect the individual permissions requested/
	* granted to an app as the platform may be grouping permissions to improve
	* presentation and help the user make an informed choice. For example, all
	* runtime permissions in the same permission group may be presented as a
	* single permission in the UI.
	*
	* @hide
	*/
	public final class RuntimePermissionPresenter {
	private static final String TAG = "RuntimePermPresenter";

	/**
	* The key for retrieving the result from the returned bundle.
	*
	* @hide
	*/
	public static final String KEY_RESULT =
	"android.content.pm.permission.RuntimePermissionPresenter.key.result";

	/**
	* Listener for delivering a result.
	*/
	public static abstract class OnResultCallback {
	/**
	* The result for {@link #getAppPermissions(String, OnResultCallback, Handler)}.
	* @param permissions The permissions list.
	*/
	public void onGetAppPermissions(@NonNull
	List<RuntimePermissionPresentationInfo> permissions) {
	/* do nothing - stub */
	}

	/**
	* The result for {@link #getAppsUsingPermissions(boolean, List)}.
	* @param system Whether to return only the system apps or only the non-system ones.
	* @param apps The apps using runtime permissions.
	*/
	public void getAppsUsingPermissions(boolean system, @NonNull List<ApplicationInfo> apps) {
	/* do nothing - stub */
	}
	}

	private static final Object sLock = new Object();

	@GuardedBy("sLock")
	private static RuntimePermissionPresenter sInstance;

	private final RemoteService mRemoteService;

	/**
	* Gets the singleton runtime permission presenter.
	*
	* @param context Context for accessing resources.
	* @return The singleton instance.
	*/
	public static RuntimePermissionPresenter getInstance(@NonNull Context context) {
	synchronized (sLock) {
	if (sInstance == null) {
	sInstance = new RuntimePermissionPresenter(context.getApplicationContext());
	}
	return sInstance;
	}
	}

	private RuntimePermissionPresenter(Context context) {
	mRemoteService = new RemoteService(context);
	}

	/**
	* Gets the runtime permissions for an app.
	*
	* @param packageName The package for which to query.
	* @param callback Callback to receive the result.
	* @param handler Handler on which to invoke the callback.
	*/
	public void getAppPermissions(@NonNull String packageName,
	@NonNull OnResultCallback callback, @Nullable Handler handler) {
	SomeArgs args = SomeArgs.obtain();
	args.arg1 = packageName;
	args.arg2 = callback;
	args.arg3 = handler;
	Message message = mRemoteService.obtainMessage(
	RemoteService.MSG_GET_APP_PERMISSIONS, args);
	mRemoteService.processMessage(message);
	}

	/**
	* Gets the system apps that use runtime permissions. System apps are ones
	* that are considered system for presentation purposes instead of ones
	* that are preinstalled on the system image. System apps are ones that
	* are on the system image, haven't been updated (a.k.a factory apps)
	* that do not have a launcher icon.
	*
	* @param system If true only system apps are returned otherwise only
	* non-system ones are returned.
	* @param callback Callback to receive the result.
	* @param handler Handler on which to invoke the callback.
	*/
	public void getAppsUsingPermissions(boolean system, @NonNull OnResultCallback callback,
	@Nullable Handler handler) {
	SomeArgs args = SomeArgs.obtain();
	args.arg1 = callback;
	args.arg2 = handler;
	args.argi1 = system ? 1 : 0;
	Message message = mRemoteService.obtainMessage(
	RemoteService.MSG_GET_APPS_USING_PERMISSIONS, args);
	mRemoteService.processMessage(message);
	}

	private static final class RemoteService
	extends Handler implements ServiceConnection {
	private static final long UNBIND_TIMEOUT_MILLIS = 10000;

	public static final int MSG_GET_APP_PERMISSIONS = 1;
	public static final int MSG_GET_APPS_USING_PERMISSIONS = 2;
	public static final int MSG_UNBIND = 3;

	private final Object mLock = new Object();

	private final Context mContext;

	@GuardedBy("mLock")
	private final List<Message> mPendingWork = new ArrayList<>();

	@GuardedBy("mLock")
	private IRuntimePermissionPresenter mRemoteInstance;

	@GuardedBy("mLock")
	private boolean mBound;

	public RemoteService(Context context) {
	super(context.getMainLooper(), null, false);
	mContext = context;
	}

	public void processMessage(Message message) {
	synchronized (mLock) {
	if (!mBound) {
	Intent intent = new Intent(
	RuntimePermissionPresenterService.SERVICE_INTERFACE);
	intent.setPackage(mContext.getPackageManager()
	.getPermissionControllerPackageName());
	mBound = mContext.bindService(intent, this,
	Context.BIND_AUTO_CREATE);
	}
	mPendingWork.add(message);
	scheduleNextMessageIfNeededLocked();
	}
	}

	@Override
	public void onServiceConnected(ComponentName name, IBinder service) {
	synchronized (mLock) {
	mRemoteInstance = IRuntimePermissionPresenter.Stub.asInterface(service);
	scheduleNextMessageIfNeededLocked();
	}
	}

	@Override
	public void onServiceDisconnected(ComponentName name) {
	synchronized (mLock) {
	mRemoteInstance = null;
	}
	}

	@Override
	public void handleMessage(Message msg) {
	switch (msg.what) {
	case MSG_GET_APP_PERMISSIONS: {
	SomeArgs args = (SomeArgs) msg.obj;
	final String packageName = (String) args.arg1;
	final OnResultCallback callback = (OnResultCallback) args.arg2;
	final Handler handler = (Handler) args.arg3;
	args.recycle();
	final IRuntimePermissionPresenter remoteInstance;
	synchronized (mLock) {
	remoteInstance = mRemoteInstance;
	}
	if (remoteInstance == null) {
	return;
	}
	try {
	remoteInstance.getAppPermissions(packageName,
	new RemoteCallback(new RemoteCallback.OnResultListener() {
	@Override
	public void onResult(Bundle result) {
	final List<RuntimePermissionPresentationInfo> reportedPermissions;
	List<RuntimePermissionPresentationInfo> permissions = null;
	if (result != null) {
	permissions = result.getParcelableArrayList(KEY_RESULT);
	}
	if (permissions == null) {
	permissions = Collections.emptyList();
	}
	reportedPermissions = permissions;
	if (handler != null) {
	handler.post(new Runnable() {
	@Override
	public void run() {
	callback.onGetAppPermissions(reportedPermissions);
	}
	});
	} else {
	callback.onGetAppPermissions(reportedPermissions);
	}
	}
	}, this));
	} catch (RemoteException re) {
	Log.e(TAG, "Error getting app permissions", re);
	}
	scheduleUnbind();
	} break;

	case MSG_GET_APPS_USING_PERMISSIONS: {
	SomeArgs args = (SomeArgs) msg.obj;
	final OnResultCallback callback = (OnResultCallback) args.arg1;
	final Handler handler = (Handler) args.arg2;
	final boolean system = args.argi1 == 1;
	args.recycle();
	final IRuntimePermissionPresenter remoteInstance;
	synchronized (mLock) {
	remoteInstance = mRemoteInstance;
	}
	if (remoteInstance == null) {
	return;
	}
	try {
	remoteInstance.getAppsUsingPermissions(system, new RemoteCallback(
	new RemoteCallback.OnResultListener() {
	@Override
	public void onResult(Bundle result) {
	final List<ApplicationInfo> reportedApps;
	List<ApplicationInfo> apps = null;
	if (result != null) {
	apps = result.getParcelableArrayList(KEY_RESULT);
	}
	if (apps == null) {
	apps = Collections.emptyList();
	}
	reportedApps = apps;
	if (handler != null) {
	handler.post(new Runnable() {
	@Override
	public void run() {
	callback.getAppsUsingPermissions(system, reportedApps);
	}
	});
	} else {
	callback.getAppsUsingPermissions(system, reportedApps);
	}
	}
	}, this));
	} catch (RemoteException re) {
	Log.e(TAG, "Error getting apps using permissions", re);
	}
	scheduleUnbind();
	} break;

	case MSG_UNBIND: {
	synchronized (mLock) {
	if (mBound) {
	mContext.unbindService(this);
	mBound = false;
	}
	mRemoteInstance = null;
	}
	} break;
	}

	synchronized (mLock) {
	scheduleNextMessageIfNeededLocked();
	}
	}

	private void scheduleNextMessageIfNeededLocked() {
	if (mBound && mRemoteInstance != null && !mPendingWork.isEmpty()) {
	Message nextMessage = mPendingWork.remove(0);
	sendMessage(nextMessage);
	}
	}

	private void scheduleUnbind() {
	removeMessages(MSG_UNBIND);
	sendEmptyMessageDelayed(MSG_UNBIND, UNBIND_TIMEOUT_MILLIS);
	}
	}
	}