AvdInfo*
avdInfo_newForAndroidBuild( const char* androidBuildRoot,
const char* androidOut,
AvdInfoParams* params )
{
AvdInfo* i;
ANEW0(i);
i->inAndroidBuild = 1;
i->androidBuildRoot = ASTRDUP(androidBuildRoot);
i->androidOut = ASTRDUP(androidOut);
i->contentPath = ASTRDUP(androidOut);
i->targetArch = path_getBuildTargetArch(i->androidOut);
i->apiLevel = path_getBuildTargetApiLevel(i->androidOut);
/* TODO: find a way to provide better information from the build files */
i->deviceName = ASTRDUP("<build>");
/* There is no config.ini in the build */
i->configIni = NULL;
if (_avdInfo_getCoreHwIniPath(i, i->androidOut) < 0 )
goto FAIL;
/* Read the build skin's hardware.ini, if any */
_avdInfo_getBuildSkinHardwareIni(i);
return i;
FAIL:
avdInfo_free(i);
return NULL;
}
static void
_avdInfo_extractBuildProperties(AvdInfo* i) {
i->targetArch = propertyFile_getTargetArch(i->buildProperties);
if (!i->targetArch) {
i->targetArch = ASTRDUP("arm");
D("Cannot find target CPU architecture, defaulting to '%s'",
i->targetArch);
}
i->targetAbi = propertyFile_getTargetAbi(i->buildProperties);
if (!i->targetAbi) {
i->targetAbi = ASTRDUP("armeabi");
D("Cannot find target CPU ABI, defaulting to '%s'",
i->targetAbi);
}
if (!i->apiLevel) {
// Note: for regular AVDs, the API level is already extracted
// from config.ini, besides, for older SDK platform images,
// there is no build.prop file and the following function
// would always return 1000, making the AVD unbootable!.
i->apiLevel = propertyFile_getApiLevel(i->buildProperties);
if (i->apiLevel < 3) {
i->apiLevel = 3;
D("Cannot find target API level, defaulting to %d",
i->apiLevel);
}
}
}
CameraDevice*
camera_device_open(const char* name, int inp_channel)
{
struct v4l2_cropcap cropcap;
struct v4l2_crop crop;
LinuxCameraDevice* cd;
/* Allocate and initialize the descriptor. */
cd = _camera_device_alloc();
//cd->device_name = name != NULL ? ASTRDUP(name) : ASTRDUP("/dev/video0");
//Gemdroid added
cd->device_name = name != NULL ? ASTRDUP(name) : ASTRDUP("/dev/video1");
//Gemdroid added
cd->input_channel = inp_channel;
/* Open the device. */
if (_camera_device_open(cd)) {
_camera_device_free(cd);
return NULL;
}
/* Select video input, video standard and tune here. */
cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
_xioctl(cd->handle, VIDIOC_CROPCAP, &cropcap);
crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
crop.c = cropcap.defrect; /* reset to default */
_xioctl (cd->handle, VIDIOC_S_CROP, &crop);
return &cd->header;
}
char*
path_get_absolute( const char* path )
{
if (path_is_absolute(path)) {
return ASTRDUP(path);
}
#ifdef _WIN32
{
char* result;
int pathLen = strlen(path);
int currentLen = GetCurrentDirectory(0, NULL);
if (currentLen <= 0) {
/* Could not get size of working directory. something is
* really fishy here, return a simple copy */
return ASTRDUP(path);
}
result = malloc(currentLen + pathLen + 2);
GetCurrentDirectory(currentLen+1, result);
if (currentLen == 0 || result[currentLen-1] != '\\') {
result[currentLen++] = '\\';
}
memcpy(result + currentLen, path, pathLen+1);
return result;
}
#else
{
int pathLen = strlen(path);
char currentDir[PATH_MAX];
int currentLen;
char* result;
if (getcwd(currentDir, sizeof(currentDir)) == NULL) {
/* Could not get the current working directory. something is really
* fishy here, so don't do anything and return a copy */
return ASTRDUP(path);
}
/* Make a new path with <current-path>/<path> */
currentLen = strlen(currentDir);
result = malloc(currentLen + pathLen + 2);
memcpy(result, currentDir, currentLen);
if (currentLen == 0 || result[currentLen-1] != '/') {
result[currentLen++] = '/';
}
memcpy(result + currentLen, path, pathLen+1);
return result;
}
#endif
}
/* Check that there is a skin named 'skinName' listed from 'skinDirRoot'
* this returns the full path of the skin directory (after alias expansions),
* including the skin name, or NULL on failure.
*/
static char*
_checkSkinSkinsDir( const char* skinDirRoot,
const char* skinName )
{
DirScanner* scanner;
char* result;
char temp[MAX_PATH], *p = temp, *end = p + sizeof(temp);
p = bufprint(temp, end, "%s/skins/%s", skinDirRoot, skinName);
DD("Probing skin directory: %s", temp);
if (p >= end || !path_exists(temp)) {
DD(" ignore bad skin directory %s", temp);
return NULL;
}
/* first, is this a normal skin directory ? */
if (_checkSkinPath(temp)) {
/* yes */
DD(" found skin directory: %s", temp);
return ASTRDUP(temp);
}
/* second, is it an alias to another skin ? */
*p = 0;
result = NULL;
scanner = dirScanner_new(temp);
if (scanner != NULL) {
for (;;) {
const char* file = dirScanner_next(scanner);
if (file == NULL)
break;
if (strncmp(file, "alias-", 6) || file[6] == 0)
continue;
p = bufprint(temp, end, "%s/skins/%s", skinDirRoot, file+6);
if (p < end && _checkSkinPath(temp)) {
/* yes, it's an alias */
DD(" skin alias '%s' points to skin directory: %s",
file+6, temp);
result = ASTRDUP(temp);
break;
}
}
dirScanner_free(scanner);
}
return result;
}
/* TODO: Put in shared source file */
static char*
_getFullFilePath( const char* rootPath, const char* fileName )
{
if (path_is_absolute(fileName)) {
return ASTRDUP(fileName);
} else {
char temp[PATH_MAX], *p=temp, *end=p+sizeof(temp);
p = bufprint(temp, end, "%s/%s", rootPath, fileName);
if (p >= end) {
return NULL;
}
return ASTRDUP(temp);
}
}
/* Initialized webcam emulation record in camera service descriptor.
* Param:
* csd - Camera service descriptor to initialize a record in.
* disp_name - Display name of a web camera ('webcam<N>') to use for emulation.
* dir - Direction ('back', or 'front') that emulated camera is facing.
* ci, ci_cnt - Array of webcam information for enumerated web cameras connected
* to the host.
*/
static void
_wecam_setup(CameraServiceDesc* csd,
const char* disp_name,
const char* dir,
CameraInfo* ci,
int ci_cnt)
{
/* Find webcam record in the list of enumerated web cameras. */
CameraInfo* found = _camera_info_get_by_display_name(disp_name, ci, ci_cnt);
if (found == NULL) {
W("Camera name '%s' is not found in the list of connected cameras.\n"
"Use '-webcam-list' emulator option to obtain the list of connected camera names.\n",
disp_name);
return;
}
/* Save to the camera info array that will be used by the service. */
memcpy(csd->camera_info + csd->camera_count, found, sizeof(CameraInfo));
/* This camera is taken. */
found->in_use = 1;
/* Update direction parameter. */
if (csd->camera_info[csd->camera_count].direction != NULL) {
free(csd->camera_info[csd->camera_count].direction);
}
csd->camera_info[csd->camera_count].direction = ASTRDUP(dir);
D("Camera %d '%s' connected to '%s' facing %s using %.4s pixel format",
csd->camera_count, csd->camera_info[csd->camera_count].display_name,
csd->camera_info[csd->camera_count].device_name,
csd->camera_info[csd->camera_count].direction,
(const char*)(&csd->camera_info[csd->camera_count].pixel_format));
csd->camera_count++;
}
/* 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;
}
int
enumerate_camera_devices(CameraInfo* cis, int max)
{
char dev_name[24];
int found = 0;
int n;
for (n = 0; n < max; n++) {
CameraDevice* cd;
sprintf(dev_name, "/dev/video%d", n);
cd = camera_device_open(dev_name, 0);
if (cd != NULL) {
LinuxCameraDevice* lcd = (LinuxCameraDevice*)cd->opaque;
if (!_camera_device_get_info(lcd, cis + found)) {
char user_name[24];
sprintf(user_name, "webcam%d", found);
cis[found].display_name = ASTRDUP(user_name);
cis[found].in_use = 0;
found++;
}
camera_device_close(cd);
} else {
break;
}
}
return found;
}
/* Search a file in the SDK search directories. Return NULL if not found,
* or a strdup() otherwise.
*/
static char*
_avdInfo_getSdkFilePath(AvdInfo* i, const char* fileName)
{
char temp[MAX_PATH], *p = temp, *end = p + sizeof(temp);
do {
/* try the search paths */
int nn;
for (nn = 0; nn < i->numSearchPaths; nn++) {
const char* searchDir = i->searchPaths[nn];
p = bufprint(temp, end, "%s/%s", searchDir, fileName);
if (p < end && path_exists(temp)) {
DD("found %s in search dir: %s", fileName, searchDir);
goto FOUND;
}
DD(" no %s in search dir: %s", fileName, searchDir);
}
return NULL;
} while (0);
FOUND:
return ASTRDUP(temp);
}
char*
avdInfo_getKernelPath( AvdInfo* i )
{
const char* imageName = _imageFileNames[ AVD_IMAGE_KERNEL ];
char* kernelPath = _avdInfo_getContentOrSdkFilePath(i, imageName);
if (kernelPath == NULL && i->inAndroidBuild) {
/* When in the Android build, look into the prebuilt directory
* for our target architecture.
*/
char temp[PATH_MAX], *p = temp, *end = p + sizeof(temp);
const char* suffix = "";
char* abi;
/* If the target ABI is armeabi-v7a, then look for
* kernel-qemu-armv7 instead of kernel-qemu in the prebuilt
* directory. */
abi = path_getBuildTargetAbi(i->androidOut);
if (!strcmp(abi,"armeabi-v7a")) {
suffix = "-armv7";
}
AFREE(abi);
p = bufprint(temp, end, "%s/prebuilts/qemu-kernel/%s/kernel-qemu%s",
i->androidBuildRoot, i->targetArch, suffix);
if (p >= end || !path_exists(temp)) {
derror("bad workspace: cannot find prebuilt kernel in: %s", temp);
exit(1);
}
kernelPath = ASTRDUP(temp);
}
return kernelPath;
}
/* 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;
}
AvdInfo*
avdInfo_newForAndroidBuild( const char* androidBuildRoot,
const char* androidOut,
AvdInfoParams* params )
{
AvdInfo* i;
ANEW0(i);
i->inAndroidBuild = 1;
i->androidBuildRoot = ASTRDUP(androidBuildRoot);
i->androidOut = ASTRDUP(androidOut);
i->contentPath = ASTRDUP(androidOut);
// Find the build.prop file and read it.
char* buildPropPath = path_getBuildBuildProp(i->androidOut);
if (buildPropPath) {
_avdInfo_readPropertyFile(i, buildPropPath, i->buildProperties);
free(buildPropPath);
}
// FInd the boot.prop file and read it.
char* bootPropPath = path_getBuildBootProp(i->androidOut);
if (bootPropPath) {
_avdInfo_readPropertyFile(i, bootPropPath, i->bootProperties);
free(bootPropPath);
}
_avdInfo_extractBuildProperties(i);
i->deviceName = ASTRDUP("<build>");
/* out/target/product/<name>/config.ini, if exists, provide configuration
* from build files. */
if (_avdInfo_getConfigIni(i) < 0 ||
_avdInfo_getCoreHwIniPath(i, i->androidOut) < 0)
goto FAIL;
/* Read the build skin's hardware.ini, if any */
_avdInfo_getBuildSkinHardwareIni(i);
return i;
FAIL:
avdInfo_free(i);
return NULL;
}
/* Find target compiler using a path from COLLECT_GCC or COMPILER_PATH. */
static char *
find_target_compiler (const char *name)
{
bool found = false;
char **paths = NULL;
unsigned n_paths, i;
char *target_compiler;
const char *collect_gcc = getenv ("COLLECT_GCC");
const char *gcc_path = dirname (ASTRDUP (collect_gcc));
const char *gcc_exec = basename (ASTRDUP (collect_gcc));
if (strcmp (gcc_exec, collect_gcc) == 0)
{
/* collect_gcc has no path, so it was found in PATH. Make sure we also
find accel-gcc in PATH. */
target_compiler = XDUPVEC (char, name, strlen (name) + 1);
found = true;
goto out;
}
char* path_getBuildBootProp(const char* androidOut) {
char temp[MAX_PATH], *p = temp, *end = p + sizeof(temp);
p = bufprint(temp, end, "%s/boot.prop", androidOut);
if (p >= end) {
D("ANDROID_BUILD_OUT is too long: %s\n", androidOut);
return NULL;
}
if (!path_exists(temp)) {
D("Cannot find boot properties file: %s\n", temp);
return NULL;
}
return ASTRDUP(temp);
}
CameraDevice*
camera_device_open(const char* name, int inp_channel)
{
WndCameraDevice* wcd;
/* Allocate descriptor and initialize windows-specific fields. */
wcd = _camera_device_alloc();
if (wcd == NULL) {
E("%s: Unable to allocate WndCameraDevice instance", __FUNCTION__);
return NULL;
}
wcd->window_name = (name != NULL) ? ASTRDUP(name) :
ASTRDUP(_default_window_name);
if (wcd->window_name == NULL) {
E("%s: Unable to save window name", __FUNCTION__);
_camera_device_free(wcd);
return NULL;
}
wcd->input_channel = inp_channel;
/* Create capture window that is a child of HWND_MESSAGE window.
* We make it invisible, so it doesn't mess with the UI. Also
* note that we supply standard HWND_MESSAGE window handle as
* the parent window, since we don't want video capturing
* machinery to be dependent on the details of our UI. */
wcd->cap_window = capCreateCaptureWindow(wcd->window_name, WS_CHILD, 0, 0,
0, 0, HWND_MESSAGE, 1);
if (wcd->cap_window == NULL) {
E("%s: Unable to create video capturing window '%s': %d",
__FUNCTION__, wcd->window_name, GetLastError());
_camera_device_free(wcd);
return NULL;
}
/* Save capture window descriptor as window's user data. */
capSetUserData(wcd->cap_window, wcd);
return &wcd->header;
}
AvdInfo*
avdInfo_new( const char* name, AvdInfoParams* params )
{
AvdInfo* i;
if (name == NULL)
return NULL;
if (!_checkAvdName(name)) {
derror("virtual device name contains invalid characters");
exit(1);
}
ANEW0(i);
i->deviceName = ASTRDUP(name);
if ( _avdInfo_getSdkRoot(i) < 0 ||
_avdInfo_getRootIni(i) < 0 ||
_avdInfo_getContentPath(i) < 0 ||
_avdInfo_getConfigIni(i) < 0 ||
_avdInfo_getCoreHwIniPath(i, i->contentPath) < 0 )
goto FAIL;
i->apiLevel = _avdInfo_getApiLevel(i);
// Add for device target infromation.
_getContentTarget(i);
/* look for image search paths. handle post 1.1/pre cupcake
* obsolete SDKs.
*/
_avdInfo_getSearchPaths(i);
// Find the build.prop and boot.prop files and read them.
_avdInfo_getPropertyFile(i, "build.prop", i->buildProperties);
_avdInfo_getPropertyFile(i, "boot.prop", i->bootProperties);
_avdInfo_extractBuildProperties(i);
/* don't need this anymore */
iniFile_free(i->rootIni);
i->rootIni = NULL;
return i;
FAIL:
avdInfo_free(i);
return NULL;
}
/* Look for a named file inside the AVD's content directory.
* Returns NULL if it doesn't exist, or a strdup() copy otherwise.
*/
static char*
_avdInfo_getContentFilePath(AvdInfo* i, const char* fileName)
{
char temp[MAX_PATH], *p = temp, *end = p + sizeof(temp);
p = bufprint(p, end, "%s/%s", i->contentPath, fileName);
if (p >= end) {
derror("can't access virtual device content directory");
return NULL;
}
if (!path_exists(temp)) {
return NULL;
}
return ASTRDUP(temp);
}
/* Return the path to the AVD's root configuration .ini file. it is located in
* ~/.android/avd/<name>.ini or Windows equivalent
*
* This file contains the path to the AVD's content directory, which
* includes its own config.ini.
*/
char*
path_getRootIniPath( const char* avdName )
{
char temp[PATH_MAX], *p=temp, *end=p+sizeof(temp);
p = bufprint_config_path(temp, end);
p = bufprint(p, end, PATH_SEP ANDROID_AVD_DIR PATH_SEP "%s.ini", avdName);
if (p >= end) {
return NULL;
}
if (!path_exists(temp)) {
return NULL;
}
return ASTRDUP(temp);
}
char*
avdInfo_getDynamicSkinPath( AvdInfo* i)
{
char tmp[PATH_MAX];
if (i->inAndroidBuild) {
snprintf(tmp, sizeof(tmp), "%s/sdk/emulator/skins/dynamic/", i->androidBuildRoot);
} else {
snprintf(tmp, sizeof(tmp), "%s/tools/lib/emulator/skins/dynamic/", i->sdkRootPath);
}
if (!path_exists(tmp))
return NULL;
return ASTRDUP(tmp);
}
char*
avdInfo_getTracePath( AvdInfo* i, const char* traceName )
{
char tmp[MAX_PATH], *p=tmp, *end=p + sizeof(tmp);
if (i == NULL || traceName == NULL || traceName[0] == 0)
return NULL;
if (i->inAndroidBuild) {
p = bufprint( p, end, "%s" PATH_SEP "traces" PATH_SEP "%s",
i->androidOut, traceName );
} else {
p = bufprint( p, end, "%s" PATH_SEP "traces" PATH_SEP "%s",
i->contentPath, traceName );
}
return ASTRDUP(tmp);
}
/* try to see if the skin name leads to a magic skin or skin path directly
* returns 1 on success, 0 on error.
*
* on success, this sets up '*pSkinName' and '*pSkinDir'
*/
static int
_getSkinPathFromName( const char* skinName,
const char* sdkRootPath,
char** pSkinName,
char** pSkinDir )
{
char temp[PATH_MAX], *p=temp, *end=p+sizeof(temp);
/* if the skin name has the format 'NNNNxNNN' where
* NNN is a decimal value, then this is a 'magic' skin
* name that doesn't require a skin directory
*/
if (isdigit(skinName[0])) {
int width, height;
if (sscanf(skinName, "%dx%d", &width, &height) == 2) {
D("'magic' skin format detected: %s", skinName);
*pSkinName = ASTRDUP(skinName);
*pSkinDir = NULL;
return 1;
}
}
/* is the skin name a direct path to the skin directory ? */
if (path_is_absolute(skinName) && _checkSkinPath(skinName)) {
goto FOUND_IT;
}
/* is the skin name a relative path from the SDK root ? */
p = bufprint(temp, end, "%s/%s", sdkRootPath, skinName);
if (p < end && _checkSkinPath(temp)) {
skinName = temp;
goto FOUND_IT;
}
/* nope */
return 0;
FOUND_IT:
if (path_split(skinName, pSkinDir, pSkinName) < 0) {
derror("malformed skin name: %s", skinName);
exit(2);
}
D("found skin '%s' in directory: %s", *pSkinName, *pSkinDir);
return 1;
}
tree
create_tmp_var_name (const char *prefix)
{
char *tmp_name;
if (prefix)
{
char *preftmp = ASTRDUP (prefix);
remove_suffix (preftmp, strlen (preftmp));
clean_symbol_name (preftmp);
prefix = preftmp;
}
ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix ? prefix : "T", tmp_var_id_num++);
return get_identifier (tmp_name);
}
/* Collects information about an opened camera device.
* The information collected in this routine contains list of pixel formats,
* supported by the device, and list of frame dimensions supported by the camera
* for each pixel format.
* Param:
* cd - Opened camera device descriptor.
* cis - Upon success contains information collected from the camera device.
* Return:
* 0 on success, != 0 on failure.
*/
static int
_camera_device_get_info(LinuxCameraDevice* cd, CameraInfo* cis)
{
int f;
int chosen = -1;
QemuPixelFormat* formats = NULL;
int num_pix_fmts = _camera_device_enum_pixel_formats(cd, &formats);
if (num_pix_fmts <= 0) {
return -1;
}
/* Lets see if camera supports preferred formats */
for (f = 0; f < _preferred_format_num; f++) {
chosen = _get_format_index(_preferred_formats[f], formats, num_pix_fmts);
if (chosen >= 0) {
printf("chosen :::%d, f:::::%d\n", chosen, f);
break;
}
}
if (chosen < 0) {
/* Camera doesn't support any of the chosen formats. Then it doesn't
* matter which one we choose. Lets choose the first one. */
chosen = 0;
}
cis->device_name = ASTRDUP(cd->device_name);
cis->inp_channel = cd->input_channel;
cis->pixel_format = formats[chosen].format;
cis->frame_sizes_num = formats[chosen].dim_num;
/* Swap instead of copy. */
cis->frame_sizes = formats[chosen].dims;
formats[chosen].dims = NULL;
cis->in_use = 0;
for (f = 0; f < num_pix_fmts; f++) {
_qemu_pixel_format_free(formats + f);
}
free(formats);
return 0;
}
AvdInfo*
avdInfo_new( const char* name, AvdInfoParams* params )
{
AvdInfo* i;
if (name == NULL)
return NULL;
if (!_checkAvdName(name)) {
derror("virtual device name contains invalid characters");
exit(1);
}
ANEW0(i);
i->deviceName = ASTRDUP(name);
if ( _avdInfo_getSdkRoot(i) < 0 ||
_avdInfo_getRootIni(i) < 0 ||
_avdInfo_getContentPath(i) < 0 ||
_avdInfo_getConfigIni(i) < 0 ||
_avdInfo_getCoreHwIniPath(i, i->contentPath) < 0 )
goto FAIL;
i->apiLevel = _avdInfo_getApiLevel(i);
/* look for image search paths. handle post 1.1/pre cupcake
* obsolete SDKs.
*/
_avdInfo_getSearchPaths(i);
/* don't need this anymore */
iniFile_free(i->rootIni);
i->rootIni = NULL;
return i;
FAIL:
avdInfo_free(i);
return NULL;
}
static char *
affix_data_type (const char *param)
{
char *const type_or_decl = ASTRDUP (param);
char *p = type_or_decl;
char *qualifiers_then_data_type;
char saved;
/* Skip as many leading const's or volatile's as there are. */
for (;;)
{
if (!strncmp (p, "volatile ", 9))
{
p += 9;
continue;
}
if (!strncmp (p, "const ", 6))
{
p += 6;
continue;
}
break;
}
/* p now points to the place where we can insert the data type. We have to
add a blank after the data-type of course. */
if (p == type_or_decl)
return concat (data_type, " ", type_or_decl, NULL);
saved = *p;
*p = '\0';
qualifiers_then_data_type = concat (type_or_decl, data_type, NULL);
*p = saved;
return reconcat (qualifiers_then_data_type,
qualifiers_then_data_type, " ", p, NULL);
}
/* Create a new QemudService object */
static QemudService*
qemud_service_new( const char* name,
int max_clients,
void* serv_opaque,
QemudServiceConnect serv_connect,
QemudService** pservices )
{
QemudService* s;
ANEW0(s);
s->name = ASTRDUP(name);
s->max_clients = max_clients;
s->num_clients = 0;
s->clients = NULL;
s->serv_opaque = serv_opaque;
s->serv_connect = serv_connect;
s->next = *pservices;
*pservices = s;
return s;
}
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;
}
char*
propertyFile_getTargetArch(const FileData* data) {
char* ret = propertyFile_getTargetAbi(data);
if (ret) {
// Translate ABI name into architecture name.
// By default, there are the same with a few exceptions.
static const struct {
const char* input;
const char* output;
} kData[] = {
{ "armeabi", "arm" },
{ "armeabi-v7a", "arm" },
};
size_t n;
for (n = 0; n < sizeof(kData)/sizeof(kData[0]); ++n) {
if (!strcmp(ret, kData[n].input)) {
free(ret);
ret = ASTRDUP(kData[n].output);
break;
}
}
}
return ret;
}
/* Return the path to the Android SDK root installation.
*
* (*pFromEnv) will be set to 1 if it comes from the $ANDROID_SDK_ROOT
* environment variable, or 0 otherwise.
*
* Caller must free() returned string.
*/
char*
path_getSdkRoot( char *pFromEnv )
{
const char* env;
char* sdkPath;
char temp[PATH_MAX], *p=temp, *end=p+sizeof(temp);
/* If ANDROID_SDK_ROOT is defined is must point to a directory
* containing a valid SDK installation.
*/
#define SDK_ROOT_ENV "ANDROID_SDK_ROOT"
env = getenv(SDK_ROOT_ENV);
if (env != NULL && env[0] != 0) {
if (path_exists(env)) {
D("found " SDK_ROOT_ENV ": %s", env);
*pFromEnv = 1;
return ASTRDUP(env);
}
D(SDK_ROOT_ENV " points to unknown directory: %s", env);
}
*pFromEnv = 0;
/* We assume the emulator binary is under tools/ so use its
* parent as the Android SDK root.
*/
(void) bufprint_app_dir(temp, end);
sdkPath = path_parent(temp, 1);
if (sdkPath == NULL) {
derror("can't find root of SDK directory");
return NULL;
}
D("found SDK root at %s", sdkPath);
return sdkPath;
}
