int avdInfo_getSkinHardwareIni( AvdInfo* i, char* skinName, char* skinDirPath)
{
char temp[PATH_MAX], *p=temp, *end=p+sizeof(temp);
p = bufprint(temp, end, "%s/%s/hardware.ini", skinDirPath, skinName);
if (p >= end || !path_exists(temp)) {
DD("no skin-specific hardware.ini in %s", skinDirPath);
return 0;
}
D("found skin-specific hardware.ini: %s", temp);
if (i->skinHardwareIni != NULL)
iniFile_free(i->skinHardwareIni);
i->skinHardwareIni = iniFile_newFromFile(temp);
if (i->skinHardwareIni == NULL)
return -1;
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;
}
/* parse the root config .ini file. it is located in
* ~/.android/avd/<name>.ini or Windows equivalent
*/
static int
_avdInfo_getRootIni( AvdInfo* i )
{
char* iniPath = path_getRootIniPath( i->deviceName );
if (iniPath == NULL) {
derror("unknown virtual device name: '%s'", i->deviceName);
return -1;
}
D("Android virtual device file at: %s", iniPath);
i->rootIni = iniFile_newFromFile(iniPath);
AFREE(iniPath);
if (i->rootIni == NULL) {
derror("Corrupt virtual device config file!");
return -1;
}
return 0;
}
/* find and parse the config.ini file from the content directory */
static int
_avdInfo_getConfigIni(AvdInfo* i)
{
char* iniPath = _avdInfo_getContentFilePath(i, "config.ini");
/* Allow non-existing config.ini */
if (iniPath == NULL) {
D("virtual device has no config file - no problem");
return 0;
}
D("virtual device config file: %s", iniPath);
i->configIni = iniFile_newFromFile(iniPath);
AFREE(iniPath);
if (i->configIni == NULL) {
derror("bad config: %s",
"virtual device has corrupted config.ini");
return -1;
}
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;
}
/* Read a hardware.ini if it is located in the skin directory */
static int
_avdInfo_getBuildSkinHardwareIni( AvdInfo* i )
{
char* skinName;
char* skinDirPath;
char temp[PATH_MAX], *p=temp, *end=p+sizeof(temp);
avdInfo_getSkinInfo(i, &skinName, &skinDirPath);
if (skinDirPath == NULL)
return 0;
p = bufprint(temp, end, "%s/%s/hardware.ini", skinDirPath, skinName);
if (p >= end || !path_exists(temp)) {
DD("no skin-specific hardware.ini in %s", skinDirPath);
return 0;
}
D("found skin-specific hardware.ini: %s", temp);
i->skinHardwareIni = iniFile_newFromFile(temp);
if (i->skinHardwareIni == NULL)
return -1;
return 0;
}
/* Create a new AUserConfig object from a given AvdInfo */
AUserConfig*
auserConfig_new( AvdInfo* info )
{
AUserConfig* uc;
char inAndroidBuild = avdInfo_inAndroidBuild(info);
char needUUID = 1;
char temp[PATH_MAX], *p=temp, *end=p+sizeof(temp);
char* parentPath;
IniFile* ini = NULL;
ANEW0(uc);
/* If we are in the Android build system, store the configuration
* in ~/.android/emulator-user.ini. otherwise, store it in the file
* emulator-user.ini in the AVD's content directory.
*/
if (inAndroidBuild) {
p = bufprint_config_file(temp, end, USER_CONFIG_FILE);
} else {
p = bufprint(temp, end, "%s/%s", avdInfo_getContentPath(info),
USER_CONFIG_FILE);
}
/* handle the unexpected */
if (p >= end) {
/* Hmmm, something is weird, let's use a temporary file instead */
p = bufprint_temp_file(temp, end, USER_CONFIG_FILE);
if (p >= end) {
derror("Weird: Cannot create temporary user-config file?");
exit(2);
}
dwarning("Weird: Content path too long, using temporary user-config.");
}
uc->iniPath = ASTRDUP(temp);
DD("looking user-config in: %s", uc->iniPath);
/* ensure that the parent directory exists */
parentPath = path_parent(uc->iniPath, 1);
if (parentPath == NULL) {
derror("Weird: Can't find parent of user-config file: %s",
uc->iniPath);
exit(2);
}
if (!path_exists(parentPath)) {
if (!inAndroidBuild) {
derror("Weird: No content path for this AVD: %s", parentPath);
exit(2);
}
DD("creating missing directory: %s", parentPath);
if (path_mkdir_if_needed(parentPath, 0755) < 0) {
derror("Using empty user-config, can't create %s: %s",
parentPath, strerror(errno));
exit(2);
}
}
if (path_exists(uc->iniPath)) {
DD("reading user-config file");
ini = iniFile_newFromFile(uc->iniPath);
if (ini == NULL) {
dwarning("Can't read user-config file: %s\nUsing default values",
uc->iniPath);
}
}
if (ini != NULL) {
uc->windowX = iniFile_getInteger(ini, KEY_WINDOW_X, DEFAULT_X);
DD(" found %s = %d", KEY_WINDOW_X, uc->windowX);
uc->windowY = iniFile_getInteger(ini, KEY_WINDOW_Y, DEFAULT_Y);
DD(" found %s = %d", KEY_WINDOW_Y, uc->windowY);
if (iniFile_getValue(ini, KEY_UUID) != NULL) {
uc->uuid = (uint64_t) iniFile_getInt64(ini, KEY_UUID, 0LL);
needUUID = 0;
DD(" found %s = %lld", KEY_UUID, uc->uuid);
}
iniFile_free(ini);
}
else {
uc->windowX = DEFAULT_X;
uc->windowY = DEFAULT_Y;
uc->changed = 1;
}
/* Generate a 64-bit UUID if necessary. We simply take the
* current time, which avoids any privacy-related value.
*/
if (needUUID) {
struct timeval tm;
gettimeofday( &tm, NULL );
uc->uuid = (uint64_t)tm.tv_sec*1000 + tm.tv_usec/1000;
uc->changed = 1;
DD(" Generated UUID = %lld", uc->uuid);
}
return uc;
}
