Java Code Examples for android.content.pm.PackageManager#checkPermission()

/**
 * SD卡存储权限检查
 */
private boolean checkPermission(Context context) {
    if (context == null) {
        Log.e(TAG, "checkMPermission context null");
        return false;
    }

    // 写权限有了默认就赋予了读权限
    PackageManager pm = context.getPackageManager();
    if (PackageManager.PERMISSION_GRANTED !=
            pm.checkPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE, context.getApplicationInfo().packageName)) {
        Log.e(TAG, "without permission to access storage");
        return false;
    }

    return true;
}
 

public GPSLocationProvider(Context context)
{
	locManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
	
	started = false;
	passiveMode = false;
	
	gpsStatusListener = new MyGPSListener();
	
	PackageManager mgr = context.getPackageManager();
	if (mgr.checkPermission(android.Manifest.permission.ACCESS_FINE_LOCATION, context.getPackageName()) == PackageManager.PERMISSION_GRANTED) {
		permGranted = true;
	} else {
		permGranted = false;
	}
}
 

/**
 * Retrieve outgoing call handlers available as plugin for csipsimple Also
 * contains stock call handler if available
 * 
 * @param ctxt context of application
 * @return A map of package name => Fancy name of call handler
 */
public static Map<String, String> getAvailableCallHandlers(Context ctxt) {

    if (AVAILABLE_HANDLERS == null) {
        AVAILABLE_HANDLERS = new HashMap<String, String>();

        PackageManager packageManager = ctxt.getPackageManager();
        Intent it = new Intent(SipManager.ACTION_GET_PHONE_HANDLERS);

        List<ResolveInfo> availables = packageManager.queryBroadcastReceivers(it, 0);
        for (ResolveInfo resInfo : availables) {
            ActivityInfo actInfos = resInfo.activityInfo;
            Log.d(THIS_FILE, "Found call handler " + actInfos.packageName + " " + actInfos.name);
            if (packageManager.checkPermission(permission.PROCESS_OUTGOING_CALLS,
                    actInfos.packageName) == PackageManager.PERMISSION_GRANTED) {
                String packagedActivityName = (new ComponentName(actInfos.packageName,
                        actInfos.name)).flattenToString();
                AVAILABLE_HANDLERS.put(packagedActivityName,
                        (String) resInfo.loadLabel(packageManager));
            }
        }
    }

    return AVAILABLE_HANDLERS;
}
 

public static boolean checkPermission(String permission) {
    if (TextUtils.isEmpty(permission)) return false;

    Context context = Manager.getContext();
    if (null == context) return false;

    String packageName = context.getPackageName();
    if (TextUtils.isEmpty(packageName)) return false;

    PackageManager pm = context.getPackageManager();
    if (null == pm) return false;

    int permissionState = PackageManager.PERMISSION_DENIED;

    try {
        permissionState = pm.checkPermission(permission, packageName);
    } catch (Exception e) {
        LogX.e(TAG, SUB_TAG, e.toString());
    }

    return PackageManager.PERMISSION_GRANTED == permissionState ? true : false;
}
 

@Override
protected void onResume() {
    super.onResume();
    PackageManager pm = getPackageManager();
    boolean hasPermission = (PackageManager.PERMISSION_GRANTED ==
            pm.checkPermission("android.permission.WRITE_EXTERNAL_STORAGE", getPackageName()))
            && (PackageManager.PERMISSION_GRANTED ==
            pm.checkPermission("android.permission.READ_EXTERNAL_STORAGE", getPackageName()));
    if (!hasPermission) {
        String error = "PatchTool需要存储读写权限";
        showDialog(error);
        mTvContent.setText(error);
        mBtnScan.setEnabled(false);
        mBtnClear.setEnabled(false);
        return;
    }
    mBtnScan.setEnabled(true);
    mBtnClear.setEnabled(true);
    updateContent();
}
 

/**
 * パーミッションを確認
 * @param context
 * @param permissionName
 * @return
 */
@SuppressLint("NewApi")
public static int checkSelfPermission(@Nullable final Context context, final String permissionName) {
	if (context == null) return PackageManager.PERMISSION_DENIED;
	int result = PackageManager.PERMISSION_DENIED;
	try {
		if (BuildCheck.isMarshmallow()) {
			result = ContextCompat.checkSelfPermission(context, permissionName);
		} else {
			final PackageManager pm = context.getPackageManager();
			result = pm.checkPermission(permissionName, context.getPackageName());
		}
	} catch (final Exception e) {
		Log.w("", e);
	}
	return result;
}
 

