/*
|
* Copyright 2018 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
#include "get_folder_items.h"
|
|
namespace bluetooth {
|
namespace avrcp {
|
|
std::unique_ptr<GetFolderItemsResponseBuilder>
|
GetFolderItemsResponseBuilder::MakePlayerListBuilder(Status status,
|
uint16_t uid_counter,
|
size_t mtu) {
|
std::unique_ptr<GetFolderItemsResponseBuilder> builder(
|
new GetFolderItemsResponseBuilder(Scope::MEDIA_PLAYER_LIST, status,
|
uid_counter, mtu));
|
|
return builder;
|
}
|
|
std::unique_ptr<GetFolderItemsResponseBuilder>
|
GetFolderItemsResponseBuilder::MakeVFSBuilder(Status status,
|
uint16_t uid_counter,
|
size_t mtu) {
|
std::unique_ptr<GetFolderItemsResponseBuilder> builder(
|
new GetFolderItemsResponseBuilder(Scope::VFS, status, uid_counter, mtu));
|
|
return builder;
|
}
|
|
std::unique_ptr<GetFolderItemsResponseBuilder>
|
GetFolderItemsResponseBuilder::MakeNowPlayingBuilder(Status status,
|
uint16_t uid_counter,
|
size_t mtu) {
|
std::unique_ptr<GetFolderItemsResponseBuilder> builder(
|
new GetFolderItemsResponseBuilder(Scope::NOW_PLAYING, status, uid_counter,
|
mtu));
|
|
return builder;
|
}
|
|
size_t GetFolderItemsResponseBuilder::size() const {
|
size_t len = BrowsePacket::kMinSize();
|
len += 1; // Status
|
|
// There is nothing other than the status in the packet if the status isn't
|
// NO_ERROR
|
if (status_ != Status::NO_ERROR || items_.size() == 0) return len;
|
|
len += 2; // UID Counter
|
len += 2; // Number of Items;
|
for (const auto& item : items_) {
|
len += item.size();
|
}
|
|
return len;
|
}
|
|
bool GetFolderItemsResponseBuilder::Serialize(
|
const std::shared_ptr<::bluetooth::Packet>& pkt) {
|
ReserveSpace(pkt, size());
|
|
BrowsePacketBuilder::PushHeader(pkt, size() - BrowsePacket::kMinSize());
|
|
if (status_ == Status::NO_ERROR && items_.size() == 0) {
|
// Return range out of bounds if there are zero items in the folder
|
status_ = Status::RANGE_OUT_OF_BOUNDS;
|
}
|
|
AddPayloadOctets1(pkt, (uint8_t)status_); // Status
|
if (status_ != Status::NO_ERROR) return true;
|
|
AddPayloadOctets2(pkt, base::ByteSwap(uid_counter_));
|
uint16_t num_items = items_.size();
|
AddPayloadOctets2(pkt, base::ByteSwap(num_items));
|
|
for (const auto& item : items_) {
|
PushMediaListItem(pkt, item);
|
}
|
|
return true;
|
}
|
|
bool GetFolderItemsResponseBuilder::AddMediaPlayer(MediaPlayerItem item) {
|
CHECK(scope_ == Scope::MEDIA_PLAYER_LIST);
|
|
if (size() + item.size() > mtu_) return false;
|
|
items_.push_back(MediaListItem(item));
|
return true;
|
}
|
|
bool GetFolderItemsResponseBuilder::AddSong(MediaElementItem item) {
|
CHECK(scope_ == Scope::VFS || scope_ == Scope::NOW_PLAYING);
|
|
if (size() + item.size() > mtu_) return false;
|
|
items_.push_back(MediaListItem(item));
|
return true;
|
}
|
|
bool GetFolderItemsResponseBuilder::AddFolder(FolderItem item) {
|
CHECK(scope_ == Scope::VFS);
|
|
if (size() + item.size() > mtu_) return false;
|
|
items_.push_back(MediaListItem(item));
|
return true;
|
}
|
|
void GetFolderItemsResponseBuilder::PushMediaListItem(
|
const std::shared_ptr<::bluetooth::Packet>& pkt,
|
const MediaListItem& item) {
|
switch (item.type_) {
|
case MediaListItem::PLAYER:
|
PushMediaPlayerItem(pkt, item.player_);
|
break;
|
case MediaListItem::FOLDER:
|
PushFolderItem(pkt, item.folder_);
|
break;
|
case MediaListItem::SONG:
|
PushMediaElementItem(pkt, item.song_);
|
break;
|
}
|
}
|
|
void GetFolderItemsResponseBuilder::PushMediaPlayerItem(
|
const std::shared_ptr<::bluetooth::Packet>& pkt,
|
const MediaPlayerItem& item) {
|
AddPayloadOctets1(pkt, 0x01); // Media Player Item
|
uint16_t item_len = item.size() - 3;
|
AddPayloadOctets2(pkt, base::ByteSwap(item_len)); // Item length
|
AddPayloadOctets2(pkt, base::ByteSwap(item.id_)); // Player ID
|
AddPayloadOctets1(pkt, 0x01); // Player Type
|
AddPayloadOctets4(pkt, 0x00000000); // Player Subtype
|
AddPayloadOctets1(
|
pkt, 0x02); // Player Play Status // TODO: Add this as a passed field
|
|
// Features
|
AddPayloadOctets1(pkt, 0x00);
|
AddPayloadOctets1(pkt, 0x00);
|
AddPayloadOctets1(pkt, 0x00);
|
AddPayloadOctets1(pkt, 0x00);
|
AddPayloadOctets1(pkt, 0x00);
|
AddPayloadOctets1(pkt, 0xb7);
|
AddPayloadOctets1(pkt, 0x01);
|
if (item.browsable_) {
|
AddPayloadOctets1(pkt, 0x0C);
|
AddPayloadOctets1(pkt, 0x0a);
|
} else {
|
AddPayloadOctets1(pkt, 0x04);
|
AddPayloadOctets1(pkt, 0x00);
|
}
|
AddPayloadOctets1(pkt, 0x00);
|
AddPayloadOctets1(pkt, 0x00);
|
AddPayloadOctets1(pkt, 0x00);
|
AddPayloadOctets1(pkt, 0x00);
|
AddPayloadOctets1(pkt, 0x00);
|
AddPayloadOctets1(pkt, 0x00);
|
AddPayloadOctets1(pkt, 0x00);
|
|
AddPayloadOctets2(pkt, base::ByteSwap((uint16_t)0x006a));
|
uint16_t name_len = item.name_.size();
|
AddPayloadOctets2(pkt, base::ByteSwap(name_len));
|
|
for (const uint8_t& byte : item.name_) {
|
AddPayloadOctets1(pkt, byte);
|
}
|
}
|
|
void GetFolderItemsResponseBuilder::PushFolderItem(
|
const std::shared_ptr<::bluetooth::Packet>& pkt, const FolderItem& item) {
|
AddPayloadOctets1(pkt, 0x02); // Folder Item
|
uint16_t item_len = item.size() - 3;
|
AddPayloadOctets2(pkt, base::ByteSwap(item_len));
|
AddPayloadOctets8(pkt, base::ByteSwap(item.uid_));
|
AddPayloadOctets1(pkt, item.folder_type_);
|
AddPayloadOctets1(pkt, item.is_playable_ ? 0x01 : 0x00);
|
AddPayloadOctets2(pkt,
|
base::ByteSwap((uint16_t)0x006a)); // UTF-8 Character Set
|
uint16_t name_len = item.name_.size();
|
AddPayloadOctets2(pkt, base::ByteSwap(name_len));
|
for (const uint8_t& byte : item.name_) {
|
AddPayloadOctets1(pkt, byte);
|
}
|
}
|
|
void GetFolderItemsResponseBuilder::PushMediaElementItem(
|
const std::shared_ptr<::bluetooth::Packet>& pkt,
|
const MediaElementItem& item) {
|
AddPayloadOctets1(pkt, 0x03); // Media Element Item
|
uint16_t item_len = item.size() - 3;
|
AddPayloadOctets2(pkt, base::ByteSwap(item_len));
|
AddPayloadOctets8(pkt, base::ByteSwap(item.uid_));
|
AddPayloadOctets1(pkt, 0x00); // Media Type Audio
|
AddPayloadOctets2(pkt,
|
base::ByteSwap((uint16_t)0x006a)); // UTF-8 Character Set
|
uint16_t name_len = item.name_.size();
|
AddPayloadOctets2(pkt, base::ByteSwap(name_len));
|
for (const uint8_t& byte : item.name_) {
|
AddPayloadOctets1(pkt, byte);
|
}
|
|
AddPayloadOctets1(pkt, (uint8_t)item.attributes_.size());
|
for (const auto& entry : item.attributes_) {
|
AddPayloadOctets4(pkt, base::ByteSwap((uint32_t)entry.attribute()));
|
AddPayloadOctets2(pkt,
|
base::ByteSwap((uint16_t)0x006a)); // UTF-8 Character Set
|
|
std::string attr_val = entry.value();
|
uint16_t attr_len = attr_val.size();
|
|
AddPayloadOctets2(pkt, base::ByteSwap(attr_len));
|
for (const uint8_t& byte : attr_val) {
|
AddPayloadOctets1(pkt, byte);
|
}
|
}
|
}
|
|
Scope GetFolderItemsRequest::GetScope() const {
|
auto it = begin() + BrowsePacket::kMinSize();
|
return static_cast<Scope>(*it);
|
}
|
|
uint32_t GetFolderItemsRequest::GetStartItem() const {
|
auto it = begin() + BrowsePacket::kMinSize() + static_cast<size_t>(1);
|
return it.extractBE<uint32_t>();
|
}
|
|
uint32_t GetFolderItemsRequest::GetEndItem() const {
|
auto it = begin() + BrowsePacket::kMinSize() + static_cast<size_t>(5);
|
return it.extractBE<uint32_t>();
|
}
|
|
uint8_t GetFolderItemsRequest::GetNumAttributes() const {
|
auto it = begin() + BrowsePacket::kMinSize() + static_cast<size_t>(9);
|
return *it;
|
}
|
|
std::vector<Attribute> GetFolderItemsRequest::GetAttributesRequested() const {
|
auto it = begin() + BrowsePacket::kMinSize() + static_cast<size_t>(9);
|
|
size_t number_of_attributes = it.extract<uint8_t>();
|
std::vector<Attribute> attribute_list;
|
|
// No attributes requested
|
if (number_of_attributes == 0xFF) return attribute_list;
|
|
// TODO: If the number of attributes equals 0, then all attributes are
|
// requested right now thats handled in the service itself, but it'd be nice
|
// to have this function return a vector with all the attributes
|
|
for (size_t i = 0; i < number_of_attributes; i++) {
|
attribute_list.push_back((Attribute)it.extractBE<uint32_t>());
|
}
|
|
return attribute_list;
|
}
|
|
bool GetFolderItemsRequest::IsValid() const {
|
if (!BrowsePacket::IsValid()) return false;
|
// The minimum size required to be valid
|
if (size() < kMinSize()) return false;
|
|
auto attr_count = GetNumAttributes();
|
|
// No items requested
|
if (attr_count == 0xFF) return true;
|
|
auto attr_start = begin() + kMinSize();
|
|
// Casting the int returned from end - attr_start should be fine. If an
|
// overflow occurs we can definitly say the packet is invalid
|
return (attr_count * sizeof(Attribute)) == (size_t)(end() - attr_start);
|
}
|
|
std::string GetFolderItemsRequest::ToString() const {
|
std::stringstream ss;
|
ss << "GetFolderItemsRequestPacket: " << std::endl;
|
ss << " └ PDU = " << GetPdu() << std::endl;
|
ss << " └ Length = " << GetLength() << std::endl;
|
ss << " └ Scope = " << GetScope() << std::endl;
|
ss << " └ Start Item = " << loghex(GetStartItem()) << std::endl;
|
ss << " └ End Item = " << loghex(GetEndItem()) << std::endl;
|
ss << " └ Attribute Count = " << loghex(GetNumAttributes()) << std::endl;
|
|
ss << std::endl;
|
|
return ss.str();
|
}
|
|
std::unique_ptr<GetFolderItemsRequestBuilder>
|
GetFolderItemsRequestBuilder::MakeBuilder(
|
Scope scope, uint32_t start_item, uint32_t end_item,
|
const std::set<Attribute>& requested_attrs) {
|
std::unique_ptr<GetFolderItemsRequestBuilder> builder(
|
new GetFolderItemsRequestBuilder(scope, start_item, end_item,
|
requested_attrs));
|
|
return builder;
|
}
|
|
size_t GetFolderItemsRequestBuilder::size() const {
|
size_t len = GetFolderItemsRequest::kMinSize();
|
len += requested_attrs_.size() * sizeof(Attribute);
|
return len;
|
}
|
|
bool GetFolderItemsRequestBuilder::Serialize(
|
const std::shared_ptr<::bluetooth::Packet>& pkt) {
|
ReserveSpace(pkt, size());
|
|
BrowsePacketBuilder::PushHeader(pkt, size() - BrowsePacket::kMinSize());
|
|
AddPayloadOctets1(pkt, static_cast<uint8_t>(scope_));
|
AddPayloadOctets4(pkt, base::ByteSwap(start_item_));
|
AddPayloadOctets4(pkt, base::ByteSwap(end_item_));
|
|
if (requested_attrs_.size() == 0) {
|
// 0xFF is the value to signify that there are no attributes requested.
|
AddPayloadOctets1(pkt, 0xFF);
|
return true;
|
}
|
|
AddPayloadOctets1(pkt, requested_attrs_.size());
|
for (const auto& attr : requested_attrs_) {
|
AddPayloadOctets4(pkt, base::ByteSwap(static_cast<uint32_t>(attr)));
|
}
|
return true;
|
}
|
|
} // namespace avrcp
|
} // namespace bluetooth
|
