Fix AVD configuration and defaults based on dogfooder input.

build/android/pylib/utils/emulator.py

 #!/usr/bin/env python
 #
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Provides an interface to start and stop Android emulator.
 
 Assumes system environment ANDROID_NDK_ROOT has been set.
 
   Emulator: The class provides the methods to launch/shutdown the emulator with
             the android virtual device named 'avd_armeabi' .
 """
 
 import logging
 import os
+import shutil
 import signal
 import subprocess
 import sys
 import time
 
 import time_profile
 # TODO(craigdh): Move these pylib dependencies to pylib/utils/.
 from pylib import android_commands
 from pylib import cmd_helper
 from pylib import constants
@@ skipping 126 matching lines @@
   # the time to launch the emulator and a wait-for-device command.
   _LAUNCH_TIMEOUT = 120
 
   # Timeout interval of wait-for-device command before bouncing to a a
   # process life check.
   _WAITFORDEVICE_TIMEOUT = 5
 
   # Time to wait for a "wait for boot complete" (property set on device).
   _WAITFORBOOT_TIMEOUT = 300
 
-  def __init__(self, avd_name, abi='x86'):
+  def __init__(self, avd_name, abi):
     """Init an Emulator.
 
     Args:
       avd_name: name of the AVD to create
       abi: target platform for emulator being created
     """
     android_sdk_root = os.path.join(constants.EMULATOR_SDK_ROOT,
                                     'android_tools', 'sdk')
     self.emulator = os.path.join(android_sdk_root, 'tools', 'emulator')
     self.android = os.path.join(android_sdk_root, 'tools', 'android')
     self.popen = None
     self.device = None
     self.abi = abi
     self.avd_name = avd_name
     self._CreateAVD()
 
   def _DeviceName(self):
     """Return our device name."""
     port = _GetAvailablePort()
     return ('emulator-%d' % port, port)
 
   def _CreateAVD(self):
     """Creates an AVD with the given name.
 
     Return avd_name.
     """
+
+    if self.abi == 'arm':
+      abi_option = 'armeabi-v7a'
+    else:
+      abi_option = 'x86'
+
     avd_command = [
         self.android,
         '--silent',
         'create', 'avd',
         '--name', self.avd_name,
-        '--abi', self.abi,
+        '--abi', abi_option,
         '--target', API_TARGET,
-        '-c', '128M',
         '--force',
     ]
     avd_process = subprocess.Popen(args=avd_command,
                                    stdin=subprocess.PIPE,
                                    stdout=subprocess.PIPE,
                                    stderr=subprocess.STDOUT)
     avd_process.stdin.write('no\n')
     avd_process.wait()

[frankf, 2013/04/05 21:05:48]

This can cause a deadlock. Don't call subprocess directly, instead use
cmd_helper.py wrapper. There are other instances here.

[navabi, 2013/04/08 21:41:56]

I can change the others, but in this case, we have to write 'no' to stdin. I do
not know of a way to do that via cmd_helper.RunCmd. Why would calling this
directly deadlock, when the cmd_helper.RunCmd calls subprocess directly?

[Isaac (away), 2013/04/08 21:45:52]

I'm not sure this can cause deadlock, but what about replacing lines 210,211
with:
avd_process.communicate('no\n')

Also if you're not using stdout and stderr, better to not pipe them.

[navabi, 2013/04/08 22:04:51]

Done.

[cjhopman, 2013/04/09 00:17:26]

Search for "deadlock" at http://docs.python.org/2/library/subprocess.html

tl;dr: using .communicate() instead of .wait() avoids it.

+
     logging.info('Create AVD command: %s', ' '.join(avd_command))
+
+    # Setup test device as default Galaxy Nexus AVD
+    avd_config_dir = os.path.join(constants.CHROME_DIR, 'build', 'android',
+                                  'avd_configs')
+    avd_ini = os.path.join(avd_config_dir,
+                                  'AVD_for_Galaxy_Nexus_by_Google_%s.ini' %

[pasko-google - do not use, 2013/04/05 09:41:05]

spacing nit:
align under the previous argument

[navabi, 2013/04/08 21:41:56]

Done.

+                                  self.abi)
+    avd_config_ini = os.path.join(avd_config_dir,
+                                  'AVD_for_Galaxy_Nexus_by_Google_%s.avd' %
+                                  self.abi, 'config.ini')
+
+    # Replace current configuration with default Galaxy Nexus config.
+    avds_dir = os.path.join(os.path.expanduser('~'), '.android', 'avd')
+    new_ini = os.path.join(avds_dir, '%s.ini' % self.avd_name)
+    new_config_ini = os.path.join(avds_dir, '%s.avd' % self.avd_name,
+                                  'config.ini')
+
+    os.unlink(new_ini)
+    os.unlink(new_config_ini)
+    shutil.copy(avd_ini, new_ini)
+    shutil.copy(avd_config_ini, new_config_ini)
+
+    replace_sed = 's/AVD_for_Galaxy_Nexus_by_Google_%s/%s/g' % (self.abi,
+                                                                self.avd_name)
+    replace_name = subprocess.Popen(['sed', '-i', replace_sed, new_ini])

[pasko-google - do not use, 2013/04/05 09:41:05]

Instead of copying, replacing with sed via subprocess it is better to just
create these 4 lines from python. Open a file, write line by line, close. This
would allow to easily make 'path' working for all users, not just one.

[nyquist, 2013/04/05 20:49:35]

And if line-wrapping, etc. becomes ugly, consider using a template file, and do
templating replacement in python instead of using sed.

[navabi, 2013/04/08 21:41:56]

Done.

+    replace_name.wait()
+
     return self.avd_name
 
   def _DeleteAVD(self):
     """Delete the AVD of this emulator."""
     avd_command = [
         self.android,
         '--silent',
         'delete',
         'avd',
         '--name', self.avd,
@@ skipping 109 matching lines @@
     logging.critical('emulator _ShutdownOnSignal')
     for sig in self._SIGNALS:
       signal.signal(sig, signal.SIG_DFL)
     self.Shutdown()
     raise KeyboardInterrupt  # print a stack
 
   def _InstallKillHandler(self):
     """Install a handler to kill the emulator when we exit unexpectedly."""
     for sig in self._SIGNALS:
       signal.signal(sig, self._ShutdownOnSignal)