public static Map<String, DynActivityPlugin> getDynActivityPlugins(Context ctxt, String action){
    if(!CACHED_ACTIVITY_RESOLUTION.containsKey(action)) {
        HashMap<String, DynActivityPlugin> plugins = new HashMap<String, DynActivityPlugin>();
        
        PackageManager packageManager = ctxt.getPackageManager();
        Intent it = new Intent(action);
        
        List<ResolveInfo> availables = packageManager.queryIntentActivities(it, 0);
        for(ResolveInfo resInfo : availables) {
            ActivityInfo actInfos = resInfo.activityInfo;
            if( packageManager.checkPermission(SipManager.PERMISSION_USE_SIP, actInfos.packageName) == PackageManager.PERMISSION_GRANTED) {
                ComponentName cmp = new ComponentName(actInfos.packageName, actInfos.name);
                DynActivityPlugin dynInfos;
                dynInfos = new DynActivityPlugin(actInfos.loadLabel(packageManager).toString(), action,
                        cmp, actInfos.metaData);
                plugins.put(cmp.flattenToString(), dynInfos);
            }
        }
        CACHED_ACTIVITY_RESOLUTION.put(action, plugins);
    }
    
    return CACHED_ACTIVITY_RESOLUTION.get(action);
}
 

/**
 * 检查包名所在的程序是否有某项权限
 *
 * @param permName 权限名称
 * @param pkgName  程序所在的包名
 * @return
 */
