• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "host/libs/config/cuttlefish_config.h"
18 
19 #include <android-base/logging.h>
20 #include <json/json.h>
21 
22 #include "common/libs/utils/files.h"
23 #include "common/libs/utils/flags_validator.h"
24 #include "host/libs/vm_manager/crosvm_manager.h"
25 #include "host/libs/vm_manager/gem5_manager.h"
26 
27 namespace cuttlefish {
28 namespace {
29 
30 using APBootFlow = CuttlefishConfig::InstanceSpecific::APBootFlow;
31 
32 const char* kInstances = "instances";
33 
IdToName(const std::string & id)34 std::string IdToName(const std::string& id) { return kCvdNamePrefix + id; }
35 
36 }  // namespace
37 
38 static constexpr char kInstanceDir[] = "instance_dir";
MutableInstanceSpecific(CuttlefishConfig * config,const std::string & id)39 CuttlefishConfig::MutableInstanceSpecific::MutableInstanceSpecific(
40     CuttlefishConfig* config, const std::string& id)
41     : config_(config), id_(id) {
42   // Legacy for acloud
43   (*Dictionary())[kInstanceDir] = config_->InstancesPath(IdToName(id));
44 }
45 
Dictionary()46 Json::Value* CuttlefishConfig::MutableInstanceSpecific::Dictionary() {
47   return &(*config_->dictionary_)[kInstances][id_];
48 }
49 
Dictionary() const50 const Json::Value* CuttlefishConfig::InstanceSpecific::Dictionary() const {
51   return &(*config_->dictionary_)[kInstances][id_];
52 }
53 
instance_dir() const54 std::string CuttlefishConfig::InstanceSpecific::instance_dir() const {
55   return config_->InstancesPath(IdToName(id_));
56 }
57 
instance_internal_dir() const58 std::string CuttlefishConfig::InstanceSpecific::instance_internal_dir() const {
59   return PerInstancePath(kInternalDirName);
60 }
61 
instance_uds_dir() const62 std::string CuttlefishConfig::InstanceSpecific::instance_uds_dir() const {
63   return config_->InstancesUdsPath(IdToName(id_));
64 }
65 
instance_internal_uds_dir() const66 std::string CuttlefishConfig::InstanceSpecific::instance_internal_uds_dir()
67     const {
68   return PerInstanceUdsPath(kInternalDirName);
69 }
70 
71 // TODO (b/163575714) add virtio console support to the bootloader so the
72 // virtio console path for the console device can be taken again. When that
73 // happens, this function can be deleted along with all the code paths it
74 // forces.
use_bootloader() const75 bool CuttlefishConfig::InstanceSpecific::use_bootloader() const {
76   return true;
77 };
78 
79 // vectorized and moved system image files into instance specific
80 static constexpr char kBootImage[] = "boot_image";
boot_image() const81 std::string CuttlefishConfig::InstanceSpecific::boot_image() const {
82   return (*Dictionary())[kBootImage].asString();
83 }
set_boot_image(const std::string & boot_image)84 void CuttlefishConfig::MutableInstanceSpecific::set_boot_image(
85     const std::string& boot_image) {
86   (*Dictionary())[kBootImage] = boot_image;
87 }
88 static constexpr char kNewBootImage[] = "new_boot_image";
new_boot_image() const89 std::string CuttlefishConfig::InstanceSpecific::new_boot_image() const {
90   return (*Dictionary())[kNewBootImage].asString();
91 }
set_new_boot_image(const std::string & new_boot_image)92 void CuttlefishConfig::MutableInstanceSpecific::set_new_boot_image(
93     const std::string& new_boot_image) {
94   (*Dictionary())[kNewBootImage] = new_boot_image;
95 }
96 static constexpr char kInitBootImage[] = "init_boot_image";
init_boot_image() const97 std::string CuttlefishConfig::InstanceSpecific::init_boot_image() const {
98   return (*Dictionary())[kInitBootImage].asString();
99 }
set_init_boot_image(const std::string & init_boot_image)100 void CuttlefishConfig::MutableInstanceSpecific::set_init_boot_image(
101     const std::string& init_boot_image) {
102   (*Dictionary())[kInitBootImage] = init_boot_image;
103 }
104 static constexpr char kDataImage[] = "data_image";
data_image() const105 std::string CuttlefishConfig::InstanceSpecific::data_image() const {
106   return (*Dictionary())[kDataImage].asString();
107 }
set_data_image(const std::string & data_image)108 void CuttlefishConfig::MutableInstanceSpecific::set_data_image(
109     const std::string& data_image) {
110   (*Dictionary())[kDataImage] = data_image;
111 }
112 static constexpr char kSuperImage[] = "super_image";
super_image() const113 std::string CuttlefishConfig::InstanceSpecific::super_image() const {
114   return (*Dictionary())[kSuperImage].asString();
115 }
set_super_image(const std::string & super_image)116 void CuttlefishConfig::MutableInstanceSpecific::set_super_image(
117     const std::string& super_image) {
118   (*Dictionary())[kSuperImage] = super_image;
119 }
120 static constexpr char kNewSuperImage[] = "new_super_image";
new_super_image() const121 std::string CuttlefishConfig::InstanceSpecific::new_super_image() const {
122   return (*Dictionary())[kNewSuperImage].asString();
123 }
set_new_super_image(const std::string & super_image)124 void CuttlefishConfig::MutableInstanceSpecific::set_new_super_image(
125     const std::string& super_image) {
126   (*Dictionary())[kNewSuperImage] = super_image;
127 }
128 static constexpr char kMiscImage[] = "misc_image";
misc_image() const129 std::string CuttlefishConfig::InstanceSpecific::misc_image() const {
130   return (*Dictionary())[kMiscImage].asString();
131 }
set_misc_image(const std::string & misc_image)132 void CuttlefishConfig::MutableInstanceSpecific::set_misc_image(
133     const std::string& misc_image) {
134   (*Dictionary())[kMiscImage] = misc_image;
135 }
136 static constexpr char kNewMiscImage[] = "new_misc_image";
new_misc_image() const137 std::string CuttlefishConfig::InstanceSpecific::new_misc_image() const {
138   return (*Dictionary())[kNewMiscImage].asString();
139 }
140 static constexpr char kMiscInfoTxt[] = "misc_info_txt";
misc_info_txt() const141 std::string CuttlefishConfig::InstanceSpecific::misc_info_txt() const {
142   return (*Dictionary())[kMiscInfoTxt].asString();
143 }
set_misc_info_txt(const std::string & misc_info)144 void CuttlefishConfig::MutableInstanceSpecific::set_misc_info_txt(
145     const std::string& misc_info) {
146   (*Dictionary())[kMiscInfoTxt] = misc_info;
147 }
set_new_misc_image(const std::string & new_misc_image)148 void CuttlefishConfig::MutableInstanceSpecific::set_new_misc_image(
149     const std::string& new_misc_image) {
150   (*Dictionary())[kNewMiscImage] = new_misc_image;
151 }
152 static constexpr char kMetadataImage[] = "metadata_image";
metadata_image() const153 std::string CuttlefishConfig::InstanceSpecific::metadata_image() const {
154   return (*Dictionary())[kMetadataImage].asString();
155 }
set_metadata_image(const std::string & metadata_image)156 void CuttlefishConfig::MutableInstanceSpecific::set_metadata_image(
157     const std::string& metadata_image) {
158   (*Dictionary())[kMetadataImage] = metadata_image;
159 }
160 static constexpr char kNewMetadataImage[] = "new_metadata_image";
new_metadata_image() const161 std::string CuttlefishConfig::InstanceSpecific::new_metadata_image() const {
162   return (*Dictionary())[kNewMetadataImage].asString();
163 }
set_new_metadata_image(const std::string & new_metadata_image)164 void CuttlefishConfig::MutableInstanceSpecific::set_new_metadata_image(
165     const std::string& new_metadata_image) {
166   (*Dictionary())[kNewMetadataImage] = new_metadata_image;
167 }
168 static constexpr char kVendorBootImage[] = "vendor_boot_image";
vendor_boot_image() const169 std::string CuttlefishConfig::InstanceSpecific::vendor_boot_image() const {
170   return (*Dictionary())[kVendorBootImage].asString();
171 }
set_vendor_boot_image(const std::string & vendor_boot_image)172 void CuttlefishConfig::MutableInstanceSpecific::set_vendor_boot_image(
173     const std::string& vendor_boot_image) {
174   (*Dictionary())[kVendorBootImage] = vendor_boot_image;
175 }
176 static constexpr char kNewVendorBootImage[] = "new_vendor_boot_image";
new_vendor_boot_image() const177 std::string CuttlefishConfig::InstanceSpecific::new_vendor_boot_image() const {
178   return (*Dictionary())[kNewVendorBootImage].asString();
179 }
set_new_vendor_boot_image(const std::string & new_vendor_boot_image)180 void CuttlefishConfig::MutableInstanceSpecific::set_new_vendor_boot_image(
181     const std::string& new_vendor_boot_image) {
182   (*Dictionary())[kNewVendorBootImage] = new_vendor_boot_image;
183 }
184 static constexpr char kVbmetaImage[] = "vbmeta_image";
vbmeta_image() const185 std::string CuttlefishConfig::InstanceSpecific::vbmeta_image() const {
186   return (*Dictionary())[kVbmetaImage].asString();
187 }
set_vbmeta_image(const std::string & vbmeta_image)188 void CuttlefishConfig::MutableInstanceSpecific::set_vbmeta_image(
189     const std::string& vbmeta_image) {
190   (*Dictionary())[kVbmetaImage] = vbmeta_image;
191 }
192 static constexpr char kVbmetaSystemImage[] = "vbmeta_system_image";
vbmeta_system_image() const193 std::string CuttlefishConfig::InstanceSpecific::vbmeta_system_image() const {
194   return (*Dictionary())[kVbmetaSystemImage].asString();
195 }
set_vbmeta_system_image(const std::string & vbmeta_system_image)196 void CuttlefishConfig::MutableInstanceSpecific::set_vbmeta_system_image(
197     const std::string& vbmeta_system_image) {
198   (*Dictionary())[kVbmetaSystemImage] = vbmeta_system_image;
199 }
200 static constexpr char kVbmetaVendorDlkmImage[] = "vbmeta_vendor_dlkm_image";
vbmeta_vendor_dlkm_image() const201 std::string CuttlefishConfig::InstanceSpecific::vbmeta_vendor_dlkm_image()
202     const {
203   return (*Dictionary())[kVbmetaVendorDlkmImage].asString();
204 }
set_vbmeta_vendor_dlkm_image(const std::string & image)205 void CuttlefishConfig::MutableInstanceSpecific::set_vbmeta_vendor_dlkm_image(
206     const std::string& image) {
207   (*Dictionary())[kVbmetaVendorDlkmImage] = image;
208 }
209 static constexpr char kNewVbmetaVendorDlkmImage[] =
210     "new_vbmeta_vendor_dlkm_image";
new_vbmeta_vendor_dlkm_image() const211 std::string CuttlefishConfig::InstanceSpecific::new_vbmeta_vendor_dlkm_image()
212     const {
213   return (*Dictionary())[kNewVbmetaVendorDlkmImage].asString();
214 }
215 void CuttlefishConfig::MutableInstanceSpecific::
set_new_vbmeta_vendor_dlkm_image(const std::string & image)216     set_new_vbmeta_vendor_dlkm_image(const std::string& image) {
217   (*Dictionary())[kNewVbmetaVendorDlkmImage] = image;
218 }
219 static constexpr char kOtherosEspImage[] = "otheros_esp_image";
otheros_esp_image() const220 std::string CuttlefishConfig::InstanceSpecific::otheros_esp_image() const {
221   return (*Dictionary())[kOtherosEspImage].asString();
222 }
set_otheros_esp_image(const std::string & otheros_esp_image)223 void CuttlefishConfig::MutableInstanceSpecific::set_otheros_esp_image(
224     const std::string& otheros_esp_image) {
225   (*Dictionary())[kOtherosEspImage] = otheros_esp_image;
226 }
227 static constexpr char kLinuxKernelPath[] = "linux_kernel_path";
linux_kernel_path() const228 std::string CuttlefishConfig::InstanceSpecific::linux_kernel_path() const {
229   return (*Dictionary())[kLinuxKernelPath].asString();
230 }
set_linux_kernel_path(const std::string & linux_kernel_path)231 void CuttlefishConfig::MutableInstanceSpecific::set_linux_kernel_path(
232     const std::string& linux_kernel_path) {
233   (*Dictionary())[kLinuxKernelPath] = linux_kernel_path;
234 }
235 static constexpr char kLinuxInitramfsPath[] = "linux_initramfs_path";
linux_initramfs_path() const236 std::string CuttlefishConfig::InstanceSpecific::linux_initramfs_path() const {
237   return (*Dictionary())[kLinuxInitramfsPath].asString();
238 }
set_linux_initramfs_path(const std::string & linux_initramfs_path)239 void CuttlefishConfig::MutableInstanceSpecific::set_linux_initramfs_path(
240     const std::string& linux_initramfs_path) {
241   (*Dictionary())[kLinuxInitramfsPath] = linux_initramfs_path;
242 }
243 static constexpr char kLinuxRootImage[] = "linux_root_image";
linux_root_image() const244 std::string CuttlefishConfig::InstanceSpecific::linux_root_image() const {
245   return (*Dictionary())[kLinuxRootImage].asString();
246 }
set_linux_root_image(const std::string & linux_root_image)247 void CuttlefishConfig::MutableInstanceSpecific::set_linux_root_image(
248     const std::string& linux_root_image) {
249   (*Dictionary())[kLinuxRootImage] = linux_root_image;
250 }
251 static constexpr char kFuchsiaZedbootPath[] = "fuchsia_zedboot_path";
set_fuchsia_zedboot_path(const std::string & fuchsia_zedboot_path)252 void CuttlefishConfig::MutableInstanceSpecific::set_fuchsia_zedboot_path(
253     const std::string& fuchsia_zedboot_path) {
254   (*Dictionary())[kFuchsiaZedbootPath] = fuchsia_zedboot_path;
255 }
fuchsia_zedboot_path() const256 std::string CuttlefishConfig::InstanceSpecific::fuchsia_zedboot_path() const {
257   return (*Dictionary())[kFuchsiaZedbootPath].asString();
258 }
259 static constexpr char kFuchsiaMultibootBinPath[] = "multiboot_bin_path";
set_fuchsia_multiboot_bin_path(const std::string & fuchsia_multiboot_bin_path)260 void CuttlefishConfig::MutableInstanceSpecific::set_fuchsia_multiboot_bin_path(
261     const std::string& fuchsia_multiboot_bin_path) {
262   (*Dictionary())[kFuchsiaMultibootBinPath] = fuchsia_multiboot_bin_path;
263 }
fuchsia_multiboot_bin_path() const264 std::string CuttlefishConfig::InstanceSpecific::fuchsia_multiboot_bin_path() const {
265   return (*Dictionary())[kFuchsiaMultibootBinPath].asString();
266 }
267 static constexpr char kFuchsiaRootImage[] = "fuchsia_root_image";
set_fuchsia_root_image(const std::string & fuchsia_root_image)268 void CuttlefishConfig::MutableInstanceSpecific::set_fuchsia_root_image(
269     const std::string& fuchsia_root_image) {
270   (*Dictionary())[kFuchsiaRootImage] = fuchsia_root_image;
271 }
fuchsia_root_image() const272 std::string CuttlefishConfig::InstanceSpecific::fuchsia_root_image() const {
273   return (*Dictionary())[kFuchsiaRootImage].asString();
274 }
275 static constexpr char kCustomPartitionPath[] = "custom_partition_path";
set_custom_partition_path(const std::string & custom_partition_path)276 void CuttlefishConfig::MutableInstanceSpecific::set_custom_partition_path(
277     const std::string& custom_partition_path) {
278   (*Dictionary())[kCustomPartitionPath] = custom_partition_path;
279 }
custom_partition_path() const280 std::string CuttlefishConfig::InstanceSpecific::custom_partition_path() const {
281   return (*Dictionary())[kCustomPartitionPath].asString();
282 }
283 static constexpr char kBlankMetadataImageMb[] = "blank_metadata_image_mb";
blank_metadata_image_mb() const284 int CuttlefishConfig::InstanceSpecific::blank_metadata_image_mb() const {
285   return (*Dictionary())[kBlankMetadataImageMb].asInt();
286 }
set_blank_metadata_image_mb(int blank_metadata_image_mb)287 void CuttlefishConfig::MutableInstanceSpecific::set_blank_metadata_image_mb(
288     int blank_metadata_image_mb) {
289   (*Dictionary())[kBlankMetadataImageMb] = blank_metadata_image_mb;
290 }
291 static constexpr char kBlankSdcardImageMb[] = "blank_sdcard_image_mb";
blank_sdcard_image_mb() const292 int CuttlefishConfig::InstanceSpecific::blank_sdcard_image_mb() const {
293   return (*Dictionary())[kBlankSdcardImageMb].asInt();
294 }
set_blank_sdcard_image_mb(int blank_sdcard_image_mb)295 void CuttlefishConfig::MutableInstanceSpecific::set_blank_sdcard_image_mb(
296     int blank_sdcard_image_mb) {
297   (*Dictionary())[kBlankSdcardImageMb] = blank_sdcard_image_mb;
298 }
299 static constexpr char kBootloader[] = "bootloader";
bootloader() const300 std::string CuttlefishConfig::InstanceSpecific::bootloader() const {
301   return (*Dictionary())[kBootloader].asString();
302 }
set_bootloader(const std::string & bootloader)303 void CuttlefishConfig::MutableInstanceSpecific::set_bootloader(
304     const std::string& bootloader) {
305   (*Dictionary())[kBootloader] = bootloader;
306 }
307 static constexpr char kInitramfsPath[] = "initramfs_path";
initramfs_path() const308 std::string CuttlefishConfig::InstanceSpecific::initramfs_path() const {
309   return (*Dictionary())[kInitramfsPath].asString();
310 }
set_initramfs_path(const std::string & initramfs_path)311 void CuttlefishConfig::MutableInstanceSpecific::set_initramfs_path(
312     const std::string& initramfs_path) {
313   (*Dictionary())[kInitramfsPath] = initramfs_path;
314 }
315 static constexpr char kKernelPath[] = "kernel_path";
kernel_path() const316 std::string CuttlefishConfig::InstanceSpecific::kernel_path() const {
317   return (*Dictionary())[kKernelPath].asString();
318 }
set_kernel_path(const std::string & kernel_path)319 void CuttlefishConfig::MutableInstanceSpecific::set_kernel_path(
320     const std::string& kernel_path) {
321   (*Dictionary())[kKernelPath] = kernel_path;
322 }
323 // end of system image files
324 
325 static constexpr char kSerialNumber[] = "serial_number";
serial_number() const326 std::string CuttlefishConfig::InstanceSpecific::serial_number() const {
327   return (*Dictionary())[kSerialNumber].asString();
328 }
set_serial_number(const std::string & serial_number)329 void CuttlefishConfig::MutableInstanceSpecific::set_serial_number(
330     const std::string& serial_number) {
331   (*Dictionary())[kSerialNumber] = serial_number;
332 }
333 
334 static constexpr char kVirtualDiskPaths[] = "virtual_disk_paths";
virtual_disk_paths() const335 std::vector<std::string> CuttlefishConfig::InstanceSpecific::virtual_disk_paths() const {
336   std::vector<std::string> virtual_disks;
337   auto virtual_disks_json_obj = (*Dictionary())[kVirtualDiskPaths];
338   for (const auto& disk : virtual_disks_json_obj) {
339     virtual_disks.push_back(disk.asString());
340   }
341   return virtual_disks;
342 }
set_virtual_disk_paths(const std::vector<std::string> & virtual_disk_paths)343 void CuttlefishConfig::MutableInstanceSpecific::set_virtual_disk_paths(
344     const std::vector<std::string>& virtual_disk_paths) {
345   Json::Value virtual_disks_json_obj(Json::arrayValue);
346   for (const auto& arg : virtual_disk_paths) {
347     virtual_disks_json_obj.append(arg);
348   }
349   (*Dictionary())[kVirtualDiskPaths] = virtual_disks_json_obj;
350 }
351 
352 static constexpr char kGuestAndroidVersion[] = "guest_android_version";
guest_android_version() const353 std::string CuttlefishConfig::InstanceSpecific::guest_android_version() const {
354   return (*Dictionary())[kGuestAndroidVersion].asString();
355 }
set_guest_android_version(const std::string & guest_android_version)356 void CuttlefishConfig::MutableInstanceSpecific::set_guest_android_version(
357     const std::string& guest_android_version) {
358   (*Dictionary())[kGuestAndroidVersion] = guest_android_version;
359 }
360 
361 static constexpr char kBootconfigSupported[] = "bootconfig_supported";
bootconfig_supported() const362 bool CuttlefishConfig::InstanceSpecific::bootconfig_supported() const {
363   return (*Dictionary())[kBootconfigSupported].asBool();
364 }
set_bootconfig_supported(bool bootconfig_supported)365 void CuttlefishConfig::MutableInstanceSpecific::set_bootconfig_supported(
366     bool bootconfig_supported) {
367   (*Dictionary())[kBootconfigSupported] = bootconfig_supported;
368 }
369 
370 static constexpr char kFilenameEncryptionMode[] = "filename_encryption_mode";
filename_encryption_mode() const371 std::string CuttlefishConfig::InstanceSpecific::filename_encryption_mode() const {
372   return (*Dictionary())[kFilenameEncryptionMode].asString();
373 }
set_filename_encryption_mode(const std::string & filename_encryption_mode)374 void CuttlefishConfig::MutableInstanceSpecific::set_filename_encryption_mode(
375     const std::string& filename_encryption_mode) {
376   auto fmt = filename_encryption_mode;
377   std::transform(fmt.begin(), fmt.end(), fmt.begin(), ::tolower);
378   (*Dictionary())[kFilenameEncryptionMode] = fmt;
379 }
380 
kernel_log_pipe_name() const381 std::string CuttlefishConfig::InstanceSpecific::kernel_log_pipe_name() const {
382   return AbsolutePath(PerInstanceInternalPath("kernel-log-pipe"));
383 }
384 
console_pipe_prefix() const385 std::string CuttlefishConfig::InstanceSpecific::console_pipe_prefix() const {
386   return AbsolutePath(PerInstanceInternalPath("console"));
387 }
388 
console_in_pipe_name() const389 std::string CuttlefishConfig::InstanceSpecific::console_in_pipe_name() const {
390   return console_pipe_prefix() + ".in";
391 }
392 
console_out_pipe_name() const393 std::string CuttlefishConfig::InstanceSpecific::console_out_pipe_name() const {
394   return console_pipe_prefix() + ".out";
395 }
396 
gnss_pipe_prefix() const397 std::string CuttlefishConfig::InstanceSpecific::gnss_pipe_prefix() const {
398   return AbsolutePath(PerInstanceInternalPath("gnss"));
399 }
400 
gnss_in_pipe_name() const401 std::string CuttlefishConfig::InstanceSpecific::gnss_in_pipe_name() const {
402   return gnss_pipe_prefix() + ".in";
403 }
404 
gnss_out_pipe_name() const405 std::string CuttlefishConfig::InstanceSpecific::gnss_out_pipe_name() const {
406   return gnss_pipe_prefix() + ".out";
407 }
408 
409 static constexpr char kGnssGrpcProxyServerPort[] =
410     "gnss_grpc_proxy_server_port";
gnss_grpc_proxy_server_port() const411 int CuttlefishConfig::InstanceSpecific::gnss_grpc_proxy_server_port() const {
412   return (*Dictionary())[kGnssGrpcProxyServerPort].asInt();
413 }
set_gnss_grpc_proxy_server_port(int gnss_grpc_proxy_server_port)414 void CuttlefishConfig::MutableInstanceSpecific::set_gnss_grpc_proxy_server_port(
415     int gnss_grpc_proxy_server_port) {
416   (*Dictionary())[kGnssGrpcProxyServerPort] = gnss_grpc_proxy_server_port;
417 }
418 
419 static constexpr char kGnssFilePath[] = "gnss_file_path";
gnss_file_path() const420 std::string CuttlefishConfig::InstanceSpecific::gnss_file_path() const {
421   return (*Dictionary())[kGnssFilePath].asString();
422 }
set_gnss_file_path(const std::string & gnss_file_path)423 void CuttlefishConfig::MutableInstanceSpecific::set_gnss_file_path(
424   const std::string& gnss_file_path) {
425   (*Dictionary())[kGnssFilePath] = gnss_file_path;
426 }
427 
428 static constexpr char kFixedLocationFilePath[] = "fixed_location_file_path";
fixed_location_file_path() const429 std::string CuttlefishConfig::InstanceSpecific::fixed_location_file_path()
430     const {
431   return (*Dictionary())[kFixedLocationFilePath].asString();
432 }
set_fixed_location_file_path(const std::string & fixed_location_file_path)433 void CuttlefishConfig::MutableInstanceSpecific::set_fixed_location_file_path(
434     const std::string& fixed_location_file_path) {
435   (*Dictionary())[kFixedLocationFilePath] = fixed_location_file_path;
436 }
437 
438 static constexpr char kGem5BinaryDir[] = "gem5_binary_dir";
gem5_binary_dir() const439 std::string CuttlefishConfig::InstanceSpecific::gem5_binary_dir() const {
440   return (*Dictionary())[kGem5BinaryDir].asString();
441 }
set_gem5_binary_dir(const std::string & gem5_binary_dir)442 void CuttlefishConfig::MutableInstanceSpecific::set_gem5_binary_dir(
443     const std::string& gem5_binary_dir) {
444   (*Dictionary())[kGem5BinaryDir] = gem5_binary_dir;
445 }
446 
447 static constexpr char kGem5CheckpointDir[] = "gem5_checkpoint_dir";
gem5_checkpoint_dir() const448 std::string CuttlefishConfig::InstanceSpecific::gem5_checkpoint_dir() const {
449   return (*Dictionary())[kGem5CheckpointDir].asString();
450 }
set_gem5_checkpoint_dir(const std::string & gem5_checkpoint_dir)451 void CuttlefishConfig::MutableInstanceSpecific::set_gem5_checkpoint_dir(
452     const std::string& gem5_checkpoint_dir) {
453   (*Dictionary())[kGem5CheckpointDir] = gem5_checkpoint_dir;
454 }
455 
456 static constexpr char kKgdb[] = "kgdb";
set_kgdb(bool kgdb)457 void CuttlefishConfig::MutableInstanceSpecific::set_kgdb(bool kgdb) {
458   (*Dictionary())[kKgdb] = kgdb;
459 }
kgdb() const460 bool CuttlefishConfig::InstanceSpecific::kgdb() const {
461   return (*Dictionary())[kKgdb].asBool();
462 }
463 
464 static constexpr char kCpus[] = "cpus";
set_cpus(int cpus)465 void CuttlefishConfig::MutableInstanceSpecific::set_cpus(int cpus) { (*Dictionary())[kCpus] = cpus; }
cpus() const466 int CuttlefishConfig::InstanceSpecific::cpus() const { return (*Dictionary())[kCpus].asInt(); }
467 
468 static constexpr char kDataPolicy[] = "data_policy";
set_data_policy(const std::string & data_policy)469 void CuttlefishConfig::MutableInstanceSpecific::set_data_policy(
470     const std::string& data_policy) {
471   (*Dictionary())[kDataPolicy] = data_policy;
472 }
data_policy() const473 std::string CuttlefishConfig::InstanceSpecific::data_policy() const {
474   return (*Dictionary())[kDataPolicy].asString();
475 }
476 
477 static constexpr char kBlankDataImageMb[] = "blank_data_image_mb";
set_blank_data_image_mb(int blank_data_image_mb)478 void CuttlefishConfig::MutableInstanceSpecific::set_blank_data_image_mb(
479     int blank_data_image_mb) {
480   (*Dictionary())[kBlankDataImageMb] = blank_data_image_mb;
481 }
blank_data_image_mb() const482 int CuttlefishConfig::InstanceSpecific::blank_data_image_mb() const {
483   return (*Dictionary())[kBlankDataImageMb].asInt();
484 }
485 
486 static constexpr char kGdbPort[] = "gdb_port";
set_gdb_port(int port)487 void CuttlefishConfig::MutableInstanceSpecific::set_gdb_port(int port) {
488   (*Dictionary())[kGdbPort] = port;
489 }
gdb_port() const490 int CuttlefishConfig::InstanceSpecific::gdb_port() const {
491   return (*Dictionary())[kGdbPort].asInt();
492 }
493 
494 static constexpr char kMemoryMb[] = "memory_mb";
memory_mb() const495 int CuttlefishConfig::InstanceSpecific::memory_mb() const {
496   return (*Dictionary())[kMemoryMb].asInt();
497 }
set_memory_mb(int memory_mb)498 void CuttlefishConfig::MutableInstanceSpecific::set_memory_mb(int memory_mb) {
499   (*Dictionary())[kMemoryMb] = memory_mb;
500 }
501 
502 static constexpr char kDdrMemMb[] = "ddr_mem_mb";
ddr_mem_mb() const503 int CuttlefishConfig::InstanceSpecific::ddr_mem_mb() const {
504   return (*Dictionary())[kDdrMemMb].asInt();
505 }
set_ddr_mem_mb(int ddr_mem_mb)506 void CuttlefishConfig::MutableInstanceSpecific::set_ddr_mem_mb(int ddr_mem_mb) {
507   (*Dictionary())[kDdrMemMb] = ddr_mem_mb;
508 }
509 
510 static constexpr char kSetupWizardMode[] = "setupwizard_mode";
setupwizard_mode() const511 std::string CuttlefishConfig::InstanceSpecific::setupwizard_mode() const {
512   return (*Dictionary())[kSetupWizardMode].asString();
513 }
set_setupwizard_mode(const std::string & mode)514 Result<void> CuttlefishConfig::MutableInstanceSpecific::set_setupwizard_mode(
515     const std::string& mode) {
516   CF_EXPECT(ValidateStupWizardMode(mode),
517             "setupwizard_mode flag has invalid value: " << mode);
518   (*Dictionary())[kSetupWizardMode] = mode;
519   return {};
520 }
521 
522 static constexpr char kUserdataFormat[] = "userdata_format";
userdata_format() const523 std::string CuttlefishConfig::InstanceSpecific::userdata_format() const {
524   return (*Dictionary())[kUserdataFormat].asString();
525 }
set_userdata_format(const std::string & userdata_format)526 void CuttlefishConfig::MutableInstanceSpecific::set_userdata_format(const std::string& userdata_format) {
527   auto fmt = userdata_format;
528   std::transform(fmt.begin(), fmt.end(), fmt.begin(), ::tolower);
529   (*Dictionary())[kUserdataFormat] = fmt;
530 }
531 
532 static constexpr char kGuestEnforceSecurity[] = "guest_enforce_security";
set_guest_enforce_security(bool guest_enforce_security)533 void CuttlefishConfig::MutableInstanceSpecific::set_guest_enforce_security(bool guest_enforce_security) {
534   (*Dictionary())[kGuestEnforceSecurity] = guest_enforce_security;
535 }
guest_enforce_security() const536 bool CuttlefishConfig::InstanceSpecific::guest_enforce_security() const {
537   return (*Dictionary())[kGuestEnforceSecurity].asBool();
538 }
539 
540 static constexpr char kUseSdcard[] = "use_sdcard";
set_use_sdcard(bool use_sdcard)541 void CuttlefishConfig::MutableInstanceSpecific::set_use_sdcard(bool use_sdcard) {
542   (*Dictionary())[kUseSdcard] = use_sdcard;
543 }
use_sdcard() const544 bool CuttlefishConfig::InstanceSpecific::use_sdcard() const {
545   return (*Dictionary())[kUseSdcard].asBool();
546 }
547 
548 static constexpr char kPauseInBootloader[] = "pause_in_bootloader";
set_pause_in_bootloader(bool pause_in_bootloader)549 void CuttlefishConfig::MutableInstanceSpecific::set_pause_in_bootloader(bool pause_in_bootloader) {
550   (*Dictionary())[kPauseInBootloader] = pause_in_bootloader;
551 }
pause_in_bootloader() const552 bool CuttlefishConfig::InstanceSpecific::pause_in_bootloader() const {
553   return (*Dictionary())[kPauseInBootloader].asBool();
554 }
555 
556 static constexpr char kRunAsDaemon[] = "run_as_daemon";
run_as_daemon() const557 bool CuttlefishConfig::InstanceSpecific::run_as_daemon() const {
558   return (*Dictionary())[kRunAsDaemon].asBool();
559 }
set_run_as_daemon(bool run_as_daemon)560 void CuttlefishConfig::MutableInstanceSpecific::set_run_as_daemon(bool run_as_daemon) {
561   (*Dictionary())[kRunAsDaemon] = run_as_daemon;
562 }
563 
564 static constexpr char kEnableMinimalMode[] = "enable_minimal_mode";
enable_minimal_mode() const565 bool CuttlefishConfig::InstanceSpecific::enable_minimal_mode() const {
566   return (*Dictionary())[kEnableMinimalMode].asBool();
567 }
set_enable_minimal_mode(bool enable_minimal_mode)568 void CuttlefishConfig::MutableInstanceSpecific::set_enable_minimal_mode(
569     bool enable_minimal_mode) {
570   (*Dictionary())[kEnableMinimalMode] = enable_minimal_mode;
571 }
572 
573 static constexpr char kRunModemSimulator[] = "enable_modem_simulator";
enable_modem_simulator() const574 bool CuttlefishConfig::InstanceSpecific::enable_modem_simulator() const {
575   return (*Dictionary())[kRunModemSimulator].asBool();
576 }
set_enable_modem_simulator(bool enable_modem_simulator)577 void CuttlefishConfig::MutableInstanceSpecific::set_enable_modem_simulator(
578     bool enable_modem_simulator) {
579   (*Dictionary())[kRunModemSimulator] = enable_modem_simulator;
580 }
581 
582 static constexpr char kModemSimulatorInstanceNumber[] =
583     "modem_simulator_instance_number";
584 void CuttlefishConfig::MutableInstanceSpecific::
set_modem_simulator_instance_number(int instance_number)585     set_modem_simulator_instance_number(int instance_number) {
586   (*Dictionary())[kModemSimulatorInstanceNumber] = instance_number;
587 }
modem_simulator_instance_number() const588 int CuttlefishConfig::InstanceSpecific::modem_simulator_instance_number()
589     const {
590   return (*Dictionary())[kModemSimulatorInstanceNumber].asInt();
591 }
592 
593 static constexpr char kModemSimulatorSimType[] = "modem_simulator_sim_type";
set_modem_simulator_sim_type(int sim_type)594 void CuttlefishConfig::MutableInstanceSpecific::set_modem_simulator_sim_type(
595     int sim_type) {
596   (*Dictionary())[kModemSimulatorSimType] = sim_type;
597 }
modem_simulator_sim_type() const598 int CuttlefishConfig::InstanceSpecific::modem_simulator_sim_type() const {
599   return (*Dictionary())[kModemSimulatorSimType].asInt();
600 }
601 
602 static constexpr char kGpuMode[] = "gpu_mode";
gpu_mode() const603 std::string CuttlefishConfig::InstanceSpecific::gpu_mode() const {
604   return (*Dictionary())[kGpuMode].asString();
605 }
set_gpu_mode(const std::string & name)606 void CuttlefishConfig::MutableInstanceSpecific::set_gpu_mode(const std::string& name) {
607   (*Dictionary())[kGpuMode] = name;
608 }
609 
610 static constexpr char kGpuAngleFeatureOverridesEnabled[] =
611     "gpu_angle_feature_overrides_enabled";
612 std::string
gpu_angle_feature_overrides_enabled() const613 CuttlefishConfig::InstanceSpecific::gpu_angle_feature_overrides_enabled()
614     const {
615   return (*Dictionary())[kGpuAngleFeatureOverridesEnabled].asString();
616 }
617 void CuttlefishConfig::MutableInstanceSpecific::
set_gpu_angle_feature_overrides_enabled(const std::string & overrides)618     set_gpu_angle_feature_overrides_enabled(const std::string& overrides) {
619   (*Dictionary())[kGpuAngleFeatureOverridesEnabled] = overrides;
620 }
621 
622 static constexpr char kGpuAngleFeatureOverridesDisabled[] =
623     "gpu_angle_feature_overrides_disabled";
624 std::string
gpu_angle_feature_overrides_disabled() const625 CuttlefishConfig::InstanceSpecific::gpu_angle_feature_overrides_disabled()
626     const {
627   return (*Dictionary())[kGpuAngleFeatureOverridesDisabled].asString();
628 }
629 void CuttlefishConfig::MutableInstanceSpecific::
set_gpu_angle_feature_overrides_disabled(const std::string & overrides)630     set_gpu_angle_feature_overrides_disabled(const std::string& overrides) {
631   (*Dictionary())[kGpuAngleFeatureOverridesDisabled] = overrides;
632 }
633 
634 static constexpr char kGpuCaptureBinary[] = "gpu_capture_binary";
gpu_capture_binary() const635 std::string CuttlefishConfig::InstanceSpecific::gpu_capture_binary() const {
636   return (*Dictionary())[kGpuCaptureBinary].asString();
637 }
set_gpu_capture_binary(const std::string & name)638 void CuttlefishConfig::MutableInstanceSpecific::set_gpu_capture_binary(const std::string& name) {
639   (*Dictionary())[kGpuCaptureBinary] = name;
640 }
641 
642 static constexpr char kRestartSubprocesses[] = "restart_subprocesses";
restart_subprocesses() const643 bool CuttlefishConfig::InstanceSpecific::restart_subprocesses() const {
644   return (*Dictionary())[kRestartSubprocesses].asBool();
645 }
set_restart_subprocesses(bool restart_subprocesses)646 void CuttlefishConfig::MutableInstanceSpecific::set_restart_subprocesses(bool restart_subprocesses) {
647   (*Dictionary())[kRestartSubprocesses] = restart_subprocesses;
648 }
649 
650 static constexpr char kHWComposer[] = "hwcomposer";
hwcomposer() const651 std::string CuttlefishConfig::InstanceSpecific::hwcomposer() const {
652   return (*Dictionary())[kHWComposer].asString();
653 }
set_hwcomposer(const std::string & name)654 void CuttlefishConfig::MutableInstanceSpecific::set_hwcomposer(const std::string& name) {
655   (*Dictionary())[kHWComposer] = name;
656 }
657 
658 static constexpr char kEnableGpuUdmabuf[] = "enable_gpu_udmabuf";
set_enable_gpu_udmabuf(const bool enable_gpu_udmabuf)659 void CuttlefishConfig::MutableInstanceSpecific::set_enable_gpu_udmabuf(const bool enable_gpu_udmabuf) {
660   (*Dictionary())[kEnableGpuUdmabuf] = enable_gpu_udmabuf;
661 }
enable_gpu_udmabuf() const662 bool CuttlefishConfig::InstanceSpecific::enable_gpu_udmabuf() const {
663   return (*Dictionary())[kEnableGpuUdmabuf].asBool();
664 }
665 
666 static constexpr char kEnableAudio[] = "enable_audio";
set_enable_audio(bool enable)667 void CuttlefishConfig::MutableInstanceSpecific::set_enable_audio(bool enable) {
668   (*Dictionary())[kEnableAudio] = enable;
669 }
enable_audio() const670 bool CuttlefishConfig::InstanceSpecific::enable_audio() const {
671   return (*Dictionary())[kEnableAudio].asBool();
672 }
673 
674 static constexpr char kEnableGnssGrpcProxy[] = "enable_gnss_grpc_proxy";
set_enable_gnss_grpc_proxy(const bool enable_gnss_grpc_proxy)675 void CuttlefishConfig::MutableInstanceSpecific::set_enable_gnss_grpc_proxy(const bool enable_gnss_grpc_proxy) {
676   (*Dictionary())[kEnableGnssGrpcProxy] = enable_gnss_grpc_proxy;
677 }
enable_gnss_grpc_proxy() const678 bool CuttlefishConfig::InstanceSpecific::enable_gnss_grpc_proxy() const {
679   return (*Dictionary())[kEnableGnssGrpcProxy].asBool();
680 }
681 
682 static constexpr char kEnableBootAnimation[] = "enable_bootanimation";
enable_bootanimation() const683 bool CuttlefishConfig::InstanceSpecific::enable_bootanimation() const {
684   return (*Dictionary())[kEnableBootAnimation].asBool();
685 }
set_enable_bootanimation(bool enable_bootanimation)686 void CuttlefishConfig::MutableInstanceSpecific::set_enable_bootanimation(
687     bool enable_bootanimation) {
688   (*Dictionary())[kEnableBootAnimation] = enable_bootanimation;
689 }
690 
691 static constexpr char kRecordScreen[] = "record_screen";
set_record_screen(bool record_screen)692 void CuttlefishConfig::MutableInstanceSpecific::set_record_screen(
693     bool record_screen) {
694   (*Dictionary())[kRecordScreen] = record_screen;
695 }
record_screen() const696 bool CuttlefishConfig::InstanceSpecific::record_screen() const {
697   return (*Dictionary())[kRecordScreen].asBool();
698 }
699 
700 static constexpr char kGem5DebugFile[] = "gem5_debug_file";
gem5_debug_file() const701 std::string CuttlefishConfig::InstanceSpecific::gem5_debug_file() const {
702   return (*Dictionary())[kGem5DebugFile].asString();
703 }
set_gem5_debug_file(const std::string & gem5_debug_file)704 void CuttlefishConfig::MutableInstanceSpecific::set_gem5_debug_file(const std::string& gem5_debug_file) {
705   (*Dictionary())[kGem5DebugFile] = gem5_debug_file;
706 }
707 
708 static constexpr char kProtectedVm[] = "protected_vm";
set_protected_vm(bool protected_vm)709 void CuttlefishConfig::MutableInstanceSpecific::set_protected_vm(bool protected_vm) {
710   (*Dictionary())[kProtectedVm] = protected_vm;
711 }
protected_vm() const712 bool CuttlefishConfig::InstanceSpecific::protected_vm() const {
713   return (*Dictionary())[kProtectedVm].asBool();
714 }
715 
716 static constexpr char kMte[] = "mte";
set_mte(bool mte)717 void CuttlefishConfig::MutableInstanceSpecific::set_mte(bool mte) {
718   (*Dictionary())[kMte] = mte;
719 }
mte() const720 bool CuttlefishConfig::InstanceSpecific::mte() const {
721   return (*Dictionary())[kMte].asBool();
722 }
723 
724 static constexpr char kEnableKernelLog[] = "enable_kernel_log";
set_enable_kernel_log(bool enable_kernel_log)725 void CuttlefishConfig::MutableInstanceSpecific::set_enable_kernel_log(bool enable_kernel_log) {
726   (*Dictionary())[kEnableKernelLog] = enable_kernel_log;
727 }
enable_kernel_log() const728 bool CuttlefishConfig::InstanceSpecific::enable_kernel_log() const {
729   return (*Dictionary())[kEnableKernelLog].asBool();
730 }
731 
732 static constexpr char kBootSlot[] = "boot_slot";
set_boot_slot(const std::string & boot_slot)733 void CuttlefishConfig::MutableInstanceSpecific::set_boot_slot(const std::string& boot_slot) {
734   (*Dictionary())[kBootSlot] = boot_slot;
735 }
boot_slot() const736 std::string CuttlefishConfig::InstanceSpecific::boot_slot() const {
737   return (*Dictionary())[kBootSlot].asString();
738 }
739 
740 static constexpr char kEnableWebRTC[] = "enable_webrtc";
set_enable_webrtc(bool enable_webrtc)741 void CuttlefishConfig::MutableInstanceSpecific::set_enable_webrtc(bool enable_webrtc) {
742   (*Dictionary())[kEnableWebRTC] = enable_webrtc;
743 }
enable_webrtc() const744 bool CuttlefishConfig::InstanceSpecific::enable_webrtc() const {
745   return (*Dictionary())[kEnableWebRTC].asBool();
746 }
747 
748 static constexpr char kWebRTCAssetsDir[] = "webrtc_assets_dir";
set_webrtc_assets_dir(const std::string & webrtc_assets_dir)749 void CuttlefishConfig::MutableInstanceSpecific::set_webrtc_assets_dir(const std::string& webrtc_assets_dir) {
750   (*Dictionary())[kWebRTCAssetsDir] = webrtc_assets_dir;
751 }
webrtc_assets_dir() const752 std::string CuttlefishConfig::InstanceSpecific::webrtc_assets_dir() const {
753   return (*Dictionary())[kWebRTCAssetsDir].asString();
754 }
755 
756 static constexpr char kWebrtcTcpPortRange[] = "webrtc_tcp_port_range";
set_webrtc_tcp_port_range(std::pair<uint16_t,uint16_t> range)757 void CuttlefishConfig::MutableInstanceSpecific::set_webrtc_tcp_port_range(
758     std::pair<uint16_t, uint16_t> range) {
759   Json::Value arr(Json::ValueType::arrayValue);
760   arr[0] = range.first;
761   arr[1] = range.second;
762   (*Dictionary())[kWebrtcTcpPortRange] = arr;
763 }
webrtc_tcp_port_range() const764 std::pair<uint16_t, uint16_t> CuttlefishConfig::InstanceSpecific::webrtc_tcp_port_range() const {
765   std::pair<uint16_t, uint16_t> ret;
766   ret.first = (*Dictionary())[kWebrtcTcpPortRange][0].asInt();
767   ret.second = (*Dictionary())[kWebrtcTcpPortRange][1].asInt();
768   return ret;
769 }
770 
771 static constexpr char kWebrtcUdpPortRange[] = "webrtc_udp_port_range";
set_webrtc_udp_port_range(std::pair<uint16_t,uint16_t> range)772 void CuttlefishConfig::MutableInstanceSpecific::set_webrtc_udp_port_range(
773     std::pair<uint16_t, uint16_t> range) {
774   Json::Value arr(Json::ValueType::arrayValue);
775   arr[0] = range.first;
776   arr[1] = range.second;
777   (*Dictionary())[kWebrtcUdpPortRange] = arr;
778 }
webrtc_udp_port_range() const779 std::pair<uint16_t, uint16_t> CuttlefishConfig::InstanceSpecific::webrtc_udp_port_range() const {
780   std::pair<uint16_t, uint16_t> ret;
781   ret.first = (*Dictionary())[kWebrtcUdpPortRange][0].asInt();
782   ret.second = (*Dictionary())[kWebrtcUdpPortRange][1].asInt();
783   return ret;
784 }
785 
786 static constexpr char kGrpcConfig[] = "grpc_config";
grpc_socket_path() const787 std::string CuttlefishConfig::InstanceSpecific::grpc_socket_path() const {
788   return (*Dictionary())[kGrpcConfig].asString();
789 }
790 
set_grpc_socket_path(const std::string & socket_path)791 void CuttlefishConfig::MutableInstanceSpecific::set_grpc_socket_path(
792     const std::string& socket_path) {
793   (*Dictionary())[kGrpcConfig] = socket_path;
794 }
795 
796 static constexpr char kSmt[] = "smt";
set_smt(bool smt)797 void CuttlefishConfig::MutableInstanceSpecific::set_smt(bool smt) {
798   (*Dictionary())[kSmt] = smt;
799 }
smt() const800 bool CuttlefishConfig::InstanceSpecific::smt() const {
801   return (*Dictionary())[kSmt].asBool();
802 }
803 
804 static constexpr char kCrosvmBinary[] = "crosvm_binary";
crosvm_binary() const805 std::string CuttlefishConfig::InstanceSpecific::crosvm_binary() const {
806   return (*Dictionary())[kCrosvmBinary].asString();
807 }
set_crosvm_binary(const std::string & crosvm_binary)808 void CuttlefishConfig::MutableInstanceSpecific::set_crosvm_binary(
809     const std::string& crosvm_binary) {
810   (*Dictionary())[kCrosvmBinary] = crosvm_binary;
811 }
812 
SetPath(const std::string & key,const std::string & path)813 void CuttlefishConfig::MutableInstanceSpecific::SetPath(
814     const std::string& key, const std::string& path) {
815   if (!path.empty()) {
816     (*Dictionary())[key] = AbsolutePath(path);
817   }
818 }
819 
820 static constexpr char kSeccompPolicyDir[] = "seccomp_policy_dir";
set_seccomp_policy_dir(const std::string & seccomp_policy_dir)821 void CuttlefishConfig::MutableInstanceSpecific::set_seccomp_policy_dir(
822     const std::string& seccomp_policy_dir) {
823   if (seccomp_policy_dir.empty()) {
824     (*Dictionary())[kSeccompPolicyDir] = seccomp_policy_dir;
825     return;
826   }
827   SetPath(kSeccompPolicyDir, seccomp_policy_dir);
828 }
seccomp_policy_dir() const829 std::string CuttlefishConfig::InstanceSpecific::seccomp_policy_dir() const {
830   return (*Dictionary())[kSeccompPolicyDir].asString();
831 }
832 
833 static constexpr char kQemuBinaryDir[] = "qemu_binary_dir";
qemu_binary_dir() const834 std::string CuttlefishConfig::InstanceSpecific::qemu_binary_dir() const {
835   return (*Dictionary())[kQemuBinaryDir].asString();
836 }
set_qemu_binary_dir(const std::string & qemu_binary_dir)837 void CuttlefishConfig::MutableInstanceSpecific::set_qemu_binary_dir(
838     const std::string& qemu_binary_dir) {
839   (*Dictionary())[kQemuBinaryDir] = qemu_binary_dir;
840 }
841 
842 static constexpr char kVhostNet[] = "vhost_net";
set_vhost_net(bool vhost_net)843 void CuttlefishConfig::MutableInstanceSpecific::set_vhost_net(bool vhost_net) {
844   (*Dictionary())[kVhostNet] = vhost_net;
845 }
vhost_net() const846 bool CuttlefishConfig::InstanceSpecific::vhost_net() const {
847   return (*Dictionary())[kVhostNet].asBool();
848 }
849 
850 static constexpr char kRilDns[] = "ril_dns";
set_ril_dns(const std::string & ril_dns)851 void CuttlefishConfig::MutableInstanceSpecific::set_ril_dns(const std::string& ril_dns) {
852   (*Dictionary())[kRilDns] = ril_dns;
853 }
ril_dns() const854 std::string CuttlefishConfig::InstanceSpecific::ril_dns() const {
855   return (*Dictionary())[kRilDns].asString();
856 }
857 
858 static constexpr char kDisplayConfigs[] = "display_configs";
859 static constexpr char kXRes[] = "x_res";
860 static constexpr char kYRes[] = "y_res";
861 static constexpr char kDpi[] = "dpi";
862 static constexpr char kRefreshRateHz[] = "refresh_rate_hz";
863 std::vector<CuttlefishConfig::DisplayConfig>
display_configs() const864 CuttlefishConfig::InstanceSpecific::display_configs() const {
865   std::vector<DisplayConfig> display_configs;
866   for (auto& display_config_json : (*Dictionary())[kDisplayConfigs]) {
867     DisplayConfig display_config = {};
868     display_config.width = display_config_json[kXRes].asInt();
869     display_config.height = display_config_json[kYRes].asInt();
870     display_config.dpi = display_config_json[kDpi].asInt();
871     display_config.refresh_rate_hz =
872         display_config_json[kRefreshRateHz].asInt();
873     display_configs.emplace_back(display_config);
874   }
875   return display_configs;
876 }
set_display_configs(const std::vector<DisplayConfig> & display_configs)877 void CuttlefishConfig::MutableInstanceSpecific::set_display_configs(
878     const std::vector<DisplayConfig>& display_configs) {
879   Json::Value display_configs_json(Json::arrayValue);
880 
881   for (const DisplayConfig& display_configs : display_configs) {
882     Json::Value display_config_json(Json::objectValue);
883     display_config_json[kXRes] = display_configs.width;
884     display_config_json[kYRes] = display_configs.height;
885     display_config_json[kDpi] = display_configs.dpi;
886     display_config_json[kRefreshRateHz] = display_configs.refresh_rate_hz;
887     display_configs_json.append(display_config_json);
888   }
889 
890   (*Dictionary())[kDisplayConfigs] = display_configs_json;
891 }
892 
893 
894 static constexpr char kTargetArch[] = "target_arch";
set_target_arch(Arch target_arch)895 void CuttlefishConfig::MutableInstanceSpecific::set_target_arch(
896     Arch target_arch) {
897   (*Dictionary())[kTargetArch] = static_cast<int>(target_arch);
898 }
target_arch() const899 Arch CuttlefishConfig::InstanceSpecific::target_arch() const {
900   return static_cast<Arch>((*Dictionary())[kTargetArch].asInt());
901 }
902 
903 static constexpr char kEnableSandbox[] = "enable_sandbox";
set_enable_sandbox(const bool enable_sandbox)904 void CuttlefishConfig::MutableInstanceSpecific::set_enable_sandbox(const bool enable_sandbox) {
905   (*Dictionary())[kEnableSandbox] = enable_sandbox;
906 }
enable_sandbox() const907 bool CuttlefishConfig::InstanceSpecific::enable_sandbox() const {
908   return (*Dictionary())[kEnableSandbox].asBool();
909 }
910 static constexpr char kConsole[] = "console";
set_console(bool console)911 void CuttlefishConfig::MutableInstanceSpecific::set_console(bool console) {
912   (*Dictionary())[kConsole] = console;
913 }
console() const914 bool CuttlefishConfig::InstanceSpecific::console() const {
915   return (*Dictionary())[kConsole].asBool();
916 }
console_dev() const917 std::string CuttlefishConfig::InstanceSpecific::console_dev() const {
918   auto can_use_virtio_console = !kgdb() && !use_bootloader();
919   std::string console_dev;
920   if (can_use_virtio_console ||
921       config_->vm_manager() == vm_manager::Gem5Manager::name()) {
922     // If kgdb and the bootloader are disabled, the Android serial console
923     // spawns on a virtio-console port. If the bootloader is enabled, virtio
924     // console can't be used since uboot doesn't support it.
925     console_dev = "hvc1";
926   } else {
927     // QEMU and Gem5 emulate pl011 on ARM/ARM64, but QEMU and crosvm on other
928     // architectures emulate ns16550a/uart8250 instead.
929     Arch target = target_arch();
930     if ((target == Arch::Arm64 || target == Arch::Arm) &&
931         config_->vm_manager() != vm_manager::CrosvmManager::name()) {
932       console_dev = "ttyAMA0";
933     } else {
934       console_dev = "ttyS0";
935     }
936   }
937   return console_dev;
938 }
939 
logcat_pipe_name() const940 std::string CuttlefishConfig::InstanceSpecific::logcat_pipe_name() const {
941   return AbsolutePath(PerInstanceInternalPath("logcat-pipe"));
942 }
943 
access_kregistry_path() const944 std::string CuttlefishConfig::InstanceSpecific::access_kregistry_path() const {
945   return AbsolutePath(PerInstancePath("access-kregistry"));
946 }
947 
hwcomposer_pmem_path() const948 std::string CuttlefishConfig::InstanceSpecific::hwcomposer_pmem_path() const {
949   return AbsolutePath(PerInstancePath("hwcomposer-pmem"));
950 }
951 
pstore_path() const952 std::string CuttlefishConfig::InstanceSpecific::pstore_path() const {
953   return AbsolutePath(PerInstancePath("pstore"));
954 }
955 
console_path() const956 std::string CuttlefishConfig::InstanceSpecific::console_path() const {
957   return AbsolutePath(PerInstancePath("console"));
958 }
959 
logcat_path() const960 std::string CuttlefishConfig::InstanceSpecific::logcat_path() const {
961   return AbsolutePath(PerInstanceLogPath("logcat"));
962 }
963 
launcher_monitor_socket_path() const964 std::string CuttlefishConfig::InstanceSpecific::launcher_monitor_socket_path()
965     const {
966   return AbsolutePath(PerInstanceUdsPath("launcher_monitor.sock"));
967 }
968 
969 static constexpr char kModemSimulatorPorts[] = "modem_simulator_ports";
modem_simulator_ports() const970 std::string CuttlefishConfig::InstanceSpecific::modem_simulator_ports() const {
971   return (*Dictionary())[kModemSimulatorPorts].asString();
972 }
set_modem_simulator_ports(const std::string & modem_simulator_ports)973 void CuttlefishConfig::MutableInstanceSpecific::set_modem_simulator_ports(
974     const std::string& modem_simulator_ports) {
975   (*Dictionary())[kModemSimulatorPorts] = modem_simulator_ports;
976 }
977 
launcher_log_path() const978 std::string CuttlefishConfig::InstanceSpecific::launcher_log_path() const {
979   return AbsolutePath(PerInstanceLogPath("launcher.log"));
980 }
981 
sdcard_path() const982 std::string CuttlefishConfig::InstanceSpecific::sdcard_path() const {
983   return AbsolutePath(PerInstancePath("sdcard.img"));
984 }
985 
persistent_composite_disk_path() const986 std::string CuttlefishConfig::InstanceSpecific::persistent_composite_disk_path()
987     const {
988   return AbsolutePath(PerInstancePath("persistent_composite.img"));
989 }
990 
persistent_ap_composite_disk_path() const991 std::string CuttlefishConfig::InstanceSpecific::persistent_ap_composite_disk_path()
992     const {
993   return AbsolutePath(PerInstancePath("ap_persistent_composite.img"));
994 }
995 
os_composite_disk_path() const996 std::string CuttlefishConfig::InstanceSpecific::os_composite_disk_path()
997     const {
998   return AbsolutePath(PerInstancePath("os_composite.img"));
999 }
1000 
ap_composite_disk_path() const1001 std::string CuttlefishConfig::InstanceSpecific::ap_composite_disk_path()
1002     const {
1003   return AbsolutePath(PerInstancePath("ap_composite.img"));
1004 }
1005 
vbmeta_path() const1006 std::string CuttlefishConfig::InstanceSpecific::vbmeta_path() const {
1007   return AbsolutePath(PerInstancePath("vbmeta.img"));
1008 }
1009 
ap_vbmeta_path() const1010 std::string CuttlefishConfig::InstanceSpecific::ap_vbmeta_path() const {
1011   return AbsolutePath(PerInstancePath("ap_vbmeta.img"));
1012 }
1013 
uboot_env_image_path() const1014 std::string CuttlefishConfig::InstanceSpecific::uboot_env_image_path() const {
1015   return AbsolutePath(PerInstancePath("uboot_env.img"));
1016 }
1017 
ap_uboot_env_image_path() const1018 std::string CuttlefishConfig::InstanceSpecific::ap_uboot_env_image_path() const {
1019   return AbsolutePath(PerInstancePath("ap_uboot_env.img"));
1020 }
1021 
otheros_esp_image_path() const1022 std::string CuttlefishConfig::InstanceSpecific::otheros_esp_image_path() const {
1023   return AbsolutePath(PerInstancePath("esp.img"));
1024 }
1025 
ap_esp_image_path() const1026 std::string CuttlefishConfig::InstanceSpecific::ap_esp_image_path() const {
1027   return AbsolutePath(PerInstancePath("ap_esp.img"));
1028 }
1029 
otheros_esp_grub_config() const1030 std::string CuttlefishConfig::InstanceSpecific::otheros_esp_grub_config() const {
1031   return AbsolutePath(PerInstancePath("grub.cfg"));
1032 }
1033 
ap_esp_grub_config() const1034 std::string CuttlefishConfig::InstanceSpecific::ap_esp_grub_config() const {
1035   return AbsolutePath(PerInstancePath("ap_grub.cfg"));
1036 }
1037 
1038 static constexpr char kMobileBridgeName[] = "mobile_bridge_name";
1039 
audio_server_path() const1040 std::string CuttlefishConfig::InstanceSpecific::audio_server_path() const {
1041   return AbsolutePath(PerInstanceInternalUdsPath("audio_server.sock"));
1042 }
1043 
boot_flow() const1044 CuttlefishConfig::InstanceSpecific::BootFlow CuttlefishConfig::InstanceSpecific::boot_flow() const {
1045   const bool linux_flow_used = !linux_kernel_path().empty()
1046     || !linux_initramfs_path().empty()
1047     || !linux_root_image().empty();
1048 
1049   const bool fuchsia_flow_used = !fuchsia_zedboot_path().empty()
1050     || !fuchsia_root_image().empty()
1051     || !fuchsia_multiboot_bin_path().empty();
1052 
1053   if (linux_flow_used) {
1054     return BootFlow::Linux;
1055   }
1056   if (fuchsia_flow_used) {
1057     return BootFlow::Fuchsia;
1058   }
1059 
1060   return BootFlow::Android;
1061  }
1062 
mobile_bridge_name() const1063 std::string CuttlefishConfig::InstanceSpecific::mobile_bridge_name() const {
1064   return (*Dictionary())[kMobileBridgeName].asString();
1065 }
set_mobile_bridge_name(const std::string & mobile_bridge_name)1066 void CuttlefishConfig::MutableInstanceSpecific::set_mobile_bridge_name(
1067     const std::string& mobile_bridge_name) {
1068   (*Dictionary())[kMobileBridgeName] = mobile_bridge_name;
1069 }
1070 
1071 static constexpr char kMobileTapName[] = "mobile_tap_name";
mobile_tap_name() const1072 std::string CuttlefishConfig::InstanceSpecific::mobile_tap_name() const {
1073   return (*Dictionary())[kMobileTapName].asString();
1074 }
set_mobile_tap_name(const std::string & mobile_tap_name)1075 void CuttlefishConfig::MutableInstanceSpecific::set_mobile_tap_name(
1076     const std::string& mobile_tap_name) {
1077   (*Dictionary())[kMobileTapName] = mobile_tap_name;
1078 }
1079 
1080 static constexpr char kMobileMac[] = "mobile_mac";
mobile_mac() const1081 std::string CuttlefishConfig::InstanceSpecific::mobile_mac() const {
1082   return (*Dictionary())[kMobileMac].asString();
1083 }
set_mobile_mac(const std::string & mac)1084 void CuttlefishConfig::MutableInstanceSpecific::set_mobile_mac(
1085     const std::string& mac) {
1086   (*Dictionary())[kMobileMac] = mac;
1087 }
1088 
1089 // TODO(b/199103204): remove this as well when
1090 // PRODUCT_ENFORCE_MAC80211_HWSIM is removed
1091 static constexpr char kWifiTapName[] = "wifi_tap_name";
wifi_tap_name() const1092 std::string CuttlefishConfig::InstanceSpecific::wifi_tap_name() const {
1093   return (*Dictionary())[kWifiTapName].asString();
1094 }
set_wifi_tap_name(const std::string & wifi_tap_name)1095 void CuttlefishConfig::MutableInstanceSpecific::set_wifi_tap_name(
1096     const std::string& wifi_tap_name) {
1097   (*Dictionary())[kWifiTapName] = wifi_tap_name;
1098 }
1099 
1100 static constexpr char kWifiBridgeName[] = "wifi_bridge_name";
wifi_bridge_name() const1101 std::string CuttlefishConfig::InstanceSpecific::wifi_bridge_name() const {
1102   return (*Dictionary())[kWifiBridgeName].asString();
1103 }
set_wifi_bridge_name(const std::string & wifi_bridge_name)1104 void CuttlefishConfig::MutableInstanceSpecific::set_wifi_bridge_name(
1105     const std::string& wifi_bridge_name) {
1106   (*Dictionary())[kWifiBridgeName] = wifi_bridge_name;
1107 }
1108 
1109 static constexpr char kWifiMac[] = "wifi_mac";
wifi_mac() const1110 std::string CuttlefishConfig::InstanceSpecific::wifi_mac() const {
1111   return (*Dictionary())[kWifiMac].asString();
1112 }
set_wifi_mac(const std::string & mac)1113 void CuttlefishConfig::MutableInstanceSpecific::set_wifi_mac(
1114     const std::string& mac) {
1115   (*Dictionary())[kWifiMac] = mac;
1116 }
1117 
1118 static constexpr char kUseBridgedWifiTap[] = "use_bridged_wifi_tap";
use_bridged_wifi_tap() const1119 bool CuttlefishConfig::InstanceSpecific::use_bridged_wifi_tap() const {
1120   return (*Dictionary())[kUseBridgedWifiTap].asBool();
1121 }
set_use_bridged_wifi_tap(bool use_bridged_wifi_tap)1122 void CuttlefishConfig::MutableInstanceSpecific::set_use_bridged_wifi_tap(
1123     bool use_bridged_wifi_tap) {
1124   (*Dictionary())[kUseBridgedWifiTap] = use_bridged_wifi_tap;
1125 }
1126 
1127 static constexpr char kEthernetTapName[] = "ethernet_tap_name";
ethernet_tap_name() const1128 std::string CuttlefishConfig::InstanceSpecific::ethernet_tap_name() const {
1129   return (*Dictionary())[kEthernetTapName].asString();
1130 }
set_ethernet_tap_name(const std::string & ethernet_tap_name)1131 void CuttlefishConfig::MutableInstanceSpecific::set_ethernet_tap_name(
1132     const std::string& ethernet_tap_name) {
1133   (*Dictionary())[kEthernetTapName] = ethernet_tap_name;
1134 }
1135 
1136 static constexpr char kEthernetBridgeName[] = "ethernet_bridge_name";
ethernet_bridge_name() const1137 std::string CuttlefishConfig::InstanceSpecific::ethernet_bridge_name() const {
1138   return (*Dictionary())[kEthernetBridgeName].asString();
1139 }
set_ethernet_bridge_name(const std::string & ethernet_bridge_name)1140 void CuttlefishConfig::MutableInstanceSpecific::set_ethernet_bridge_name(
1141     const std::string& ethernet_bridge_name) {
1142   (*Dictionary())[kEthernetBridgeName] = ethernet_bridge_name;
1143 }
1144 
1145 static constexpr char kEthernetMac[] = "ethernet_mac";
ethernet_mac() const1146 std::string CuttlefishConfig::InstanceSpecific::ethernet_mac() const {
1147   return (*Dictionary())[kEthernetMac].asString();
1148 }
set_ethernet_mac(const std::string & mac)1149 void CuttlefishConfig::MutableInstanceSpecific::set_ethernet_mac(
1150     const std::string& mac) {
1151   (*Dictionary())[kEthernetMac] = mac;
1152 }
1153 
1154 static constexpr char kEthernetIPV6[] = "ethernet_ipv6";
ethernet_ipv6() const1155 std::string CuttlefishConfig::InstanceSpecific::ethernet_ipv6() const {
1156   return (*Dictionary())[kEthernetIPV6].asString();
1157 }
set_ethernet_ipv6(const std::string & ip)1158 void CuttlefishConfig::MutableInstanceSpecific::set_ethernet_ipv6(
1159     const std::string& ip) {
1160   (*Dictionary())[kEthernetIPV6] = ip;
1161 }
1162 
1163 static constexpr char kUseAllocd[] = "use_allocd";
use_allocd() const1164 bool CuttlefishConfig::InstanceSpecific::use_allocd() const {
1165   return (*Dictionary())[kUseAllocd].asBool();
1166 }
set_use_allocd(bool use_allocd)1167 void CuttlefishConfig::MutableInstanceSpecific::set_use_allocd(
1168     bool use_allocd) {
1169   (*Dictionary())[kUseAllocd] = use_allocd;
1170 }
1171 
1172 static constexpr char kSessionId[] = "session_id";
session_id() const1173 uint32_t CuttlefishConfig::InstanceSpecific::session_id() const {
1174   return (*Dictionary())[kSessionId].asUInt();
1175 }
set_session_id(uint32_t session_id)1176 void CuttlefishConfig::MutableInstanceSpecific::set_session_id(
1177     uint32_t session_id) {
1178   (*Dictionary())[kSessionId] = session_id;
1179 }
1180 
1181 static constexpr char kVsockGuestCid[] = "vsock_guest_cid";
vsock_guest_cid() const1182 int CuttlefishConfig::InstanceSpecific::vsock_guest_cid() const {
1183   return (*Dictionary())[kVsockGuestCid].asInt();
1184 }
set_vsock_guest_cid(int vsock_guest_cid)1185 void CuttlefishConfig::MutableInstanceSpecific::set_vsock_guest_cid(
1186     int vsock_guest_cid) {
1187   (*Dictionary())[kVsockGuestCid] = vsock_guest_cid;
1188 }
1189 
1190 static constexpr char kUuid[] = "uuid";
uuid() const1191 std::string CuttlefishConfig::InstanceSpecific::uuid() const {
1192   return (*Dictionary())[kUuid].asString();
1193 }
set_uuid(const std::string & uuid)1194 void CuttlefishConfig::MutableInstanceSpecific::set_uuid(const std::string& uuid) {
1195   (*Dictionary())[kUuid] = uuid;
1196 }
1197 
1198 static constexpr char kHostPort[] = "adb_host_port";
adb_host_port() const1199 int CuttlefishConfig::InstanceSpecific::adb_host_port() const {
1200   return (*Dictionary())[kHostPort].asInt();
1201 }
set_adb_host_port(int port)1202 void CuttlefishConfig::MutableInstanceSpecific::set_adb_host_port(int port) {
1203   (*Dictionary())[kHostPort] = port;
1204 }
1205 
1206 static constexpr char kFastbootHostPort[] = "fastboot_host_port";
fastboot_host_port() const1207 int CuttlefishConfig::InstanceSpecific::fastboot_host_port() const {
1208   return (*Dictionary())[kFastbootHostPort].asInt();
1209 }
set_fastboot_host_port(int port)1210 void CuttlefishConfig::MutableInstanceSpecific::set_fastboot_host_port(int port) {
1211   (*Dictionary())[kFastbootHostPort] = port;
1212 }
1213 
1214 static constexpr char kModemSimulatorId[] = "modem_simulator_host_id";
modem_simulator_host_id() const1215 int CuttlefishConfig::InstanceSpecific::modem_simulator_host_id() const {
1216   return (*Dictionary())[kModemSimulatorId].asInt();
1217 }
set_modem_simulator_host_id(int id)1218 void CuttlefishConfig::MutableInstanceSpecific::set_modem_simulator_host_id(
1219     int id) {
1220   (*Dictionary())[kModemSimulatorId] = id;
1221 }
1222 
1223 static constexpr char kAdbIPAndPort[] = "adb_ip_and_port";
adb_ip_and_port() const1224 std::string CuttlefishConfig::InstanceSpecific::adb_ip_and_port() const {
1225   return (*Dictionary())[kAdbIPAndPort].asString();
1226 }
set_adb_ip_and_port(const std::string & ip_port)1227 void CuttlefishConfig::MutableInstanceSpecific::set_adb_ip_and_port(
1228     const std::string& ip_port) {
1229   (*Dictionary())[kAdbIPAndPort] = ip_port;
1230 }
1231 
adb_device_name() const1232 std::string CuttlefishConfig::InstanceSpecific::adb_device_name() const {
1233   if (adb_ip_and_port() != "") {
1234     return adb_ip_and_port();
1235   }
1236   LOG(ERROR) << "no adb_mode found, returning bad device name";
1237   return "NO_ADB_MODE_SET_NO_VALID_DEVICE_NAME";
1238 }
1239 
1240 static constexpr char kQemuVncServerPort[] = "qemu_vnc_server_port";
qemu_vnc_server_port() const1241 int CuttlefishConfig::InstanceSpecific::qemu_vnc_server_port() const {
1242   return (*Dictionary())[kQemuVncServerPort].asInt();
1243 }
set_qemu_vnc_server_port(int qemu_vnc_server_port)1244 void CuttlefishConfig::MutableInstanceSpecific::set_qemu_vnc_server_port(
1245     int qemu_vnc_server_port) {
1246   (*Dictionary())[kQemuVncServerPort] = qemu_vnc_server_port;
1247 }
1248 
1249 static constexpr char kTouchServerPort[] = "touch_server_port";
touch_server_port() const1250 int CuttlefishConfig::InstanceSpecific::touch_server_port() const {
1251   return (*Dictionary())[kTouchServerPort].asInt();
1252 }
1253 
set_touch_server_port(int touch_server_port)1254 void CuttlefishConfig::MutableInstanceSpecific::set_touch_server_port(int touch_server_port) {
1255   (*Dictionary())[kTouchServerPort] = touch_server_port;
1256 }
1257 
1258 static constexpr char kKeyboardServerPort[] = "keyboard_server_port";
keyboard_server_port() const1259 int CuttlefishConfig::InstanceSpecific::keyboard_server_port() const {
1260   return (*Dictionary())[kKeyboardServerPort].asInt();
1261 }
set_keyboard_server_port(int keyboard_server_port)1262 void CuttlefishConfig::MutableInstanceSpecific::set_keyboard_server_port(int keyboard_server_port) {
1263   (*Dictionary())[kKeyboardServerPort] = keyboard_server_port;
1264 }
1265 
1266 static constexpr char kTombstoneReceiverPort[] = "tombstone_receiver_port";
tombstone_receiver_port() const1267 int CuttlefishConfig::InstanceSpecific::tombstone_receiver_port() const {
1268   return (*Dictionary())[kTombstoneReceiverPort].asInt();
1269 }
set_tombstone_receiver_port(int tombstone_receiver_port)1270 void CuttlefishConfig::MutableInstanceSpecific::set_tombstone_receiver_port(int tombstone_receiver_port) {
1271   (*Dictionary())[kTombstoneReceiverPort] = tombstone_receiver_port;
1272 }
1273 
1274 static constexpr char kAudioControlServerPort[] = "audiocontrol_server_port";
audiocontrol_server_port() const1275 int CuttlefishConfig::InstanceSpecific::audiocontrol_server_port() const {
1276   return (*Dictionary())[kAudioControlServerPort].asInt();
1277 }
set_audiocontrol_server_port(int audiocontrol_server_port)1278 void CuttlefishConfig::MutableInstanceSpecific::set_audiocontrol_server_port(int audiocontrol_server_port) {
1279   (*Dictionary())[kAudioControlServerPort] = audiocontrol_server_port;
1280 }
1281 
1282 static constexpr char kConfigServerPort[] = "config_server_port";
config_server_port() const1283 int CuttlefishConfig::InstanceSpecific::config_server_port() const {
1284   return (*Dictionary())[kConfigServerPort].asInt();
1285 }
set_config_server_port(int config_server_port)1286 void CuttlefishConfig::MutableInstanceSpecific::set_config_server_port(int config_server_port) {
1287   (*Dictionary())[kConfigServerPort] = config_server_port;
1288 }
1289 
1290 static constexpr char kCameraServerPort[] = "camera_server_port";
camera_server_port() const1291 int CuttlefishConfig::InstanceSpecific::camera_server_port() const {
1292   return (*Dictionary())[kCameraServerPort].asInt();
1293 }
set_camera_server_port(int camera_server_port)1294 void CuttlefishConfig::MutableInstanceSpecific::set_camera_server_port(
1295     int camera_server_port) {
1296   (*Dictionary())[kCameraServerPort] = camera_server_port;
1297 }
1298 
1299 static constexpr char kWebrtcDeviceId[] = "webrtc_device_id";
set_webrtc_device_id(const std::string & id)1300 void CuttlefishConfig::MutableInstanceSpecific::set_webrtc_device_id(
1301     const std::string& id) {
1302   (*Dictionary())[kWebrtcDeviceId] = id;
1303 }
webrtc_device_id() const1304 std::string CuttlefishConfig::InstanceSpecific::webrtc_device_id() const {
1305   return (*Dictionary())[kWebrtcDeviceId].asString();
1306 }
1307 
1308 static constexpr char kStartSigServer[] = "webrtc_start_sig_server";
set_start_webrtc_signaling_server(bool start)1309 void CuttlefishConfig::MutableInstanceSpecific::set_start_webrtc_signaling_server(bool start) {
1310   (*Dictionary())[kStartSigServer] = start;
1311 }
start_webrtc_sig_server() const1312 bool CuttlefishConfig::InstanceSpecific::start_webrtc_sig_server() const {
1313   return (*Dictionary())[kStartSigServer].asBool();
1314 }
1315 
1316 static constexpr char kStartSigServerProxy[] = "webrtc_start_sig_server_proxy";
1317 void CuttlefishConfig::MutableInstanceSpecific::
set_start_webrtc_sig_server_proxy(bool start)1318     set_start_webrtc_sig_server_proxy(bool start) {
1319   (*Dictionary())[kStartSigServerProxy] = start;
1320 }
start_webrtc_sig_server_proxy() const1321 bool CuttlefishConfig::InstanceSpecific::start_webrtc_sig_server_proxy() const {
1322   return (*Dictionary())[kStartSigServerProxy].asBool();
1323 }
1324 
1325 static constexpr char kStartWmediumd[] = "start_wmediumd";
set_start_wmediumd(bool start)1326 void CuttlefishConfig::MutableInstanceSpecific::set_start_wmediumd(bool start) {
1327   (*Dictionary())[kStartWmediumd] = start;
1328 }
start_wmediumd() const1329 bool CuttlefishConfig::InstanceSpecific::start_wmediumd() const {
1330   return (*Dictionary())[kStartWmediumd].asBool();
1331 }
1332 
1333 static constexpr char kStartRootcanal[] = "start_rootcanal";
set_start_rootcanal(bool start)1334 void CuttlefishConfig::MutableInstanceSpecific::set_start_rootcanal(
1335     bool start) {
1336   (*Dictionary())[kStartRootcanal] = start;
1337 }
start_rootcanal() const1338 bool CuttlefishConfig::InstanceSpecific::start_rootcanal() const {
1339   return (*Dictionary())[kStartRootcanal].asBool();
1340 }
1341 
1342 static constexpr char kStartPica[] = "start_pica";
set_start_pica(bool start)1343 void CuttlefishConfig::MutableInstanceSpecific::set_start_pica(
1344     bool start) {
1345   (*Dictionary())[kStartPica] = start;
1346 }
start_pica() const1347 bool CuttlefishConfig::InstanceSpecific::start_pica() const {
1348   return (*Dictionary())[kStartPica].asBool();
1349 }
1350 
1351 static constexpr char kStartNetsim[] = "start_netsim";
set_start_netsim(bool start)1352 void CuttlefishConfig::MutableInstanceSpecific::set_start_netsim(bool start) {
1353   (*Dictionary())[kStartNetsim] = start;
1354 }
start_netsim() const1355 bool CuttlefishConfig::InstanceSpecific::start_netsim() const {
1356   return (*Dictionary())[kStartNetsim].asBool();
1357 }
1358 
1359 static constexpr char kApBootFlow[] = "ap_boot_flow";
set_ap_boot_flow(APBootFlow flow)1360 void CuttlefishConfig::MutableInstanceSpecific::set_ap_boot_flow(APBootFlow flow) {
1361   (*Dictionary())[kApBootFlow] = static_cast<int>(flow);
1362 }
ap_boot_flow() const1363 APBootFlow CuttlefishConfig::InstanceSpecific::ap_boot_flow() const {
1364   return static_cast<APBootFlow>((*Dictionary())[kApBootFlow].asInt());
1365 }
1366 
touch_socket_path(int screen_idx) const1367 std::string CuttlefishConfig::InstanceSpecific::touch_socket_path(
1368     int screen_idx) const {
1369   return PerInstanceInternalUdsPath(
1370       ("touch_" + std::to_string(screen_idx) + ".sock").c_str());
1371 }
1372 
keyboard_socket_path() const1373 std::string CuttlefishConfig::InstanceSpecific::keyboard_socket_path() const {
1374   return PerInstanceInternalUdsPath("keyboard.sock");
1375 }
1376 
switches_socket_path() const1377 std::string CuttlefishConfig::InstanceSpecific::switches_socket_path() const {
1378   return PerInstanceInternalUdsPath("switches.sock");
1379 }
1380 
frames_socket_path() const1381 std::string CuttlefishConfig::InstanceSpecific::frames_socket_path() const {
1382   return PerInstanceInternalUdsPath("frames.sock");
1383 }
1384 
1385 static constexpr char kWifiMacPrefix[] = "wifi_mac_prefix";
wifi_mac_prefix() const1386 int CuttlefishConfig::InstanceSpecific::wifi_mac_prefix() const {
1387   return (*Dictionary())[kWifiMacPrefix].asInt();
1388 }
set_wifi_mac_prefix(int wifi_mac_prefix)1389 void CuttlefishConfig::MutableInstanceSpecific::set_wifi_mac_prefix(
1390     int wifi_mac_prefix) {
1391   (*Dictionary())[kWifiMacPrefix] = wifi_mac_prefix;
1392 }
1393 
factory_reset_protected_path() const1394 std::string CuttlefishConfig::InstanceSpecific::factory_reset_protected_path() const {
1395   return PerInstanceInternalPath("factory_reset_protected.img");
1396 }
1397 
persistent_bootconfig_path() const1398 std::string CuttlefishConfig::InstanceSpecific::persistent_bootconfig_path()
1399     const {
1400   return PerInstanceInternalPath("bootconfig");
1401 }
1402 
PerInstancePath(const std::string & file_name) const1403 std::string CuttlefishConfig::InstanceSpecific::PerInstancePath(
1404     const std::string& file_name) const {
1405   return (instance_dir() + "/") + file_name;
1406 }
1407 
PerInstanceInternalPath(const std::string & file_name) const1408 std::string CuttlefishConfig::InstanceSpecific::PerInstanceInternalPath(
1409     const std::string& file_name) const {
1410   if (file_name[0] == '\0') {
1411     // Don't append a / if file_name is empty.
1412     return PerInstancePath(kInternalDirName);
1413   }
1414   auto relative_path = (std::string(kInternalDirName) + "/") + file_name;
1415   return PerInstancePath(relative_path.c_str());
1416 }
1417 
PerInstanceUdsPath(const std::string & file_name) const1418 std::string CuttlefishConfig::InstanceSpecific::PerInstanceUdsPath(
1419     const std::string& file_name) const {
1420   return (instance_uds_dir() + "/") + file_name;
1421 }
1422 
PerInstanceInternalUdsPath(const std::string & file_name) const1423 std::string CuttlefishConfig::InstanceSpecific::PerInstanceInternalUdsPath(
1424     const std::string& file_name) const {
1425   if (file_name[0] == '\0') {
1426     // Don't append a / if file_name is empty.
1427     return PerInstanceUdsPath(kInternalDirName);
1428   }
1429   auto relative_path = (std::string(kInternalDirName) + "/") + file_name;
1430   return PerInstanceUdsPath(relative_path.c_str());
1431 }
1432 
PerInstanceGrpcSocketPath(const std::string & socket_name) const1433 std::string CuttlefishConfig::InstanceSpecific::PerInstanceGrpcSocketPath(
1434     const std::string& socket_name) const {
1435   if (socket_name.size() == 0) {
1436     // Don't append a / if file_name is empty.
1437     return PerInstanceUdsPath(kGrpcSocketDirName);
1438   }
1439   auto relative_path = (std::string(kGrpcSocketDirName) + "/") + socket_name;
1440   return PerInstanceUdsPath(relative_path.c_str());
1441 }
1442 
PerInstanceLogPath(const std::string & file_name) const1443 std::string CuttlefishConfig::InstanceSpecific::PerInstanceLogPath(
1444     const std::string& file_name) const {
1445   if (file_name.size() == 0) {
1446     // Don't append a / if file_name is empty.
1447     return PerInstancePath(kLogDirName);
1448   }
1449   auto relative_path = (std::string(kLogDirName) + "/") + file_name;
1450   return PerInstancePath(relative_path.c_str());
1451 }
1452 
instance_name() const1453 std::string CuttlefishConfig::InstanceSpecific::instance_name() const {
1454   return IdToName(id_);
1455 }
1456 
id() const1457 std::string CuttlefishConfig::InstanceSpecific::id() const { return id_; }
1458 
1459 }  // namespace cuttlefish
1460