static bool find_paths(struct paths *paths)
{
std::unordered_map<std::string, std::string> props;
util::file_get_all_properties(DEFAULT_PROP_PATH, &props);
std::string userdata;
std::string header;
std::string recovery;
std::vector<unsigned char> contents;
util::file_read_all(DEVICE_JSON_PATH, &contents);
contents.push_back('\0');
MbDeviceJsonError error;
Device *device = mb_device_new_from_json((char *) contents.data(), &error);
if (!device) {
LOGE("%s: Failed to load device definition", DEVICE_JSON_PATH);
return false;
} else if (mb_device_validate(device) != 0) {
LOGE("%s: Device definition validation failed", DEVICE_JSON_PATH);
mb_device_free(device);
return false;
}
auto userdata_list = mb_device_data_block_devs(device);
auto recovery_list = mb_device_recovery_block_devs(device);
if (userdata_list) {
for (auto it = userdata_list; *it; ++it) {
if (access(*it, R_OK) == 0) {
userdata = *it;
break;
}
}
}
if (recovery_list) {
for (auto it = recovery_list; *it; ++it) {
if (access(*it, R_OK) == 0) {
recovery = *it;
break;
}
}
}
mb_device_free(device);
header = props[PROP_CRYPTFS_HEADER_PATH];
if (userdata.empty()) {
LOGE("Encrypted partition path could not be detected");
return false;
}
if (recovery.empty()) {
LOGE("Recovery partition path could not be detected");
return false;
}
if (header.empty()) {
LOGE("Cryptfs header path could not be detected");
return false;
}
paths->userdata.swap(userdata);
paths->recovery.swap(recovery);
paths->header.swap(header);
return true;
}
TEST(JsonTest, LoadCompleteDefinition)
{
ScopedDevice sd(sample_complete);
ASSERT_NE(sd.device, nullptr);
ASSERT_STREQ(mb_device_id(sd.device), "test");
const char *codenames[] = { "test1", "test2", "test3", "test4", nullptr };
ASSERT_TRUE(string_array_eq(mb_device_codenames(sd.device), codenames));
ASSERT_STREQ(mb_device_name(sd.device), "Test Device");
ASSERT_STREQ(mb_device_architecture(sd.device), "arm64-v8a");
uint64_t device_flags = FLAG_HAS_COMBINED_BOOT_AND_RECOVERY;
ASSERT_EQ(mb_device_flags(sd.device), device_flags);
const char *base_dirs[] = { "/dev/block/bootdevice/by-name", nullptr };
ASSERT_TRUE(string_array_eq(mb_device_block_dev_base_dirs(sd.device), base_dirs));
const char *system_devs[] = {
"/dev/block/bootdevice/by-name/system",
"/dev/block/sda1",
nullptr
};
ASSERT_TRUE(string_array_eq(mb_device_system_block_devs(sd.device), system_devs));
const char *cache_devs[] = {
"/dev/block/bootdevice/by-name/cache",
"/dev/block/sda2",
nullptr
};
ASSERT_TRUE(string_array_eq(mb_device_cache_block_devs(sd.device), cache_devs));
const char *data_devs[] = {
"/dev/block/bootdevice/by-name/userdata",
"/dev/block/sda3",
nullptr
};
ASSERT_TRUE(string_array_eq(mb_device_data_block_devs(sd.device), data_devs));
const char *boot_devs[] = {
"/dev/block/bootdevice/by-name/boot",
"/dev/block/sda4",
nullptr
};
ASSERT_TRUE(string_array_eq(mb_device_boot_block_devs(sd.device), boot_devs));
const char *recovery_devs[] = {
"/dev/block/bootdevice/by-name/recovery",
"/dev/block/sda5",
nullptr
};
ASSERT_TRUE(string_array_eq(mb_device_recovery_block_devs(sd.device), recovery_devs));
const char *extra_devs[] = {
"/dev/block/bootdevice/by-name/modem",
"/dev/block/sda6",
nullptr
};
ASSERT_TRUE(string_array_eq(mb_device_extra_block_devs(sd.device), extra_devs));
/* Boot UI */
ASSERT_EQ(mb_device_tw_supported(sd.device), true);
uint64_t flags =
FLAG_TW_TOUCHSCREEN_SWAP_XY
| FLAG_TW_TOUCHSCREEN_FLIP_X
| FLAG_TW_TOUCHSCREEN_FLIP_Y
| FLAG_TW_GRAPHICS_FORCE_USE_LINELENGTH
| FLAG_TW_SCREEN_BLANK_ON_BOOT
| FLAG_TW_BOARD_HAS_FLIPPED_SCREEN
| FLAG_TW_IGNORE_MAJOR_AXIS_0
| FLAG_TW_IGNORE_MT_POSITION_0
| FLAG_TW_IGNORE_ABS_MT_TRACKING_ID
| FLAG_TW_NEW_ION_HEAP
| FLAG_TW_NO_SCREEN_BLANK
| FLAG_TW_NO_SCREEN_TIMEOUT
| FLAG_TW_ROUND_SCREEN
| FLAG_TW_NO_CPU_TEMP
| FLAG_TW_QCOM_RTC_FIX
| FLAG_TW_HAS_DOWNLOAD_MODE
| FLAG_TW_PREFER_LCD_BACKLIGHT;
ASSERT_EQ(mb_device_tw_flags(sd.device), flags);
ASSERT_EQ(mb_device_tw_pixel_format(sd.device), TW_PIXEL_FORMAT_RGBA_8888);
ASSERT_EQ(mb_device_tw_force_pixel_format(sd.device), TW_FORCE_PIXEL_FORMAT_RGB_565);
ASSERT_EQ(mb_device_tw_overscan_percent(sd.device), 10);
ASSERT_EQ(mb_device_tw_default_x_offset(sd.device), 20);
ASSERT_EQ(mb_device_tw_default_y_offset(sd.device), 30);
ASSERT_STREQ(mb_device_tw_brightness_path(sd.device), "/sys/class/backlight");
ASSERT_STREQ(mb_device_tw_secondary_brightness_path(sd.device), "/sys/class/lcd-backlight");
ASSERT_EQ(mb_device_tw_max_brightness(sd.device), 255);
ASSERT_EQ(mb_device_tw_default_brightness(sd.device), 100);
ASSERT_STREQ(mb_device_tw_battery_path(sd.device), "/sys/class/battery");
ASSERT_STREQ(mb_device_tw_cpu_temp_path(sd.device), "/sys/class/cputemp");
ASSERT_STREQ(mb_device_tw_input_blacklist(sd.device), "foo");
ASSERT_STREQ(mb_device_tw_input_whitelist(sd.device), "bar");
const char *graphics_backends[] = {
"overlay_msm_old",
"fbdev",
nullptr
};
ASSERT_TRUE(string_array_eq(mb_device_tw_graphics_backends(sd.device), graphics_backends));
ASSERT_STREQ(mb_device_tw_theme(sd.device), "portrait_hdpi");
}
