Java tutorial
/** * 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 * <p> * http://www.apache.org/licenses/LICENSE-2.0 * <p> * 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.codyy.rx.permissions; import android.annotation.TargetApi; import android.app.Activity; import android.content.Context; import android.content.DialogInterface; import android.content.Intent; import android.net.Uri; import android.os.Build; import android.support.annotation.NonNull; import android.support.v7.app.AlertDialog; import android.text.TextUtils; import android.widget.Toast; import java.util.ArrayList; import java.util.List; import io.reactivex.Observable; import io.reactivex.ObservableSource; import io.reactivex.ObservableTransformer; import io.reactivex.functions.Function; import io.reactivex.subjects.PublishSubject; public class RxPermissions { static final String TAG = "RxPermissions"; private RxPermissionsFragment mRxPermissionsFragment; public RxPermissions(@NonNull android.support.v4.app.FragmentManager fragmentManager) { mRxPermissionsFragment = getRxPermissionsFragment(fragmentManager); } private RxPermissionsFragment getRxPermissionsFragment( @NonNull android.support.v4.app.FragmentManager fragmentManager) { RxPermissionsFragment rxPermissionsFragment = findRxPermissionsFragment(fragmentManager); boolean isNewInstance = rxPermissionsFragment == null; if (isNewInstance) { rxPermissionsFragment = new RxPermissionsFragment(); fragmentManager.beginTransaction().add(rxPermissionsFragment, TAG).commitAllowingStateLoss(); fragmentManager.executePendingTransactions(); } return rxPermissionsFragment; } private RxPermissionsFragment findRxPermissionsFragment( @NonNull android.support.v4.app.FragmentManager fragmentManager) { return (RxPermissionsFragment) fragmentManager.findFragmentByTag(TAG); } public void setLogging(boolean logging) { mRxPermissionsFragment.setLogging(logging); } /** * Map emitted items from the source observable into {@code true} if permissions in parameters * are granted, or {@code false} if not. * <p> * If one or several permissions have never been requested, invoke the related framework method * to ask the user if he allows the permissions. */ @SuppressWarnings("WeakerAccess") public ObservableTransformer<Object, Boolean> ensure(final String... permissions) { return new ObservableTransformer<Object, Boolean>() { @Override public ObservableSource<Boolean> apply(Observable<Object> observable) { return request(observable, permissions) // Transform Observable<Permission> to Observable<Boolean> .buffer(permissions.length) .flatMap(new Function<List<Permission>, ObservableSource<Boolean>>() { @Override public ObservableSource<Boolean> apply( @io.reactivex.annotations.NonNull List<Permission> permissions) throws Exception { if (permissions.isEmpty()) { // Occurs during orientation change, when the subject receives onComplete. // In that case we don't want to propagate that empty list to the // subscriber, only the onComplete. return Observable.empty(); } // Return true if all permissions are granted. for (Permission p : permissions) { if (!p.granted) { return Observable.just(false); } } return Observable.just(true); } }); } }; } /** * Map emitted items from the source observable into {@link Permission} objects for each * permission in parameters. * <p> * If one or several permissions have never been requested, invoke the related framework method * to ask the user if he allows the permissions. */ @SuppressWarnings("WeakerAccess") public ObservableTransformer<Object, Permission> ensureEach(final String... permissions) { return new ObservableTransformer<Object, Permission>() { @Override public ObservableSource<Permission> apply(Observable<Object> observable) { return request(observable, permissions); } }; } /** * Request permissions immediately, <b>must be invoked during initialization phase * of your application</b>. */ @SuppressWarnings({ "WeakerAccess", "unused" }) public Observable<Boolean> request(final String... permissions) { return Observable.just(1).compose(ensure(permissions)); } /** * Request permissions immediately, <b>must be invoked during initialization phase * of your application</b>. */ @SuppressWarnings({ "WeakerAccess", "unused" }) public Observable<Permission> requestEach(final String... permissions) { return Observable.just(1).compose(ensureEach(permissions)); } private Observable<Permission> request(final Observable<?> trigger, final String... permissions) { if (permissions == null || permissions.length == 0) { throw new IllegalArgumentException( "RxPermissions.request/requestEach requires at least one input permission"); } return oneOf(trigger, pending(permissions)).flatMap(new Function<Object, ObservableSource<Permission>>() { @Override public ObservableSource<Permission> apply(@io.reactivex.annotations.NonNull Object o) throws Exception { return requestImplementation(permissions); } }); } private Observable<?> pending(final String... permissions) { for (String p : permissions) { if (!mRxPermissionsFragment.containsByPermission(p)) { return Observable.empty(); } } return Observable.just(1); } private Observable<?> oneOf(Observable<?> trigger, Observable<?> pending) { if (trigger == null) { return Observable.just(1); } return Observable.merge(trigger, pending); } private Observable<Permission> requestImplementation(final String... permissions) { List<Observable<Permission>> list = new ArrayList<>(permissions.length); List<String> unrequestedPermissions = new ArrayList<>(); // In case of multiple permissions, we create an Observable for each of them. // At the end, the observables are combined to have a unique response. for (String permission : permissions) { mRxPermissionsFragment.log("Requesting permission " + permission); if (isGranted(permission)) { // Already granted, or not Android M // Return a granted Permission object. list.add(Observable.just(new Permission(permission, true, false))); continue; } if (isRevoked(permission)) { // Revoked by a policy, return a denied Permission object. list.add(Observable.just(new Permission(permission, false, false))); continue; } PublishSubject<Permission> subject = mRxPermissionsFragment.getSubjectByPermission(permission); // Create a new subject if not exists if (subject == null) { unrequestedPermissions.add(permission); subject = PublishSubject.create(); mRxPermissionsFragment.setSubjectForPermission(permission, subject); } list.add(subject); } if (!unrequestedPermissions.isEmpty()) { String[] unrequestedPermissionsArray = unrequestedPermissions .toArray(new String[unrequestedPermissions.size()]); requestPermissionsFromFragment(unrequestedPermissionsArray); } return Observable.concat(Observable.fromIterable(list)); } /** * Invokes Activity.shouldShowRequestPermissionRationale and wraps * the returned value in an observable. * <p> * In case of multiple permissions, only emits true if * Activity.shouldShowRequestPermissionRationale returned true for * all revoked permissions. * <p> * You shouldn't call this method if all permissions have been granted. * <p> * For SDK < 23, the observable will always emit false. */ @SuppressWarnings("WeakerAccess") public Observable<Boolean> shouldShowRequestPermissionRationale(final Activity activity, final String... permissions) { if (!isMarshmallow()) { return Observable.just(false); } return Observable.just(shouldShowRequestPermissionRationaleImplementation(activity, permissions)); } @TargetApi(Build.VERSION_CODES.M) private boolean shouldShowRequestPermissionRationaleImplementation(final Activity activity, final String... permissions) { for (String p : permissions) { if (!isGranted(p) && !activity.shouldShowRequestPermissionRationale(p)) { return false; } } return true; } @TargetApi(Build.VERSION_CODES.M) void requestPermissionsFromFragment(String[] permissions) { mRxPermissionsFragment.log("requestPermissionsFromFragment " + TextUtils.join(", ", permissions)); mRxPermissionsFragment.requestPermissions(permissions); } /** * Returns true if the permission is already granted. * <p> * Always true if SDK < 23. */ @SuppressWarnings("WeakerAccess") public boolean isGranted(String permission) { return !isMarshmallow() || mRxPermissionsFragment.isGranted(permission); } /** * Returns true if the permission has been revoked by a policy. * <p> * Always false if SDK < 23. */ @SuppressWarnings("WeakerAccess") public boolean isRevoked(String permission) { return isMarshmallow() && mRxPermissionsFragment.isRevoked(permission); } boolean isMarshmallow() { return Build.VERSION.SDK_INT >= Build.VERSION_CODES.M; } void onRequestPermissionsResult(String permissions[], int[] grantResults) { mRxPermissionsFragment.onRequestPermissionsResult(permissions, grantResults, new boolean[permissions.length]); } /** * ??,???? * * @param context context * @param packageName ?? * @param message ??? */ public static void showDialog(@NonNull final Context context, @NonNull final String packageName, @NonNull String message) { AlertDialog.Builder builder = new AlertDialog.Builder(context); builder.setTitle("??").setMessage(message); builder.setCancelable(true); builder.setPositiveButton("", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { openPermissionSettings(context, packageName); } }).setNegativeButton("?", null).create().show(); } /** * ??? * * @param context context * @param packageName ?? */ public static void openPermissionSettings(@NonNull Context context, @NonNull String packageName) { Intent intent = new Intent(); intent.setAction("miui.intent.action.APP_PERM_EDITOR");//??MIUI??? intent.addCategory(Intent.CATEGORY_DEFAULT); intent.putExtra("extra_pkgname", packageName); if (intent.resolveActivity(context.getPackageManager()) != null) { context.startActivity(intent); } else { Uri packageURI = Uri.parse("package:" + packageName); intent = new Intent("android.settings.APPLICATION_DETAILS_SETTINGS", packageURI);//??? if (intent.resolveActivity(context.getPackageManager()) != null) { context.startActivity(intent); } else { Toast.makeText(context, "???", Toast.LENGTH_SHORT).show(); } } } }