1 /*
2 * Copyright (C) 2018 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "cuttlefish_config.h"
18 #include "host/libs/config/cuttlefish_config.h"
19
20 #include <string>
21 #include <string_view>
22
23 #include <android-base/logging.h>
24 #include <android-base/strings.h>
25 #include <json/json.h>
26
27 #include "common/libs/utils/files.h"
28 #include "common/libs/utils/flags_validator.h"
29 #include "host/libs/vm_manager/crosvm_manager.h"
30 #include "host/libs/vm_manager/gem5_manager.h"
31
32 namespace cuttlefish {
33 namespace {
34
35 using APBootFlow = CuttlefishConfig::InstanceSpecific::APBootFlow;
36
37 const char* kInstances = "instances";
38
IdToName(const std::string & id)39 std::string IdToName(const std::string& id) { return kCvdNamePrefix + id; }
40
41 } // namespace
42
operator <<(std::ostream & out,ExternalNetworkMode net)43 std::ostream& operator<<(std::ostream& out, ExternalNetworkMode net) {
44 switch (net) {
45 case ExternalNetworkMode::kUnknown:
46 return out << "unknown";
47 case ExternalNetworkMode::kTap:
48 return out << "tap";
49 case ExternalNetworkMode::kSlirp:
50 return out << "slirp";
51 }
52 }
ParseExternalNetworkMode(std::string_view str)53 Result<ExternalNetworkMode> ParseExternalNetworkMode(std::string_view str) {
54 if (android::base::EqualsIgnoreCase(str, "tap")) {
55 return ExternalNetworkMode::kTap;
56 } else if (android::base::EqualsIgnoreCase(str, "slirp")) {
57 return ExternalNetworkMode::kSlirp;
58 } else {
59 return CF_ERRF(
60 "\"{}\" is not a valid ExternalNetworkMode. Valid values are \"tap\" "
61 "and \"slirp\"",
62 str);
63 }
64 }
65
ToString(VmmMode mode)66 std::string ToString(VmmMode mode) {
67 std::stringstream ss;
68 ss << mode;
69 return ss.str();
70 }
71
operator <<(std::ostream & out,VmmMode vmm)72 std::ostream& operator<<(std::ostream& out, VmmMode vmm) {
73 switch (vmm) {
74 case VmmMode::kUnknown:
75 return out << "unknown";
76 case VmmMode::kCrosvm:
77 return out << "crosvm";
78 case VmmMode::kGem5:
79 return out << "gem5";
80 case VmmMode::kQemu:
81 return out << "qemu_cli";
82 }
83 }
84
ParseVmm(std::string_view str)85 Result<VmmMode> ParseVmm(std::string_view str) {
86 if (android::base::EqualsIgnoreCase(str, "crosvm")) {
87 return VmmMode::kCrosvm;
88 } else if (android::base::EqualsIgnoreCase(str, "gem5")) {
89 return VmmMode::kGem5;
90 } else if (android::base::EqualsIgnoreCase(str, "qemu_cli")) {
91 return VmmMode::kQemu;
92 } else {
93 return CF_ERRF("\"{}\" is not a valid Vmm.", str);
94 }
95 }
96
operator <<(std::ostream & out,GuestHwuiRenderer renderer)97 std::ostream& operator<<(std::ostream& out, GuestHwuiRenderer renderer) {
98 return out << ToString(renderer);
99 }
100
ToString(GuestHwuiRenderer renderer)101 std::string ToString(GuestHwuiRenderer renderer) {
102 switch (renderer) {
103 case GuestHwuiRenderer::kUnknown:
104 return "unknown";
105 case GuestHwuiRenderer::kSkiaGl:
106 return "skiagl";
107 case GuestHwuiRenderer::kSkiaVk:
108 return "skiavk";
109 }
110 }
111
ParseGuestHwuiRenderer(std::string_view str)112 Result<GuestHwuiRenderer> ParseGuestHwuiRenderer(std::string_view str) {
113 if (android::base::EqualsIgnoreCase(str, "unknown")) {
114 return GuestHwuiRenderer::kUnknown;
115 } else if (android::base::EqualsIgnoreCase(str, "skiagl")) {
116 return GuestHwuiRenderer::kSkiaGl;
117 } else if (android::base::EqualsIgnoreCase(str, "skiavk")) {
118 return GuestHwuiRenderer::kSkiaVk;
119 } else {
120 return CF_ERRF("\"{}\" is not a valid HWUI renderer.", str);
121 }
122 }
123
operator <<(std::ostream & out,GuestRendererPreload preload)124 std::ostream& operator<<(std::ostream& out, GuestRendererPreload preload) {
125 return out << ToString(preload);
126 }
127
ToString(GuestRendererPreload preload)128 std::string ToString(GuestRendererPreload preload) {
129 switch (preload) {
130 case GuestRendererPreload::kAuto:
131 return "auto";
132 case GuestRendererPreload::kGuestDefault:
133 return "default";
134 case GuestRendererPreload::kEnabled:
135 return "enabled";
136 case GuestRendererPreload::kDisabled:
137 return "disabled";
138 }
139 }
140
ParseGuestRendererPreload(std::string_view str)141 Result<GuestRendererPreload> ParseGuestRendererPreload(std::string_view str) {
142 if (android::base::EqualsIgnoreCase(str, "auto")) {
143 return GuestRendererPreload::kAuto;
144 } else if (android::base::EqualsIgnoreCase(str, "default")) {
145 return GuestRendererPreload::kGuestDefault;
146 } else if (android::base::EqualsIgnoreCase(str, "enabled")) {
147 return GuestRendererPreload::kEnabled;
148 } else if (android::base::EqualsIgnoreCase(str, "disabled")) {
149 return GuestRendererPreload::kDisabled;
150 } else {
151 return CF_ERRF("\"{}\" is not a valid renderer preload.", str);
152 }
153 }
154
155 std::ostream& operator<<(std::ostream&, GuestRendererPreload);
156 std::string ToString(GuestRendererPreload);
157 Result<GuestRendererPreload> ParseGuestRendererPreload(std::string_view);
158
159 static constexpr char kInstanceDir[] = "instance_dir";
MutableInstanceSpecific(CuttlefishConfig * config,const std::string & id)160 CuttlefishConfig::MutableInstanceSpecific::MutableInstanceSpecific(
161 CuttlefishConfig* config, const std::string& id)
162 : config_(config), id_(id) {
163 // Legacy for acloud
164 (*Dictionary())[kInstanceDir] = config_->InstancesPath(IdToName(id));
165 }
166
Dictionary()167 Json::Value* CuttlefishConfig::MutableInstanceSpecific::Dictionary() {
168 return &(*config_->dictionary_)[kInstances][id_];
169 }
170
Dictionary() const171 const Json::Value* CuttlefishConfig::InstanceSpecific::Dictionary() const {
172 return &(*config_->dictionary_)[kInstances][id_];
173 }
174
instance_dir() const175 std::string CuttlefishConfig::InstanceSpecific::instance_dir() const {
176 return config_->InstancesPath(IdToName(id_));
177 }
178
instance_internal_dir() const179 std::string CuttlefishConfig::InstanceSpecific::instance_internal_dir() const {
180 return PerInstancePath(kInternalDirName);
181 }
182
instance_uds_dir() const183 std::string CuttlefishConfig::InstanceSpecific::instance_uds_dir() const {
184 return config_->InstancesUdsPath(IdToName(id_));
185 }
186
instance_internal_uds_dir() const187 std::string CuttlefishConfig::InstanceSpecific::instance_internal_uds_dir()
188 const {
189 return PerInstanceUdsPath(kInternalDirName);
190 }
191
192 // TODO (b/163575714) add virtio console support to the bootloader so the
193 // virtio console path for the console device can be taken again. When that
194 // happens, this function can be deleted along with all the code paths it
195 // forces.
use_bootloader() const196 bool CuttlefishConfig::InstanceSpecific::use_bootloader() const {
197 return true;
198 };
199
200 // vectorized and moved system image files into instance specific
201 static constexpr char kBootImage[] = "boot_image";
boot_image() const202 std::string CuttlefishConfig::InstanceSpecific::boot_image() const {
203 return (*Dictionary())[kBootImage].asString();
204 }
set_boot_image(const std::string & boot_image)205 void CuttlefishConfig::MutableInstanceSpecific::set_boot_image(
206 const std::string& boot_image) {
207 (*Dictionary())[kBootImage] = boot_image;
208 }
209 static constexpr char kNewBootImage[] = "new_boot_image";
new_boot_image() const210 std::string CuttlefishConfig::InstanceSpecific::new_boot_image() const {
211 return (*Dictionary())[kNewBootImage].asString();
212 }
set_new_boot_image(const std::string & new_boot_image)213 void CuttlefishConfig::MutableInstanceSpecific::set_new_boot_image(
214 const std::string& new_boot_image) {
215 (*Dictionary())[kNewBootImage] = new_boot_image;
216 }
217 static constexpr char kInitBootImage[] = "init_boot_image";
init_boot_image() const218 std::string CuttlefishConfig::InstanceSpecific::init_boot_image() const {
219 return (*Dictionary())[kInitBootImage].asString();
220 }
set_init_boot_image(const std::string & init_boot_image)221 void CuttlefishConfig::MutableInstanceSpecific::set_init_boot_image(
222 const std::string& init_boot_image) {
223 (*Dictionary())[kInitBootImage] = init_boot_image;
224 }
225 static constexpr char kDataImage[] = "data_image";
data_image() const226 std::string CuttlefishConfig::InstanceSpecific::data_image() const {
227 return (*Dictionary())[kDataImage].asString();
228 }
set_data_image(const std::string & data_image)229 void CuttlefishConfig::MutableInstanceSpecific::set_data_image(
230 const std::string& data_image) {
231 (*Dictionary())[kDataImage] = data_image;
232 }
233 static constexpr char kNewDataImage[] = "new_data_image";
new_data_image() const234 std::string CuttlefishConfig::InstanceSpecific::new_data_image() const {
235 return (*Dictionary())[kNewDataImage].asString();
236 }
set_new_data_image(const std::string & new_data_image)237 void CuttlefishConfig::MutableInstanceSpecific::set_new_data_image(
238 const std::string& new_data_image) {
239 (*Dictionary())[kNewDataImage] = new_data_image;
240 }
241 static constexpr char kSuperImage[] = "super_image";
super_image() const242 std::string CuttlefishConfig::InstanceSpecific::super_image() const {
243 return (*Dictionary())[kSuperImage].asString();
244 }
set_super_image(const std::string & super_image)245 void CuttlefishConfig::MutableInstanceSpecific::set_super_image(
246 const std::string& super_image) {
247 (*Dictionary())[kSuperImage] = super_image;
248 }
249 static constexpr char kNewSuperImage[] = "new_super_image";
new_super_image() const250 std::string CuttlefishConfig::InstanceSpecific::new_super_image() const {
251 return (*Dictionary())[kNewSuperImage].asString();
252 }
set_new_super_image(const std::string & super_image)253 void CuttlefishConfig::MutableInstanceSpecific::set_new_super_image(
254 const std::string& super_image) {
255 (*Dictionary())[kNewSuperImage] = super_image;
256 }
257 static constexpr char kMiscInfoTxt[] = "misc_info_txt";
misc_info_txt() const258 std::string CuttlefishConfig::InstanceSpecific::misc_info_txt() const {
259 return (*Dictionary())[kMiscInfoTxt].asString();
260 }
set_misc_info_txt(const std::string & misc_info)261 void CuttlefishConfig::MutableInstanceSpecific::set_misc_info_txt(
262 const std::string& misc_info) {
263 (*Dictionary())[kMiscInfoTxt] = misc_info;
264 }
265 static constexpr char kVendorBootImage[] = "vendor_boot_image";
vendor_boot_image() const266 std::string CuttlefishConfig::InstanceSpecific::vendor_boot_image() const {
267 return (*Dictionary())[kVendorBootImage].asString();
268 }
set_vendor_boot_image(const std::string & vendor_boot_image)269 void CuttlefishConfig::MutableInstanceSpecific::set_vendor_boot_image(
270 const std::string& vendor_boot_image) {
271 (*Dictionary())[kVendorBootImage] = vendor_boot_image;
272 }
273 static constexpr char kNewVendorBootImage[] = "new_vendor_boot_image";
new_vendor_boot_image() const274 std::string CuttlefishConfig::InstanceSpecific::new_vendor_boot_image() const {
275 return (*Dictionary())[kNewVendorBootImage].asString();
276 }
set_new_vendor_boot_image(const std::string & new_vendor_boot_image)277 void CuttlefishConfig::MutableInstanceSpecific::set_new_vendor_boot_image(
278 const std::string& new_vendor_boot_image) {
279 (*Dictionary())[kNewVendorBootImage] = new_vendor_boot_image;
280 }
281 static constexpr char kVbmetaImage[] = "vbmeta_image";
vbmeta_image() const282 std::string CuttlefishConfig::InstanceSpecific::vbmeta_image() const {
283 return (*Dictionary())[kVbmetaImage].asString();
284 }
set_vbmeta_image(const std::string & vbmeta_image)285 void CuttlefishConfig::MutableInstanceSpecific::set_vbmeta_image(
286 const std::string& vbmeta_image) {
287 (*Dictionary())[kVbmetaImage] = vbmeta_image;
288 }
289 static constexpr char kNewVbmetaImage[] = "new_vbmeta_image";
new_vbmeta_image() const290 std::string CuttlefishConfig::InstanceSpecific::new_vbmeta_image() const {
291 return (*Dictionary())[kNewVbmetaImage].asString();
292 }
set_new_vbmeta_image(const std::string & new_vbmeta_image)293 void CuttlefishConfig::MutableInstanceSpecific::set_new_vbmeta_image(
294 const std::string& new_vbmeta_image) {
295 (*Dictionary())[kNewVbmetaImage] = new_vbmeta_image;
296 }
297 static constexpr char kVbmetaSystemImage[] = "vbmeta_system_image";
vbmeta_system_image() const298 std::string CuttlefishConfig::InstanceSpecific::vbmeta_system_image() const {
299 return (*Dictionary())[kVbmetaSystemImage].asString();
300 }
set_vbmeta_system_image(const std::string & vbmeta_system_image)301 void CuttlefishConfig::MutableInstanceSpecific::set_vbmeta_system_image(
302 const std::string& vbmeta_system_image) {
303 (*Dictionary())[kVbmetaSystemImage] = vbmeta_system_image;
304 }
305 static constexpr char kVbmetaVendorDlkmImage[] = "vbmeta_vendor_dlkm_image";
vbmeta_vendor_dlkm_image() const306 std::string CuttlefishConfig::InstanceSpecific::vbmeta_vendor_dlkm_image()
307 const {
308 return (*Dictionary())[kVbmetaVendorDlkmImage].asString();
309 }
set_vbmeta_vendor_dlkm_image(const std::string & image)310 void CuttlefishConfig::MutableInstanceSpecific::set_vbmeta_vendor_dlkm_image(
311 const std::string& image) {
312 (*Dictionary())[kVbmetaVendorDlkmImage] = image;
313 }
314 static constexpr char kNewVbmetaVendorDlkmImage[] =
315 "new_vbmeta_vendor_dlkm_image";
new_vbmeta_vendor_dlkm_image() const316 std::string CuttlefishConfig::InstanceSpecific::new_vbmeta_vendor_dlkm_image()
317 const {
318 return (*Dictionary())[kNewVbmetaVendorDlkmImage].asString();
319 }
320 void CuttlefishConfig::MutableInstanceSpecific::
set_new_vbmeta_vendor_dlkm_image(const std::string & image)321 set_new_vbmeta_vendor_dlkm_image(const std::string& image) {
322 (*Dictionary())[kNewVbmetaVendorDlkmImage] = image;
323 }
324 static constexpr char kVbmetaSystemDlkmImage[] = "vbmeta_system_dlkm_image";
vbmeta_system_dlkm_image() const325 std::string CuttlefishConfig::InstanceSpecific::vbmeta_system_dlkm_image()
326 const {
327 return (*Dictionary())[kVbmetaSystemDlkmImage].asString();
328 }
set_vbmeta_system_dlkm_image(const std::string & image)329 void CuttlefishConfig::MutableInstanceSpecific::set_vbmeta_system_dlkm_image(
330 const std::string& image) {
331 (*Dictionary())[kVbmetaSystemDlkmImage] = image;
332 }
333 static constexpr char kNewVbmetaSystemDlkmImage[] =
334 "new_vbmeta_system_dlkm_image";
new_vbmeta_system_dlkm_image() const335 std::string CuttlefishConfig::InstanceSpecific::new_vbmeta_system_dlkm_image()
336 const {
337 return (*Dictionary())[kNewVbmetaSystemDlkmImage].asString();
338 }
339 void CuttlefishConfig::MutableInstanceSpecific::
set_new_vbmeta_system_dlkm_image(const std::string & image)340 set_new_vbmeta_system_dlkm_image(const std::string& image) {
341 (*Dictionary())[kNewVbmetaSystemDlkmImage] = image;
342 }
343 static constexpr char kOtherosEspImage[] = "otheros_esp_image";
otheros_esp_image() const344 std::string CuttlefishConfig::InstanceSpecific::otheros_esp_image() const {
345 return (*Dictionary())[kOtherosEspImage].asString();
346 }
set_otheros_esp_image(const std::string & otheros_esp_image)347 void CuttlefishConfig::MutableInstanceSpecific::set_otheros_esp_image(
348 const std::string& otheros_esp_image) {
349 (*Dictionary())[kOtherosEspImage] = otheros_esp_image;
350 }
351 static constexpr char kAndroidEfiLoader[] = "android_efi_loader";
android_efi_loader() const352 std::string CuttlefishConfig::InstanceSpecific::android_efi_loader() const {
353 return (*Dictionary())[kAndroidEfiLoader].asString();
354 }
set_android_efi_loader(const std::string & android_efi_loader)355 void CuttlefishConfig::MutableInstanceSpecific::set_android_efi_loader(
356 const std::string& android_efi_loader) {
357 (*Dictionary())[kAndroidEfiLoader] = android_efi_loader;
358 }
359 static constexpr char kChromeOsDisk[] = "chromeos_disk";
chromeos_disk() const360 std::string CuttlefishConfig::InstanceSpecific::chromeos_disk() const {
361 return (*Dictionary())[kChromeOsDisk].asString();
362 }
set_chromeos_disk(const std::string & chromeos_disk)363 void CuttlefishConfig::MutableInstanceSpecific::set_chromeos_disk(
364 const std::string& chromeos_disk) {
365 (*Dictionary())[kChromeOsDisk] = chromeos_disk;
366 }
367 static constexpr char kChromeOsKernelPath[] = "chromeos_kernel_path";
chromeos_kernel_path() const368 std::string CuttlefishConfig::InstanceSpecific::chromeos_kernel_path() const {
369 return (*Dictionary())[kChromeOsKernelPath].asString();
370 }
set_chromeos_kernel_path(const std::string & chromeos_kernel_path)371 void CuttlefishConfig::MutableInstanceSpecific::set_chromeos_kernel_path(
372 const std::string& chromeos_kernel_path) {
373 (*Dictionary())[kChromeOsKernelPath] = chromeos_kernel_path;
374 }
375 static constexpr char kChromeOsRootImage[] = "chromeos_root_image";
chromeos_root_image() const376 std::string CuttlefishConfig::InstanceSpecific::chromeos_root_image() const {
377 return (*Dictionary())[kChromeOsRootImage].asString();
378 }
set_chromeos_root_image(const std::string & chromeos_root_image)379 void CuttlefishConfig::MutableInstanceSpecific::set_chromeos_root_image(
380 const std::string& chromeos_root_image) {
381 (*Dictionary())[kChromeOsRootImage] = chromeos_root_image;
382 }
383 static constexpr char kLinuxKernelPath[] = "linux_kernel_path";
linux_kernel_path() const384 std::string CuttlefishConfig::InstanceSpecific::linux_kernel_path() const {
385 return (*Dictionary())[kLinuxKernelPath].asString();
386 }
set_linux_kernel_path(const std::string & linux_kernel_path)387 void CuttlefishConfig::MutableInstanceSpecific::set_linux_kernel_path(
388 const std::string& linux_kernel_path) {
389 (*Dictionary())[kLinuxKernelPath] = linux_kernel_path;
390 }
391 static constexpr char kLinuxInitramfsPath[] = "linux_initramfs_path";
linux_initramfs_path() const392 std::string CuttlefishConfig::InstanceSpecific::linux_initramfs_path() const {
393 return (*Dictionary())[kLinuxInitramfsPath].asString();
394 }
set_linux_initramfs_path(const std::string & linux_initramfs_path)395 void CuttlefishConfig::MutableInstanceSpecific::set_linux_initramfs_path(
396 const std::string& linux_initramfs_path) {
397 (*Dictionary())[kLinuxInitramfsPath] = linux_initramfs_path;
398 }
399 static constexpr char kLinuxRootImage[] = "linux_root_image";
linux_root_image() const400 std::string CuttlefishConfig::InstanceSpecific::linux_root_image() const {
401 return (*Dictionary())[kLinuxRootImage].asString();
402 }
set_linux_root_image(const std::string & linux_root_image)403 void CuttlefishConfig::MutableInstanceSpecific::set_linux_root_image(
404 const std::string& linux_root_image) {
405 (*Dictionary())[kLinuxRootImage] = linux_root_image;
406 }
407 static constexpr char kFuchsiaZedbootPath[] = "fuchsia_zedboot_path";
set_fuchsia_zedboot_path(const std::string & fuchsia_zedboot_path)408 void CuttlefishConfig::MutableInstanceSpecific::set_fuchsia_zedboot_path(
409 const std::string& fuchsia_zedboot_path) {
410 (*Dictionary())[kFuchsiaZedbootPath] = fuchsia_zedboot_path;
411 }
fuchsia_zedboot_path() const412 std::string CuttlefishConfig::InstanceSpecific::fuchsia_zedboot_path() const {
413 return (*Dictionary())[kFuchsiaZedbootPath].asString();
414 }
415 static constexpr char kFuchsiaMultibootBinPath[] = "multiboot_bin_path";
set_fuchsia_multiboot_bin_path(const std::string & fuchsia_multiboot_bin_path)416 void CuttlefishConfig::MutableInstanceSpecific::set_fuchsia_multiboot_bin_path(
417 const std::string& fuchsia_multiboot_bin_path) {
418 (*Dictionary())[kFuchsiaMultibootBinPath] = fuchsia_multiboot_bin_path;
419 }
fuchsia_multiboot_bin_path() const420 std::string CuttlefishConfig::InstanceSpecific::fuchsia_multiboot_bin_path() const {
421 return (*Dictionary())[kFuchsiaMultibootBinPath].asString();
422 }
423 static constexpr char kFuchsiaRootImage[] = "fuchsia_root_image";
set_fuchsia_root_image(const std::string & fuchsia_root_image)424 void CuttlefishConfig::MutableInstanceSpecific::set_fuchsia_root_image(
425 const std::string& fuchsia_root_image) {
426 (*Dictionary())[kFuchsiaRootImage] = fuchsia_root_image;
427 }
fuchsia_root_image() const428 std::string CuttlefishConfig::InstanceSpecific::fuchsia_root_image() const {
429 return (*Dictionary())[kFuchsiaRootImage].asString();
430 }
431 static constexpr char kCustomPartitionPath[] = "custom_partition_path";
set_custom_partition_path(const std::string & custom_partition_path)432 void CuttlefishConfig::MutableInstanceSpecific::set_custom_partition_path(
433 const std::string& custom_partition_path) {
434 (*Dictionary())[kCustomPartitionPath] = custom_partition_path;
435 }
custom_partition_path() const436 std::string CuttlefishConfig::InstanceSpecific::custom_partition_path() const {
437 return (*Dictionary())[kCustomPartitionPath].asString();
438 }
439 static constexpr char kHibernationPartitionImage[] =
440 "hibernation_partition_image";
set_hibernation_partition_image(const std::string & hibernation_partition_image)441 void CuttlefishConfig::MutableInstanceSpecific::set_hibernation_partition_image(
442 const std::string& hibernation_partition_image) {
443 (*Dictionary())[kHibernationPartitionImage] = hibernation_partition_image;
444 }
hibernation_partition_image() const445 std::string CuttlefishConfig::InstanceSpecific::hibernation_partition_image()
446 const {
447 return (*Dictionary())[kHibernationPartitionImage].asString();
448 }
449 static constexpr char kBlankMetadataImageMb[] = "blank_metadata_image_mb";
blank_metadata_image_mb() const450 int CuttlefishConfig::InstanceSpecific::blank_metadata_image_mb() const {
451 return (*Dictionary())[kBlankMetadataImageMb].asInt();
452 }
set_blank_metadata_image_mb(int blank_metadata_image_mb)453 void CuttlefishConfig::MutableInstanceSpecific::set_blank_metadata_image_mb(
454 int blank_metadata_image_mb) {
455 (*Dictionary())[kBlankMetadataImageMb] = blank_metadata_image_mb;
456 }
457 static constexpr char kBlankSdcardImageMb[] = "blank_sdcard_image_mb";
blank_sdcard_image_mb() const458 int CuttlefishConfig::InstanceSpecific::blank_sdcard_image_mb() const {
459 return (*Dictionary())[kBlankSdcardImageMb].asInt();
460 }
set_blank_sdcard_image_mb(int blank_sdcard_image_mb)461 void CuttlefishConfig::MutableInstanceSpecific::set_blank_sdcard_image_mb(
462 int blank_sdcard_image_mb) {
463 (*Dictionary())[kBlankSdcardImageMb] = blank_sdcard_image_mb;
464 }
465 static constexpr char kBootloader[] = "bootloader";
bootloader() const466 std::string CuttlefishConfig::InstanceSpecific::bootloader() const {
467 return (*Dictionary())[kBootloader].asString();
468 }
set_bootloader(const std::string & bootloader)469 void CuttlefishConfig::MutableInstanceSpecific::set_bootloader(
470 const std::string& bootloader) {
471 (*Dictionary())[kBootloader] = bootloader;
472 }
473 static constexpr char kInitramfsPath[] = "initramfs_path";
initramfs_path() const474 std::string CuttlefishConfig::InstanceSpecific::initramfs_path() const {
475 return (*Dictionary())[kInitramfsPath].asString();
476 }
set_initramfs_path(const std::string & initramfs_path)477 void CuttlefishConfig::MutableInstanceSpecific::set_initramfs_path(
478 const std::string& initramfs_path) {
479 (*Dictionary())[kInitramfsPath] = initramfs_path;
480 }
481 static constexpr char kKernelPath[] = "kernel_path";
kernel_path() const482 std::string CuttlefishConfig::InstanceSpecific::kernel_path() const {
483 return (*Dictionary())[kKernelPath].asString();
484 }
set_kernel_path(const std::string & kernel_path)485 void CuttlefishConfig::MutableInstanceSpecific::set_kernel_path(
486 const std::string& kernel_path) {
487 (*Dictionary())[kKernelPath] = kernel_path;
488 }
489 static constexpr char kVvmtruststorePath[] = "vvmtruststore_path";
set_vvmtruststore_path(const std::string & vvmtruststore_path)490 void CuttlefishConfig::MutableInstanceSpecific::set_vvmtruststore_path(
491 const std::string& vvmtruststore_path) {
492 (*Dictionary())[kVvmtruststorePath] = vvmtruststore_path;
493 }
vvmtruststore_path() const494 std::string CuttlefishConfig::InstanceSpecific::vvmtruststore_path() const {
495 return (*Dictionary())[kVvmtruststorePath].asString();
496 }
497 // end of system image files
498
499 static constexpr char kDefaultTargetZip[] = "default_target_zip";
default_target_zip() const500 std::string CuttlefishConfig::InstanceSpecific::default_target_zip() const {
501 return (*Dictionary())[kDefaultTargetZip].asString();
502 }
set_default_target_zip(const std::string & default_target_zip)503 void CuttlefishConfig::MutableInstanceSpecific::set_default_target_zip(
504 const std::string& default_target_zip) {
505 (*Dictionary())[kDefaultTargetZip] = default_target_zip;
506 }
507 static constexpr char kSystemTargetZip[] = "system_target_zip";
system_target_zip() const508 std::string CuttlefishConfig::InstanceSpecific::system_target_zip() const {
509 return (*Dictionary())[kSystemTargetZip].asString();
510 }
set_system_target_zip(const std::string & system_target_zip)511 void CuttlefishConfig::MutableInstanceSpecific::set_system_target_zip(
512 const std::string& system_target_zip) {
513 (*Dictionary())[kSystemTargetZip] = system_target_zip;
514 }
515
516 static constexpr char kSerialNumber[] = "serial_number";
serial_number() const517 std::string CuttlefishConfig::InstanceSpecific::serial_number() const {
518 return (*Dictionary())[kSerialNumber].asString();
519 }
set_serial_number(const std::string & serial_number)520 void CuttlefishConfig::MutableInstanceSpecific::set_serial_number(
521 const std::string& serial_number) {
522 (*Dictionary())[kSerialNumber] = serial_number;
523 }
524
index() const525 int CuttlefishConfig::InstanceSpecific::index() const {
526 int instance_index = 0;
527 for (const auto& i : config_->Instances()) {
528 if (i.serial_number() == serial_number()) {
529 break;
530 }
531 instance_index++;
532 }
533 return instance_index;
534 }
535
536 static constexpr char kVirtualDiskPaths[] = "virtual_disk_paths";
virtual_disk_paths() const537 std::vector<std::string> CuttlefishConfig::InstanceSpecific::virtual_disk_paths() const {
538 std::vector<std::string> virtual_disks;
539 auto virtual_disks_json_obj = (*Dictionary())[kVirtualDiskPaths];
540 for (const auto& disk : virtual_disks_json_obj) {
541 virtual_disks.push_back(disk.asString());
542 }
543 return virtual_disks;
544 }
set_virtual_disk_paths(const std::vector<std::string> & virtual_disk_paths)545 void CuttlefishConfig::MutableInstanceSpecific::set_virtual_disk_paths(
546 const std::vector<std::string>& virtual_disk_paths) {
547 Json::Value virtual_disks_json_obj(Json::arrayValue);
548 for (const auto& arg : virtual_disk_paths) {
549 virtual_disks_json_obj.append(arg);
550 }
551 (*Dictionary())[kVirtualDiskPaths] = virtual_disks_json_obj;
552 }
553
554 static constexpr char kGuestAndroidVersion[] = "guest_android_version";
guest_android_version() const555 std::string CuttlefishConfig::InstanceSpecific::guest_android_version() const {
556 return (*Dictionary())[kGuestAndroidVersion].asString();
557 }
set_guest_android_version(const std::string & guest_android_version)558 void CuttlefishConfig::MutableInstanceSpecific::set_guest_android_version(
559 const std::string& guest_android_version) {
560 (*Dictionary())[kGuestAndroidVersion] = guest_android_version;
561 }
562
563 static constexpr char kBootconfigSupported[] = "bootconfig_supported";
bootconfig_supported() const564 bool CuttlefishConfig::InstanceSpecific::bootconfig_supported() const {
565 return (*Dictionary())[kBootconfigSupported].asBool();
566 }
set_bootconfig_supported(bool bootconfig_supported)567 void CuttlefishConfig::MutableInstanceSpecific::set_bootconfig_supported(
568 bool bootconfig_supported) {
569 (*Dictionary())[kBootconfigSupported] = bootconfig_supported;
570 }
571
572 static constexpr char kFilenameEncryptionMode[] = "filename_encryption_mode";
filename_encryption_mode() const573 std::string CuttlefishConfig::InstanceSpecific::filename_encryption_mode() const {
574 return (*Dictionary())[kFilenameEncryptionMode].asString();
575 }
set_filename_encryption_mode(const std::string & filename_encryption_mode)576 void CuttlefishConfig::MutableInstanceSpecific::set_filename_encryption_mode(
577 const std::string& filename_encryption_mode) {
578 auto fmt = filename_encryption_mode;
579 std::transform(fmt.begin(), fmt.end(), fmt.begin(), ::tolower);
580 (*Dictionary())[kFilenameEncryptionMode] = fmt;
581 }
582
583 static constexpr char kExternalNetworkMode[] = "external_network_mode";
external_network_mode() const584 ExternalNetworkMode CuttlefishConfig::InstanceSpecific::external_network_mode()
585 const {
586 auto str = (*Dictionary())[kExternalNetworkMode].asString();
587 return ParseExternalNetworkMode(str).value_or(ExternalNetworkMode::kUnknown);
588 }
set_external_network_mode(ExternalNetworkMode mode)589 void CuttlefishConfig::MutableInstanceSpecific::set_external_network_mode(
590 ExternalNetworkMode mode) {
591 (*Dictionary())[kExternalNetworkMode] = fmt::format("{}", mode);
592 }
593
kernel_log_pipe_name() const594 std::string CuttlefishConfig::InstanceSpecific::kernel_log_pipe_name() const {
595 return AbsolutePath(PerInstanceInternalPath("kernel-log-pipe"));
596 }
597
console_pipe_prefix() const598 std::string CuttlefishConfig::InstanceSpecific::console_pipe_prefix() const {
599 return AbsolutePath(PerInstanceInternalPath("console"));
600 }
601
console_in_pipe_name() const602 std::string CuttlefishConfig::InstanceSpecific::console_in_pipe_name() const {
603 return console_pipe_prefix() + ".in";
604 }
605
console_out_pipe_name() const606 std::string CuttlefishConfig::InstanceSpecific::console_out_pipe_name() const {
607 return console_pipe_prefix() + ".out";
608 }
609
gnss_pipe_prefix() const610 std::string CuttlefishConfig::InstanceSpecific::gnss_pipe_prefix() const {
611 return AbsolutePath(PerInstanceInternalPath("gnss"));
612 }
613
gnss_in_pipe_name() const614 std::string CuttlefishConfig::InstanceSpecific::gnss_in_pipe_name() const {
615 return gnss_pipe_prefix() + ".in";
616 }
617
gnss_out_pipe_name() const618 std::string CuttlefishConfig::InstanceSpecific::gnss_out_pipe_name() const {
619 return gnss_pipe_prefix() + ".out";
620 }
621
622 static constexpr char kGnssGrpcProxyServerPort[] =
623 "gnss_grpc_proxy_server_port";
gnss_grpc_proxy_server_port() const624 int CuttlefishConfig::InstanceSpecific::gnss_grpc_proxy_server_port() const {
625 return (*Dictionary())[kGnssGrpcProxyServerPort].asInt();
626 }
set_gnss_grpc_proxy_server_port(int gnss_grpc_proxy_server_port)627 void CuttlefishConfig::MutableInstanceSpecific::set_gnss_grpc_proxy_server_port(
628 int gnss_grpc_proxy_server_port) {
629 (*Dictionary())[kGnssGrpcProxyServerPort] = gnss_grpc_proxy_server_port;
630 }
631
632 static constexpr char kGnssFilePath[] = "gnss_file_path";
gnss_file_path() const633 std::string CuttlefishConfig::InstanceSpecific::gnss_file_path() const {
634 return (*Dictionary())[kGnssFilePath].asString();
635 }
set_gnss_file_path(const std::string & gnss_file_path)636 void CuttlefishConfig::MutableInstanceSpecific::set_gnss_file_path(
637 const std::string& gnss_file_path) {
638 (*Dictionary())[kGnssFilePath] = gnss_file_path;
639 }
640
641 static constexpr char kFixedLocationFilePath[] = "fixed_location_file_path";
fixed_location_file_path() const642 std::string CuttlefishConfig::InstanceSpecific::fixed_location_file_path()
643 const {
644 return (*Dictionary())[kFixedLocationFilePath].asString();
645 }
set_fixed_location_file_path(const std::string & fixed_location_file_path)646 void CuttlefishConfig::MutableInstanceSpecific::set_fixed_location_file_path(
647 const std::string& fixed_location_file_path) {
648 (*Dictionary())[kFixedLocationFilePath] = fixed_location_file_path;
649 }
650
651 static constexpr char kGem5BinaryDir[] = "gem5_binary_dir";
gem5_binary_dir() const652 std::string CuttlefishConfig::InstanceSpecific::gem5_binary_dir() const {
653 return (*Dictionary())[kGem5BinaryDir].asString();
654 }
set_gem5_binary_dir(const std::string & gem5_binary_dir)655 void CuttlefishConfig::MutableInstanceSpecific::set_gem5_binary_dir(
656 const std::string& gem5_binary_dir) {
657 (*Dictionary())[kGem5BinaryDir] = gem5_binary_dir;
658 }
659
660 static constexpr char kGem5CheckpointDir[] = "gem5_checkpoint_dir";
gem5_checkpoint_dir() const661 std::string CuttlefishConfig::InstanceSpecific::gem5_checkpoint_dir() const {
662 return (*Dictionary())[kGem5CheckpointDir].asString();
663 }
set_gem5_checkpoint_dir(const std::string & gem5_checkpoint_dir)664 void CuttlefishConfig::MutableInstanceSpecific::set_gem5_checkpoint_dir(
665 const std::string& gem5_checkpoint_dir) {
666 (*Dictionary())[kGem5CheckpointDir] = gem5_checkpoint_dir;
667 }
668
669 static constexpr char kKgdb[] = "kgdb";
set_kgdb(bool kgdb)670 void CuttlefishConfig::MutableInstanceSpecific::set_kgdb(bool kgdb) {
671 (*Dictionary())[kKgdb] = kgdb;
672 }
kgdb() const673 bool CuttlefishConfig::InstanceSpecific::kgdb() const {
674 return (*Dictionary())[kKgdb].asBool();
675 }
676
677 static constexpr char kCpus[] = "cpus";
set_cpus(int cpus)678 void CuttlefishConfig::MutableInstanceSpecific::set_cpus(int cpus) { (*Dictionary())[kCpus] = cpus; }
cpus() const679 int CuttlefishConfig::InstanceSpecific::cpus() const { return (*Dictionary())[kCpus].asInt(); }
680
681 static constexpr char kVcpuInfo[] = "vcpu_config_path";
set_vcpu_config_path(const std::string & vcpu_config_path)682 void CuttlefishConfig::MutableInstanceSpecific::set_vcpu_config_path(
683 const std::string& vcpu_config_path) {
684 (*Dictionary())[kVcpuInfo] = vcpu_config_path;
685 }
vcpu_config_path() const686 std::string CuttlefishConfig::InstanceSpecific::vcpu_config_path() const {
687 return (*Dictionary())[kVcpuInfo].asString();
688 }
689
690 static constexpr char kDataPolicy[] = "data_policy";
set_data_policy(const std::string & data_policy)691 void CuttlefishConfig::MutableInstanceSpecific::set_data_policy(
692 const std::string& data_policy) {
693 (*Dictionary())[kDataPolicy] = data_policy;
694 }
data_policy() const695 std::string CuttlefishConfig::InstanceSpecific::data_policy() const {
696 return (*Dictionary())[kDataPolicy].asString();
697 }
698
699 static constexpr char kBlankDataImageMb[] = "blank_data_image_mb";
set_blank_data_image_mb(int blank_data_image_mb)700 void CuttlefishConfig::MutableInstanceSpecific::set_blank_data_image_mb(
701 int blank_data_image_mb) {
702 (*Dictionary())[kBlankDataImageMb] = blank_data_image_mb;
703 }
blank_data_image_mb() const704 int CuttlefishConfig::InstanceSpecific::blank_data_image_mb() const {
705 return (*Dictionary())[kBlankDataImageMb].asInt();
706 }
707
708 static constexpr char kGdbPort[] = "gdb_port";
set_gdb_port(int port)709 void CuttlefishConfig::MutableInstanceSpecific::set_gdb_port(int port) {
710 (*Dictionary())[kGdbPort] = port;
711 }
gdb_port() const712 int CuttlefishConfig::InstanceSpecific::gdb_port() const {
713 return (*Dictionary())[kGdbPort].asInt();
714 }
715
716 static constexpr char kMemoryMb[] = "memory_mb";
memory_mb() const717 int CuttlefishConfig::InstanceSpecific::memory_mb() const {
718 return (*Dictionary())[kMemoryMb].asInt();
719 }
set_memory_mb(int memory_mb)720 void CuttlefishConfig::MutableInstanceSpecific::set_memory_mb(int memory_mb) {
721 (*Dictionary())[kMemoryMb] = memory_mb;
722 }
723
724 static constexpr char kDdrMemMb[] = "ddr_mem_mb";
ddr_mem_mb() const725 int CuttlefishConfig::InstanceSpecific::ddr_mem_mb() const {
726 return (*Dictionary())[kDdrMemMb].asInt();
727 }
set_ddr_mem_mb(int ddr_mem_mb)728 void CuttlefishConfig::MutableInstanceSpecific::set_ddr_mem_mb(int ddr_mem_mb) {
729 (*Dictionary())[kDdrMemMb] = ddr_mem_mb;
730 }
731
732 static constexpr char kSetupWizardMode[] = "setupwizard_mode";
setupwizard_mode() const733 std::string CuttlefishConfig::InstanceSpecific::setupwizard_mode() const {
734 return (*Dictionary())[kSetupWizardMode].asString();
735 }
set_setupwizard_mode(const std::string & mode)736 Result<void> CuttlefishConfig::MutableInstanceSpecific::set_setupwizard_mode(
737 const std::string& mode) {
738 CF_EXPECT(ValidateSetupWizardMode(mode),
739 "setupwizard_mode flag has invalid value: " << mode);
740 (*Dictionary())[kSetupWizardMode] = mode;
741 return {};
742 }
743
744 static constexpr char kUserdataFormat[] = "userdata_format";
userdata_format() const745 std::string CuttlefishConfig::InstanceSpecific::userdata_format() const {
746 return (*Dictionary())[kUserdataFormat].asString();
747 }
set_userdata_format(const std::string & userdata_format)748 void CuttlefishConfig::MutableInstanceSpecific::set_userdata_format(const std::string& userdata_format) {
749 auto fmt = userdata_format;
750 std::transform(fmt.begin(), fmt.end(), fmt.begin(), ::tolower);
751 (*Dictionary())[kUserdataFormat] = fmt;
752 }
753
754 static constexpr char kGuestEnforceSecurity[] = "guest_enforce_security";
set_guest_enforce_security(bool guest_enforce_security)755 void CuttlefishConfig::MutableInstanceSpecific::set_guest_enforce_security(bool guest_enforce_security) {
756 (*Dictionary())[kGuestEnforceSecurity] = guest_enforce_security;
757 }
guest_enforce_security() const758 bool CuttlefishConfig::InstanceSpecific::guest_enforce_security() const {
759 return (*Dictionary())[kGuestEnforceSecurity].asBool();
760 }
761
762 static constexpr char kUseSdcard[] = "use_sdcard";
set_use_sdcard(bool use_sdcard)763 void CuttlefishConfig::MutableInstanceSpecific::set_use_sdcard(bool use_sdcard) {
764 (*Dictionary())[kUseSdcard] = use_sdcard;
765 }
use_sdcard() const766 bool CuttlefishConfig::InstanceSpecific::use_sdcard() const {
767 return (*Dictionary())[kUseSdcard].asBool();
768 }
769
770 static constexpr char kPauseInBootloader[] = "pause_in_bootloader";
set_pause_in_bootloader(bool pause_in_bootloader)771 void CuttlefishConfig::MutableInstanceSpecific::set_pause_in_bootloader(bool pause_in_bootloader) {
772 (*Dictionary())[kPauseInBootloader] = pause_in_bootloader;
773 }
pause_in_bootloader() const774 bool CuttlefishConfig::InstanceSpecific::pause_in_bootloader() const {
775 return (*Dictionary())[kPauseInBootloader].asBool();
776 }
777
778 static constexpr char kRunAsDaemon[] = "run_as_daemon";
run_as_daemon() const779 bool CuttlefishConfig::InstanceSpecific::run_as_daemon() const {
780 return (*Dictionary())[kRunAsDaemon].asBool();
781 }
set_run_as_daemon(bool run_as_daemon)782 void CuttlefishConfig::MutableInstanceSpecific::set_run_as_daemon(bool run_as_daemon) {
783 (*Dictionary())[kRunAsDaemon] = run_as_daemon;
784 }
785
786 static constexpr char kEnableMinimalMode[] = "enable_minimal_mode";
enable_minimal_mode() const787 bool CuttlefishConfig::InstanceSpecific::enable_minimal_mode() const {
788 return (*Dictionary())[kEnableMinimalMode].asBool();
789 }
set_enable_minimal_mode(bool enable_minimal_mode)790 void CuttlefishConfig::MutableInstanceSpecific::set_enable_minimal_mode(
791 bool enable_minimal_mode) {
792 (*Dictionary())[kEnableMinimalMode] = enable_minimal_mode;
793 }
794
795 static constexpr char kRunModemSimulator[] = "enable_modem_simulator";
enable_modem_simulator() const796 bool CuttlefishConfig::InstanceSpecific::enable_modem_simulator() const {
797 return (*Dictionary())[kRunModemSimulator].asBool();
798 }
set_enable_modem_simulator(bool enable_modem_simulator)799 void CuttlefishConfig::MutableInstanceSpecific::set_enable_modem_simulator(
800 bool enable_modem_simulator) {
801 (*Dictionary())[kRunModemSimulator] = enable_modem_simulator;
802 }
803
804 static constexpr char kModemSimulatorInstanceNumber[] =
805 "modem_simulator_instance_number";
806 void CuttlefishConfig::MutableInstanceSpecific::
set_modem_simulator_instance_number(int instance_number)807 set_modem_simulator_instance_number(int instance_number) {
808 (*Dictionary())[kModemSimulatorInstanceNumber] = instance_number;
809 }
modem_simulator_instance_number() const810 int CuttlefishConfig::InstanceSpecific::modem_simulator_instance_number()
811 const {
812 return (*Dictionary())[kModemSimulatorInstanceNumber].asInt();
813 }
814
815 static constexpr char kModemSimulatorSimType[] = "modem_simulator_sim_type";
set_modem_simulator_sim_type(int sim_type)816 void CuttlefishConfig::MutableInstanceSpecific::set_modem_simulator_sim_type(
817 int sim_type) {
818 (*Dictionary())[kModemSimulatorSimType] = sim_type;
819 }
modem_simulator_sim_type() const820 int CuttlefishConfig::InstanceSpecific::modem_simulator_sim_type() const {
821 return (*Dictionary())[kModemSimulatorSimType].asInt();
822 }
823
824 static constexpr char kGpuMode[] = "gpu_mode";
gpu_mode() const825 std::string CuttlefishConfig::InstanceSpecific::gpu_mode() const {
826 return (*Dictionary())[kGpuMode].asString();
827 }
set_gpu_mode(const std::string & name)828 void CuttlefishConfig::MutableInstanceSpecific::set_gpu_mode(const std::string& name) {
829 (*Dictionary())[kGpuMode] = name;
830 }
831
832 static constexpr char kGpuAngleFeatureOverridesEnabled[] =
833 "gpu_angle_feature_overrides_enabled";
834 std::string
gpu_angle_feature_overrides_enabled() const835 CuttlefishConfig::InstanceSpecific::gpu_angle_feature_overrides_enabled()
836 const {
837 return (*Dictionary())[kGpuAngleFeatureOverridesEnabled].asString();
838 }
839 void CuttlefishConfig::MutableInstanceSpecific::
set_gpu_angle_feature_overrides_enabled(const std::string & overrides)840 set_gpu_angle_feature_overrides_enabled(const std::string& overrides) {
841 (*Dictionary())[kGpuAngleFeatureOverridesEnabled] = overrides;
842 }
843
844 static constexpr char kGpuAngleFeatureOverridesDisabled[] =
845 "gpu_angle_feature_overrides_disabled";
846 std::string
gpu_angle_feature_overrides_disabled() const847 CuttlefishConfig::InstanceSpecific::gpu_angle_feature_overrides_disabled()
848 const {
849 return (*Dictionary())[kGpuAngleFeatureOverridesDisabled].asString();
850 }
851 void CuttlefishConfig::MutableInstanceSpecific::
set_gpu_angle_feature_overrides_disabled(const std::string & overrides)852 set_gpu_angle_feature_overrides_disabled(const std::string& overrides) {
853 (*Dictionary())[kGpuAngleFeatureOverridesDisabled] = overrides;
854 }
855
856 static constexpr char kGpuCaptureBinary[] = "gpu_capture_binary";
gpu_capture_binary() const857 std::string CuttlefishConfig::InstanceSpecific::gpu_capture_binary() const {
858 return (*Dictionary())[kGpuCaptureBinary].asString();
859 }
set_gpu_capture_binary(const std::string & name)860 void CuttlefishConfig::MutableInstanceSpecific::set_gpu_capture_binary(const std::string& name) {
861 (*Dictionary())[kGpuCaptureBinary] = name;
862 }
863
864 static constexpr char kGpuGfxstreamTransport[] = "gpu_gfxstream_transport";
gpu_gfxstream_transport() const865 std::string CuttlefishConfig::InstanceSpecific::gpu_gfxstream_transport()
866 const {
867 return (*Dictionary())[kGpuGfxstreamTransport].asString();
868 }
set_gpu_gfxstream_transport(const std::string & transport)869 void CuttlefishConfig::MutableInstanceSpecific::set_gpu_gfxstream_transport(
870 const std::string& transport) {
871 (*Dictionary())[kGpuGfxstreamTransport] = transport;
872 }
873
874 static constexpr char kGpuRendererFeatures[] = "gpu_renderer_features";
gpu_renderer_features() const875 std::string CuttlefishConfig::InstanceSpecific::gpu_renderer_features() const {
876 return (*Dictionary())[kGpuRendererFeatures].asString();
877 }
set_gpu_renderer_features(const std::string & transport)878 void CuttlefishConfig::MutableInstanceSpecific::set_gpu_renderer_features(
879 const std::string& transport) {
880 (*Dictionary())[kGpuRendererFeatures] = transport;
881 }
882
883 static constexpr char kGpuContextTypes[] = "gpu_context_types";
gpu_context_types() const884 std::string CuttlefishConfig::InstanceSpecific::gpu_context_types() const {
885 return (*Dictionary())[kGpuContextTypes].asString();
886 }
set_gpu_context_types(const std::string & context_types)887 void CuttlefishConfig::MutableInstanceSpecific::set_gpu_context_types(
888 const std::string& context_types) {
889 (*Dictionary())[kGpuContextTypes] = context_types;
890 }
891
892 static constexpr char kGuestHwuiRenderer[] = "guest_hwui_renderer";
guest_hwui_renderer() const893 GuestHwuiRenderer CuttlefishConfig::InstanceSpecific::guest_hwui_renderer()
894 const {
895 auto str = (*Dictionary())[kGuestHwuiRenderer].asString();
896 return ParseGuestHwuiRenderer(str).value_or(GuestHwuiRenderer::kUnknown);
897 }
set_guest_hwui_renderer(GuestHwuiRenderer renderer)898 void CuttlefishConfig::MutableInstanceSpecific::set_guest_hwui_renderer(
899 GuestHwuiRenderer renderer) {
900 (*Dictionary())[kGuestHwuiRenderer] = ToString(renderer);
901 }
902
903 static constexpr char kGuestRendererPreload[] = "guest_renderer_preload";
904 GuestRendererPreload
guest_renderer_preload() const905 CuttlefishConfig::InstanceSpecific::guest_renderer_preload() const {
906 auto str = (*Dictionary())[kGuestRendererPreload].asString();
907 return ParseGuestRendererPreload(str).value_or(GuestRendererPreload::kAuto);
908 }
set_guest_renderer_preload(GuestRendererPreload preload)909 void CuttlefishConfig::MutableInstanceSpecific::set_guest_renderer_preload(
910 GuestRendererPreload preload) {
911 (*Dictionary())[kGuestRendererPreload] = ToString(preload);
912 }
913
914 static constexpr char kVulkanDriver[] = "guest_vulkan_driver";
guest_vulkan_driver() const915 std::string CuttlefishConfig::InstanceSpecific::guest_vulkan_driver() const {
916 return (*Dictionary())[kVulkanDriver].asString();
917 }
set_guest_vulkan_driver(const std::string & driver)918 void CuttlefishConfig::MutableInstanceSpecific::set_guest_vulkan_driver(
919 const std::string& driver) {
920 (*Dictionary())[kVulkanDriver] = driver;
921 }
922
923 static constexpr char kGuestUsesBgraFramebuffers[] =
924 "guest_uses_bgra_framebuffers";
guest_uses_bgra_framebuffers() const925 bool CuttlefishConfig::InstanceSpecific::guest_uses_bgra_framebuffers() const {
926 return (*Dictionary())[kGuestUsesBgraFramebuffers].asBool();
927 }
928 void CuttlefishConfig::MutableInstanceSpecific::
set_guest_uses_bgra_framebuffers(bool uses_bgra)929 set_guest_uses_bgra_framebuffers(bool uses_bgra) {
930 (*Dictionary())[kGuestUsesBgraFramebuffers] = uses_bgra;
931 }
932
933 static constexpr char kRestartSubprocesses[] = "restart_subprocesses";
restart_subprocesses() const934 bool CuttlefishConfig::InstanceSpecific::restart_subprocesses() const {
935 return (*Dictionary())[kRestartSubprocesses].asBool();
936 }
set_restart_subprocesses(bool restart_subprocesses)937 void CuttlefishConfig::MutableInstanceSpecific::set_restart_subprocesses(bool restart_subprocesses) {
938 (*Dictionary())[kRestartSubprocesses] = restart_subprocesses;
939 }
940
941 static constexpr char kHWComposer[] = "hwcomposer";
hwcomposer() const942 std::string CuttlefishConfig::InstanceSpecific::hwcomposer() const {
943 return (*Dictionary())[kHWComposer].asString();
944 }
set_hwcomposer(const std::string & name)945 void CuttlefishConfig::MutableInstanceSpecific::set_hwcomposer(const std::string& name) {
946 (*Dictionary())[kHWComposer] = name;
947 }
948
949 static constexpr char kEnableGpuUdmabuf[] = "enable_gpu_udmabuf";
set_enable_gpu_udmabuf(const bool enable_gpu_udmabuf)950 void CuttlefishConfig::MutableInstanceSpecific::set_enable_gpu_udmabuf(const bool enable_gpu_udmabuf) {
951 (*Dictionary())[kEnableGpuUdmabuf] = enable_gpu_udmabuf;
952 }
enable_gpu_udmabuf() const953 bool CuttlefishConfig::InstanceSpecific::enable_gpu_udmabuf() const {
954 return (*Dictionary())[kEnableGpuUdmabuf].asBool();
955 }
956
957 static constexpr char kEnableGpuVhostUser[] = "enable_gpu_vhost_user";
set_enable_gpu_vhost_user(const bool enable_gpu_vhost_user)958 void CuttlefishConfig::MutableInstanceSpecific::set_enable_gpu_vhost_user(
959 const bool enable_gpu_vhost_user) {
960 (*Dictionary())[kEnableGpuVhostUser] = enable_gpu_vhost_user;
961 }
enable_gpu_vhost_user() const962 bool CuttlefishConfig::InstanceSpecific::enable_gpu_vhost_user() const {
963 return (*Dictionary())[kEnableGpuVhostUser].asBool();
964 }
965
966 static constexpr char kEnableGpuExternalBlob[] = "enable_gpu_external_blob";
set_enable_gpu_external_blob(const bool enable_gpu_external_blob)967 void CuttlefishConfig::MutableInstanceSpecific::set_enable_gpu_external_blob(
968 const bool enable_gpu_external_blob) {
969 (*Dictionary())[kEnableGpuExternalBlob] = enable_gpu_external_blob;
970 }
enable_gpu_external_blob() const971 bool CuttlefishConfig::InstanceSpecific::enable_gpu_external_blob() const {
972 return (*Dictionary())[kEnableGpuExternalBlob].asBool();
973 }
974
975 static constexpr char kEnableGpuSystemBlob[] = "enable_gpu_system_blob";
set_enable_gpu_system_blob(const bool enable_gpu_system_blob)976 void CuttlefishConfig::MutableInstanceSpecific::set_enable_gpu_system_blob(
977 const bool enable_gpu_system_blob) {
978 (*Dictionary())[kEnableGpuSystemBlob] = enable_gpu_system_blob;
979 }
enable_gpu_system_blob() const980 bool CuttlefishConfig::InstanceSpecific::enable_gpu_system_blob() const {
981 return (*Dictionary())[kEnableGpuSystemBlob].asBool();
982 }
983
984 static constexpr char kEnableAudio[] = "enable_audio";
set_enable_audio(bool enable)985 void CuttlefishConfig::MutableInstanceSpecific::set_enable_audio(bool enable) {
986 (*Dictionary())[kEnableAudio] = enable;
987 }
enable_audio() const988 bool CuttlefishConfig::InstanceSpecific::enable_audio() const {
989 return (*Dictionary())[kEnableAudio].asBool();
990 }
991
992 static constexpr char kEnableMouse[] = "enable_mouse";
set_enable_mouse(bool enable)993 void CuttlefishConfig::MutableInstanceSpecific::set_enable_mouse(bool enable) {
994 (*Dictionary())[kEnableMouse] = enable;
995 }
enable_mouse() const996 bool CuttlefishConfig::InstanceSpecific::enable_mouse() const {
997 return (*Dictionary())[kEnableMouse].asBool();
998 }
999
1000 static constexpr char kCustomKeyboardConfig[] = "custom_keyboard_config";
set_custom_keyboard_config(const std::string & custom_keyboard_config_json_path)1001 void CuttlefishConfig::MutableInstanceSpecific::set_custom_keyboard_config(
1002 const std::string& custom_keyboard_config_json_path) {
1003 (*Dictionary())[kCustomKeyboardConfig] = custom_keyboard_config_json_path;
1004 }
1005 std::optional<std::string>
custom_keyboard_config() const1006 CuttlefishConfig::InstanceSpecific::custom_keyboard_config() const {
1007 auto value = (*Dictionary())[kCustomKeyboardConfig];
1008 if (value.isNull()) {
1009 return std::nullopt;
1010 }
1011 return value.asString();
1012 }
1013
1014 static constexpr char kDomkeyMappingConfig[] = "domkey_mapping_config";
set_domkey_mapping_config(const std::string & domkey_mapping_config_json_path)1015 void CuttlefishConfig::MutableInstanceSpecific::set_domkey_mapping_config(
1016 const std::string& domkey_mapping_config_json_path) {
1017 Json::Value domkey_config_json;
1018 Json::CharReaderBuilder builder;
1019 std::ifstream ifs(domkey_mapping_config_json_path);
1020 std::string error_message;
1021 if (!Json::parseFromStream(builder, ifs, &domkey_config_json,
1022 &error_message)) {
1023 LOG(ERROR) << "Could not read domkey config file "
1024 << domkey_mapping_config_json_path << ": " << error_message;
1025 }
1026 (*Dictionary())[kDomkeyMappingConfig] = domkey_config_json;
1027 }
domkey_mapping_config() const1028 const Json::Value& CuttlefishConfig::InstanceSpecific::domkey_mapping_config()
1029 const {
1030 return (*Dictionary())[kDomkeyMappingConfig];
1031 }
1032
1033 static constexpr char kEnableGnssGrpcProxy[] = "enable_gnss_grpc_proxy";
set_enable_gnss_grpc_proxy(const bool enable_gnss_grpc_proxy)1034 void CuttlefishConfig::MutableInstanceSpecific::set_enable_gnss_grpc_proxy(const bool enable_gnss_grpc_proxy) {
1035 (*Dictionary())[kEnableGnssGrpcProxy] = enable_gnss_grpc_proxy;
1036 }
enable_gnss_grpc_proxy() const1037 bool CuttlefishConfig::InstanceSpecific::enable_gnss_grpc_proxy() const {
1038 return (*Dictionary())[kEnableGnssGrpcProxy].asBool();
1039 }
1040
1041 static constexpr char kEnableBootAnimation[] = "enable_bootanimation";
enable_bootanimation() const1042 bool CuttlefishConfig::InstanceSpecific::enable_bootanimation() const {
1043 return (*Dictionary())[kEnableBootAnimation].asBool();
1044 }
set_enable_bootanimation(bool enable_bootanimation)1045 void CuttlefishConfig::MutableInstanceSpecific::set_enable_bootanimation(
1046 bool enable_bootanimation) {
1047 (*Dictionary())[kEnableBootAnimation] = enable_bootanimation;
1048 }
1049
1050 static constexpr char kEnableUsb[] = "enable_usb";
set_enable_usb(bool enable)1051 void CuttlefishConfig::MutableInstanceSpecific::set_enable_usb(bool enable) {
1052 (*Dictionary())[kEnableUsb] = enable;
1053 }
enable_usb() const1054 bool CuttlefishConfig::InstanceSpecific::enable_usb() const {
1055 return (*Dictionary())[kEnableUsb].asBool();
1056 }
1057
1058 static constexpr char kExtraBootconfigArgsInstanced[] = "extra_bootconfig_args";
1059 std::vector<std::string>
extra_bootconfig_args() const1060 CuttlefishConfig::InstanceSpecific::extra_bootconfig_args() const {
1061 std::string extra_bootconfig_args_str =
1062 (*Dictionary())[kExtraBootconfigArgsInstanced].asString();
1063 std::vector<std::string> bootconfig;
1064 if (!extra_bootconfig_args_str.empty()) {
1065 for (const auto& arg :
1066 android::base::Split(extra_bootconfig_args_str, " ")) {
1067 bootconfig.push_back(arg);
1068 }
1069 }
1070 return bootconfig;
1071 }
1072
set_extra_bootconfig_args(const std::string & transport)1073 void CuttlefishConfig::MutableInstanceSpecific::set_extra_bootconfig_args(
1074 const std::string& transport) {
1075 (*Dictionary())[kExtraBootconfigArgsInstanced] = transport;
1076 }
1077
1078 static constexpr char kRecordScreen[] = "record_screen";
set_record_screen(bool record_screen)1079 void CuttlefishConfig::MutableInstanceSpecific::set_record_screen(
1080 bool record_screen) {
1081 (*Dictionary())[kRecordScreen] = record_screen;
1082 }
record_screen() const1083 bool CuttlefishConfig::InstanceSpecific::record_screen() const {
1084 return (*Dictionary())[kRecordScreen].asBool();
1085 }
1086
1087 static constexpr char kGem5DebugFile[] = "gem5_debug_file";
gem5_debug_file() const1088 std::string CuttlefishConfig::InstanceSpecific::gem5_debug_file() const {
1089 return (*Dictionary())[kGem5DebugFile].asString();
1090 }
set_gem5_debug_file(const std::string & gem5_debug_file)1091 void CuttlefishConfig::MutableInstanceSpecific::set_gem5_debug_file(const std::string& gem5_debug_file) {
1092 (*Dictionary())[kGem5DebugFile] = gem5_debug_file;
1093 }
1094
1095 static constexpr char kProtectedVm[] = "protected_vm";
set_protected_vm(bool protected_vm)1096 void CuttlefishConfig::MutableInstanceSpecific::set_protected_vm(bool protected_vm) {
1097 (*Dictionary())[kProtectedVm] = protected_vm;
1098 }
protected_vm() const1099 bool CuttlefishConfig::InstanceSpecific::protected_vm() const {
1100 return (*Dictionary())[kProtectedVm].asBool();
1101 }
1102
1103 static constexpr char kMte[] = "mte";
set_mte(bool mte)1104 void CuttlefishConfig::MutableInstanceSpecific::set_mte(bool mte) {
1105 (*Dictionary())[kMte] = mte;
1106 }
mte() const1107 bool CuttlefishConfig::InstanceSpecific::mte() const {
1108 return (*Dictionary())[kMte].asBool();
1109 }
1110
1111 static constexpr char kEnableKernelLog[] = "enable_kernel_log";
set_enable_kernel_log(bool enable_kernel_log)1112 void CuttlefishConfig::MutableInstanceSpecific::set_enable_kernel_log(bool enable_kernel_log) {
1113 (*Dictionary())[kEnableKernelLog] = enable_kernel_log;
1114 }
enable_kernel_log() const1115 bool CuttlefishConfig::InstanceSpecific::enable_kernel_log() const {
1116 return (*Dictionary())[kEnableKernelLog].asBool();
1117 }
1118
1119 static constexpr char kBootSlot[] = "boot_slot";
set_boot_slot(const std::string & boot_slot)1120 void CuttlefishConfig::MutableInstanceSpecific::set_boot_slot(const std::string& boot_slot) {
1121 (*Dictionary())[kBootSlot] = boot_slot;
1122 }
boot_slot() const1123 std::string CuttlefishConfig::InstanceSpecific::boot_slot() const {
1124 return (*Dictionary())[kBootSlot].asString();
1125 }
1126
1127 static constexpr char kFailFast[] = "fail_fast";
set_fail_fast(bool fail_fast)1128 void CuttlefishConfig::MutableInstanceSpecific::set_fail_fast(bool fail_fast) {
1129 (*Dictionary())[kFailFast] = fail_fast;
1130 }
fail_fast() const1131 bool CuttlefishConfig::InstanceSpecific::fail_fast() const {
1132 return (*Dictionary())[kFailFast].asBool();
1133 }
1134
1135 static constexpr char kVhostUserBlock[] = "vhost_user_block";
set_vhost_user_block(bool block)1136 void CuttlefishConfig::MutableInstanceSpecific::set_vhost_user_block(
1137 bool block) {
1138 (*Dictionary())[kVhostUserBlock] = block;
1139 }
vhost_user_block() const1140 bool CuttlefishConfig::InstanceSpecific::vhost_user_block() const {
1141 return (*Dictionary())[kVhostUserBlock].asBool();
1142 }
1143
1144 static constexpr char kTi50[] = "ti50";
set_ti50_emulator(const std::string & ti50)1145 void CuttlefishConfig::MutableInstanceSpecific::set_ti50_emulator(
1146 const std::string& ti50) {
1147 (*Dictionary())[kTi50] = ti50;
1148 }
ti50_emulator() const1149 std::string CuttlefishConfig::InstanceSpecific::ti50_emulator() const {
1150 return (*Dictionary())[kTi50].asString();
1151 }
1152
1153 static constexpr char kEnableWebRTC[] = "enable_webrtc";
set_enable_webrtc(bool enable_webrtc)1154 void CuttlefishConfig::MutableInstanceSpecific::set_enable_webrtc(bool enable_webrtc) {
1155 (*Dictionary())[kEnableWebRTC] = enable_webrtc;
1156 }
enable_webrtc() const1157 bool CuttlefishConfig::InstanceSpecific::enable_webrtc() const {
1158 return (*Dictionary())[kEnableWebRTC].asBool();
1159 }
1160
1161 static constexpr char kWebRTCAssetsDir[] = "webrtc_assets_dir";
set_webrtc_assets_dir(const std::string & webrtc_assets_dir)1162 void CuttlefishConfig::MutableInstanceSpecific::set_webrtc_assets_dir(const std::string& webrtc_assets_dir) {
1163 (*Dictionary())[kWebRTCAssetsDir] = webrtc_assets_dir;
1164 }
webrtc_assets_dir() const1165 std::string CuttlefishConfig::InstanceSpecific::webrtc_assets_dir() const {
1166 return (*Dictionary())[kWebRTCAssetsDir].asString();
1167 }
1168
1169 static constexpr char kWebrtcTcpPortRange[] = "webrtc_tcp_port_range";
set_webrtc_tcp_port_range(std::pair<uint16_t,uint16_t> range)1170 void CuttlefishConfig::MutableInstanceSpecific::set_webrtc_tcp_port_range(
1171 std::pair<uint16_t, uint16_t> range) {
1172 Json::Value arr(Json::ValueType::arrayValue);
1173 arr[0] = range.first;
1174 arr[1] = range.second;
1175 (*Dictionary())[kWebrtcTcpPortRange] = arr;
1176 }
webrtc_tcp_port_range() const1177 std::pair<uint16_t, uint16_t> CuttlefishConfig::InstanceSpecific::webrtc_tcp_port_range() const {
1178 std::pair<uint16_t, uint16_t> ret;
1179 ret.first = (*Dictionary())[kWebrtcTcpPortRange][0].asInt();
1180 ret.second = (*Dictionary())[kWebrtcTcpPortRange][1].asInt();
1181 return ret;
1182 }
1183
1184 static constexpr char kWebrtcUdpPortRange[] = "webrtc_udp_port_range";
set_webrtc_udp_port_range(std::pair<uint16_t,uint16_t> range)1185 void CuttlefishConfig::MutableInstanceSpecific::set_webrtc_udp_port_range(
1186 std::pair<uint16_t, uint16_t> range) {
1187 Json::Value arr(Json::ValueType::arrayValue);
1188 arr[0] = range.first;
1189 arr[1] = range.second;
1190 (*Dictionary())[kWebrtcUdpPortRange] = arr;
1191 }
webrtc_udp_port_range() const1192 std::pair<uint16_t, uint16_t> CuttlefishConfig::InstanceSpecific::webrtc_udp_port_range() const {
1193 std::pair<uint16_t, uint16_t> ret;
1194 ret.first = (*Dictionary())[kWebrtcUdpPortRange][0].asInt();
1195 ret.second = (*Dictionary())[kWebrtcUdpPortRange][1].asInt();
1196 return ret;
1197 }
1198
1199 static constexpr char kGrpcConfig[] = "grpc_config";
grpc_socket_path() const1200 std::string CuttlefishConfig::InstanceSpecific::grpc_socket_path() const {
1201 return (*Dictionary())[kGrpcConfig].asString();
1202 }
1203
set_grpc_socket_path(const std::string & socket_path)1204 void CuttlefishConfig::MutableInstanceSpecific::set_grpc_socket_path(
1205 const std::string& socket_path) {
1206 (*Dictionary())[kGrpcConfig] = socket_path;
1207 }
1208
1209 static constexpr char kSmt[] = "smt";
set_smt(bool smt)1210 void CuttlefishConfig::MutableInstanceSpecific::set_smt(bool smt) {
1211 (*Dictionary())[kSmt] = smt;
1212 }
smt() const1213 bool CuttlefishConfig::InstanceSpecific::smt() const {
1214 return (*Dictionary())[kSmt].asBool();
1215 }
1216
1217 static constexpr char kCrosvmBinary[] = "crosvm_binary";
crosvm_binary() const1218 std::string CuttlefishConfig::InstanceSpecific::crosvm_binary() const {
1219 return (*Dictionary())[kCrosvmBinary].asString();
1220 }
set_crosvm_binary(const std::string & crosvm_binary)1221 void CuttlefishConfig::MutableInstanceSpecific::set_crosvm_binary(
1222 const std::string& crosvm_binary) {
1223 (*Dictionary())[kCrosvmBinary] = crosvm_binary;
1224 }
1225
SetPath(const std::string & key,const std::string & path)1226 void CuttlefishConfig::MutableInstanceSpecific::SetPath(
1227 const std::string& key, const std::string& path) {
1228 if (!path.empty()) {
1229 (*Dictionary())[key] = AbsolutePath(path);
1230 }
1231 }
1232
1233 static constexpr char kSeccompPolicyDir[] = "seccomp_policy_dir";
set_seccomp_policy_dir(const std::string & seccomp_policy_dir)1234 void CuttlefishConfig::MutableInstanceSpecific::set_seccomp_policy_dir(
1235 const std::string& seccomp_policy_dir) {
1236 if (seccomp_policy_dir.empty()) {
1237 (*Dictionary())[kSeccompPolicyDir] = seccomp_policy_dir;
1238 return;
1239 }
1240 SetPath(kSeccompPolicyDir, seccomp_policy_dir);
1241 }
seccomp_policy_dir() const1242 std::string CuttlefishConfig::InstanceSpecific::seccomp_policy_dir() const {
1243 return (*Dictionary())[kSeccompPolicyDir].asString();
1244 }
1245
1246 static constexpr char kQemuBinaryDir[] = "qemu_binary_dir";
qemu_binary_dir() const1247 std::string CuttlefishConfig::InstanceSpecific::qemu_binary_dir() const {
1248 return (*Dictionary())[kQemuBinaryDir].asString();
1249 }
set_qemu_binary_dir(const std::string & qemu_binary_dir)1250 void CuttlefishConfig::MutableInstanceSpecific::set_qemu_binary_dir(
1251 const std::string& qemu_binary_dir) {
1252 (*Dictionary())[kQemuBinaryDir] = qemu_binary_dir;
1253 }
1254
1255 static constexpr char kVhostNet[] = "vhost_net";
set_vhost_net(bool vhost_net)1256 void CuttlefishConfig::MutableInstanceSpecific::set_vhost_net(bool vhost_net) {
1257 (*Dictionary())[kVhostNet] = vhost_net;
1258 }
vhost_net() const1259 bool CuttlefishConfig::InstanceSpecific::vhost_net() const {
1260 return (*Dictionary())[kVhostNet].asBool();
1261 }
1262
1263 static constexpr char kOpenThreadNodeId[] = "openthread_node_id";
set_openthread_node_id(int node_id)1264 void CuttlefishConfig::MutableInstanceSpecific::set_openthread_node_id(int node_id) {
1265 (*Dictionary())[kOpenThreadNodeId] = node_id;
1266 }
openthread_node_id() const1267 int CuttlefishConfig::InstanceSpecific::openthread_node_id() const {
1268 return (*Dictionary())[kOpenThreadNodeId].asInt();
1269 }
1270
1271 static constexpr char kVhostUserVsock[] = "vhost_user_vsock";
set_vhost_user_vsock(bool vhost_user_vsock)1272 void CuttlefishConfig::MutableInstanceSpecific::set_vhost_user_vsock(
1273 bool vhost_user_vsock) {
1274 (*Dictionary())[kVhostUserVsock] = vhost_user_vsock;
1275 }
vhost_user_vsock() const1276 bool CuttlefishConfig::InstanceSpecific::vhost_user_vsock() const {
1277 return (*Dictionary())[kVhostUserVsock].asBool();
1278 }
1279
1280 static constexpr char kRilDns[] = "ril_dns";
set_ril_dns(const std::string & ril_dns)1281 void CuttlefishConfig::MutableInstanceSpecific::set_ril_dns(const std::string& ril_dns) {
1282 (*Dictionary())[kRilDns] = ril_dns;
1283 }
ril_dns() const1284 std::string CuttlefishConfig::InstanceSpecific::ril_dns() const {
1285 return (*Dictionary())[kRilDns].asString();
1286 }
1287
1288 static constexpr char kRilIpaddr[] = "ril_ipaddr";
set_ril_ipaddr(const std::string & ril_ipaddr)1289 void CuttlefishConfig::MutableInstanceSpecific::set_ril_ipaddr(
1290 const std::string& ril_ipaddr) {
1291 (*Dictionary())[kRilIpaddr] = ril_ipaddr;
1292 }
ril_ipaddr() const1293 std::string CuttlefishConfig::InstanceSpecific::ril_ipaddr() const {
1294 return (*Dictionary())[kRilIpaddr].asString();
1295 }
1296
1297 static constexpr char kRilGateway[] = "ril_gateway";
set_ril_gateway(const std::string & ril_gateway)1298 void CuttlefishConfig::MutableInstanceSpecific::set_ril_gateway(
1299 const std::string& ril_gateway) {
1300 (*Dictionary())[kRilGateway] = ril_gateway;
1301 }
ril_gateway() const1302 std::string CuttlefishConfig::InstanceSpecific::ril_gateway() const {
1303 return (*Dictionary())[kRilGateway].asString();
1304 }
1305
1306 static constexpr char kRilBroadcast[] = "ril_broadcast";
set_ril_broadcast(const std::string & ril_broadcast)1307 void CuttlefishConfig::MutableInstanceSpecific::set_ril_broadcast(
1308 const std::string& ril_broadcast) {
1309 (*Dictionary())[kRilBroadcast] = ril_broadcast;
1310 }
ril_broadcast() const1311 std::string CuttlefishConfig::InstanceSpecific::ril_broadcast() const {
1312 return (*Dictionary())[kRilBroadcast].asString();
1313 }
1314
1315 static constexpr char kRilPrefixlen[] = "ril_prefixlen";
set_ril_prefixlen(uint8_t ril_prefixlen)1316 void CuttlefishConfig::MutableInstanceSpecific::set_ril_prefixlen(
1317 uint8_t ril_prefixlen) {
1318 (*Dictionary())[kRilPrefixlen] = static_cast<Json::UInt>(ril_prefixlen);
1319 }
ril_prefixlen() const1320 uint8_t CuttlefishConfig::InstanceSpecific::ril_prefixlen() const {
1321 return static_cast<uint8_t>((*Dictionary())[kRilPrefixlen].asUInt());
1322 }
1323
1324 static constexpr char kDisplayConfigs[] = "display_configs";
1325 static constexpr char kXRes[] = "x_res";
1326 static constexpr char kYRes[] = "y_res";
1327 static constexpr char kDpi[] = "dpi";
1328 static constexpr char kRefreshRateHz[] = "refresh_rate_hz";
1329 static constexpr char kOverlays[] = "overlays";
1330 std::vector<CuttlefishConfig::DisplayConfig>
display_configs() const1331 CuttlefishConfig::InstanceSpecific::display_configs() const {
1332 std::vector<DisplayConfig> display_configs;
1333 for (auto& display_config_json : (*Dictionary())[kDisplayConfigs]) {
1334 DisplayConfig display_config = {};
1335 display_config.width = display_config_json[kXRes].asInt();
1336 display_config.height = display_config_json[kYRes].asInt();
1337 display_config.dpi = display_config_json[kDpi].asInt();
1338 display_config.refresh_rate_hz =
1339 display_config_json[kRefreshRateHz].asInt();
1340 display_config.overlays = display_config_json[kOverlays].asString();
1341 display_configs.emplace_back(display_config);
1342 }
1343 return display_configs;
1344 }
set_display_configs(const std::vector<DisplayConfig> & display_configs)1345 void CuttlefishConfig::MutableInstanceSpecific::set_display_configs(
1346 const std::vector<DisplayConfig>& display_configs) {
1347 Json::Value display_configs_json(Json::arrayValue);
1348
1349 for (const DisplayConfig& display_configs : display_configs) {
1350 Json::Value display_config_json(Json::objectValue);
1351 display_config_json[kXRes] = display_configs.width;
1352 display_config_json[kYRes] = display_configs.height;
1353 display_config_json[kDpi] = display_configs.dpi;
1354 display_config_json[kRefreshRateHz] = display_configs.refresh_rate_hz;
1355 display_config_json[kOverlays] = display_configs.overlays;
1356 display_configs_json.append(display_config_json);
1357 }
1358
1359 (*Dictionary())[kDisplayConfigs] = display_configs_json;
1360 }
1361
1362 static constexpr char kTouchpadConfigs[] = "touchpad_configs";
1363
Serialize(const CuttlefishConfig::TouchpadConfig & config)1364 Json::Value CuttlefishConfig::TouchpadConfig::Serialize(
1365 const CuttlefishConfig::TouchpadConfig& config) {
1366 Json::Value config_json(Json::objectValue);
1367 config_json[kXRes] = config.width;
1368 config_json[kYRes] = config.height;
1369
1370 return config_json;
1371 }
1372
Deserialize(const Json::Value & config_json)1373 CuttlefishConfig::TouchpadConfig CuttlefishConfig::TouchpadConfig::Deserialize(
1374 const Json::Value& config_json) {
1375 TouchpadConfig touchpad_config = {};
1376 touchpad_config.width = config_json[kXRes].asInt();
1377 touchpad_config.height = config_json[kYRes].asInt();
1378
1379 return touchpad_config;
1380 }
1381
1382 std::vector<CuttlefishConfig::TouchpadConfig>
touchpad_configs() const1383 CuttlefishConfig::InstanceSpecific::touchpad_configs() const {
1384 std::vector<TouchpadConfig> touchpad_configs;
1385 for (auto& touchpad_config_json : (*Dictionary())[kTouchpadConfigs]) {
1386 auto touchpad_config = TouchpadConfig::Deserialize(touchpad_config_json);
1387 touchpad_configs.emplace_back(touchpad_config);
1388 }
1389 return touchpad_configs;
1390 }
set_touchpad_configs(const std::vector<TouchpadConfig> & touchpad_configs)1391 void CuttlefishConfig::MutableInstanceSpecific::set_touchpad_configs(
1392 const std::vector<TouchpadConfig>& touchpad_configs) {
1393 Json::Value touchpad_configs_json(Json::arrayValue);
1394
1395 for (const TouchpadConfig& touchpad_config : touchpad_configs) {
1396 touchpad_configs_json.append(TouchpadConfig::Serialize(touchpad_config));
1397 }
1398
1399 (*Dictionary())[kTouchpadConfigs] = touchpad_configs_json;
1400 }
1401
1402 static constexpr char kTargetArch[] = "target_arch";
set_target_arch(Arch target_arch)1403 void CuttlefishConfig::MutableInstanceSpecific::set_target_arch(
1404 Arch target_arch) {
1405 (*Dictionary())[kTargetArch] = static_cast<int>(target_arch);
1406 }
target_arch() const1407 Arch CuttlefishConfig::InstanceSpecific::target_arch() const {
1408 return static_cast<Arch>((*Dictionary())[kTargetArch].asInt());
1409 }
1410
1411 static constexpr char kDeviceType[] = "device_type";
set_device_type(DeviceType type)1412 void CuttlefishConfig::MutableInstanceSpecific::set_device_type(
1413 DeviceType type) {
1414 (*Dictionary())[kDeviceType] = static_cast<int>(type);
1415 }
device_type() const1416 DeviceType CuttlefishConfig::InstanceSpecific::device_type() const {
1417 return static_cast<DeviceType>((*Dictionary())[kDeviceType].asInt());
1418 }
1419
1420 static constexpr char kEnableSandbox[] = "enable_sandbox";
set_enable_sandbox(const bool enable_sandbox)1421 void CuttlefishConfig::MutableInstanceSpecific::set_enable_sandbox(const bool enable_sandbox) {
1422 (*Dictionary())[kEnableSandbox] = enable_sandbox;
1423 }
enable_sandbox() const1424 bool CuttlefishConfig::InstanceSpecific::enable_sandbox() const {
1425 return (*Dictionary())[kEnableSandbox].asBool();
1426 }
1427 static constexpr char kEnableVirtiofs[] = "enable_virtiofs";
set_enable_virtiofs(const bool enable_virtiofs)1428 void CuttlefishConfig::MutableInstanceSpecific::set_enable_virtiofs(
1429 const bool enable_virtiofs) {
1430 (*Dictionary())[kEnableVirtiofs] = enable_virtiofs;
1431 }
enable_virtiofs() const1432 bool CuttlefishConfig::InstanceSpecific::enable_virtiofs() const {
1433 return (*Dictionary())[kEnableVirtiofs].asBool();
1434 }
1435 static constexpr char kConsole[] = "console";
set_console(bool console)1436 void CuttlefishConfig::MutableInstanceSpecific::set_console(bool console) {
1437 (*Dictionary())[kConsole] = console;
1438 }
console() const1439 bool CuttlefishConfig::InstanceSpecific::console() const {
1440 return (*Dictionary())[kConsole].asBool();
1441 }
console_dev() const1442 std::string CuttlefishConfig::InstanceSpecific::console_dev() const {
1443 auto can_use_virtio_console = !kgdb() && !use_bootloader();
1444 std::string console_dev;
1445 if (can_use_virtio_console || config_->vm_manager() == VmmMode::kGem5) {
1446 // If kgdb and the bootloader are disabled, the Android serial console
1447 // spawns on a virtio-console port. If the bootloader is enabled, virtio
1448 // console can't be used since uboot doesn't support it.
1449 console_dev = "hvc1";
1450 } else {
1451 // QEMU and Gem5 emulate pl011 on ARM/ARM64, but QEMU and crosvm on other
1452 // architectures emulate ns16550a/uart8250 instead.
1453 Arch target = target_arch();
1454 if ((target == Arch::Arm64 || target == Arch::Arm) &&
1455 config_->vm_manager() != VmmMode::kCrosvm) {
1456 console_dev = "ttyAMA0";
1457 } else {
1458 console_dev = "ttyS0";
1459 }
1460 }
1461 return console_dev;
1462 }
1463
logcat_pipe_name() const1464 std::string CuttlefishConfig::InstanceSpecific::logcat_pipe_name() const {
1465 return AbsolutePath(PerInstanceInternalPath("logcat-pipe"));
1466 }
1467
restore_adbd_pipe_name() const1468 std::string CuttlefishConfig::InstanceSpecific::restore_adbd_pipe_name() const {
1469 return AbsolutePath(PerInstanceInternalPath("restore-pipe-adbd"));
1470 }
1471
access_kregistry_path() const1472 std::string CuttlefishConfig::InstanceSpecific::access_kregistry_path() const {
1473 return AbsolutePath(PerInstancePath("access-kregistry"));
1474 }
1475
hwcomposer_pmem_path() const1476 std::string CuttlefishConfig::InstanceSpecific::hwcomposer_pmem_path() const {
1477 return AbsolutePath(PerInstancePath("hwcomposer-pmem"));
1478 }
1479
pstore_path() const1480 std::string CuttlefishConfig::InstanceSpecific::pstore_path() const {
1481 return AbsolutePath(PerInstancePath("pstore"));
1482 }
1483
pflash_path() const1484 std::string CuttlefishConfig::InstanceSpecific::pflash_path() const {
1485 return AbsolutePath(PerInstancePath("pflash.img"));
1486 }
1487
console_path() const1488 std::string CuttlefishConfig::InstanceSpecific::console_path() const {
1489 return AbsolutePath(PerInstancePath("console"));
1490 }
1491
logcat_path() const1492 std::string CuttlefishConfig::InstanceSpecific::logcat_path() const {
1493 return AbsolutePath(PerInstanceLogPath("logcat"));
1494 }
1495
launcher_monitor_socket_path() const1496 std::string CuttlefishConfig::InstanceSpecific::launcher_monitor_socket_path()
1497 const {
1498 return AbsolutePath(PerInstanceUdsPath("launcher_monitor.sock"));
1499 }
1500
1501 static constexpr char kModemSimulatorPorts[] = "modem_simulator_ports";
modem_simulator_ports() const1502 std::string CuttlefishConfig::InstanceSpecific::modem_simulator_ports() const {
1503 return (*Dictionary())[kModemSimulatorPorts].asString();
1504 }
set_modem_simulator_ports(const std::string & modem_simulator_ports)1505 void CuttlefishConfig::MutableInstanceSpecific::set_modem_simulator_ports(
1506 const std::string& modem_simulator_ports) {
1507 (*Dictionary())[kModemSimulatorPorts] = modem_simulator_ports;
1508 }
1509
launcher_log_path() const1510 std::string CuttlefishConfig::InstanceSpecific::launcher_log_path() const {
1511 return AbsolutePath(PerInstanceLogPath("launcher.log"));
1512 }
1513
metadata_image() const1514 std::string CuttlefishConfig::InstanceSpecific::metadata_image() const {
1515 return AbsolutePath(PerInstancePath("metadata.img"));
1516 }
1517
misc_image() const1518 std::string CuttlefishConfig::InstanceSpecific::misc_image() const {
1519 return AbsolutePath(PerInstancePath("misc.img"));
1520 }
1521
sdcard_path() const1522 std::string CuttlefishConfig::InstanceSpecific::sdcard_path() const {
1523 return AbsolutePath(PerInstancePath("sdcard.img"));
1524 }
1525
sdcard_overlay_path() const1526 std::string CuttlefishConfig::InstanceSpecific::sdcard_overlay_path() const {
1527 return AbsolutePath(PerInstancePath("sdcard_overlay.img"));
1528 }
1529
persistent_composite_disk_path() const1530 std::string CuttlefishConfig::InstanceSpecific::persistent_composite_disk_path()
1531 const {
1532 return AbsolutePath(PerInstancePath("persistent_composite.img"));
1533 }
1534
1535 std::string
persistent_composite_overlay_path() const1536 CuttlefishConfig::InstanceSpecific::persistent_composite_overlay_path() const {
1537 return AbsolutePath(PerInstancePath("persistent_composite_overlay.img"));
1538 }
1539
persistent_ap_composite_disk_path() const1540 std::string CuttlefishConfig::InstanceSpecific::persistent_ap_composite_disk_path()
1541 const {
1542 return AbsolutePath(PerInstancePath("ap_persistent_composite.img"));
1543 }
1544
1545 std::string
persistent_ap_composite_overlay_path() const1546 CuttlefishConfig::InstanceSpecific::persistent_ap_composite_overlay_path()
1547 const {
1548 return AbsolutePath(PerInstancePath("ap_persistent_composite_overlay.img"));
1549 }
1550
os_composite_disk_path() const1551 std::string CuttlefishConfig::InstanceSpecific::os_composite_disk_path()
1552 const {
1553 return AbsolutePath(PerInstancePath("os_composite.img"));
1554 }
1555
ap_composite_disk_path() const1556 std::string CuttlefishConfig::InstanceSpecific::ap_composite_disk_path()
1557 const {
1558 return AbsolutePath(PerInstancePath("ap_composite.img"));
1559 }
1560
vbmeta_path() const1561 std::string CuttlefishConfig::InstanceSpecific::vbmeta_path() const {
1562 return AbsolutePath(PerInstancePath("persistent_vbmeta.img"));
1563 }
1564
ap_vbmeta_path() const1565 std::string CuttlefishConfig::InstanceSpecific::ap_vbmeta_path() const {
1566 return AbsolutePath(PerInstancePath("ap_vbmeta.img"));
1567 }
1568
uboot_env_image_path() const1569 std::string CuttlefishConfig::InstanceSpecific::uboot_env_image_path() const {
1570 return AbsolutePath(PerInstancePath("uboot_env.img"));
1571 }
1572
ap_uboot_env_image_path() const1573 std::string CuttlefishConfig::InstanceSpecific::ap_uboot_env_image_path() const {
1574 return AbsolutePath(PerInstancePath("ap_uboot_env.img"));
1575 }
1576
chromeos_state_image() const1577 std::string CuttlefishConfig::InstanceSpecific::chromeos_state_image() const {
1578 return AbsolutePath(PerInstancePath("chromeos_state.img"));
1579 }
1580
esp_image_path() const1581 std::string CuttlefishConfig::InstanceSpecific::esp_image_path() const {
1582 return AbsolutePath(PerInstancePath("esp.img"));
1583 }
1584
ap_esp_image_path() const1585 std::string CuttlefishConfig::InstanceSpecific::ap_esp_image_path() const {
1586 return AbsolutePath(PerInstancePath("ap_esp.img"));
1587 }
1588
otheros_esp_grub_config() const1589 std::string CuttlefishConfig::InstanceSpecific::otheros_esp_grub_config() const {
1590 return AbsolutePath(PerInstancePath("grub.cfg"));
1591 }
1592
ap_esp_grub_config() const1593 std::string CuttlefishConfig::InstanceSpecific::ap_esp_grub_config() const {
1594 return AbsolutePath(PerInstancePath("ap_grub.cfg"));
1595 }
1596
1597 static constexpr char kMobileBridgeName[] = "mobile_bridge_name";
1598
audio_server_path() const1599 std::string CuttlefishConfig::InstanceSpecific::audio_server_path() const {
1600 return AbsolutePath(PerInstanceInternalUdsPath("audio_server.sock"));
1601 }
1602
boot_flow() const1603 CuttlefishConfig::InstanceSpecific::BootFlow CuttlefishConfig::InstanceSpecific::boot_flow() const {
1604 const bool android_efi_loader_flow_used = !android_efi_loader().empty();
1605
1606 const bool chromeos_disk_flow_used = !chromeos_disk().empty();
1607
1608 const bool chromeos_flow_used =
1609 !chromeos_kernel_path().empty() || !chromeos_root_image().empty();
1610
1611 const bool linux_flow_used = !linux_kernel_path().empty()
1612 || !linux_initramfs_path().empty()
1613 || !linux_root_image().empty();
1614
1615 const bool fuchsia_flow_used = !fuchsia_zedboot_path().empty()
1616 || !fuchsia_root_image().empty()
1617 || !fuchsia_multiboot_bin_path().empty();
1618
1619 if (android_efi_loader_flow_used) {
1620 return BootFlow::AndroidEfiLoader;
1621 } else if (chromeos_flow_used) {
1622 return BootFlow::ChromeOs;
1623 } else if (chromeos_disk_flow_used) {
1624 return BootFlow::ChromeOsDisk;
1625 } else if (linux_flow_used) {
1626 return BootFlow::Linux;
1627 } else if (fuchsia_flow_used) {
1628 return BootFlow::Fuchsia;
1629 } else {
1630 return BootFlow::Android;
1631 }
1632 }
1633
mobile_bridge_name() const1634 std::string CuttlefishConfig::InstanceSpecific::mobile_bridge_name() const {
1635 return (*Dictionary())[kMobileBridgeName].asString();
1636 }
set_mobile_bridge_name(const std::string & mobile_bridge_name)1637 void CuttlefishConfig::MutableInstanceSpecific::set_mobile_bridge_name(
1638 const std::string& mobile_bridge_name) {
1639 (*Dictionary())[kMobileBridgeName] = mobile_bridge_name;
1640 }
1641
1642 static constexpr char kMobileTapName[] = "mobile_tap_name";
mobile_tap_name() const1643 std::string CuttlefishConfig::InstanceSpecific::mobile_tap_name() const {
1644 return (*Dictionary())[kMobileTapName].asString();
1645 }
set_mobile_tap_name(const std::string & mobile_tap_name)1646 void CuttlefishConfig::MutableInstanceSpecific::set_mobile_tap_name(
1647 const std::string& mobile_tap_name) {
1648 (*Dictionary())[kMobileTapName] = mobile_tap_name;
1649 }
1650
1651 static constexpr char kMobileMac[] = "mobile_mac";
mobile_mac() const1652 std::string CuttlefishConfig::InstanceSpecific::mobile_mac() const {
1653 return (*Dictionary())[kMobileMac].asString();
1654 }
set_mobile_mac(const std::string & mac)1655 void CuttlefishConfig::MutableInstanceSpecific::set_mobile_mac(
1656 const std::string& mac) {
1657 (*Dictionary())[kMobileMac] = mac;
1658 }
1659
1660 // TODO(b/199103204): remove this as well when
1661 // PRODUCT_ENFORCE_MAC80211_HWSIM is removed
1662 static constexpr char kWifiTapName[] = "wifi_tap_name";
wifi_tap_name() const1663 std::string CuttlefishConfig::InstanceSpecific::wifi_tap_name() const {
1664 return (*Dictionary())[kWifiTapName].asString();
1665 }
set_wifi_tap_name(const std::string & wifi_tap_name)1666 void CuttlefishConfig::MutableInstanceSpecific::set_wifi_tap_name(
1667 const std::string& wifi_tap_name) {
1668 (*Dictionary())[kWifiTapName] = wifi_tap_name;
1669 }
1670
1671 static constexpr char kWifiBridgeName[] = "wifi_bridge_name";
wifi_bridge_name() const1672 std::string CuttlefishConfig::InstanceSpecific::wifi_bridge_name() const {
1673 return (*Dictionary())[kWifiBridgeName].asString();
1674 }
set_wifi_bridge_name(const std::string & wifi_bridge_name)1675 void CuttlefishConfig::MutableInstanceSpecific::set_wifi_bridge_name(
1676 const std::string& wifi_bridge_name) {
1677 (*Dictionary())[kWifiBridgeName] = wifi_bridge_name;
1678 }
1679
1680 static constexpr char kWifiMac[] = "wifi_mac";
wifi_mac() const1681 std::string CuttlefishConfig::InstanceSpecific::wifi_mac() const {
1682 return (*Dictionary())[kWifiMac].asString();
1683 }
set_wifi_mac(const std::string & mac)1684 void CuttlefishConfig::MutableInstanceSpecific::set_wifi_mac(
1685 const std::string& mac) {
1686 (*Dictionary())[kWifiMac] = mac;
1687 }
1688
1689 static constexpr char kUseBridgedWifiTap[] = "use_bridged_wifi_tap";
use_bridged_wifi_tap() const1690 bool CuttlefishConfig::InstanceSpecific::use_bridged_wifi_tap() const {
1691 return (*Dictionary())[kUseBridgedWifiTap].asBool();
1692 }
set_use_bridged_wifi_tap(bool use_bridged_wifi_tap)1693 void CuttlefishConfig::MutableInstanceSpecific::set_use_bridged_wifi_tap(
1694 bool use_bridged_wifi_tap) {
1695 (*Dictionary())[kUseBridgedWifiTap] = use_bridged_wifi_tap;
1696 }
1697
1698 static constexpr char kEthernetTapName[] = "ethernet_tap_name";
ethernet_tap_name() const1699 std::string CuttlefishConfig::InstanceSpecific::ethernet_tap_name() const {
1700 return (*Dictionary())[kEthernetTapName].asString();
1701 }
set_ethernet_tap_name(const std::string & ethernet_tap_name)1702 void CuttlefishConfig::MutableInstanceSpecific::set_ethernet_tap_name(
1703 const std::string& ethernet_tap_name) {
1704 (*Dictionary())[kEthernetTapName] = ethernet_tap_name;
1705 }
1706
1707 static constexpr char kEthernetBridgeName[] = "ethernet_bridge_name";
ethernet_bridge_name() const1708 std::string CuttlefishConfig::InstanceSpecific::ethernet_bridge_name() const {
1709 return (*Dictionary())[kEthernetBridgeName].asString();
1710 }
set_ethernet_bridge_name(const std::string & ethernet_bridge_name)1711 void CuttlefishConfig::MutableInstanceSpecific::set_ethernet_bridge_name(
1712 const std::string& ethernet_bridge_name) {
1713 (*Dictionary())[kEthernetBridgeName] = ethernet_bridge_name;
1714 }
1715
1716 static constexpr char kEthernetMac[] = "ethernet_mac";
ethernet_mac() const1717 std::string CuttlefishConfig::InstanceSpecific::ethernet_mac() const {
1718 return (*Dictionary())[kEthernetMac].asString();
1719 }
set_ethernet_mac(const std::string & mac)1720 void CuttlefishConfig::MutableInstanceSpecific::set_ethernet_mac(
1721 const std::string& mac) {
1722 (*Dictionary())[kEthernetMac] = mac;
1723 }
1724
1725 static constexpr char kEthernetIPV6[] = "ethernet_ipv6";
ethernet_ipv6() const1726 std::string CuttlefishConfig::InstanceSpecific::ethernet_ipv6() const {
1727 return (*Dictionary())[kEthernetIPV6].asString();
1728 }
set_ethernet_ipv6(const std::string & ip)1729 void CuttlefishConfig::MutableInstanceSpecific::set_ethernet_ipv6(
1730 const std::string& ip) {
1731 (*Dictionary())[kEthernetIPV6] = ip;
1732 }
1733
1734 static constexpr char kUseAllocd[] = "use_allocd";
use_allocd() const1735 bool CuttlefishConfig::InstanceSpecific::use_allocd() const {
1736 return (*Dictionary())[kUseAllocd].asBool();
1737 }
set_use_allocd(bool use_allocd)1738 void CuttlefishConfig::MutableInstanceSpecific::set_use_allocd(
1739 bool use_allocd) {
1740 (*Dictionary())[kUseAllocd] = use_allocd;
1741 }
1742
1743 static constexpr char kSessionId[] = "session_id";
session_id() const1744 uint32_t CuttlefishConfig::InstanceSpecific::session_id() const {
1745 return (*Dictionary())[kSessionId].asUInt();
1746 }
set_session_id(uint32_t session_id)1747 void CuttlefishConfig::MutableInstanceSpecific::set_session_id(
1748 uint32_t session_id) {
1749 (*Dictionary())[kSessionId] = session_id;
1750 }
1751
1752 static constexpr char kVsockGuestCid[] = "vsock_guest_cid";
vsock_guest_cid() const1753 int CuttlefishConfig::InstanceSpecific::vsock_guest_cid() const {
1754 return (*Dictionary())[kVsockGuestCid].asInt();
1755 }
set_vsock_guest_cid(int vsock_guest_cid)1756 void CuttlefishConfig::MutableInstanceSpecific::set_vsock_guest_cid(
1757 int vsock_guest_cid) {
1758 (*Dictionary())[kVsockGuestCid] = vsock_guest_cid;
1759 }
1760
1761 static constexpr char kVsockGuestGroup[] = "vsock_guest_group";
vsock_guest_group() const1762 std::string CuttlefishConfig::InstanceSpecific::vsock_guest_group() const {
1763 return (*Dictionary())[kVsockGuestGroup].asString();
1764 }
set_vsock_guest_group(const std::string & vsock_guest_group)1765 void CuttlefishConfig::MutableInstanceSpecific::set_vsock_guest_group(
1766 const std::string& vsock_guest_group) {
1767 (*Dictionary())[kVsockGuestGroup] = vsock_guest_group;
1768 }
1769
1770 static constexpr char kUuid[] = "uuid";
uuid() const1771 std::string CuttlefishConfig::InstanceSpecific::uuid() const {
1772 return (*Dictionary())[kUuid].asString();
1773 }
set_uuid(const std::string & uuid)1774 void CuttlefishConfig::MutableInstanceSpecific::set_uuid(const std::string& uuid) {
1775 (*Dictionary())[kUuid] = uuid;
1776 }
1777
1778 static constexpr char kEnvironmentName[] = "environment_name";
environment_name() const1779 std::string CuttlefishConfig::InstanceSpecific::environment_name() const {
1780 return (*Dictionary())[kEnvironmentName].asString();
1781 }
set_environment_name(const std::string & environment_name)1782 void CuttlefishConfig::MutableInstanceSpecific::set_environment_name(
1783 const std::string& environment_name) {
1784 (*Dictionary())[kEnvironmentName] = environment_name;
1785 }
1786
CrosvmSocketPath() const1787 std::string CuttlefishConfig::InstanceSpecific::CrosvmSocketPath() const {
1788 return PerInstanceInternalUdsPath("crosvm_control.sock");
1789 }
1790
OpenwrtCrosvmSocketPath() const1791 std::string CuttlefishConfig::InstanceSpecific::OpenwrtCrosvmSocketPath()
1792 const {
1793 return PerInstanceInternalUdsPath("ap_control.sock");
1794 }
1795
1796 static constexpr char kHostPort[] = "adb_host_port";
adb_host_port() const1797 int CuttlefishConfig::InstanceSpecific::adb_host_port() const {
1798 return (*Dictionary())[kHostPort].asInt();
1799 }
set_adb_host_port(int port)1800 void CuttlefishConfig::MutableInstanceSpecific::set_adb_host_port(int port) {
1801 (*Dictionary())[kHostPort] = port;
1802 }
1803
1804 static constexpr char kFastbootHostPort[] = "fastboot_host_port";
fastboot_host_port() const1805 int CuttlefishConfig::InstanceSpecific::fastboot_host_port() const {
1806 return (*Dictionary())[kFastbootHostPort].asInt();
1807 }
set_fastboot_host_port(int port)1808 void CuttlefishConfig::MutableInstanceSpecific::set_fastboot_host_port(int port) {
1809 (*Dictionary())[kFastbootHostPort] = port;
1810 }
1811
1812 static constexpr char kModemSimulatorId[] = "modem_simulator_host_id";
modem_simulator_host_id() const1813 int CuttlefishConfig::InstanceSpecific::modem_simulator_host_id() const {
1814 return (*Dictionary())[kModemSimulatorId].asInt();
1815 }
set_modem_simulator_host_id(int id)1816 void CuttlefishConfig::MutableInstanceSpecific::set_modem_simulator_host_id(
1817 int id) {
1818 (*Dictionary())[kModemSimulatorId] = id;
1819 }
1820
1821 static constexpr char kAdbIPAndPort[] = "adb_ip_and_port";
adb_ip_and_port() const1822 std::string CuttlefishConfig::InstanceSpecific::adb_ip_and_port() const {
1823 return (*Dictionary())[kAdbIPAndPort].asString();
1824 }
set_adb_ip_and_port(const std::string & ip_port)1825 void CuttlefishConfig::MutableInstanceSpecific::set_adb_ip_and_port(
1826 const std::string& ip_port) {
1827 (*Dictionary())[kAdbIPAndPort] = ip_port;
1828 }
1829
adb_device_name() const1830 std::string CuttlefishConfig::InstanceSpecific::adb_device_name() const {
1831 if (adb_ip_and_port() != "") {
1832 return adb_ip_and_port();
1833 }
1834 LOG(ERROR) << "no adb_mode found, returning bad device name";
1835 return "NO_ADB_MODE_SET_NO_VALID_DEVICE_NAME";
1836 }
1837
1838 static constexpr char kQemuVncServerPort[] = "qemu_vnc_server_port";
qemu_vnc_server_port() const1839 int CuttlefishConfig::InstanceSpecific::qemu_vnc_server_port() const {
1840 return (*Dictionary())[kQemuVncServerPort].asInt();
1841 }
set_qemu_vnc_server_port(int qemu_vnc_server_port)1842 void CuttlefishConfig::MutableInstanceSpecific::set_qemu_vnc_server_port(
1843 int qemu_vnc_server_port) {
1844 (*Dictionary())[kQemuVncServerPort] = qemu_vnc_server_port;
1845 }
1846
1847 static constexpr char kTombstoneReceiverPort[] = "tombstone_receiver_port";
tombstone_receiver_port() const1848 int CuttlefishConfig::InstanceSpecific::tombstone_receiver_port() const {
1849 return (*Dictionary())[kTombstoneReceiverPort].asInt();
1850 }
set_tombstone_receiver_port(int tombstone_receiver_port)1851 void CuttlefishConfig::MutableInstanceSpecific::set_tombstone_receiver_port(int tombstone_receiver_port) {
1852 (*Dictionary())[kTombstoneReceiverPort] = tombstone_receiver_port;
1853 }
1854
1855 static constexpr char kAudioControlServerPort[] = "audiocontrol_server_port";
audiocontrol_server_port() const1856 int CuttlefishConfig::InstanceSpecific::audiocontrol_server_port() const {
1857 return (*Dictionary())[kAudioControlServerPort].asInt();
1858 }
set_audiocontrol_server_port(int audiocontrol_server_port)1859 void CuttlefishConfig::MutableInstanceSpecific::set_audiocontrol_server_port(int audiocontrol_server_port) {
1860 (*Dictionary())[kAudioControlServerPort] = audiocontrol_server_port;
1861 }
1862
1863 static constexpr char kConfigServerPort[] = "config_server_port";
config_server_port() const1864 int CuttlefishConfig::InstanceSpecific::config_server_port() const {
1865 return (*Dictionary())[kConfigServerPort].asInt();
1866 }
set_config_server_port(int config_server_port)1867 void CuttlefishConfig::MutableInstanceSpecific::set_config_server_port(int config_server_port) {
1868 (*Dictionary())[kConfigServerPort] = config_server_port;
1869 }
1870
1871 static constexpr char kLightsServerPort[] = "lights_server_port";
lights_server_port() const1872 int CuttlefishConfig::InstanceSpecific::lights_server_port() const {
1873 return (*Dictionary())[kLightsServerPort].asInt();
1874 }
set_lights_server_port(int lights_server_port)1875 void CuttlefishConfig::MutableInstanceSpecific::set_lights_server_port(int lights_server_port) {
1876 (*Dictionary())[kLightsServerPort] = lights_server_port;
1877 }
1878
1879 static constexpr char kCameraServerPort[] = "camera_server_port";
camera_server_port() const1880 int CuttlefishConfig::InstanceSpecific::camera_server_port() const {
1881 return (*Dictionary())[kCameraServerPort].asInt();
1882 }
set_camera_server_port(int camera_server_port)1883 void CuttlefishConfig::MutableInstanceSpecific::set_camera_server_port(
1884 int camera_server_port) {
1885 (*Dictionary())[kCameraServerPort] = camera_server_port;
1886 }
1887
1888 static constexpr char kWebrtcDeviceId[] = "webrtc_device_id";
set_webrtc_device_id(const std::string & id)1889 void CuttlefishConfig::MutableInstanceSpecific::set_webrtc_device_id(
1890 const std::string& id) {
1891 (*Dictionary())[kWebrtcDeviceId] = id;
1892 }
webrtc_device_id() const1893 std::string CuttlefishConfig::InstanceSpecific::webrtc_device_id() const {
1894 return (*Dictionary())[kWebrtcDeviceId].asString();
1895 }
1896
1897 static constexpr char kGroupId[] = "group_id";
set_group_id(const std::string & id)1898 void CuttlefishConfig::MutableInstanceSpecific::set_group_id(
1899 const std::string& id) {
1900 (*Dictionary())[kGroupId] = id;
1901 }
group_id() const1902 std::string CuttlefishConfig::InstanceSpecific::group_id() const {
1903 return (*Dictionary())[kGroupId].asString();
1904 }
1905
1906 static constexpr char kStartSigServer[] = "webrtc_start_sig_server";
set_start_webrtc_signaling_server(bool start)1907 void CuttlefishConfig::MutableInstanceSpecific::set_start_webrtc_signaling_server(bool start) {
1908 (*Dictionary())[kStartSigServer] = start;
1909 }
start_webrtc_sig_server() const1910 bool CuttlefishConfig::InstanceSpecific::start_webrtc_sig_server() const {
1911 return (*Dictionary())[kStartSigServer].asBool();
1912 }
1913
1914 static constexpr char kStartSigServerProxy[] = "webrtc_start_sig_server_proxy";
1915 void CuttlefishConfig::MutableInstanceSpecific::
set_start_webrtc_sig_server_proxy(bool start)1916 set_start_webrtc_sig_server_proxy(bool start) {
1917 (*Dictionary())[kStartSigServerProxy] = start;
1918 }
start_webrtc_sig_server_proxy() const1919 bool CuttlefishConfig::InstanceSpecific::start_webrtc_sig_server_proxy() const {
1920 return (*Dictionary())[kStartSigServerProxy].asBool();
1921 }
1922
1923 static constexpr char kStartRootcanal[] = "start_rootcanal";
set_start_rootcanal(bool start)1924 void CuttlefishConfig::MutableInstanceSpecific::set_start_rootcanal(
1925 bool start) {
1926 (*Dictionary())[kStartRootcanal] = start;
1927 }
start_rootcanal() const1928 bool CuttlefishConfig::InstanceSpecific::start_rootcanal() const {
1929 return (*Dictionary())[kStartRootcanal].asBool();
1930 }
1931
1932 static constexpr char kStartCasimir[] = "start_casimir";
set_start_casimir(bool start)1933 void CuttlefishConfig::MutableInstanceSpecific::set_start_casimir(bool start) {
1934 (*Dictionary())[kStartCasimir] = start;
1935 }
start_casimir() const1936 bool CuttlefishConfig::InstanceSpecific::start_casimir() const {
1937 return (*Dictionary())[kStartCasimir].asBool();
1938 }
1939
1940 static constexpr char kStartPica[] = "start_pica";
set_start_pica(bool start)1941 void CuttlefishConfig::MutableInstanceSpecific::set_start_pica(
1942 bool start) {
1943 (*Dictionary())[kStartPica] = start;
1944 }
start_pica() const1945 bool CuttlefishConfig::InstanceSpecific::start_pica() const {
1946 return (*Dictionary())[kStartPica].asBool();
1947 }
1948
1949 static constexpr char kStartNetsim[] = "start_netsim";
set_start_netsim(bool start)1950 void CuttlefishConfig::MutableInstanceSpecific::set_start_netsim(bool start) {
1951 (*Dictionary())[kStartNetsim] = start;
1952 }
start_netsim() const1953 bool CuttlefishConfig::InstanceSpecific::start_netsim() const {
1954 return (*Dictionary())[kStartNetsim].asBool();
1955 }
1956
1957 // TODO(b/288987294) Remove this when separating environment is done
1958 static constexpr char kStartWmediumdInstance[] = "start_wmediumd_instance";
set_start_wmediumd_instance(bool start)1959 void CuttlefishConfig::MutableInstanceSpecific::set_start_wmediumd_instance(
1960 bool start) {
1961 (*Dictionary())[kStartWmediumdInstance] = start;
1962 }
start_wmediumd_instance() const1963 bool CuttlefishConfig::InstanceSpecific::start_wmediumd_instance() const {
1964 return (*Dictionary())[kStartWmediumdInstance].asBool();
1965 }
1966
1967 static constexpr char kMcu[] = "mcu";
set_mcu(const Json::Value & cfg)1968 void CuttlefishConfig::MutableInstanceSpecific::set_mcu(const Json::Value& cfg) {
1969 (*Dictionary())[kMcu] = cfg;
1970 }
mcu() const1971 const Json::Value& CuttlefishConfig::InstanceSpecific::mcu() const {
1972 return (*Dictionary())[kMcu];
1973 }
1974
1975 static constexpr char kApBootFlow[] = "ap_boot_flow";
set_ap_boot_flow(APBootFlow flow)1976 void CuttlefishConfig::MutableInstanceSpecific::set_ap_boot_flow(APBootFlow flow) {
1977 (*Dictionary())[kApBootFlow] = static_cast<int>(flow);
1978 }
ap_boot_flow() const1979 APBootFlow CuttlefishConfig::InstanceSpecific::ap_boot_flow() const {
1980 return static_cast<APBootFlow>((*Dictionary())[kApBootFlow].asInt());
1981 }
1982
1983 static constexpr char kCrosvmUseBalloon[] = "crosvm_use_balloon";
set_crosvm_use_balloon(const bool use_balloon)1984 void CuttlefishConfig::MutableInstanceSpecific::set_crosvm_use_balloon(
1985 const bool use_balloon) {
1986 (*Dictionary())[kCrosvmUseBalloon] = use_balloon;
1987 }
crosvm_use_balloon() const1988 bool CuttlefishConfig::InstanceSpecific::crosvm_use_balloon() const {
1989 return (*Dictionary())[kCrosvmUseBalloon].asBool();
1990 }
1991
1992 static constexpr char kCrosvmUseRng[] = "crosvm_use_rng";
set_crosvm_use_rng(const bool use_rng)1993 void CuttlefishConfig::MutableInstanceSpecific::set_crosvm_use_rng(
1994 const bool use_rng) {
1995 (*Dictionary())[kCrosvmUseRng] = use_rng;
1996 }
crosvm_use_rng() const1997 bool CuttlefishConfig::InstanceSpecific::crosvm_use_rng() const {
1998 return (*Dictionary())[kCrosvmUseRng].asBool();
1999 }
2000
2001 static constexpr char kCrosvmSimpleMediaDevice[] = "crosvm_simple_media_device";
set_crosvm_simple_media_device(const bool use_media)2002 void CuttlefishConfig::MutableInstanceSpecific::set_crosvm_simple_media_device(
2003 const bool use_media) {
2004 (*Dictionary())[kCrosvmSimpleMediaDevice] = use_media;
2005 }
crosvm_simple_media_device() const2006 bool CuttlefishConfig::InstanceSpecific::crosvm_simple_media_device() const {
2007 return (*Dictionary())[kCrosvmSimpleMediaDevice].asBool();
2008 }
2009
2010 static constexpr char kCrosvmV4l2Proxy[] = "crosvm_v4l2_proxy";
set_crosvm_v4l2_proxy(const std::string v4l2_proxy)2011 void CuttlefishConfig::MutableInstanceSpecific::set_crosvm_v4l2_proxy(
2012 const std::string v4l2_proxy) {
2013 (*Dictionary())[kCrosvmV4l2Proxy] = v4l2_proxy;
2014 }
crosvm_v4l2_proxy() const2015 std::string CuttlefishConfig::InstanceSpecific::crosvm_v4l2_proxy() const {
2016 return (*Dictionary())[kCrosvmV4l2Proxy].asString();
2017 }
2018
2019 static constexpr char kCrosvmUsePmem[] = "use_pmem";
set_use_pmem(const bool use_pmem)2020 void CuttlefishConfig::MutableInstanceSpecific::set_use_pmem(
2021 const bool use_pmem) {
2022 (*Dictionary())[kCrosvmUsePmem] = use_pmem;
2023 }
use_pmem() const2024 bool CuttlefishConfig::InstanceSpecific::use_pmem() const {
2025 return (*Dictionary())[kCrosvmUsePmem].asBool();
2026 }
2027
2028 static constexpr char kEnableTapDevices[] = "enable_tap_devices";
set_enable_tap_devices(const bool enable_tap_devices)2029 void CuttlefishConfig::MutableInstanceSpecific::set_enable_tap_devices(
2030 const bool enable_tap_devices) {
2031 (*Dictionary())[kEnableTapDevices] = enable_tap_devices;
2032 }
enable_tap_devices() const2033 bool CuttlefishConfig::InstanceSpecific::enable_tap_devices() const {
2034 return (*Dictionary())[kEnableTapDevices].asBool();
2035 }
2036
touch_socket_path(int touch_dev_idx) const2037 std::string CuttlefishConfig::InstanceSpecific::touch_socket_path(
2038 int touch_dev_idx) const {
2039 return PerInstanceInternalUdsPath(
2040 ("touch_" + std::to_string(touch_dev_idx) + ".sock").c_str());
2041 }
2042
mouse_socket_path() const2043 std::string CuttlefishConfig::InstanceSpecific::mouse_socket_path() const {
2044 return PerInstanceInternalUdsPath("mouse.sock");
2045 }
2046
rotary_socket_path() const2047 std::string CuttlefishConfig::InstanceSpecific::rotary_socket_path() const {
2048 return PerInstanceInternalUdsPath("rotary.sock");
2049 }
2050
keyboard_socket_path() const2051 std::string CuttlefishConfig::InstanceSpecific::keyboard_socket_path() const {
2052 return PerInstanceInternalUdsPath("keyboard.sock");
2053 }
2054
switches_socket_path() const2055 std::string CuttlefishConfig::InstanceSpecific::switches_socket_path() const {
2056 return PerInstanceInternalUdsPath("switches.sock");
2057 }
2058
2059 static constexpr char kFrameSockPath[] = "frame_sock_path";
set_frames_socket_path(const std::string & frame_socket_path)2060 void CuttlefishConfig::MutableInstanceSpecific::set_frames_socket_path(
2061 const std::string& frame_socket_path) {
2062 (*Dictionary())[kFrameSockPath] = frame_socket_path;
2063 }
2064
frames_socket_path() const2065 std::string CuttlefishConfig::InstanceSpecific::frames_socket_path() const {
2066 return (*Dictionary())[kFrameSockPath].asString();
2067 }
2068
2069 static constexpr char kWifiMacPrefix[] = "wifi_mac_prefix";
wifi_mac_prefix() const2070 int CuttlefishConfig::InstanceSpecific::wifi_mac_prefix() const {
2071 return (*Dictionary())[kWifiMacPrefix].asInt();
2072 }
set_wifi_mac_prefix(int wifi_mac_prefix)2073 void CuttlefishConfig::MutableInstanceSpecific::set_wifi_mac_prefix(
2074 int wifi_mac_prefix) {
2075 (*Dictionary())[kWifiMacPrefix] = wifi_mac_prefix;
2076 }
2077
2078 static constexpr char kStartVhalProxyServer[] = "start_vhal_proxy_server";
set_start_vhal_proxy_server(bool start_vhal_proxy_server)2079 void CuttlefishConfig::MutableInstanceSpecific::set_start_vhal_proxy_server(
2080 bool start_vhal_proxy_server) {
2081 (*Dictionary())[kStartVhalProxyServer] = start_vhal_proxy_server;
2082 }
start_vhal_proxy_server() const2083 bool CuttlefishConfig::InstanceSpecific::start_vhal_proxy_server() const {
2084 return (*Dictionary())[kStartVhalProxyServer].asBool();
2085 }
2086
2087 static constexpr char kAudioOutputStreamsCount[] = "audio_output_streams_count";
set_audio_output_streams_count(int count)2088 void CuttlefishConfig::MutableInstanceSpecific::set_audio_output_streams_count(
2089 int count) {
2090 (*Dictionary())[kAudioOutputStreamsCount] = count;
2091 }
audio_output_streams_count() const2092 int CuttlefishConfig::InstanceSpecific::audio_output_streams_count() const {
2093 return (*Dictionary())[kAudioOutputStreamsCount].asInt();
2094 }
2095
factory_reset_protected_path() const2096 std::string CuttlefishConfig::InstanceSpecific::factory_reset_protected_path() const {
2097 return PerInstanceInternalPath("factory_reset_protected.img");
2098 }
2099
persistent_bootconfig_path() const2100 std::string CuttlefishConfig::InstanceSpecific::persistent_bootconfig_path()
2101 const {
2102 return PerInstanceInternalPath("bootconfig");
2103 }
2104
PerInstancePath(const std::string & file_name) const2105 std::string CuttlefishConfig::InstanceSpecific::PerInstancePath(
2106 const std::string& file_name) const {
2107 return (instance_dir() + "/") + file_name;
2108 }
2109
PerInstanceInternalPath(const std::string & file_name) const2110 std::string CuttlefishConfig::InstanceSpecific::PerInstanceInternalPath(
2111 const std::string& file_name) const {
2112 if (file_name[0] == '\0') {
2113 // Don't append a / if file_name is empty.
2114 return PerInstancePath(kInternalDirName);
2115 }
2116 auto relative_path = (std::string(kInternalDirName) + "/") + file_name;
2117 return PerInstancePath(relative_path.c_str());
2118 }
2119
PerInstanceUdsPath(const std::string & file_name) const2120 std::string CuttlefishConfig::InstanceSpecific::PerInstanceUdsPath(
2121 const std::string& file_name) const {
2122 return (instance_uds_dir() + "/") + file_name;
2123 }
2124
PerInstanceInternalUdsPath(const std::string & file_name) const2125 std::string CuttlefishConfig::InstanceSpecific::PerInstanceInternalUdsPath(
2126 const std::string& file_name) const {
2127 if (file_name[0] == '\0') {
2128 // Don't append a / if file_name is empty.
2129 return PerInstanceUdsPath(kInternalDirName);
2130 }
2131 auto relative_path = (std::string(kInternalDirName) + "/") + file_name;
2132 return PerInstanceUdsPath(relative_path.c_str());
2133 }
2134
PerInstanceGrpcSocketPath(const std::string & socket_name) const2135 std::string CuttlefishConfig::InstanceSpecific::PerInstanceGrpcSocketPath(
2136 const std::string& socket_name) const {
2137 if (socket_name.size() == 0) {
2138 // Don't append a / if file_name is empty.
2139 return PerInstanceUdsPath(kGrpcSocketDirName);
2140 }
2141 auto relative_path = (std::string(kGrpcSocketDirName) + "/") + socket_name;
2142 return PerInstanceUdsPath(relative_path.c_str());
2143 }
2144
PerInstanceLogPath(const std::string & file_name) const2145 std::string CuttlefishConfig::InstanceSpecific::PerInstanceLogPath(
2146 const std::string& file_name) const {
2147 if (file_name.size() == 0) {
2148 // Don't append a / if file_name is empty.
2149 return PerInstancePath(kLogDirName);
2150 }
2151 auto relative_path = (std::string(kLogDirName) + "/") + file_name;
2152 return PerInstancePath(relative_path.c_str());
2153 }
2154
instance_name() const2155 std::string CuttlefishConfig::InstanceSpecific::instance_name() const {
2156 return IdToName(id_);
2157 }
2158
id() const2159 std::string CuttlefishConfig::InstanceSpecific::id() const { return id_; }
2160
2161 } // namespace cuttlefish
2162