Merge pull request #1356 from rmartin16/adb-device-time

Use Date/Time on Android Device for Fallback Logging

changes/1146.bugfix.rst

@@ -0,0 +1 @@
+The run command now ensures Android logging is shown when the datetime on the device is different from the host machine.

src/briefcase/integrations/android_sdk.py

@@ -1293,10 +1293,10 @@ def avd_name(self) -> str | None:
  f"Unable to interrogate AVD name of device {self.device}"
  ) from e
 
- def has_booted(self):
+ def has_booted(self) -> bool:
  """Determine if the device has completed booting.
 
- :returns True if it has booted; False otherwise.
+ :returns: True if it has booted; False otherwise.
  """
  try:
  # When the sys.boot_completed property of the device
@@ -1326,8 +1326,6 @@ def run(self, *arguments: SubprocessArgT, quiet: bool = False) -> str:
  # checking that they are valid, then parsing output to notice errors.
  # This keeps performance good in the success case.
  try:
- # Capture `stderr` so that if the process exits with failure, the
- # stderr data is in `e.output`.
  return self.tools.subprocess.check_output(
  [
  os.fsdecode(self.tools.android_sdk.adb_path),
@@ -1349,8 +1347,7 @@ def install_apk(self, apk_path: str | Path):
  """Install an APK file on an Android device.
 
  :param apk_path: The path of the Android APK file to install.
-
- Returns `None` on success; raises an exception on failure.
+ :returns: `None` on success; raises an exception on failure.
  """
  try:
  self.run("install", "-r", apk_path)
@@ -1363,8 +1360,7 @@ def force_stop_app(self, package: str):
  """Force-stop an app, specified as a package name.
 
  :param package: The name of the Android package, e.g., com.username.myapp.
-
- Returns `None` on success; raises an exception on failure.
+ :returns: `None` on success; raises an exception on failure.
  """
  # In my testing, `force-stop` exits with status code 0 (success) so long
  # as you pass a package name, even if the package does not exist, or the
@@ -1379,15 +1375,14 @@ def force_stop_app(self, package: str):
  def start_app(self, package: str, activity: str, passthrough: list[str]):
  """Start an app, specified as a package name & activity name.
 
- :param package: The name of the Android package, e.g., com.username.myapp.
- :param activity: The activity of the APK to start.
- :param passthrough: Arguments to pass to the app.
-
- Returns `None` on success; raises an exception on failure.
-
  If you have an APK file, and you are not sure of the package or activity
  name, you can find it using `aapt dump badging filename.apk` and looking
  for "package" and "launchable-activity" in the output.
+
+ :param package: The name of the Android package, e.g., com.username.myapp.
+ :param activity: The activity of the APK to start.
+ :param passthrough: Arguments to pass to the app.
+ :returns: `None` on success; raises an exception on failure.
  """
  try:
  # `am start` also accepts string array extras, but we pass the arguments as a
@@ -1429,7 +1424,7 @@ def start_app(self, package: str, activity: str, passthrough: list[str]):
  f"Unable to start {package}/{activity} on {self.device}"
  ) from e
 
- def logcat(self, pid: str):
+ def logcat(self, pid: str) -> subprocess.Popen:
  """Start following the adb log for the device.
 
  :param pid: The PID whose logs you want to display.
@@ -1519,4 +1514,18 @@ def kill(self):
  try:
  self.run("emu", "kill")
  except subprocess.CalledProcessError as e:
- raise BriefcaseCommandError("Error starting ADB logcat.") from e
+ raise BriefcaseCommandError("Error stopping the Android emulator.") from e
+
+ def datetime(self) -> datetime:
+ """Obtain the device's current date/time.
+
+ This date/time is naive (i.e. not timezone aware) and in the device's "local"
+ time. Therefore, it may be quite different from the date/time for Briefcase and
+ caution should be used if comparing it to machine's "local" time.
+ """
+ datetime_format = "%Y-%m-%d %H:%M:%S"
+ try:
+ device_datetime = self.run("shell", "date", f"+'{datetime_format}'").strip()
+ return datetime.strptime(device_datetime, datetime_format)
+ except (ValueError, subprocess.CalledProcessError) as e:
+ raise BriefcaseCommandError("Error obtaining device date/time.") from e

src/briefcase/platforms/android/gradle.py

@@ -277,19 +277,13 @@ def run_app(
  extra = f" (with {' '.join(extra_emulator_args)})"
  else:
  extra = ""
- self.logger.info(
- f"Starting emulator {avd}{extra}...",
- prefix=app.app_name,
- )
+ self.logger.info(f"Starting emulator {avd}{extra}...", prefix=app.app_name)
  device, name = self.tools.android_sdk.start_emulator(
  avd, extra_emulator_args
  )
 
  try:
- if test_mode:
- label = "test suite"
- else:
- label = "app"
+ label = "test suite" if test_mode else "app"
 
  self.logger.info(
  f"Starting {label} on {name} (device ID {device})", prefix=app.app_name
@@ -313,29 +307,27 @@ def run_app(
 
  # To start the app, we launch `org.beeware.android.MainActivity`.
  with self.input.wait_bar(f"Launching {label}..."):
- # Any log after this point must be associated with the new instance
- start_time = datetime.datetime.now()
+ # capture the earliest time for device logging in case PID not found
+ device_start_time = adb.datetime()
+
  adb.start_app(package, "org.beeware.android.MainActivity", passthrough)
- pid = None
- attempts = 0
- delay = 0.01
 
  # Try to get the PID for 5 seconds.
- fail_time = start_time + datetime.timedelta(seconds=5)
+ pid = None
+ fail_time = datetime.datetime.now() + datetime.timedelta(seconds=5)
  while not pid and datetime.datetime.now() < fail_time:
  # Try to get the PID; run in quiet mode because we may
  # need to do this a lot in the next 5 seconds.
  pid = adb.pidof(package, quiet=True)
  if not pid:
- time.sleep(delay)
- attempts += 1
+ time.sleep(0.01)
 
  if pid:
  self.logger.info(
  "Following device log output (type CTRL-C to stop log)...",
  prefix=app.app_name,
  )
- # Start the app in a way that lets us stream the logs
+ # Start adb's logcat in a way that lets us stream the logs
  log_popen = adb.logcat(pid=pid)
 
  # Stream the app logs.
@@ -352,13 +344,11 @@ def run_app(
  else:
  self.logger.error("Unable to find PID for app", prefix=app.app_name)
  self.logger.error("Logs for launch attempt follow...")
+ self.logger.error("=" * 75)
 
  # Show the log from the start time of the app
- self.logger.error("=" * 75)
+ adb.logcat_tail(since=device_start_time)
 
- # Pad by a few seconds because the android emulator's clock and the
- # local system clock may not be perfectly aligned.
- adb.logcat_tail(since=start_time - datetime.timedelta(seconds=10))
  raise BriefcaseCommandError(f"Problem starting app {app.app_name!r}")
  finally:
  if shutdown_on_exit:

tests/integrations/android_sdk/ADB/test_avd_name.py

@@ -4,13 +4,11 @@
 import pytest
 
 from briefcase.exceptions import BriefcaseCommandError, InvalidDeviceError
-from briefcase.integrations.android_sdk import ADB
 
 
-def test_emulator(mock_tools, capsys):
+def test_emulator(adb, capsys):
  """Invoking `avd_name()` on an emulator returns the AVD."""
  # Mock out the adb response for an emulator
- adb = ADB(mock_tools, "deafbeefcafe")
  adb.run = MagicMock(return_value="exampledevice\nOK\n")
 
  # Invoke avd_name
@@ -20,10 +18,9 @@ def test_emulator(mock_tools, capsys):
  adb.run.assert_called_once_with("emu", "avd", "name")
 
 
-def test_device(mock_tools, capsys):
+def test_device(adb, capsys):
  """Invoking `avd_name()` on a device returns None."""
  # Mock out the adb response for a physical device
- adb = ADB(mock_tools, "deafbeefcafe")
  adb.run = MagicMock(
  side_effect=subprocess.CalledProcessError(returncode=1, cmd="emu avd name")
  )
@@ -35,10 +32,9 @@ def test_device(mock_tools, capsys):
  adb.run.assert_called_once_with("emu", "avd", "name")
 
 
-def test_adb_failure(mock_tools, capsys):
+def test_adb_failure(adb, capsys):
  """If `adb()` fails for a miscellaneous reason, an error is raised."""
  # Mock out the run command on an adb instance
- adb = ADB(mock_tools, "exampleDevice")
  adb.run = MagicMock(
  side_effect=subprocess.CalledProcessError(returncode=69, cmd="emu avd name")
  )
@@ -51,10 +47,9 @@ def test_adb_failure(mock_tools, capsys):
  adb.run.assert_called_once_with("emu", "avd", "name")
 
 
-def test_invalid_device(mock_tools, capsys):
+def test_invalid_device(adb, capsys):
  """Invoking `avd_name()` on an invalid device raises an error."""
  # Mock out the run command on an adb instance
- adb = ADB(mock_tools, "exampleDevice")
  adb.run = MagicMock(side_effect=InvalidDeviceError("device", "exampleDevice"))
 
  # Invoke install

tests/integrations/android_sdk/ADB/test_datetime.py

@@ -0,0 +1,48 @@
+import subprocess
+from datetime import datetime
+from unittest.mock import Mock
+
+import pytest
+
+from briefcase.exceptions import BriefcaseCommandError
+
+
+@pytest.mark.parametrize(
+ "device_output, expected_datetime",
+ [
+ ("2023-07-12 09:28:04", datetime(2023, 7, 12, 9, 28, 4)),
+ ("2023-07-12 09:28:04\n", datetime(2023, 7, 12, 9, 28, 4)),
+ ("2023-7-12 9:28:04", datetime(2023, 7, 12, 9, 28, 4)),
+ ("2023-12-2 14:28:04", datetime(2023, 12, 2, 14, 28, 4)),
+ ],
+)
+def test_datetime_success(adb, device_output, expected_datetime):
+ """adb.datetime() returns `datetime` for device."""
+ adb.run = Mock(return_value=device_output)
+
+ assert adb.datetime() == expected_datetime
+ adb.run.assert_called_once_with("shell", "date", "+'%Y-%m-%d %H:%M:%S'")
+
+
+def test_datetime_failure_call(adb):
+ """adb.datetime() fails in subprocess call."""
+ adb.run = Mock(
+ side_effect=subprocess.CalledProcessError(returncode=1, cmd="adb shell ...")
+ )
+
+ with pytest.raises(
+ BriefcaseCommandError,
+ match="Error obtaining device date/time.",
+ ):
+ adb.datetime()
+
+
+def test_datetime_failure_bad_value(adb):
+ """adb.datetime() fails in output conversion."""
+ adb.run = Mock(return_value="the date is jan 1 1970")
+
+ with pytest.raises(
+ BriefcaseCommandError,
+ match="Error obtaining device date/time.",
+ ):
+ adb.datetime()

tests/integrations/android_sdk/ADB/test_force_stop_app.py

@@ -4,13 +4,11 @@
 import pytest
 
 from briefcase.exceptions import BriefcaseCommandError, InvalidDeviceError
-from briefcase.integrations.android_sdk import ADB
 
 
-def test_force_stop_app(mock_tools, capsys):
+def test_force_stop_app(adb, capsys):
  """Invoking `force_stop_app()` calls `run()` with the appropriate parameters."""
  # Mock out the run command on an adb instance
- adb = ADB(mock_tools, "exampleDevice")
  adb.run = MagicMock(return_value="example normal adb output")
 
  # Invoke force_stop_app
@@ -26,10 +24,9 @@ def test_force_stop_app(mock_tools, capsys):
  assert "normal adb output" not in capsys.readouterr()
 
 
-def test_force_top_fail(mock_tools, capsys):
+def test_force_top_fail(adb, capsys):
  """If `force_stop_app()` fails, an error is raised."""
  # Mock out the run command on an adb instance
- adb = ADB(mock_tools, "exampleDevice")
  adb.run = MagicMock(
  side_effect=subprocess.CalledProcessError(returncode=69, cmd="force-stop")
  )
@@ -44,10 +41,9 @@ def test_force_top_fail(mock_tools, capsys):
  )
 
 
-def test_invalid_device(mock_tools, capsys):
+def test_invalid_device(adb, capsys):
  """Invoking `force_stop_app()` on an invalid device raises an error."""
  # Mock out the run command on an adb instance
- adb = ADB(mock_tools, "exampleDevice")
  adb.run = MagicMock(side_effect=InvalidDeviceError("device", "exampleDevice"))
 
  # Invoke force_stop_app

tests/integrations/android_sdk/ADB/test_has_booted.py

@@ -4,13 +4,11 @@
 import pytest
 
 from briefcase.exceptions import BriefcaseCommandError, InvalidDeviceError
-from briefcase.integrations.android_sdk import ADB
 
 
-def test_booted(mock_tools, capsys):
+def test_booted(adb, capsys):
  """A booted device returns true."""
  # Mock out the adb response for an emulator
- adb = ADB(mock_tools, "deafbeefcafe")
  adb.run = MagicMock(return_value="1\n")
 
  # Invoke avd_name
@@ -20,10 +18,9 @@ def test_booted(mock_tools, capsys):
  adb.run.assert_called_once_with("shell", "getprop", "sys.boot_completed")
 
 
-def test_not_booted(mock_tools, capsys):
+def test_not_booted(adb, capsys):
  """A non-booted device returns False."""
  # Mock out the adb response for an emulator
- adb = ADB(mock_tools, "deafbeefcafe")
  adb.run = MagicMock(return_value="\n")
 
  # Invoke avd_name
@@ -33,10 +30,9 @@ def test_not_booted(mock_tools, capsys):
  adb.run.assert_called_once_with("shell", "getprop", "sys.boot_completed")
 
 
-def test_adb_failure(mock_tools, capsys):
+def test_adb_failure(adb, capsys):
  """If ADB fails, an error is raised."""
  # Mock out the adb response for an emulator
- adb = ADB(mock_tools, "deafbeefcafe")
  adb.run = MagicMock(
  side_effect=subprocess.CalledProcessError(returncode=69, cmd="emu avd name")
  )
@@ -49,10 +45,9 @@ def test_adb_failure(mock_tools, capsys):
  adb.run.assert_called_once_with("shell", "getprop", "sys.boot_completed")
 
 
-def test_invalid_device(mock_tools, capsys):
+def test_invalid_device(adb, capsys):
  """If the device ID is invalid, an error is raised."""
  # Mock out the adb response for an emulator
- adb = ADB(mock_tools, "not-a-device")
  adb.run = MagicMock(side_effect=InvalidDeviceError("device", "exampleDevice"))
 
  # Invoke avd_name

tests/integrations/android_sdk/ADB/test_install_apk.py

@@ -4,13 +4,11 @@
 import pytest
 
 from briefcase.exceptions import BriefcaseCommandError, InvalidDeviceError
-from briefcase.integrations.android_sdk import ADB
 
 
-def test_install_apk(mock_tools, capsys):
+def test_install_apk(adb, capsys):
  """Invoking `install_apk()` calls `run()` with the appropriate parameters."""
  # Mock out the run command on an adb instance
- adb = ADB(mock_tools, "exampleDevice")
  adb.run = MagicMock(return_value="example normal adb output")
 
  # Invoke install
@@ -24,10 +22,9 @@ def test_install_apk(mock_tools, capsys):
  assert "normal adb output" not in capsys.readouterr()
 
 
-def test_install_failure(mock_tools, capsys):
+def test_install_failure(adb, capsys):
  """If `install_apk()` fails, an error is raised."""
  # Mock out the run command on an adb instance
- adb = ADB(mock_tools, "exampleDevice")
  adb.run = MagicMock(
  side_effect=subprocess.CalledProcessError(returncode=2, cmd="install")
  )
@@ -40,10 +37,9 @@ def test_install_failure(mock_tools, capsys):
  adb.run.assert_called_once_with("install", "-r", "example.apk")
 
 
-def test_invalid_device(mock_tools, capsys):
+def test_invalid_device(adb, capsys):
  """Invoking `install_apk()` on an invalid device raises an error."""
  # Mock out the run command on an adb instance
- adb = ADB(mock_tools, "exampleDevice")
  adb.run = MagicMock(side_effect=InvalidDeviceError("device", "exampleDevice"))
 
  # Invoke install