public static boolean checkPermission(String permName, String pkgName) {
    PackageManager pm = AppUtils.getAppContext().getPackageManager();
    try {
        boolean isHave = (PackageManager.PERMISSION_GRANTED == pm.checkPermission(permName, pkgName));
        return isHave;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return false;
}
 

/**
 * 获取当前网络状态 返回2代表wifi,1代表2G/3G
 *
 * @param paramContext
 * @return
 */
public static String[] getNetType(Context paramContext) {
    String[] arrayOfString = {"Unknown", "Unknown"};
    PackageManager localPackageManager = paramContext.getPackageManager();
    if (localPackageManager.checkPermission("android.permission.ACCESS_NETWORK_STATE", paramContext.getPackageName()) != 0) {
        arrayOfString[0] = "Unknown";
        return arrayOfString;
    }

    ConnectivityManager localConnectivityManager = (ConnectivityManager) paramContext.getSystemService("connectivity");
    if (localConnectivityManager == null) {
        arrayOfString[0] = "Unknown";
        return arrayOfString;
    }

    NetworkInfo localNetworkInfo1 = localConnectivityManager.getNetworkInfo(1);
    if (localNetworkInfo1 != null && localNetworkInfo1.getState() == NetworkInfo.State.CONNECTED) {
        arrayOfString[0] = "2";
        return arrayOfString;
    }

    NetworkInfo localNetworkInfo2 = localConnectivityManager.getNetworkInfo(0);
    if (localNetworkInfo2 != null && localNetworkInfo2.getState() == NetworkInfo.State.CONNECTED) {
        arrayOfString[0] = "1";
        arrayOfString[1] = localNetworkInfo2.getSubtypeName();
        return arrayOfString;
    }

    return arrayOfString;
}
 

private boolean hasPermissions() {
    PackageManager pm = getPackageManager();
    String packageName = getPackageName();
    int granted = (pm.checkPermission(RECORD_AUDIO, packageName) | pm.checkPermission(WRITE_EXTERNAL_STORAGE,
            packageName));
    return granted == PackageManager.PERMISSION_GRANTED;
}
 

@SuppressLint("NewApi")
public static boolean checkPermission(Context context, String permission) {
    boolean result = false;
    if (Build.VERSION.SDK_INT >= 23) {
        if (context.checkCallingOrSelfPermission(permission) == PackageManager.PERMISSION_GRANTED) {
            result = true;
        }
    } else {
        PackageManager pm = context.getPackageManager();
        if (pm.checkPermission(permission, context.getPackageName()) == PackageManager.PERMISSION_GRANTED) {
            result = true;
        }
    }
    return result;
}
 

public ArrayList<AppModel> getAutoRunAppList() {
    PackageManager localPackageManager = mContext.getPackageManager();
    Intent localIntent = new Intent("android.intent.action.MAIN");
    localIntent.addCategory("android.intent.category.LAUNCHER");
    List<ResolveInfo> localList = localPackageManager.queryIntentActivities(localIntent, 0);
    ArrayList<AppModel> localArrayList = null;
    Iterator<ResolveInfo> localIterator = null;
    if (localList != null) {
        localArrayList = new ArrayList<>();
        localIterator = localList.iterator();
    }

    while (true) {
        if (!localIterator.hasNext())
            break;
        ResolveInfo localResolveInfo = localIterator.next();
        AppModel localAppBean = new AppModel();
        localAppBean.setIcon(localResolveInfo.activityInfo.loadIcon(localPackageManager));
        localAppBean.setName(localResolveInfo.activityInfo.loadLabel(localPackageManager).toString());
        localAppBean.setPackageName(localResolveInfo.activityInfo.packageName);
        localAppBean.setDataDir(localResolveInfo.activityInfo.applicationInfo.publicSourceDir);
        String pkgName = localResolveInfo.activityInfo.packageName;
        String permission = "android.permission.RECEIVE_BOOT_COMPLETED";
        try {
            PackageInfo mPackageInfo = mContext.getPackageManager().getPackageInfo(pkgName, 0);
            if ((PackageManager.PERMISSION_GRANTED == localPackageManager.checkPermission(permission, pkgName))
                    && !((mPackageInfo.applicationInfo.flags & mPackageInfo.applicationInfo.FLAG_SYSTEM) > 0)) {
                localArrayList.add(localAppBean);
            }
        } catch (NameNotFoundException e) {
            e.printStackTrace();
        }
    }
    return localArrayList;
}
 

/**
 * To check for internet permission
 *
 * @param context - Application context for current run
 */
public static void hasInternetPermission(Context context) {
  validateNotNull(context, "context");
  PackageManager pm = context.getPackageManager();
  int hasPermission = pm.checkPermission(Manifest.permission.INTERNET, context.getPackageName());//context.checkCallingOrSelfPermission(Manifest.permission.INTERNET);
  if (hasPermission ==
      PackageManager.PERMISSION_DENIED) {
    throw new IllegalStateException("Paystack requires internet permission. " +
        "Please add the intenet permission to your AndroidManifest.xml");
  }
}
 

private boolean internetPermissionGranted() {
    PackageManager pm = getContext().getPackageManager();
    String packageName = getContext().getPackageName();
    return pm.checkPermission(Manifest.permission.INTERNET, packageName) == PackageManager.PERMISSION_GRANTED;
}
 

private boolean internetPermissionGranted() {
    PackageManager pm = getContext().getPackageManager();
    String packageName = getContext().getPackageName();
    return pm.checkPermission(Manifest.permission.INTERNET, packageName) == PackageManager.PERMISSION_GRANTED;
}
 

public static boolean haveReadLogsPermission(Context context) {
    PackageManager pm = context.getPackageManager();
    return pm.checkPermission(android.Manifest.permission.READ_LOGS, context.getPackageName()) == 0;
}
 

/**
 * 是否有权限
 *
 * @param context
 * @param permission
 * @return
 */
public static boolean hasPermission(Context context, String permission) {
    if (context != null && !TextUtils.isEmpty(permission)) {
        try {
            PackageManager packageManager = context.getPackageManager();
            if (packageManager != null) {
                if (PackageManager.PERMISSION_GRANTED == packageManager.checkPermission(permission, context
                        .getPackageName())) {
                    return true;
                }
                Log.d("AppUtils", "Have you  declared permission " + permission + " in AndroidManifest.xml ?");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    return false;
}
 

public static boolean hasInternet(String packageName, Context context) {
    PackageManager pm = context.getPackageManager();
    return (pm.checkPermission("android.permission.INTERNET", packageName) == PackageManager.PERMISSION_GRANTED);
}
 

/**
 * 是否有某个权限（某权限是否开启）
 * <p><b>注: </b>结果不一定准确，对于第三方厂商会更改<p/>
 * @param context
 * @param permissionString 权限字符串，例如android.permission.RECORD_AUDIO
 * @return
 */
public static boolean isHavePermission(Context context, String permissionString){
    PackageManager pm = context.getPackageManager();
    boolean isHave = (PackageManager.PERMISSION_GRANTED ==
            pm.checkPermission(permissionString, context.getPackageName()));
    return isHave;
}
 

/**
 * Method to verify that vibrate permission has been granted.
 *
 * Allows users of the library to disabled vibrate support if desired.
 * @return true if Vibrate permission has been granted
 */
private boolean hasVibratePermission(Context context) {
    PackageManager pm = context.getPackageManager();
    int hasPerm = pm.checkPermission(android.Manifest.permission.VIBRATE, context.getPackageName());
    return hasPerm == PackageManager.PERMISSION_GRANTED;
}