void BluetoothProfileController::AddProfile(BluetoothProfileManagerBase* aProfile, bool aCheckConnected) { if (!aProfile) { DispatchBluetoothReply(mRunnable, BluetoothValue(), NS_LITERAL_STRING(ERR_NO_AVAILABLE_RESOURCE)); mCallback(); return; } if (aCheckConnected && !aProfile->IsConnected()) { BT_WARNING("The profile is not connected."); return; } mProfiles.AppendElement(aProfile); }
void DispatchBluetoothReply(BluetoothReplyRunnable* aRunnable, const BluetoothValue& aValue, const enum BluetoothStatus aStatusCode) { // Reply will be deleted by the runnable after running on main thread BluetoothReply* reply; if (aStatusCode != STATUS_SUCCESS) { reply = new BluetoothReply(BluetoothReplyError(aStatusCode, EmptyString())); } else { MOZ_ASSERT(aValue.type() != BluetoothValue::T__None); reply = new BluetoothReply(BluetoothReplySuccess(aValue)); } aRunnable->SetReply(reply); if (NS_FAILED(NS_DispatchToMainThread(aRunnable))) { BT_WARNING("Failed to dispatch to main thread!"); } }
int AppendAppParameter(uint8_t* aRetBuf, int aBufferSize, const uint8_t aTagId, const uint8_t* aValue, int aLength) { // An application parameter is a [tag]-[length]-[value] triplet. The [tag] and // [length] fields are 1-byte length each. if (aBufferSize < aLength + 2) { // aBufferSize should be larger than size of AppParameter + header. BT_WARNING("Return buffer size is too small for the AppParameter"); return 0; } aRetBuf[0] = aTagId; aRetBuf[1] = aLength; memcpy(&aRetBuf[2], aValue, aLength); return aLength + 2; }
void DispatchBluetoothReply(BluetoothReplyRunnable* aRunnable, const BluetoothValue& aValue, const nsAString& aErrorStr) { // Reply will be deleted by the runnable after running on main thread BluetoothReply* reply; if (!aErrorStr.IsEmpty()) { nsString err(aErrorStr); reply = new BluetoothReply(BluetoothReplyError(err)); } else { MOZ_ASSERT(aValue.type() != BluetoothValue::T__None); reply = new BluetoothReply(BluetoothReplySuccess(aValue)); } aRunnable->SetReply(reply); if (NS_FAILED(NS_DispatchToMainThread(aRunnable))) { BT_WARNING("Failed to dispatch to main thread!"); } }
static nsresult DispatchBluetoothHALResult(BluetoothResultHandler* aRes, void (BluetoothResultHandler::*aMethod)(), BluetoothStatus aStatus) { MOZ_ASSERT(aRes); nsRefPtr<nsRunnable> runnable; if (aStatus == STATUS_SUCCESS) { runnable = new BluetoothHALResultRunnable(aRes, aMethod); } else { runnable = new BluetoothHALErrorRunnable( aRes, &BluetoothResultHandler::OnError, aStatus); } nsresult rv = NS_DispatchToMainThread(runnable); if (NS_FAILED(rv)) { BT_WARNING("NS_DispatchToMainThread failed: %X", rv); } return rv; }
void BluetoothPairingListener::Notify(const BluetoothSignal& aData) { InfallibleTArray<BluetoothNamedValue> arr; BluetoothValue value = aData.value(); if (aData.name().EqualsLiteral("PairingRequest")) { MOZ_ASSERT(value.type() == BluetoothValue::TArrayOfBluetoothNamedValue); const InfallibleTArray<BluetoothNamedValue>& arr = value.get_ArrayOfBluetoothNamedValue(); MOZ_ASSERT(arr.Length() == 4 && arr[0].value().type() == BluetoothValue::TnsString && // address arr[1].value().type() == BluetoothValue::TnsString && // name arr[2].value().type() == BluetoothValue::TnsString && // passkey arr[3].value().type() == BluetoothValue::TnsString); // type nsString deviceAddress = arr[0].value().get_nsString(); nsString deviceName = arr[1].value().get_nsString(); nsString passkey = arr[2].value().get_nsString(); nsString type = arr[3].value().get_nsString(); // Create a temporary device with deviceAddress and deviceName InfallibleTArray<BluetoothNamedValue> props; BT_APPEND_NAMED_VALUE(props, "Address", deviceAddress); BT_APPEND_NAMED_VALUE(props, "Name", deviceName); nsRefPtr<BluetoothDevice> device = BluetoothDevice::Create(GetOwner(), props); // Notify pairing listener of pairing requests DispatchPairingEvent(device, passkey, type); } else { BT_WARNING("Not handling pairing listener signal: %s", NS_ConvertUTF16toUTF8(aData.name()).get()); } }
static nsresult DispatchBluetoothSocketHALResult( BluetoothSocketResultHandler* aRes, void (BluetoothSocketResultHandler::*aMethod)(int, const nsAString&, int), int aArg1, const nsAString& aArg2, int aArg3, BluetoothStatus aStatus) { MOZ_ASSERT(aRes); nsRunnable* runnable; if (aStatus == STATUS_SUCCESS) { runnable = new BluetoothSocketHALIntStringIntResultRunnable( aRes, aMethod, aArg1, aArg2, aArg3); } else { runnable = new BluetoothSocketHALErrorRunnable(aRes, &BluetoothSocketResultHandler::OnError, aStatus); } nsresult rv = NS_DispatchToMainThread(runnable); if (NS_FAILED(rv)) { BT_WARNING("NS_DispatchToMainThread failed: %X", rv); } return rv; }
void BluetoothDevice::Notify(const BluetoothSignal& aData) { BT_LOGD("[D] %s: %s", __FUNCTION__, NS_ConvertUTF16toUTF8(aData.name()).get()); BluetoothValue v = aData.value(); if (aData.name().EqualsLiteral("PropertyChanged")) { MOZ_ASSERT(v.type() == BluetoothValue::TArrayOfBluetoothNamedValue); const InfallibleTArray<BluetoothNamedValue>& arr = v.get_ArrayOfBluetoothNamedValue(); for (uint32_t i = 0, propCount = arr.Length(); i < propCount; ++i) { SetPropertyByValue(arr[i]); } } else { #ifdef DEBUG nsCString warningMsg; warningMsg.AssignLiteral("Not handling device signal: "); warningMsg.Append(NS_ConvertUTF16toUTF8(aData.name())); BT_WARNING(warningMsg.get()); #endif } }
already_AddRefed<mozilla::dom::DOMRequest> BluetoothPropertyContainer::SetProperty(nsPIDOMWindow* aOwner, const BluetoothNamedValue& aProperty, ErrorResult& aRv) { nsRefPtr<mozilla::dom::DOMRequest> request = new DOMRequest(aOwner); nsRefPtr<BluetoothReplyRunnable> task = new BluetoothVoidReplyRunnable(request); BluetoothService* bs = BluetoothService::Get(); if (!bs) { BT_WARNING("Bluetooth service not available!"); aRv.Throw(NS_ERROR_FAILURE); return nullptr; } nsresult rv = bs->SetProperty(mObjectType, aProperty, task); if (NS_FAILED(rv)) { aRv.Throw(rv); return nullptr; } return request.forget(); }
BluetoothInterface* BluetoothInterface::GetInstance() { #if ANDROID_VERSION >= 17 /* We pick a default backend from the available ones. The options are * ordered by preference. If a backend is supported but not available * on the current system, we pick the next one. The selected default * can be overriden manually by storing the respective string in the * system property 'ro.moz.bluetooth.backend'. */ static const char* const sDefaultBackend[] = { #ifdef MOZ_B2G_BT_DAEMON "bluetoothd", #endif nullptr // no default backend; must be final element in array }; const char* defaultBackend; for (size_t i = 0; i < MOZ_ARRAY_LENGTH(sDefaultBackend); ++i) { /* select current backend */ defaultBackend = sDefaultBackend[i]; if (defaultBackend) { if (!strcmp(defaultBackend, "bluetoothd") && access("/init.bluetooth.rc", F_OK) == -1) { continue; /* bluetoothd not available */ } } break; } char value[PROPERTY_VALUE_MAX]; int len; len = property_get("ro.moz.bluetooth.backend", value, defaultBackend); if (len < 0) { BT_WARNING("No Bluetooth backend available."); return nullptr; } const nsDependentCString backend(value, len); /* Here's where we decide which implementation to use. Currently * there is only Bluedroid and the Bluetooth daemon, but others are * possible. Having multiple interfaces built-in and selecting the * correct one at runtime is also an option. */ #ifdef MOZ_B2G_BT_DAEMON if (backend.LowerCaseEqualsLiteral("bluetoothd")) { return BluetoothDaemonInterface::GetInstance(); } else #endif { BT_WARNING("Bluetooth backend '%s' is unknown or not available.", backend.get()); } return nullptr; #else /* Anything that's not Android 4.2 or later uses BlueZ instead. The * code should actually never reach this point. */ BT_WARNING("No Bluetooth backend available for your system."); return nullptr; #endif }
void BluetoothGattResultHandler::OnError(BluetoothStatus aStatus) { BT_WARNING("Received error code %d", (int)aStatus); }