blob: 04d2871c77addbe9c8b8fd4d0e061ceb1899cc03 [file] [log] [blame]
/*
* Copyright (C) 2019 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 <android-base/stringprintf.h>
#include <binder/Parcel.h>
#include <gui/LayerMetadata.h>
using android::base::StringPrintf;
namespace android {
LayerMetadata::LayerMetadata() = default;
LayerMetadata::LayerMetadata(std::unordered_map<uint32_t, std::vector<uint8_t>> map)
: mMap(std::move(map)) {}
LayerMetadata::LayerMetadata(const LayerMetadata& other) = default;
LayerMetadata::LayerMetadata(LayerMetadata&& other) = default;
bool LayerMetadata::merge(const LayerMetadata& other, bool eraseEmpty) {
bool changed = false;
for (const auto& entry : other.mMap) {
auto it = mMap.find(entry.first);
if (it != mMap.cend() && it->second != entry.second) {
if (eraseEmpty && entry.second.empty()) {
mMap.erase(it);
} else {
it->second = entry.second;
}
changed = true;
} else if (it == mMap.cend() && !entry.second.empty()) {
mMap[entry.first] = entry.second;
changed = true;
}
}
return changed;
}
status_t LayerMetadata::writeToParcel(Parcel* parcel) const {
parcel->writeInt32(static_cast<int>(mMap.size()));
status_t status = OK;
for (const auto& entry : mMap) {
status = parcel->writeUint32(entry.first);
if (status != OK) {
break;
}
status = parcel->writeByteVector(entry.second);
if (status != OK) {
break;
}
}
return status;
}
status_t LayerMetadata::readFromParcel(const Parcel* parcel) {
int size = parcel->readInt32();
status_t status = OK;
mMap.clear();
for (int i = 0; i < size; ++i) {
uint32_t key = parcel->readUint32();
status = parcel->readByteVector(&mMap[key]);
if (status != OK) {
break;
}
}
return status;
}
LayerMetadata& LayerMetadata::operator=(const LayerMetadata& other) {
mMap = other.mMap;
return *this;
}
LayerMetadata& LayerMetadata::operator=(LayerMetadata&& other) {
mMap = std::move(other.mMap);
return *this;
}
bool LayerMetadata::has(uint32_t key) const {
return mMap.count(key);
}
int32_t LayerMetadata::getInt32(uint32_t key, int32_t fallback) const {
if (!has(key)) return fallback;
const std::vector<uint8_t>& data = mMap.at(key);
if (data.size() < sizeof(uint32_t)) return fallback;
Parcel p;
p.setData(data.data(), data.size());
return p.readInt32();
}
void LayerMetadata::setInt32(uint32_t key, int32_t value) {
std::vector<uint8_t>& data = mMap[key];
Parcel p;
p.writeInt32(value);
data.resize(p.dataSize());
memcpy(data.data(), p.data(), p.dataSize());
}
std::string LayerMetadata::itemToString(uint32_t key, const char* separator) const {
if (!has(key)) return std::string();
switch (key) {
case METADATA_OWNER_UID:
return StringPrintf("ownerUID%s%d", separator, getInt32(key, 0));
case METADATA_WINDOW_TYPE:
return StringPrintf("windowType%s%d", separator, getInt32(key, 0));
case METADATA_TASK_ID:
return StringPrintf("taskId%s%d", separator, getInt32(key, 0));
default:
return StringPrintf("%d%s%dbytes", key, separator,
static_cast<int>(mMap.at(key).size()));
}
}
} // namespace android