public class WifiP2pServiceImpl extends IWifiP2pManager.Stub {
    ...
    @Override
    public void checkConfigureWifiDisplayPermission() {
        if (!getWfdPermission(Binder.getCallingUid())) {
            throw new SecurityException("Wifi Display Permission denied for uid = "
                    + Binder.getCallingUid());
        }
    }

    private boolean getWfdPermission(int uid) {
        if (mWifiInjector == null) {
            mWifiInjector = WifiInjector.getInstance();
        }
        WifiPermissionsWrapper wifiPermissionsWrapper = mWifiInjector.getWifiPermissionsWrapper();
        return wifiPermissionsWrapper.getUidPermission(
                android.Manifest.permission.CONFIGURE_WIFI_DISPLAY, uid)
                != PackageManager.PERMISSION_DENIED;
    }
    ...
}

/**
 * Request the current list of peers.
 *
 * @param c is the channel created at {@link #initialize}
 * @param listener for callback when peer list is available. Can be null.
 */
public void requestPeers(Channel c, PeerListListener listener) {
    checkChannel(c);
    Bundle callingPackage = new Bundle();
    callingPackage.putString(CALLING_PACKAGE, c.mContext.getOpPackageName());
    c.mAsyncChannel.sendMessage(REQUEST_PEERS, 0, c.putListener(listener),
            callingPackage);
}

...
case WifiP2pManager.REQUEST_PEERS:
    replyToMessage(message, WifiP2pManager.RESPONSE_PEERS,
            getPeers((Bundle) message.obj, message.sendingUid));
    break;
...

/**
 * Enforces permissions on the caller who is requesting for P2p Peers
 * @param pkg Bundle containing the calling package string
 * @param uid of the caller
 * @return WifiP2pDeviceList the peer list
 */
private WifiP2pDeviceList getPeers(Bundle pkg, int uid) {
    String pkgName = pkg.getString(WifiP2pManager.CALLING_PACKAGE);
    boolean scanPermission = false;
    WifiPermissionsUtil wifiPermissionsUtil;
    // getPeers() is guaranteed to be invoked after Wifi Service is up
    // This ensures getInstance() will return a non-null object now
    if (mWifiInjector == null) {
        mWifiInjector = WifiInjector.getInstance();
    }
    wifiPermissionsUtil = mWifiInjector.getWifiPermissionsUtil();
    // Minimum Version to enforce location permission is O or later
    try {
        scanPermission = wifiPermissionsUtil.canAccessScanResults(pkgName, uid,
                Build.VERSION_CODES.O);
    } catch (SecurityException e) {
        Log.e(TAG, "Security Exception, cannot access peer list");
    }
    if (scanPermission) {
        return new WifiP2pDeviceList(mPeers);
    } else {
        return new WifiP2pDeviceList();
    }
}

/**
 * API to determine if the caller has permissions to get
 * scan results.
 * @param pkgName package name of the application requesting access
 * @param uid The uid of the package
 * @param minVersion Minimum app API Version number to enforce location permission
 * @return boolean true or false if permissions is granted
 */
public boolean canAccessScanResults(String pkgName, int uid,
            int minVersion) throws SecurityException {
    mAppOps.checkPackage(uid, pkgName);
    // Check if the calling Uid has CAN_READ_PEER_MAC_ADDRESS
    // permission or is an Active Nw scorer.
    boolean canCallingUidAccessLocation = checkCallerHasPeersMacAddressPermission(uid)
            || isCallerActiveNwScorer(uid);
    // LocationAccess by App: For AppVersion older than minVersion,
    // it is sufficient to check if the App is foreground.
    // Otherwise, Location Mode must be enabled and caller must have
    // Coarse Location permission to have access to location information.
    boolean canAppPackageUseLocation = isLegacyForeground(pkgName, minVersion)
            || (isLocationModeEnabled(pkgName)
                    && checkCallersLocationPermission(pkgName, uid));
    // If neither caller or app has location access, there is no need to check
    // any other permissions. Deny access to scan results.
    if (!canCallingUidAccessLocation && !canAppPackageUseLocation) {
        mLog.tC("Denied: no location permission");
        return false;
    }
    // Check if Wifi Scan request is an operation allowed for this App.
    if (!isScanAllowedbyApps(pkgName, uid)) {
        mLog.tC("Denied: app wifi scan not allowed");
        return false;
    }
    // If the User or profile is current, permission is granted
    // Otherwise, uid must have INTERACT_ACROSS_USERS_FULL permission.
    if (!canAccessUserProfile(uid)) {
        mLog.tC("Denied: Profile not permitted");
        return false;
    }
    return true;
}

