wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity
3fea9f7ebe
gecko/dom/bluetooth/bluedroid/BluetoothDaemonGattInterface.cpp

3052 lines
85 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "BluetoothDaemonGattInterface.h"
#include "BluetoothDaemonSetupInterface.h"
#include "mozilla/unused.h"
BEGIN_BLUETOOTH_NAMESPACE
//
// GATT module
//
const int BluetoothDaemonGattModule::MAX_NUM_CLIENTS = 1;
BluetoothGattNotificationHandler*
BluetoothDaemonGattModule::sNotificationHandler;
void
BluetoothDaemonGattModule::SetNotificationHandler(
BluetoothGattNotificationHandler* aNotificationHandler)
{
sNotificationHandler = aNotificationHandler;
}
nsresult
BluetoothDaemonGattModule::Send(DaemonSocketPDU* aPDU,
BluetoothGattResultHandler* aRes)
{
if (aRes) {
aRes->AddRef(); // Keep reference for response
}
return Send(aPDU, static_cast<void*>(aRes));
}
nsresult
BluetoothDaemonGattModule::Send(DaemonSocketPDU* aPDU,
BluetoothGattClientResultHandler* aRes)
{
if (aRes) {
aRes->AddRef(); // Keep reference for response
}
return Send(aPDU, static_cast<void*>(aRes));
}
nsresult
BluetoothDaemonGattModule::Send(DaemonSocketPDU* aPDU,
BluetoothGattServerResultHandler* aRes)
{
aRes->AddRef(); // Keep reference for response
return Send(aPDU, static_cast<void*>(aRes));
}
void
BluetoothDaemonGattModule::HandleSvc(const DaemonSocketPDUHeader& aHeader,
DaemonSocketPDU& aPDU, void* aUserData)
{
static void (BluetoothDaemonGattModule::* const HandleOp[])(
const DaemonSocketPDUHeader&, DaemonSocketPDU&, void*) = {
INIT_ARRAY_AT(0, &BluetoothDaemonGattModule::HandleRsp),
INIT_ARRAY_AT(1, &BluetoothDaemonGattModule::HandleNtf),
};
MOZ_ASSERT(!NS_IsMainThread());
// Negate twice to map bit to 0/1
unsigned long isNtf = !!(aHeader.mOpcode & 0x80);
(this->*(HandleOp[isNtf]))(aHeader, aPDU, aUserData);
}
// Commands
//
nsresult
BluetoothDaemonGattModule::ClientRegisterCmd(
const BluetoothUuid& aUuid, BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_REGISTER,
16)); // Service UUID
nsresult rv = PackPDU(aUuid, *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientUnregisterCmd(
int aClientIf, BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_UNREGISTER,
4)); // Client Interface
nsresult rv = PackPDU(aClientIf, *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientScanCmd(
int aClientIf, bool aStart, BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_SCAN,
4 + // Client Interface
1)); // Start
nsresult rv = PackPDU(PackConversion<int, int32_t>(aClientIf),
PackConversion<bool, uint8_t>(aStart), *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientConnectCmd(
int aClientIf, const nsAString& aBdAddr, bool aIsDirect,
BluetoothTransport aTransport, BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_CONNECT,
4 + // Client Interface
6 + // Remote Address
1 + // Is Direct
4)); // Transport
nsresult rv = PackPDU(
PackConversion<int, int32_t>(aClientIf),
PackConversion<nsAString, BluetoothAddress>(aBdAddr),
PackConversion<bool, uint8_t>(aIsDirect),
PackConversion<BluetoothTransport, int32_t>(aTransport), *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientDisconnectCmd(
int aClientIf, const nsAString& aBdAddr, int aConnId,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_DISCONNECT,
4 + // Client Interface
6 + // Remote Address
4)); // Connection ID
nsresult rv;
rv = PackPDU(PackConversion<int, int32_t>(aClientIf),
PackConversion<nsAString, BluetoothAddress>(aBdAddr),
PackConversion<int, int32_t>(aConnId), *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientListenCmd(
int aClientIf, bool aIsStart, BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_LISTEN,
4 + // Client Interface
1)); // Start
nsresult rv;
rv = PackPDU(PackConversion<int, int32_t>(aClientIf),
PackConversion<bool, uint8_t>(aIsStart), *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientRefreshCmd(
int aClientIf, const nsAString& aBdAddr,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_REFRESH,
4 + // Client Interface
6)); // Remote Address
nsresult rv = PackPDU(PackConversion<int, int32_t>(aClientIf),
PackConversion<nsAString, BluetoothAddress>(aBdAddr),
*pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientSearchServiceCmd(
int aConnId, bool aFiltered, const BluetoothUuid& aUuid,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_SEARCH_SERVICE,
4 + // Connection ID
1 + // Filtered
16)); // UUID
nsresult rv = PackPDU(PackConversion<int, int32_t>(aConnId),
PackConversion<bool, uint8_t>(aFiltered),
PackReversed<BluetoothUuid>(aUuid),
*pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientGetIncludedServiceCmd(
int aConnId, const BluetoothGattServiceId& aServiceId, bool aContinuation,
const BluetoothGattServiceId& aStartServiceId,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_GET_INCLUDED_SERVICE,
4 + // Connection ID
18 + // Service ID
1 + // Continuation
18)); // Start Service ID
nsresult rv = PackPDU(PackConversion<int, int32_t>(aConnId), aServiceId,
PackConversion<bool, uint8_t>(aContinuation),
aStartServiceId, *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientGetCharacteristicCmd(
int aConnId, const BluetoothGattServiceId& aServiceId, bool aContinuation,
const BluetoothGattId& aStartCharId,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_GET_CHARACTERISTIC,
4 + // Connection ID
18 + // Service ID
1 + // Continuation
17)); // Start Characteristic ID
nsresult rv = PackPDU(PackConversion<int, int32_t>(aConnId), aServiceId,
PackConversion<bool, uint8_t>(aContinuation),
aStartCharId, *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientGetDescriptorCmd(
int aConnId, const BluetoothGattServiceId& aServiceId,
const BluetoothGattId& aCharId, bool aContinuation,
const BluetoothGattId& aStartDescriptorId,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_GET_DESCRIPTOR,
4 + // Connection ID
18 + // Service ID
17 + // Characteristic ID
1 + // Continuation
17)); // Start Descriptor ID
nsresult rv = PackPDU(PackConversion<int, int32_t>(aConnId),
aServiceId, aCharId,
PackConversion<bool, uint8_t>(aContinuation),
aStartDescriptorId, *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientReadCharacteristicCmd(
int aConnId, const BluetoothGattServiceId& aServiceId,
const BluetoothGattId& aCharId, BluetoothGattAuthReq aAuthReq,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_READ_CHARACTERISTIC,
4 + // Connection ID
18 + // Service ID
17 + // Characteristic ID
4)); // Authorization
nsresult rv = PackPDU(PackConversion<int, int32_t>(aConnId), aServiceId,
aCharId, aAuthReq, *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientWriteCharacteristicCmd(
int aConnId, const BluetoothGattServiceId& aServiceId,
const BluetoothGattId& aCharId, BluetoothGattWriteType aWriteType,
int aLength, BluetoothGattAuthReq aAuthReq, char* aValue,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_WRITE_CHARACTERISTIC, 0));
nsresult rv = PackPDU(PackConversion<int, int32_t>(aConnId), aServiceId,
aCharId, aWriteType,
PackConversion<int, int32_t>(aLength), aAuthReq,
PackArray<char>(aValue, aLength), *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientReadDescriptorCmd(
int aConnId, const BluetoothGattServiceId& aServiceId,
const BluetoothGattId& aCharId, const BluetoothGattId& aDescriptorId,
BluetoothGattAuthReq aAuthReq, BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_READ_DESCRIPTOR,
4 + // Connection ID
18 + // Service ID
17 + // Characteristic ID
17 + // Descriptor ID
4)); // Authorization
nsresult rv = PackPDU(PackConversion<int, int32_t>(aConnId), aServiceId,
aCharId, aDescriptorId, aAuthReq, *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientWriteDescriptorCmd(
int aConnId, const BluetoothGattServiceId& aServiceId,
const BluetoothGattId& aCharId, const BluetoothGattId& aDescriptorId,
BluetoothGattWriteType aWriteType, int aLength,
BluetoothGattAuthReq aAuthReq, char* aValue,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_WRITE_DESCRIPTOR, 0));
nsresult rv = PackPDU(PackConversion<int, int32_t>(aConnId), aServiceId,
aCharId, aDescriptorId, aWriteType,
PackConversion<int, int32_t>(aLength), aAuthReq,
PackArray<char>(aValue, aLength), *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientExecuteWriteCmd(
int aConnId, int aIsExecute, BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_EXECUTE_WRITE,
4 + // Connection ID
4)); // Execute
nsresult rv = PackPDU(PackConversion<int, int32_t>(aConnId),
PackConversion<int, int32_t>(aIsExecute), *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientRegisterNotificationCmd(
int aClientIf, const nsAString& aBdAddr,
const BluetoothGattServiceId& aServiceId, const BluetoothGattId& aCharId,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_REGISTER_NOTIFICATION,
4 + // Client Interface
6 + // Remote Address
18 + // Service ID
17)); // Characteristic ID
nsresult rv = PackPDU(PackConversion<int, int32_t>(aClientIf),
PackConversion<nsAString, BluetoothAddress>(aBdAddr),
aServiceId, aCharId, *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientDeregisterNotificationCmd(
int aClientIf, const nsAString& aBdAddr,
const BluetoothGattServiceId& aServiceId, const BluetoothGattId& aCharId,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_DEREGISTER_NOTIFICATION,
4 + // Client Interface
6 + // Remote Address
18 + // Service ID
17)); // Characteristic ID
nsresult rv = PackPDU(PackConversion<int, int32_t>(aClientIf),
PackConversion<nsAString, BluetoothAddress>(aBdAddr),
aServiceId, aCharId, *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientReadRemoteRssiCmd(
int aClientIf, const nsAString& aBdAddr,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_READ_REMOTE_RSSI,
4 + // Client Interface
6)); // Remote Address
nsresult rv = PackPDU(PackConversion<int, int32_t>(aClientIf),
PackConversion<nsAString, BluetoothAddress>(aBdAddr),
*pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientGetDeviceTypeCmd(
const nsAString& aBdAddr, BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_GET_DEVICE_TYPE,
6)); // Remote Address
nsresult rv = PackPDU(
PackConversion<nsAString, BluetoothAddress>(aBdAddr), *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientSetAdvDataCmd(
int aServerIf, bool aIsScanRsp, bool aIsNameIncluded,
bool aIsTxPowerIncluded, int aMinInterval, int aMaxInterval, int aApperance,
uint16_t aManufacturerLen, char* aManufacturerData,
uint16_t aServiceDataLen, char* aServiceData,
uint16_t aServiceUuidLen, char* aServiceUuid,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_SET_ADV_DATA, 0));
nsresult rv = PackPDU(
PackConversion<int, int32_t>(aServerIf),
PackConversion<bool, uint8_t>(aIsScanRsp),
PackConversion<bool, uint8_t>(aIsNameIncluded),
PackConversion<bool, uint8_t>(aIsTxPowerIncluded),
PackConversion<int, int32_t>(aMinInterval),
PackConversion<int, int32_t>(aMaxInterval),
PackConversion<int, int32_t>(aApperance),
aManufacturerLen, PackArray<char>(aManufacturerData, aManufacturerLen),
aServiceDataLen, PackArray<char>(aServiceData, aServiceDataLen),
aServiceUuidLen, PackArray<char>(aServiceUuid, aServiceUuidLen), *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ClientTestCommandCmd(
int aCommand, const BluetoothGattTestParam& aTestParam,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_CLIENT_TEST_COMMAND,
4 + // Command
6 + // Address
16 + // UUID
2 + // U1
2 + // U2
2 + // U3
2 + // U4
2)); // U5
nsresult rv = PackPDU(
PackConversion<int, int32_t>(aCommand),
PackConversion<nsAString, BluetoothAddress>(aTestParam.mBdAddr),
aTestParam.mU1, aTestParam.mU2, aTestParam.mU3, aTestParam.mU4,
aTestParam.mU5, *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ServerRegisterCmd(
const BluetoothUuid& aUuid, BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_SERVER_REGISTER,
16)); // Uuid
nsresult rv = PackPDU(aUuid, *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ServerUnregisterCmd(
int aServerIf, BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_SERVER_UNREGISTER,
4)); // Server Interface
nsresult rv = PackPDU(PackConversion<int, int32_t>(aServerIf), *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ServerConnectPeripheralCmd(
int aServerIf, const nsAString& aBdAddr, bool aIsDirect,
BluetoothTransport aTransport, BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_SERVER_CONNECT_PERIPHERAL,
4 + // Server Interface
6 + // Remote Address
1 + // Is Direct
4)); // Transport
nsresult rv = PackPDU(
PackConversion<int, int32_t>(aServerIf),
PackConversion<nsAString, BluetoothAddress>(aBdAddr),
PackConversion<bool, uint8_t>(aIsDirect),
PackConversion<BluetoothTransport, int32_t>(aTransport), *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ServerDisconnectPeripheralCmd(
int aServerIf, const nsAString& aBdAddr, int aConnId,
BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_SERVER_DISCONNECT_PERIPHERAL,
4 + // Server Interface
6 + // Remote Address
4)); // Connection Id
nsresult rv = PackPDU(PackConversion<int, int32_t>(aServerIf),
PackConversion<nsAString, BluetoothAddress>(aBdAddr),
PackConversion<int, int32_t>(aConnId), *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ServerAddServiceCmd(
int aServerIf, const BluetoothGattServiceId& aServiceId, int aNumHandles,
BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_SERVER_ADD_SERVICE,
4 + // Server Interface
18 + // Service ID
4)); // Number of Handles
nsresult rv = PackPDU(PackConversion<int, int32_t>(aServerIf), aServiceId,
PackConversion<int, int32_t>(aNumHandles), *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ServerAddIncludedServiceCmd(
int aServerIf, int aServiceHandle, int aIncludedServiceHandle,
BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_SERVER_ADD_INCLUDED_SERVICE,
4 + // Server Interface
4 + // Service Handle
4)); // Included Service Handle
nsresult rv = PackPDU(PackConversion<int, int32_t>(aServerIf),
PackConversion<int, int32_t>(aServiceHandle),
PackConversion<int, int32_t>(aIncludedServiceHandle),
*pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ServerAddCharacteristicCmd(
int aServerIf, int aServiceHandle, const BluetoothUuid& aUuid,
BluetoothGattCharProp aProperties, BluetoothGattAttrPerm aPermissions,
BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_SERVER_ADD_CHARACTERISTIC,
4 + // Server Interface
4 + // Service Handle
16 + // UUID
4 + // Properties
4)); // Permissions
nsresult rv = PackPDU(PackConversion<int, int32_t>(aServerIf),
PackConversion<int, int32_t>(aServiceHandle),
aUuid, aProperties, aPermissions, *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ServerAddDescriptorCmd(
int aServerIf, int aServiceHandle, const BluetoothUuid& aUuid,
BluetoothGattAttrPerm aPermissions, BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_SERVER_ADD_DESCRIPTOR,
4 + // Server Interface
4 + // Service Handle
16 + // UUID
4)); // Permissions
nsresult rv = PackPDU(PackConversion<int, int32_t>(aServerIf),
PackConversion<int, int32_t>(aServiceHandle),
aUuid, aPermissions, *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ServerStartServiceCmd(
int aServerIf, int aServiceHandle, BluetoothTransport aTransport,
BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_SERVER_START_SERVICE,
4 + // Server Interface
4 + // Service Handle
4)); // Transport
nsresult rv = PackPDU(
PackConversion<int, int32_t>(aServerIf),
PackConversion<int, int32_t>(aServiceHandle),
PackConversion<BluetoothTransport, int32_t>(aTransport), *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ServerStopServiceCmd(
int aServerIf, int aServiceHandle, BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_SERVER_STOP_SERVICE,
4 + // Server Interface
4)); // Service Handle
nsresult rv = PackPDU(PackConversion<int, int32_t>(aServerIf),
PackConversion<int, int32_t>(aServiceHandle), *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ServerDeleteServiceCmd(
int aServerIf, int aServiceHandle, BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_SERVER_DELETE_SERVICE,
4 + // Server Interface
4)); // Service Handle
nsresult rv = PackPDU(PackConversion<int, int32_t>(aServerIf),
PackConversion<int, int32_t>(aServiceHandle), *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ServerSendIndicationCmd(
int aServerIf, int aAttributeHandle, int aConnId, int aLength, bool aConfirm,
uint8_t* aValue, BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_SERVER_SEND_INDICATION,
0));
nsresult rv = PackPDU(PackConversion<int, int32_t>(aServerIf),
PackConversion<int, int32_t>(aAttributeHandle),
PackConversion<int, int32_t>(aConnId),
PackConversion<int, int32_t>(aLength),
PackConversion<bool, int32_t>(aConfirm),
PackArray<uint8_t>(aValue, aLength), *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
nsresult
BluetoothDaemonGattModule::ServerSendResponseCmd(
int aConnId, int aTransId, BluetoothGattStatus aStatus,
const BluetoothGattResponse& aResponse,
BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(NS_IsMainThread());
nsAutoPtr<DaemonSocketPDU> pdu(
new DaemonSocketPDU(SERVICE_ID, OPCODE_SERVER_SEND_RESPONSE,
0));
nsresult rv = PackPDU(
PackConversion<int, int32_t>(aConnId),
PackConversion<int, int32_t>(aTransId),
aResponse.mHandle,
aResponse.mOffset,
PackConversion<BluetoothGattAuthReq, uint8_t>(aResponse.mAuthReq),
PackConversion<BluetoothGattStatus, int32_t>(aStatus),
aResponse.mLength,
PackArray<uint8_t>(aResponse.mValue, aResponse.mLength), *pdu);
if (NS_FAILED(rv)) {
return rv;
}
rv = Send(pdu, aRes);
if (NS_FAILED(rv)) {
return rv;
}
unused << pdu.forget();
return NS_OK;
}
// Responses
//
void
BluetoothDaemonGattModule::ErrorRsp(
const DaemonSocketPDUHeader& aHeader,
DaemonSocketPDU& aPDU, BluetoothGattResultHandler* aRes)
{
ErrorRunnable::Dispatch(
aRes, &BluetoothGattResultHandler::OnError, UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientRegisterRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::RegisterClient,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientUnregisterRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::UnregisterClient,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientScanRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::Scan, UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientConnectRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::Connect, UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientDisconnectRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::Disconnect,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientListenRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::Listen, UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientRefreshRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::Refresh, UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientSearchServiceRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::SearchService,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientGetIncludedServiceRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::GetIncludedService,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientGetCharacteristicRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::GetCharacteristic,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientGetDescriptorRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::GetDescriptor,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientReadCharacteristicRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::ReadCharacteristic,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientWriteCharacteristicRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::WriteCharacteristic,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientReadDescriptorRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::ReadDescriptor,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientWriteDescriptorRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::WriteDescriptor,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientExecuteWriteRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::ExecuteWrite,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientRegisterNotificationRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::RegisterNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientDeregisterNotificationRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::DeregisterNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientReadRemoteRssiRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::ReadRemoteRssi,
UnpackPDUInitOp(aPDU));
}
// Init operator class for ClientGetDeviceTypeRsp
class BluetoothDaemonGattModule::ClientGetDeviceTypeInitOp final
: private PDUInitOp
{
public:
ClientGetDeviceTypeInitOp(DaemonSocketPDU& aPDU)
: PDUInitOp(aPDU)
{ }
nsresult
operator () (BluetoothTypeOfDevice& aArg1) const
{
/* Read device type */
nsresult rv = UnpackPDU(
GetPDU(), UnpackConversion<uint8_t, BluetoothTypeOfDevice>(aArg1));
if (NS_FAILED(rv)) {
return rv;
}
WarnAboutTrailingData();
return NS_OK;
}
};
void
BluetoothDaemonGattModule::ClientGetDeviceTypeRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientGetDeviceTypeResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::GetDeviceType,
ClientGetDeviceTypeInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientSetAdvDataRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::SetAdvData,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientTestCommandRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattClientResultHandler* aRes)
{
ClientResultRunnable::Dispatch(
aRes, &BluetoothGattClientResultHandler::TestCommand,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerRegisterRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattServerResultHandler* aRes)
{
ServerResultRunnable::Dispatch(
aRes, &BluetoothGattServerResultHandler::RegisterServer,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerUnregisterRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattServerResultHandler* aRes)
{
ServerResultRunnable::Dispatch(
aRes, &BluetoothGattServerResultHandler::UnregisterServer,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerConnectPeripheralRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattServerResultHandler* aRes)
{
ServerResultRunnable::Dispatch(
aRes, &BluetoothGattServerResultHandler::ConnectPeripheral,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerDisconnectPeripheralRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattServerResultHandler* aRes)
{
ServerResultRunnable::Dispatch(
aRes, &BluetoothGattServerResultHandler::DisconnectPeripheral,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerAddServiceRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattServerResultHandler* aRes)
{
ServerResultRunnable::Dispatch(
aRes, &BluetoothGattServerResultHandler::AddService,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerAddIncludedServiceRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattServerResultHandler* aRes)
{
ServerResultRunnable::Dispatch(
aRes, &BluetoothGattServerResultHandler::AddIncludedService,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerAddCharacteristicRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattServerResultHandler* aRes)
{
ServerResultRunnable::Dispatch(
aRes, &BluetoothGattServerResultHandler::AddCharacteristic,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerAddDescriptorRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattServerResultHandler* aRes)
{
ServerResultRunnable::Dispatch(
aRes, &BluetoothGattServerResultHandler::AddDescriptor,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerStartServiceRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattServerResultHandler* aRes)
{
ServerResultRunnable::Dispatch(
aRes, &BluetoothGattServerResultHandler::StartService,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerStopServiceRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattServerResultHandler* aRes)
{
ServerResultRunnable::Dispatch(
aRes, &BluetoothGattServerResultHandler::StopService,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerDeleteServiceRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattServerResultHandler* aRes)
{
ServerResultRunnable::Dispatch(
aRes, &BluetoothGattServerResultHandler::DeleteService,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerSendIndicationRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattServerResultHandler* aRes)
{
ServerResultRunnable::Dispatch(
aRes, &BluetoothGattServerResultHandler::SendIndication,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerSendResponseRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
BluetoothGattServerResultHandler* aRes)
{
ServerResultRunnable::Dispatch(
aRes, &BluetoothGattServerResultHandler::SendResponse,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::HandleRsp(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
void* aUserData)
{
static void (BluetoothDaemonGattModule::* const HandleRsp[])(
const DaemonSocketPDUHeader&,
DaemonSocketPDU&,
BluetoothGattResultHandler*) = {
INIT_ARRAY_AT(OPCODE_ERROR,
&BluetoothDaemonGattModule::ErrorRsp)
};
static void (BluetoothDaemonGattModule::* const HandleClientRsp[])(
const DaemonSocketPDUHeader&,
DaemonSocketPDU&,
BluetoothGattClientResultHandler*) = {
INIT_ARRAY_AT(0, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_REGISTER,
&BluetoothDaemonGattModule::ClientRegisterRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_UNREGISTER,
&BluetoothDaemonGattModule::ClientUnregisterRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_SCAN,
&BluetoothDaemonGattModule::ClientScanRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_CONNECT,
&BluetoothDaemonGattModule::ClientConnectRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_DISCONNECT,
&BluetoothDaemonGattModule::ClientDisconnectRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_LISTEN,
&BluetoothDaemonGattModule::ClientListenRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_REFRESH,
&BluetoothDaemonGattModule::ClientRefreshRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_SEARCH_SERVICE,
&BluetoothDaemonGattModule::ClientSearchServiceRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_GET_INCLUDED_SERVICE,
&BluetoothDaemonGattModule::ClientGetIncludedServiceRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_GET_CHARACTERISTIC,
&BluetoothDaemonGattModule::ClientGetCharacteristicRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_GET_DESCRIPTOR,
&BluetoothDaemonGattModule::ClientGetDescriptorRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_READ_CHARACTERISTIC,
&BluetoothDaemonGattModule::ClientReadCharacteristicRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_WRITE_CHARACTERISTIC,
&BluetoothDaemonGattModule::ClientWriteCharacteristicRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_READ_DESCRIPTOR,
&BluetoothDaemonGattModule::ClientReadDescriptorRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_WRITE_DESCRIPTOR,
&BluetoothDaemonGattModule::ClientWriteDescriptorRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_EXECUTE_WRITE,
&BluetoothDaemonGattModule::ClientExecuteWriteRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_REGISTER_NOTIFICATION,
&BluetoothDaemonGattModule::ClientRegisterNotificationRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_DEREGISTER_NOTIFICATION,
&BluetoothDaemonGattModule::ClientDeregisterNotificationRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_READ_REMOTE_RSSI,
&BluetoothDaemonGattModule::ClientReadRemoteRssiRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_GET_DEVICE_TYPE,
&BluetoothDaemonGattModule::ClientGetDeviceTypeRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_SET_ADV_DATA,
&BluetoothDaemonGattModule::ClientSetAdvDataRsp),
INIT_ARRAY_AT(OPCODE_CLIENT_TEST_COMMAND,
&BluetoothDaemonGattModule::ClientTestCommandRsp)
};
/**
* These client opcodes are added since non-trivial designated initializers
* are not supported.
* We could use a single array for GattRsp, GattClientRsp, and GattServerRsp
* after combining result handlers in Bug 1181512.
**/
static void (BluetoothDaemonGattModule::* const HandleServerRsp[])(
const DaemonSocketPDUHeader&,
DaemonSocketPDU&,
BluetoothGattServerResultHandler*) = {
INIT_ARRAY_AT(0, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_REGISTER, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_UNREGISTER, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_SCAN, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_CONNECT, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_DISCONNECT, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_LISTEN, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_REFRESH, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_SEARCH_SERVICE, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_GET_INCLUDED_SERVICE, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_GET_CHARACTERISTIC, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_GET_DESCRIPTOR, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_READ_CHARACTERISTIC, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_WRITE_CHARACTERISTIC, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_READ_DESCRIPTOR, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_WRITE_DESCRIPTOR, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_EXECUTE_WRITE, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_REGISTER_NOTIFICATION, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_DEREGISTER_NOTIFICATION, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_READ_REMOTE_RSSI, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_GET_DEVICE_TYPE, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_SET_ADV_DATA, nullptr),
INIT_ARRAY_AT(OPCODE_CLIENT_TEST_COMMAND, nullptr),
INIT_ARRAY_AT(OPCODE_SERVER_REGISTER,
&BluetoothDaemonGattModule::ServerRegisterRsp),
INIT_ARRAY_AT(OPCODE_SERVER_UNREGISTER,
&BluetoothDaemonGattModule::ServerUnregisterRsp),
INIT_ARRAY_AT(OPCODE_SERVER_CONNECT_PERIPHERAL,
&BluetoothDaemonGattModule::ServerConnectPeripheralRsp),
INIT_ARRAY_AT(OPCODE_SERVER_DISCONNECT_PERIPHERAL,
&BluetoothDaemonGattModule::ServerDisconnectPeripheralRsp),
INIT_ARRAY_AT(OPCODE_SERVER_ADD_SERVICE,
&BluetoothDaemonGattModule::ServerAddServiceRsp),
INIT_ARRAY_AT(OPCODE_SERVER_ADD_INCLUDED_SERVICE,
&BluetoothDaemonGattModule::ServerAddIncludedServiceRsp),
INIT_ARRAY_AT(OPCODE_SERVER_ADD_CHARACTERISTIC,
&BluetoothDaemonGattModule::ServerAddCharacteristicRsp),
INIT_ARRAY_AT(OPCODE_SERVER_ADD_DESCRIPTOR,
&BluetoothDaemonGattModule::ServerAddDescriptorRsp),
INIT_ARRAY_AT(OPCODE_SERVER_START_SERVICE,
&BluetoothDaemonGattModule::ServerStartServiceRsp),
INIT_ARRAY_AT(OPCODE_SERVER_STOP_SERVICE,
&BluetoothDaemonGattModule::ServerStopServiceRsp),
INIT_ARRAY_AT(OPCODE_SERVER_DELETE_SERVICE,
&BluetoothDaemonGattModule::ServerDeleteServiceRsp),
INIT_ARRAY_AT(OPCODE_SERVER_SEND_INDICATION,
&BluetoothDaemonGattModule::ServerSendIndicationRsp),
INIT_ARRAY_AT(OPCODE_SERVER_SEND_RESPONSE,
&BluetoothDaemonGattModule::ServerSendResponseRsp)
};
MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
bool isInGattArray = aHeader.mOpcode < MOZ_ARRAY_LENGTH(HandleRsp) &&
HandleRsp[aHeader.mOpcode];
bool isInGattClientArray =
aHeader.mOpcode < MOZ_ARRAY_LENGTH(HandleClientRsp) &&
HandleClientRsp[aHeader.mOpcode];
bool isInGattServerArray =
aHeader.mOpcode < MOZ_ARRAY_LENGTH(HandleServerRsp) &&
HandleServerRsp[aHeader.mOpcode];
if (NS_WARN_IF(!isInGattArray && !isInGattClientArray &&
!isInGattServerArray)) {
return;
}
if (!aUserData) {
return; // Return early if no result handler has been set for response
}
if (isInGattArray) {
nsRefPtr<BluetoothGattResultHandler> res =
already_AddRefed<BluetoothGattResultHandler>(
static_cast<BluetoothGattResultHandler*>(aUserData));
(this->*(HandleRsp[aHeader.mOpcode]))(aHeader, aPDU, res);
} else if (isInGattClientArray) {
nsRefPtr<BluetoothGattClientResultHandler> res =
already_AddRefed<BluetoothGattClientResultHandler>(
static_cast<BluetoothGattClientResultHandler*>(aUserData));
(this->*(HandleClientRsp[aHeader.mOpcode]))(aHeader, aPDU, res);
} else { // isInGattServerArray
nsRefPtr<BluetoothGattServerResultHandler> res =
already_AddRefed<BluetoothGattServerResultHandler>(
static_cast<BluetoothGattServerResultHandler*>(aUserData));
(this->*(HandleServerRsp[aHeader.mOpcode]))(aHeader, aPDU, res);
}
}
// Notifications
//
// Returns the current notification handler to a notification runnable
class BluetoothDaemonGattModule::NotificationHandlerWrapper final
{
public:
typedef BluetoothGattNotificationHandler ObjectType;
static ObjectType* GetInstance()
{
MOZ_ASSERT(NS_IsMainThread());
return sNotificationHandler;
}
};
// Returns the current notification handler to a notification runnable
class BluetoothDaemonGattModule::ClientNotificationHandlerWrapper final
{
public:
typedef BluetoothGattClientNotificationHandler ObjectType;
static ObjectType* GetInstance()
{
MOZ_ASSERT(NS_IsMainThread());
return sNotificationHandler;
}
};
// Returns the current notification handler to a notification runnable
class BluetoothDaemonGattModule::ServerNotificationHandlerWrapper final
{
public:
typedef BluetoothGattServerNotificationHandler ObjectType;
static ObjectType* GetInstance()
{
MOZ_ASSERT(NS_IsMainThread());
return sNotificationHandler;
}
};
void
BluetoothDaemonGattModule::ClientRegisterNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ClientRegisterNotification::Dispatch(
&BluetoothGattClientNotificationHandler::RegisterClientNotification,
UnpackPDUInitOp(aPDU));
}
// Init operator class for ClientScanResultNotification
class BluetoothDaemonGattModule::ClientScanResultInitOp final
: private PDUInitOp
{
public:
ClientScanResultInitOp(DaemonSocketPDU& aPDU)
: PDUInitOp(aPDU)
{ }
nsresult
operator () (nsString& aArg1,
int& aArg2,
BluetoothGattAdvData& aArg3) const
{
DaemonSocketPDU& pdu = GetPDU();
/* Read address */
nsresult rv = UnpackPDU(
pdu, UnpackConversion<BluetoothAddress, nsAString>(aArg1));
if (NS_FAILED(rv)) {
return rv;
}
/* Read RSSI */
rv = UnpackPDU(pdu, aArg2);
if (NS_FAILED(rv)) {
return rv;
}
/* Read Length */
uint16_t length;
rv = UnpackPDU(pdu, length);
if (NS_FAILED(rv)) {
return rv;
}
/* Read Adv Data */
rv = UnpackPDU(pdu, UnpackArray<uint8_t>(aArg3.mAdvData, length));
if (NS_FAILED(rv)) {
return rv;
}
WarnAboutTrailingData();
return NS_OK;
}
};
void
BluetoothDaemonGattModule::ClientScanResultNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ClientScanResultNotification::Dispatch(
&BluetoothGattClientNotificationHandler::ScanResultNotification,
ClientScanResultInitOp(aPDU));
}
// Init operator class for ClientConnect/DisconnectNotification
class BluetoothDaemonGattModule::ClientConnectDisconnectInitOp final
: private PDUInitOp
{
public:
ClientConnectDisconnectInitOp(DaemonSocketPDU& aPDU)
: PDUInitOp(aPDU)
{ }
nsresult
operator () (int& aArg1,
BluetoothGattStatus& aArg2,
int& aArg3,
nsString& aArg4) const
{
DaemonSocketPDU& pdu = GetPDU();
/* Read connection ID */
nsresult rv = UnpackPDU(pdu, aArg1);
if (NS_FAILED(rv)) {
return rv;
}
/* Read status */
rv = UnpackPDU(pdu, aArg2);
if (NS_FAILED(rv)) {
return rv;
}
/* Read client interface */
rv = UnpackPDU(pdu, aArg3);
if (NS_FAILED(rv)) {
return rv;
}
/* Read address */
rv = UnpackPDU(
pdu, UnpackConversion<BluetoothAddress, nsAString>(aArg4));
if (NS_FAILED(rv)) {
return rv;
}
WarnAboutTrailingData();
return NS_OK;
}
};
void
BluetoothDaemonGattModule::ClientConnectNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ClientConnectNotification::Dispatch(
&BluetoothGattClientNotificationHandler::ConnectNotification,
ClientConnectDisconnectInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientDisconnectNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ClientDisconnectNotification::Dispatch(
&BluetoothGattClientNotificationHandler::DisconnectNotification,
ClientConnectDisconnectInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientSearchCompleteNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ClientSearchCompleteNotification::Dispatch(
&BluetoothGattClientNotificationHandler::SearchCompleteNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientSearchResultNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ClientSearchResultNotification::Dispatch(
&BluetoothGattClientNotificationHandler::SearchResultNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientGetCharacteristicNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ClientGetCharacteristicNotification::Dispatch(
&BluetoothGattClientNotificationHandler::GetCharacteristicNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientGetDescriptorNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ClientGetDescriptorNotification::Dispatch(
&BluetoothGattClientNotificationHandler::GetDescriptorNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientGetIncludedServiceNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ClientGetIncludedServiceNotification::Dispatch(
&BluetoothGattClientNotificationHandler::GetIncludedServiceNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientRegisterNotificationNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ClientRegisterNotificationNotification::Dispatch(
&BluetoothGattClientNotificationHandler::RegisterNotificationNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientNotifyNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ClientNotifyNotification::Dispatch(
&BluetoothGattClientNotificationHandler::NotifyNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientReadCharacteristicNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ClientReadCharacteristicNotification::Dispatch(
&BluetoothGattClientNotificationHandler::ReadCharacteristicNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientWriteCharacteristicNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ClientWriteCharacteristicNotification::Dispatch(
&BluetoothGattClientNotificationHandler::WriteCharacteristicNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientReadDescriptorNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ClientReadDescriptorNotification::Dispatch(
&BluetoothGattClientNotificationHandler::ReadDescriptorNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientWriteDescriptorNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ClientWriteDescriptorNotification::Dispatch(
&BluetoothGattClientNotificationHandler::WriteDescriptorNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientExecuteWriteNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ClientExecuteWriteNotification::Dispatch(
&BluetoothGattClientNotificationHandler::ExecuteWriteNotification,
UnpackPDUInitOp(aPDU));
}
// Init operator class for ClientReadRemoteRssiNotification
class BluetoothDaemonGattModule::ClientReadRemoteRssiInitOp final
: private PDUInitOp
{
public:
ClientReadRemoteRssiInitOp(DaemonSocketPDU& aPDU)
: PDUInitOp(aPDU)
{ }
nsresult
operator () (int& aArg1,
nsString& aArg2,
int& aArg3,
BluetoothGattStatus& aArg4) const
{
DaemonSocketPDU& pdu = GetPDU();
/* Read client interface */
nsresult rv = UnpackPDU(pdu, aArg1);
if (NS_FAILED(rv)) {
return rv;
}
/* Read address */
rv = UnpackPDU(pdu, UnpackConversion<BluetoothAddress, nsAString>(aArg2));
if (NS_FAILED(rv)) {
return rv;
}
/* Read RSSI */
rv = UnpackPDU(pdu, aArg3);
if (NS_FAILED(rv)) {
return rv;
}
/* Read status */
rv = UnpackPDU(pdu, aArg4);
if (NS_FAILED(rv)) {
return rv;
}
WarnAboutTrailingData();
return NS_OK;
}
};
void
BluetoothDaemonGattModule::ClientReadRemoteRssiNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ClientReadRemoteRssiNotification::Dispatch(
&BluetoothGattClientNotificationHandler::ReadRemoteRssiNotification,
ClientReadRemoteRssiInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ClientListenNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ClientListenNotification::Dispatch(
&BluetoothGattClientNotificationHandler::ListenNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerRegisterNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ServerRegisterNotification::Dispatch(
&BluetoothGattServerNotificationHandler::RegisterServerNotification,
UnpackPDUInitOp(aPDU));
}
// Init operator class for ServerConnectionNotification
class BluetoothDaemonGattModule::ServerConnectionInitOp final
: private PDUInitOp
{
public:
ServerConnectionInitOp(DaemonSocketPDU& aPDU)
: PDUInitOp(aPDU)
{ }
nsresult
operator () (int& aArg1,
int& aArg2,
bool& aArg3,
nsString& aArg4) const
{
DaemonSocketPDU& pdu = GetPDU();
/* Read connection ID */
nsresult rv = UnpackPDU(pdu, aArg1);
if (NS_FAILED(rv)) {
return rv;
}
/* Read server interface */
rv = UnpackPDU(pdu, aArg2);
if (NS_FAILED(rv)) {
return rv;
}
/* Read connected */
rv = UnpackPDU(pdu, aArg3);
if (NS_FAILED(rv)) {
return rv;
}
/* Read address */
rv = UnpackPDU(
pdu, UnpackConversion<BluetoothAddress, nsAString>(aArg4));
if (NS_FAILED(rv)) {
return rv;
}
WarnAboutTrailingData();
return NS_OK;
}
};
void
BluetoothDaemonGattModule::ServerConnectionNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ServerConnectionNotification::Dispatch(
&BluetoothGattServerNotificationHandler::ConnectionNotification,
ServerConnectionInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerServiceAddedNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ServerServiceAddedNotification::Dispatch(
&BluetoothGattServerNotificationHandler::ServiceAddedNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerIncludedServiceAddedNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ServerIncludedServiceAddedNotification::Dispatch(
&BluetoothGattServerNotificationHandler::IncludedServiceAddedNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerCharacteristicAddedNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ServerCharacteristicAddedNotification::Dispatch(
&BluetoothGattServerNotificationHandler::CharacteristicAddedNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerDescriptorAddedNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ServerDescriptorAddedNotification::Dispatch(
&BluetoothGattServerNotificationHandler::DescriptorAddedNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerServiceStartedNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ServerServiceStartedNotification::Dispatch(
&BluetoothGattServerNotificationHandler::ServiceStartedNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerServiceStoppedNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ServerServiceStoppedNotification::Dispatch(
&BluetoothGattServerNotificationHandler::ServiceStoppedNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerServiceDeletedNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ServerServiceDeletedNotification::Dispatch(
&BluetoothGattServerNotificationHandler::ServiceDeletedNotification,
UnpackPDUInitOp(aPDU));
}
// Init operator class for ServerRequestReadNotification
class BluetoothDaemonGattModule::ServerRequestReadInitOp final
: private PDUInitOp
{
public:
ServerRequestReadInitOp(DaemonSocketPDU& aPDU)
: PDUInitOp(aPDU)
{ }
nsresult
operator () (int& aArg1,
int& aArg2,
nsString& aArg3,
int& aArg4,
int& aArg5,
bool& aArg6) const
{
DaemonSocketPDU& pdu = GetPDU();
/* Read connection ID */
nsresult rv = UnpackPDU(pdu, aArg1);
if (NS_FAILED(rv)) {
return rv;
}
/* Read trans ID */
rv = UnpackPDU(pdu, aArg2);
if (NS_FAILED(rv)) {
return rv;
}
/* Read address */
rv = UnpackPDU(
pdu, UnpackConversion<BluetoothAddress, nsAString>(aArg3));
if (NS_FAILED(rv)) {
return rv;
}
/* Read attribute handle */
rv = UnpackPDU(pdu, aArg4);
if (NS_FAILED(rv)) {
return rv;
}
/* Read offset */
rv = UnpackPDU(pdu, aArg5);
if (NS_FAILED(rv)) {
return rv;
}
/* Read isLong */
rv = UnpackPDU(pdu, aArg6);
if (NS_FAILED(rv)) {
return rv;
}
WarnAboutTrailingData();
return NS_OK;
}
};
void
BluetoothDaemonGattModule::ServerRequestReadNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ServerRequestReadNotification::Dispatch(
&BluetoothGattServerNotificationHandler::RequestReadNotification,
ServerRequestReadInitOp(aPDU));
}
// Init operator class for ServerRequestWriteNotification
class BluetoothDaemonGattModule::ServerRequestWriteInitOp final
: private PDUInitOp
{
public:
ServerRequestWriteInitOp(DaemonSocketPDU& aPDU)
: PDUInitOp(aPDU)
{ }
nsresult
operator () (int& aArg1,
int& aArg2,
nsString& aArg3,
int& aArg4,
int& aArg5,
int& aArg6,
nsAutoArrayPtr<uint8_t>& aArg7,
bool& aArg8,
bool& aArg9) const
{
DaemonSocketPDU& pdu = GetPDU();
/* Read connection ID */
nsresult rv = UnpackPDU(pdu, aArg1);
if (NS_FAILED(rv)) {
return rv;
}
/* Read trans ID */
rv = UnpackPDU(pdu, aArg2);
if (NS_FAILED(rv)) {
return rv;
}
/* Read address */
rv = UnpackPDU(
pdu, UnpackConversion<BluetoothAddress, nsAString>(aArg3));
if (NS_FAILED(rv)) {
return rv;
}
/* Read attribute handle */
rv = UnpackPDU(pdu, aArg4);
if (NS_FAILED(rv)) {
return rv;
}
/* Read offset */
rv = UnpackPDU(pdu, aArg5);
if (NS_FAILED(rv)) {
return rv;
}
/* Read Length */
rv = UnpackPDU(pdu, aArg6);
if (NS_FAILED(rv)) {
return rv;
}
/* Read value */
rv = UnpackPDU(pdu,
UnpackArray<uint8_t>(aArg7, static_cast<size_t>(aArg6)));
if (NS_FAILED(rv)) {
return rv;
}
/* Read need response */
rv = UnpackPDU(pdu, aArg8);
if (NS_FAILED(rv)) {
return rv;
}
/* Read isPrepare */
rv = UnpackPDU(pdu, aArg9);
if (NS_FAILED(rv)) {
return rv;
}
WarnAboutTrailingData();
return NS_OK;
}
};
void
BluetoothDaemonGattModule::ServerRequestWriteNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ServerRequestWriteNotification::Dispatch(
&BluetoothGattServerNotificationHandler::RequestWriteNotification,
ServerRequestWriteInitOp(aPDU));
}
// Init operator class for ServerRequestExecuteWriteNotification
class BluetoothDaemonGattModule::ServerRequestExecuteWriteInitOp final
: private PDUInitOp
{
public:
ServerRequestExecuteWriteInitOp(DaemonSocketPDU& aPDU)
: PDUInitOp(aPDU)
{ }
nsresult
operator () (int& aArg1,
int& aArg2,
nsString& aArg3,
bool& aArg4) const
{
DaemonSocketPDU& pdu = GetPDU();
/* Read connection ID */
nsresult rv = UnpackPDU(pdu, aArg1);
if (NS_FAILED(rv)) {
return rv;
}
/* Read trans ID */
rv = UnpackPDU(pdu, aArg2);
if (NS_FAILED(rv)) {
return rv;
}
/* Read address */
rv = UnpackPDU(
pdu, UnpackConversion<BluetoothAddress, nsAString>(aArg3));
if (NS_FAILED(rv)) {
return rv;
}
/* Read execute write */
rv = UnpackPDU(pdu, aArg4);
if (NS_FAILED(rv)) {
return rv;
}
WarnAboutTrailingData();
return NS_OK;
}
};
void
BluetoothDaemonGattModule::ServerRequestExecuteWriteNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ServerRequestExecuteWriteNotification::Dispatch(
&BluetoothGattServerNotificationHandler::RequestExecuteWriteNotification,
ServerRequestExecuteWriteInitOp(aPDU));
}
void
BluetoothDaemonGattModule::ServerResponseConfirmationNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU)
{
ServerResponseConfirmationNotification::Dispatch(
&BluetoothGattServerNotificationHandler::ResponseConfirmationNotification,
UnpackPDUInitOp(aPDU));
}
void
BluetoothDaemonGattModule::HandleNtf(
const DaemonSocketPDUHeader& aHeader, DaemonSocketPDU& aPDU,
void* aUserData)
{
static void (BluetoothDaemonGattModule::* const HandleNtf[])(
const DaemonSocketPDUHeader&, DaemonSocketPDU&) = {
INIT_ARRAY_AT(0, &BluetoothDaemonGattModule::ClientRegisterNtf),
INIT_ARRAY_AT(1, &BluetoothDaemonGattModule::ClientScanResultNtf),
INIT_ARRAY_AT(2, &BluetoothDaemonGattModule::ClientConnectNtf),
INIT_ARRAY_AT(3, &BluetoothDaemonGattModule::ClientDisconnectNtf),
INIT_ARRAY_AT(4, &BluetoothDaemonGattModule::ClientSearchCompleteNtf),
INIT_ARRAY_AT(5, &BluetoothDaemonGattModule::ClientSearchResultNtf),
INIT_ARRAY_AT(6, &BluetoothDaemonGattModule::ClientGetCharacteristicNtf),
INIT_ARRAY_AT(7, &BluetoothDaemonGattModule::ClientGetDescriptorNtf),
INIT_ARRAY_AT(8, &BluetoothDaemonGattModule::ClientGetIncludedServiceNtf),
INIT_ARRAY_AT(9, &BluetoothDaemonGattModule::ClientRegisterNotificationNtf),
INIT_ARRAY_AT(10, &BluetoothDaemonGattModule::ClientNotifyNtf),
INIT_ARRAY_AT(11, &BluetoothDaemonGattModule::ClientReadCharacteristicNtf),
INIT_ARRAY_AT(12, &BluetoothDaemonGattModule::ClientWriteCharacteristicNtf),
INIT_ARRAY_AT(13, &BluetoothDaemonGattModule::ClientReadDescriptorNtf),
INIT_ARRAY_AT(14, &BluetoothDaemonGattModule::ClientWriteDescriptorNtf),
INIT_ARRAY_AT(15, &BluetoothDaemonGattModule::ClientExecuteWriteNtf),
INIT_ARRAY_AT(16, &BluetoothDaemonGattModule::ClientReadRemoteRssiNtf),
INIT_ARRAY_AT(17, &BluetoothDaemonGattModule::ClientListenNtf),
INIT_ARRAY_AT(18, &BluetoothDaemonGattModule::ServerRegisterNtf),
INIT_ARRAY_AT(19, &BluetoothDaemonGattModule::ServerConnectionNtf),
INIT_ARRAY_AT(20, &BluetoothDaemonGattModule::ServerServiceAddedNtf),
INIT_ARRAY_AT(21, &BluetoothDaemonGattModule::ServerIncludedServiceAddedNtf),
INIT_ARRAY_AT(22, &BluetoothDaemonGattModule::ServerCharacteristicAddedNtf),
INIT_ARRAY_AT(23, &BluetoothDaemonGattModule::ServerDescriptorAddedNtf),
INIT_ARRAY_AT(24, &BluetoothDaemonGattModule::ServerServiceStartedNtf),
INIT_ARRAY_AT(25, &BluetoothDaemonGattModule::ServerServiceStoppedNtf),
INIT_ARRAY_AT(26, &BluetoothDaemonGattModule::ServerServiceDeletedNtf),
INIT_ARRAY_AT(27, &BluetoothDaemonGattModule::ServerRequestReadNtf),
INIT_ARRAY_AT(28, &BluetoothDaemonGattModule::ServerRequestWriteNtf),
INIT_ARRAY_AT(29, &BluetoothDaemonGattModule::ServerRequestExecuteWriteNtf),
INIT_ARRAY_AT(30, &BluetoothDaemonGattModule::ServerResponseConfirmationNtf)
};
MOZ_ASSERT(!NS_IsMainThread());
uint8_t index = aHeader.mOpcode - 0x81;
if (NS_WARN_IF(!(index < MOZ_ARRAY_LENGTH(HandleNtf))) ||
NS_WARN_IF(!HandleNtf[index])) {
return;
}
(this->*(HandleNtf[index]))(aHeader, aPDU);
}
//
// Gatt interface
//
BluetoothDaemonGattClientInterface::BluetoothDaemonGattClientInterface(
BluetoothDaemonGattModule* aModule)
: mModule(aModule)
{ }
BluetoothDaemonGattServerInterface::BluetoothDaemonGattServerInterface(
BluetoothDaemonGattModule* aModule)
: mModule(aModule)
{ }
BluetoothDaemonGattInterface::BluetoothDaemonGattInterface(
BluetoothDaemonGattModule* aModule)
: mModule(aModule)
{ }
BluetoothDaemonGattInterface::~BluetoothDaemonGattInterface()
{ }
class BluetoothDaemonGattInterface::InitResultHandler final
: public BluetoothSetupResultHandler
{
public:
InitResultHandler(BluetoothGattResultHandler* aRes)
: mRes(aRes)
{
MOZ_ASSERT(mRes);
}
void OnError(BluetoothStatus aStatus) override
{
MOZ_ASSERT(NS_IsMainThread());
mRes->OnError(aStatus);
}
void RegisterModule() override
{
MOZ_ASSERT(NS_IsMainThread());
mRes->Init();
}
private:
nsRefPtr<BluetoothGattResultHandler> mRes;
};
void
BluetoothDaemonGattInterface::Init(
BluetoothGattNotificationHandler* aNotificationHandler,
BluetoothGattResultHandler* aRes)
{
// Set notification handler _before_ registering the module. It could
// happen that we receive notifications, before the result handler runs.
mModule->SetNotificationHandler(aNotificationHandler);
InitResultHandler* res;
if (aRes) {
res = new InitResultHandler(aRes);
} else {
// We don't need a result handler if the caller is not interested.
res = nullptr;
}
nsresult rv = mModule->RegisterModule(
BluetoothDaemonGattModule::SERVICE_ID, 0x00,
BluetoothDaemonGattModule::MAX_NUM_CLIENTS, res);
if (NS_FAILED(rv) && aRes) {
DispatchError(aRes, rv);
}
}
class BluetoothDaemonGattInterface::CleanupResultHandler final
: public BluetoothSetupResultHandler
{
public:
CleanupResultHandler(BluetoothDaemonGattModule* aModule,
BluetoothGattResultHandler* aRes)
: mModule(aModule)
, mRes(aRes)
{
MOZ_ASSERT(mModule);
}
void OnError(BluetoothStatus aStatus) override
{
MOZ_ASSERT(NS_IsMainThread());
if (mRes) {
mRes->OnError(aStatus);
}
}
void UnregisterModule() override
{
MOZ_ASSERT(NS_IsMainThread());
// Clear notification handler _after_ module has been
// unregistered. While unregistering the module, we might
// still receive notifications.
mModule->SetNotificationHandler(nullptr);
if (mRes) {
mRes->Cleanup();
}
}
private:
BluetoothDaemonGattModule* mModule;
nsRefPtr<BluetoothGattResultHandler> mRes;
};
void
BluetoothDaemonGattInterface::Cleanup(
BluetoothGattResultHandler* aRes)
{
nsresult rv = mModule->UnregisterModule(
BluetoothDaemonGattModule::SERVICE_ID,
new CleanupResultHandler(mModule, aRes));
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
/* Register / Unregister */
void
BluetoothDaemonGattClientInterface::RegisterClient(
const BluetoothUuid& aUuid, BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientRegisterCmd(aUuid, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattClientInterface::UnregisterClient(
int aClientIf, BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientUnregisterCmd(aClientIf, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
/* Start / Stop LE Scan */
void
BluetoothDaemonGattClientInterface::Scan(
int aClientIf, bool aStart, BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientScanCmd(aClientIf, aStart, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
/* Connect / Disconnect */
void
BluetoothDaemonGattClientInterface::Connect(
int aClientIf, const nsAString& aBdAddr, bool aIsDirect,
BluetoothTransport aTransport, BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientConnectCmd(
aClientIf, aBdAddr, aIsDirect, aTransport, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattClientInterface::Disconnect(
int aClientIf, const nsAString& aBdAddr, int aConnId,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientDisconnectCmd(
aClientIf, aBdAddr, aConnId, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
/* Start / Stop advertisements to listen for incoming connections */
void
BluetoothDaemonGattClientInterface::Listen(
int aClientIf, bool aIsStart, BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientListenCmd(aClientIf, aIsStart, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
/* Clear the attribute cache for a given device*/
void
BluetoothDaemonGattClientInterface::Refresh(
int aClientIf, const nsAString& aBdAddr, BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientRefreshCmd(aClientIf, aBdAddr, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
/* Enumerate Attributes */
void
BluetoothDaemonGattClientInterface::SearchService(
int aConnId, bool aSearchAll, const BluetoothUuid& aUuid,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientSearchServiceCmd(
aConnId, !aSearchAll /* Filtered */, aUuid, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattClientInterface::GetIncludedService(
int aConnId, const BluetoothGattServiceId& aServiceId, bool aFirst,
const BluetoothGattServiceId& aStartServiceId,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientGetIncludedServiceCmd(
aConnId, aServiceId, !aFirst /* Continuation */, aStartServiceId, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattClientInterface::GetCharacteristic(
int aConnId, const BluetoothGattServiceId& aServiceId, bool aFirst,
const BluetoothGattId& aStartCharId, BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientGetCharacteristicCmd(
aConnId, aServiceId, !aFirst /* Continuation */, aStartCharId, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattClientInterface::GetDescriptor(
int aConnId, const BluetoothGattServiceId& aServiceId,
const BluetoothGattId& aCharId, bool aFirst,
const BluetoothGattId& aDescriptorId, BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientGetDescriptorCmd(
aConnId, aServiceId, aCharId, !aFirst /* Continuation */, aDescriptorId,
aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
/* Read / Write An Attribute */
void
BluetoothDaemonGattClientInterface::ReadCharacteristic(
int aConnId, const BluetoothGattServiceId& aServiceId,
const BluetoothGattId& aCharId, BluetoothGattAuthReq aAuthReq,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientReadCharacteristicCmd(
aConnId, aServiceId, aCharId, aAuthReq, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattClientInterface::WriteCharacteristic(
int aConnId, const BluetoothGattServiceId& aServiceId,
const BluetoothGattId& aCharId, BluetoothGattWriteType aWriteType,
BluetoothGattAuthReq aAuthReq, const nsTArray<uint8_t>& aValue,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientWriteCharacteristicCmd(
aConnId, aServiceId, aCharId, aWriteType,
aValue.Length() * sizeof(uint8_t), aAuthReq,
reinterpret_cast<char*>(const_cast<uint8_t*>(aValue.Elements())), aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattClientInterface::ReadDescriptor(
int aConnId, const BluetoothGattServiceId& aServiceId,
const BluetoothGattId& aCharId, const BluetoothGattId& aDescriptorId,
BluetoothGattAuthReq aAuthReq, BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientReadDescriptorCmd(
aConnId, aServiceId, aCharId, aDescriptorId, aAuthReq, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattClientInterface::WriteDescriptor(
int aConnId, const BluetoothGattServiceId& aServiceId,
const BluetoothGattId& aCharId, const BluetoothGattId& aDescriptorId,
BluetoothGattWriteType aWriteType, BluetoothGattAuthReq aAuthReq,
const nsTArray<uint8_t>& aValue, BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientWriteDescriptorCmd(
aConnId, aServiceId, aCharId, aDescriptorId, aWriteType,
aValue.Length() * sizeof(uint8_t), aAuthReq,
reinterpret_cast<char*>(const_cast<uint8_t*>(aValue.Elements())), aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
/* Execute / Abort Prepared Write*/
void
BluetoothDaemonGattClientInterface::ExecuteWrite(
int aConnId, int aIsExecute, BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientExecuteWriteCmd(aConnId, aIsExecute, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
/* Register / Deregister Characteristic Notifications or Indications */
void
BluetoothDaemonGattClientInterface::RegisterNotification(
int aClientIf, const nsAString& aBdAddr,
const BluetoothGattServiceId& aServiceId, const BluetoothGattId& aCharId,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientRegisterNotificationCmd(
aClientIf, aBdAddr, aServiceId, aCharId, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattClientInterface::DeregisterNotification(
int aClientIf, const nsAString& aBdAddr,
const BluetoothGattServiceId& aServiceId, const BluetoothGattId& aCharId,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientDeregisterNotificationCmd(
aClientIf, aBdAddr, aServiceId, aCharId, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattClientInterface::ReadRemoteRssi(
int aClientIf, const nsAString& aBdAddr,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientReadRemoteRssiCmd(
aClientIf, aBdAddr, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattClientInterface::GetDeviceType(
const nsAString& aBdAddr, BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientGetDeviceTypeCmd(aBdAddr, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattClientInterface::SetAdvData(
int aServerIf, bool aIsScanRsp, bool aIsNameIncluded,
bool aIsTxPowerIncluded, int aMinInterval, int aMaxInterval, int aApperance,
uint16_t aManufacturerLen, char* aManufacturerData,
uint16_t aServiceDataLen, char* aServiceData,
uint16_t aServiceUUIDLen, char* aServiceUUID,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientSetAdvDataCmd(
aServerIf, aIsScanRsp, aIsNameIncluded, aIsTxPowerIncluded, aMinInterval,
aMaxInterval, aApperance, aManufacturerLen, aManufacturerData,
aServiceDataLen, aServiceData, aServiceUUIDLen, aServiceUUID, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattClientInterface::TestCommand(
int aCommand, const BluetoothGattTestParam& aTestParam,
BluetoothGattClientResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ClientTestCommandCmd(aCommand, aTestParam, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
/* Register / Unregister */
void
BluetoothDaemonGattServerInterface::RegisterServer(
const BluetoothUuid& aUuid, BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ServerRegisterCmd(aUuid, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattServerInterface::UnregisterServer(
int aServerIf, BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ServerUnregisterCmd(aServerIf, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
/* Connect / Disconnect */
void
BluetoothDaemonGattServerInterface::ConnectPeripheral(
int aServerIf, const nsAString& aBdAddr, bool aIsDirect, /* auto connect */
BluetoothTransport aTransport, BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ServerConnectPeripheralCmd(
aServerIf, aBdAddr, aIsDirect, aTransport, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattServerInterface::DisconnectPeripheral(
int aServerIf, const nsAString& aBdAddr, int aConnId,
BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ServerDisconnectPeripheralCmd(
aServerIf, aBdAddr, aConnId, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
/* Add a services / a characteristic / a descriptor */
void
BluetoothDaemonGattServerInterface::AddService(
int aServerIf, const BluetoothGattServiceId& aServiceId, int aNumHandles,
BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ServerAddServiceCmd(
aServerIf, aServiceId, aNumHandles, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattServerInterface::AddIncludedService(
int aServerIf, int aServiceHandle, int aIncludedServiceHandle,
BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ServerAddIncludedServiceCmd(
aServerIf, aServiceHandle, aIncludedServiceHandle, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattServerInterface::AddCharacteristic(
int aServerIf, int aServiceHandle, const BluetoothUuid& aUuid,
BluetoothGattCharProp aProperties, BluetoothGattAttrPerm aPermissions,
BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ServerAddCharacteristicCmd(
aServerIf, aServiceHandle, aUuid, aProperties, aPermissions, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattServerInterface::AddDescriptor(
int aServerIf, int aServiceHandle, const BluetoothUuid& aUuid,
BluetoothGattAttrPerm aPermissions, BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ServerAddDescriptorCmd(
aServerIf, aServiceHandle, aUuid, aPermissions, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
/* Start / Stop / Delete a service */
void
BluetoothDaemonGattServerInterface::StartService(
int aServerIf, int aServiceHandle, BluetoothTransport aTransport,
BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ServerStartServiceCmd(
aServerIf, aServiceHandle, aTransport, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattServerInterface::StopService(
int aServerIf, int aServiceHandle, BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ServerStopServiceCmd(aServerIf, aServiceHandle, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattServerInterface::DeleteService(
int aServerIf, int aServiceHandle, BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ServerDeleteServiceCmd(
aServerIf, aServiceHandle, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattServerInterface::SendIndication(
int aServerIf, int aAttributeHandle, int aConnId,
const nsTArray<uint8_t>& aValue, bool aConfirm,
BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ServerSendIndicationCmd(
aServerIf, aAttributeHandle, aConnId,
aValue.Length() * sizeof(uint8_t), aConfirm,
const_cast<uint8_t*>(aValue.Elements()), aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattServerInterface::SendResponse(
int aConnId, int aTransId, BluetoothGattStatus aStatus,
const BluetoothGattResponse& aResponse,
BluetoothGattServerResultHandler* aRes)
{
MOZ_ASSERT(mModule);
nsresult rv = mModule->ServerSendResponseCmd(
aConnId, aTransId, aStatus, aResponse, aRes);
if (NS_FAILED(rv)) {
DispatchError(aRes, rv);
}
}
void
BluetoothDaemonGattClientInterface::DispatchError(
BluetoothGattClientResultHandler* aRes, BluetoothStatus aStatus)
{
BluetoothResultRunnable1<BluetoothGattClientResultHandler, void,
BluetoothStatus, BluetoothStatus>::Dispatch(
aRes, &BluetoothGattResultHandler::OnError,
ConstantInitOp1<BluetoothStatus>(aStatus));
}
void
BluetoothDaemonGattClientInterface::DispatchError(
BluetoothGattClientResultHandler* aRes, nsresult aRv)
{
BluetoothStatus status;
if (NS_WARN_IF(NS_FAILED(Convert(aRv, status)))) {
status = STATUS_FAIL;
}
DispatchError(aRes, status);
}
void
BluetoothDaemonGattServerInterface::DispatchError(
BluetoothGattServerResultHandler* aRes, BluetoothStatus aStatus)
{
BluetoothResultRunnable1<BluetoothGattServerResultHandler, void,
BluetoothStatus, BluetoothStatus>::Dispatch(
aRes, &BluetoothGattResultHandler::OnError,
ConstantInitOp1<BluetoothStatus>(aStatus));
}
void
BluetoothDaemonGattServerInterface::DispatchError(
BluetoothGattServerResultHandler* aRes, nsresult aRv)
{
BluetoothStatus status;
if (NS_WARN_IF(NS_FAILED(Convert(aRv, status)))) {
status = STATUS_FAIL;
}
DispatchError(aRes, status);
}
void
BluetoothDaemonGattInterface::DispatchError(
BluetoothGattResultHandler* aRes, BluetoothStatus aStatus)
{
BluetoothResultRunnable1<BluetoothGattResultHandler, void,
BluetoothStatus, BluetoothStatus>::Dispatch(
aRes, &BluetoothGattResultHandler::OnError,
ConstantInitOp1<BluetoothStatus>(aStatus));
}
void
BluetoothDaemonGattInterface::DispatchError(
BluetoothGattResultHandler* aRes, nsresult aRv)
{
BluetoothStatus status;
if (NS_WARN_IF(NS_FAILED(Convert(aRv, status)))) {
status = STATUS_FAIL;
}
DispatchError(aRes, status);
}
BluetoothGattClientInterface*
BluetoothDaemonGattInterface::GetBluetoothGattClientInterface()
{
MOZ_ASSERT(mModule);
BluetoothDaemonGattClientInterface* gattClientInterface =
new BluetoothDaemonGattClientInterface(mModule);
return gattClientInterface;
}
BluetoothGattServerInterface*
BluetoothDaemonGattInterface::GetBluetoothGattServerInterface()
{
MOZ_ASSERT(mModule);
BluetoothDaemonGattServerInterface* gattServerInterface =
new BluetoothDaemonGattServerInterface(mModule);
return gattServerInterface;
}
END_BLUETOOTH_NAMESPACE
Reference in New Issue View Git Blame Copy Permalink