/* Returns the AVD's content path, i.e. the directory that contains * the AVD's content files (e.g. data partition, cache, sd card, etc...). * * We extract this by parsing the root config .ini file, looking for * a "path" elements. */ static int _avdInfo_getContentPath( AvdInfo* i ) { char temp[PATH_MAX], *p=temp, *end=p+sizeof(temp); i->contentPath = iniFile_getString(i->rootIni, ROOT_ABS_PATH_KEY, NULL); if (i->contentPath == NULL) { derror("bad config: %s", "virtual device file lacks a "ROOT_ABS_PATH_KEY" entry"); return -1; } if (!path_is_dir(i->contentPath)) { // If the absolute path doesn't match an actual directory, try // the relative path if present. const char* relPath = iniFile_getString(i->rootIni, ROOT_REL_PATH_KEY, NULL); if (relPath != NULL) { p = bufprint_config_path(temp, end); p = bufprint(p, end, PATH_SEP "%s", relPath); if (p < end && path_is_dir(temp)) { AFREE(i->contentPath); i->contentPath = ASTRDUP(temp); } } } D("virtual device content at %s", i->contentPath); return 0; }
/* Parse a given config.ini file and extract the list of SDK search paths * from it. Returns the number of valid paths stored in 'searchPaths', or -1 * in case of problem. * * Relative search paths in the config.ini will be stored as full pathnames * relative to 'sdkRootPath'. * * 'searchPaths' must be an array of char* pointers of at most 'maxSearchPaths' * entries. */ static int _getSearchPaths( IniFile* configIni, const char* sdkRootPath, int maxSearchPaths, char** searchPaths ) { char temp[PATH_MAX], *p = temp, *end= p+sizeof temp; int nn, count = 0; for (nn = 0; nn < maxSearchPaths; nn++) { char* path; p = bufprint(temp, end, "%s%d", SEARCH_PREFIX, nn+1 ); if (p >= end) continue; path = iniFile_getString(configIni, temp, NULL); if (path != NULL) { DD(" found image search path: %s", path); if (!path_is_absolute(path)) { p = bufprint(temp, end, "%s/%s", sdkRootPath, path); AFREE(path); path = ASTRDUP(temp); } searchPaths[count++] = path; } } return count; }
static int _getContentTarget(AvdInfo* i) { i->contentTarget = iniFile_getString(i->rootIni, ROOT_TARGET_KEY, NULL); if (i->contentTarget == NULL) { return -1; } D("virtual device target is %s", i->contentTarget); return 0; }
static char* _getAvdContentPath(const char* avdName) { char temp[PATH_MAX], *p=temp, *end=p+sizeof(temp); IniFile* ini = NULL; char* iniPath = path_getRootIniPath(avdName); char* avdPath = NULL; if (iniPath != NULL) { ini = iniFile_newFromFile(iniPath); AFREE(iniPath); } if (ini == NULL) { APANIC("Could not open: %s\n", iniPath == NULL ? avdName : iniPath); } avdPath = iniFile_getString(ini, ROOT_ABS_PATH_KEY, NULL); if (!path_is_dir(avdPath)) { // If the absolute path doesn't match an actual directory, try // the relative path if present. const char* relPath = iniFile_getString(ini, ROOT_REL_PATH_KEY, NULL); if (relPath != NULL) { p = bufprint_config_path(temp, end); p = bufprint(p, end, PATH_SEP "%s", relPath); if (p < end && path_is_dir(temp)) { AFREE(avdPath); avdPath = ASTRDUP(temp); } } } iniFile_free(ini); return avdPath; }
/* Returns the AVD's content path, i.e. the directory that contains * the AVD's content files (e.g. data partition, cache, sd card, etc...). * * We extract this by parsing the root config .ini file, looking for * a "path" elements. */ static int _avdInfo_getContentPath( AvdInfo* i ) { # define ROOT_PATH_KEY "path" i->contentPath = iniFile_getString(i->rootIni, ROOT_PATH_KEY, NULL); if (i->contentPath == NULL) { derror("bad config: %s", "virtual device file lacks a "ROOT_PATH_KEY" entry"); return -1; } D("virtual device content at %s", i->contentPath); return 0; }
static char* _getAvdTargetArch(const char* avdPath) { IniFile* ini; char* targetArch = NULL; char temp[PATH_MAX], *p=temp, *end=p+sizeof(temp); p = bufprint(temp, end, "%s" PATH_SEP "config.ini", avdPath); if (p >= end) { APANIC("AVD path too long: %s\n", avdPath); } ini = iniFile_newFromFile(temp); if (ini == NULL) { APANIC("Could not open AVD config file: %s\n", temp); } targetArch = iniFile_getString(ini, "hw.cpu.arch", "arm"); iniFile_free(ini); return targetArch; }
char* avdInfo_getSdCardPath( AvdInfo* i ) { const char* imageName = _imageFileNames[ AVD_IMAGE_SDCARD ]; char* path; /* Special case, the config.ini can have a SDCARD_PATH entry * that gives the full path to the SD Card. */ if (i->configIni != NULL) { path = iniFile_getString(i->configIni, SDCARD_PATH, NULL); if (path != NULL) { if (path_exists(path)) return path; dwarning("Ignoring invalid SDCard path: %s", path); AFREE(path); } } /* Otherwise, simply look into the content directory */ return _avdInfo_getContentFilePath(i, imageName); }
static int _avdInfo_getApiLevel( AvdInfo* i ) { char* target; const char* p; const int defaultLevel = 1000; int level = defaultLevel; # define ROOT_TARGET_KEY "target" target = iniFile_getString(i->rootIni, ROOT_TARGET_KEY, NULL); if (target == NULL) { D("No target field in root AVD .ini file?"); D("Defaulting to API level %d", level); return level; } DD("Found target field in root AVD .ini file: '%s'", target); /* There are two acceptable formats for the target key. * * 1/ android-<level> * 2/ <vendor-name>:<add-on-name>:<level> * * Where <level> can be either a _name_ (for experimental/preview SDK builds) * or a decimal number. Note that if a _name_, it can start with a digit. */ /* First, extract the level */ if (!memcmp(target, "android-", 8)) p = target + 8; else { /* skip two columns */ p = strchr(target, ':'); if (p != NULL) { p = strchr(p+1, ':'); if (p != NULL) p += 1; } } if (p == NULL || !isdigit(*p)) { goto NOT_A_NUMBER; } else { char* end; long val = strtol(p, &end, 10); if (end == NULL || *end != '\0' || val != (int)val) { goto NOT_A_NUMBER; } level = (int)val; /* Sanity check, we don't support anything prior to Android 1.5 */ if (level < 3) level = 3; D("Found AVD target API level: %d", level); } EXIT: AFREE(target); return level; NOT_A_NUMBER: if (p == NULL) { D("Invalid target field in root AVD .ini file"); } else { D("Target AVD api level is not a number"); } D("Defaulting to API level %d", level); goto EXIT; }
void avdInfo_getSkinInfo( AvdInfo* i, char** pSkinName, char** pSkinDir ) { char* skinName = NULL; char* skinPath; char temp[PATH_MAX], *p=temp, *end=p+sizeof(temp); *pSkinName = NULL; *pSkinDir = NULL; /* First, see if the config.ini contains a SKIN_PATH entry that * names the full directory path for the skin. */ if (i->configIni != NULL ) { skinPath = iniFile_getString( i->configIni, SKIN_PATH, NULL ); if (skinPath != NULL) { /* If this skin name is magic or a direct directory path * we have our result right here. */ if (_getSkinPathFromName(skinPath, i->sdkRootPath, pSkinName, pSkinDir )) { AFREE(skinPath); return; } } /* The SKIN_PATH entry was not valid, so look at SKIN_NAME */ D("Warning: config.ini contains invalid %s entry: %s", SKIN_PATH, skinPath); AFREE(skinPath); skinName = iniFile_getString( i->configIni, SKIN_NAME, NULL ); } if (skinName == NULL) { /* If there is no skin listed in the config.ini, try to see if * there is one single 'skin' directory in the content directory. */ p = bufprint(temp, end, "%s/skin", i->contentPath); if (p < end && _checkSkinPath(temp)) { D("using skin content from %s", temp); AFREE(i->skinName); *pSkinName = ASTRDUP("skin"); *pSkinDir = ASTRDUP(i->contentPath); return; } /* otherwise, use the default name */ skinName = ASTRDUP(SKIN_DEFAULT); } /* now try to find the skin directory for that name - */ do { /* first try the content directory, i.e. $CONTENT/skins/<name> */ skinPath = _checkSkinSkinsDir(i->contentPath, skinName); if (skinPath != NULL) break; #define PREBUILT_SKINS_ROOT "development/tools/emulator" /* if we are in the Android build, try the prebuilt directory */ if (i->inAndroidBuild) { p = bufprint( temp, end, "%s/%s", i->androidBuildRoot, PREBUILT_SKINS_ROOT ); if (p < end) { skinPath = _checkSkinSkinsDir(temp, skinName); if (skinPath != NULL) break; } /* or in the parent directory of the system dir */ { char* parentDir = path_parent(i->androidOut, 1); if (parentDir != NULL) { skinPath = _checkSkinSkinsDir(parentDir, skinName); AFREE(parentDir); if (skinPath != NULL) break; } } } /* look in the search paths. For each <dir> in the list, * look into <dir>/../skins/<name>/ */ { int nn; for (nn = 0; nn < i->numSearchPaths; nn++) { char* parentDir = path_parent(i->searchPaths[nn], 1); if (parentDir == NULL) continue; skinPath = _checkSkinSkinsDir(parentDir, skinName); AFREE(parentDir); if (skinPath != NULL) break; } if (nn < i->numSearchPaths) break; } /* We didn't find anything ! */ *pSkinName = skinName; return; } while (0); if (path_split(skinPath, pSkinDir, pSkinName) < 0) { derror("weird skin path: %s", skinPath); AFREE(skinPath); return; } DD("found skin '%s' in directory: %s", *pSkinName, *pSkinDir); AFREE(skinPath); return; }