Remove unused methods from AssetManager.cpp (a77685fa) · Commits · e / os / android_frameworks_base

include/androidfw/AssetManager.h

+8 −59

Original line number	Diff line number	Diff line
		@@ -59,10 +59,7 @@ struct ResTable_config;
		* 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 purpose of the AssetManager is to create Asset objects.
		*
		* The asset hierarchy may be examined like a filesystem, using
		* AssetDir objects to peruse a single directory.
		@@ -82,14 +79,7 @@ public:
		static const char* TARGET_APK_PATH;
		static const char* IDMAP_DIR;

		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);
		AssetManager();
		virtual ~AssetManager(void);

		static int32_t getGlobalCount();
		@@ -126,23 +116,16 @@ public:
		int32_t nextAssetPath(const int32_t cookie) const;

		/*
		* Return an asset path in the manager. 'which' must be between 0 and
		* countAssetPaths().
		* Return an asset path in the manager. 'cookie' must be a non-negative value
		* previously returned from addAssetPath() or nextAssetPath().
		*/
		String8 getAssetPath(const int32_t 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.
		* Sets various device configuration parameters, like screen orientation, layout,
		* size, locale, etc.
		* The optional 'locale' string takes precedence over the locale within 'config'
		* and must be in bcp47 format.
		*/
		void setConfiguration(const ResTable_config& config, const char* locale = NULL);

		@@ -214,13 +197,6 @@ public:
		*/
		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
		@@ -253,12 +229,8 @@ private:
		bool isSystemAsset;
		};

		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);
		@@ -278,15 +250,6 @@ private:
		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;
		@@ -381,23 +344,9 @@ private:

		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

libs/androidfw/AssetManager.cpp

+50 −469

