/* 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;
}