/**
 * Returns true if the caller holds PEERS_MAC_ADDRESS permission.
 */
private boolean checkCallerHasPeersMacAddressPermission(int uid) {
    return mWifiPermissionsWrapper.getUidPermission(
            android.Manifest.permission.PEERS_MAC_ADDRESS, uid)
            == PackageManager.PERMISSION_GRANTED;
}

/**
 * Returns true if the caller is an Active Network Scorer.
 */
private boolean isCallerActiveNwScorer(int uid) {
    return mNetworkScoreManager.isCallerActiveScorer(uid);
}

private boolean isLegacyForeground(String pkgName, int version) {
    return isLegacyVersion(pkgName, version) && isForegroundApp(pkgName);
}
/**
 * Returns true if the App version is older than minVersion.
 */
private boolean isLegacyVersion(String pkgName, int minVersion) {
    try {
        if (mContext.getPackageManager().getApplicationInfo(pkgName, 0)
                .targetSdkVersion < minVersion) {
            return true;
        }
    } catch (PackageManager.NameNotFoundException e) {
        // In case of exception, assume known app (more strict checking)
        // Note: This case will never happen since checkPackage is
        // called to verify valididity before checking App's version.
    }
    return false;
}

/**
 * Network Location Provider disabled, but GPS and other sensors enabled.
 */
public static final int LOCATION_MODE_SENSORS_ONLY = 1;
/**
 * Reduced power usage, such as limiting the number of GPS updates per hour. Requests
 * with {@link android.location.Criteria#POWER_HIGH} may be downgraded to
 * {@link android.location.Criteria#POWER_MEDIUM}.
 */
public static final int LOCATION_MODE_BATTERY_SAVING = 2;
/**
 * Best-effort location computation allowed.
 */
public static final int LOCATION_MODE_HIGH_ACCURACY = 3;

private boolean isLocationModeEnabled(String pkgName) {
    // Location mode check on applications that are later than version.
    return (mSettingsStore.getLocationModeSetting(mContext)
             != Settings.Secure.LOCATION_MODE_OFF);
}
/**
 * Get Location Mode settings for the context
 * @param context
 * @return Location Mode setting
 */
public int getLocationModeSetting(Context context) {
    return Settings.Secure.getInt(context.getContentResolver(),
          Settings.Secure.LOCATION_MODE, Settings.Secure.LOCATION_MODE_OFF);
}

/**
 * Checks that calling process has android.Manifest.permission.ACCESS_COARSE_LOCATION
 * and a corresponding app op is allowed for this package and uid.
 *
 * @param pkgName PackageName of the application requesting access
 * @param uid The uid of the package
 */
public boolean checkCallersLocationPermission(String pkgName, int uid) {
    // Coarse Permission implies Fine permission
    if ((mWifiPermissionsWrapper.getUidPermission(
            Manifest.permission.ACCESS_COARSE_LOCATION, uid)
            == PackageManager.PERMISSION_GRANTED)
            && checkAppOpAllowed(AppOpsManager.OP_COARSE_LOCATION, pkgName, uid)) {
        return true;
    }
    return false;
}

private boolean checkPermissions() {
    // For wifi p2p requestPeers permission
    int checkResult = ContextCompat.checkSelfPermission(getApplicationContext(),
            Manifest.permission.ACCESS_FINE_LOCATION);
    if (checkResult != PackageManager.PERMISSION_GRANTED) {
        ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, REQUEST_CODE);
        return false;
    }
    return true;
}

@Override
public void onRequestPermissionsResult(int requestCode, @NotNull String[] permissions, @NotNull int[] grantResults) {
    if (requestCode != REQUEST_CODE) {
        return;
    }
    if (grantResults[0] != PackageManager.PERMISSION_GRANTED) {
        String msg = "Permission not granted: " + permissions[0];
        Toast.makeText(this, msg, Toast.LENGTH_LONG).show();
    }
    ...
}