Import device_type config logic

Originally introduced: https://android-review.googlesource.com/c/device/google/cuttlefish/+/3541865 https://android-review.googlesource.com/c/device/google/cuttlefish/+/3556148 Bug: 402297215

Author: dimorinny

base/cvd/cuttlefish/common/libs/utils/BUILD.bazel

@@ -96,6 +96,7 @@ cc_library(
  "archive.cpp",
  "base64.cpp",
  "container.cpp",
+ "device_type.cpp",
  "files.cpp",
  "flag_parser.cpp",
  "flags_validator.cpp",
@@ -121,6 +122,7 @@ cc_library(
  "cf_endian.h",
  "container.h",
  "contains.h",
+ "device_type.h",
  "files.h",
  "flag_parser.h",
  "flags_validator.h",

base/cvd/cuttlefish/common/libs/utils/device_type.cpp

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "common/libs/utils/device_type.h"
+
+namespace cuttlefish {
+
+// Parse device type from android-info.txt config field.
+DeviceType ParseDeviceType(std::string_view type_name) {
+ if (type_name == "phone") {
+ return DeviceType::Phone;
+ } else if (type_name == "wear") {
+ return DeviceType::Wear;
+ } else if (type_name == "auto" || type_name == "auto_portrait" ||
+ type_name == "auto_dd" || type_name == "auto_md") {
+ return DeviceType::Auto;
+ } else if (type_name == "foldable") {
+ return DeviceType::Foldable;
+ } else if (type_name == "tv") {
+ return DeviceType::Tv;
+ } else if (type_name == "minidroid") {
+ return DeviceType::Minidroid;
+ } else if (type_name == "go") {
+ return DeviceType::Go;
+ } else {
+ return DeviceType::Unknown;
+ }
+}
+
+} // namespace cuttlefish

base/cvd/cuttlefish/common/libs/utils/device_type.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <string>
+
+namespace cuttlefish {
+
+enum class DeviceType {
+ Unknown = 0,
+ Phone,
+ Wear,
+ Auto,
+ Foldable,
+ Tv,
+ Minidroid,
+ Go,
+};
+
+// Parse device type android-info.txt config field.
+DeviceType ParseDeviceType(std::string_view type_name);
+
+} // namespace cuttlefish

base/cvd/cuttlefish/host/commands/assemble_cvd/flags.cc

@@ -724,6 +724,15 @@ Result<std::vector<GuestConfig>> ReadGuestConfig() {
  system_image_dir[instance_index] + "/android-info.txt";
  }
 
+ auto res_device_type =
+ GetAndroidInfoConfig(instance_android_info_txt, "device_type");
+ // If that "device_type" is not explicitly set, fall back to parse "config".
+ if (!res_device_type.ok()) {
+ res_device_type =
+ GetAndroidInfoConfig(instance_android_info_txt, "config");
+ }
+ guest_config.device_type = ParseDeviceType(res_device_type.value_or(""));
+
  auto res = GetAndroidInfoConfig(instance_android_info_txt, "gfxstream");
  guest_config.gfxstream_supported =
  res.ok() && res.value() == "supported";
@@ -1637,6 +1646,7 @@ Result<CuttlefishConfig> InitializeCuttlefishConfiguration(
  "instance_index " << instance_index << " out of boundary "
  << guest_configs.size());
  instance.set_target_arch(guest_configs[instance_index].target_arch);
+ instance.set_device_type(guest_configs[instance_index].device_type);
  instance.set_guest_android_version(
  guest_configs[instance_index].android_version_number);
  instance.set_console(console_vec[instance_index]);

base/cvd/cuttlefish/host/commands/assemble_cvd/flags.h

@@ -30,6 +30,7 @@ namespace cuttlefish {
 
 struct GuestConfig {
  Arch target_arch;
+ DeviceType device_type;
  bool bootconfig_supported = false;
  bool hctr2_supported = false;
  std::string android_version_number;

base/cvd/cuttlefish/host/libs/config/cuttlefish_config.h

@@ -29,6 +29,7 @@
 #include <fmt/ostream.h>
 
 #include "common/libs/utils/architecture.h"
+#include "common/libs/utils/device_type.h"
 #include "common/libs/utils/result.h"
 #include "host/libs/config/config_constants.h"
 #include "host/libs/config/config_fragment.h"
@@ -594,6 +595,8 @@ class CuttlefishConfig {
  // forces.
  bool use_bootloader() const;
 
+ DeviceType device_type() const;
+
  Arch target_arch() const;
 
  int cpus() const;
@@ -835,6 +838,7 @@ class CuttlefishConfig {
  void set_enable_sandbox(const bool enable_sandbox);
  void set_enable_virtiofs(const bool enable_virtiofs);
  void set_kgdb(bool kgdb);
+ void set_device_type(DeviceType type);
  void set_target_arch(Arch target_arch);
  void set_cpus(int cpus);
  void set_vcpu_config_path(const std::string& vcpu_config_path);

base/cvd/cuttlefish/host/libs/config/cuttlefish_config_instance.cpp

@@ -1407,6 +1407,15 @@ Arch CuttlefishConfig::InstanceSpecific::target_arch() const {
  return static_cast<Arch>((*Dictionary())[kTargetArch].asInt());
 }
 
+static constexpr char kDeviceType[] = "device_type";
+void CuttlefishConfig::MutableInstanceSpecific::set_device_type(
+ DeviceType type) {
+ (*Dictionary())[kDeviceType] = static_cast<int>(type);
+}
+DeviceType CuttlefishConfig::InstanceSpecific::device_type() const {
+ return static_cast<DeviceType>((*Dictionary())[kDeviceType].asInt());
+}
+
 static constexpr char kEnableSandbox[] = "enable_sandbox";
 void CuttlefishConfig::MutableInstanceSpecific::set_enable_sandbox(const bool enable_sandbox) {
  (*Dictionary())[kEnableSandbox] = enable_sandbox;