mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-30 21:55:31 +00:00
1060 lines
28 KiB
C++
1060 lines
28 KiB
C++
/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
|
|
/* vim: set ts=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 "BluetoothDaemonAvrcpInterface.h"
|
|
#include "BluetoothDaemonSetupInterface.h"
|
|
#include "mozilla/unused.h"
|
|
|
|
BEGIN_BLUETOOTH_NAMESPACE
|
|
|
|
//
|
|
// AVRCP module
|
|
//
|
|
|
|
const int BluetoothDaemonAvrcpModule::MAX_NUM_CLIENTS = 1;
|
|
|
|
BluetoothAvrcpNotificationHandler*
|
|
BluetoothDaemonAvrcpModule::sNotificationHandler;
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::SetNotificationHandler(
|
|
BluetoothAvrcpNotificationHandler* aNotificationHandler)
|
|
{
|
|
sNotificationHandler = aNotificationHandler;
|
|
}
|
|
|
|
nsresult
|
|
BluetoothDaemonAvrcpModule::Send(BluetoothDaemonPDU* aPDU,
|
|
BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
if (aRes) {
|
|
aRes->AddRef(); // Keep reference for response
|
|
}
|
|
return Send(aPDU, static_cast<void*>(aRes));
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::HandleSvc(const BluetoothDaemonPDUHeader& aHeader,
|
|
BluetoothDaemonPDU& aPDU, void* aUserData)
|
|
{
|
|
static void (BluetoothDaemonAvrcpModule::* const HandleOp[])(
|
|
const BluetoothDaemonPDUHeader&, BluetoothDaemonPDU&, void*) = {
|
|
INIT_ARRAY_AT(0, &BluetoothDaemonAvrcpModule::HandleRsp),
|
|
INIT_ARRAY_AT(1, &BluetoothDaemonAvrcpModule::HandleNtf),
|
|
};
|
|
|
|
MOZ_ASSERT(!NS_IsMainThread());
|
|
|
|
unsigned int isNtf = !!(aHeader.mOpcode & 0x80);
|
|
|
|
(this->*(HandleOp[isNtf]))(aHeader, aPDU, aUserData);
|
|
}
|
|
|
|
// Commands
|
|
//
|
|
|
|
nsresult
|
|
BluetoothDaemonAvrcpModule::GetPlayStatusRspCmd(
|
|
ControlPlayStatus aPlayStatus, uint32_t aSongLen, uint32_t aSongPos,
|
|
BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
nsAutoPtr<BluetoothDaemonPDU> pdu(
|
|
new BluetoothDaemonPDU(SERVICE_ID, OPCODE_GET_PLAY_STATUS_RSP,
|
|
1 + // Play status
|
|
4 + // Duration
|
|
4)); // Position
|
|
|
|
nsresult rv = PackPDU(aPlayStatus, aSongLen, aSongPos, *pdu);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
rv = Send(pdu, aRes);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
unused << pdu.forget();
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
BluetoothDaemonAvrcpModule::ListPlayerAppAttrRspCmd(
|
|
int aNumAttr, const BluetoothAvrcpPlayerAttribute* aPAttrs,
|
|
BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
nsAutoPtr<BluetoothDaemonPDU> pdu(
|
|
new BluetoothDaemonPDU(SERVICE_ID, OPCODE_LIST_PLAYER_APP_ATTR_RSP,
|
|
1 + // # Attributes
|
|
aNumAttr)); // Player attributes
|
|
|
|
nsresult rv = PackPDU(
|
|
PackConversion<int, uint8_t>(aNumAttr),
|
|
PackArray<BluetoothAvrcpPlayerAttribute>(aPAttrs, aNumAttr), *pdu);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
rv = Send(pdu, aRes);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
unused << pdu.forget();
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
BluetoothDaemonAvrcpModule::ListPlayerAppValueRspCmd(
|
|
int aNumVal, uint8_t* aPVals, BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
nsAutoPtr<BluetoothDaemonPDU> pdu(
|
|
new BluetoothDaemonPDU(SERVICE_ID, OPCODE_LIST_PLAYER_APP_VALUE_RSP,
|
|
1 + // # Values
|
|
aNumVal)); // Player values
|
|
|
|
nsresult rv = PackPDU(PackConversion<int, uint8_t>(aNumVal),
|
|
PackArray<uint8_t>(aPVals, aNumVal), *pdu);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
rv = Send(pdu, aRes);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
unused << pdu.forget();
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
BluetoothDaemonAvrcpModule::GetPlayerAppValueRspCmd(
|
|
uint8_t aNumAttrs, const uint8_t* aIds, const uint8_t* aValues,
|
|
BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
nsAutoPtr<BluetoothDaemonPDU> pdu(
|
|
new BluetoothDaemonPDU(SERVICE_ID, OPCODE_GET_PLAYER_APP_VALUE_RSP,
|
|
1 + // # Pairs
|
|
2 * aNumAttrs)); // Attribute-value pairs
|
|
nsresult rv = PackPDU(
|
|
aNumAttrs,
|
|
BluetoothAvrcpAttributeValuePairs(aIds, aValues, aNumAttrs), *pdu);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
rv = Send(pdu, aRes);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
unused << pdu.forget();
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
BluetoothDaemonAvrcpModule::GetPlayerAppAttrTextRspCmd(
|
|
int aNumAttr, const uint8_t* aIds, const char** aTexts,
|
|
BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
nsAutoPtr<BluetoothDaemonPDU> pdu(
|
|
new BluetoothDaemonPDU(SERVICE_ID, OPCODE_GET_PLAYER_APP_ATTR_TEXT_RSP,
|
|
0)); // Dynamically allocated
|
|
nsresult rv = PackPDU(
|
|
PackConversion<int, uint8_t>(aNumAttr),
|
|
BluetoothAvrcpAttributeTextPairs(aIds, aTexts, aNumAttr), *pdu);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
rv = Send(pdu, aRes);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
unused << pdu.forget();
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
BluetoothDaemonAvrcpModule::GetPlayerAppValueTextRspCmd(
|
|
int aNumVal, const uint8_t* aIds, const char** aTexts,
|
|
BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
nsAutoPtr<BluetoothDaemonPDU> pdu(
|
|
new BluetoothDaemonPDU(SERVICE_ID, OPCODE_GET_PLAYER_APP_VALUE_TEXT_RSP,
|
|
0)); // Dynamically allocated
|
|
nsresult rv = PackPDU(
|
|
PackConversion<int, uint8_t>(aNumVal),
|
|
BluetoothAvrcpAttributeTextPairs(aIds, aTexts, aNumVal), *pdu);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
rv = Send(pdu, aRes);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
unused << pdu.forget();
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
BluetoothDaemonAvrcpModule::GetElementAttrRspCmd(
|
|
uint8_t aNumAttr, const BluetoothAvrcpElementAttribute* aAttr,
|
|
BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
nsAutoPtr<BluetoothDaemonPDU> pdu(
|
|
new BluetoothDaemonPDU(SERVICE_ID, OPCODE_GET_ELEMENT_ATTR_RSP,
|
|
0)); // Dynamically allocated
|
|
nsresult rv = PackPDU(
|
|
aNumAttr,
|
|
PackArray<BluetoothAvrcpElementAttribute>(aAttr, aNumAttr), *pdu);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
rv = Send(pdu, aRes);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
unused << pdu.forget();
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
BluetoothDaemonAvrcpModule::SetPlayerAppValueRspCmd(
|
|
BluetoothAvrcpStatus aRspStatus, BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
nsAutoPtr<BluetoothDaemonPDU> pdu(
|
|
new BluetoothDaemonPDU(SERVICE_ID, OPCODE_SET_PLAYER_APP_VALUE_RSP,
|
|
1)); // Status code
|
|
|
|
nsresult rv = PackPDU(aRspStatus, *pdu);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
rv = Send(pdu, aRes);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
unused << pdu.forget();
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
BluetoothDaemonAvrcpModule::RegisterNotificationRspCmd(
|
|
BluetoothAvrcpEvent aEvent, BluetoothAvrcpNotification aType,
|
|
const BluetoothAvrcpNotificationParam& aParam,
|
|
BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
nsAutoPtr<BluetoothDaemonPDU> pdu(
|
|
new BluetoothDaemonPDU(SERVICE_ID, OPCODE_REGISTER_NOTIFICATION_RSP,
|
|
1 + // Event
|
|
1 + // Type
|
|
1 + // Data length
|
|
256)); // Maximum data length
|
|
|
|
nsresult rv = PackPDU(aEvent, aType,
|
|
BluetoothAvrcpEventParamPair(aEvent, aParam), *pdu);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
rv = Send(pdu, aRes);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
unused << pdu.forget();
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
BluetoothDaemonAvrcpModule::SetVolumeCmd(uint8_t aVolume,
|
|
BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
nsAutoPtr<BluetoothDaemonPDU> pdu(
|
|
new BluetoothDaemonPDU(SERVICE_ID, OPCODE_SET_VOLUME,
|
|
1)); // Volume
|
|
|
|
nsresult rv = PackPDU(aVolume, *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
|
|
BluetoothDaemonAvrcpModule::ErrorRsp(
|
|
const BluetoothDaemonPDUHeader& aHeader,
|
|
BluetoothDaemonPDU& aPDU, BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
ErrorRunnable::Dispatch(
|
|
aRes, &BluetoothAvrcpResultHandler::OnError, UnpackPDUInitOp(aPDU));
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::GetPlayStatusRspRsp(
|
|
const BluetoothDaemonPDUHeader& aHeader,
|
|
BluetoothDaemonPDU& aPDU, BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
ResultRunnable::Dispatch(
|
|
aRes, &BluetoothAvrcpResultHandler::GetPlayStatusRsp,
|
|
UnpackPDUInitOp(aPDU));
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::ListPlayerAppAttrRspRsp(
|
|
const BluetoothDaemonPDUHeader& aHeader,
|
|
BluetoothDaemonPDU& aPDU, BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
ResultRunnable::Dispatch(
|
|
aRes, &BluetoothAvrcpResultHandler::ListPlayerAppAttrRsp,
|
|
UnpackPDUInitOp(aPDU));
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::ListPlayerAppValueRspRsp(
|
|
const BluetoothDaemonPDUHeader& aHeader,
|
|
BluetoothDaemonPDU& aPDU, BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
ResultRunnable::Dispatch(
|
|
aRes, &BluetoothAvrcpResultHandler::ListPlayerAppValueRsp,
|
|
UnpackPDUInitOp(aPDU));
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::GetPlayerAppValueRspRsp(
|
|
const BluetoothDaemonPDUHeader& aHeader,
|
|
BluetoothDaemonPDU& aPDU, BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
ResultRunnable::Dispatch(
|
|
aRes, &BluetoothAvrcpResultHandler::GetPlayerAppValueRsp,
|
|
UnpackPDUInitOp(aPDU));
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::GetPlayerAppAttrTextRspRsp(
|
|
const BluetoothDaemonPDUHeader& aHeader,
|
|
BluetoothDaemonPDU& aPDU, BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
ResultRunnable::Dispatch(
|
|
aRes, &BluetoothAvrcpResultHandler::GetPlayerAppAttrTextRsp,
|
|
UnpackPDUInitOp(aPDU));
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::GetPlayerAppValueTextRspRsp(
|
|
const BluetoothDaemonPDUHeader& aHeader,
|
|
BluetoothDaemonPDU& aPDU, BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
ResultRunnable::Dispatch(
|
|
aRes, &BluetoothAvrcpResultHandler::GetPlayerAppValueTextRsp,
|
|
UnpackPDUInitOp(aPDU));
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::GetElementAttrRspRsp(
|
|
const BluetoothDaemonPDUHeader& aHeader,
|
|
BluetoothDaemonPDU& aPDU, BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
ResultRunnable::Dispatch(
|
|
aRes, &BluetoothAvrcpResultHandler::GetElementAttrRsp,
|
|
UnpackPDUInitOp(aPDU));
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::SetPlayerAppValueRspRsp(
|
|
const BluetoothDaemonPDUHeader& aHeader,
|
|
BluetoothDaemonPDU& aPDU, BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
ResultRunnable::Dispatch(
|
|
aRes, &BluetoothAvrcpResultHandler::SetPlayerAppValueRsp,
|
|
UnpackPDUInitOp(aPDU));
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::RegisterNotificationRspRsp(
|
|
const BluetoothDaemonPDUHeader& aHeader,
|
|
BluetoothDaemonPDU& aPDU, BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
ResultRunnable::Dispatch(
|
|
aRes, &BluetoothAvrcpResultHandler::RegisterNotificationRsp,
|
|
UnpackPDUInitOp(aPDU));
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::SetVolumeRsp(
|
|
const BluetoothDaemonPDUHeader& aHeader,
|
|
BluetoothDaemonPDU& aPDU, BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
ResultRunnable::Dispatch(
|
|
aRes, &BluetoothAvrcpResultHandler::SetVolume,
|
|
UnpackPDUInitOp(aPDU));
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::HandleRsp(
|
|
const BluetoothDaemonPDUHeader& aHeader, BluetoothDaemonPDU& aPDU,
|
|
void* aUserData)
|
|
{
|
|
static void (BluetoothDaemonAvrcpModule::* const HandleRsp[])(
|
|
const BluetoothDaemonPDUHeader&,
|
|
BluetoothDaemonPDU&,
|
|
BluetoothAvrcpResultHandler*) = {
|
|
INIT_ARRAY_AT(OPCODE_ERROR,
|
|
&BluetoothDaemonAvrcpModule::ErrorRsp),
|
|
INIT_ARRAY_AT(OPCODE_GET_PLAY_STATUS_RSP,
|
|
&BluetoothDaemonAvrcpModule::GetPlayStatusRspRsp),
|
|
INIT_ARRAY_AT(OPCODE_LIST_PLAYER_APP_ATTR_RSP,
|
|
&BluetoothDaemonAvrcpModule::ListPlayerAppAttrRspRsp),
|
|
INIT_ARRAY_AT(OPCODE_LIST_PLAYER_APP_VALUE_RSP,
|
|
&BluetoothDaemonAvrcpModule::ListPlayerAppValueRspRsp),
|
|
INIT_ARRAY_AT(OPCODE_GET_PLAYER_APP_VALUE_RSP,
|
|
&BluetoothDaemonAvrcpModule::GetPlayerAppValueRspRsp),
|
|
INIT_ARRAY_AT(OPCODE_GET_PLAYER_APP_ATTR_TEXT_RSP,
|
|
&BluetoothDaemonAvrcpModule::GetPlayerAppAttrTextRspRsp),
|
|
INIT_ARRAY_AT(OPCODE_GET_PLAYER_APP_VALUE_TEXT_RSP,
|
|
&BluetoothDaemonAvrcpModule::GetPlayerAppValueTextRspRsp),
|
|
INIT_ARRAY_AT(OPCODE_GET_ELEMENT_ATTR_RSP,
|
|
&BluetoothDaemonAvrcpModule::GetElementAttrRspRsp),
|
|
INIT_ARRAY_AT(OPCODE_SET_PLAYER_APP_VALUE_RSP,
|
|
&BluetoothDaemonAvrcpModule::SetPlayerAppValueRspRsp),
|
|
INIT_ARRAY_AT(OPCODE_REGISTER_NOTIFICATION_RSP,
|
|
&BluetoothDaemonAvrcpModule::RegisterNotificationRspRsp),
|
|
INIT_ARRAY_AT(OPCODE_SET_VOLUME,
|
|
&BluetoothDaemonAvrcpModule::SetVolumeRsp)
|
|
};
|
|
|
|
MOZ_ASSERT(!NS_IsMainThread()); // I/O thread
|
|
|
|
if (NS_WARN_IF(!(aHeader.mOpcode < MOZ_ARRAY_LENGTH(HandleRsp))) ||
|
|
NS_WARN_IF(!HandleRsp[aHeader.mOpcode])) {
|
|
return;
|
|
}
|
|
|
|
nsRefPtr<BluetoothAvrcpResultHandler> res =
|
|
already_AddRefed<BluetoothAvrcpResultHandler>(
|
|
static_cast<BluetoothAvrcpResultHandler*>(aUserData));
|
|
|
|
if (!res) {
|
|
return; // Return early if no result handler has been set for response
|
|
}
|
|
|
|
(this->*(HandleRsp[aHeader.mOpcode]))(aHeader, aPDU, res);
|
|
}
|
|
|
|
// Notifications
|
|
//
|
|
|
|
// Returns the current notification handler to a notification runnable
|
|
class BluetoothDaemonAvrcpModule::NotificationHandlerWrapper MOZ_FINAL
|
|
{
|
|
public:
|
|
typedef BluetoothAvrcpNotificationHandler ObjectType;
|
|
|
|
static ObjectType* GetInstance()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
return sNotificationHandler;
|
|
}
|
|
};
|
|
|
|
// Init operator class for RemoteFeatureNotification
|
|
class BluetoothDaemonAvrcpModule::RemoteFeatureInitOp MOZ_FINAL
|
|
: private PDUInitOp
|
|
{
|
|
public:
|
|
RemoteFeatureInitOp(BluetoothDaemonPDU& aPDU)
|
|
: PDUInitOp(aPDU)
|
|
{ }
|
|
|
|
nsresult
|
|
operator () (nsString& aArg1, unsigned long& aArg2) const
|
|
{
|
|
BluetoothDaemonPDU& pdu = GetPDU();
|
|
|
|
/* Read address */
|
|
nsresult rv = UnpackPDU(
|
|
pdu, UnpackConversion<BluetoothAddress, nsAString>(aArg1));
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
/* Read feature */
|
|
rv = UnpackPDU(
|
|
pdu,
|
|
UnpackConversion<BluetoothAvrcpRemoteFeature, unsigned long>(aArg2));
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
WarnAboutTrailingData();
|
|
return NS_OK;
|
|
}
|
|
};
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::RemoteFeatureNtf(
|
|
const BluetoothDaemonPDUHeader& aHeader, BluetoothDaemonPDU& aPDU)
|
|
{
|
|
RemoteFeatureNotification::Dispatch(
|
|
&BluetoothAvrcpNotificationHandler::RemoteFeatureNotification,
|
|
RemoteFeatureInitOp(aPDU));
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::GetPlayStatusNtf(
|
|
const BluetoothDaemonPDUHeader& aHeader, BluetoothDaemonPDU& aPDU)
|
|
{
|
|
GetPlayStatusNotification::Dispatch(
|
|
&BluetoothAvrcpNotificationHandler::GetPlayStatusNotification,
|
|
UnpackPDUInitOp(aPDU));
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::ListPlayerAppAttrNtf(
|
|
const BluetoothDaemonPDUHeader& aHeader, BluetoothDaemonPDU& aPDU)
|
|
{
|
|
ListPlayerAppAttrNotification::Dispatch(
|
|
&BluetoothAvrcpNotificationHandler::ListPlayerAppAttrNotification,
|
|
UnpackPDUInitOp(aPDU));
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::ListPlayerAppValuesNtf(
|
|
const BluetoothDaemonPDUHeader& aHeader, BluetoothDaemonPDU& aPDU)
|
|
{
|
|
ListPlayerAppValuesNotification::Dispatch(
|
|
&BluetoothAvrcpNotificationHandler::ListPlayerAppValuesNotification,
|
|
UnpackPDUInitOp(aPDU));
|
|
}
|
|
|
|
// Init operator class for GetPlayerAppValueNotification
|
|
class BluetoothDaemonAvrcpModule::GetPlayerAppValueInitOp MOZ_FINAL
|
|
: private PDUInitOp
|
|
{
|
|
public:
|
|
GetPlayerAppValueInitOp(BluetoothDaemonPDU& aPDU)
|
|
: PDUInitOp(aPDU)
|
|
{ }
|
|
|
|
nsresult
|
|
operator () (uint8_t& aArg1,
|
|
nsAutoArrayPtr<BluetoothAvrcpPlayerAttribute>& aArg2) const
|
|
{
|
|
BluetoothDaemonPDU& pdu = GetPDU();
|
|
|
|
/* Read number of attributes */
|
|
nsresult rv = UnpackPDU(pdu, aArg1);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
/* Read attributes */
|
|
rv = UnpackPDU(
|
|
pdu, UnpackArray<BluetoothAvrcpPlayerAttribute>(aArg2, aArg1));
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
WarnAboutTrailingData();
|
|
return NS_OK;
|
|
}
|
|
};
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::GetPlayerAppValueNtf(
|
|
const BluetoothDaemonPDUHeader& aHeader, BluetoothDaemonPDU& aPDU)
|
|
{
|
|
GetPlayerAppValueNotification::Dispatch(
|
|
&BluetoothAvrcpNotificationHandler::GetPlayerAppValueNotification,
|
|
GetPlayerAppValueInitOp(aPDU));
|
|
}
|
|
|
|
// Init operator class for GetPlayerAppAttrsTextNotification
|
|
class BluetoothDaemonAvrcpModule::GetPlayerAppAttrsTextInitOp MOZ_FINAL
|
|
: private PDUInitOp
|
|
{
|
|
public:
|
|
GetPlayerAppAttrsTextInitOp(BluetoothDaemonPDU& aPDU)
|
|
: PDUInitOp(aPDU)
|
|
{ }
|
|
|
|
nsresult
|
|
operator () (uint8_t& aArg1,
|
|
nsAutoArrayPtr<BluetoothAvrcpPlayerAttribute>& aArg2) const
|
|
{
|
|
BluetoothDaemonPDU& pdu = GetPDU();
|
|
|
|
/* Read number of attributes */
|
|
nsresult rv = UnpackPDU(pdu, aArg1);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
/* Read attributes */
|
|
rv = UnpackPDU(
|
|
pdu, UnpackArray<BluetoothAvrcpPlayerAttribute>(aArg2, aArg1));
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
WarnAboutTrailingData();
|
|
return NS_OK;
|
|
}
|
|
};
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::GetPlayerAppAttrsTextNtf(
|
|
const BluetoothDaemonPDUHeader& aHeader, BluetoothDaemonPDU& aPDU)
|
|
{
|
|
GetPlayerAppAttrsTextNotification::Dispatch(
|
|
&BluetoothAvrcpNotificationHandler::GetPlayerAppAttrsTextNotification,
|
|
GetPlayerAppAttrsTextInitOp(aPDU));
|
|
}
|
|
|
|
// Init operator class for GetPlayerAppValuesTextNotification
|
|
class BluetoothDaemonAvrcpModule::GetPlayerAppValuesTextInitOp MOZ_FINAL
|
|
: private PDUInitOp
|
|
{
|
|
public:
|
|
GetPlayerAppValuesTextInitOp(BluetoothDaemonPDU& aPDU)
|
|
: PDUInitOp(aPDU)
|
|
{ }
|
|
|
|
nsresult
|
|
operator () (uint8_t& aArg1, uint8_t& aArg2,
|
|
nsAutoArrayPtr<uint8_t>& aArg3) const
|
|
{
|
|
BluetoothDaemonPDU& pdu = GetPDU();
|
|
|
|
/* Read attribute */
|
|
nsresult rv = UnpackPDU(pdu, aArg1);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
/* Read number of values */
|
|
rv = UnpackPDU(pdu, aArg2);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
/* Read values */
|
|
rv = UnpackPDU(pdu, UnpackArray<uint8_t>(aArg3, aArg2));
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
WarnAboutTrailingData();
|
|
return NS_OK;
|
|
}
|
|
};
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::GetPlayerAppValuesTextNtf(
|
|
const BluetoothDaemonPDUHeader& aHeader, BluetoothDaemonPDU& aPDU)
|
|
{
|
|
GetPlayerAppValuesTextNotification::Dispatch(
|
|
&BluetoothAvrcpNotificationHandler::GetPlayerAppValuesTextNotification,
|
|
GetPlayerAppValuesTextInitOp(aPDU));
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::SetPlayerAppValueNtf(
|
|
const BluetoothDaemonPDUHeader& aHeader, BluetoothDaemonPDU& aPDU)
|
|
{
|
|
SetPlayerAppValueNotification::Dispatch(
|
|
&BluetoothAvrcpNotificationHandler::SetPlayerAppValueNotification,
|
|
UnpackPDUInitOp(aPDU));
|
|
}
|
|
|
|
// Init operator class for GetElementAttrNotification
|
|
class BluetoothDaemonAvrcpModule::GetElementAttrInitOp MOZ_FINAL
|
|
: private PDUInitOp
|
|
{
|
|
public:
|
|
GetElementAttrInitOp(BluetoothDaemonPDU& aPDU)
|
|
: PDUInitOp(aPDU)
|
|
{ }
|
|
|
|
nsresult
|
|
operator () (uint8_t& aArg1,
|
|
nsAutoArrayPtr<BluetoothAvrcpMediaAttribute>& aArg2) const
|
|
{
|
|
BluetoothDaemonPDU& pdu = GetPDU();
|
|
|
|
/* Read number of attributes */
|
|
nsresult rv = UnpackPDU(pdu, aArg1);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
/* Read attributes */
|
|
rv = UnpackPDU(
|
|
pdu, UnpackArray<BluetoothAvrcpMediaAttribute>(aArg2, aArg1));
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
WarnAboutTrailingData();
|
|
return NS_OK;
|
|
}
|
|
};
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::GetElementAttrNtf(
|
|
const BluetoothDaemonPDUHeader& aHeader, BluetoothDaemonPDU& aPDU)
|
|
{
|
|
GetElementAttrNotification::Dispatch(
|
|
&BluetoothAvrcpNotificationHandler::GetElementAttrNotification,
|
|
GetElementAttrInitOp(aPDU));
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::RegisterNotificationNtf(
|
|
const BluetoothDaemonPDUHeader& aHeader, BluetoothDaemonPDU& aPDU)
|
|
{
|
|
RegisterNotificationNotification::Dispatch(
|
|
&BluetoothAvrcpNotificationHandler::RegisterNotificationNotification,
|
|
UnpackPDUInitOp(aPDU));
|
|
}
|
|
|
|
#if ANDROID_VERSION >= 19
|
|
void
|
|
BluetoothDaemonAvrcpModule::VolumeChangeNtf(
|
|
const BluetoothDaemonPDUHeader& aHeader, BluetoothDaemonPDU& aPDU)
|
|
{
|
|
VolumeChangeNotification::Dispatch(
|
|
&BluetoothAvrcpNotificationHandler::VolumeChangeNotification,
|
|
UnpackPDUInitOp(aPDU));
|
|
}
|
|
|
|
// Init operator class for PassthroughCmdNotification
|
|
class BluetoothDaemonAvrcpModule::PassthroughCmdInitOp MOZ_FINAL
|
|
: private PDUInitOp
|
|
{
|
|
public:
|
|
PassthroughCmdInitOp(BluetoothDaemonPDU& aPDU)
|
|
: PDUInitOp(aPDU)
|
|
{ }
|
|
|
|
nsresult
|
|
operator () (int& aArg1, int& aArg2) const
|
|
{
|
|
BluetoothDaemonPDU& pdu = GetPDU();
|
|
|
|
nsresult rv = UnpackPDU(pdu, UnpackConversion<uint8_t, int>(aArg1));
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
rv = UnpackPDU(pdu, UnpackConversion<uint8_t, int>(aArg2));
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
WarnAboutTrailingData();
|
|
return NS_OK;
|
|
}
|
|
};
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::PassthroughCmdNtf(
|
|
const BluetoothDaemonPDUHeader& aHeader, BluetoothDaemonPDU& aPDU)
|
|
{
|
|
PassthroughCmdNotification::Dispatch(
|
|
&BluetoothAvrcpNotificationHandler::PassthroughCmdNotification,
|
|
PassthroughCmdInitOp(aPDU));
|
|
}
|
|
#endif
|
|
|
|
void
|
|
BluetoothDaemonAvrcpModule::HandleNtf(
|
|
const BluetoothDaemonPDUHeader& aHeader, BluetoothDaemonPDU& aPDU,
|
|
void* aUserData)
|
|
{
|
|
static void (BluetoothDaemonAvrcpModule::* const HandleNtf[])(
|
|
const BluetoothDaemonPDUHeader&, BluetoothDaemonPDU&) = {
|
|
#if ANDROID_VERSION >= 19
|
|
INIT_ARRAY_AT(0, &BluetoothDaemonAvrcpModule::RemoteFeatureNtf),
|
|
INIT_ARRAY_AT(1, &BluetoothDaemonAvrcpModule::GetPlayStatusNtf),
|
|
INIT_ARRAY_AT(2, &BluetoothDaemonAvrcpModule::ListPlayerAppAttrNtf),
|
|
INIT_ARRAY_AT(3, &BluetoothDaemonAvrcpModule::ListPlayerAppValuesNtf),
|
|
INIT_ARRAY_AT(4, &BluetoothDaemonAvrcpModule::GetPlayerAppValueNtf),
|
|
INIT_ARRAY_AT(5, &BluetoothDaemonAvrcpModule::GetPlayerAppAttrsTextNtf),
|
|
INIT_ARRAY_AT(6, &BluetoothDaemonAvrcpModule::GetPlayerAppValuesTextNtf),
|
|
INIT_ARRAY_AT(7, &BluetoothDaemonAvrcpModule::SetPlayerAppValueNtf),
|
|
INIT_ARRAY_AT(8, &BluetoothDaemonAvrcpModule::GetElementAttrNtf),
|
|
INIT_ARRAY_AT(9, &BluetoothDaemonAvrcpModule::RegisterNotificationNtf),
|
|
INIT_ARRAY_AT(10, &BluetoothDaemonAvrcpModule::VolumeChangeNtf),
|
|
INIT_ARRAY_AT(11, &BluetoothDaemonAvrcpModule::PassthroughCmdNtf)
|
|
#else
|
|
INIT_ARRAY_AT(0, &BluetoothDaemonAvrcpModule::GetPlayStatusNtf),
|
|
INIT_ARRAY_AT(1, &BluetoothDaemonAvrcpModule::ListPlayerAppAttrNtf),
|
|
INIT_ARRAY_AT(2, &BluetoothDaemonAvrcpModule::ListPlayerAppValuesNtf),
|
|
INIT_ARRAY_AT(3, &BluetoothDaemonAvrcpModule::GetPlayerAppValueNtf),
|
|
INIT_ARRAY_AT(4, &BluetoothDaemonAvrcpModule::GetPlayerAppAttrsTextNtf),
|
|
INIT_ARRAY_AT(5, &BluetoothDaemonAvrcpModule::GetPlayerAppValuesTextNtf),
|
|
INIT_ARRAY_AT(6, &BluetoothDaemonAvrcpModule::SetPlayerAppValueNtf),
|
|
INIT_ARRAY_AT(7, &BluetoothDaemonAvrcpModule::GetElementAttrNtf),
|
|
INIT_ARRAY_AT(8, &BluetoothDaemonAvrcpModule::RegisterNotificationNtf)
|
|
#endif
|
|
};
|
|
|
|
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);
|
|
}
|
|
|
|
//
|
|
// AVRCP interface
|
|
//
|
|
|
|
BluetoothDaemonAvrcpInterface::BluetoothDaemonAvrcpInterface(
|
|
BluetoothDaemonAvrcpModule* aModule)
|
|
: mModule(aModule)
|
|
{ }
|
|
|
|
BluetoothDaemonAvrcpInterface::~BluetoothDaemonAvrcpInterface()
|
|
{ }
|
|
|
|
class BluetoothDaemonAvrcpInterface::InitResultHandler MOZ_FINAL
|
|
: public BluetoothSetupResultHandler
|
|
{
|
|
public:
|
|
InitResultHandler(BluetoothAvrcpResultHandler* aRes)
|
|
: mRes(aRes)
|
|
{
|
|
MOZ_ASSERT(mRes);
|
|
}
|
|
|
|
void OnError(BluetoothStatus aStatus) MOZ_OVERRIDE
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
mRes->OnError(aStatus);
|
|
}
|
|
|
|
void RegisterModule() MOZ_OVERRIDE
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
mRes->Init();
|
|
}
|
|
|
|
private:
|
|
nsRefPtr<BluetoothAvrcpResultHandler> mRes;
|
|
};
|
|
|
|
void
|
|
BluetoothDaemonAvrcpInterface::Init(
|
|
BluetoothAvrcpNotificationHandler* aNotificationHandler,
|
|
BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(mModule);
|
|
|
|
// 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(
|
|
BluetoothDaemonAvrcpModule::SERVICE_ID,
|
|
BluetoothDaemonAvrcpModule::MAX_NUM_CLIENTS, 0x00, res);
|
|
|
|
if (NS_FAILED(rv) && aRes) {
|
|
DispatchError(aRes, STATUS_FAIL);
|
|
}
|
|
}
|
|
|
|
class BluetoothDaemonAvrcpInterface::CleanupResultHandler MOZ_FINAL
|
|
: public BluetoothSetupResultHandler
|
|
{
|
|
public:
|
|
CleanupResultHandler(BluetoothDaemonAvrcpModule* aModule,
|
|
BluetoothAvrcpResultHandler* aRes)
|
|
: mModule(aModule)
|
|
, mRes(aRes)
|
|
{
|
|
MOZ_ASSERT(mModule);
|
|
}
|
|
|
|
void OnError(BluetoothStatus aStatus) MOZ_OVERRIDE
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
if (mRes) {
|
|
mRes->OnError(aStatus);
|
|
}
|
|
}
|
|
|
|
void UnregisterModule() MOZ_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:
|
|
BluetoothDaemonAvrcpModule* mModule;
|
|
nsRefPtr<BluetoothAvrcpResultHandler> mRes;
|
|
};
|
|
|
|
void
|
|
BluetoothDaemonAvrcpInterface::Cleanup(
|
|
BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(mModule);
|
|
|
|
mModule->UnregisterModule(BluetoothDaemonAvrcpModule::SERVICE_ID,
|
|
new CleanupResultHandler(mModule, aRes));
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpInterface::GetPlayStatusRsp(
|
|
ControlPlayStatus aPlayStatus, uint32_t aSongLen, uint32_t aSongPos,
|
|
BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(mModule);
|
|
|
|
mModule->GetPlayStatusRspCmd(aPlayStatus, aSongLen, aSongPos, aRes);
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpInterface::ListPlayerAppAttrRsp(
|
|
int aNumAttr, const BluetoothAvrcpPlayerAttribute* aPAttrs,
|
|
BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(mModule);
|
|
|
|
mModule->ListPlayerAppAttrRspCmd(aNumAttr, aPAttrs, aRes);
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpInterface::ListPlayerAppValueRsp(
|
|
int aNumVal, uint8_t* aPVals, BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(mModule);
|
|
|
|
mModule->ListPlayerAppValueRspCmd(aNumVal, aPVals, aRes);
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpInterface::GetPlayerAppValueRsp(
|
|
uint8_t aNumAttrs, const uint8_t* aIds, const uint8_t* aValues,
|
|
BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(mModule);
|
|
|
|
mModule->GetPlayerAppValueRspCmd(aNumAttrs, aIds, aValues, aRes);
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpInterface::GetPlayerAppAttrTextRsp(
|
|
int aNumAttr, const uint8_t* aIds, const char** aTexts,
|
|
BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(mModule);
|
|
|
|
mModule->GetPlayerAppAttrTextRspCmd(aNumAttr, aIds, aTexts, aRes);
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpInterface::GetPlayerAppValueTextRsp(
|
|
int aNumVal, const uint8_t* aIds, const char** aTexts,
|
|
BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(mModule);
|
|
|
|
mModule->GetPlayerAppValueTextRspCmd(aNumVal, aIds, aTexts, aRes);
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpInterface::GetElementAttrRsp(
|
|
uint8_t aNumAttr, const BluetoothAvrcpElementAttribute* aAttr,
|
|
BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(mModule);
|
|
|
|
mModule->GetElementAttrRspCmd(aNumAttr, aAttr, aRes);
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpInterface::SetPlayerAppValueRsp(
|
|
BluetoothAvrcpStatus aRspStatus, BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(mModule);
|
|
|
|
mModule->SetPlayerAppValueRspCmd(aRspStatus, aRes);
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpInterface::RegisterNotificationRsp(
|
|
BluetoothAvrcpEvent aEvent,
|
|
BluetoothAvrcpNotification aType,
|
|
const BluetoothAvrcpNotificationParam& aParam,
|
|
BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(mModule);
|
|
|
|
mModule->RegisterNotificationRspCmd(aEvent, aType, aParam, aRes);
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpInterface::SetVolume(
|
|
uint8_t aVolume, BluetoothAvrcpResultHandler* aRes)
|
|
{
|
|
MOZ_ASSERT(mModule);
|
|
|
|
mModule->SetVolumeCmd(aVolume, aRes);
|
|
}
|
|
|
|
void
|
|
BluetoothDaemonAvrcpInterface::DispatchError(
|
|
BluetoothAvrcpResultHandler* aRes, BluetoothStatus aStatus)
|
|
{
|
|
BluetoothResultRunnable1<BluetoothAvrcpResultHandler, void,
|
|
BluetoothStatus, BluetoothStatus>::Dispatch(
|
|
aRes, &BluetoothAvrcpResultHandler::OnError,
|
|
ConstantInitOp1<BluetoothStatus>(aStatus));
|
|
}
|
|
|
|
END_BLUETOOTH_NAMESPACE
|