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