public class EasyPermissions {
private static final String TAG = "EasyPermissions";
private static PermissionDialog finalPermissionDialog = null;
public interface PermissionCallbacks {
void onPermissionsGranted(int requestCode, List<String> perms);
void onPermissionsDenied(int requestCode, List<String> perms);
void onPermissionsPermanentlyDeclined(int requestCode, List<String> perms);
}
/** * Check if the calling mContext has a set of permissions. * * @param context the calling mContext. * @param perms one ore more permissions, such as {@code android.Manifest.permission.CAMERA}. * @return true if all permissions are already granted, false if at least one permission * is not yet granted. */ public static boolean hasPermissions(Context context, String... perms) {
// Always return true for SDK < M, let the system deal with the permissions if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
Log.w(TAG, "hasPermissions: API version < M, returning true by default");
return true;
}
for (String perm : perms) {
boolean hasPerm = (ContextCompat.checkSelfPermission(context, perm) ==
PackageManager.PERMISSION_GRANTED);
if (!hasPerm) {
return false;
}
}
return true;
}
private static PermissionCallbacks callbacks;
/** * Request a set of permissions, showing rationale if the system requests it. * * @param object Activity or Fragment requesting permissions. Should implement * {@link ActivityCompat.OnRequestPermissionsResultCallback} * or * @param rationale a message explaining why the application needs this set of permissions, will * be displayed if the user rejects the request the first clinicTime. * @param requestCode request code to track this request, must be < 256. * @param perms a set of permissions to be requested. */ public static void requestPermissions(final Object object, PermissionCallbacks callback, String rationale,
final int requestCode, final String... perms) {
requestPermissions(object, callback, rationale,
android.R.string.ok,
android.R.string.cancel,
requestCode, perms);
}
static long timeWhenRequestingStart;
static Object object;
/** * Request a set of permissions, showing rationale if the system requests it. * * @param obj Activity or Fragment requesting permissions. Should implement * {@link ActivityCompat.OnRequestPermissionsResultCallback} * or * @param rationale a message explaining why the application needs this set of permissions, will * be displayed if the user rejects the request the first clinicTime. * @param positiveButton custom text for positive button * @param negativeButton custom text for negative button * @param requestCode request code to track this request, must be < 256. * @param permission a set of permissions or permission.group to be requested. */ public static void requestPermissions(final Object obj, final PermissionCallbacks callback, String rationale,
@StringRes int positiveButton,
@StringRes int negativeButton,
final int requestCode, final String... permission) {
callbacks = callback;
object = obj;
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
// only for lower of M// PermissionCallbacks callbacks = (PermissionCallbacks) object; callbacks.onPermissionsGranted(requestCode, new ArrayList<String>(Arrays.asList(permission)));
return;
}
checkCallingObjectSuitability(object);
// final PermissionCallbacks callbacks = (PermissionCallbacks) object; final String[] perms = getActualPermissions(object,
permission);
/* boolean hasPermission = true; for (String perm : perms) { if (!EasyPermissions.hasPermissions(getActivity(object), perm)) { hasPermission = false; break; } }*/
if (perms.length <= 0) {
callbacks.onPermissionsGranted(requestCode, new ArrayList<String>(Arrays.asList(permission)));
return;
}
boolean shouldShowRationale = false;
for (String perm : perms) {
shouldShowRationale = shouldShowRationale || shouldShowRequestPermissionRationale(object, perm);
}
if (shouldShowRationale) {
if (!TextUtils.isEmpty(rationale)) {
finalPermissionDialog = new PermissionDialog(getActivity(object), new View.OnClickListener() {
@Override public void onClick(View view) {
executePermissionsRequest(object, perms, requestCode);
finalPermissionDialog.dismiss();
}
}, new View.OnClickListener() {
@Override public void onClick(View view) {
callbacks.onPermissionsDenied(requestCode, Arrays.asList(perms));
finalPermissionDialog.dismiss();
}
}, rationale, "Ok");
finalPermissionDialog.show();
} else {
executePermissionsRequest(object, perms, requestCode);
}
} else {
for (String perm : perms) {
shouldShowRationale = shouldShowRationale || shouldShowRequestPermissionRationale(object, perm);
}
if (shouldShowRationale) {
Log.d(TAG, "requestPermissions: show dialog");
} else {
timeWhenRequestingStart = System.currentTimeMillis();
executePermissionsRequest(object, perms, requestCode);
}
}
}
private static String[] getActualPermissions(Object object, String[] permission) {
initPermissionGroups();
ArrayList<String> permissionList = new ArrayList<>();
for (String indiPerm : permission) {
if (permissionGroups.containsKey(indiPerm)) {
String[] arr = permissionGroups.get(indiPerm);
for (String s : arr) {
if (!EasyPermissions.hasPermissions(getActivity(object), s)) {
permissionList.add(s);
}
}
} else {
if (!EasyPermissions.hasPermissions(getActivity(object), indiPerm)) {
permissionList.add(indiPerm);
}
}
}
Set<String> set = new LinkedHashSet<String>(permissionList);
return set.toArray(new String[set.size()]);
}
private static void initPermissionGroups() {
if (permissionGroups == null) {
permissionGroups = new HashMap<String, String[]>();
permissionGroups.put(Manifest.permission_group.CALENDAR, new String[]{Manifest.permission.READ_CALENDAR, Manifest.permission.WRITE_CALENDAR});
permissionGroups.put(Manifest.permission_group.CAMERA, new String[]{Manifest.permission.CAMERA});
permissionGroups.put(Manifest.permission_group.CONTACTS, new String[]{Manifest.permission.READ_CONTACTS, Manifest.permission.WRITE_CONTACTS, Manifest.permission.GET_ACCOUNTS});
permissionGroups.put(Manifest.permission_group.LOCATION, new String[]{Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION});
permissionGroups.put(Manifest.permission_group.MICROPHONE, new String[]{Manifest.permission.RECORD_AUDIO});
permissionGroups.put(Manifest.permission_group.PHONE, new String[]{Manifest.permission.READ_PHONE_STATE, Manifest.permission.CALL_PHONE, Manifest.permission.READ_CALL_LOG, Manifest.permission.WRITE_CALL_LOG, Manifest.permission.ADD_VOICEMAIL, Manifest.permission.USE_SIP, Manifest.permission.PROCESS_OUTGOING_CALLS});
permissionGroups.put(Manifest.permission_group.SENSORS, new String[]{Manifest.permission.BODY_SENSORS});
permissionGroups.put(Manifest.permission_group.SMS, new String[]{Manifest.permission.SEND_SMS, Manifest.permission.RECEIVE_SMS, Manifest.permission.READ_SMS, Manifest.permission.RECEIVE_WAP_PUSH, Manifest.permission.RECEIVE_MMS});
permissionGroups.put(Manifest.permission_group.STORAGE, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE});
}
}
private static HashMap<String, String[]> permissionGroups;
/** * Handle the result of a permission request, should be called from the calling Activity's * {@link ActivityCompat.OnRequestPermissionsResultCallback#onRequestPermissionsResult(int, String[], int[])} * method. * <p/>
* If any permissions were granted or denied, the Activity will receive the appropriate * callbacks through {@link PermissionCallbacks} and methods annotated with * * @param requestCode requestCode argument to permission result callback. * @param permissions permissions argument to permission result callback. * @param grantResults grantResults argument to permission result callback. * @throws IllegalArgumentException if the calling Activity does not implement * {@link PermissionCallbacks}. */ public static void onRequestPermissionsResult(int requestCode, String[] permissions,
int[] grantResults) {
boolean isPermenantlyDisabled = false;
// checkCallingObjectSuitability(object);// PermissionCallbacks callbacks = (PermissionCallbacks) object;
// Make a collection of granted and denied permissions from the request. ArrayList<String> granted = new ArrayList<>();
ArrayList<String> denied = new ArrayList<>();
for (int i = 0; i < permissions.length; i++) {
String perm = permissions[i];
if (grantResults[i] == PackageManager.PERMISSION_GRANTED) {
granted.add(perm);
} else {
/**if deny then it will true and on never as me again it will return false * **/ boolean showRationale = shouldShowRequestPermissionRationale(object, perm);
isPermenantlyDisabled = !showRationale;
denied.add(perm);
// denied.add(perm); }
}
// Report granted permissions, if any. if (!granted.isEmpty() && denied.isEmpty()) {
// Notify callbacks callbacks.onPermissionsGranted(requestCode, granted);
}
// Report denied permissions, if any. /*if (!denied.isEmpty()) { callbacks.onPermissionsDenied(requestCode, denied); }*/
//if 100% fail then check for whether timing else if (granted.isEmpty() && !denied.isEmpty() && isPermenantlyDisabled) {
long diff = System.currentTimeMillis() - timeWhenRequestingStart;
// if (diff < 350) { //means it is permenantly disabled callbacks.onPermissionsPermanentlyDeclined(requestCode, denied);
// } Log.i("TAG", diff + "");
}
// Report denied permissions, if any. if (!denied.isEmpty() && !isPermenantlyDisabled) {
callbacks.onPermissionsDenied(requestCode, denied);
}
/*// If 100% successful, call annotated methods if (!granted.isEmpty() && denied.isEmpty()) { runAnnotatedMethods(object, requestCode); }*/ }
@TargetApi(23)
private static boolean shouldShowRequestPermissionRationale(Object object, String perm) {
if (object instanceof Activity) {
return ActivityCompat.shouldShowRequestPermissionRationale((Activity) object, perm);
} else if (object instanceof Fragment) {
return ((Fragment) object).shouldShowRequestPermissionRationale(perm);
} else if (object instanceof android.app.Fragment) {
return ((android.app.Fragment) object).shouldShowRequestPermissionRationale(perm);
} else {
return false;
}
}
@TargetApi(23)
private static void executePermissionsRequest(Object object, String[] perms, int requestCode) {
checkCallingObjectSuitability(object);
if (object instanceof Activity) {
ActivityCompat.requestPermissions((Activity) object, perms, requestCode);
} else if (object instanceof Fragment) {
((Fragment) object).requestPermissions(perms, requestCode);
} else if (object instanceof android.app.Fragment) {
((android.app.Fragment) object).requestPermissions(perms, requestCode);
}
}
@TargetApi(11)
private static Activity getActivity(Object object) {
if (object instanceof Activity) {
return ((Activity) object);
} else if (object instanceof Fragment) {
return ((Fragment) object).getActivity();
} else if (object instanceof android.app.Fragment) {
return ((android.app.Fragment) object).getActivity();
} else {
return null;
}
}
/*private static void runAnnotatedMethods(Object object, int requestCode) { Class clazz = object.getClass(); for (Method method : clazz.getDeclaredMethods()) { if (method.isAnnotationPresent(AfterPermissionGranted.class)) { // Check for annotated methods with matching request code. AfterPermissionGranted ann = method.getAnnotation(AfterPermissionGranted.class); if (ann.value() == requestCode) { // Method must be void so that we can invoke it if (method.getParameterTypes().length > 0) { throw new RuntimeException( "Cannot execute non-void method " + method.getName()); }
try { // Make method accessible if private if (!method.isAccessible()) { method.setAccessible(true); } method.invoke(object); } catch (IllegalAccessException e) { Log.e(TAG, "runDefaultMethod:IllegalAccessException", e); } catch (InvocationTargetException e) { Log.e(TAG, "runDefaultMethod:InvocationTargetException", e); } } } } }*/
private static void checkCallingObjectSuitability(Object object) {
// Make sure Object is an Activity or Fragment boolean isActivity = object instanceof Activity;
boolean isSupportFragment = object instanceof Fragment;
boolean isAppFragment = object instanceof android.app.Fragment;
boolean isMinSdkM = Build.VERSION.SDK_INT >= Build.VERSION_CODES.M;
if (!(isSupportFragment || isActivity || (isAppFragment && isMinSdkM))) {
if (isAppFragment) {
throw new IllegalArgumentException(
"Target SDK needs to be greater than 23 if caller is android.app.Fragment");
} else {
throw new IllegalArgumentException("Caller must be an Activity or a Fragment.");
}
}
/*// Make sure Object implements callbacks if (!(object instanceof PermissionCallbacks)) { throw new IllegalArgumentException("Caller must implement PermissionCallbacks."); }*/ }
}
Its common issue in android and most of newbee faced. To understand why its happening, you have to read about behavior of Getview method of listivew, its your home work, let continue with tutorial. Below tutorial will explain that how to maintain the position of button which is in row file using settag and gettag. main.xml ( its contain listview which will hold row data) <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:descendantFocusability="blocksDescendants"> <ListView android:id="@+id/listView" android:layout_width="fill_parent" android:layout_height="fill_parent"/> </LinearLayout> ...
Comments
Post a Comment