internal DevicePairingResult(int error)
{
switch (error)
{
case 0:
_status = DevicePairingResultStatus.Paired;
break;
case 258: /* WAIT_TIMEOUT */
_status = DevicePairingResultStatus.AuthenticationTimeout;
break;
case 259: /*ERROR_NO_MORE_ITEMS*/
_status = DevicePairingResultStatus.AlreadyPaired;
break;
case 1223: /*ERROR_CANCELLED*/
_status = DevicePairingResultStatus.PairingCanceled;
break;
case 1244: /*ERROR_NOT_AUTHENTICATED*/
_status = DevicePairingResultStatus.AuthenticationFailure;
break;
default:
_status = DevicePairingResultStatus.Failed;
break;
}
}
static bool PlatformPairRequest(BluetoothAddress device, string pin)
{
BluetoothDevice bluetoothDevice = null;
var t = Task <bool> .Run(async() =>
{
bluetoothDevice = await BluetoothDevice.FromBluetoothAddressAsync(device.ToUInt64());
DevicePairingResultStatus status = DevicePairingResultStatus.NotPaired;
if (string.IsNullOrEmpty(pin))
{
var result = await bluetoothDevice.DeviceInformation.Pairing.PairAsync();
status = result.Status;
}
else
{
pinMappings.Add(bluetoothDevice.DeviceId, pin);
bluetoothDevice.DeviceInformation.Pairing.Custom.PairingRequested += Custom_PairingRequested;
var result = await bluetoothDevice.DeviceInformation.Pairing.Custom.PairAsync(DevicePairingKinds.ProvidePin);
status = result.Status;
}
return(status == DevicePairingResultStatus.Paired);
});
t.Wait();
return(t.Result);
}
public static bool IsSuccessful(this DevicePairingResultStatus result)
{
switch (result)
{
case DevicePairingResultStatus.Paired:
case DevicePairingResultStatus.AlreadyPaired:
return(true);
default:
return(false);
}
}
private void buttonPair_Click(object sender, EventArgs e)
{
if (listViewDevices.SelectedItems.Count == 0)
{
return;
}
DnaBluetoothLEDevice device = (DnaBluetoothLEDevice)listViewDevices.SelectedItems[0].Tag;
DevicePairingResultStatus result = DevicePairingResultStatus.Failed;
Task.Run(async() =>
{
try
{
// Try and connect
log("Pairing with " + device);
result = await watcher.PairToDeviceAsync(device.DeviceId);
if (result == DevicePairingResultStatus.Paired)
{
log("Pairing successful with " + device);
findDeviceTypeAsync(device);
}
else
{
log("Pairing failed: " + result, Color.Red);
}
}
catch (Exception ex)
{
// Log it out
log("Failed to pair with " + device);
Console.WriteLine("Failed to pair to Contour device.");
Console.WriteLine(ex);
}
});
}
public static BT_PairingStatus ConvertStatus(this DevicePairingResultStatus result)
{
switch (result)
{
case DevicePairingResultStatus.Paired:
return(BT_PairingStatus.Paired);
case DevicePairingResultStatus.NotReadyToPair:
return(BT_PairingStatus.NotReadyToPair);
case DevicePairingResultStatus.NotPaired:
return(BT_PairingStatus.NotPaired);
case DevicePairingResultStatus.AlreadyPaired:
return(BT_PairingStatus.AlreadyPaired);
case DevicePairingResultStatus.ConnectionRejected:
return(BT_PairingStatus.Rejected);
case DevicePairingResultStatus.TooManyConnections:
return(BT_PairingStatus.TooManyConnections);
case DevicePairingResultStatus.HardwareFailure:
return(BT_PairingStatus.HardwareFailure);
case DevicePairingResultStatus.AuthenticationTimeout:
return(BT_PairingStatus.AuthenticationTimeout);
case DevicePairingResultStatus.AuthenticationNotAllowed:
return(BT_PairingStatus.AuthenticationNotAllowed);
case DevicePairingResultStatus.AuthenticationFailure:
return(BT_PairingStatus.AuthenticationFailure);
case DevicePairingResultStatus.NoSupportedProfiles:
return(BT_PairingStatus.NoSupportedProfiles);
case DevicePairingResultStatus.ProtectionLevelCouldNotBeMet:
return(BT_PairingStatus.ProtectionLevelCouldNotBeMet);
case DevicePairingResultStatus.AccessDenied:
return(BT_PairingStatus.AccessDenied);
case DevicePairingResultStatus.InvalidCeremonyData:
return(BT_PairingStatus.InvalidCeremonyData);
case DevicePairingResultStatus.PairingCanceled:
return(BT_PairingStatus.PairingCanceled);
case DevicePairingResultStatus.OperationAlreadyInProgress:
return(BT_PairingStatus.OperationAlreadyInProgress);
case DevicePairingResultStatus.RequiredHandlerNotRegistered:
return(BT_PairingStatus.RequiredHandlerNotRegistered);
case DevicePairingResultStatus.RejectedByHandler:
return(BT_PairingStatus.RejectedByHandler);
case DevicePairingResultStatus.RemoteDeviceHasAssociation:
return(BT_PairingStatus.RemoteDeviceHasAssociation);
case DevicePairingResultStatus.Failed:
return(BT_PairingStatus.Failed);
default:
LogUtils.Net.Log.Error(9999, () => string.Format("Unknown Pair failure:{0}", result));
return(BT_PairingStatus.Failed);
}
}
private ERROR_CODE ConvertErrorCodePairing(DevicePairingResultStatus status)
{
var error_status = ERROR_CODE.UNKNOWN_ERROR;
switch (status)
{
case DevicePairingResultStatus.Paired:
error_status = ERROR_CODE.PAIRING_SUCCESS;
break;
case DevicePairingResultStatus.NotReadyToPair:
error_status = ERROR_CODE.PAIRING_NOT_READY_TO_PAIR;
break;
case DevicePairingResultStatus.NotPaired:
error_status = ERROR_CODE.PAIRING_NOT_PAIRED;
break;
case DevicePairingResultStatus.AlreadyPaired:
error_status = ERROR_CODE.PAIRING_ALREADY_PAIRED;
break;
case DevicePairingResultStatus.ConnectionRejected:
error_status = ERROR_CODE.PAIRING_CONNECTION_REJECTED;
break;
case DevicePairingResultStatus.TooManyConnections:
error_status = ERROR_CODE.PAIRING_TOO_MANY_CONNECTIONS;
break;
case DevicePairingResultStatus.HardwareFailure:
error_status = ERROR_CODE.PAIRING_HARDWARE_FAILURE;
break;
case DevicePairingResultStatus.AuthenticationTimeout:
error_status = ERROR_CODE.PAIRING_AUTHENTICATION_TIMEOUT;
break;
case DevicePairingResultStatus.AuthenticationNotAllowed:
error_status = ERROR_CODE.PAIRING_AUTHENTICATIION_NOT_ALLOWED;
break;
case DevicePairingResultStatus.AuthenticationFailure:
error_status = ERROR_CODE.PAIRING_AUTHENTICATION_FAILURE;
break;
case DevicePairingResultStatus.NoSupportedProfiles:
error_status = ERROR_CODE.PAIRING_NOT_SUPPORTED_PROFILES;
break;
case DevicePairingResultStatus.ProtectionLevelCouldNotBeMet:
error_status = ERROR_CODE.PAIRING_PROTEDTION_LEVEL_COULDNOT_BE_MET;
break;
case DevicePairingResultStatus.AccessDenied:
error_status = ERROR_CODE.PAIRING_ACCESS_DENIED;
break;
case DevicePairingResultStatus.InvalidCeremonyData:
error_status = ERROR_CODE.PAIRING_INVALID_CEREMONYDATA;
break;
case DevicePairingResultStatus.PairingCanceled:
error_status = ERROR_CODE.PAIRING_PAIRING_CANCELED;
break;
case DevicePairingResultStatus.OperationAlreadyInProgress:
error_status = ERROR_CODE.PAIRING_OPERATION_ALREADY_INPROGRESS;
break;
case DevicePairingResultStatus.RequiredHandlerNotRegistered:
error_status = ERROR_CODE.PAIRING_REQUIRED_HANDLER_NOT_REGISTERED;
break;
case DevicePairingResultStatus.RejectedByHandler:
error_status = ERROR_CODE.PAIRING_REJECTED_BY_HANDLER;
break;
case DevicePairingResultStatus.RemoteDeviceHasAssociation:
error_status = ERROR_CODE.PAIRING_REMOTE_DEVICE_HAS_ASSOCIATION;
break;
case DevicePairingResultStatus.Failed:
error_status = ERROR_CODE.PAIRING_FAILED;
break;
}
return(error_status);
}
internal DevicePairingResult(bool success)
{
_status = success ? DevicePairingResultStatus.Paired : DevicePairingResultStatus.Failed;
}
