diff options
Diffstat (limited to 'include/utils')
| -rw-r--r-- | include/utils/Asset.h | 322 | ||||
| -rw-r--r-- | include/utils/AssetDir.h | 145 | ||||
| -rw-r--r-- | include/utils/AssetManager.h | 373 | ||||
| -rw-r--r-- | include/utils/BackupHelpers.h | 169 | ||||
| -rw-r--r-- | include/utils/BasicHashtable.h | 393 | ||||
| -rw-r--r-- | include/utils/CallStack.h | 8 | ||||
| -rw-r--r-- | include/utils/GenerationCache.h | 114 | ||||
| -rw-r--r-- | include/utils/KeyedVector.h | 2 | ||||
| -rw-r--r-- | include/utils/ObbFile.h | 145 | ||||
| -rw-r--r-- | include/utils/ResourceTypes.h | 2128 | ||||
| -rw-r--r-- | include/utils/StreamingZipInflater.h | 84 | ||||
| -rw-r--r-- | include/utils/TypeHelpers.h | 48 | ||||
| -rw-r--r-- | include/utils/ZipFileCRO.h | 61 | ||||
| -rw-r--r-- | include/utils/ZipFileRO.h | 262 | ||||
| -rw-r--r-- | include/utils/ZipUtils.h | 67 | ||||
| -rw-r--r-- | include/utils/threads.h | 12 |
16 files changed, 504 insertions, 3829 deletions
diff --git a/include/utils/Asset.h b/include/utils/Asset.h deleted file mode 100644 index 1fe0e06..0000000 --- a/include/utils/Asset.h +++ /dev/null @@ -1,322 +0,0 @@ -/* - * Copyright (C) 2006 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. - */ - -// -// Class providing access to a read-only asset. Asset objects are NOT -// thread-safe, and should not be shared across threads. -// -#ifndef __LIBS_ASSET_H -#define __LIBS_ASSET_H - -#include <stdio.h> -#include <sys/types.h> - -#include <utils/Compat.h> -#include <utils/Errors.h> -#include <utils/FileMap.h> -#include <utils/String8.h> - -namespace android { - -/* - * Instances of this class provide read-only operations on a byte stream. - * - * Access may be optimized for streaming, random, or whole buffer modes. All - * operations are supported regardless of how the file was opened, but some - * things will be less efficient. [pass that in??] - * - * "Asset" is the base class for all types of assets. The classes below - * provide most of the implementation. The AssetManager uses one of the - * static "create" functions defined here to create a new instance. - */ -class Asset { -public: - virtual ~Asset(void); - - static int32_t getGlobalCount(); - static String8 getAssetAllocations(); - - /* used when opening an asset */ - typedef enum AccessMode { - ACCESS_UNKNOWN = 0, - - /* read chunks, and seek forward and backward */ - ACCESS_RANDOM, - - /* read sequentially, with an occasional forward seek */ - ACCESS_STREAMING, - - /* caller plans to ask for a read-only buffer with all data */ - ACCESS_BUFFER, - } AccessMode; - - /* - * Read data from the current offset. Returns the actual number of - * bytes read, 0 on EOF, or -1 on error. - */ - virtual ssize_t read(void* buf, size_t count) = 0; - - /* - * Seek to the specified offset. "whence" uses the same values as - * lseek/fseek. Returns the new position on success, or (off64_t) -1 - * on failure. - */ - virtual off64_t seek(off64_t offset, int whence) = 0; - - /* - * Close the asset, freeing all associated resources. - */ - virtual void close(void) = 0; - - /* - * Get a pointer to a buffer with the entire contents of the file. - */ - virtual const void* getBuffer(bool wordAligned) = 0; - - /* - * Get the total amount of data that can be read. - */ - virtual off64_t getLength(void) const = 0; - - /* - * Get the total amount of data that can be read from the current position. - */ - virtual off64_t getRemainingLength(void) const = 0; - - /* - * Open a new file descriptor that can be used to read this asset. - * Returns -1 if you can not use the file descriptor (for example if the - * asset is compressed). - */ - virtual int openFileDescriptor(off64_t* outStart, off64_t* outLength) const = 0; - - /* - * Return whether this asset's buffer is allocated in RAM (not mmapped). - * Note: not virtual so it is safe to call even when being destroyed. - */ - virtual bool isAllocated(void) const { return false; } - - /* - * Get a string identifying the asset's source. This might be a full - * path, it might be a colon-separated list of identifiers. - * - * This is NOT intended to be used for anything except debug output. - * DO NOT try to parse this or use it to open a file. - */ - const char* getAssetSource(void) const { return mAssetSource.string(); } - -protected: - Asset(void); // constructor; only invoked indirectly - - /* handle common seek() housekeeping */ - off64_t handleSeek(off64_t offset, int whence, off64_t curPosn, off64_t maxPosn); - - /* set the asset source string */ - void setAssetSource(const String8& path) { mAssetSource = path; } - - AccessMode getAccessMode(void) const { return mAccessMode; } - -private: - /* these operations are not implemented */ - Asset(const Asset& src); - Asset& operator=(const Asset& src); - - /* AssetManager needs access to our "create" functions */ - friend class AssetManager; - - /* - * Create the asset from a named file on disk. - */ - static Asset* createFromFile(const char* fileName, AccessMode mode); - - /* - * Create the asset from a named, compressed file on disk (e.g. ".gz"). - */ - static Asset* createFromCompressedFile(const char* fileName, - AccessMode mode); - -#if 0 - /* - * Create the asset from a segment of an open file. This will fail - * if "offset" and "length" don't fit within the bounds of the file. - * - * The asset takes ownership of the file descriptor. - */ - static Asset* createFromFileSegment(int fd, off64_t offset, size_t length, - AccessMode mode); - - /* - * Create from compressed data. "fd" should be seeked to the start of - * the compressed data. This could be inside a gzip file or part of a - * Zip archive. - * - * The asset takes ownership of the file descriptor. - * - * This may not verify the validity of the compressed data until first - * use. - */ - static Asset* createFromCompressedData(int fd, off64_t offset, - int compressionMethod, size_t compressedLength, - size_t uncompressedLength, AccessMode mode); -#endif - - /* - * Create the asset from a memory-mapped file segment. - * - * The asset takes ownership of the FileMap. - */ - static Asset* createFromUncompressedMap(FileMap* dataMap, AccessMode mode); - - /* - * Create the asset from a memory-mapped file segment with compressed - * data. "method" is a Zip archive compression method constant. - * - * The asset takes ownership of the FileMap. - */ - static Asset* createFromCompressedMap(FileMap* dataMap, int method, - size_t uncompressedLen, AccessMode mode); - - - /* - * Create from a reference-counted chunk of shared memory. - */ - // TODO - - AccessMode mAccessMode; // how the asset was opened - String8 mAssetSource; // debug string - - Asset* mNext; // linked list. - Asset* mPrev; -}; - - -/* - * =========================================================================== - * - * Innards follow. Do not use these classes directly. - */ - -/* - * An asset based on an uncompressed file on disk. It may encompass the - * entire file or just a piece of it. Access is through fread/fseek. - */ -class _FileAsset : public Asset { -public: - _FileAsset(void); - virtual ~_FileAsset(void); - - /* - * Use a piece of an already-open file. - * - * On success, the object takes ownership of "fd". - */ - status_t openChunk(const char* fileName, int fd, off64_t offset, size_t length); - - /* - * Use a memory-mapped region. - * - * On success, the object takes ownership of "dataMap". - */ - status_t openChunk(FileMap* dataMap); - - /* - * Standard Asset interfaces. - */ - virtual ssize_t read(void* buf, size_t count); - virtual off64_t seek(off64_t offset, int whence); - virtual void close(void); - virtual const void* getBuffer(bool wordAligned); - virtual off64_t getLength(void) const { return mLength; } - virtual off64_t getRemainingLength(void) const { return mLength-mOffset; } - virtual int openFileDescriptor(off64_t* outStart, off64_t* outLength) const; - virtual bool isAllocated(void) const { return mBuf != NULL; } - -private: - off64_t mStart; // absolute file offset of start of chunk - off64_t mLength; // length of the chunk - off64_t mOffset; // current local offset, 0 == mStart - FILE* mFp; // for read/seek - char* mFileName; // for opening - - /* - * To support getBuffer() we either need to read the entire thing into - * a buffer or memory-map it. For small files it's probably best to - * just read them in. - */ - enum { kReadVsMapThreshold = 4096 }; - - FileMap* mMap; // for memory map - unsigned char* mBuf; // for read - - const void* ensureAlignment(FileMap* map); -}; - - -/* - * An asset based on compressed data in a file. - */ -class _CompressedAsset : public Asset { -public: - _CompressedAsset(void); - virtual ~_CompressedAsset(void); - - /* - * Use a piece of an already-open file. - * - * On success, the object takes ownership of "fd". - */ - status_t openChunk(int fd, off64_t offset, int compressionMethod, - size_t uncompressedLen, size_t compressedLen); - - /* - * Use a memory-mapped region. - * - * On success, the object takes ownership of "fd". - */ - status_t openChunk(FileMap* dataMap, int compressionMethod, - size_t uncompressedLen); - - /* - * Standard Asset interfaces. - */ - virtual ssize_t read(void* buf, size_t count); - virtual off64_t seek(off64_t offset, int whence); - virtual void close(void); - virtual const void* getBuffer(bool wordAligned); - virtual off64_t getLength(void) const { return mUncompressedLen; } - virtual off64_t getRemainingLength(void) const { return mUncompressedLen-mOffset; } - virtual int openFileDescriptor(off64_t* outStart, off64_t* outLength) const { return -1; } - virtual bool isAllocated(void) const { return mBuf != NULL; } - -private: - off64_t mStart; // offset to start of compressed data - off64_t mCompressedLen; // length of the compressed data - off64_t mUncompressedLen; // length of the uncompressed data - off64_t mOffset; // current offset, 0 == start of uncomp data - - FileMap* mMap; // for memory-mapped input - int mFd; // for file input - - class StreamingZipInflater* mZipInflater; // for streaming large compressed assets - - unsigned char* mBuf; // for getBuffer() -}; - -// need: shared mmap version? - -}; // namespace android - -#endif // __LIBS_ASSET_H diff --git a/include/utils/AssetDir.h b/include/utils/AssetDir.h deleted file mode 100644 index abf8a35..0000000 --- a/include/utils/AssetDir.h +++ /dev/null @@ -1,145 +0,0 @@ -/* - * Copyright (C) 2006 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. - */ - -// -// Access a chunk of the asset hierarchy as if it were a single directory. -// -#ifndef __LIBS_ASSETDIR_H -#define __LIBS_ASSETDIR_H - -#include <utils/String8.h> -#include <utils/Vector.h> -#include <utils/SortedVector.h> -#include <utils/misc.h> -#include <sys/types.h> - -namespace android { - -/* - * This provides vector-style access to a directory. We do this rather - * than modeling opendir/readdir access because it's simpler and the - * nature of the operation requires us to have all data on hand anyway. - * - * The list of files will be sorted in ascending order by ASCII value. - * - * The contents are populated by our friend, the AssetManager. - */ -class AssetDir { -public: - AssetDir(void) - : mFileInfo(NULL) - {} - virtual ~AssetDir(void) { - delete mFileInfo; - } - - /* - * Vector-style access. - */ - size_t getFileCount(void) { return mFileInfo->size(); } - const String8& getFileName(int idx) { - return mFileInfo->itemAt(idx).getFileName(); - } - const String8& getSourceName(int idx) { - return mFileInfo->itemAt(idx).getSourceName(); - } - - /* - * Get the type of a file (usually regular or directory). - */ - FileType getFileType(int idx) { - return mFileInfo->itemAt(idx).getFileType(); - } - -private: - /* these operations are not implemented */ - AssetDir(const AssetDir& src); - const AssetDir& operator=(const AssetDir& src); - - friend class AssetManager; - - /* - * This holds information about files in the asset hierarchy. - */ - class FileInfo { - public: - FileInfo(void) {} - FileInfo(const String8& path) // useful for e.g. svect.indexOf - : mFileName(path), mFileType(kFileTypeUnknown) - {} - ~FileInfo(void) {} - FileInfo(const FileInfo& src) { - copyMembers(src); - } - const FileInfo& operator= (const FileInfo& src) { - if (this != &src) - copyMembers(src); - return *this; - } - - void copyMembers(const FileInfo& src) { - mFileName = src.mFileName; - mFileType = src.mFileType; - mSourceName = src.mSourceName; - } - - /* need this for SortedVector; must compare only on file name */ - bool operator< (const FileInfo& rhs) const { - return mFileName < rhs.mFileName; - } - - /* used by AssetManager */ - bool operator== (const FileInfo& rhs) const { - return mFileName == rhs.mFileName; - } - - void set(const String8& path, FileType type) { - mFileName = path; - mFileType = type; - } - - const String8& getFileName(void) const { return mFileName; } - void setFileName(const String8& path) { mFileName = path; } - - FileType getFileType(void) const { return mFileType; } - void setFileType(FileType type) { mFileType = type; } - - const String8& getSourceName(void) const { return mSourceName; } - void setSourceName(const String8& path) { mSourceName = path; } - - /* - * Handy utility for finding an entry in a sorted vector of FileInfo. - * Returns the index of the matching entry, or -1 if none found. - */ - static int findEntry(const SortedVector<FileInfo>* pVector, - const String8& fileName); - - private: - String8 mFileName; // filename only - FileType mFileType; // regular, directory, etc - - String8 mSourceName; // currently debug-only - }; - - /* AssetManager uses this to initialize us */ - void setFileList(SortedVector<FileInfo>* list) { mFileInfo = list; } - - SortedVector<FileInfo>* mFileInfo; -}; - -}; // namespace android - -#endif // __LIBS_ASSETDIR_H diff --git a/include/utils/AssetManager.h b/include/utils/AssetManager.h deleted file mode 100644 index a8c7ddb..0000000 --- a/include/utils/AssetManager.h +++ /dev/null @@ -1,373 +0,0 @@ -/* - * Copyright (C) 2006 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. - */ - -// -// Asset management class. AssetManager objects are thread-safe. -// -#ifndef __LIBS_ASSETMANAGER_H -#define __LIBS_ASSETMANAGER_H - -#include <utils/Asset.h> -#include <utils/AssetDir.h> -#include <utils/KeyedVector.h> -#include <utils/String8.h> -#include <utils/Vector.h> -#include <utils/String16.h> -#include <utils/ZipFileRO.h> -#include <utils/threads.h> - -/* - * Native-app access is via the opaque typedef struct AAssetManager in the C namespace. - */ -#ifdef __cplusplus -extern "C" { -#endif - -struct AAssetManager { }; - -#ifdef __cplusplus -}; -#endif - - -/* - * Now the proper C++ android-namespace definitions - */ - -namespace android { - -class Asset; // fwd decl for things that include Asset.h first -class ResTable; -struct ResTable_config; - -/* - * Every application that uses assets needs one instance of this. A - * single instance may be shared across multiple threads, and a single - * thread may have more than one instance (the latter is discouraged). - * - * The purpose of the AssetManager is to create Asset objects. To do - * this efficiently it may cache information about the locations of - * files it has seen. This can be controlled with the "cacheMode" - * argument. - * - * The asset hierarchy may be examined like a filesystem, using - * AssetDir objects to peruse a single directory. - */ -class AssetManager : public AAssetManager { -public: - typedef enum CacheMode { - CACHE_UNKNOWN = 0, - CACHE_OFF, // don't try to cache file locations - CACHE_DEFER, // construct cache as pieces are needed - //CACHE_SCAN, // scan full(!) asset hierarchy at init() time - } CacheMode; - - AssetManager(CacheMode cacheMode = CACHE_OFF); - virtual ~AssetManager(void); - - static int32_t getGlobalCount(); - - /* - * Add a new source for assets. This can be called multiple times to - * look in multiple places for assets. It can be either a directory (for - * finding assets as raw files on the disk) or a ZIP file. This newly - * added asset path will be examined first when searching for assets, - * before any that were previously added. - * - * Returns "true" on success, "false" on failure. If 'cookie' is non-NULL, - * then on success, *cookie is set to the value corresponding to the - * newly-added asset source. - */ - bool addAssetPath(const String8& path, void** cookie); - - /* - * Convenience for adding the standard system assets. Uses the - * ANDROID_ROOT environment variable to find them. - */ - bool addDefaultAssets(); - - /* - * Iterate over the asset paths in this manager. (Previously - * added via addAssetPath() and addDefaultAssets().) On first call, - * 'cookie' must be NULL, resulting in the first cookie being returned. - * Each next cookie will be returned there-after, until NULL indicating - * the end has been reached. - */ - void* nextAssetPath(void* cookie) const; - - /* - * Return an asset path in the manager. 'which' must be between 0 and - * countAssetPaths(). - */ - String8 getAssetPath(void* cookie) const; - - /* - * Set the current locale and vendor. The locale can change during - * the lifetime of an AssetManager if the user updates the device's - * language setting. The vendor is less likely to change. - * - * Pass in NULL to indicate no preference. - */ - void setLocale(const char* locale); - void setVendor(const char* vendor); - - /* - * Choose screen orientation for resources values returned. - */ - void setConfiguration(const ResTable_config& config, const char* locale = NULL); - - void getConfiguration(ResTable_config* outConfig) const; - - typedef Asset::AccessMode AccessMode; // typing shortcut - - /* - * Open an asset. - * - * This will search through locale-specific and vendor-specific - * directories and packages to find the file. - * - * The object returned does not depend on the AssetManager. It should - * be freed by calling Asset::close(). - */ - Asset* open(const char* fileName, AccessMode mode); - - /* - * Open a non-asset file as an asset. - * - * This is for opening files that are included in an asset package - * but aren't assets. These sit outside the usual "locale/vendor" - * path hierarchy, and will not be seen by "AssetDir" or included - * in our filename cache. - */ - Asset* openNonAsset(const char* fileName, AccessMode mode); - - /* - * Explicit non-asset file. The file explicitly named by the cookie (the - * resource set to look in) and fileName will be opened and returned. - */ - Asset* openNonAsset(void* cookie, const char* fileName, AccessMode mode); - - /* - * Open a directory within the asset hierarchy. - * - * The contents of the directory are an amalgam of vendor-specific, - * locale-specific, and generic assets stored loosely or in asset - * packages. Depending on the cache setting and previous accesses, - * this call may incur significant disk overhead. - * - * To open the top-level directory, pass in "". - */ - AssetDir* openDir(const char* dirName); - - /* - * Open a directory within a particular path of the asset manager. - * - * The contents of the directory are an amalgam of vendor-specific, - * locale-specific, and generic assets stored loosely or in asset - * packages. Depending on the cache setting and previous accesses, - * this call may incur significant disk overhead. - * - * To open the top-level directory, pass in "". - */ - AssetDir* openNonAssetDir(void* cookie, const char* dirName); - - /* - * Get the type of a file in the asset hierarchy. They will either - * be "regular" or "directory". [Currently only works for "regular".] - * - * Can also be used as a quick test for existence of a file. - */ - FileType getFileType(const char* fileName); - - /* - * Return the complete resource table to find things in the package. - */ - const ResTable& getResources(bool required = true) const; - - /* - * Discard cached filename information. This only needs to be called - * if somebody has updated the set of "loose" files, and we want to - * discard our cached notion of what's where. - */ - void purge(void) { purgeFileNameCacheLocked(); } - - /* - * Return true if the files this AssetManager references are all - * up-to-date (have not been changed since it was created). If false - * is returned, you will need to create a new AssetManager to get - * the current data. - */ - bool isUpToDate(); - - /** - * Get the known locales for this asset manager object. - */ - void getLocales(Vector<String8>* locales) const; - -private: - struct asset_path - { - String8 path; - FileType type; - String8 idmap; - }; - - Asset* openInPathLocked(const char* fileName, AccessMode mode, - const asset_path& path); - Asset* openNonAssetInPathLocked(const char* fileName, AccessMode mode, - const asset_path& path); - Asset* openInLocaleVendorLocked(const char* fileName, AccessMode mode, - const asset_path& path, const char* locale, const char* vendor); - String8 createPathNameLocked(const asset_path& path, const char* locale, - const char* vendor); - String8 createPathNameLocked(const asset_path& path, const char* rootDir); - String8 createZipSourceNameLocked(const String8& zipFileName, - const String8& dirName, const String8& fileName); - - ZipFileRO* getZipFileLocked(const asset_path& path); - Asset* openAssetFromFileLocked(const String8& fileName, AccessMode mode); - Asset* openAssetFromZipLocked(const ZipFileRO* pZipFile, - const ZipEntryRO entry, AccessMode mode, const String8& entryName); - - bool scanAndMergeDirLocked(SortedVector<AssetDir::FileInfo>* pMergedInfo, - const asset_path& path, const char* rootDir, const char* dirName); - SortedVector<AssetDir::FileInfo>* scanDirLocked(const String8& path); - bool scanAndMergeZipLocked(SortedVector<AssetDir::FileInfo>* pMergedInfo, - const asset_path& path, const char* rootDir, const char* dirName); - void mergeInfoLocked(SortedVector<AssetDir::FileInfo>* pMergedInfo, - const SortedVector<AssetDir::FileInfo>* pContents); - - void loadFileNameCacheLocked(void); - void fncScanLocked(SortedVector<AssetDir::FileInfo>* pMergedInfo, - const char* dirName); - bool fncScanAndMergeDirLocked( - SortedVector<AssetDir::FileInfo>* pMergedInfo, - const asset_path& path, const char* locale, const char* vendor, - const char* dirName); - void purgeFileNameCacheLocked(void); - - const ResTable* getResTable(bool required = true) const; - void setLocaleLocked(const char* locale); - void updateResourceParamsLocked() const; - - bool createIdmapFileLocked(const String8& originalPath, const String8& overlayPath, - const String8& idmapPath); - - bool isIdmapStaleLocked(const String8& originalPath, const String8& overlayPath, - const String8& idmapPath); - - Asset* openIdmapLocked(const struct asset_path& ap) const; - - bool getZipEntryCrcLocked(const String8& zipPath, const char* entryFilename, uint32_t* pCrc); - - class SharedZip : public RefBase { - public: - static sp<SharedZip> get(const String8& path); - - ZipFileRO* getZip(); - - Asset* getResourceTableAsset(); - Asset* setResourceTableAsset(Asset* asset); - - ResTable* getResourceTable(); - ResTable* setResourceTable(ResTable* res); - - bool isUpToDate(); - - protected: - ~SharedZip(); - - private: - SharedZip(const String8& path, time_t modWhen); - SharedZip(); // <-- not implemented - - String8 mPath; - ZipFileRO* mZipFile; - time_t mModWhen; - - Asset* mResourceTableAsset; - ResTable* mResourceTable; - - static Mutex gLock; - static DefaultKeyedVector<String8, wp<SharedZip> > gOpen; - }; - - /* - * Manage a set of Zip files. For each file we need a pointer to the - * ZipFile and a time_t with the file's modification date. - * - * We currently only have two zip files (current app, "common" app). - * (This was originally written for 8, based on app/locale/vendor.) - */ - class ZipSet { - public: - ZipSet(void); - ~ZipSet(void); - - /* - * Return a ZipFileRO structure for a ZipFileRO with the specified - * parameters. - */ - ZipFileRO* getZip(const String8& path); - - Asset* getZipResourceTableAsset(const String8& path); - Asset* setZipResourceTableAsset(const String8& path, Asset* asset); - - ResTable* getZipResourceTable(const String8& path); - ResTable* setZipResourceTable(const String8& path, ResTable* res); - - // generate path, e.g. "common/en-US-noogle.zip" - static String8 getPathName(const char* path); - - bool isUpToDate(); - - private: - void closeZip(int idx); - - int getIndex(const String8& zip) const; - mutable Vector<String8> mZipPath; - mutable Vector<sp<SharedZip> > mZipFile; - }; - - // Protect all internal state. - mutable Mutex mLock; - - ZipSet mZipSet; - - Vector<asset_path> mAssetPaths; - char* mLocale; - char* mVendor; - - mutable ResTable* mResources; - ResTable_config* mConfig; - - /* - * Cached data for "loose" files. This lets us avoid poking at the - * filesystem when searching for loose assets. Each entry is the - * "extended partial" path, e.g. "default/default/foo/bar.txt". The - * full set of files is present, including ".EXCLUDE" entries. - * - * We do not cache directory names. We don't retain the ".gz", - * because to our clients "foo" and "foo.gz" both look like "foo". - */ - CacheMode mCacheMode; // is the cache enabled? - bool mCacheValid; // clear when locale or vendor changes - SortedVector<AssetDir::FileInfo> mCache; -}; - -}; // namespace android - -#endif // __LIBS_ASSETMANAGER_H diff --git a/include/utils/BackupHelpers.h b/include/utils/BackupHelpers.h deleted file mode 100644 index 1bb04a7..0000000 --- a/include/utils/BackupHelpers.h +++ /dev/null @@ -1,169 +0,0 @@ -/* - * Copyright (C) 2009 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. - */ - -#ifndef _UTILS_BACKUP_HELPERS_H -#define _UTILS_BACKUP_HELPERS_H - -#include <utils/Errors.h> -#include <utils/String8.h> -#include <utils/KeyedVector.h> - -namespace android { - -enum { - BACKUP_HEADER_ENTITY_V1 = 0x61746144, // Data (little endian) -}; - -typedef struct { - int type; // BACKUP_HEADER_ENTITY_V1 - int keyLen; // length of the key name, not including the null terminator - int dataSize; // size of the data, not including the padding, -1 means delete -} entity_header_v1; - -struct SnapshotHeader { - int magic0; - int fileCount; - int magic1; - int totalSize; -}; - -struct FileState { - int modTime_sec; - int modTime_nsec; - int mode; - int size; - int crc32; - int nameLen; -}; - -struct FileRec { - String8 file; - bool deleted; - FileState s; -}; - - -/** - * Writes the data. - * - * If an error occurs, it poisons this object and all write calls will fail - * with the error that occurred. - */ -class BackupDataWriter -{ -public: - BackupDataWriter(int fd); - // does not close fd - ~BackupDataWriter(); - - status_t WriteEntityHeader(const String8& key, size_t dataSize); - - /* Note: WriteEntityData will write arbitrary data into the file without - * validation or a previously-supplied header. The full backup implementation - * uses it this way to generate a controlled binary stream that is not - * entity-structured. If the implementation here is changed, either this - * use case must remain valid, or the full backup implementation should be - * adjusted to use some other appropriate mechanism. - */ - status_t WriteEntityData(const void* data, size_t size); - - void SetKeyPrefix(const String8& keyPrefix); - -private: - explicit BackupDataWriter(); - status_t write_padding_for(int n); - - int m_fd; - status_t m_status; - ssize_t m_pos; - int m_entityCount; - String8 m_keyPrefix; -}; - -/** - * Reads the data. - * - * If an error occurs, it poisons this object and all write calls will fail - * with the error that occurred. - */ -class BackupDataReader -{ -public: - BackupDataReader(int fd); - // does not close fd - ~BackupDataReader(); - - status_t Status(); - status_t ReadNextHeader(bool* done, int* type); - - bool HasEntities(); - status_t ReadEntityHeader(String8* key, size_t* dataSize); - status_t SkipEntityData(); // must be called with the pointer at the beginning of the data. - ssize_t ReadEntityData(void* data, size_t size); - -private: - explicit BackupDataReader(); - status_t skip_padding(); - - int m_fd; - bool m_done; - status_t m_status; - ssize_t m_pos; - ssize_t m_dataEndPos; - int m_entityCount; - union { - int type; - entity_header_v1 entity; - } m_header; - String8 m_key; -}; - -int back_up_files(int oldSnapshotFD, BackupDataWriter* dataStream, int newSnapshotFD, - char const* const* files, char const* const *keys, int fileCount); - -int write_tarfile(const String8& packageName, const String8& domain, - const String8& rootPath, const String8& filePath, BackupDataWriter* outputStream); - -class RestoreHelperBase -{ -public: - RestoreHelperBase(); - ~RestoreHelperBase(); - - status_t WriteFile(const String8& filename, BackupDataReader* in); - status_t WriteSnapshot(int fd); - -private: - void* m_buf; - bool m_loggedUnknownMetadata; - KeyedVector<String8,FileRec> m_files; -}; - -#define TEST_BACKUP_HELPERS 1 - -#if TEST_BACKUP_HELPERS -int backup_helper_test_empty(); -int backup_helper_test_four(); -int backup_helper_test_files(); -int backup_helper_test_null_base(); -int backup_helper_test_missing_file(); -int backup_helper_test_data_writer(); -int backup_helper_test_data_reader(); -#endif - -} // namespace android - -#endif // _UTILS_BACKUP_HELPERS_H diff --git a/include/utils/BasicHashtable.h b/include/utils/BasicHashtable.h new file mode 100644 index 0000000..fdf9738 --- /dev/null +++ b/include/utils/BasicHashtable.h @@ -0,0 +1,393 @@ +/* + * Copyright (C) 2011 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. + */ + +#ifndef ANDROID_BASIC_HASHTABLE_H +#define ANDROID_BASIC_HASHTABLE_H + +#include <stdint.h> +#include <sys/types.h> +#include <utils/SharedBuffer.h> +#include <utils/TypeHelpers.h> + +namespace android { + +/* Implementation type. Nothing to see here. */ +class BasicHashtableImpl { +protected: + struct Bucket { + // The collision flag indicates that the bucket is part of a collision chain + // such that at least two entries both hash to this bucket. When true, we + // may need to seek further along the chain to find the entry. + static const uint32_t COLLISION = 0x80000000UL; + + // The present flag indicates that the bucket contains an initialized entry value. + static const uint32_t PRESENT = 0x40000000UL; + + // Mask for 30 bits worth of the hash code that are stored within the bucket to + // speed up lookups and rehashing by eliminating the need to recalculate the + // hash code of the entry's key. + static const uint32_t HASH_MASK = 0x3fffffffUL; + + // Combined value that stores the collision and present flags as well as + // a 30 bit hash code. + uint32_t cookie; + + // Storage for the entry begins here. + char entry[0]; + }; + + BasicHashtableImpl(size_t entrySize, bool hasTrivialDestructor, + size_t minimumInitialCapacity, float loadFactor); + BasicHashtableImpl(const BasicHashtableImpl& other); + + void dispose(); + + inline void edit() { + if (mBuckets && !SharedBuffer::bufferFromData(mBuckets)->onlyOwner()) { + clone(); + } + } + + void setTo(const BasicHashtableImpl& other); + void clear(); + + ssize_t next(ssize_t index) const; + ssize_t find(ssize_t index, hash_t hash, const void* __restrict__ key) const; + size_t add(hash_t hash, const void* __restrict__ entry); + void removeAt(size_t index); + void rehash(size_t minimumCapacity, float loadFactor); + + const size_t mBucketSize; // number of bytes per bucket including the entry + const bool mHasTrivialDestructor; // true if the entry type does not require destruction + size_t mCapacity; // number of buckets that can be filled before exceeding load factor + float mLoadFactor; // load factor + size_t mSize; // number of elements actually in the table + size_t mFilledBuckets; // number of buckets for which collision or present is true + size_t mBucketCount; // number of slots in the mBuckets array + void* mBuckets; // array of buckets, as a SharedBuffer + + inline const Bucket& bucketAt(const void* __restrict__ buckets, size_t index) const { + return *reinterpret_cast<const Bucket*>( + static_cast<const uint8_t*>(buckets) + index * mBucketSize); + } + + inline Bucket& bucketAt(void* __restrict__ buckets, size_t index) const { + return *reinterpret_cast<Bucket*>(static_cast<uint8_t*>(buckets) + index * mBucketSize); + } + + virtual bool compareBucketKey(const Bucket& bucket, const void* __restrict__ key) const = 0; + virtual void initializeBucketEntry(Bucket& bucket, const void* __restrict__ entry) const = 0; + virtual void destroyBucketEntry(Bucket& bucket) const = 0; + +private: + void clone(); + + // Allocates a bucket array as a SharedBuffer. + void* allocateBuckets(size_t count) const; + + // Releases a bucket array's associated SharedBuffer. + void releaseBuckets(void* __restrict__ buckets, size_t count) const; + + // Destroys the contents of buckets (invokes destroyBucketEntry for each + // populated bucket if needed). + void destroyBuckets(void* __restrict__ buckets, size_t count) const; + + // Copies the content of buckets (copies the cookie and invokes copyBucketEntry + // for each populated bucket if needed). + void copyBuckets(const void* __restrict__ fromBuckets, + void* __restrict__ toBuckets, size_t count) const; + + // Determines the appropriate size of a bucket array to store a certain minimum + // number of entries and returns its effective capacity. + static void determineCapacity(size_t minimumCapacity, float loadFactor, + size_t* __restrict__ outBucketCount, size_t* __restrict__ outCapacity); + + // Trim a hash code to 30 bits to match what we store in the bucket's cookie. + inline static hash_t trimHash(hash_t hash) { + return (hash & Bucket::HASH_MASK) ^ (hash >> 30); + } + + // Returns the index of the first bucket that is in the collision chain + // for the specified hash code, given the total number of buckets. + // (Primary hash) + inline static size_t chainStart(hash_t hash, size_t count) { + return hash % count; + } + + // Returns the increment to add to a bucket index to seek to the next bucket + // in the collision chain for the specified hash code, given the total number of buckets. + // (Secondary hash) + inline static size_t chainIncrement(hash_t hash, size_t count) { + return ((hash >> 7) | (hash << 25)) % (count - 1) + 1; + } + + // Returns the index of the next bucket that is in the collision chain + // that is defined by the specified increment, given the total number of buckets. + inline static size_t chainSeek(size_t index, size_t increment, size_t count) { + return (index + increment) % count; + } +}; + +/* + * A BasicHashtable stores entries that are indexed by hash code in place + * within an array. The basic operations are finding entries by key, + * adding new entries and removing existing entries. + * + * This class provides a very limited set of operations with simple semantics. + * It is intended to be used as a building block to construct more complex + * and interesting data structures such as HashMap. Think very hard before + * adding anything extra to BasicHashtable, it probably belongs at a + * higher level of abstraction. + * + * TKey: The key type. + * TEntry: The entry type which is what is actually stored in the array. + * + * TKey must support the following contract: + * bool operator==(const TKey& other) const; // return true if equal + * bool operator!=(const TKey& other) const; // return true if unequal + * + * TEntry must support the following contract: + * const TKey& getKey() const; // get the key from the entry + * + * This class supports storing entries with duplicate keys. Of course, it can't + * tell them apart during removal so only the first entry will be removed. + * We do this because it means that operations like add() can't fail. + */ +template <typename TKey, typename TEntry> +class BasicHashtable : private BasicHashtableImpl { +public: + /* Creates a hashtable with the specified minimum initial capacity. + * The underlying array will be created when the first entry is added. + * + * minimumInitialCapacity: The minimum initial capacity for the hashtable. + * Default is 0. + * loadFactor: The desired load factor for the hashtable, between 0 and 1. + * Default is 0.75. + */ + BasicHashtable(size_t minimumInitialCapacity = 0, float loadFactor = 0.75f); + + /* Copies a hashtable. + * The underlying storage is shared copy-on-write. + */ + BasicHashtable(const BasicHashtable& other); + + /* Clears and destroys the hashtable. + */ + virtual ~BasicHashtable(); + + /* Making this hashtable a copy of the other hashtable. + * The underlying storage is shared copy-on-write. + * + * other: The hashtable to copy. + */ + inline BasicHashtable<TKey, TEntry>& operator =(const BasicHashtable<TKey, TEntry> & other) { + setTo(other); + return *this; + } + + /* Returns the number of entries in the hashtable. + */ + inline size_t size() const { + return mSize; + } + + /* Returns the capacity of the hashtable, which is the number of elements that can + * added to the hashtable without requiring it to be grown. + */ + inline size_t capacity() const { + return mCapacity; + } + + /* Returns the number of buckets that the hashtable has, which is the size of its + * underlying array. + */ + inline size_t bucketCount() const { + return mBucketCount; + } + + /* Returns the load factor of the hashtable. */ + inline float loadFactor() const { + return mLoadFactor; + }; + + /* Returns a const reference to the entry at the specified index. + * + * index: The index of the entry to retrieve. Must be a valid index within + * the bounds of the hashtable. + */ + inline const TEntry& entryAt(size_t index) const { + return entryFor(bucketAt(mBuckets, index)); + } + + /* Returns a non-const reference to the entry at the specified index. + * + * index: The index of the entry to edit. Must be a valid index within + * the bounds of the hashtable. + */ + inline TEntry& editEntryAt(size_t index) { + edit(); + return entryFor(bucketAt(mBuckets, index)); + } + + /* Clears the hashtable. + * All entries in the hashtable are destroyed immediately. + * If you need to do something special with the entries in the hashtable then iterate + * over them and do what you need before clearing the hashtable. + */ + inline void clear() { + BasicHashtableImpl::clear(); + } + + /* Returns the index of the next entry in the hashtable given the index of a previous entry. + * If the given index is -1, then returns the index of the first entry in the hashtable, + * if there is one, or -1 otherwise. + * If the given index is not -1, then returns the index of the next entry in the hashtable, + * in strictly increasing order, or -1 if there are none left. + * + * index: The index of the previous entry that was iterated, or -1 to begin + * iteration at the beginning of the hashtable. + */ + inline ssize_t next(ssize_t index) const { + return BasicHashtableImpl::next(index); + } + + /* Finds the index of an entry with the specified key. + * If the given index is -1, then returns the index of the first matching entry, + * otherwise returns the index of the next matching entry. + * If the hashtable contains multiple entries with keys that match the requested + * key, then the sequence of entries returned is arbitrary. + * Returns -1 if no entry was found. + * + * index: The index of the previous entry with the specified key, or -1 to + * find the first matching entry. + * hash: The hashcode of the key. + * key: The key. + */ + inline ssize_t find(ssize_t index, hash_t hash, const TKey& key) const { + return BasicHashtableImpl::find(index, hash, &key); + } + + /* Adds the entry to the hashtable. + * Returns the index of the newly added entry. + * If an entry with the same key already exists, then a duplicate entry is added. + * If the entry will not fit, then the hashtable's capacity is increased and + * its contents are rehashed. See rehash(). + * + * hash: The hashcode of the key. + * entry: The entry to add. + */ + inline size_t add(hash_t hash, const TEntry& entry) { + return BasicHashtableImpl::add(hash, &entry); + } + + /* Removes the entry with the specified index from the hashtable. + * The entry is destroyed immediately. + * The index must be valid. + * + * The hashtable is not compacted after an item is removed, so it is legal + * to continue iterating over the hashtable using next() or find(). + * + * index: The index of the entry to remove. Must be a valid index within the + * bounds of the hashtable, and it must refer to an existing entry. + */ + inline void removeAt(size_t index) { + BasicHashtableImpl::removeAt(index); + } + + /* Rehashes the contents of the hashtable. + * Grows the hashtable to at least the specified minimum capacity or the + * current number of elements, whichever is larger. + * + * Rehashing causes all entries to be copied and the entry indices may change. + * Although the hash codes are cached by the hashtable, rehashing can be an + * expensive operation and should be avoided unless the hashtable's size + * needs to be changed. + * + * Rehashing is the only way to change the capacity or load factor of the + * hashtable once it has been created. It can be used to compact the + * hashtable by choosing a minimum capacity that is smaller than the current + * capacity (such as 0). + * + * minimumCapacity: The desired minimum capacity after rehashing. + * loadFactor: The desired load factor after rehashing. + */ + inline void rehash(size_t minimumCapacity, float loadFactor) { + BasicHashtableImpl::rehash(minimumCapacity, loadFactor); + } + +protected: + static inline const TEntry& entryFor(const Bucket& bucket) { + return reinterpret_cast<const TEntry&>(bucket.entry); + } + + static inline TEntry& entryFor(Bucket& bucket) { + return reinterpret_cast<TEntry&>(bucket.entry); + } + + virtual bool compareBucketKey(const Bucket& bucket, const void* __restrict__ key) const; + virtual void initializeBucketEntry(Bucket& bucket, const void* __restrict__ entry) const; + virtual void destroyBucketEntry(Bucket& bucket) const; + +private: + // For dumping the raw contents of a hashtable during testing. + friend class BasicHashtableTest; + inline uint32_t cookieAt(size_t index) const { + return bucketAt(mBuckets, index).cookie; + } +}; + +template <typename TKey, typename TEntry> +BasicHashtable<TKey, TEntry>::BasicHashtable(size_t minimumInitialCapacity, float loadFactor) : + BasicHashtableImpl(sizeof(TEntry), traits<TEntry>::has_trivial_dtor, + minimumInitialCapacity, loadFactor) { +} + +template <typename TKey, typename TEntry> +BasicHashtable<TKey, TEntry>::BasicHashtable(const BasicHashtable<TKey, TEntry>& other) : + BasicHashtableImpl(other) { +} + +template <typename TKey, typename TEntry> +BasicHashtable<TKey, TEntry>::~BasicHashtable() { + dispose(); +} + +template <typename TKey, typename TEntry> +bool BasicHashtable<TKey, TEntry>::compareBucketKey(const Bucket& bucket, + const void* __restrict__ key) const { + return entryFor(bucket).getKey() == *static_cast<const TKey*>(key); +} + +template <typename TKey, typename TEntry> +void BasicHashtable<TKey, TEntry>::initializeBucketEntry(Bucket& bucket, + const void* __restrict__ entry) const { + if (!traits<TEntry>::has_trivial_copy) { + new (&entryFor(bucket)) TEntry(*(static_cast<const TEntry*>(entry))); + } else { + memcpy(&entryFor(bucket), entry, sizeof(TEntry)); + } +} + +template <typename TKey, typename TEntry> +void BasicHashtable<TKey, TEntry>::destroyBucketEntry(Bucket& bucket) const { + if (!traits<TEntry>::has_trivial_dtor) { + entryFor(bucket).~TEntry(); + } +} + +}; // namespace android + +#endif // ANDROID_BASIC_HASHTABLE_H diff --git a/include/utils/CallStack.h b/include/utils/CallStack.h index 8817120..079e20c 100644 --- a/include/utils/CallStack.h +++ b/include/utils/CallStack.h @@ -21,6 +21,7 @@ #include <sys/types.h> #include <utils/String8.h> +#include <corkscrew/backtrace.h> // --------------------------------------------------------------------------- @@ -61,11 +62,8 @@ public: size_t size() const { return mCount; } private: - // Internal helper function - String8 toStringSingleLevel(const char* prefix, int32_t level) const; - - size_t mCount; - const void* mStack[MAX_DEPTH]; + size_t mCount; + backtrace_frame_t mStack[MAX_DEPTH]; }; }; // namespace android diff --git a/include/utils/GenerationCache.h b/include/utils/GenerationCache.h index bb9ddd6..40722d1 100644 --- a/include/utils/GenerationCache.h +++ b/include/utils/GenerationCache.h @@ -34,17 +34,17 @@ public: template<typename EntryKey, typename EntryValue> struct Entry: public LightRefBase<Entry<EntryKey, EntryValue> > { - Entry() { } - Entry(const Entry<EntryKey, EntryValue>& e): - key(e.key), value(e.value), parent(e.parent), child(e.child) { } - Entry(sp<Entry<EntryKey, EntryValue> > e): - key(e->key), value(e->value), parent(e->parent), child(e->child) { } + Entry(const Entry<EntryKey, EntryValue>& e) : + key(e.key), value(e.value), + parent(e.parent), child(e.child) { } + Entry(const EntryKey& key, const EntryValue& value) : + key(key), value(value) { } EntryKey key; EntryValue value; - sp<Entry<EntryKey, EntryValue> > parent; - sp<Entry<EntryKey, EntryValue> > child; + sp<Entry<EntryKey, EntryValue> > parent; // next older entry + sp<Entry<EntryKey, EntryValue> > child; // next younger entry }; // struct Entry /** @@ -62,23 +62,20 @@ public: void setOnEntryRemovedListener(OnEntryRemoved<K, V>* listener); - void clear(); + size_t size() const; - bool contains(K key) const; - V get(K key); - K getKeyAt(uint32_t index) const; - bool put(K key, V value); - V remove(K key); - V removeOldest(); - V getValueAt(uint32_t index) const; + void clear(); - uint32_t size() const; + bool contains(const K& key) const; + const K& getKeyAt(size_t index) const; + const V& getValueAt(size_t index) const; - void addToCache(sp<Entry<K, V> > entry, K key, V value); - void attachToCache(sp<Entry<K, V> > entry); - void detachFromCache(sp<Entry<K, V> > entry); + const V& get(const K& key); + bool put(const K& key, const V& value); - V removeAt(ssize_t index); + void removeAt(ssize_t index); + bool remove(const K& key); + bool removeOldest(); private: KeyedVector<K, sp<Entry<K, V> > > mCache; @@ -88,11 +85,16 @@ private: sp<Entry<K, V> > mOldest; sp<Entry<K, V> > mYoungest; + + void attachToCache(const sp<Entry<K, V> >& entry); + void detachFromCache(const sp<Entry<K, V> >& entry); + + const V mNullValue; }; // class GenerationCache template<typename K, typename V> GenerationCache<K, V>::GenerationCache(uint32_t maxCapacity): mMaxCapacity(maxCapacity), - mListener(NULL) { + mListener(NULL), mNullValue(NULL) { }; template<typename K, typename V> @@ -130,45 +132,44 @@ void GenerationCache<K, V>::clear() { } template<typename K, typename V> -bool GenerationCache<K, V>::contains(K key) const { +bool GenerationCache<K, V>::contains(const K& key) const { return mCache.indexOfKey(key) >= 0; } template<typename K, typename V> -K GenerationCache<K, V>::getKeyAt(uint32_t index) const { +const K& GenerationCache<K, V>::getKeyAt(size_t index) const { return mCache.keyAt(index); } template<typename K, typename V> -V GenerationCache<K, V>::getValueAt(uint32_t index) const { +const V& GenerationCache<K, V>::getValueAt(size_t index) const { return mCache.valueAt(index)->value; } template<typename K, typename V> -V GenerationCache<K, V>::get(K key) { +const V& GenerationCache<K, V>::get(const K& key) { ssize_t index = mCache.indexOfKey(key); if (index >= 0) { - sp<Entry<K, V> > entry = mCache.valueAt(index); - if (entry.get()) { - detachFromCache(entry); - attachToCache(entry); - return entry->value; - } + const sp<Entry<K, V> >& entry = mCache.valueAt(index); + detachFromCache(entry); + attachToCache(entry); + return entry->value; } - return NULL; + return mNullValue; } template<typename K, typename V> -bool GenerationCache<K, V>::put(K key, V value) { +bool GenerationCache<K, V>::put(const K& key, const V& value) { if (mMaxCapacity != kUnlimitedCapacity && mCache.size() >= mMaxCapacity) { removeOldest(); } ssize_t index = mCache.indexOfKey(key); if (index < 0) { - sp<Entry<K, V> > entry = new Entry<K, V>; - addToCache(entry, key, value); + sp<Entry<K, V> > entry = new Entry<K, V>(key, value); + mCache.add(key, entry); + attachToCache(entry); return true; } @@ -176,49 +177,44 @@ bool GenerationCache<K, V>::put(K key, V value) { } template<typename K, typename V> -void GenerationCache<K, V>::addToCache(sp<Entry<K, V> > entry, K key, V value) { - entry->key = key; - entry->value = value; - mCache.add(key, entry); - attachToCache(entry); -} - -template<typename K, typename V> -V GenerationCache<K, V>::remove(K key) { +bool GenerationCache<K, V>::remove(const K& key) { ssize_t index = mCache.indexOfKey(key); if (index >= 0) { - return removeAt(index); + removeAt(index); + return true; } - return NULL; + return false; } template<typename K, typename V> -V GenerationCache<K, V>::removeAt(ssize_t index) { +void GenerationCache<K, V>::removeAt(ssize_t index) { sp<Entry<K, V> > entry = mCache.valueAt(index); if (mListener) { (*mListener)(entry->key, entry->value); } mCache.removeItemsAt(index, 1); detachFromCache(entry); - - return entry->value; } template<typename K, typename V> -V GenerationCache<K, V>::removeOldest() { +bool GenerationCache<K, V>::removeOldest() { if (mOldest.get()) { ssize_t index = mCache.indexOfKey(mOldest->key); if (index >= 0) { - return removeAt(index); + removeAt(index); + return true; } + ALOGE("GenerationCache: removeOldest failed to find the item in the cache " + "with the given key, but we know it must be in there. " + "Is the key comparator kaput?"); } - return NULL; + return false; } template<typename K, typename V> -void GenerationCache<K, V>::attachToCache(sp<Entry<K, V> > entry) { +void GenerationCache<K, V>::attachToCache(const sp<Entry<K, V> >& entry) { if (!mYoungest.get()) { mYoungest = mOldest = entry; } else { @@ -229,20 +225,16 @@ void GenerationCache<K, V>::attachToCache(sp<Entry<K, V> > entry) { } template<typename K, typename V> -void GenerationCache<K, V>::detachFromCache(sp<Entry<K, V> > entry) { +void GenerationCache<K, V>::detachFromCache(const sp<Entry<K, V> >& entry) { if (entry->parent.get()) { entry->parent->child = entry->child; + } else { + mOldest = entry->child; } if (entry->child.get()) { entry->child->parent = entry->parent; - } - - if (mOldest == entry) { - mOldest = entry->child; - } - - if (mYoungest == entry) { + } else { mYoungest = entry->parent; } diff --git a/include/utils/KeyedVector.h b/include/utils/KeyedVector.h index 65165a2..85535bd 100644 --- a/include/utils/KeyedVector.h +++ b/include/utils/KeyedVector.h @@ -66,7 +66,7 @@ public: ssize_t indexOfKey(const KEY& key) const; /*! - * modifing the array + * modifying the array */ VALUE& editValueFor(const KEY& key); diff --git a/include/utils/ObbFile.h b/include/utils/ObbFile.h deleted file mode 100644 index 47559cd..0000000 --- a/include/utils/ObbFile.h +++ /dev/null @@ -1,145 +0,0 @@ -/* - * Copyright (C) 2010 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. - */ - -#ifndef OBBFILE_H_ -#define OBBFILE_H_ - -#include <stdint.h> -#include <strings.h> - -#include <utils/RefBase.h> -#include <utils/String8.h> - -namespace android { - -// OBB flags (bit 0) -#define OBB_OVERLAY (1 << 0) -#define OBB_SALTED (1 << 1) - -class ObbFile : public RefBase { -protected: - virtual ~ObbFile(); - -public: - ObbFile(); - - bool readFrom(const char* filename); - bool readFrom(int fd); - bool writeTo(const char* filename); - bool writeTo(int fd); - bool removeFrom(const char* filename); - bool removeFrom(int fd); - - const char* getFileName() const { - return mFileName; - } - - const String8 getPackageName() const { - return mPackageName; - } - - void setPackageName(String8 packageName) { - mPackageName = packageName; - } - - int32_t getVersion() const { - return mVersion; - } - - void setVersion(int32_t version) { - mVersion = version; - } - - int32_t getFlags() const { - return mFlags; - } - - void setFlags(int32_t flags) { - mFlags = flags; - } - - const unsigned char* getSalt(size_t* length) const { - if ((mFlags & OBB_SALTED) == 0) { - *length = 0; - return NULL; - } - - *length = sizeof(mSalt); - return mSalt; - } - - bool setSalt(const unsigned char* salt, size_t length) { - if (length != sizeof(mSalt)) { - return false; - } - - memcpy(mSalt, salt, sizeof(mSalt)); - mFlags |= OBB_SALTED; - return true; - } - - bool isOverlay() { - return (mFlags & OBB_OVERLAY) == OBB_OVERLAY; - } - - void setOverlay(bool overlay) { - if (overlay) { - mFlags |= OBB_OVERLAY; - } else { - mFlags &= ~OBB_OVERLAY; - } - } - - static inline uint32_t get4LE(const unsigned char* buf) { - return buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24); - } - - static inline void put4LE(unsigned char* buf, uint32_t val) { - buf[0] = val & 0xFF; - buf[1] = (val >> 8) & 0xFF; - buf[2] = (val >> 16) & 0xFF; - buf[3] = (val >> 24) & 0xFF; - } - -private: - /* Package name this ObbFile is associated with */ - String8 mPackageName; - - /* Package version this ObbFile is associated with */ - int32_t mVersion; - - /* Flags for this OBB type. */ - int32_t mFlags; - - /* Whether the file is salted. */ - bool mSalted; - - /* The encryption salt. */ - unsigned char mSalt[8]; - - const char* mFileName; - - size_t mFileSize; - - size_t mFooterStart; - - unsigned char* mReadBuf; - - bool parseObbFile(int fd); -}; - -} -#endif /* OBBFILE_H_ */ diff --git a/include/utils/ResourceTypes.h b/include/utils/ResourceTypes.h deleted file mode 100644 index 71e5324..0000000 --- a/include/utils/ResourceTypes.h +++ /dev/null @@ -1,2128 +0,0 @@ -/* - * Copyright (C) 2005 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. - */ - -// -// Definitions of resource data structures. -// -#ifndef _LIBS_UTILS_RESOURCE_TYPES_H -#define _LIBS_UTILS_RESOURCE_TYPES_H - -#include <utils/Asset.h> -#include <utils/ByteOrder.h> -#include <utils/Errors.h> -#include <utils/String16.h> -#include <utils/Vector.h> - -#include <utils/threads.h> - -#include <stdint.h> -#include <sys/types.h> - -#include <android/configuration.h> - -namespace android { - -/** ******************************************************************** - * PNG Extensions - * - * New private chunks that may be placed in PNG images. - * - *********************************************************************** */ - -/** - * This chunk specifies how to split an image into segments for - * scaling. - * - * There are J horizontal and K vertical segments. These segments divide - * the image into J*K regions as follows (where J=4 and K=3): - * - * F0 S0 F1 S1 - * +-----+----+------+-------+ - * S2| 0 | 1 | 2 | 3 | - * +-----+----+------+-------+ - * | | | | | - * | | | | | - * F2| 4 | 5 | 6 | 7 | - * | | | | | - * | | | | | - * +-----+----+------+-------+ - * S3| 8 | 9 | 10 | 11 | - * +-----+----+------+-------+ - * - * Each horizontal and vertical segment is considered to by either - * stretchable (marked by the Sx labels) or fixed (marked by the Fy - * labels), in the horizontal or vertical axis, respectively. In the - * above example, the first is horizontal segment (F0) is fixed, the - * next is stretchable and then they continue to alternate. Note that - * the segment list for each axis can begin or end with a stretchable - * or fixed segment. - * - * The relative sizes of the stretchy segments indicates the relative - * amount of stretchiness of the regions bordered by the segments. For - * example, regions 3, 7 and 11 above will take up more horizontal space - * than regions 1, 5 and 9 since the horizontal segment associated with - * the first set of regions is larger than the other set of regions. The - * ratios of the amount of horizontal (or vertical) space taken by any - * two stretchable slices is exactly the ratio of their corresponding - * segment lengths. - * - * xDivs and yDivs point to arrays of horizontal and vertical pixel - * indices. The first pair of Divs (in either array) indicate the - * starting and ending points of the first stretchable segment in that - * axis. The next pair specifies the next stretchable segment, etc. So - * in the above example xDiv[0] and xDiv[1] specify the horizontal - * coordinates for the regions labeled 1, 5 and 9. xDiv[2] and - * xDiv[3] specify the coordinates for regions 3, 7 and 11. Note that - * the leftmost slices always start at x=0 and the rightmost slices - * always end at the end of the image. So, for example, the regions 0, - * 4 and 8 (which are fixed along the X axis) start at x value 0 and - * go to xDiv[0] and slices 2, 6 and 10 start at xDiv[1] and end at - * xDiv[2]. - * - * The array pointed to by the colors field lists contains hints for - * each of the regions. They are ordered according left-to-right and - * top-to-bottom as indicated above. For each segment that is a solid - * color the array entry will contain that color value; otherwise it - * will contain NO_COLOR. Segments that are completely transparent - * will always have the value TRANSPARENT_COLOR. - * - * The PNG chunk type is "npTc". - */ -struct Res_png_9patch -{ - Res_png_9patch() : wasDeserialized(false), xDivs(NULL), - yDivs(NULL), colors(NULL) { } - - int8_t wasDeserialized; - int8_t numXDivs; - int8_t numYDivs; - int8_t numColors; - - // These tell where the next section of a patch starts. - // For example, the first patch includes the pixels from - // 0 to xDivs[0]-1 and the second patch includes the pixels - // from xDivs[0] to xDivs[1]-1. - // Note: allocation/free of these pointers is left to the caller. - int32_t* xDivs; - int32_t* yDivs; - - int32_t paddingLeft, paddingRight; - int32_t paddingTop, paddingBottom; - - enum { - // The 9 patch segment is not a solid color. - NO_COLOR = 0x00000001, - - // The 9 patch segment is completely transparent. - TRANSPARENT_COLOR = 0x00000000 - }; - // Note: allocation/free of this pointer is left to the caller. - uint32_t* colors; - - // Convert data from device representation to PNG file representation. - void deviceToFile(); - // Convert data from PNG file representation to device representation. - void fileToDevice(); - // Serialize/Marshall the patch data into a newly malloc-ed block - void* serialize(); - // Serialize/Marshall the patch data - void serialize(void* outData); - // Deserialize/Unmarshall the patch data - static Res_png_9patch* deserialize(const void* data); - // Compute the size of the serialized data structure - size_t serializedSize(); -}; - -/** ******************************************************************** - * Base Types - * - * These are standard types that are shared between multiple specific - * resource types. - * - *********************************************************************** */ - -/** - * Header that appears at the front of every data chunk in a resource. - */ -struct ResChunk_header -{ - // Type identifier for this chunk. The meaning of this value depends - // on the containing chunk. - uint16_t type; - - // Size of the chunk header (in bytes). Adding this value to - // the address of the chunk allows you to find its associated data - // (if any). - uint16_t headerSize; - - // Total size of this chunk (in bytes). This is the chunkSize plus - // the size of any data associated with the chunk. Adding this value - // to the chunk allows you to completely skip its contents (including - // any child chunks). If this value is the same as chunkSize, there is - // no data associated with the chunk. - uint32_t size; -}; - -enum { - RES_NULL_TYPE = 0x0000, - RES_STRING_POOL_TYPE = 0x0001, - RES_TABLE_TYPE = 0x0002, - RES_XML_TYPE = 0x0003, - - // Chunk types in RES_XML_TYPE - RES_XML_FIRST_CHUNK_TYPE = 0x0100, - RES_XML_START_NAMESPACE_TYPE= 0x0100, - RES_XML_END_NAMESPACE_TYPE = 0x0101, - RES_XML_START_ELEMENT_TYPE = 0x0102, - RES_XML_END_ELEMENT_TYPE = 0x0103, - RES_XML_CDATA_TYPE = 0x0104, - RES_XML_LAST_CHUNK_TYPE = 0x017f, - // This contains a uint32_t array mapping strings in the string - // pool back to resource identifiers. It is optional. - RES_XML_RESOURCE_MAP_TYPE = 0x0180, - - // Chunk types in RES_TABLE_TYPE - RES_TABLE_PACKAGE_TYPE = 0x0200, - RES_TABLE_TYPE_TYPE = 0x0201, - RES_TABLE_TYPE_SPEC_TYPE = 0x0202 -}; - -/** - * Macros for building/splitting resource identifiers. - */ -#define Res_VALIDID(resid) (resid != 0) -#define Res_CHECKID(resid) ((resid&0xFFFF0000) != 0) -#define Res_MAKEID(package, type, entry) \ - (((package+1)<<24) | (((type+1)&0xFF)<<16) | (entry&0xFFFF)) -#define Res_GETPACKAGE(id) ((id>>24)-1) -#define Res_GETTYPE(id) (((id>>16)&0xFF)-1) -#define Res_GETENTRY(id) (id&0xFFFF) - -#define Res_INTERNALID(resid) ((resid&0xFFFF0000) != 0 && (resid&0xFF0000) == 0) -#define Res_MAKEINTERNAL(entry) (0x01000000 | (entry&0xFFFF)) -#define Res_MAKEARRAY(entry) (0x02000000 | (entry&0xFFFF)) - -#define Res_MAXPACKAGE 255 - -/** - * Representation of a value in a resource, supplying type - * information. - */ -struct Res_value -{ - // Number of bytes in this structure. - uint16_t size; - - // Always set to 0. - uint8_t res0; - - // Type of the data value. - enum { - // Contains no data. - TYPE_NULL = 0x00, - // The 'data' holds a ResTable_ref, a reference to another resource - // table entry. - TYPE_REFERENCE = 0x01, - // The 'data' holds an attribute resource identifier. - TYPE_ATTRIBUTE = 0x02, - // The 'data' holds an index into the containing resource table's - // global value string pool. - TYPE_STRING = 0x03, - // The 'data' holds a single-precision floating point number. - TYPE_FLOAT = 0x04, - // The 'data' holds a complex number encoding a dimension value, - // such as "100in". - TYPE_DIMENSION = 0x05, - // The 'data' holds a complex number encoding a fraction of a - // container. - TYPE_FRACTION = 0x06, - - // Beginning of integer flavors... - TYPE_FIRST_INT = 0x10, - - // The 'data' is a raw integer value of the form n..n. - TYPE_INT_DEC = 0x10, - // The 'data' is a raw integer value of the form 0xn..n. - TYPE_INT_HEX = 0x11, - // The 'data' is either 0 or 1, for input "false" or "true" respectively. - TYPE_INT_BOOLEAN = 0x12, - - // Beginning of color integer flavors... - TYPE_FIRST_COLOR_INT = 0x1c, - - // The 'data' is a raw integer value of the form #aarrggbb. - TYPE_INT_COLOR_ARGB8 = 0x1c, - // The 'data' is a raw integer value of the form #rrggbb. - TYPE_INT_COLOR_RGB8 = 0x1d, - // The 'data' is a raw integer value of the form #argb. - TYPE_INT_COLOR_ARGB4 = 0x1e, - // The 'data' is a raw integer value of the form #rgb. - TYPE_INT_COLOR_RGB4 = 0x1f, - - // ...end of integer flavors. - TYPE_LAST_COLOR_INT = 0x1f, - - // ...end of integer flavors. - TYPE_LAST_INT = 0x1f - }; - uint8_t dataType; - - // Structure of complex data values (TYPE_UNIT and TYPE_FRACTION) - enum { - // Where the unit type information is. This gives us 16 possible - // types, as defined below. - COMPLEX_UNIT_SHIFT = 0, - COMPLEX_UNIT_MASK = 0xf, - - // TYPE_DIMENSION: Value is raw pixels. - COMPLEX_UNIT_PX = 0, - // TYPE_DIMENSION: Value is Device Independent Pixels. - COMPLEX_UNIT_DIP = 1, - // TYPE_DIMENSION: Value is a Scaled device independent Pixels. - COMPLEX_UNIT_SP = 2, - // TYPE_DIMENSION: Value is in points. - COMPLEX_UNIT_PT = 3, - // TYPE_DIMENSION: Value is in inches. - COMPLEX_UNIT_IN = 4, - // TYPE_DIMENSION: Value is in millimeters. - COMPLEX_UNIT_MM = 5, - - // TYPE_FRACTION: A basic fraction of the overall size. - COMPLEX_UNIT_FRACTION = 0, - // TYPE_FRACTION: A fraction of the parent size. - COMPLEX_UNIT_FRACTION_PARENT = 1, - - // Where the radix information is, telling where the decimal place - // appears in the mantissa. This give us 4 possible fixed point - // representations as defined below. - COMPLEX_RADIX_SHIFT = 4, - COMPLEX_RADIX_MASK = 0x3, - - // The mantissa is an integral number -- i.e., 0xnnnnnn.0 - COMPLEX_RADIX_23p0 = 0, - // The mantissa magnitude is 16 bits -- i.e, 0xnnnn.nn - COMPLEX_RADIX_16p7 = 1, - // The mantissa magnitude is 8 bits -- i.e, 0xnn.nnnn - COMPLEX_RADIX_8p15 = 2, - // The mantissa magnitude is 0 bits -- i.e, 0x0.nnnnnn - COMPLEX_RADIX_0p23 = 3, - - // Where the actual value is. This gives us 23 bits of - // precision. The top bit is the sign. - COMPLEX_MANTISSA_SHIFT = 8, - COMPLEX_MANTISSA_MASK = 0xffffff - }; - - // The data for this item, as interpreted according to dataType. - uint32_t data; - - void copyFrom_dtoh(const Res_value& src); -}; - -/** - * This is a reference to a unique entry (a ResTable_entry structure) - * in a resource table. The value is structured as: 0xpptteeee, - * where pp is the package index, tt is the type index in that - * package, and eeee is the entry index in that type. The package - * and type values start at 1 for the first item, to help catch cases - * where they have not been supplied. - */ -struct ResTable_ref -{ - uint32_t ident; -}; - -/** - * Reference to a string in a string pool. - */ -struct ResStringPool_ref -{ - // Index into the string pool table (uint32_t-offset from the indices - // immediately after ResStringPool_header) at which to find the location - // of the string data in the pool. - uint32_t index; -}; - -/** ******************************************************************** - * String Pool - * - * A set of strings that can be references by others through a - * ResStringPool_ref. - * - *********************************************************************** */ - -/** - * Definition for a pool of strings. The data of this chunk is an - * array of uint32_t providing indices into the pool, relative to - * stringsStart. At stringsStart are all of the UTF-16 strings - * concatenated together; each starts with a uint16_t of the string's - * length and each ends with a 0x0000 terminator. If a string is > - * 32767 characters, the high bit of the length is set meaning to take - * those 15 bits as a high word and it will be followed by another - * uint16_t containing the low word. - * - * If styleCount is not zero, then immediately following the array of - * uint32_t indices into the string table is another array of indices - * into a style table starting at stylesStart. Each entry in the - * style table is an array of ResStringPool_span structures. - */ -struct ResStringPool_header -{ - struct ResChunk_header header; - - // Number of strings in this pool (number of uint32_t indices that follow - // in the data). - uint32_t stringCount; - - // Number of style span arrays in the pool (number of uint32_t indices - // follow the string indices). - uint32_t styleCount; - - // Flags. - enum { - // If set, the string index is sorted by the string values (based - // on strcmp16()). - SORTED_FLAG = 1<<0, - - // String pool is encoded in UTF-8 - UTF8_FLAG = 1<<8 - }; - uint32_t flags; - - // Index from header of the string data. - uint32_t stringsStart; - - // Index from header of the style data. - uint32_t stylesStart; -}; - -/** - * This structure defines a span of style information associated with - * a string in the pool. - */ -struct ResStringPool_span -{ - enum { - END = 0xFFFFFFFF - }; - - // This is the name of the span -- that is, the name of the XML - // tag that defined it. The special value END (0xFFFFFFFF) indicates - // the end of an array of spans. - ResStringPool_ref name; - - // The range of characters in the string that this span applies to. - uint32_t firstChar, lastChar; -}; - -/** - * Convenience class for accessing data in a ResStringPool resource. - */ -class ResStringPool -{ -public: - ResStringPool(); - ResStringPool(const void* data, size_t size, bool copyData=false); - ~ResStringPool(); - - status_t setTo(const void* data, size_t size, bool copyData=false); - - status_t getError() const; - - void uninit(); - - inline const char16_t* stringAt(const ResStringPool_ref& ref, size_t* outLen) const { - return stringAt(ref.index, outLen); - } - const char16_t* stringAt(size_t idx, size_t* outLen) const; - - const char* string8At(size_t idx, size_t* outLen) const; - - const ResStringPool_span* styleAt(const ResStringPool_ref& ref) const; - const ResStringPool_span* styleAt(size_t idx) const; - - ssize_t indexOfString(const char16_t* str, size_t strLen) const; - - size_t size() const; - -#ifndef HAVE_ANDROID_OS - bool isUTF8() const; -#endif - -private: - status_t mError; - void* mOwnedData; - const ResStringPool_header* mHeader; - size_t mSize; - mutable Mutex mDecodeLock; - const uint32_t* mEntries; - const uint32_t* mEntryStyles; - const void* mStrings; - char16_t** mCache; - uint32_t mStringPoolSize; // number of uint16_t - const uint32_t* mStyles; - uint32_t mStylePoolSize; // number of uint32_t -}; - -/** ******************************************************************** - * XML Tree - * - * Binary representation of an XML document. This is designed to - * express everything in an XML document, in a form that is much - * easier to parse on the device. - * - *********************************************************************** */ - -/** - * XML tree header. This appears at the front of an XML tree, - * describing its content. It is followed by a flat array of - * ResXMLTree_node structures; the hierarchy of the XML document - * is described by the occurrance of RES_XML_START_ELEMENT_TYPE - * and corresponding RES_XML_END_ELEMENT_TYPE nodes in the array. - */ -struct ResXMLTree_header -{ - struct ResChunk_header header; -}; - -/** - * Basic XML tree node. A single item in the XML document. Extended info - * about the node can be found after header.headerSize. - */ -struct ResXMLTree_node -{ - struct ResChunk_header header; - - // Line number in original source file at which this element appeared. - uint32_t lineNumber; - - // Optional XML comment that was associated with this element; -1 if none. - struct ResStringPool_ref comment; -}; - -/** - * Extended XML tree node for CDATA tags -- includes the CDATA string. - * Appears header.headerSize bytes after a ResXMLTree_node. - */ -struct ResXMLTree_cdataExt -{ - // The raw CDATA character data. - struct ResStringPool_ref data; - - // The typed value of the character data if this is a CDATA node. - struct Res_value typedData; -}; - -/** - * Extended XML tree node for namespace start/end nodes. - * Appears header.headerSize bytes after a ResXMLTree_node. - */ -struct ResXMLTree_namespaceExt -{ - // The prefix of the namespace. - struct ResStringPool_ref prefix; - - // The URI of the namespace. - struct ResStringPool_ref uri; -}; - -/** - * Extended XML tree node for element start/end nodes. - * Appears header.headerSize bytes after a ResXMLTree_node. - */ -struct ResXMLTree_endElementExt -{ - // String of the full namespace of this element. - struct ResStringPool_ref ns; - - // String name of this node if it is an ELEMENT; the raw - // character data if this is a CDATA node. - struct ResStringPool_ref name; -}; - -/** - * Extended XML tree node for start tags -- includes attribute - * information. - * Appears header.headerSize bytes after a ResXMLTree_node. - */ -struct ResXMLTree_attrExt -{ - // String of the full namespace of this element. - struct ResStringPool_ref ns; - - // String name of this node if it is an ELEMENT; the raw - // character data if this is a CDATA node. - struct ResStringPool_ref name; - - // Byte offset from the start of this structure where the attributes start. - uint16_t attributeStart; - - // Size of the ResXMLTree_attribute structures that follow. - uint16_t attributeSize; - - // Number of attributes associated with an ELEMENT. These are - // available as an array of ResXMLTree_attribute structures - // immediately following this node. - uint16_t attributeCount; - - // Index (1-based) of the "id" attribute. 0 if none. - uint16_t idIndex; - - // Index (1-based) of the "class" attribute. 0 if none. - uint16_t classIndex; - - // Index (1-based) of the "style" attribute. 0 if none. - uint16_t styleIndex; -}; - -struct ResXMLTree_attribute -{ - // Namespace of this attribute. - struct ResStringPool_ref ns; - - // Name of this attribute. - struct ResStringPool_ref name; - - // The original raw string value of this attribute. - struct ResStringPool_ref rawValue; - - // Processesd typed value of this attribute. - struct Res_value typedValue; -}; - -class ResXMLTree; - -class ResXMLParser -{ -public: - ResXMLParser(const ResXMLTree& tree); - - enum event_code_t { - BAD_DOCUMENT = -1, - START_DOCUMENT = 0, - END_DOCUMENT = 1, - - FIRST_CHUNK_CODE = RES_XML_FIRST_CHUNK_TYPE, - - START_NAMESPACE = RES_XML_START_NAMESPACE_TYPE, - END_NAMESPACE = RES_XML_END_NAMESPACE_TYPE, - START_TAG = RES_XML_START_ELEMENT_TYPE, - END_TAG = RES_XML_END_ELEMENT_TYPE, - TEXT = RES_XML_CDATA_TYPE - }; - - struct ResXMLPosition - { - event_code_t eventCode; - const ResXMLTree_node* curNode; - const void* curExt; - }; - - void restart(); - - const ResStringPool& getStrings() const; - - event_code_t getEventType() const; - // Note, unlike XmlPullParser, the first call to next() will return - // START_TAG of the first element. - event_code_t next(); - - // These are available for all nodes: - int32_t getCommentID() const; - const uint16_t* getComment(size_t* outLen) const; - uint32_t getLineNumber() const; - - // This is available for TEXT: - int32_t getTextID() const; - const uint16_t* getText(size_t* outLen) const; - ssize_t getTextValue(Res_value* outValue) const; - - // These are available for START_NAMESPACE and END_NAMESPACE: - int32_t getNamespacePrefixID() const; - const uint16_t* getNamespacePrefix(size_t* outLen) const; - int32_t getNamespaceUriID() const; - const uint16_t* getNamespaceUri(size_t* outLen) const; - - // These are available for START_TAG and END_TAG: - int32_t getElementNamespaceID() const; - const uint16_t* getElementNamespace(size_t* outLen) const; - int32_t getElementNameID() const; - const uint16_t* getElementName(size_t* outLen) const; - - // Remaining methods are for retrieving information about attributes - // associated with a START_TAG: - - size_t getAttributeCount() const; - - // Returns -1 if no namespace, -2 if idx out of range. - int32_t getAttributeNamespaceID(size_t idx) const; - const uint16_t* getAttributeNamespace(size_t idx, size_t* outLen) const; - - int32_t getAttributeNameID(size_t idx) const; - const uint16_t* getAttributeName(size_t idx, size_t* outLen) const; - uint32_t getAttributeNameResID(size_t idx) const; - - int32_t getAttributeValueStringID(size_t idx) const; - const uint16_t* getAttributeStringValue(size_t idx, size_t* outLen) const; - - int32_t getAttributeDataType(size_t idx) const; - int32_t getAttributeData(size_t idx) const; - ssize_t getAttributeValue(size_t idx, Res_value* outValue) const; - - ssize_t indexOfAttribute(const char* ns, const char* attr) const; - ssize_t indexOfAttribute(const char16_t* ns, size_t nsLen, - const char16_t* attr, size_t attrLen) const; - - ssize_t indexOfID() const; - ssize_t indexOfClass() const; - ssize_t indexOfStyle() const; - - void getPosition(ResXMLPosition* pos) const; - void setPosition(const ResXMLPosition& pos); - -private: - friend class ResXMLTree; - - event_code_t nextNode(); - - const ResXMLTree& mTree; - event_code_t mEventCode; - const ResXMLTree_node* mCurNode; - const void* mCurExt; -}; - -/** - * Convenience class for accessing data in a ResXMLTree resource. - */ -class ResXMLTree : public ResXMLParser -{ -public: - ResXMLTree(); - ResXMLTree(const void* data, size_t size, bool copyData=false); - ~ResXMLTree(); - - status_t setTo(const void* data, size_t size, bool copyData=false); - - status_t getError() const; - - void uninit(); - -private: - friend class ResXMLParser; - - status_t validateNode(const ResXMLTree_node* node) const; - - status_t mError; - void* mOwnedData; - const ResXMLTree_header* mHeader; - size_t mSize; - const uint8_t* mDataEnd; - ResStringPool mStrings; - const uint32_t* mResIds; - size_t mNumResIds; - const ResXMLTree_node* mRootNode; - const void* mRootExt; - event_code_t mRootCode; -}; - -/** ******************************************************************** - * RESOURCE TABLE - * - *********************************************************************** */ - -/** - * Header for a resource table. Its data contains a series of - * additional chunks: - * * A ResStringPool_header containing all table values. - * * One or more ResTable_package chunks. - * - * Specific entries within a resource table can be uniquely identified - * with a single integer as defined by the ResTable_ref structure. - */ -struct ResTable_header -{ - struct ResChunk_header header; - - // The number of ResTable_package structures. - uint32_t packageCount; -}; - -/** - * A collection of resource data types within a package. Followed by - * one or more ResTable_type and ResTable_typeSpec structures containing the - * entry values for each resource type. - */ -struct ResTable_package -{ - struct ResChunk_header header; - - // If this is a base package, its ID. Package IDs start - // at 1 (corresponding to the value of the package bits in a - // resource identifier). 0 means this is not a base package. - uint32_t id; - - // Actual name of this package, \0-terminated. - char16_t name[128]; - - // Offset to a ResStringPool_header defining the resource - // type symbol table. If zero, this package is inheriting from - // another base package (overriding specific values in it). - uint32_t typeStrings; - - // Last index into typeStrings that is for public use by others. - uint32_t lastPublicType; - - // Offset to a ResStringPool_header defining the resource - // key symbol table. If zero, this package is inheriting from - // another base package (overriding specific values in it). - uint32_t keyStrings; - - // Last index into keyStrings that is for public use by others. - uint32_t lastPublicKey; -}; - -/** - * Describes a particular resource configuration. - */ -struct ResTable_config -{ - // Number of bytes in this structure. - uint32_t size; - - union { - struct { - // Mobile country code (from SIM). 0 means "any". - uint16_t mcc; - // Mobile network code (from SIM). 0 means "any". - uint16_t mnc; - }; - uint32_t imsi; - }; - - union { - struct { - // \0\0 means "any". Otherwise, en, fr, etc. - char language[2]; - - // \0\0 means "any". Otherwise, US, CA, etc. - char country[2]; - }; - uint32_t locale; - }; - - enum { - ORIENTATION_ANY = ACONFIGURATION_ORIENTATION_ANY, - ORIENTATION_PORT = ACONFIGURATION_ORIENTATION_PORT, - ORIENTATION_LAND = ACONFIGURATION_ORIENTATION_LAND, - ORIENTATION_SQUARE = ACONFIGURATION_ORIENTATION_SQUARE, - }; - - enum { - TOUCHSCREEN_ANY = ACONFIGURATION_TOUCHSCREEN_ANY, - TOUCHSCREEN_NOTOUCH = ACONFIGURATION_TOUCHSCREEN_NOTOUCH, - TOUCHSCREEN_STYLUS = ACONFIGURATION_TOUCHSCREEN_STYLUS, - TOUCHSCREEN_FINGER = ACONFIGURATION_TOUCHSCREEN_FINGER, - }; - - enum { - DENSITY_DEFAULT = ACONFIGURATION_DENSITY_DEFAULT, - DENSITY_LOW = ACONFIGURATION_DENSITY_LOW, - DENSITY_MEDIUM = ACONFIGURATION_DENSITY_MEDIUM, - DENSITY_TV = ACONFIGURATION_DENSITY_TV, - DENSITY_HIGH = ACONFIGURATION_DENSITY_HIGH, - DENSITY_NONE = ACONFIGURATION_DENSITY_NONE - }; - - union { - struct { - uint8_t orientation; - uint8_t touchscreen; - uint16_t density; - }; - uint32_t screenType; - }; - - enum { - KEYBOARD_ANY = ACONFIGURATION_KEYBOARD_ANY, - KEYBOARD_NOKEYS = ACONFIGURATION_KEYBOARD_NOKEYS, - KEYBOARD_QWERTY = ACONFIGURATION_KEYBOARD_QWERTY, - KEYBOARD_12KEY = ACONFIGURATION_KEYBOARD_12KEY, - }; - - enum { - NAVIGATION_ANY = ACONFIGURATION_NAVIGATION_ANY, - NAVIGATION_NONAV = ACONFIGURATION_NAVIGATION_NONAV, - NAVIGATION_DPAD = ACONFIGURATION_NAVIGATION_DPAD, - NAVIGATION_TRACKBALL = ACONFIGURATION_NAVIGATION_TRACKBALL, - NAVIGATION_WHEEL = ACONFIGURATION_NAVIGATION_WHEEL, - }; - - enum { - MASK_KEYSHIDDEN = 0x0003, - KEYSHIDDEN_ANY = ACONFIGURATION_KEYSHIDDEN_ANY, - KEYSHIDDEN_NO = ACONFIGURATION_KEYSHIDDEN_NO, - KEYSHIDDEN_YES = ACONFIGURATION_KEYSHIDDEN_YES, - KEYSHIDDEN_SOFT = ACONFIGURATION_KEYSHIDDEN_SOFT, - }; - - enum { - MASK_NAVHIDDEN = 0x000c, - SHIFT_NAVHIDDEN = 2, - NAVHIDDEN_ANY = ACONFIGURATION_NAVHIDDEN_ANY << SHIFT_NAVHIDDEN, - NAVHIDDEN_NO = ACONFIGURATION_NAVHIDDEN_NO << SHIFT_NAVHIDDEN, - NAVHIDDEN_YES = ACONFIGURATION_NAVHIDDEN_YES << SHIFT_NAVHIDDEN, - }; - - union { - struct { - uint8_t keyboard; - uint8_t navigation; - uint8_t inputFlags; - uint8_t inputPad0; - }; - uint32_t input; - }; - - enum { - SCREENWIDTH_ANY = 0 - }; - - enum { - SCREENHEIGHT_ANY = 0 - }; - - union { - struct { - uint16_t screenWidth; - uint16_t screenHeight; - }; - uint32_t screenSize; - }; - - enum { - SDKVERSION_ANY = 0 - }; - - enum { - MINORVERSION_ANY = 0 - }; - - union { - struct { - uint16_t sdkVersion; - // For now minorVersion must always be 0!!! Its meaning - // is currently undefined. - uint16_t minorVersion; - }; - uint32_t version; - }; - - enum { - // screenLayout bits for screen size class. - MASK_SCREENSIZE = 0x0f, - SCREENSIZE_ANY = ACONFIGURATION_SCREENSIZE_ANY, - SCREENSIZE_SMALL = ACONFIGURATION_SCREENSIZE_SMALL, - SCREENSIZE_NORMAL = ACONFIGURATION_SCREENSIZE_NORMAL, - SCREENSIZE_LARGE = ACONFIGURATION_SCREENSIZE_LARGE, - SCREENSIZE_XLARGE = ACONFIGURATION_SCREENSIZE_XLARGE, - - // screenLayout bits for wide/long screen variation. - MASK_SCREENLONG = 0x30, - SHIFT_SCREENLONG = 4, - SCREENLONG_ANY = ACONFIGURATION_SCREENLONG_ANY << SHIFT_SCREENLONG, - SCREENLONG_NO = ACONFIGURATION_SCREENLONG_NO << SHIFT_SCREENLONG, - SCREENLONG_YES = ACONFIGURATION_SCREENLONG_YES << SHIFT_SCREENLONG, - }; - - enum { - // uiMode bits for the mode type. - MASK_UI_MODE_TYPE = 0x0f, - UI_MODE_TYPE_ANY = ACONFIGURATION_UI_MODE_TYPE_ANY, - UI_MODE_TYPE_NORMAL = ACONFIGURATION_UI_MODE_TYPE_NORMAL, - UI_MODE_TYPE_DESK = ACONFIGURATION_UI_MODE_TYPE_DESK, - UI_MODE_TYPE_CAR = ACONFIGURATION_UI_MODE_TYPE_CAR, - UI_MODE_TYPE_TELEVISION = ACONFIGURATION_UI_MODE_TYPE_TELEVISION, - - // uiMode bits for the night switch. - MASK_UI_MODE_NIGHT = 0x30, - SHIFT_UI_MODE_NIGHT = 4, - UI_MODE_NIGHT_ANY = ACONFIGURATION_UI_MODE_NIGHT_ANY << SHIFT_UI_MODE_NIGHT, - UI_MODE_NIGHT_NO = ACONFIGURATION_UI_MODE_NIGHT_NO << SHIFT_UI_MODE_NIGHT, - UI_MODE_NIGHT_YES = ACONFIGURATION_UI_MODE_NIGHT_YES << SHIFT_UI_MODE_NIGHT, - }; - - union { - struct { - uint8_t screenLayout; - uint8_t uiMode; - uint16_t smallestScreenWidthDp; - }; - uint32_t screenConfig; - }; - - union { - struct { - uint16_t screenWidthDp; - uint16_t screenHeightDp; - }; - uint32_t screenSizeDp; - }; - - inline void 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); - } - } - - inline void 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); - } - - inline void 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); - } - - inline int compare(const ResTable_config& o) const { - int32_t diff = (int32_t)(imsi - o.imsi); - if (diff != 0) return diff; - diff = (int32_t)(locale - o.locale); - if (diff != 0) return diff; - diff = (int32_t)(screenType - o.screenType); - if (diff != 0) return diff; - diff = (int32_t)(input - o.input); - if (diff != 0) return diff; - diff = (int32_t)(screenSize - o.screenSize); - if (diff != 0) return diff; - diff = (int32_t)(version - o.version); - if (diff != 0) return diff; - diff = (int32_t)(screenLayout - o.screenLayout); - if (diff != 0) return diff; - diff = (int32_t)(uiMode - o.uiMode); - if (diff != 0) return diff; - diff = (int32_t)(smallestScreenWidthDp - o.smallestScreenWidthDp); - if (diff != 0) return diff; - diff = (int32_t)(screenSizeDp - o.screenSizeDp); - return (int)diff; - } - - // Flags indicating a set of config values. These flag constants must - // match the corresponding ones in android.content.pm.ActivityInfo and - // attrs_manifest.xml. - enum { - CONFIG_MCC = ACONFIGURATION_MCC, - CONFIG_MNC = ACONFIGURATION_MCC, - CONFIG_LOCALE = ACONFIGURATION_LOCALE, - CONFIG_TOUCHSCREEN = ACONFIGURATION_TOUCHSCREEN, - CONFIG_KEYBOARD = ACONFIGURATION_KEYBOARD, - CONFIG_KEYBOARD_HIDDEN = ACONFIGURATION_KEYBOARD_HIDDEN, - CONFIG_NAVIGATION = ACONFIGURATION_NAVIGATION, - CONFIG_ORIENTATION = ACONFIGURATION_ORIENTATION, - CONFIG_DENSITY = ACONFIGURATION_DENSITY, - CONFIG_SCREEN_SIZE = ACONFIGURATION_SCREEN_SIZE, - CONFIG_SMALLEST_SCREEN_SIZE = ACONFIGURATION_SMALLEST_SCREEN_SIZE, - CONFIG_VERSION = ACONFIGURATION_VERSION, - CONFIG_SCREEN_LAYOUT = ACONFIGURATION_SCREEN_LAYOUT, - CONFIG_UI_MODE = ACONFIGURATION_UI_MODE - }; - - // Compare two configuration, returning CONFIG_* flags set for each value - // that is different. - inline int diff(const ResTable_config& o) const { - int diffs = 0; - if (mcc != o.mcc) diffs |= CONFIG_MCC; - if (mnc != o.mnc) diffs |= CONFIG_MNC; - if (locale != o.locale) diffs |= CONFIG_LOCALE; - 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 != o.screenLayout) diffs |= CONFIG_SCREEN_LAYOUT; - 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; - return diffs; - } - - // Return true if 'this' is more specific than 'o'. - inline bool - 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) { - if (language[0] != o.language[0]) { - if (!language[0]) return false; - if (!o.language[0]) return true; - } - - if (country[0] != o.country[0]) { - if (!country[0]) return false; - if (!o.country[0]) 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 (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; - } - - // Return true if 'this' is a better match than 'o' for the 'requested' - // configuration. This assumes that match() has already been used to - // remove any configurations that don't match the requested configuration - // at all; if they are not first filtered, non-matching results can be - // considered better than matching ones. - // The general rule per attribute: if the request cares about an attribute - // (it normally does), if the two (this and o) are equal it's a tie. If - // they are not equal then one must be generic because only generic and - // '==requested' will pass the match() call. So if this is not generic, - // it wins. If this IS generic, o wins (return false). - inline bool - 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 (locale || o.locale) { - if ((language[0] != o.language[0]) && requested->language[0]) { - return (language[0]); - } - - if ((country[0] != o.country[0]) && requested->country[0]) { - return (country[0]); - } - } - - 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. - 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; - } - //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); - 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; - } - return fixedMySL >= fixedOSL; - } - if (((screenLayout^o.screenLayout) & MASK_SCREENLONG) != 0 - && (requested->screenLayout & MASK_SCREENLONG)) { - return (screenLayout & MASK_SCREENLONG); - } - } - - 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) { - // density is tough. Any density is potentially useful - // because the system will scale it. Scaling down - // is generally better than scaling up. - // Default density counts as 160dpi (the system default) - // TODO - remove 160 constants - int h = (density?density:160); - int l = (o.density?o.density:160); - bool bImBigger = true; - if (l > h) { - int t = h; - h = l; - l = t; - bImBigger = false; - } - - int reqValue = (requested->density?requested->density:160); - if (reqValue >= h) { - // requested value higher than both l and h, give h - return bImBigger; - } - if (l >= reqValue) { - // requested value lower than both l and h, give l - return !bImBigger; - } - // saying that scaling down is 2x better than up - if (((2 * l) - reqValue) * h > reqValue * reqValue) { - 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; - } - 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); - } - - // Return true if 'this' can be considered a match for the parameters in - // 'settings'. - // Note this is asymetric. A default piece of data will match every request - // but a request for the default should not match odd specifics - // (ie, request with no mcc should not match a particular mcc's data) - // settings is the requested settings - inline bool match(const ResTable_config& settings) const { - if (imsi != 0) { - if (mcc != 0 && mcc != settings.mcc) { - return false; - } - if (mnc != 0 && mnc != settings.mnc) { - return false; - } - } - if (locale != 0) { - if (language[0] != 0 - && (language[0] != settings.language[0] - || language[1] != settings.language[1])) { - return false; - } - if (country[0] != 0 - && (country[0] != settings.country[0] - || country[1] != settings.country[1])) { - return false; - } - } - if (screenConfig != 0) { - const int screenSize = screenLayout&MASK_SCREENSIZE; - const int setScreenSize = settings.screenLayout&MASK_SCREENSIZE; - // Any screen sizes for larger screens than the setting do not - // match. - if (screenSize != 0 && screenSize > setScreenSize) { - return false; - } - - const int screenLong = screenLayout&MASK_SCREENLONG; - const int setScreenLong = settings.screenLayout&MASK_SCREENLONG; - if (screenLong != 0 && screenLong != setScreenLong) { - return false; - } - - const int uiModeType = uiMode&MASK_UI_MODE_TYPE; - const int setUiModeType = settings.uiMode&MASK_UI_MODE_TYPE; - if (uiModeType != 0 && uiModeType != setUiModeType) { - return false; - } - - const int uiModeNight = uiMode&MASK_UI_MODE_NIGHT; - const int setUiModeNight = settings.uiMode&MASK_UI_MODE_NIGHT; - if (uiModeNight != 0 && uiModeNight != setUiModeNight) { - return false; - } - - if (smallestScreenWidthDp != 0 - && smallestScreenWidthDp > settings.smallestScreenWidthDp) { - return false; - } - } - if (screenSizeDp != 0) { - if (screenWidthDp != 0 && screenWidthDp > settings.screenWidthDp) { - //ALOGI("Filtering out width %d in requested %d", screenWidthDp, settings.screenWidthDp); - return false; - } - if (screenHeightDp != 0 && screenHeightDp > settings.screenHeightDp) { - //ALOGI("Filtering out height %d in requested %d", screenHeightDp, settings.screenHeightDp); - return false; - } - } - if (screenType != 0) { - if (orientation != 0 && orientation != settings.orientation) { - return false; - } - // density always matches - we can scale it. See isBetterThan - if (touchscreen != 0 && touchscreen != settings.touchscreen) { - return false; - } - } - if (input != 0) { - const int keysHidden = inputFlags&MASK_KEYSHIDDEN; - const int setKeysHidden = settings.inputFlags&MASK_KEYSHIDDEN; - if (keysHidden != 0 && keysHidden != setKeysHidden) { - // For compatibility, we count a request for KEYSHIDDEN_NO as also - // matching the more recent KEYSHIDDEN_SOFT. Basically - // KEYSHIDDEN_NO means there is some kind of keyboard available. - //ALOGI("Matching keysHidden: have=%d, config=%d\n", keysHidden, setKeysHidden); - if (keysHidden != KEYSHIDDEN_NO || setKeysHidden != KEYSHIDDEN_SOFT) { - //ALOGI("No match!"); - return false; - } - } - const int navHidden = inputFlags&MASK_NAVHIDDEN; - const int setNavHidden = settings.inputFlags&MASK_NAVHIDDEN; - if (navHidden != 0 && navHidden != setNavHidden) { - return false; - } - if (keyboard != 0 && keyboard != settings.keyboard) { - return false; - } - if (navigation != 0 && navigation != settings.navigation) { - return false; - } - } - if (screenSize != 0) { - if (screenWidth != 0 && screenWidth > settings.screenWidth) { - return false; - } - if (screenHeight != 0 && screenHeight > settings.screenHeight) { - return false; - } - } - if (version != 0) { - if (sdkVersion != 0 && sdkVersion > settings.sdkVersion) { - return false; - } - if (minorVersion != 0 && minorVersion != settings.minorVersion) { - return false; - } - } - return true; - } - - void getLocale(char str[6]) const { - memset(str, 0, 6); - if (language[0]) { - str[0] = language[0]; - str[1] = language[1]; - if (country[0]) { - str[2] = '_'; - str[3] = country[0]; - str[4] = country[1]; - } - } - } - - String8 toString() const { - char buf[200]; - sprintf(buf, "imsi=%d/%d lang=%c%c reg=%c%c orient=%d touch=%d dens=%d " - "kbd=%d nav=%d input=%d ssz=%dx%d sw%ddp w%ddp h%ddp sz=%d long=%d " - "ui=%d night=%d vers=%d.%d", - mcc, mnc, - language[0] ? language[0] : '-', language[1] ? language[1] : '-', - country[0] ? country[0] : '-', country[1] ? country[1] : '-', - orientation, touchscreen, density, keyboard, navigation, inputFlags, - screenWidth, screenHeight, smallestScreenWidthDp, screenWidthDp, screenHeightDp, - screenLayout&MASK_SCREENSIZE, screenLayout&MASK_SCREENLONG, - uiMode&MASK_UI_MODE_TYPE, uiMode&MASK_UI_MODE_NIGHT, - sdkVersion, minorVersion); - return String8(buf); - } -}; - -/** - * A specification of the resources defined by a particular type. - * - * There should be one of these chunks for each resource type. - * - * This structure is followed by an array of integers providing the set of - * configuation change flags (ResTable_config::CONFIG_*) that have multiple - * resources for that configuration. In addition, the high bit is set if that - * resource has been made public. - */ -struct ResTable_typeSpec -{ - struct ResChunk_header header; - - // The type identifier this chunk is holding. Type IDs start - // at 1 (corresponding to the value of the type bits in a - // resource identifier). 0 is invalid. - uint8_t id; - - // Must be 0. - uint8_t res0; - // Must be 0. - uint16_t res1; - - // Number of uint32_t entry configuration masks that follow. - uint32_t entryCount; - - enum { - // Additional flag indicating an entry is public. - SPEC_PUBLIC = 0x40000000 - }; -}; - -/** - * A collection of resource entries for a particular resource data - * type. Followed by an array of uint32_t defining the resource - * values, corresponding to the array of type strings in the - * ResTable_package::typeStrings string block. Each of these hold an - * index from entriesStart; a value of NO_ENTRY means that entry is - * not defined. - * - * There may be multiple of these chunks for a particular resource type, - * supply different configuration variations for the resource values of - * that type. - * - * It would be nice to have an additional ordered index of entries, so - * we can do a binary search if trying to find a resource by string name. - */ -struct ResTable_type -{ - struct ResChunk_header header; - - enum { - NO_ENTRY = 0xFFFFFFFF - }; - - // The type identifier this chunk is holding. Type IDs start - // at 1 (corresponding to the value of the type bits in a - // resource identifier). 0 is invalid. - uint8_t id; - - // Must be 0. - uint8_t res0; - // Must be 0. - uint16_t res1; - - // Number of uint32_t entry indices that follow. - uint32_t entryCount; - - // Offset from header where ResTable_entry data starts. - uint32_t entriesStart; - - // Configuration this collection of entries is designed for. - ResTable_config config; -}; - -/** - * This is the beginning of information about an entry in the resource - * table. It holds the reference to the name of this entry, and is - * immediately followed by one of: - * * A Res_value structure, if FLAG_COMPLEX is -not- set. - * * An array of ResTable_map structures, if FLAG_COMPLEX is set. - * These supply a set of name/value mappings of data. - */ -struct ResTable_entry -{ - // Number of bytes in this structure. - uint16_t size; - - enum { - // If set, this is a complex entry, holding a set of name/value - // mappings. It is followed by an array of ResTable_map structures. - FLAG_COMPLEX = 0x0001, - // If set, this resource has been declared public, so libraries - // are allowed to reference it. - FLAG_PUBLIC = 0x0002 - }; - uint16_t flags; - - // Reference into ResTable_package::keyStrings identifying this entry. - struct ResStringPool_ref key; -}; - -/** - * Extended form of a ResTable_entry for map entries, defining a parent map - * resource from which to inherit values. - */ -struct ResTable_map_entry : public ResTable_entry -{ - // Resource identifier of the parent mapping, or 0 if there is none. - ResTable_ref parent; - // Number of name/value pairs that follow for FLAG_COMPLEX. - uint32_t count; -}; - -/** - * A single name/value mapping that is part of a complex resource - * entry. - */ -struct ResTable_map -{ - // The resource identifier defining this mapping's name. For attribute - // resources, 'name' can be one of the following special resource types - // to supply meta-data about the attribute; for all other resource types - // it must be an attribute resource. - ResTable_ref name; - - // Special values for 'name' when defining attribute resources. - enum { - // This entry holds the attribute's type code. - ATTR_TYPE = Res_MAKEINTERNAL(0), - - // For integral attributes, this is the minimum value it can hold. - ATTR_MIN = Res_MAKEINTERNAL(1), - - // For integral attributes, this is the maximum value it can hold. - ATTR_MAX = Res_MAKEINTERNAL(2), - - // Localization of this resource is can be encouraged or required with - // an aapt flag if this is set - ATTR_L10N = Res_MAKEINTERNAL(3), - - // for plural support, see android.content.res.PluralRules#attrForQuantity(int) - ATTR_OTHER = Res_MAKEINTERNAL(4), - ATTR_ZERO = Res_MAKEINTERNAL(5), - ATTR_ONE = Res_MAKEINTERNAL(6), - ATTR_TWO = Res_MAKEINTERNAL(7), - ATTR_FEW = Res_MAKEINTERNAL(8), - ATTR_MANY = Res_MAKEINTERNAL(9) - - }; - - // Bit mask of allowed types, for use with ATTR_TYPE. - enum { - // No type has been defined for this attribute, use generic - // type handling. The low 16 bits are for types that can be - // handled generically; the upper 16 require additional information - // in the bag so can not be handled generically for TYPE_ANY. - TYPE_ANY = 0x0000FFFF, - - // Attribute holds a references to another resource. - TYPE_REFERENCE = 1<<0, - - // Attribute holds a generic string. - TYPE_STRING = 1<<1, - - // Attribute holds an integer value. ATTR_MIN and ATTR_MIN can - // optionally specify a constrained range of possible integer values. - TYPE_INTEGER = 1<<2, - - // Attribute holds a boolean integer. - TYPE_BOOLEAN = 1<<3, - - // Attribute holds a color value. - TYPE_COLOR = 1<<4, - - // Attribute holds a floating point value. - TYPE_FLOAT = 1<<5, - - // Attribute holds a dimension value, such as "20px". - TYPE_DIMENSION = 1<<6, - - // Attribute holds a fraction value, such as "20%". - TYPE_FRACTION = 1<<7, - - // Attribute holds an enumeration. The enumeration values are - // supplied as additional entries in the map. - TYPE_ENUM = 1<<16, - - // Attribute holds a bitmaks of flags. The flag bit values are - // supplied as additional entries in the map. - TYPE_FLAGS = 1<<17 - }; - - // Enum of localization modes, for use with ATTR_L10N. - enum { - L10N_NOT_REQUIRED = 0, - L10N_SUGGESTED = 1 - }; - - // This mapping's value. - Res_value value; -}; - -/** - * Convenience class for accessing data in a ResTable resource. - */ -class ResTable -{ -public: - ResTable(); - ResTable(const void* data, size_t size, void* cookie, - bool copyData=false); - ~ResTable(); - - status_t add(const void* data, size_t size, void* cookie, - bool copyData=false, const void* idmap = NULL); - status_t add(Asset* asset, void* cookie, - bool copyData=false, const void* idmap = NULL); - status_t add(ResTable* src); - - status_t getError() const; - - void uninit(); - - struct resource_name - { - const char16_t* package; - size_t packageLen; - const char16_t* type; - size_t typeLen; - const char16_t* name; - size_t nameLen; - }; - - bool getResourceName(uint32_t resID, resource_name* outName) const; - - /** - * Retrieve the value of a resource. If the resource is found, returns a - * value >= 0 indicating the table it is in (for use with - * getTableStringBlock() and getTableCookie()) and fills in 'outValue'. If - * not found, returns a negative error code. - * - * Note that this function does not do reference traversal. If you want - * to follow references to other resources to get the "real" value to - * use, you need to call resolveReference() after this function. - * - * @param resID The desired resoruce identifier. - * @param outValue Filled in with the resource data that was found. - * - * @return ssize_t Either a >= 0 table index or a negative error code. - */ - ssize_t getResource(uint32_t resID, Res_value* outValue, bool mayBeBag = false, - uint16_t density = 0, - uint32_t* outSpecFlags = NULL, - ResTable_config* outConfig = NULL) const; - - inline ssize_t getResource(const ResTable_ref& res, Res_value* outValue, - uint32_t* outSpecFlags=NULL) const { - return getResource(res.ident, outValue, false, 0, outSpecFlags, NULL); - } - - ssize_t resolveReference(Res_value* inOutValue, - ssize_t blockIndex, - uint32_t* outLastRef = NULL, - uint32_t* inoutTypeSpecFlags = NULL, - ResTable_config* outConfig = NULL) const; - - enum { - TMP_BUFFER_SIZE = 16 - }; - const char16_t* valueToString(const Res_value* value, size_t stringBlock, - char16_t tmpBuffer[TMP_BUFFER_SIZE], - size_t* outLen); - - struct bag_entry { - ssize_t stringBlock; - ResTable_map map; - }; - - /** - * Retrieve the bag of a resource. If the resoruce is found, returns the - * number of bags it contains and 'outBag' points to an array of their - * values. If not found, a negative error code is returned. - * - * Note that this function -does- do reference traversal of the bag data. - * - * @param resID The desired resource identifier. - * @param outBag Filled inm with a pointer to the bag mappings. - * - * @return ssize_t Either a >= 0 bag count of negative error code. - */ - ssize_t lockBag(uint32_t resID, const bag_entry** outBag) const; - - void unlockBag(const bag_entry* bag) const; - - void lock() const; - - ssize_t getBagLocked(uint32_t resID, const bag_entry** outBag, - uint32_t* outTypeSpecFlags=NULL) const; - - void unlock() const; - - class Theme { - public: - Theme(const ResTable& table); - ~Theme(); - - inline const ResTable& getResTable() const { return mTable; } - - status_t applyStyle(uint32_t resID, bool force=false); - status_t setTo(const Theme& other); - - /** - * Retrieve a value in the theme. If the theme defines this - * value, returns a value >= 0 indicating the table it is in - * (for use with getTableStringBlock() and getTableCookie) and - * fills in 'outValue'. If not found, returns a negative error - * code. - * - * Note that this function does not do reference traversal. If you want - * to follow references to other resources to get the "real" value to - * use, you need to call resolveReference() after this function. - * - * @param resID A resource identifier naming the desired theme - * attribute. - * @param outValue Filled in with the theme value that was - * found. - * - * @return ssize_t Either a >= 0 table index or a negative error code. - */ - ssize_t getAttribute(uint32_t resID, Res_value* outValue, - uint32_t* outTypeSpecFlags = NULL) const; - - /** - * This is like ResTable::resolveReference(), but also takes - * care of resolving attribute references to the theme. - */ - ssize_t resolveAttributeReference(Res_value* inOutValue, - ssize_t blockIndex, uint32_t* outLastRef = NULL, - uint32_t* inoutTypeSpecFlags = NULL, - ResTable_config* inoutConfig = NULL) const; - - void dumpToLog() const; - - private: - Theme(const Theme&); - Theme& operator=(const Theme&); - - struct theme_entry { - ssize_t stringBlock; - uint32_t typeSpecFlags; - Res_value value; - }; - struct type_info { - size_t numEntries; - theme_entry* entries; - }; - struct package_info { - size_t numTypes; - type_info types[]; - }; - - void free_package(package_info* pi); - package_info* copy_package(package_info* pi); - - const ResTable& mTable; - package_info* mPackages[Res_MAXPACKAGE]; - }; - - void setParameters(const ResTable_config* params); - void getParameters(ResTable_config* params) const; - - // Retrieve an identifier (which can be passed to getResource) - // for a given resource name. The 'name' can be fully qualified - // (<package>:<type>.<basename>) or the package or type components - // can be dropped if default values are supplied here. - // - // Returns 0 if no such resource was found, else a valid resource ID. - uint32_t identifierForName(const char16_t* name, size_t nameLen, - const char16_t* type = 0, size_t typeLen = 0, - const char16_t* defPackage = 0, - size_t defPackageLen = 0, - uint32_t* outTypeSpecFlags = NULL) const; - - static bool expandResourceRef(const uint16_t* refStr, size_t refLen, - String16* outPackage, - String16* outType, - String16* outName, - const String16* defType = NULL, - const String16* defPackage = NULL, - const char** outErrorMsg = NULL, - bool* outPublicOnly = NULL); - - static bool stringToInt(const char16_t* s, size_t len, Res_value* outValue); - static bool stringToFloat(const char16_t* s, size_t len, Res_value* outValue); - - // Used with stringToValue. - class Accessor - { - public: - inline virtual ~Accessor() { } - - virtual uint32_t getCustomResource(const String16& package, - const String16& type, - const String16& name) const = 0; - virtual uint32_t getCustomResourceWithCreation(const String16& package, - const String16& type, - const String16& name, - const bool createIfNeeded = false) = 0; - virtual uint32_t getRemappedPackage(uint32_t origPackage) const = 0; - virtual bool getAttributeType(uint32_t attrID, uint32_t* outType) = 0; - virtual bool getAttributeMin(uint32_t attrID, uint32_t* outMin) = 0; - virtual bool getAttributeMax(uint32_t attrID, uint32_t* outMax) = 0; - virtual bool getAttributeEnum(uint32_t attrID, - const char16_t* name, size_t nameLen, - Res_value* outValue) = 0; - virtual bool getAttributeFlags(uint32_t attrID, - const char16_t* name, size_t nameLen, - Res_value* outValue) = 0; - virtual uint32_t getAttributeL10N(uint32_t attrID) = 0; - virtual bool getLocalizationSetting() = 0; - virtual void reportError(void* accessorCookie, const char* fmt, ...) = 0; - }; - - // Convert a string to a resource value. Handles standard "@res", - // "#color", "123", and "0x1bd" types; performs escaping of strings. - // The resulting value is placed in 'outValue'; if it is a string type, - // 'outString' receives the string. If 'attrID' is supplied, the value is - // type checked against this attribute and it is used to perform enum - // evaluation. If 'acccessor' is supplied, it will be used to attempt to - // resolve resources that do not exist in this ResTable. If 'attrType' is - // supplied, the value will be type checked for this format if 'attrID' - // is not supplied or found. - bool stringToValue(Res_value* outValue, String16* outString, - const char16_t* s, size_t len, - bool preserveSpaces, bool coerceType, - uint32_t attrID = 0, - const String16* defType = NULL, - const String16* defPackage = NULL, - Accessor* accessor = NULL, - void* accessorCookie = NULL, - uint32_t attrType = ResTable_map::TYPE_ANY, - bool enforcePrivate = true) const; - - // Perform processing of escapes and quotes in a string. - static bool collectString(String16* outString, - const char16_t* s, size_t len, - bool preserveSpaces, - const char** outErrorMsg = NULL, - bool append = false); - - size_t getBasePackageCount() const; - const char16_t* getBasePackageName(size_t idx) const; - uint32_t getBasePackageId(size_t idx) const; - - size_t getTableCount() const; - const ResStringPool* getTableStringBlock(size_t index) const; - void* getTableCookie(size_t index) const; - - // Return the configurations (ResTable_config) that we know about - void getConfigurations(Vector<ResTable_config>* configs) const; - - void getLocales(Vector<String8>* locales) const; - - // Generate an idmap. - // - // Return value: on success: NO_ERROR; caller is responsible for free-ing - // outData (using free(3)). On failure, any status_t value other than - // NO_ERROR; the caller should not free outData. - status_t createIdmap(const ResTable& overlay, uint32_t originalCrc, uint32_t overlayCrc, - void** outData, size_t* outSize) const; - - enum { - IDMAP_HEADER_SIZE_BYTES = 3 * sizeof(uint32_t), - }; - // Retrieve idmap meta-data. - // - // This function only requires the idmap header (the first - // IDMAP_HEADER_SIZE_BYTES) bytes of an idmap file. - static bool getIdmapInfo(const void* idmap, size_t size, - uint32_t* pOriginalCrc, uint32_t* pOverlayCrc); - -#ifndef HAVE_ANDROID_OS - void print(bool inclValues) const; - static String8 normalizeForOutput(const char* input); -#endif - -private: - struct Header; - struct Type; - struct Package; - struct PackageGroup; - struct bag_set; - - status_t add(const void* data, size_t size, void* cookie, - Asset* asset, bool copyData, const Asset* idmap); - - ssize_t getResourcePackageIndex(uint32_t resID) const; - ssize_t getEntry( - const Package* package, int typeIndex, int entryIndex, - const ResTable_config* config, - const ResTable_type** outType, const ResTable_entry** outEntry, - const Type** outTypeClass) const; - status_t parsePackage( - const ResTable_package* const pkg, const Header* const header, uint32_t idmap_id); - - void print_value(const Package* pkg, const Res_value& value) const; - - mutable Mutex mLock; - - status_t mError; - - ResTable_config mParams; - - // Array of all resource tables. - Vector<Header*> mHeaders; - - // Array of packages in all resource tables. - Vector<PackageGroup*> mPackageGroups; - - // Mapping from resource package IDs to indices into the internal - // package array. - uint8_t mPackageMap[256]; -}; - -} // namespace android - -#endif // _LIBS_UTILS_RESOURCE_TYPES_H diff --git a/include/utils/StreamingZipInflater.h b/include/utils/StreamingZipInflater.h deleted file mode 100644 index 3ace5d5..0000000 --- a/include/utils/StreamingZipInflater.h +++ /dev/null @@ -1,84 +0,0 @@ -/* - * Copyright (C) 2010 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. - */ - -#ifndef __LIBS_STREAMINGZIPINFLATER_H -#define __LIBS_STREAMINGZIPINFLATER_H - -#include <unistd.h> -#include <inttypes.h> -#include <zlib.h> - -#include <utils/Compat.h> - -namespace android { - -class StreamingZipInflater { -public: - static const size_t INPUT_CHUNK_SIZE = 64 * 1024; - static const size_t OUTPUT_CHUNK_SIZE = 64 * 1024; - - // Flavor that pages in the compressed data from a fd - StreamingZipInflater(int fd, off64_t compDataStart, size_t uncompSize, size_t compSize); - - // Flavor that gets the compressed data from an in-memory buffer - StreamingZipInflater(class FileMap* dataMap, size_t uncompSize); - - ~StreamingZipInflater(); - - // read 'count' bytes of uncompressed data from the current position. outBuf may - // be NULL, in which case the data is consumed and discarded. - ssize_t read(void* outBuf, size_t count); - - // seeking backwards requires uncompressing fom the beginning, so is very - // expensive. seeking forwards only requires uncompressing from the current - // position to the destination. - off64_t seekAbsolute(off64_t absoluteInputPosition); - -private: - void initInflateState(); - int readNextChunk(); - - // where to find the uncompressed data - int mFd; - off64_t mInFileStart; // where the compressed data lives in the file - class FileMap* mDataMap; - - z_stream mInflateState; - bool mStreamNeedsInit; - - // output invariants for this asset - uint8_t* mOutBuf; // output buf for decompressed bytes - size_t mOutBufSize; // allocated size of mOutBuf - size_t mOutTotalSize; // total uncompressed size of the blob - - // current output state bookkeeping - off64_t mOutCurPosition; // current position in total offset - size_t mOutLastDecoded; // last decoded byte + 1 in mOutbuf - size_t mOutDeliverable; // next undelivered byte of decoded output in mOutBuf - - // input invariants - uint8_t* mInBuf; - size_t mInBufSize; // allocated size of mInBuf; - size_t mInTotalSize; // total size of compressed data for this blob - - // input state bookkeeping - size_t mInNextChunkOffset; // offset from start of blob at which the next input chunk lies - // the z_stream contains state about input block consumption -}; - -} - -#endif diff --git a/include/utils/TypeHelpers.h b/include/utils/TypeHelpers.h index a1663f3..1f2c2d5 100644 --- a/include/utils/TypeHelpers.h +++ b/include/utils/TypeHelpers.h @@ -213,6 +213,9 @@ void move_backward_type(TYPE* d, const TYPE* s, size_t n = 1) { template <typename KEY, typename VALUE> struct key_value_pair_t { + typedef KEY key_t; + typedef VALUE value_t; + KEY key; VALUE value; key_value_pair_t() { } @@ -222,27 +225,64 @@ struct key_value_pair_t { inline bool operator < (const key_value_pair_t& o) const { return strictly_order_type(key, o.key); } + inline const KEY& getKey() const { + return key; + } + inline const VALUE& getValue() const { + return value; + } }; -template<> template <typename K, typename V> struct trait_trivial_ctor< key_value_pair_t<K, V> > { enum { value = aggregate_traits<K,V>::has_trivial_ctor }; }; -template<> template <typename K, typename V> struct trait_trivial_dtor< key_value_pair_t<K, V> > { enum { value = aggregate_traits<K,V>::has_trivial_dtor }; }; -template<> template <typename K, typename V> struct trait_trivial_copy< key_value_pair_t<K, V> > { enum { value = aggregate_traits<K,V>::has_trivial_copy }; }; -template<> template <typename K, typename V> struct trait_trivial_move< key_value_pair_t<K, V> > { enum { value = aggregate_traits<K,V>::has_trivial_move }; }; // --------------------------------------------------------------------------- +/* + * Hash codes. + */ +typedef uint32_t hash_t; + +template <typename TKey> +hash_t hash_type(const TKey& key); + +/* Built-in hash code specializations. + * Assumes pointers are 32bit. */ +#define ANDROID_INT32_HASH(T) \ + template <> inline hash_t hash_type(const T& value) { return hash_t(value); } +#define ANDROID_INT64_HASH(T) \ + template <> inline hash_t hash_type(const T& value) { \ + return hash_t((value >> 32) ^ value); } +#define ANDROID_REINTERPRET_HASH(T, R) \ + template <> inline hash_t hash_type(const T& value) { \ + return hash_type(*reinterpret_cast<const R*>(&value)); } + +ANDROID_INT32_HASH(bool) +ANDROID_INT32_HASH(int8_t) +ANDROID_INT32_HASH(uint8_t) +ANDROID_INT32_HASH(int16_t) +ANDROID_INT32_HASH(uint16_t) +ANDROID_INT32_HASH(int32_t) +ANDROID_INT32_HASH(uint32_t) +ANDROID_INT64_HASH(int64_t) +ANDROID_INT64_HASH(uint64_t) +ANDROID_REINTERPRET_HASH(float, uint32_t) +ANDROID_REINTERPRET_HASH(double, uint64_t) + +template <typename T> inline hash_t hash_type(const T*& value) { + return hash_type(uintptr_t(value)); +} + }; // namespace android // --------------------------------------------------------------------------- diff --git a/include/utils/ZipFileCRO.h b/include/utils/ZipFileCRO.h deleted file mode 100644 index 3e42a95..0000000 --- a/include/utils/ZipFileCRO.h +++ /dev/null @@ -1,61 +0,0 @@ -/* - * 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. - */ - -// -// C API for ead-only access to Zip archives, with minimal heap allocation. -// -#ifndef __LIBS_ZIPFILECRO_H -#define __LIBS_ZIPFILECRO_H - -#include <stdio.h> -#include <stdlib.h> -#include <unistd.h> - -#include <utils/Compat.h> - -#ifdef __cplusplus -extern "C" { -#endif - -/* - * Trivial typedef to ensure that ZipFileCRO is not treated as a simple integer. - */ -typedef void* ZipFileCRO; - -/* - * Trivial typedef to ensure that ZipEntryCRO is not treated as a simple - * integer. We use NULL to indicate an invalid value. - */ -typedef void* ZipEntryCRO; - -extern ZipFileCRO ZipFileXRO_open(const char* path); - -extern void ZipFileCRO_destroy(ZipFileCRO zip); - -extern ZipEntryCRO ZipFileCRO_findEntryByName(ZipFileCRO zip, - const char* fileName); - -extern bool ZipFileCRO_getEntryInfo(ZipFileCRO zip, ZipEntryCRO entry, - int* pMethod, size_t* pUncompLen, - size_t* pCompLen, off64_t* pOffset, long* pModWhen, long* pCrc32); - -extern bool ZipFileCRO_uncompressEntry(ZipFileCRO zip, ZipEntryCRO entry, int fd); - -#ifdef __cplusplus -} -#endif - -#endif /*__LIBS_ZIPFILECRO_H*/ diff --git a/include/utils/ZipFileRO.h b/include/utils/ZipFileRO.h deleted file mode 100644 index 547e36a..0000000 --- a/include/utils/ZipFileRO.h +++ /dev/null @@ -1,262 +0,0 @@ -/* - * Copyright (C) 2007 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. - */ - -/* - * Read-only access to Zip archives, with minimal heap allocation. - * - * This is similar to the more-complete ZipFile class, but no attempt - * has been made to make them interchangeable. This class operates under - * a very different set of assumptions and constraints. - * - * One such assumption is that if you're getting file descriptors for - * use with this class as a child of a fork() operation, you must be on - * a pread() to guarantee correct operation. This is because pread() can - * atomically read at a file offset without worrying about a lock around an - * lseek() + read() pair. - */ -#ifndef __LIBS_ZIPFILERO_H -#define __LIBS_ZIPFILERO_H - -#include <utils/Compat.h> -#include <utils/Errors.h> -#include <utils/FileMap.h> -#include <utils/threads.h> - -#include <stdio.h> -#include <stdlib.h> -#include <unistd.h> -#include <time.h> - -namespace android { - -/* - * Trivial typedef to ensure that ZipEntryRO is not treated as a simple - * integer. We use NULL to indicate an invalid value. - */ -typedef void* ZipEntryRO; - -/* - * Open a Zip archive for reading. - * - * We want "open" and "find entry by name" to be fast operations, and we - * want to use as little memory as possible. We memory-map the file, - * and load a hash table with pointers to the filenames (which aren't - * null-terminated). The other fields are at a fixed offset from the - * filename, so we don't need to extract those (but we do need to byte-read - * and endian-swap them every time we want them). - * - * To speed comparisons when doing a lookup by name, we could make the mapping - * "private" (copy-on-write) and null-terminate the filenames after verifying - * the record structure. However, this requires a private mapping of - * every page that the Central Directory touches. Easier to tuck a copy - * of the string length into the hash table entry. - * - * NOTE: If this is used on file descriptors inherited from a fork() operation, - * you must be on a platform that implements pread() to guarantee correctness - * on the shared file descriptors. - */ -class ZipFileRO { -public: - ZipFileRO() - : mFd(-1), mFileName(NULL), mFileLength(-1), - mDirectoryMap(NULL), - mNumEntries(-1), mDirectoryOffset(-1), - mHashTableSize(-1), mHashTable(NULL) - {} - - ~ZipFileRO(); - - /* - * Open an archive. - */ - status_t open(const char* zipFileName); - - /* - * Find an entry, by name. Returns the entry identifier, or NULL if - * not found. - * - * If two entries have the same name, one will be chosen at semi-random. - */ - ZipEntryRO findEntryByName(const char* fileName) const; - - /* - * Return the #of entries in the Zip archive. - */ - int getNumEntries(void) const { - return mNumEntries; - } - - /* - * Return the Nth entry. Zip file entries are not stored in sorted - * order, and updated entries may appear at the end, so anyone walking - * the archive needs to avoid making ordering assumptions. We take - * that further by returning the Nth non-empty entry in the hash table - * rather than the Nth entry in the archive. - * - * Valid values are [0..numEntries). - * - * [This is currently O(n). If it needs to be fast we can allocate an - * additional data structure or provide an iterator interface.] - */ - ZipEntryRO findEntryByIndex(int idx) const; - - /* - * Copy the filename into the supplied buffer. Returns 0 on success, - * -1 if "entry" is invalid, or the filename length if it didn't fit. The - * length, and the returned string, include the null-termination. - */ - int getEntryFileName(ZipEntryRO entry, char* buffer, int bufLen) const; - - /* - * Get the vital stats for an entry. Pass in NULL pointers for anything - * you don't need. - * - * "*pOffset" holds the Zip file offset of the entry's data. - * - * Returns "false" if "entry" is bogus or if the data in the Zip file - * appears to be bad. - */ - bool getEntryInfo(ZipEntryRO entry, int* pMethod, size_t* pUncompLen, - size_t* pCompLen, off64_t* pOffset, long* pModWhen, long* pCrc32) const; - - /* - * Create a new FileMap object that maps a subset of the archive. For - * an uncompressed entry this effectively provides a pointer to the - * actual data, for a compressed entry this provides the input buffer - * for inflate(). - */ - FileMap* createEntryFileMap(ZipEntryRO entry) const; - - /* - * Uncompress the data into a buffer. Depending on the compression - * format, this is either an "inflate" operation or a memcpy. - * - * Use "uncompLen" from getEntryInfo() to determine the required - * buffer size. - * - * Returns "true" on success. - */ - bool uncompressEntry(ZipEntryRO entry, void* buffer) const; - - /* - * Uncompress the data to an open file descriptor. - */ - bool uncompressEntry(ZipEntryRO entry, int fd) const; - - /* Zip compression methods we support */ - enum { - kCompressStored = 0, // no compression - kCompressDeflated = 8, // standard deflate - }; - - /* - * Utility function: uncompress deflated data, buffer to buffer. - */ - static bool inflateBuffer(void* outBuf, const void* inBuf, - size_t uncompLen, size_t compLen); - - /* - * Utility function: uncompress deflated data, buffer to fd. - */ - static bool inflateBuffer(int fd, const void* inBuf, - size_t uncompLen, size_t compLen); - - /* - * Utility function to convert ZIP's time format to a timespec struct. - */ - static inline void zipTimeToTimespec(long when, struct tm* timespec) { - const long date = when >> 16; - timespec->tm_year = ((date >> 9) & 0x7F) + 80; // Zip is years since 1980 - timespec->tm_mon = (date >> 5) & 0x0F; - timespec->tm_mday = date & 0x1F; - - timespec->tm_hour = (when >> 11) & 0x1F; - timespec->tm_min = (when >> 5) & 0x3F; - timespec->tm_sec = (when & 0x1F) << 1; - } - - /* - * Some basic functions for raw data manipulation. "LE" means - * Little Endian. - */ - static inline unsigned short get2LE(const unsigned char* buf) { - return buf[0] | (buf[1] << 8); - } - static inline unsigned long get4LE(const unsigned char* buf) { - return buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24); - } - -private: - /* these are private and not defined */ - ZipFileRO(const ZipFileRO& src); - ZipFileRO& operator=(const ZipFileRO& src); - - /* locate and parse the central directory */ - bool mapCentralDirectory(void); - - /* parse the archive, prepping internal structures */ - bool parseZipArchive(void); - - /* add a new entry to the hash table */ - void addToHash(const char* str, int strLen, unsigned int hash); - - /* compute string hash code */ - static unsigned int computeHash(const char* str, int len); - - /* convert a ZipEntryRO back to a hash table index */ - int entryToIndex(const ZipEntryRO entry) const; - - /* - * One entry in the hash table. - */ - typedef struct HashEntry { - const char* name; - unsigned short nameLen; - //unsigned int hash; - } HashEntry; - - /* open Zip archive */ - int mFd; - - /* Lock for handling the file descriptor (seeks, etc) */ - mutable Mutex mFdLock; - - /* zip file name */ - char* mFileName; - - /* length of file */ - size_t mFileLength; - - /* mapped file */ - FileMap* mDirectoryMap; - - /* number of entries in the Zip archive */ - int mNumEntries; - - /* CD directory offset in the Zip archive */ - off64_t mDirectoryOffset; - - /* - * We know how many entries are in the Zip archive, so we have a - * fixed-size hash table. We probe for an empty slot. - */ - int mHashTableSize; - HashEntry* mHashTable; -}; - -}; // namespace android - -#endif /*__LIBS_ZIPFILERO_H*/ diff --git a/include/utils/ZipUtils.h b/include/utils/ZipUtils.h deleted file mode 100644 index 42c42b6..0000000 --- a/include/utils/ZipUtils.h +++ /dev/null @@ -1,67 +0,0 @@ -/* - * Copyright (C) 2007 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. - */ - -// -// Miscellaneous zip/gzip utility functions. -// -#ifndef __LIBS_ZIPUTILS_H -#define __LIBS_ZIPUTILS_H - -#include <stdio.h> - -namespace android { - -/* - * Container class for utility functions, primarily for namespace reasons. - */ -class ZipUtils { -public: - /* - * General utility function for uncompressing "deflate" data from a file - * to a buffer. - */ - static bool inflateToBuffer(int fd, void* buf, long uncompressedLen, - long compressedLen); - static bool inflateToBuffer(FILE* fp, void* buf, long uncompressedLen, - long compressedLen); - - /* - * Someday we might want to make this generic and handle bzip2 ".bz2" - * files too. - * - * We could declare gzip to be a sub-class of zip that has exactly - * one always-compressed entry, but we currently want to treat Zip - * and gzip as distinct, so there's no value. - * - * The zlib library has some gzip utilities, but it has no interface - * for extracting the uncompressed length of the file (you do *not* - * want to gzseek to the end). - * - * Pass in a seeked file pointer for the gzip file. If this is a gzip - * file, we set our return values appropriately and return "true" with - * the file seeked to the start of the compressed data. - */ - static bool examineGzip(FILE* fp, int* pCompressionMethod, - long* pUncompressedLen, long* pCompressedLen, unsigned long* pCRC32); - -private: - ZipUtils() {} - ~ZipUtils() {} -}; - -}; // namespace android - -#endif /*__LIBS_ZIPUTILS_H*/ diff --git a/include/utils/threads.h b/include/utils/threads.h index ab3e8cd..b4a8b7c 100644 --- a/include/utils/threads.h +++ b/include/utils/threads.h @@ -526,6 +526,12 @@ public: // Do not call from this object's thread; will return WOULD_BLOCK in that case. status_t join(); +#ifdef HAVE_ANDROID_OS + // Return the thread's kernel ID, same as the thread itself calling gettid() or + // androidGetTid(), or -1 if the thread is not running. + pid_t getTid() const; +#endif + protected: // exitPending() returns true if requestExit() has been called. bool exitPending() const; @@ -551,8 +557,10 @@ private: volatile bool mExitPending; volatile bool mRunning; sp<Thread> mHoldSelf; -#if HAVE_ANDROID_OS - int mTid; +#ifdef HAVE_ANDROID_OS + // legacy for debugging, not used by getTid() as it is set by the child thread + // and so is not initialized until the child reaches that point + pid_t mTid; #endif }; |