Original line number	Diff line number	Diff line
		@@ -82,8 +82,8 @@ const char* AssetManager::TARGET_APK_PATH = "/system/framework/framework-res.apk
		const char* AssetManager::IDMAP_DIR = "/data/resource-cache";

		namespace {
		String8 idmapPathForPackagePath(const String8& pkgPath)
		{

		String8 idmapPathForPackagePath(const String8& pkgPath) {
		const char* root = getenv("ANDROID_DATA");
		LOG_ALWAYS_FATAL_IF(root == NULL, "ANDROID_DATA not set");
		String8 path(root);
		@@ -112,8 +112,7 @@ namespace {
		/*
		* Like strdup(), but uses C++ "new" operator instead of malloc.
		*/
		static char* strdupNew(const char* str)
		{
		static char* strdupNew(const char* str) {
		char* newStr;
		int len;

		@@ -126,7 +125,8 @@ namespace {

		return newStr;
		}
		}

		} // namespace

		/*
		* ===========================================================================
		@@ -134,16 +134,12 @@ namespace {
		* ===========================================================================
		*/

		int32_t AssetManager::getGlobalCount()
		{
		int32_t AssetManager::getGlobalCount() {
		return gCount;
		}

		AssetManager::AssetManager(CacheMode cacheMode)
		: mLocale(NULL), mVendor(NULL),
		mResources(NULL), mConfig(new ResTable_config),
		mCacheMode(cacheMode), mCacheValid(false)
		{
		AssetManager::AssetManager() :
		mLocale(NULL), mResources(NULL), mConfig(new ResTable_config) {
		int count = android_atomic_inc(&gCount) + 1;
		if (kIsDebug) {
		ALOGI("Creating AssetManager %p #%d\n", this, count);
		@@ -151,8 +147,7 @@ AssetManager::AssetManager(CacheMode cacheMode)
		memset(mConfig, 0, sizeof(ResTable_config));
		}

		AssetManager::~AssetManager(void)
		{
		AssetManager::~AssetManager() {
		int count = android_atomic_dec(&gCount);
		if (kIsDebug) {
		ALOGI("Destroying AssetManager in %p #%d\n", this, count);
		@@ -163,12 +158,10 @@ AssetManager::~AssetManager(void)

		// don't have a String class yet, so make sure we clean up
		delete[] mLocale;
		delete[] mVendor;
		}

		bool AssetManager::addAssetPath(
		const String8& path, int32_t* cookie, bool appAsLib, bool isSystemAsset)
		{
		const String8& path, int32_t* cookie, bool appAsLib, bool isSystemAsset) {
		AutoMutex _l(mLock);

		asset_path ap;
		@@ -343,25 +336,9 @@ String8 AssetManager::getAssetPath(const int32_t cookie) const
		return String8();
		}

		/*
		* Set the current locale. Use NULL to indicate no locale.
		*
		* Close and reopen Zip archives as appropriate, and reset cached
		* information in the locale-specific sections of the tree.
		*/
		void AssetManager::setLocale(const char* locale)
		{
		AutoMutex _l(mLock);
		setLocaleLocked(locale);
		}


		void AssetManager::setLocaleLocked(const char* locale)
		{
		if (mLocale != NULL) {
		/* previously set, purge cached data */
		purgeFileNameCacheLocked();
		//mZipSet.purgeLocale();
		delete[] mLocale;
		}

		@@ -369,25 +346,6 @@ void AssetManager::setLocaleLocked(const char* locale)
		updateResourceParamsLocked();
		}

		/*
		* Set the current vendor. Use NULL to indicate no vendor.
		*
		* Close and reopen Zip archives as appropriate, and reset cached
		* information in the vendor-specific sections of the tree.
		*/
		void AssetManager::setVendor(const char* vendor)
		{
		AutoMutex _l(mLock);

		if (mVendor != NULL) {
		/* previously set, purge cached data */
		purgeFileNameCacheLocked();
		//mZipSet.purgeVendor();
		delete[] mVendor;
		}
		mVendor = strdupNew(vendor);
		}

		void AssetManager::setConfiguration(const ResTable_config& config, const char* locale)
		{
		AutoMutex _l(mLock);
		@@ -439,10 +397,6 @@ Asset* AssetManager::open(const char* fileName, AccessMode mode)

		LOG_FATAL_IF(mAssetPaths.size() == 0, "No assets added to AssetManager");


		if (mCacheMode != CACHE_OFF && !mCacheValid)
		loadFileNameCacheLocked();

		String8 assetName(kAssetsRoot);
		assetName.appendPath(fileName);

		@@ -476,10 +430,6 @@ Asset* AssetManager::openNonAsset(const char* fileName, AccessMode mode, int32_t

		LOG_FATAL_IF(mAssetPaths.size() == 0, "No assets added to AssetManager");


		if (mCacheMode != CACHE_OFF && !mCacheValid)
		loadFileNameCacheLocked();

		/*
		* For each top-level asset path, search for the asset.
		*/
		@@ -507,9 +457,6 @@ Asset* AssetManager::openNonAsset(const int32_t cookie, const char* fileName, Ac

		LOG_FATAL_IF(mAssetPaths.size() == 0, "No assets added to AssetManager");

		if (mCacheMode != CACHE_OFF && !mCacheValid)
		loadFileNameCacheLocked();

		if (which < mAssetPaths.size()) {
		ALOGV("Looking for non-asset '%s' in '%s'\n", fileName,
		mAssetPaths.itemAt(which).path.string());
		@@ -659,10 +606,6 @@ const ResTable* AssetManager::getResTable(bool required) const
		LOG_FATAL_IF(mAssetPaths.size() == 0, "No assets added to AssetManager");
		}

		if (mCacheMode != CACHE_OFF && !mCacheValid) {
		const_cast<AssetManager*>(this)->loadFileNameCacheLocked();
		}

		mResources = new ResTable();
		updateResourceParamsLocked();

		@@ -832,158 +775,6 @@ Asset* AssetManager::openNonAssetInPathLocked(const char* fileName, AccessMode m
		return pAsset;
		}

		/*
		* Open an asset, searching for it in the directory hierarchy for the
		* specified app.
		*
		* Pass in a NULL values for "appName" if the common app directory should
		* be used.
		*/
		Asset* AssetManager::openInPathLocked(const char* fileName, AccessMode mode,
		const asset_path& ap)
		{
		Asset* pAsset = NULL;

		/*
		* Try various combinations of locale and vendor.
		*/
		if (mLocale != NULL && mVendor != NULL)
		pAsset = openInLocaleVendorLocked(fileName, mode, ap, mLocale, mVendor);
		if (pAsset == NULL && mVendor != NULL)
		pAsset = openInLocaleVendorLocked(fileName, mode, ap, NULL, mVendor);
		if (pAsset == NULL && mLocale != NULL)
		pAsset = openInLocaleVendorLocked(fileName, mode, ap, mLocale, NULL);
		if (pAsset == NULL)
		pAsset = openInLocaleVendorLocked(fileName, mode, ap, NULL, NULL);

		return pAsset;
		}

		/*
		* Open an asset, searching for it in the directory hierarchy for the
		* specified locale and vendor.
		*
		* We also search in "app.jar".
		*
		* Pass in NULL values for "appName", "locale", and "vendor" if the
		* defaults should be used.
		*/
		Asset* AssetManager::openInLocaleVendorLocked(const char* fileName, AccessMode mode,
		const asset_path& ap, const char* locale, const char* vendor)
		{
		Asset* pAsset = NULL;

		if (ap.type == kFileTypeDirectory) {
		if (mCacheMode == CACHE_OFF) {
		/* look at the filesystem on disk */
		String8 path(createPathNameLocked(ap, locale, vendor));
		path.appendPath(fileName);

		String8 excludeName(path);
		excludeName.append(kExcludeExtension);
		if (::getFileType(excludeName.string()) != kFileTypeNonexistent) {
		/* say no more */
		//printf("+++ excluding '%s'\n", (const char*) excludeName);
		return kExcludedAsset;
		}

		pAsset = openAssetFromFileLocked(path, mode);

		if (pAsset == NULL) {
		/* try again, this time with ".gz" */
		path.append(".gz");
		pAsset = openAssetFromFileLocked(path, mode);
		}

		if (pAsset != NULL)
		pAsset->setAssetSource(path);
		} else {
		/* find in cache */
		String8 path(createPathNameLocked(ap, locale, vendor));
		path.appendPath(fileName);

		AssetDir::FileInfo tmpInfo;
		bool found = false;

		String8 excludeName(path);
		excludeName.append(kExcludeExtension);

		if (mCache.indexOf(excludeName) != NAME_NOT_FOUND) {
		/* go no farther */
		//printf("+++ Excluding '%s'\n", (const char*) excludeName);
		return kExcludedAsset;
		}

		/*
		* File compression extensions (".gz") don't get stored in the
		* name cache, so we have to try both here.
		*/
		if (mCache.indexOf(path) != NAME_NOT_FOUND) {
		found = true;
		pAsset = openAssetFromFileLocked(path, mode);
		if (pAsset == NULL) {
		/* try again, this time with ".gz" */
		path.append(".gz");
		pAsset = openAssetFromFileLocked(path, mode);
		}
		}

		if (pAsset != NULL)
		pAsset->setAssetSource(path);

		/*
		* Don't continue the search into the Zip files. Our cached info
		* said it was a file on disk; to be consistent with openDir()
		* we want to return the loose asset. If the cached file gets
		* removed, we fail.
		*
		* The alternative is to update our cache when files get deleted,
		* or make some sort of "best effort" promise, but for now I'm
		* taking the hard line.
		*/
		if (found) {
		if (pAsset == NULL)
		ALOGD("Expected file not found: '%s'\n", path.string());
		return pAsset;
		}
		}
		}

		/*
		* Either it wasn't found on disk or on the cached view of the disk.
		* Dig through the currently-opened set of Zip files. If caching
		* is disabled, the Zip file may get reopened.
		*/
		if (pAsset == NULL && ap.type == kFileTypeRegular) {
		String8 path;

		path.appendPath((locale != NULL) ? locale : kDefaultLocale);
		path.appendPath((vendor != NULL) ? vendor : kDefaultVendor);
		path.appendPath(fileName);

		/* check the appropriate Zip file */
		ZipFileRO* pZip = getZipFileLocked(ap);
		if (pZip != NULL) {
		//printf("GOT zip, checking '%s'\n", (const char*) path);
		ZipEntryRO entry = pZip->findEntryByName(path.string());
		if (entry != NULL) {
		//printf("FOUND in Zip file for %s/%s-%s\n",
		// appName, locale, vendor);
		pAsset = openAssetFromZipLocked(pZip, entry, mode, path);
		pZip->releaseEntry(entry);
		}
		}

		if (pAsset != NULL) {
		/* create a "source" name, for debug/display */
		pAsset->setAssetSource(createZipSourceNameLocked(ZipSet::getPathName(ap.path.string()),
		String8(""), String8(fileName)));
		}
		}

		return pAsset;
		}

		/*
		* Create a "source name" for a file from a Zip archive.
		*/
		@@ -1141,9 +932,6 @@ AssetDir* AssetManager::openDir(const char* dirName)

		//printf("+++ openDir(%s) in '%s'\n", dirName, (const char*) mAssetBase);

		if (mCacheMode != CACHE_OFF && !mCacheValid)
		loadFileNameCacheLocked();

		pDir = new AssetDir;

		/*
		@@ -1204,9 +992,6 @@ AssetDir* AssetManager::openNonAssetDir(const int32_t cookie, const char* dirNam

		//printf("+++ openDir(%s) in '%s'\n", dirName, (const char*) mAssetBase);

		if (mCacheMode != CACHE_OFF && !mCacheValid)
		loadFileNameCacheLocked();

		pDir = new AssetDir;

		pMergedInfo = new SortedVector<AssetDir::FileInfo>;
		@@ -1247,74 +1032,17 @@ AssetDir* AssetManager::openNonAssetDir(const int32_t cookie, const char* dirNam
		bool AssetManager::scanAndMergeDirLocked(SortedVector<AssetDir::FileInfo>* pMergedInfo,
		const asset_path& ap, const char* rootDir, const char* dirName)
		{
		SortedVector<AssetDir::FileInfo>* pContents;
		String8 path;

		assert(pMergedInfo != NULL);

		//printf("scanAndMergeDir: %s %s %s %s\n", appName, locale, vendor,dirName);

		if (mCacheValid) {
		int i, start, count;
		//printf("scanAndMergeDir: %s %s %s\n", ap.path.string(), rootDir, dirName);

		pContents = new SortedVector<AssetDir::FileInfo>;

		/*
		* Get the basic partial path and find it in the cache. That's
		* the start point for the search.
		*/
		path = createPathNameLocked(ap, rootDir);
		String8 path = createPathNameLocked(ap, rootDir);
		if (dirName[0] != '\0')
		path.appendPath(dirName);

		start = mCache.indexOf(path);
		if (start == NAME_NOT_FOUND) {
		//printf("+++ not found in cache: dir '%s'\n", (const char*) path);
		delete pContents;
		return false;
		}

		/*
		* The match string looks like "common/default/default/foo/bar/".
		* The '/' on the end ensures that we don't match on the directory
		* itself or on ".../foo/barfy/".
		*/
		path.append("/");

		count = mCache.size();

		/*
		* Pick out the stuff in the current dir by examining the pathname.
		* It needs to match the partial pathname prefix, and not have a '/'
		* (fssep) anywhere after the prefix.
		*/
		for (i = start+1; i < count; i++) {
		if (mCache[i].getFileName().length() > path.length() &&
		strncmp(mCache[i].getFileName().string(), path.string(), path.length()) == 0)
		{
		const char* name = mCache[i].getFileName().string();
		// XXX THIS IS BROKEN! Looks like we need to store the full
		// path prefix separately from the file path.
		if (strchr(name + path.length(), '/') == NULL) {
		/* grab it, reducing path to just the filename component */
		AssetDir::FileInfo tmp = mCache[i];
		tmp.setFileName(tmp.getFileName().getPathLeaf());
		pContents->add(tmp);
		}
		} else {
		/* no longer in the dir or its subdirs */
		break;
		}

		}
		} else {
		path = createPathNameLocked(ap, rootDir);
		if (dirName[0] != '\0')
		path.appendPath(dirName);
		pContents = scanDirLocked(path);
		SortedVector<AssetDir::FileInfo>* pContents = scanDirLocked(path);
		if (pContents == NULL)
		return false;
		}

		// if we wanted to do an incremental cache fill, we would do it here

		@@ -1641,153 +1369,6 @@ void AssetManager::mergeInfoLocked(SortedVector<AssetDir::FileInfo>* pMergedInfo
		#endif
		}


		/*
		* Load all files into the file name cache. We want to do this across
		* all combinations of { appname, locale, vendor }, performing a recursive
		* directory traversal.
		*
		* This is not the most efficient data structure. Also, gathering the
		* information as we needed it (file-by-file or directory-by-directory)
		* would be faster. However, on the actual device, 99% of the files will
		* live in Zip archives, so this list will be very small. The trouble
		* is that we have to check the "loose" files first, so it's important
		* that we don't beat the filesystem silly looking for files that aren't
		* there.
		*
		* Note on thread safety: this is the only function that causes updates
		* to mCache, and anybody who tries to use it will call here if !mCacheValid,
		* so we need to employ a mutex here.
		*/
		void AssetManager::loadFileNameCacheLocked(void)
		{
		assert(!mCacheValid);
		assert(mCache.size() == 0);

		#ifdef DO_TIMINGS // need to link against -lrt for this now
		DurationTimer timer;
		timer.start();
		#endif

		fncScanLocked(&mCache, "");

		#ifdef DO_TIMINGS
		timer.stop();
		ALOGD("Cache scan took %.3fms\n",
		timer.durationUsecs() / 1000.0);
		#endif

		#if 0
		int i;
		printf("CACHED FILE LIST (%d entries):\n", mCache.size());
		for (i = 0; i < (int) mCache.size(); i++) {
		printf(" %d: (%d) '%s'\n", i,
		mCache.itemAt(i).getFileType(),
		(const char*) mCache.itemAt(i).getFileName());
		}
		#endif

		mCacheValid = true;
		}

		/*
		* Scan up to 8 versions of the specified directory.
		*/
		void AssetManager::fncScanLocked(SortedVector<AssetDir::FileInfo>* pMergedInfo,
		const char* dirName)
		{
		size_t i = mAssetPaths.size();
		while (i > 0) {
		i--;
		const asset_path& ap = mAssetPaths.itemAt(i);
		fncScanAndMergeDirLocked(pMergedInfo, ap, NULL, NULL, dirName);
		if (mLocale != NULL)
		fncScanAndMergeDirLocked(pMergedInfo, ap, mLocale, NULL, dirName);
		if (mVendor != NULL)
		fncScanAndMergeDirLocked(pMergedInfo, ap, NULL, mVendor, dirName);
		if (mLocale != NULL && mVendor != NULL)
		fncScanAndMergeDirLocked(pMergedInfo, ap, mLocale, mVendor, dirName);
		}
		}

		/*
		* Recursively scan this directory and all subdirs.
		*
		* This is similar to scanAndMergeDir, but we don't remove the .EXCLUDE
		* files, and we prepend the extended partial path to the filenames.
		*/
		bool AssetManager::fncScanAndMergeDirLocked(
		SortedVector<AssetDir::FileInfo>* pMergedInfo,
		const asset_path& ap, const char* locale, const char* vendor,
		const char* dirName)
		{
		SortedVector<AssetDir::FileInfo>* pContents;
		String8 partialPath;
		String8 fullPath;

		// XXX This is broken -- the filename cache needs to hold the base
		// asset path separately from its filename.

		partialPath = createPathNameLocked(ap, locale, vendor);
		if (dirName[0] != '\0') {
		partialPath.appendPath(dirName);
		}

		fullPath = partialPath;
		pContents = scanDirLocked(fullPath);
		if (pContents == NULL) {
		return false; // directory did not exist
		}

		/*
		* Scan all subdirectories of the current dir, merging what we find
		* into "pMergedInfo".
		*/
		for (int i = 0; i < (int) pContents->size(); i++) {
		if (pContents->itemAt(i).getFileType() == kFileTypeDirectory) {
		String8 subdir(dirName);
		subdir.appendPath(pContents->itemAt(i).getFileName());

		fncScanAndMergeDirLocked(pMergedInfo, ap, locale, vendor, subdir.string());
		}
		}

		/*
		* To be consistent, we want entries for the root directory. If
		* we're the root, add one now.
		*/
		if (dirName[0] == '\0') {
		AssetDir::FileInfo tmpInfo;

		tmpInfo.set(String8(""), kFileTypeDirectory);
		tmpInfo.setSourceName(createPathNameLocked(ap, locale, vendor));
		pContents->add(tmpInfo);
		}

		/*
		* We want to prepend the extended partial path to every entry in
		* "pContents". It's the same value for each entry, so this will
		* not change the sorting order of the vector contents.
		*/
		for (int i = 0; i < (int) pContents->size(); i++) {
		const AssetDir::FileInfo& info = pContents->itemAt(i);
		pContents->editItemAt(i).setFileName(partialPath.appendPathCopy(info.getFileName()));
		}

		mergeInfoLocked(pMergedInfo, pContents);
		delete pContents;
		return true;
		}

		/*
		* Trash the cache.
		*/
		void AssetManager::purgeFileNameCacheLocked(void)
		{
		mCacheValid = false;
		mCache.clear();
		}

		/*
		* ===========================================================================
		* AssetManager::SharedZip

tools/aapt/Command.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -1281,7 +1281,7 @@ int doDump(Bundle* bundle)
		const size_t NL = locales.size();
		for (size_t i=0; i<NL; i++) {
		const char* localeStr = locales[i].string();
		assets.setLocale(localeStr != NULL ? localeStr : "");
		assets.setConfiguration(config, localeStr != NULL ? localeStr : "");
		String8 llabel = AaptXml::getResolvedAttribute(res, tree, LABEL_ATTR,
		&error);
		if (llabel != "") {