How do I check if the user has granted the required Bluetooth permissions in MvvmCross

Checking Bluetooth Permissions on Android

For Android, you need to check for different permissions based on the Android version:

1. Android 12 and Later (API Level 31+):**
- You need to check for `BLUETOOTH_SCAN`, `BLUETOOTH_CONNECT`, and `BLUETOOTH_ADVERTISE` permissions.
- Use the `ContextCompat.checkSelfPermission` method to verify if these permissions are granted.

2. Android 11 and Earlier (API Level 30 and Below):**
- You need to check for `ACCESS_FINE_LOCATION` permission.
- Use the `ContextCompat.checkSelfPermission` method to verify if this permission is granted.

Here's a basic example of how you might implement this in a MvvmCross Android project:

csharp
using MvvmCross.Platforms.Android;
using Android.Content;
using Android.Content.PM;

public class BluetoothService : IBluetoothService
{
    private readonly Context _context;

    public BluetoothService(Context context)
    {
        _context = context;
    }

    public async Task CheckBluetoothPermissions()
    {
        if (Build.VERSION.SdkInt >= BuildVersionCodes.S)
        {
            if (ContextCompat.CheckSelfPermission(_context, Manifest.Permission.BluetoothScan) == Permission.Granted &&
                ContextCompat.CheckSelfPermission(_context, Manifest.Permission.BluetoothConnect) == Permission.Granted)
            {
                return await Task.FromResult(PermissionStatus.Granted);
            }
            else
            {
                return await Task.FromResult(PermissionStatus.Denied);
            }
        }
        else
        {
            if (ContextCompat.CheckSelfPermission(_context, Manifest.Permission.AccessFineLocation) == Permission.Granted)
            {
                return await Task.FromResult(PermissionStatus.Granted);
            }
            else
            {
                return await Task.FromResult(PermissionStatus.Denied);
            }
        }
    }
}

Requesting Bluetooth Permissions on Android

If the permissions are not granted, you need to request them using `ActivityCompat.RequestPermissions`. Here's how you can modify the `CheckBluetoothPermissions` method to request permissions if they are not granted:

csharp
public async Task RequestBluetoothPermissions()
{
    ArrayList permissions = new ArrayList();

    if (Build.VERSION.SdkInt >= BuildVersionCodes.S)
    {
        permissions.Add(Manifest.Permission.BluetoothScan);
        permissions.Add(Manifest.Permission.BluetoothConnect);
    }
    else
    {
        permissions.Add(Manifest.Permission.AccessFineLocation);
    }

    string[] requestPermissions = (string[])permissions.ToArray(typeof(string));

    // Assuming MainActivity is your activity
    MainActivity.Instance.RequestPermissions(requestPermissions, MainActivity.RequestCode);

    return await CheckBluetoothPermissions();
}

Handling Permission Results

After requesting permissions, you need to handle the results in the `OnRequestPermissionsResult` method of your activity:

csharp
public override void OnRequestPermissionsResult(int requestCode, string[] permissions, Permission[] grantResults)
{
    base.OnRequestPermissionsResult(requestCode, permissions, grantResults);

    if (requestCode == MainActivity.RequestCode)
    {
        if (grantResults.All(g => g == Permission.Granted))
        {
            // Permissions granted, proceed with Bluetooth operations
        }
        else
        {
            // Handle denied permissions
        }
    }
}

Checking Bluetooth Permissions on iOS

For iOS, Bluetooth permissions are not explicitly requested like on Android. Instead, you need to add the `NSBluetoothAlwaysUsageDescription` key to your app's Info.plist file to explain why your app needs Bluetooth access.

xml
NSBluetoothAlwaysUsageDescription
This app needs access to Bluetooth to connect to devices.

However, MvvmCross does not directly handle Bluetooth permissions on iOS. You would typically use platform-specific code or libraries like CoreBluetooth to manage Bluetooth connections.

Using MvvmCross with Bluetooth Permissions

In a MvvmCross application, you would typically create a service interface (`IBluetoothService`) that encapsulates the permission checking logic. This interface would be implemented differently for each platform (Android and iOS).

csharp
public interface IBluetoothService
{
    Task CheckBluetoothPermissions();
    Task RequestBluetoothPermissions();
}

Then, in your view model, you can use dependency injection to get an instance of `IBluetoothService` and call its methods to check or request Bluetooth permissions.

csharp
public class MyViewModel : MvxViewModel
{
    private readonly IBluetoothService _bluetoothService;

    public MyViewModel(IBluetoothService bluetoothService)
    {
        _bluetoothService = bluetoothService;
    }

    public async Task CheckPermissions()
    {
        var status = await _bluetoothService.CheckBluetoothPermissions();
        if (status == PermissionStatus.Denied)
        {
            await _bluetoothService.RequestBluetoothPermissions();
        }
    }
}

This approach allows you to handle Bluetooth permissions in a platform-agnostic way within your MvvmCross application.