Google Git
Sign in
android / platform / frameworks / base / refs/heads/pie-platform-release / . / libs / androidfw / ResourceTypes.cpp
blob: 861dc0f3879cdfa94230bd6a4892d43ad7e8cce1 [file] [log] [blame] [edit]
/*
* Copyright (C) 2008 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.
*/
#define LOG_TAG "ResourceType"
//#define LOG_NDEBUG 0
#include <ctype.h>
#include <memory.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <limits>
#include <memory>
#include <type_traits>
#include <androidfw/ByteBucketArray.h>
#include <androidfw/ResourceTypes.h>
#include <androidfw/TypeWrappers.h>
#include <cutils/atomic.h>
#include <utils/ByteOrder.h>
#include <utils/Debug.h>
#include <utils/Log.h>
#include <utils/String16.h>
#include <utils/String8.h>
#ifdef __ANDROID__
#include <binder/TextOutput.h>
#endif
#ifndef INT32_MAX
#define INT32_MAX ((int32_t)(2147483647))
#endif
namespace android {
#if defined(_WIN32)
#undef nhtol
#undef htonl
#define ntohl(x) ( ((x) << 24) | (((x) >> 24) & 255) | (((x) << 8) & 0xff0000) | (((x) >> 8) & 0xff00) )
#define htonl(x) ntohl(x)
#define ntohs(x) ( (((x) << 8) & 0xff00) | (((x) >> 8) & 255) )
#define htons(x) ntohs(x)
#endif
#define IDMAP_MAGIC 0x504D4449
#define APP_PACKAGE_ID 0x7f
#define SYS_PACKAGE_ID 0x01
static const bool kDebugStringPoolNoisy = false;
static const bool kDebugXMLNoisy = false;
static const bool kDebugTableNoisy = false;
static const bool kDebugTableGetEntry = false;
static const bool kDebugTableSuperNoisy = false;
static const bool kDebugLoadTableNoisy = false;
static const bool kDebugLoadTableSuperNoisy = false;
static const bool kDebugTableTheme = false;
static const bool kDebugResXMLTree = false;
static const bool kDebugLibNoisy = false;
// TODO: This code uses 0xFFFFFFFF converted to bag_set* as a sentinel value. This is bad practice.
// Standard C isspace() is only required to look at the low byte of its input, so
// produces incorrect results for UTF-16 characters. For safety's sake, assume that
// any high-byte UTF-16 code point is not whitespace.
inline int isspace16(char16_t c) {
return (c < 0x0080 && isspace(c));
}
template<typename T>
inline static T max(T a, T b) {
return a > b ? a : b;
}
// range checked; guaranteed to NUL-terminate within the stated number of available slots
// NOTE: if this truncates the dst string due to running out of space, no attempt is
// made to avoid splitting surrogate pairs.
static void strcpy16_dtoh(char16_t* dst, const uint16_t* src, size_t avail)
{
char16_t* last = dst + avail - 1;
while (*src && (dst < last)) {
char16_t s = dtohs(static_cast<char16_t>(*src));
*dst++ = s;
src++;
}
*dst = 0;
}
static status_t validate_chunk(const ResChunk_header* chunk,
size_t minSize,
const uint8_t* dataEnd,
const char* name)
{
const uint16_t headerSize = dtohs(chunk->headerSize);
const uint32_t size = dtohl(chunk->size);
if (headerSize >= minSize) {
if (headerSize <= size) {
if (((headerSize|size)&0x3) == 0) {
if ((size_t)size <= (size_t)(dataEnd-((const uint8_t*)chunk))) {
return NO_ERROR;
}
ALOGW("%s data size 0x%x extends beyond resource end %p.",
name, size, (void*)(dataEnd-((const uint8_t*)chunk)));
return BAD_TYPE;
}
ALOGW("%s size 0x%x or headerSize 0x%x is not on an integer boundary.",
name, (int)size, (int)headerSize);
return BAD_TYPE;
}
ALOGW("%s size 0x%x is smaller than header size 0x%x.",
name, size, headerSize);
return BAD_TYPE;
}
ALOGW("%s header size 0x%04x is too small.",
name, headerSize);
return BAD_TYPE;
}
static void fill9patchOffsets(Res_png_9patch* patch) {
patch->xDivsOffset = sizeof(Res_png_9patch);
patch->yDivsOffset = patch->xDivsOffset + (patch->numXDivs * sizeof(int32_t));
patch->colorsOffset = patch->yDivsOffset + (patch->numYDivs * sizeof(int32_t));
}
void Res_value::copyFrom_dtoh(const Res_value& src)
{
size = dtohs(src.size);
res0 = src.res0;
dataType = src.dataType;
data = dtohl(src.data);
}
void Res_png_9patch::deviceToFile()
{
int32_t* xDivs = getXDivs();
for (int i = 0; i < numXDivs; i++) {
xDivs[i] = htonl(xDivs[i]);
}
int32_t* yDivs = getYDivs();
for (int i = 0; i < numYDivs; i++) {
yDivs[i] = htonl(yDivs[i]);
}
paddingLeft = htonl(paddingLeft);
paddingRight = htonl(paddingRight);
paddingTop = htonl(paddingTop);
paddingBottom = htonl(paddingBottom);
uint32_t* colors = getColors();
for (int i=0; i<numColors; i++) {
colors[i] = htonl(colors[i]);
}
}
void Res_png_9patch::fileToDevice()
{
int32_t* xDivs = getXDivs();
for (int i = 0; i < numXDivs; i++) {
xDivs[i] = ntohl(xDivs[i]);
}
int32_t* yDivs = getYDivs();
for (int i = 0; i < numYDivs; i++) {
yDivs[i] = ntohl(yDivs[i]);
}
paddingLeft = ntohl(paddingLeft);
paddingRight = ntohl(paddingRight);
paddingTop = ntohl(paddingTop);
paddingBottom = ntohl(paddingBottom);
uint32_t* colors = getColors();
for (int i=0; i<numColors; i++) {
colors[i] = ntohl(colors[i]);
}
}
size_t Res_png_9patch::serializedSize() const
{
// The size of this struct is 32 bytes on the 32-bit target system
// 4 * int8_t
// 4 * int32_t
// 3 * uint32_t
return 32
+ numXDivs * sizeof(int32_t)
+ numYDivs * sizeof(int32_t)
+ numColors * sizeof(uint32_t);
}
void* Res_png_9patch::serialize(const Res_png_9patch& patch, const int32_t* xDivs,
const int32_t* yDivs, const uint32_t* colors)
{
// Use calloc since we're going to leave a few holes in the data
// and want this to run cleanly under valgrind
void* newData = calloc(1, patch.serializedSize());
serialize(patch, xDivs, yDivs, colors, newData);
return newData;
}
void Res_png_9patch::serialize(const Res_png_9patch& patch, const int32_t* xDivs,
const int32_t* yDivs, const uint32_t* colors, void* outData)
{
uint8_t* data = (uint8_t*) outData;
memcpy(data, &patch.wasDeserialized, 4); // copy wasDeserialized, numXDivs, numYDivs, numColors
memcpy(data + 12, &patch.paddingLeft, 16); // copy paddingXXXX
data += 32;
memcpy(data, xDivs, patch.numXDivs * sizeof(int32_t));
data += patch.numXDivs * sizeof(int32_t);
memcpy(data, yDivs, patch.numYDivs * sizeof(int32_t));
data += patch.numYDivs * sizeof(int32_t);
memcpy(data, colors, patch.numColors * sizeof(uint32_t));
fill9patchOffsets(reinterpret_cast<Res_png_9patch*>(outData));
}
static bool assertIdmapHeader(const void* idmap, size_t size) {
if (reinterpret_cast<uintptr_t>(idmap) & 0x03) {
ALOGE("idmap: header is not word aligned");
return false;
}
if (size < ResTable::IDMAP_HEADER_SIZE_BYTES) {
ALOGW("idmap: header too small (%d bytes)", (uint32_t) size);
return false;
}
const uint32_t magic = htodl(*reinterpret_cast<const uint32_t*>(idmap));
if (magic != IDMAP_MAGIC) {
ALOGW("idmap: no magic found in header (is 0x%08x, expected 0x%08x)",
magic, IDMAP_MAGIC);
return false;
}
const uint32_t version = htodl(*(reinterpret_cast<const uint32_t*>(idmap) + 1));
if (version != ResTable::IDMAP_CURRENT_VERSION) {
// We are strict about versions because files with this format are
// auto-generated and don't need backwards compatibility.
ALOGW("idmap: version mismatch in header (is 0x%08x, expected 0x%08x)",
version, ResTable::IDMAP_CURRENT_VERSION);
return false;
}
return true;
}
class IdmapEntries {
public:
IdmapEntries() : mData(NULL) {}
bool hasEntries() const {
if (mData == NULL) {
return false;
}
return (dtohs(*mData) > 0);
}
size_t byteSize() const {
if (mData == NULL) {
return 0;
}
uint16_t entryCount = dtohs(mData[2]);
return (sizeof(uint16_t) * 4) + (sizeof(uint32_t) * static_cast<size_t>(entryCount));
}
uint8_t targetTypeId() const {
if (mData == NULL) {
return 0;
}
return dtohs(mData[0]);
}
uint8_t overlayTypeId() const {
if (mData == NULL) {
return 0;
}
return dtohs(mData[1]);
}
status_t setTo(const void* entryHeader, size_t size) {
if (reinterpret_cast<uintptr_t>(entryHeader) & 0x03) {
ALOGE("idmap: entry header is not word aligned");
return UNKNOWN_ERROR;
}
if (size < sizeof(uint16_t) * 4) {
ALOGE("idmap: entry header is too small (%u bytes)", (uint32_t) size);
return UNKNOWN_ERROR;
}
const uint16_t* header = reinterpret_cast<const uint16_t*>(entryHeader);
const uint16_t targetTypeId = dtohs(header[0]);
const uint16_t overlayTypeId = dtohs(header[1]);
if (targetTypeId == 0 || overlayTypeId == 0 || targetTypeId > 255 || overlayTypeId > 255) {
ALOGE("idmap: invalid type map (%u -> %u)", targetTypeId, overlayTypeId);
return UNKNOWN_ERROR;
}
uint16_t entryCount = dtohs(header[2]);
if (size < sizeof(uint32_t) * (entryCount + 2)) {
ALOGE("idmap: too small (%u bytes) for the number of entries (%u)",
(uint32_t) size, (uint32_t) entryCount);
return UNKNOWN_ERROR;
}
mData = header;
return NO_ERROR;
}
status_t lookup(uint16_t entryId, uint16_t* outEntryId) const {
uint16_t entryCount = dtohs(mData[2]);
uint16_t offset = dtohs(mData[3]);
if (entryId < offset) {
// The entry is not present in this idmap
return BAD_INDEX;
}
entryId -= offset;
if (entryId >= entryCount) {
// The entry is not present in this idmap
return BAD_INDEX;
}
// It is safe to access the type here without checking the size because
// we have checked this when it was first loaded.
const uint32_t* entries = reinterpret_cast<const uint32_t*>(mData) + 2;
uint32_t mappedEntry = dtohl(entries[entryId]);
if (mappedEntry == 0xffffffff) {
// This entry is not present in this idmap
return BAD_INDEX;
}
*outEntryId = static_cast<uint16_t>(mappedEntry);
return NO_ERROR;
}
private:
const uint16_t* mData;
};
status_t parseIdmap(const void* idmap, size_t size, uint8_t* outPackageId, KeyedVector<uint8_t, IdmapEntries>* outMap) {
if (!assertIdmapHeader(idmap, size)) {
return UNKNOWN_ERROR;
}
size -= ResTable::IDMAP_HEADER_SIZE_BYTES;
if (size < sizeof(uint16_t) * 2) {
ALOGE("idmap: too small to contain any mapping");
return UNKNOWN_ERROR;
}
const uint16_t* data = reinterpret_cast<const uint16_t*>(
reinterpret_cast<const uint8_t*>(idmap) + ResTable::IDMAP_HEADER_SIZE_BYTES);
uint16_t targetPackageId = dtohs(*(data++));
if (targetPackageId == 0 || targetPackageId > 255) {
ALOGE("idmap: target package ID is invalid (%02x)", targetPackageId);
return UNKNOWN_ERROR;
}
uint16_t mapCount = dtohs(*(data++));
if (mapCount == 0) {
ALOGE("idmap: no mappings");
return UNKNOWN_ERROR;
}
if (mapCount > 255) {
ALOGW("idmap: too many mappings. Only 255 are possible but %u are present", (uint32_t) mapCount);
}
while (size > sizeof(uint16_t) * 4) {
IdmapEntries entries;
status_t err = entries.setTo(data, size);
if (err != NO_ERROR) {
return err;
}
ssize_t index = outMap->add(entries.overlayTypeId(), entries);
if (index < 0) {
return NO_MEMORY;
}
data += entries.byteSize() / sizeof(uint16_t);
size -= entries.byteSize();
}
if (outPackageId != NULL) {
*outPackageId = static_cast<uint8_t>(targetPackageId);
}
return NO_ERROR;
}
Res_png_9patch* Res_png_9patch::deserialize(void* inData)
{
Res_png_9patch* patch = reinterpret_cast<Res_png_9patch*>(inData);
patch->wasDeserialized = true;
fill9patchOffsets(patch);
return patch;
}
// --------------------------------------------------------------------
// --------------------------------------------------------------------
// --------------------------------------------------------------------
ResStringPool::ResStringPool()
: mError(NO_INIT), mOwnedData(NULL), mHeader(NULL), mCache(NULL)
{
}
ResStringPool::ResStringPool(const void* data, size_t size, bool copyData)
: mError(NO_INIT), mOwnedData(NULL), mHeader(NULL), mCache(NULL)
{
setTo(data, size, copyData);
}
ResStringPool::~ResStringPool()
{
uninit();
}
void ResStringPool::setToEmpty()
{
uninit();
mOwnedData = calloc(1, sizeof(ResStringPool_header));
ResStringPool_header* header = (ResStringPool_header*) mOwnedData;
mSize = 0;
mEntries = NULL;
mStrings = NULL;
mStringPoolSize = 0;
mEntryStyles = NULL;
mStyles = NULL;
mStylePoolSize = 0;
mHeader = (const ResStringPool_header*) header;
}
status_t ResStringPool::setTo(const void* data, size_t size, bool copyData)
{
if (!data || !size) {
return (mError=BAD_TYPE);
}
uninit();
// The chunk must be at least the size of the string pool header.
if (size < sizeof(ResStringPool_header)) {
ALOGW("Bad string block: data size %zu is too small to be a string block", size);
return (mError=BAD_TYPE);
}
// The data is at least as big as a ResChunk_header, so we can safely validate the other
// header fields.
// `data + size` is safe because the source of `size` comes from the kernel/filesystem.
if (validate_chunk(reinterpret_cast<const ResChunk_header*>(data), sizeof(ResStringPool_header),
reinterpret_cast<const uint8_t*>(data) + size,
"ResStringPool_header") != NO_ERROR) {
ALOGW("Bad string block: malformed block dimensions");
return (mError=BAD_TYPE);
}
const bool notDeviceEndian = htods(0xf0) != 0xf0;
if (copyData || notDeviceEndian) {
mOwnedData = malloc(size);
if (mOwnedData == NULL) {
return (mError=NO_MEMORY);
}
memcpy(mOwnedData, data, size);
data = mOwnedData;
}
// The size has been checked, so it is safe to read the data in the ResStringPool_header
// data structure.
mHeader = (const ResStringPool_header*)data;
if (notDeviceEndian) {
ResStringPool_header* h = const_cast<ResStringPool_header*>(mHeader);
h->header.headerSize = dtohs(mHeader->header.headerSize);
h->header.type = dtohs(mHeader->header.type);
h->header.size = dtohl(mHeader->header.size);
h->stringCount = dtohl(mHeader->stringCount);
h->styleCount = dtohl(mHeader->styleCount);
h->flags = dtohl(mHeader->flags);
h->stringsStart = dtohl(mHeader->stringsStart);
h->stylesStart = dtohl(mHeader->stylesStart);
}
if (mHeader->header.headerSize > mHeader->header.size
|| mHeader->header.size > size) {
ALOGW("Bad string block: header size %d or total size %d is larger than data size %d\n",
(int)mHeader->header.headerSize, (int)mHeader->header.size, (int)size);
return (mError=BAD_TYPE);
}
mSize = mHeader->header.size;
mEntries = (const uint32_t*)
(((const uint8_t*)data)+mHeader->header.headerSize);
if (mHeader->stringCount > 0) {
if ((mHeader->stringCount*sizeof(uint32_t) < mHeader->stringCount) // uint32 overflow?
|| (mHeader->header.headerSize+(mHeader->stringCount*sizeof(uint32_t)))
> size) {
ALOGW("Bad string block: entry of %d items extends past data size %d\n",
(int)(mHeader->header.headerSize+(mHeader->stringCount*sizeof(uint32_t))),
(int)size);
return (mError=BAD_TYPE);
}
size_t charSize;
if (mHeader->flags&ResStringPool_header::UTF8_FLAG) {
charSize = sizeof(uint8_t);
} else {
charSize = sizeof(uint16_t);
}
// There should be at least space for the smallest string
// (2 bytes length, null terminator).
if (mHeader->stringsStart >= (mSize - sizeof(uint16_t))) {
ALOGW("Bad string block: string pool starts at %d, after total size %d\n",
(int)mHeader->stringsStart, (int)mHeader->header.size);
return (mError=BAD_TYPE);
}
mStrings = (const void*)
(((const uint8_t*)data) + mHeader->stringsStart);
if (mHeader->styleCount == 0) {
mStringPoolSize = (mSize - mHeader->stringsStart) / charSize;
} else {
// check invariant: styles starts before end of data
if (mHeader->stylesStart >= (mSize - sizeof(uint16_t))) {
ALOGW("Bad style block: style block starts at %d past data size of %d\n",
(int)mHeader->stylesStart, (int)mHeader->header.size);
return (mError=BAD_TYPE);
}
// check invariant: styles follow the strings
if (mHeader->stylesStart <= mHeader->stringsStart) {
ALOGW("Bad style block: style block starts at %d, before strings at %d\n",
(int)mHeader->stylesStart, (int)mHeader->stringsStart);
return (mError=BAD_TYPE);
}
mStringPoolSize =
(mHeader->stylesStart-mHeader->stringsStart)/charSize;
}
// check invariant: stringCount > 0 requires a string pool to exist
if (mStringPoolSize == 0) {
ALOGW("Bad string block: stringCount is %d but pool size is 0\n", (int)mHeader->stringCount);
return (mError=BAD_TYPE);
}
if (notDeviceEndian) {
size_t i;
uint32_t* e = const_cast<uint32_t*>(mEntries);
for (i=0; i<mHeader->stringCount; i++) {
e[i] = dtohl(mEntries[i]);
}
if (!(mHeader->flags&ResStringPool_header::UTF8_FLAG)) {
const uint16_t* strings = (const uint16_t*)mStrings;
uint16_t* s = const_cast<uint16_t*>(strings);
for (i=0; i<mStringPoolSize; i++) {
s[i] = dtohs(strings[i]);
}
}
}
if ((mHeader->flags&ResStringPool_header::UTF8_FLAG &&
((uint8_t*)mStrings)[mStringPoolSize-1] != 0) ||
(!(mHeader->flags&ResStringPool_header::UTF8_FLAG) &&
((uint16_t*)mStrings)[mStringPoolSize-1] != 0)) {
ALOGW("Bad string block: last string is not 0-terminated\n");
return (mError=BAD_TYPE);
}
} else {
mStrings = NULL;
mStringPoolSize = 0;
}
if (mHeader->styleCount > 0) {
mEntryStyles = mEntries + mHeader->stringCount;
// invariant: integer overflow in calculating mEntryStyles
if (mEntryStyles < mEntries) {
ALOGW("Bad string block: integer overflow finding styles\n");
return (mError=BAD_TYPE);
}
if (((const uint8_t*)mEntryStyles-(const uint8_t*)mHeader) > (int)size) {
ALOGW("Bad string block: entry of %d styles extends past data size %d\n",
(int)((const uint8_t*)mEntryStyles-(const uint8_t*)mHeader),
(int)size);
return (mError=BAD_TYPE);
}
mStyles = (const uint32_t*)
(((const uint8_t*)data)+mHeader->stylesStart);
if (mHeader->stylesStart >= mHeader->header.size) {
ALOGW("Bad string block: style pool starts %d, after total size %d\n",
(int)mHeader->stylesStart, (int)mHeader->header.size);
return (mError=BAD_TYPE);
}
mStylePoolSize =
(mHeader->header.size-mHeader->stylesStart)/sizeof(uint32_t);
if (notDeviceEndian) {
size_t i;
uint32_t* e = const_cast<uint32_t*>(mEntryStyles);
for (i=0; i<mHeader->styleCount; i++) {
e[i] = dtohl(mEntryStyles[i]);
}
uint32_t* s = const_cast<uint32_t*>(mStyles);
for (i=0; i<mStylePoolSize; i++) {
s[i] = dtohl(mStyles[i]);
}
}
const ResStringPool_span endSpan = {
{ htodl(ResStringPool_span::END) },
htodl(ResStringPool_span::END), htodl(ResStringPool_span::END)
};
if (memcmp(&mStyles[mStylePoolSize-(sizeof(endSpan)/sizeof(uint32_t))],
&endSpan, sizeof(endSpan)) != 0) {
ALOGW("Bad string block: last style is not 0xFFFFFFFF-terminated\n");
return (mError=BAD_TYPE);
}
} else {
mEntryStyles = NULL;
mStyles = NULL;
mStylePoolSize = 0;
}
return (mError=NO_ERROR);
}
status_t ResStringPool::getError() const
{
return mError;
}
void ResStringPool::uninit()
{
mError = NO_INIT;
if (mHeader != NULL && mCache != NULL) {
for (size_t x = 0; x < mHeader->stringCount; x++) {
if (mCache[x] != NULL) {
free(mCache[x]);
mCache[x] = NULL;
}
}
free(mCache);
mCache = NULL;
}
if (mOwnedData) {
free(mOwnedData);
mOwnedData = NULL;
}
}
/**
* Strings in UTF-16 format have length indicated by a length encoded in the
* stored data. It is either 1 or 2 characters of length data. This allows a
* maximum length of 0x7FFFFFF (2147483647 bytes), but if you're storing that
* much data in a string, you're abusing them.
*
* If the high bit is set, then there are two characters or 4 bytes of length
* data encoded. In that case, drop the high bit of the first character and
* add it together with the next character.
*/
static inline size_t
decodeLength(const uint16_t** str)
{
size_t len = **str;
if ((len & 0x8000) != 0) {
(*str)++;
len = ((len & 0x7FFF) << 16) | **str;
}
(*str)++;
return len;
}
/**
* Strings in UTF-8 format have length indicated by a length encoded in the
* stored data. It is either 1 or 2 characters of length data. This allows a
* maximum length of 0x7FFF (32767 bytes), but you should consider storing
* text in another way if you're using that much data in a single string.
*
* If the high bit is set, then there are two characters or 2 bytes of length
* data encoded. In that case, drop the high bit of the first character and
* add it together with the next character.
*/
static inline size_t
decodeLength(const uint8_t** str)
{
size_t len = **str;
if ((len & 0x80) != 0) {
(*str)++;
len = ((len & 0x7F) << 8) | **str;
}
(*str)++;
return len;
}
const char16_t* ResStringPool::stringAt(size_t idx, size_t* u16len) const
{
if (mError == NO_ERROR && idx < mHeader->stringCount) {
const bool isUTF8 = (mHeader->flags&ResStringPool_header::UTF8_FLAG) != 0;
const uint32_t off = mEntries[idx]/(isUTF8?sizeof(uint8_t):sizeof(uint16_t));
if (off < (mStringPoolSize-1)) {
if (!isUTF8) {
const uint16_t* strings = (uint16_t*)mStrings;
const uint16_t* str = strings+off;
*u16len = decodeLength(&str);
if ((uint32_t)(str+*u16len-strings) < mStringPoolSize) {
// Reject malformed (non null-terminated) strings
if (str[*u16len] != 0x0000) {
ALOGW("Bad string block: string #%d is not null-terminated",
(int)idx);
return NULL;
}
return reinterpret_cast<const char16_t*>(str);
} else {
ALOGW("Bad string block: string #%d extends to %d, past end at %d\n",
(int)idx, (int)(str+*u16len-strings), (int)mStringPoolSize);
}
} else {
const uint8_t* strings = (uint8_t*)mStrings;
const uint8_t* u8str = strings+off;
*u16len = decodeLength(&u8str);
size_t u8len = decodeLength(&u8str);
// encLen must be less than 0x7FFF due to encoding.
if ((uint32_t)(u8str+u8len-strings) < mStringPoolSize) {
AutoMutex lock(mDecodeLock);
if (mCache != NULL && mCache[idx] != NULL) {
return mCache[idx];
}
// Retrieve the actual length of the utf8 string if the
// encoded length was truncated
if (stringDecodeAt(idx, u8str, u8len, &u8len) == NULL) {
return NULL;
}
// Since AAPT truncated lengths longer than 0x7FFF, check
// that the bits that remain after truncation at least match
// the bits of the actual length
ssize_t actualLen = utf8_to_utf16_length(u8str, u8len);
if (actualLen < 0 || ((size_t)actualLen & 0x7FFF) != *u16len) {
ALOGW("Bad string block: string #%lld decoded length is not correct "
"%lld vs %llu\n",
(long long)idx, (long long)actualLen, (long long)*u16len);
return NULL;
}
*u16len = (size_t) actualLen;
char16_t *u16str = (char16_t *)calloc(*u16len+1, sizeof(char16_t));
if (!u16str) {
ALOGW("No memory when trying to allocate decode cache for string #%d\n",
(int)idx);
return NULL;
}
utf8_to_utf16(u8str, u8len, u16str, *u16len + 1);
if (mCache == NULL) {
#ifndef __ANDROID__
if (kDebugStringPoolNoisy) {
ALOGI("CREATING STRING CACHE OF %zu bytes",
mHeader->stringCount*sizeof(char16_t**));
}
#else
// We do not want to be in this case when actually running Android.
ALOGW("CREATING STRING CACHE OF %zu bytes",
static_cast<size_t>(mHeader->stringCount*sizeof(char16_t**)));
#endif
mCache = (char16_t**)calloc(mHeader->stringCount, sizeof(char16_t*));
if (mCache == NULL) {
ALOGW("No memory trying to allocate decode cache table of %d bytes\n",
(int)(mHeader->stringCount*sizeof(char16_t**)));
return NULL;
}
}
if (kDebugStringPoolNoisy) {
ALOGI("Caching UTF8 string: %s", u8str);
}
mCache[idx] = u16str;
return u16str;
} else {
ALOGW("Bad string block: string #%lld extends to %lld, past end at %lld\n",
(long long)idx, (long long)(u8str+u8len-strings),
(long long)mStringPoolSize);
}
}
} else {
ALOGW("Bad string block: string #%d entry is at %d, past end at %d\n",
(int)idx, (int)(off*sizeof(uint16_t)),
(int)(mStringPoolSize*sizeof(uint16_t)));
}
}
return NULL;
}
const char* ResStringPool::string8At(size_t idx, size_t* outLen) const
{
if (mError == NO_ERROR && idx < mHeader->stringCount) {
if ((mHeader->flags&ResStringPool_header::UTF8_FLAG) == 0) {
return NULL;
}
const uint32_t off = mEntries[idx]/sizeof(char);
if (off < (mStringPoolSize-1)) {
const uint8_t* strings = (uint8_t*)mStrings;
const uint8_t* str = strings+off;
// Decode the UTF-16 length. This is not used if we're not
// converting to UTF-16 from UTF-8.
decodeLength(&str);
const size_t encLen = decodeLength(&str);
*outLen = encLen;
if ((uint32_t)(str+encLen-strings) < mStringPoolSize) {
return stringDecodeAt(idx, str, encLen, outLen);
} else {
ALOGW("Bad string block: string #%d extends to %d, past end at %d\n",
(int)idx, (int)(str+encLen-strings), (int)mStringPoolSize);
}
} else {
ALOGW("Bad string block: string #%d entry is at %d, past end at %d\n",
(int)idx, (int)(off*sizeof(uint16_t)),
(int)(mStringPoolSize*sizeof(uint16_t)));
}
}
return NULL;
}
/**
* AAPT incorrectly writes a truncated string length when the string size
* exceeded the maximum possible encode length value (0x7FFF). To decode a
* truncated length, iterate through length values that end in the encode length
* bits. Strings that exceed the maximum encode length are not placed into
* StringPools in AAPT2.
**/
const char* ResStringPool::stringDecodeAt(size_t idx, const uint8_t* str,
const size_t encLen, size_t* outLen) const {
const uint8_t* strings = (uint8_t*)mStrings;
size_t i = 0, end = encLen;
while ((uint32_t)(str+end-strings) < mStringPoolSize) {
if (str[end] == 0x00) {
if (i != 0) {
ALOGW("Bad string block: string #%d is truncated (actual length is %d)",
(int)idx, (int)end);
}
*outLen = end;
return (const char*)str;
}
end = (++i << (sizeof(uint8_t) * 8 * 2 - 1)) | encLen;
}
// Reject malformed (non null-terminated) strings
ALOGW("Bad string block: string #%d is not null-terminated",
(int)idx);
return NULL;
}
const String8 ResStringPool::string8ObjectAt(size_t idx) const
{
size_t len;
const char *str = string8At(idx, &len);
if (str != NULL) {
return String8(str, len);
}
const char16_t *str16 = stringAt(idx, &len);
if (str16 != NULL) {
return String8(str16, len);
}
return String8();
}
const ResStringPool_span* ResStringPool::styleAt(const ResStringPool_ref& ref) const
{
return styleAt(ref.index);
}
const ResStringPool_span* ResStringPool::styleAt(size_t idx) const
{
if (mError == NO_ERROR && idx < mHeader->styleCount) {
const uint32_t off = (mEntryStyles[idx]/sizeof(uint32_t));
if (off < mStylePoolSize) {
return (const ResStringPool_span*)(mStyles+off);
} else {
ALOGW("Bad string block: style #%d entry is at %d, past end at %d\n",
(int)idx, (int)(off*sizeof(uint32_t)),
(int)(mStylePoolSize*sizeof(uint32_t)));
}
}
return NULL;
}
ssize_t ResStringPool::indexOfString(const char16_t* str, size_t strLen) const
{
if (mError != NO_ERROR) {
return mError;
}
size_t len;
if ((mHeader->flags&ResStringPool_header::UTF8_FLAG) != 0) {
if (kDebugStringPoolNoisy) {
ALOGI("indexOfString UTF-8: %s", String8(str, strLen).string());
}
// The string pool contains UTF 8 strings; we don't want to cause
// temporary UTF-16 strings to be created as we search.
if (mHeader->flags&ResStringPool_header::SORTED_FLAG) {
// Do a binary search for the string... this is a little tricky,
// because the strings are sorted with strzcmp16(). So to match
// the ordering, we need to convert strings in the pool to UTF-16.
// But we don't want to hit the cache, so instead we will have a
// local temporary allocation for the conversions.
size_t convBufferLen = strLen + 4;
char16_t* convBuffer = (char16_t*)calloc(convBufferLen, sizeof(char16_t));
ssize_t l = 0;
ssize_t h = mHeader->stringCount-1;
ssize_t mid;
while (l <= h) {
mid = l + (h - l)/2;
const uint8_t* s = (const uint8_t*)string8At(mid, &len);
int c;
if (s != NULL) {
char16_t* end = utf8_to_utf16(s, len, convBuffer, convBufferLen);
c = strzcmp16(convBuffer, end-convBuffer, str, strLen);
} else {
c = -1;
}
if (kDebugStringPoolNoisy) {
ALOGI("Looking at %s, cmp=%d, l/mid/h=%d/%d/%d\n",
(const char*)s, c, (int)l, (int)mid, (int)h);
}
if (c == 0) {
if (kDebugStringPoolNoisy) {
ALOGI("MATCH!");
}
free(convBuffer);
return mid;
} else if (c < 0) {
l = mid + 1;
} else {
h = mid - 1;
}
}
free(convBuffer);
} else {
// It is unusual to get the ID from an unsorted string block...
// most often this happens because we want to get IDs for style
// span tags; since those always appear at the end of the string
// block, start searching at the back.
String8 str8(str, strLen);
const size_t str8Len = str8.size();
for (int i=mHeader->stringCount-1; i>=0; i--) {
const char* s = string8At(i, &len);
if (kDebugStringPoolNoisy) {
ALOGI("Looking at %s, i=%d\n", String8(s).string(), i);
}
if (s && str8Len == len && memcmp(s, str8.string(), str8Len) == 0) {
if (kDebugStringPoolNoisy) {
ALOGI("MATCH!");
}
return i;
}
}
}
} else {
if (kDebugStringPoolNoisy) {
ALOGI("indexOfString UTF-16: %s", String8(str, strLen).string());
}
if (mHeader->flags&ResStringPool_header::SORTED_FLAG) {
// Do a binary search for the string...
ssize_t l = 0;
ssize_t h = mHeader->stringCount-1;
ssize_t mid;
while (l <= h) {
mid = l + (h - l)/2;
const char16_t* s = stringAt(mid, &len);
int c = s ? strzcmp16(s, len, str, strLen) : -1;
if (kDebugStringPoolNoisy) {
ALOGI("Looking at %s, cmp=%d, l/mid/h=%d/%d/%d\n",
String8(s).string(), c, (int)l, (int)mid, (int)h);
}
if (c == 0) {
if (kDebugStringPoolNoisy) {
ALOGI("MATCH!");
}
return mid;
} else if (c < 0) {
l = mid + 1;
} else {
h = mid - 1;
}
}
} else {
// It is unusual to get the ID from an unsorted string block...
// most often this happens because we want to get IDs for style
// span tags; since those always appear at the end of the string
// block, start searching at the back.
for (int i=mHeader->stringCount-1; i>=0; i--) {
const char16_t* s = stringAt(i, &len);
if (kDebugStringPoolNoisy) {
ALOGI("Looking at %s, i=%d\n", String8(s).string(), i);
}
if (s && strLen == len && strzcmp16(s, len, str, strLen) == 0) {
if (kDebugStringPoolNoisy) {
ALOGI("MATCH!");
}
return i;
}
}
}
}
return NAME_NOT_FOUND;
}
size_t ResStringPool::size() const
{
return (mError == NO_ERROR) ? mHeader->stringCount : 0;
}
size_t ResStringPool::styleCount() const
{
return (mError == NO_ERROR) ? mHeader->styleCount : 0;
}
size_t ResStringPool::bytes() const
{
return (mError == NO_ERROR) ? mHeader->header.size : 0;
}
bool ResStringPool::isSorted() const
{
return (mHeader->flags&ResStringPool_header::SORTED_FLAG)!=0;
}
bool ResStringPool::isUTF8() const
{
return (mHeader->flags&ResStringPool_header::UTF8_FLAG)!=0;
}
// --------------------------------------------------------------------
// --------------------------------------------------------------------
// --------------------------------------------------------------------
ResXMLParser::ResXMLParser(const ResXMLTree& tree)
: mTree(tree), mEventCode(BAD_DOCUMENT)
{
}
void ResXMLParser::restart()
{
mCurNode = NULL;
mEventCode = mTree.mError == NO_ERROR ? START_DOCUMENT : BAD_DOCUMENT;
}
const ResStringPool& ResXMLParser::getStrings() const
{
return mTree.mStrings;
}
ResXMLParser::event_code_t ResXMLParser::getEventType() const
{
return mEventCode;
}
ResXMLParser::event_code_t ResXMLParser::next()
{
if (mEventCode == START_DOCUMENT) {
mCurNode = mTree.mRootNode;
mCurExt = mTree.mRootExt;
return (mEventCode=mTree.mRootCode);
} else if (mEventCode >= FIRST_CHUNK_CODE) {
return nextNode();
}
return mEventCode;
}
int32_t ResXMLParser::getCommentID() const
{
return mCurNode != NULL ? dtohl(mCurNode->comment.index) : -1;
}
const char16_t* ResXMLParser::getComment(size_t* outLen) const
{
int32_t id = getCommentID();
return id >= 0 ? mTree.mStrings.stringAt(id, outLen) : NULL;
}
uint32_t ResXMLParser::getLineNumber() const
{
return mCurNode != NULL ? dtohl(mCurNode->lineNumber) : -1;
}
int32_t ResXMLParser::getTextID() const
{
if (mEventCode == TEXT) {
return dtohl(((const ResXMLTree_cdataExt*)mCurExt)->data.index);
}
return -1;
}
const char16_t* ResXMLParser::getText(size_t* outLen) const
{
int32_t id = getTextID();
return id >= 0 ? mTree.mStrings.stringAt(id, outLen) : NULL;
}
ssize_t ResXMLParser::getTextValue(Res_value* outValue) const
{
if (mEventCode == TEXT) {
outValue->copyFrom_dtoh(((const ResXMLTree_cdataExt*)mCurExt)->typedData);
return sizeof(Res_value);
}
return BAD_TYPE;
}
int32_t ResXMLParser::getNamespacePrefixID() const
{
if (mEventCode == START_NAMESPACE || mEventCode == END_NAMESPACE) {
return dtohl(((const ResXMLTree_namespaceExt*)mCurExt)->prefix.index);
}
return -1;
}
const char16_t* ResXMLParser::getNamespacePrefix(size_t* outLen) const
{
int32_t id = getNamespacePrefixID();
//printf("prefix=%d event=%p\n", id, mEventCode);
return id >= 0 ? mTree.mStrings.stringAt(id, outLen) : NULL;
}
int32_t ResXMLParser::getNamespaceUriID() const
{
if (mEventCode == START_NAMESPACE || mEventCode == END_NAMESPACE) {
return dtohl(((const ResXMLTree_namespaceExt*)mCurExt)->uri.index);
}
return -1;
}
const char16_t* ResXMLParser::getNamespaceUri(size_t* outLen) const
{
int32_t id = getNamespaceUriID();
//printf("uri=%d event=%p\n", id, mEventCode);
return id >= 0 ? mTree.mStrings.stringAt(id, outLen) : NULL;
}
int32_t ResXMLParser::getElementNamespaceID() const
{
if (mEventCode == START_TAG) {
return dtohl(((const ResXMLTree_attrExt*)mCurExt)->ns.index);
}
if (mEventCode == END_TAG) {
return dtohl(((const ResXMLTree_endElementExt*)mCurExt)->ns.index);
}
return -1;
}
const char16_t* ResXMLParser::getElementNamespace(size_t* outLen) const
{
int32_t id = getElementNamespaceID();
return id >= 0 ? mTree.mStrings.stringAt(id, outLen) : NULL;
}
int32_t ResXMLParser::getElementNameID() const
{
if (mEventCode == START_TAG) {
return dtohl(((const ResXMLTree_attrExt*)mCurExt)->name.index);
}
if (mEventCode == END_TAG) {
return dtohl(((const ResXMLTree_endElementExt*)mCurExt)->name.index);
}
return -1;
}
const char16_t* ResXMLParser::getElementName(size_t* outLen) const
{
int32_t id = getElementNameID();
return id >= 0 ? mTree.mStrings.stringAt(id, outLen) : NULL;
}
size_t ResXMLParser::getAttributeCount() const
{
if (mEventCode == START_TAG) {
return dtohs(((const ResXMLTree_attrExt*)mCurExt)->attributeCount);
}
return 0;
}
int32_t ResXMLParser::getAttributeNamespaceID(size_t idx) const
{
if (mEventCode == START_TAG) {
const ResXMLTree_attrExt* tag = (const ResXMLTree_attrExt*)mCurExt;
if (idx < dtohs(tag->attributeCount)) {
const ResXMLTree_attribute* attr = (const ResXMLTree_attribute*)
(((const uint8_t*)tag)
+ dtohs(tag->attributeStart)
+ (dtohs(tag->attributeSize)*idx));
return dtohl(attr->ns.index);
}
}
return -2;
}
const char16_t* ResXMLParser::getAttributeNamespace(size_t idx, size_t* outLen) const
{
int32_t id = getAttributeNamespaceID(idx);
//printf("attribute namespace=%d idx=%d event=%p\n", id, idx, mEventCode);
if (kDebugXMLNoisy) {
printf("getAttributeNamespace 0x%zx=0x%x\n", idx, id);
}
return id >= 0 ? mTree.mStrings.stringAt(id, outLen) : NULL;
}
const char* ResXMLParser::getAttributeNamespace8(size_t idx, size_t* outLen) const
{
int32_t id = getAttributeNamespaceID(idx);
//printf("attribute namespace=%d idx=%d event=%p\n", id, idx, mEventCode);
if (kDebugXMLNoisy) {
printf("getAttributeNamespace 0x%zx=0x%x\n", idx, id);
}
return id >= 0 ? mTree.mStrings.string8At(id, outLen) : NULL;
}
int32_t ResXMLParser::getAttributeNameID(size_t idx) const
{
if (mEventCode == START_TAG) {
const ResXMLTree_attrExt* tag = (const ResXMLTree_attrExt*)mCurExt;
if (idx < dtohs(tag->attributeCount)) {
const ResXMLTree_attribute* attr = (const ResXMLTree_attribute*)
(((const uint8_t*)tag)
+ dtohs(tag->attributeStart)
+ (dtohs(tag->attributeSize)*idx));
return dtohl(attr->name.index);
}
}
return -1;
}
const char16_t* ResXMLParser::getAttributeName(size_t idx, size_t* outLen) const
{
int32_t id = getAttributeNameID(idx);
//printf("attribute name=%d idx=%d event=%p\n", id, idx, mEventCode);
if (kDebugXMLNoisy) {
printf("getAttributeName 0x%zx=0x%x\n", idx, id);
}
return id >= 0 ? mTree.mStrings.stringAt(id, outLen) : NULL;
}
const char* ResXMLParser::getAttributeName8(size_t idx, size_t* outLen) const
{
int32_t id = getAttributeNameID(idx);
//printf("attribute name=%d idx=%d event=%p\n", id, idx, mEventCode);
if (kDebugXMLNoisy) {
printf("getAttributeName 0x%zx=0x%x\n", idx, id);
}
return id >= 0 ? mTree.mStrings.string8At(id, outLen) : NULL;
}
uint32_t ResXMLParser::getAttributeNameResID(size_t idx) const
{
int32_t id = getAttributeNameID(idx);
if (id >= 0 && (size_t)id < mTree.mNumResIds) {
uint32_t resId = dtohl(mTree.mResIds[id]);
if (mTree.mDynamicRefTable != NULL) {
mTree.mDynamicRefTable->lookupResourceId(&resId);
}
return resId;
}
return 0;
}
int32_t ResXMLParser::getAttributeValueStringID(size_t idx) const
{
if (mEventCode == START_TAG) {
const ResXMLTree_attrExt* tag = (const ResXMLTree_attrExt*)mCurExt;
if (idx < dtohs(tag->attributeCount)) {
const ResXMLTree_attribute* attr = (const ResXMLTree_attribute*)
(((const uint8_t*)tag)
+ dtohs(tag->attributeStart)
+ (dtohs(tag->attributeSize)*idx));
return dtohl(attr->rawValue.index);
}
}
return -1;
}
const char16_t* ResXMLParser::getAttributeStringValue(size_t idx, size_t* outLen) const
{
int32_t id = getAttributeValueStringID(idx);
if (kDebugXMLNoisy) {
printf("getAttributeValue 0x%zx=0x%x\n", idx, id);
}
return id >= 0 ? mTree.mStrings.stringAt(id, outLen) : NULL;
}
int32_t ResXMLParser::getAttributeDataType(size_t idx) const
{
if (mEventCode == START_TAG) {
const ResXMLTree_attrExt* tag = (const ResXMLTree_attrExt*)mCurExt;
if (idx < dtohs(tag->attributeCount)) {
const ResXMLTree_attribute* attr = (const ResXMLTree_attribute*)
(((const uint8_t*)tag)
+ dtohs(tag->attributeStart)
+ (dtohs(tag->attributeSize)*idx));
uint8_t type = attr->typedValue.dataType;
if (type != Res_value::TYPE_DYNAMIC_REFERENCE) {
return type;
}
// This is a dynamic reference. We adjust those references
// to regular references at this level, so lie to the caller.
return Res_value::TYPE_REFERENCE;
}
}
return Res_value::TYPE_NULL;
}
int32_t ResXMLParser::getAttributeData(size_t idx) const
{
if (mEventCode == START_TAG) {
const ResXMLTree_attrExt* tag = (const ResXMLTree_attrExt*)mCurExt;
if (idx < dtohs(tag->attributeCount)) {
const ResXMLTree_attribute* attr = (const ResXMLTree_attribute*)
(((const uint8_t*)tag)
+ dtohs(tag->attributeStart)
+ (dtohs(tag->attributeSize)*idx));
if (attr->typedValue.dataType != Res_value::TYPE_DYNAMIC_REFERENCE ||
mTree.mDynamicRefTable == NULL) {
return dtohl(attr->typedValue.data);
}
uint32_t data = dtohl(attr->typedValue.data);
if (mTree.mDynamicRefTable->lookupResourceId(&data) == NO_ERROR) {
return data;
}
}
}
return 0;
}
ssize_t ResXMLParser::getAttributeValue(size_t idx, Res_value* outValue) const
{
if (mEventCode == START_TAG) {
const ResXMLTree_attrExt* tag = (const ResXMLTree_attrExt*)mCurExt;
if (idx < dtohs(tag->attributeCount)) {
const ResXMLTree_attribute* attr = (const ResXMLTree_attribute*)
(((const uint8_t*)tag)
+ dtohs(tag->attributeStart)
+ (dtohs(tag->attributeSize)*idx));
outValue->copyFrom_dtoh(attr->typedValue);
if (mTree.mDynamicRefTable != NULL &&
mTree.mDynamicRefTable->lookupResourceValue(outValue) != NO_ERROR) {
return BAD_TYPE;
}
return sizeof(Res_value);
}
}
return BAD_TYPE;
}
ssize_t ResXMLParser::indexOfAttribute(const char* ns, const char* attr) const
{
String16 nsStr(ns != NULL ? ns : "");
String16 attrStr(attr);
return indexOfAttribute(ns ? nsStr.string() : NULL, ns ? nsStr.size() : 0,
attrStr.string(), attrStr.size());
}
ssize_t ResXMLParser::indexOfAttribute(const char16_t* ns, size_t nsLen,
const char16_t* attr, size_t attrLen) const
{
if (mEventCode == START_TAG) {
if (attr == NULL) {
return NAME_NOT_FOUND;
}
const size_t N = getAttributeCount();
if (mTree.mStrings.isUTF8()) {
String8 ns8, attr8;
if (ns != NULL) {
ns8 = String8(ns, nsLen);
}
attr8 = String8(attr, attrLen);
if (kDebugStringPoolNoisy) {
ALOGI("indexOfAttribute UTF8 %s (%zu) / %s (%zu)", ns8.string(), nsLen,
attr8.string(), attrLen);
}
for (size_t i=0; i<N; i++) {
size_t curNsLen = 0, curAttrLen = 0;
const char* curNs = getAttributeNamespace8(i, &curNsLen);
const char* curAttr = getAttributeName8(i, &curAttrLen);
if (kDebugStringPoolNoisy) {
ALOGI(" curNs=%s (%zu), curAttr=%s (%zu)", curNs, curNsLen, curAttr, curAttrLen);
}
if (curAttr != NULL && curNsLen == nsLen && curAttrLen == attrLen
&& memcmp(attr8.string(), curAttr, attrLen) == 0) {
if (ns == NULL) {
if (curNs == NULL) {
if (kDebugStringPoolNoisy) {
ALOGI(" FOUND!");
}
return i;
}
} else if (curNs != NULL) {
//printf(" --> ns=%s, curNs=%s\n",
// String8(ns).string(), String8(curNs).string());
if (memcmp(ns8.string(), curNs, nsLen) == 0) {
if (kDebugStringPoolNoisy) {
ALOGI(" FOUND!");
}
return i;
}
}
}
}
} else {
if (kDebugStringPoolNoisy) {
ALOGI("indexOfAttribute UTF16 %s (%zu) / %s (%zu)",
String8(ns, nsLen).string(), nsLen,
String8(attr, attrLen).string(), attrLen);
}
for (size_t i=0; i<N; i++) {
size_t curNsLen = 0, curAttrLen = 0;
const char16_t* curNs = getAttributeNamespace(i, &curNsLen);
const char16_t* curAttr = getAttributeName(i, &curAttrLen);
if (kDebugStringPoolNoisy) {
ALOGI(" curNs=%s (%zu), curAttr=%s (%zu)",
String8(curNs, curNsLen).string(), curNsLen,
String8(curAttr, curAttrLen).string(), curAttrLen);
}
if (curAttr != NULL && curNsLen == nsLen && curAttrLen == attrLen
&& (memcmp(attr, curAttr, attrLen*sizeof(char16_t)) == 0)) {
if (ns == NULL) {
if (curNs == NULL) {
if (kDebugStringPoolNoisy) {
ALOGI(" FOUND!");
}
return i;
}
} else if (curNs != NULL) {
//printf(" --> ns=%s, curNs=%s\n",
// String8(ns).string(), String8(curNs).string());
if (memcmp(ns, curNs, nsLen*sizeof(char16_t)) == 0) {
if (kDebugStringPoolNoisy) {
ALOGI(" FOUND!");
}
return i;
}
}
}
}
}
}
return NAME_NOT_FOUND;
}
ssize_t ResXMLParser::indexOfID() const
{
if (mEventCode == START_TAG) {
const ssize_t idx = dtohs(((const ResXMLTree_attrExt*)mCurExt)->idIndex);
if (idx > 0) return (idx-1);
}
return NAME_NOT_FOUND;
}
ssize_t ResXMLParser::indexOfClass() const
{
if (mEventCode == START_TAG) {
const ssize_t idx = dtohs(((const ResXMLTree_attrExt*)mCurExt)->classIndex);
if (idx > 0) return (idx-1);
}
return NAME_NOT_FOUND;
}
ssize_t ResXMLParser::indexOfStyle() const
{
if (mEventCode == START_TAG) {
const ssize_t idx = dtohs(((const ResXMLTree_attrExt*)mCurExt)->styleIndex);
if (idx > 0) return (idx-1);
}
return NAME_NOT_FOUND;
}
ResXMLParser::event_code_t ResXMLParser::nextNode()
{
if (mEventCode < 0) {
return mEventCode;
}
do {
const ResXMLTree_node* next = (const ResXMLTree_node*)
(((const uint8_t*)mCurNode) + dtohl(mCurNode->header.size));
if (kDebugXMLNoisy) {
ALOGI("Next node: prev=%p, next=%p\n", mCurNode, next);
}
if (((const uint8_t*)next) >= mTree.mDataEnd) {
mCurNode = NULL;
return (mEventCode=END_DOCUMENT);
}
if (mTree.validateNode(next) != NO_ERROR) {
mCurNode = NULL;
return (mEventCode=BAD_DOCUMENT);
}
mCurNode = next;
const uint16_t headerSize = dtohs(next->header.headerSize);
const uint32_t totalSize = dtohl(next->header.size);
mCurExt = ((const uint8_t*)next) + headerSize;
size_t minExtSize = 0;
event_code_t eventCode = (event_code_t)dtohs(next->header.type);
switch ((mEventCode=eventCode)) {
case RES_XML_START_NAMESPACE_TYPE:
case RES_XML_END_NAMESPACE_TYPE:
minExtSize = sizeof(ResXMLTree_namespaceExt);
break;
case RES_XML_START_ELEMENT_TYPE:
minExtSize = sizeof(ResXMLTree_attrExt);
break;
case RES_XML_END_ELEMENT_TYPE:
minExtSize = sizeof(ResXMLTree_endElementExt);
break;
case RES_XML_CDATA_TYPE:
minExtSize = sizeof(ResXMLTree_cdataExt);
break;
default:
ALOGW("Unknown XML block: header type %d in node at %d\n",
(int)dtohs(next->header.type),
(int)(((const uint8_t*)next)-((const uint8_t*)mTree.mHeader)));
continue;
}
if ((totalSize-headerSize) < minExtSize) {
ALOGW("Bad XML block: header type 0x%x in node at 0x%x has size %d, need %d\n",
(int)dtohs(next->header.type),
(int)(((const uint8_t*)next)-((const uint8_t*)mTree.mHeader)),
(int)(totalSize-headerSize), (int)minExtSize);
return (mEventCode=BAD_DOCUMENT);
}
//printf("CurNode=%p, CurExt=%p, headerSize=%d, minExtSize=%d\n",
// mCurNode, mCurExt, headerSize, minExtSize);
return eventCode;
} while (true);
}
void ResXMLParser::getPosition(ResXMLParser::ResXMLPosition* pos) const
{
pos->eventCode = mEventCode;
pos->curNode = mCurNode;
pos->curExt = mCurExt;
}
void ResXMLParser::setPosition(const ResXMLParser::ResXMLPosition& pos)
{
mEventCode = pos.eventCode;
mCurNode = pos.curNode;
mCurExt = pos.curExt;
}
// --------------------------------------------------------------------
static volatile int32_t gCount = 0;
ResXMLTree::ResXMLTree(const DynamicRefTable* dynamicRefTable)
: ResXMLParser(*this)
, mDynamicRefTable((dynamicRefTable != nullptr) ? dynamicRefTable->clone()
: std::unique_ptr<DynamicRefTable>(nullptr))
, mError(NO_INIT), mOwnedData(NULL)
{
if (kDebugResXMLTree) {
ALOGI("Creating ResXMLTree %p #%d\n", this, android_atomic_inc(&gCount)+1);
}
restart();
}
ResXMLTree::ResXMLTree()
: ResXMLParser(*this)
, mDynamicRefTable(std::unique_ptr<DynamicRefTable>(nullptr))
, mError(NO_INIT), mOwnedData(NULL)
{
if (kDebugResXMLTree) {
ALOGI("Creating ResXMLTree %p #%d\n", this, android_atomic_inc(&gCount)+1);
}
restart();
}
ResXMLTree::~ResXMLTree()
{
if (kDebugResXMLTree) {
ALOGI("Destroying ResXMLTree in %p #%d\n", this, android_atomic_dec(&gCount)-1);
}
uninit();
}
status_t ResXMLTree::setTo(const void* data, size_t size, bool copyData)
{
uninit();
mEventCode = START_DOCUMENT;
if (!data || !size) {
return (mError=BAD_TYPE);
}
if (copyData) {
mOwnedData = malloc(size);
if (mOwnedData == NULL) {
return (mError=NO_MEMORY);
}
memcpy(mOwnedData, data, size);
data = mOwnedData;
}
mHeader = (const ResXMLTree_header*)data;
mSize = dtohl(mHeader->header.size);
if (dtohs(mHeader->header.headerSize) > mSize || mSize > size) {
ALOGW("Bad XML block: header size %d or total size %d is larger than data size %d\n",
(int)dtohs(mHeader->header.headerSize),
(int)dtohl(mHeader->header.size), (int)size);
mError = BAD_TYPE;
restart();
return mError;
}
mDataEnd = ((const uint8_t*)mHeader) + mSize;
mStrings.uninit();
mRootNode = NULL;
mResIds = NULL;
mNumResIds = 0;
// First look for a couple interesting chunks: the string block
// and first XML node.
const ResChunk_header* chunk =
(const ResChunk_header*)(((const uint8_t*)mHeader) + dtohs(mHeader->header.headerSize));
const ResChunk_header* lastChunk = chunk;
while (((const uint8_t*)chunk) < (mDataEnd-sizeof(ResChunk_header)) &&
((const uint8_t*)chunk) < (mDataEnd-dtohl(chunk->size))) {
status_t err = validate_chunk(chunk, sizeof(ResChunk_header), mDataEnd, "XML");
if (err != NO_ERROR) {
mError = err;
goto done;
}
const uint16_t type = dtohs(chunk->type);
const size_t size = dtohl(chunk->size);
if (kDebugXMLNoisy) {
printf("Scanning @ %p: type=0x%x, size=0x%zx\n",
(void*)(((uintptr_t)chunk)-((uintptr_t)mHeader)), type, size);
}
if (type == RES_STRING_POOL_TYPE) {
mStrings.setTo(chunk, size);
} else if (type == RES_XML_RESOURCE_MAP_TYPE) {
mResIds = (const uint32_t*)
(((const uint8_t*)chunk)+dtohs(chunk->headerSize));
mNumResIds = (dtohl(chunk->size)-dtohs(chunk->headerSize))/sizeof(uint32_t);
} else if (type >= RES_XML_FIRST_CHUNK_TYPE
&& type <= RES_XML_LAST_CHUNK_TYPE) {
if (validateNode((const ResXMLTree_node*)chunk) != NO_ERROR) {
mError = BAD_TYPE;
goto done;
}
mCurNode = (const ResXMLTree_node*)lastChunk;
if (nextNode() == BAD_DOCUMENT) {
mError = BAD_TYPE;
goto done;
}
mRootNode = mCurNode;
mRootExt = mCurExt;
mRootCode = mEventCode;
break;
} else {
if (kDebugXMLNoisy) {
printf("Skipping unknown chunk!\n");
}
}
lastChunk = chunk;
chunk = (const ResChunk_header*)
(((const uint8_t*)chunk) + size);
}
if (mRootNode == NULL) {
ALOGW("Bad XML block: no root element node found\n");
mError = BAD_TYPE;
goto done;
}
mError = mStrings.getError();
done:
restart();
return mError;
}
status_t ResXMLTree::getError() const
{
return mError;
}
void ResXMLTree::uninit()
{
mError = NO_INIT;
mStrings.uninit();
if (mOwnedData) {
free(mOwnedData);
mOwnedData = NULL;
}
restart();
}
status_t ResXMLTree::validateNode(const ResXMLTree_node* node) const
{
const uint16_t eventCode = dtohs(node->header.type);
status_t err = validate_chunk(
&node->header, sizeof(ResXMLTree_node),
mDataEnd, "ResXMLTree_node");
if (err >= NO_ERROR) {
// Only perform additional validation on START nodes
if (eventCode != RES_XML_START_ELEMENT_TYPE) {
return NO_ERROR;
}
const uint16_t headerSize = dtohs(node->header.headerSize);
const uint32_t size = dtohl(node->header.size);
const ResXMLTree_attrExt* attrExt = (const ResXMLTree_attrExt*)
(((const uint8_t*)node) + headerSize);
// check for sensical values pulled out of the stream so far...
if ((size >= headerSize + sizeof(ResXMLTree_attrExt))
&& ((void*)attrExt > (void*)node)) {
const size_t attrSize = ((size_t)dtohs(attrExt->attributeSize))
* dtohs(attrExt->attributeCount);
if ((dtohs(attrExt->attributeStart)+attrSize) <= (size-headerSize)) {
return NO_ERROR;
}
ALOGW("Bad XML block: node attributes use 0x%x bytes, only have 0x%x bytes\n",
(unsigned int)(dtohs(attrExt->attributeStart)+attrSize),
(unsigned int)(size-headerSize));
}
else {
ALOGW("Bad XML start block: node header size 0x%x, size 0x%x\n",
(unsigned int)headerSize, (unsigned int)size);
}
return BAD_TYPE;
}
return err;
#if 0
const bool isStart = dtohs(node->header.type) == RES_XML_START_ELEMENT_TYPE;
const uint16_t headerSize = dtohs(node->header.headerSize);
const uint32_t size = dtohl(node->header.size);
if (headerSize >= (isStart ? sizeof(ResXMLTree_attrNode) : sizeof(ResXMLTree_node))) {
if (size >= headerSize) {
if (((const uint8_t*)node) <= (mDataEnd-size)) {
if (!isStart) {
return NO_ERROR;
}
if ((((size_t)dtohs(node->attributeSize))*dtohs(node->attributeCount))
<= (size-headerSize)) {
return NO_ERROR;
}
ALOGW("Bad XML block: node attributes use 0x%x bytes, only have 0x%x bytes\n",
((int)dtohs(node->attributeSize))*dtohs(node->attributeCount),
(int)(size-headerSize));
return BAD_TYPE;
}
ALOGW("Bad XML block: node at 0x%x extends beyond data end 0x%x\n",
(int)(((const uint8_t*)node)-((const uint8_t*)mHeader)), (int)mSize);
return BAD_TYPE;
}
ALOGW("Bad XML block: node at 0x%x header size 0x%x smaller than total size 0x%x\n",
(int)(((const uint8_t*)node)-((const uint8_t*)mHeader)),
(int)headerSize, (int)size);
return BAD_TYPE;
}
ALOGW("Bad XML block: node at 0x%x header size 0x%x too small\n",
(int)(((const uint8_t*)node)-((const uint8_t*)mHeader)),
(int)headerSize);
return BAD_TYPE;
#endif
}
// --------------------------------------------------------------------
// --------------------------------------------------------------------
// --------------------------------------------------------------------
void ResTable_config::copyFromDeviceNoSwap(const ResTable_config& o) {
const size_t size = dtohl(o.size);
if (size >= sizeof(ResTable_config)) {
*this = o;
} else {
memcpy(this, &o, size);
memset(((uint8_t*)this)+size, 0, sizeof(ResTable_config)-size);
}
}
/* static */ size_t unpackLanguageOrRegion(const char in[2], const char base,
char out[4]) {
if (in[0] & 0x80) {
// The high bit is "1", which means this is a packed three letter
// language code.
// The smallest 5 bits of the second char are the first alphabet.
const uint8_t first = in[1] & 0x1f;
// The last three bits of the second char and the first two bits
// of the first char are the second alphabet.
const uint8_t second = ((in[1] & 0xe0) >> 5) + ((in[0] & 0x03) << 3);
// Bits 3 to 7 (inclusive) of the first char are the third alphabet.
const uint8_t third = (in[0] & 0x7c) >> 2;
out[0] = first + base;
out[1] = second + base;
out[2] = third + base;
out[3] = 0;
return 3;
}
if (in[0]) {
memcpy(out, in, 2);
memset(out + 2, 0, 2);
return 2;
}
memset(out, 0, 4);
return 0;
}
/* static */ void packLanguageOrRegion(const char* in, const char base,
char out[2]) {
if (in[2] == 0 || in[2] == '-') {
out[0] = in[0];
out[1] = in[1];
} else {
uint8_t first = (in[0] - base) & 0x007f;
uint8_t second = (in[1] - base) & 0x007f;
uint8_t third = (in[2] - base) & 0x007f;
out[0] = (0x80 | (third << 2) | (second >> 3));
out[1] = ((second << 5) | first);
}
}
void ResTable_config::packLanguage(const char* language) {
packLanguageOrRegion(language, 'a', this->language);
}
void ResTable_config::packRegion(const char* region) {
packLanguageOrRegion(region, '0', this->country);
}
size_t ResTable_config::unpackLanguage(char language[4]) const {
return unpackLanguageOrRegion(this->language, 'a', language);
}
size_t ResTable_config::unpackRegion(char region[4]) const {
return unpackLanguageOrRegion(this->country, '0', region);
}
void ResTable_config::copyFromDtoH(const ResTable_config& o) {
copyFromDeviceNoSwap(o);
size = sizeof(ResTable_config);
mcc = dtohs(mcc);
mnc = dtohs(mnc);
density = dtohs(density);
screenWidth = dtohs(screenWidth);
screenHeight = dtohs(screenHeight);
sdkVersion = dtohs(sdkVersion);
minorVersion = dtohs(minorVersion);
smallestScreenWidthDp = dtohs(smallestScreenWidthDp);
screenWidthDp = dtohs(screenWidthDp);
screenHeightDp = dtohs(screenHeightDp);
}
void ResTable_config::swapHtoD() {
size = htodl(size);
mcc = htods(mcc);
mnc = htods(mnc);
density = htods(density);
screenWidth = htods(screenWidth);
screenHeight = htods(screenHeight);
sdkVersion = htods(sdkVersion);
minorVersion = htods(minorVersion);
smallestScreenWidthDp = htods(smallestScreenWidthDp);
screenWidthDp = htods(screenWidthDp);
screenHeightDp = htods(screenHeightDp);
}
/* static */ inline int compareLocales(const ResTable_config &l, const ResTable_config &r) {
if (l.locale != r.locale) {
return (l.locale > r.locale) ? 1 : -1;
}
// The language & region are equal, so compare the scripts, variants and
// numbering systms in this order. Comparison of variants and numbering
// systems should happen very infrequently (if at all.)
// The comparison code relies on memcmp low-level optimizations that make it
// more efficient than strncmp.
const char emptyScript[sizeof(l.localeScript)] = {'\0', '\0', '\0', '\0'};
const char *lScript = l.localeScriptWasComputed ? emptyScript : l.localeScript;
const char *rScript = r.localeScriptWasComputed ? emptyScript : r.localeScript;
int script = memcmp(lScript, rScript, sizeof(l.localeScript));
if (script) {
return script;
}
int variant = memcmp(l.localeVariant, r.localeVariant, sizeof(l.localeVariant));
if (variant) {
return variant;
}
return memcmp(l.localeNumberingSystem, r.localeNumberingSystem,
sizeof(l.localeNumberingSystem));
}
int ResTable_config::compare(const ResTable_config& o) const {
if (imsi != o.imsi) {
return (imsi > o.imsi) ? 1 : -1;
}
int32_t diff = compareLocales(*this, o);
if (diff < 0) {
return -1;
}
if (diff > 0) {
return 1;
}
if (screenType != o.screenType) {
return (screenType > o.screenType) ? 1 : -1;
}
if (input != o.input) {
return (input > o.input) ? 1 : -1;
}
if (screenSize != o.screenSize) {
return (screenSize > o.screenSize) ? 1 : -1;
}
if (version != o.version) {
return (version > o.version) ? 1 : -1;
}
if (screenLayout != o.screenLayout) {
return (screenLayout > o.screenLayout) ? 1 : -1;
}
if (screenLayout2 != o.screenLayout2) {
return (screenLayout2 > o.screenLayout2) ? 1 : -1;
}
if (colorMode != o.colorMode) {
return (colorMode > o.colorMode) ? 1 : -1;
}
if (uiMode != o.uiMode) {
return (uiMode > o.uiMode) ? 1 : -1;
}
if (smallestScreenWidthDp != o.smallestScreenWidthDp) {
return (smallestScreenWidthDp > o.smallestScreenWidthDp) ? 1 : -1;
}
if (screenSizeDp != o.screenSizeDp) {
return (screenSizeDp > o.screenSizeDp) ? 1 : -1;
}
return 0;
}
int ResTable_config::compareLogical(const ResTable_config& o) const {
if (mcc != o.mcc) {
return mcc < o.mcc ? -1 : 1;
}
if (mnc != o.mnc) {
return mnc < o.mnc ? -1 : 1;
}
int diff = compareLocales(*this, o);
if (diff < 0) {
return -1;
}
if (diff > 0) {
return 1;
}
if ((screenLayout & MASK_LAYOUTDIR) != (o.screenLayout & MASK_LAYOUTDIR)) {
return (screenLayout & MASK_LAYOUTDIR) < (o.screenLayout & MASK_LAYOUTDIR) ? -1 : 1;
}
if (smallestScreenWidthDp != o.smallestScreenWidthDp) {
return smallestScreenWidthDp < o.smallestScreenWidthDp ? -1 : 1;
}
if (screenWidthDp != o.screenWidthDp) {
return screenWidthDp < o.screenWidthDp ? -1 : 1;
}
if (screenHeightDp != o.screenHeightDp) {
return screenHeightDp < o.screenHeightDp ? -1 : 1;
}
if (screenWidth != o.screenWidth) {
return screenWidth < o.screenWidth ? -1 : 1;
}
if (screenHeight != o.screenHeight) {
return screenHeight < o.screenHeight ? -1 : 1;
}
if (density != o.density) {
return density < o.density ? -1 : 1;
}
if (orientation != o.orientation) {
return orientation < o.orientation ? -1 : 1;
}
if (touchscreen != o.touchscreen) {
return touchscreen < o.touchscreen ? -1 : 1;
}
if (input != o.input) {
return input < o.input ? -1 : 1;
}
if (screenLayout != o.screenLayout) {
return screenLayout < o.screenLayout ? -1 : 1;
}
if (screenLayout2 != o.screenLayout2) {
return screenLayout2 < o.screenLayout2 ? -1 : 1;
}
if (colorMode != o.colorMode) {
return colorMode < o.colorMode ? -1 : 1;
}
if (uiMode != o.uiMode) {
return uiMode < o.uiMode ? -1 : 1;
}
if (version != o.version) {
return version < o.version ? -1 : 1;
}
return 0;
}
int ResTable_config::diff(const ResTable_config& o) const {
int diffs = 0;
if (mcc != o.mcc) diffs |= CONFIG_MCC;
if (mnc != o.mnc) diffs |= CONFIG_MNC;
if (orientation != o.orientation) diffs |= CONFIG_ORIENTATION;
if (density != o.density) diffs |= CONFIG_DENSITY;
if (touchscreen != o.touchscreen) diffs |= CONFIG_TOUCHSCREEN;
if (((inputFlags^o.inputFlags)&(MASK_KEYSHIDDEN|MASK_NAVHIDDEN)) != 0)
diffs |= CONFIG_KEYBOARD_HIDDEN;
if (keyboard != o.keyboard) diffs |= CONFIG_KEYBOARD;
if (navigation != o.navigation) diffs |= CONFIG_NAVIGATION;
if (screenSize != o.screenSize) diffs |= CONFIG_SCREEN_SIZE;
if (version != o.version) diffs |= CONFIG_VERSION;
if ((screenLayout & MASK_LAYOUTDIR) != (o.screenLayout & MASK_LAYOUTDIR)) diffs |= CONFIG_LAYOUTDIR;
if ((screenLayout & ~MASK_LAYOUTDIR) != (o.screenLayout & ~MASK_LAYOUTDIR)) diffs |= CONFIG_SCREEN_LAYOUT;
if ((screenLayout2 & MASK_SCREENROUND) != (o.screenLayout2 & MASK_SCREENROUND)) diffs |= CONFIG_SCREEN_ROUND;
if ((colorMode & MASK_WIDE_COLOR_GAMUT) != (o.colorMode & MASK_WIDE_COLOR_GAMUT)) diffs |= CONFIG_COLOR_MODE;
if ((colorMode & MASK_HDR) != (o.colorMode & MASK_HDR)) diffs |= CONFIG_COLOR_MODE;
if (uiMode != o.uiMode) diffs |= CONFIG_UI_MODE;
if (smallestScreenWidthDp != o.smallestScreenWidthDp) diffs |= CONFIG_SMALLEST_SCREEN_SIZE;
if (screenSizeDp != o.screenSizeDp) diffs |= CONFIG_SCREEN_SIZE;
const int diff = compareLocales(*this, o);
if (diff) diffs |= CONFIG_LOCALE;
return diffs;
}
// There isn't a well specified "importance" order between variants and
// scripts. We can't easily tell whether, say "en-Latn-US" is more or less
// specific than "en-US-POSIX".
//
// We therefore arbitrarily decide to give priority to variants over
// scripts since it seems more useful to do so. We will consider
// "en-US-POSIX" to be more specific than "en-Latn-US".
//
// Unicode extension keywords are considered to be less important than
// scripts and variants.
inline int ResTable_config::getImportanceScoreOfLocale() const {
return (localeVariant[0] ? 4 : 0)
+ (localeScript[0] && !localeScriptWasComputed ? 2: 0)
+ (localeNumberingSystem[0] ? 1: 0);
}
int ResTable_config::isLocaleMoreSpecificThan(const ResTable_config& o) const {
if (locale || o.locale) {
if (language[0] != o.language[0]) {
if (!language[0]) return -1;
if (!o.language[0]) return 1;
}
if (country[0] != o.country[0]) {
if (!country[0]) return -1;
if (!o.country[0]) return 1;
}
}
return getImportanceScoreOfLocale() - o.getImportanceScoreOfLocale();
}
bool ResTable_config::isMoreSpecificThan(const ResTable_config& o) const {
// The order of the following tests defines the importance of one
// configuration parameter over another. Those tests first are more
// important, trumping any values in those following them.
if (imsi || o.imsi) {
if (mcc != o.mcc) {
if (!mcc) return false;
if (!o.mcc) return true;
}
if (mnc != o.mnc) {
if (!mnc) return false;
if (!o.mnc) return true;
}
}
if (locale || o.locale) {
const int diff = isLocaleMoreSpecificThan(o);
if (diff < 0) {
return false;
}
if (diff > 0) {
return true;
}
}
if (screenLayout || o.screenLayout) {
if (((screenLayout^o.screenLayout) & MASK_LAYOUTDIR) != 0) {
if (!(screenLayout & MASK_LAYOUTDIR)) return false;
if (!(o.screenLayout & MASK_LAYOUTDIR)) return true;
}
}
if (smallestScreenWidthDp || o.smallestScreenWidthDp) {
if (smallestScreenWidthDp != o.smallestScreenWidthDp) {
if (!smallestScreenWidthDp) return false;
if (!o.smallestScreenWidthDp) return true;
}
}
if (screenSizeDp || o.screenSizeDp) {
if (screenWidthDp != o.screenWidthDp) {
if (!screenWidthDp) return false;
if (!o.screenWidthDp) return true;
}
if (screenHeightDp != o.screenHeightDp) {
if (!screenHeightDp) return false;
if (!o.screenHeightDp) return true;
}
}
if (screenLayout || o.screenLayout) {
if (((screenLayout^o.screenLayout) & MASK_SCREENSIZE) != 0) {
if (!(screenLayout & MASK_SCREENSIZE)) return false;
if (!(o.screenLayout & MASK_SCREENSIZE)) return true;
}
if (((screenLayout^o.screenLayout) & MASK_SCREENLONG) != 0) {
if (!(screenLayout & MASK_SCREENLONG)) return false;
if (!(o.screenLayout & MASK_SCREENLONG)) return true;
}
}
if (screenLayout2 || o.screenLayout2) {
if (((screenLayout2^o.screenLayout2) & MASK_SCREENROUND) != 0) {
if (!(screenLayout2 & MASK_SCREENROUND)) return false;
if (!(o.screenLayout2 & MASK_SCREENROUND)) return true;
}
}
if (colorMode || o.colorMode) {
if (((colorMode^o.colorMode) & MASK_HDR) != 0) {
if (!(colorMode & MASK_HDR)) return false;
if (!(o.colorMode & MASK_HDR)) return true;
}
if (((colorMode^o.colorMode) & MASK_WIDE_COLOR_GAMUT) != 0) {
if (!(colorMode & MASK_WIDE_COLOR_GAMUT)) return false;
if (!(o.colorMode & MASK_WIDE_COLOR_GAMUT)) return true;
}
}
if (orientation != o.orientation) {
if (!orientation) return false;
if (!o.orientation) return true;
}
if (uiMode || o.uiMode) {
if (((uiMode^o.uiMode) & MASK_UI_MODE_TYPE) != 0) {
if (!(uiMode & MASK_UI_MODE_TYPE)) return false;
if (!(o.uiMode & MASK_UI_MODE_TYPE)) return true;
}
if (((uiMode^o.uiMode) & MASK_UI_MODE_NIGHT) != 0) {
if (!(uiMode & MASK_UI_MODE_NIGHT)) return false;
if (!(o.uiMode & MASK_UI_MODE_NIGHT)) return true;
}
}
// density is never 'more specific'
// as the default just equals 160
if (touchscreen != o.touchscreen) {
if (!touchscreen) return false;
if (!o.touchscreen) return true;
}
if (input || o.input) {
if (((inputFlags^o.inputFlags) & MASK_KEYSHIDDEN) != 0) {
if (!(inputFlags & MASK_KEYSHIDDEN)) return false;
if (!(o.inputFlags & MASK_KEYSHIDDEN)) return true;
}
if (((inputFlags^o.inputFlags) & MASK_NAVHIDDEN) != 0) {
if (!(inputFlags & MASK_NAVHIDDEN)) return false;
if (!(o.inputFlags & MASK_NAVHIDDEN)) return true;
}
if (keyboard != o.keyboard) {
if (!keyboard) return false;
if (!o.keyboard) return true;
}
if (navigation != o.navigation) {
if (!navigation) return false;
if (!o.navigation) return true;
}
}
if (screenSize || o.screenSize) {
if (screenWidth != o.screenWidth) {
if (!screenWidth) return false;
if (!o.screenWidth) return true;
}
if (screenHeight != o.screenHeight) {
if (!screenHeight) return false;
if (!o.screenHeight) return true;
}
}
if (version || o.version) {
if (sdkVersion != o.sdkVersion) {
if (!sdkVersion) return false;
if (!o.sdkVersion) return true;
}
if (minorVersion != o.minorVersion) {
if (!minorVersion) return false;
if (!o.minorVersion) return true;
}
}
return false;
}
// Codes for specially handled languages and regions
static const char kEnglish[2] = {'e', 'n'}; // packed version of "en"
static const char kUnitedStates[2] = {'U', 'S'}; // packed version of "US"
static const char kFilipino[2] = {'\xAD', '\x05'}; // packed version of "fil"
static const char kTagalog[2] = {'t', 'l'}; // packed version of "tl"
// Checks if two language or region codes are identical
inline bool areIdentical(const char code1[2], const char code2[2]) {
return code1[0] == code2[0] && code1[1] == code2[1];
}
inline bool langsAreEquivalent(const char lang1[2], const char lang2[2]) {
return areIdentical(lang1, lang2) ||
(areIdentical(lang1, kTagalog) && areIdentical(lang2, kFilipino)) ||
(areIdentical(lang1, kFilipino) && areIdentical(lang2, kTagalog));
}
bool ResTable_config::isLocaleBetterThan(const ResTable_config& o,
const ResTable_config* requested) const {
if (requested->locale == 0) {
// The request doesn't have a locale, so no resource is better
// than the other.
return false;
}
if (locale == 0 && o.locale == 0) {
// The locale part of both resources is empty, so none is better
// than the other.
return false;
}
// Non-matching locales have been filtered out, so both resources
// match the requested locale.
//
// Because of the locale-related checks in match() and the checks, we know
// that:
// 1) The resource languages are either empty or match the request;
// and
// 2) If the request's script is known, the resource scripts are either
// unknown or match the request.
if (!langsAreEquivalent(language, o.language)) {
// The languages of the two resources are not equivalent. If we are
// here, we can only assume that the two resources matched the request
// because one doesn't have a language and the other has a matching
// language.
//
// We consider the one that has the language specified a better match.
//
// The exception is that we consider no-language resources a better match
// for US English and similar locales than locales that are a descendant
// of Internatinal English (en-001), since no-language resources are
// where the US English resource have traditionally lived for most apps.
if (areIdentical(requested->language, kEnglish)) {
if (areIdentical(requested->country, kUnitedStates)) {
// For US English itself, we consider a no-locale resource a
// better match if the other resource has a country other than
// US specified.
if (language[0] != '\0') {
return country[0] == '\0' || areIdentical(country, kUnitedStates);
} else {
return !(o.country[0] == '\0' || areIdentical(o.country, kUnitedStates));
}
} else if (localeDataIsCloseToUsEnglish(requested->country)) {
if (language[0] != '\0') {
return localeDataIsCloseToUsEnglish(country);
} else {
return !localeDataIsCloseToUsEnglish(o.country);
}
}
}
return (language[0] != '\0');
}
// If we are here, both the resources have an equivalent non-empty language
// to the request.
//
// Because the languages are equivalent, computeScript() always returns a
// non-empty script for languages it knows about, and we have passed the
// script checks in match(), the scripts are either all unknown or are all
// the same. So we can't gain anything by checking the scripts. We need to
// check the region and variant.
// See if any of the regions is better than the other.
const int region_comparison = localeDataCompareRegions(
country, o.country,
requested->language, requested->localeScript, requested->country);
if (region_comparison != 0) {
return (region_comparison > 0);
}
// The regions are the same. Try the variant.
const bool localeMatches = strncmp(
localeVariant, requested->localeVariant, sizeof(localeVariant)) == 0;
const bool otherMatches = strncmp(
o.localeVariant, requested->localeVariant, sizeof(localeVariant)) == 0;
if (localeMatches != otherMatches) {
return localeMatches;
}
// The variants are the same, try numbering system.
const bool localeNumsysMatches = strncmp(localeNumberingSystem,
requested->localeNumberingSystem,
sizeof(localeNumberingSystem)) == 0;
const bool otherNumsysMatches = strncmp(o.localeNumberingSystem,
requested->localeNumberingSystem,
sizeof(localeNumberingSystem)) == 0;
if (localeNumsysMatches != otherNumsysMatches) {
return localeNumsysMatches;
}
// Finally, the languages, although equivalent, may still be different
// (like for Tagalog and Filipino). Identical is better than just
// equivalent.
if (areIdentical(language, requested->language)
&& !areIdentical(o.language, requested->language)) {
return true;
}
return false;
}
bool ResTable_config::isBetterThan(const ResTable_config& o,
const ResTable_config* requested) const {
if (requested) {
if (imsi || o.imsi) {
if ((mcc != o.mcc) && requested->mcc) {
return (mcc);
}
if ((mnc != o.mnc) && requested->mnc) {
return (mnc);
}
}
if (isLocaleBetterThan(o, requested)) {
return true;
}
if (screenLayout || o.screenLayout) {
if (((screenLayout^o.screenLayout) & MASK_LAYOUTDIR) != 0
&& (requested->screenLayout & MASK_LAYOUTDIR)) {
int myLayoutDir = screenLayout & MASK_LAYOUTDIR;
int oLayoutDir = o.screenLayout & MASK_LAYOUTDIR;
return (myLayoutDir > oLayoutDir);
}
}
if (smallestScreenWidthDp || o.smallestScreenWidthDp) {
// The configuration closest to the actual size is best.
// We assume that larger configs have already been filtered
// out at this point. That means we just want the largest one.
if (smallestScreenWidthDp != o.smallestScreenWidthDp) {
return smallestScreenWidthDp > o.smallestScreenWidthDp;
}
}
if (screenSizeDp || o.screenSizeDp) {
// "Better" is based on the sum of the difference between both
// width and height from the requested dimensions. We are
// assuming the invalid configs (with smaller dimens) have
// already been filtered. Note that if a particular dimension
// is unspecified, we will end up with a large value (the
// difference between 0 and the requested dimension), which is
// good since we will prefer a config that has specified a
// dimension value.
int myDelta = 0, otherDelta = 0;
if (requested->screenWidthDp) {
myDelta += requested->screenWidthDp - screenWidthDp;
otherDelta += requested->screenWidthDp - o.screenWidthDp;
}
if (requested->screenHeightDp) {
myDelta += requested->screenHeightDp - screenHeightDp;
otherDelta += requested->screenHeightDp - o.screenHeightDp;
}
if (kDebugTableSuperNoisy) {
ALOGI("Comparing this %dx%d to other %dx%d in %dx%d: myDelta=%d otherDelta=%d",
screenWidthDp, screenHeightDp, o.screenWidthDp, o.screenHeightDp,
requested->screenWidthDp, requested->screenHeightDp, myDelta, otherDelta);
}
if (myDelta != otherDelta) {
return myDelta < otherDelta;
}
}
if (screenLayout || o.screenLayout) {
if (((screenLayout^o.screenLayout) & MASK_SCREENSIZE) != 0
&& (requested->screenLayout & MASK_SCREENSIZE)) {
// A little backwards compatibility here: undefined is
// considered equivalent to normal. But only if the
// requested size is at least normal; otherwise, small
// is better than the default.
int mySL = (screenLayout & MASK_SCREENSIZE);
int oSL = (o.screenLayout & MASK_SCREENSIZE);
int fixedMySL = mySL;
int fixedOSL = oSL;
if ((requested->screenLayout & MASK_SCREENSIZE) >= SCREENSIZE_NORMAL) {
if (fixedMySL == 0) fixedMySL = SCREENSIZE_NORMAL;
if (fixedOSL == 0) fixedOSL = SCREENSIZE_NORMAL;
}
// For screen size, the best match is the one that is
// closest to the requested screen size, but not over
// (the not over part is dealt with in match() below).
if (fixedMySL == fixedOSL) {
// If the two are the same, but 'this' is actually
// undefined, then the other is really a better match.
if (mySL == 0) return false;
return true;
}
if (fixedMySL != fixedOSL) {
return fixedMySL > fixedOSL;
}
}
if (((screenLayout^o.screenLayout) & MASK_SCREENLONG) != 0
&& (requested->screenLayout & MASK_SCREENLONG)) {
return (screenLayout & MASK_SCREENLONG);
}
}
if (screenLayout2 || o.screenLayout2) {
if (((screenLayout2^o.screenLayout2) & MASK_SCREENROUND) != 0 &&
(requested->screenLayout2 & MASK_SCREENROUND)) {
return screenLayout2 & MASK_SCREENROUND;
}
}
if (colorMode || o.colorMode) {
if (((colorMode^o.colorMode) & MASK_WIDE_COLOR_GAMUT) != 0 &&
(requested->colorMode & MASK_WIDE_COLOR_GAMUT)) {
return colorMode & MASK_WIDE_COLOR_GAMUT;
}
if (((colorMode^o.colorMode) & MASK_HDR) != 0 &&
(requested->colorMode & MASK_HDR)) {
return colorMode & MASK_HDR;
}
}
if ((orientation != o.orientation) && requested->orientation) {
return (orientation);
}
if (uiMode || o.uiMode) {
if (((uiMode^o.uiMode) & MASK_UI_MODE_TYPE) != 0
&& (requested->uiMode & MASK_UI_MODE_TYPE)) {
return (uiMode & MASK_UI_MODE_TYPE);
}
if (((uiMode^o.uiMode) & MASK_UI_MODE_NIGHT) != 0
&& (requested->uiMode & MASK_UI_MODE_NIGHT)) {
return (uiMode & MASK_UI_MODE_NIGHT);
}
}
if (screenType || o.screenType) {
if (density != o.density) {
// Use the system default density (DENSITY_MEDIUM, 160dpi) if none specified.
const int thisDensity = density ? density : int(ResTable_config::DENSITY_MEDIUM);
const int otherDensity = o.density ? o.density : int(ResTable_config::DENSITY_MEDIUM);
// We always prefer DENSITY_ANY over scaling a density bucket.
if (thisDensity == ResTable_config::DENSITY_ANY) {
return true;
} else if (otherDensity == ResTable_config::DENSITY_ANY) {
return false;
}
int requestedDensity = requested->density;
if (requested->density == 0 ||
requested->density == ResTable_config::DENSITY_ANY) {
requestedDensity = ResTable_config::DENSITY_MEDIUM;
}
// DENSITY_ANY is now dealt with. We should look to
// pick a density bucket and potentially scale it.
// Any density is potentially useful
// because the system will scale it. Scaling down
// is generally better than scaling up.
int h = thisDensity;
int l = otherDensity;
bool bImBigger = true;
if (l > h) {
int t = h;
h = l;
l = t;
bImBigger = false;
}
if (requestedDensity >= h) {
// requested value higher than both l and h, give h
return bImBigger;
}
if (l >= requestedDensity) {
// requested value lower than both l and h, give l
return !bImBigger;
}
// saying that scaling down is 2x better than up
if (((2 * l) - requestedDensity) * h > requestedDensity * requestedDensity) {
return !bImBigger;
} else {
return bImBigger;
}
}
if ((touchscreen != o.touchscreen) && requested->touchscreen) {
return (touchscreen);
}
}
if (input || o.input) {
const int keysHidden = inputFlags & MASK_KEYSHIDDEN;
const int oKeysHidden = o.inputFlags & MASK_KEYSHIDDEN;
if (keysHidden != oKeysHidden) {
const int reqKeysHidden =
requested->inputFlags & MASK_KEYSHIDDEN;
if (reqKeysHidden) {
if (!keysHidden) return false;
if (!oKeysHidden) return true;
// For compatibility, we count KEYSHIDDEN_NO as being
// the same as KEYSHIDDEN_SOFT. Here we disambiguate
// these by making an exact match more specific.
if (reqKeysHidden == keysHidden) return true;
if (reqKeysHidden == oKeysHidden) return false;
}
}
const int navHidden = inputFlags & MASK_NAVHIDDEN;
const int oNavHidden = o.inputFlags & MASK_NAVHIDDEN;
if (navHidden != oNavHidden) {
const int reqNavHidden =
requested->inputFlags & MASK_NAVHIDDEN;
if (reqNavHidden) {
if (!navHidden) return false;
if (!oNavHidden) return true;
}
}
if ((keyboard != o.keyboard) && requested->keyboard) {
return (keyboard);
}
if ((navigation != o.navigation) && requested->navigation) {
return (navigation);
}
}
if (screenSize || o.screenSize) {
// "Better" is based on the sum of the difference between both
// width and height from the requested dimensions. We are
// assuming the invalid configs (with smaller sizes) have
// already been filtered. Note that if a particular dimension
// is unspecified, we will end up with a large value (the
// difference between 0 and the requested dimension), which is
// good since we will prefer a config that has specified a
// size value.
int myDelta = 0, otherDelta = 0;
if (requested->screenWidth) {
myDelta += requested->screenWidth - screenWidth;
otherDelta += requested->screenWidth - o.screenWidth;
}
if (requested->screenHeight) {
myDelta += requested->screenHeight - screenHeight;
otherDelta += requested->screenHeight - o.screenHeight;
}
if (myDelta != otherDelta) {
return myDelta < otherDelta;
}
}
if (version || o.version) {
if ((sdkVersion != o.sdkVersion) && requested->sdkVersion) {
return (sdkVersion > o.sdkVersion);
}
if ((minorVersion != o.minorVersion) &&
requested->minorVersion) {
return (minorVersion);
}
}
return false;
}
return isMoreSpecificThan(o);
}
bool ResTable_config::match(</