services/surfaceflinger/SurfaceFlingerProperties.cpp - LeafOS-Project/android_frameworks_native - Gitiles

 /*
  * Copyright 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
 #include <android/hardware/configstore/1.1/ISurfaceFlingerConfigs.h>
 #include <android/hardware/configstore/1.1/types.h>
 #include <configstore/Utils.h>
 #include <utils/Log.h>

 #include <log/log.h>
 #include <cstdlib>
 #include <tuple>

 #include "SurfaceFlingerProperties.h"

 namespace android {
 namespace sysprop {
 using namespace android::hardware::configstore;
 using namespace android::hardware::configstore::V1_0;
 using android::hardware::graphics::common::V1_2::Dataspace;
 using android::hardware::graphics::common::V1_2::PixelFormat;
 using android::ui::DisplayPrimaries;

 // Keep logic in sync with WindowManagerService functions that query SurfaceFlinger properties.
 // Consider exposing properties via ISurfaceComposer instead.
 int64_t vsync_event_phase_offset_ns(int64_t defaultValue) {
     auto temp = SurfaceFlingerProperties::vsync_event_phase_offset_ns();
     if (temp.has_value()) {
         return *temp;
     }
     return getInt64<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::vsyncEventPhaseOffsetNs>(
             defaultValue);
 }

 int64_t vsync_sf_event_phase_offset_ns(int64_t defaultValue) {
     auto temp = SurfaceFlingerProperties::vsync_sf_event_phase_offset_ns();
     if (temp.has_value()) {
         return *temp;
     }
     return getInt64<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::vsyncSfEventPhaseOffsetNs>(
             defaultValue);
 }

 bool use_context_priority(bool defaultValue) {
     auto temp = SurfaceFlingerProperties::use_context_priority();
     if (temp.has_value()) {
         return *temp;
     }
     return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::useContextPriority>(
             defaultValue);
 }

 int64_t max_frame_buffer_acquired_buffers(int64_t defaultValue) {
     auto temp = SurfaceFlingerProperties::max_frame_buffer_acquired_buffers();
     if (temp.has_value()) {
         return *temp;
     }
     return getInt64<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::maxFrameBufferAcquiredBuffers>(
             defaultValue);
 }

 int32_t max_graphics_width(int32_t defaultValue) {
     auto temp = SurfaceFlingerProperties::max_graphics_width();
     if (temp.has_value()) {
         return *temp;
     }
     return defaultValue;
 }

 int32_t max_graphics_height(int32_t defaultValue) {
     auto temp = SurfaceFlingerProperties::max_graphics_height();
     if (temp.has_value()) {
         return *temp;
     }
     return defaultValue;
 }

 bool has_wide_color_display(bool defaultValue) {
     auto temp = SurfaceFlingerProperties::has_wide_color_display();
     if (temp.has_value()) {
         return *temp;
     }
     return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::hasWideColorDisplay>(
             defaultValue);
 }

 bool running_without_sync_framework(bool defaultValue) {
     auto temp = SurfaceFlingerProperties::running_without_sync_framework();
     if (temp.has_value()) {
         return !(*temp);
     }
     return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::hasSyncFramework>(defaultValue);
 }

 bool has_HDR_display(bool defaultValue) {
     auto temp = SurfaceFlingerProperties::has_HDR_display();
     if (temp.has_value()) {
         return *temp;
     }
     return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::hasHDRDisplay>(defaultValue);
 }

 int64_t present_time_offset_from_vsync_ns(int64_t defaultValue) {
     auto temp = SurfaceFlingerProperties::present_time_offset_from_vsync_ns();
     if (temp.has_value()) {
         return *temp;
     }
     return getInt64<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::presentTimeOffsetFromVSyncNs>(
             defaultValue);
 }

 bool force_hwc_copy_for_virtual_displays(bool defaultValue) {
     auto temp = SurfaceFlingerProperties::force_hwc_copy_for_virtual_displays();
     if (temp.has_value()) {
         return *temp;
     }
     return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::useHwcForRGBtoYUV>(
             defaultValue);
 }

 int64_t max_virtual_display_dimension(int64_t defaultValue) {
     auto temp = SurfaceFlingerProperties::max_virtual_display_dimension();
     if (temp.has_value()) {
         return *temp;
     }
     return getUInt64<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::maxVirtualDisplaySize>(
             defaultValue);
 }

 bool use_vr_flinger(bool defaultValue) {
     auto temp = SurfaceFlingerProperties::use_vr_flinger();
     if (temp.has_value()) {
         return *temp;
     }
     return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::useVrFlinger>(defaultValue);
 }

 bool start_graphics_allocator_service(bool defaultValue) {
     auto temp = SurfaceFlingerProperties::start_graphics_allocator_service();
     if (temp.has_value()) {
         return *temp;
     }
     return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::startGraphicsAllocatorService>(
             defaultValue);
 }

 SurfaceFlingerProperties::primary_display_orientation_values primary_display_orientation(
         SurfaceFlingerProperties::primary_display_orientation_values defaultValue) {
     auto temp = SurfaceFlingerProperties::primary_display_orientation();
     if (temp.has_value()) {
         return *temp;
     }
     auto configDefault = DisplayOrientation::ORIENTATION_0;
     switch (defaultValue) {
         case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_90:
             configDefault = DisplayOrientation::ORIENTATION_90;
             break;
         case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_180:
             configDefault = DisplayOrientation::ORIENTATION_180;
             break;
         case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_270:
             configDefault = DisplayOrientation::ORIENTATION_270;
             break;
         default:
             configDefault = DisplayOrientation::ORIENTATION_0;
             break;
     }
     DisplayOrientation result =
             getDisplayOrientation<V1_1::ISurfaceFlingerConfigs,
                                   &V1_1::ISurfaceFlingerConfigs::primaryDisplayOrientation>(
                     configDefault);
     switch (result) {
         case DisplayOrientation::ORIENTATION_90:
             return SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_90;
         case DisplayOrientation::ORIENTATION_180:
             return SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_180;
         case DisplayOrientation::ORIENTATION_270:
             return SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_270;
         default:
             break;
     }
     return SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_0;
 }

 int64_t default_composition_dataspace(Dataspace defaultValue) {
     auto temp = SurfaceFlingerProperties::default_composition_dataspace();
     if (temp.has_value()) {
         return *temp;
     }
     return static_cast<int64_t>(defaultValue);
 }

 int32_t default_composition_pixel_format(PixelFormat defaultValue) {
     auto temp = SurfaceFlingerProperties::default_composition_pixel_format();
     if (temp.has_value()) {
         return *temp;
     }
     return static_cast<int32_t>(defaultValue);
 }

 int64_t wcg_composition_dataspace(Dataspace defaultValue) {
     auto temp = SurfaceFlingerProperties::wcg_composition_dataspace();
     if (temp.has_value()) {
         return *temp;
     }
     return static_cast<int64_t>(defaultValue);
 }

 int32_t wcg_composition_pixel_format(PixelFormat defaultValue) {
     auto temp = SurfaceFlingerProperties::wcg_composition_pixel_format();
     if (temp.has_value()) {
         return *temp;
     }
     return static_cast<int32_t>(defaultValue);
 }

 int64_t color_space_agnostic_dataspace(Dataspace defaultValue) {
     auto temp = SurfaceFlingerProperties::color_space_agnostic_dataspace();
     if (temp.has_value()) {
         return *temp;
     }
     return static_cast<int64_t>(defaultValue);
 }

 bool refresh_rate_switching(bool defaultValue) {
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
     auto temp = SurfaceFlingerProperties::refresh_rate_switching();
 #pragma clang diagnostic pop
     if (temp.has_value()) {
         ALOGW("Using deprecated refresh_rate_switching sysprop. Value: %d", *temp);
         return *temp;
     }
     return defaultValue;
 }

 int32_t set_idle_timer_ms(int32_t defaultValue) {
     auto temp = SurfaceFlingerProperties::set_idle_timer_ms();
     if (temp.has_value()) {
         return *temp;
     }
     return defaultValue;
 }

 int32_t set_touch_timer_ms(int32_t defaultValue) {
     auto temp = SurfaceFlingerProperties::set_touch_timer_ms();
     if (temp.has_value()) {
         return *temp;
     }
     return defaultValue;
 }

 int32_t set_display_power_timer_ms(int32_t defaultValue) {
     auto temp = SurfaceFlingerProperties::set_display_power_timer_ms();
     if (temp.has_value()) {
         return *temp;
     }
     return defaultValue;
 }

 bool use_content_detection_for_refresh_rate(bool defaultValue) {
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
     auto smart_90_deprecated = SurfaceFlingerProperties::use_smart_90_for_video();
 #pragma clang diagnostic pop
     if (smart_90_deprecated.has_value()) {
         ALOGW("Using deprecated use_smart_90_for_video sysprop. Value: %d", *smart_90_deprecated);
         return *smart_90_deprecated;
     }

     auto temp = SurfaceFlingerProperties::use_content_detection_for_refresh_rate();
     if (temp.has_value()) {
         return *temp;
     }
     return defaultValue;
 }

 bool enable_protected_contents(bool defaultValue) {
     auto temp = SurfaceFlingerProperties::enable_protected_contents();
     if (temp.has_value()) {
         return *temp;
     }
     return defaultValue;
 }

 bool support_kernel_idle_timer(bool defaultValue) {
     auto temp = SurfaceFlingerProperties::support_kernel_idle_timer();
     if (temp.has_value()) {
         return *temp;
     }
     return defaultValue;
 }

 bool enable_sdr_dimming(bool defaultValue) {
     return SurfaceFlingerProperties::enable_sdr_dimming().value_or(defaultValue);
 }

 int32_t display_update_imminent_timeout_ms(int32_t defaultValue) {
     auto temp = SurfaceFlingerProperties::display_update_imminent_timeout_ms();
     if (temp.has_value()) {
         return *temp;
     }
     return defaultValue;
 }

 #define DISPLAY_PRIMARY_SIZE 3

 constexpr float kSrgbRedX = 0.4123f;
 constexpr float kSrgbRedY = 0.2126f;
 constexpr float kSrgbRedZ = 0.0193f;
 constexpr float kSrgbGreenX = 0.3576f;
 constexpr float kSrgbGreenY = 0.7152f;
 constexpr float kSrgbGreenZ = 0.1192f;
 constexpr float kSrgbBlueX = 0.1805f;
 constexpr float kSrgbBlueY = 0.0722f;
 constexpr float kSrgbBlueZ = 0.9506f;
 constexpr float kSrgbWhiteX = 0.9505f;
 constexpr float kSrgbWhiteY = 1.0000f;
 constexpr float kSrgbWhiteZ = 1.0891f;

 DisplayPrimaries getDisplayNativePrimaries() {
     auto mDisplay_primary_red = SurfaceFlingerProperties::display_primary_red();
     auto mDisplay_primary_green = SurfaceFlingerProperties::display_primary_green();
     auto mDisplay_primary_blue = SurfaceFlingerProperties::display_primary_blue();
     auto mDisplay_primary_white = SurfaceFlingerProperties::display_primary_white();
     // To avoid null point exception.
     mDisplay_primary_red.resize(DISPLAY_PRIMARY_SIZE);
     mDisplay_primary_green.resize(DISPLAY_PRIMARY_SIZE);
     mDisplay_primary_blue.resize(DISPLAY_PRIMARY_SIZE);
     mDisplay_primary_white.resize(DISPLAY_PRIMARY_SIZE);
     DisplayPrimaries primaries =
             {{static_cast<float>(mDisplay_primary_red[0].value_or(kSrgbRedX)),
               static_cast<float>(mDisplay_primary_red[1].value_or(kSrgbRedY)),
               static_cast<float>(mDisplay_primary_red[2].value_or(kSrgbRedZ))},
              {static_cast<float>(mDisplay_primary_green[0].value_or(kSrgbGreenX)),
               static_cast<float>(mDisplay_primary_green[1].value_or(kSrgbGreenY)),
               static_cast<float>(mDisplay_primary_green[2].value_or(kSrgbGreenZ))},
              {static_cast<float>(mDisplay_primary_blue[0].value_or(kSrgbBlueX)),
               static_cast<float>(mDisplay_primary_blue[1].value_or(kSrgbBlueY)),
               static_cast<float>(mDisplay_primary_blue[2].value_or(kSrgbBlueZ))},
              {static_cast<float>(mDisplay_primary_white[0].value_or(kSrgbWhiteX)),
               static_cast<float>(mDisplay_primary_white[1].value_or(kSrgbWhiteY)),
               static_cast<float>(mDisplay_primary_white[2].value_or(kSrgbWhiteZ))}};

     return primaries;
 }

 bool update_device_product_info_on_hotplug_reconnect(bool defaultValue) {
     return SurfaceFlingerProperties::update_device_product_info_on_hotplug_reconnect().value_or(
             defaultValue);
 }

 bool enable_frame_rate_override(bool defaultValue) {
     return SurfaceFlingerProperties::enable_frame_rate_override().value_or(defaultValue);
 }

 bool enable_layer_caching(bool defaultValue) {
     return SurfaceFlingerProperties::enable_layer_caching().value_or(defaultValue);
 }

 bool ignore_hdr_camera_layers(bool defaultValue) {
     return SurfaceFlingerProperties::ignore_hdr_camera_layers().value_or(defaultValue);
 }

 bool clear_slots_with_set_layer_buffer(bool defaultValue) {
     return SurfaceFlingerProperties::clear_slots_with_set_layer_buffer().value_or(defaultValue);
 }

 } // namespace sysprop
 } // namespace android
	/*
	* Copyright 2019 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
	#include <android/hardware/configstore/1.1/ISurfaceFlingerConfigs.h>
	#include <android/hardware/configstore/1.1/types.h>
	#include <configstore/Utils.h>
	#include <utils/Log.h>

	#include <log/log.h>
	#include <cstdlib>
	#include <tuple>

	#include "SurfaceFlingerProperties.h"

	namespace android {
	namespace sysprop {
	using namespace android::hardware::configstore;
	using namespace android::hardware::configstore::V1_0;
	using android::hardware::graphics::common::V1_2::Dataspace;
	using android::hardware::graphics::common::V1_2::PixelFormat;
	using android::ui::DisplayPrimaries;

	// Keep logic in sync with WindowManagerService functions that query SurfaceFlinger properties.
	// Consider exposing properties via ISurfaceComposer instead.
	int64_t vsync_event_phase_offset_ns(int64_t defaultValue) {
	auto temp = SurfaceFlingerProperties::vsync_event_phase_offset_ns();
	if (temp.has_value()) {
	return *temp;
	}
	return getInt64<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::vsyncEventPhaseOffsetNs>(
	defaultValue);
	}

	int64_t vsync_sf_event_phase_offset_ns(int64_t defaultValue) {
	auto temp = SurfaceFlingerProperties::vsync_sf_event_phase_offset_ns();
	if (temp.has_value()) {
	return *temp;
	}
	return getInt64<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::vsyncSfEventPhaseOffsetNs>(
	defaultValue);
	}

	bool use_context_priority(bool defaultValue) {
	auto temp = SurfaceFlingerProperties::use_context_priority();
	if (temp.has_value()) {
	return *temp;
	}
	return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::useContextPriority>(
	defaultValue);
	}

	int64_t max_frame_buffer_acquired_buffers(int64_t defaultValue) {
	auto temp = SurfaceFlingerProperties::max_frame_buffer_acquired_buffers();
	if (temp.has_value()) {
	return *temp;
	}
	return getInt64<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::maxFrameBufferAcquiredBuffers>(
	defaultValue);
	}

	int32_t max_graphics_width(int32_t defaultValue) {
	auto temp = SurfaceFlingerProperties::max_graphics_width();
	if (temp.has_value()) {
	return *temp;
	}
	return defaultValue;
	}

	int32_t max_graphics_height(int32_t defaultValue) {
	auto temp = SurfaceFlingerProperties::max_graphics_height();
	if (temp.has_value()) {
	return *temp;
	}
	return defaultValue;
	}

	bool has_wide_color_display(bool defaultValue) {
	auto temp = SurfaceFlingerProperties::has_wide_color_display();
	if (temp.has_value()) {
	return *temp;
	}
	return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::hasWideColorDisplay>(
	defaultValue);
	}

	bool running_without_sync_framework(bool defaultValue) {
	auto temp = SurfaceFlingerProperties::running_without_sync_framework();
	if (temp.has_value()) {
	return !(*temp);
	}
	return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::hasSyncFramework>(defaultValue);
	}

	bool has_HDR_display(bool defaultValue) {
	auto temp = SurfaceFlingerProperties::has_HDR_display();
	if (temp.has_value()) {
	return *temp;
	}
	return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::hasHDRDisplay>(defaultValue);
	}

	int64_t present_time_offset_from_vsync_ns(int64_t defaultValue) {
	auto temp = SurfaceFlingerProperties::present_time_offset_from_vsync_ns();
	if (temp.has_value()) {
	return *temp;
	}
	return getInt64<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::presentTimeOffsetFromVSyncNs>(
	defaultValue);
	}

	bool force_hwc_copy_for_virtual_displays(bool defaultValue) {
	auto temp = SurfaceFlingerProperties::force_hwc_copy_for_virtual_displays();
	if (temp.has_value()) {
	return *temp;
	}
	return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::useHwcForRGBtoYUV>(
	defaultValue);
	}

	int64_t max_virtual_display_dimension(int64_t defaultValue) {
	auto temp = SurfaceFlingerProperties::max_virtual_display_dimension();
	if (temp.has_value()) {
	return *temp;
	}
	return getUInt64<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::maxVirtualDisplaySize>(
	defaultValue);
	}

	bool use_vr_flinger(bool defaultValue) {
	auto temp = SurfaceFlingerProperties::use_vr_flinger();
	if (temp.has_value()) {
	return *temp;
	}
	return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::useVrFlinger>(defaultValue);
	}

	bool start_graphics_allocator_service(bool defaultValue) {
	auto temp = SurfaceFlingerProperties::start_graphics_allocator_service();
	if (temp.has_value()) {
	return *temp;
	}
	return getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::startGraphicsAllocatorService>(
	defaultValue);
	}

	SurfaceFlingerProperties::primary_display_orientation_values primary_display_orientation(
	SurfaceFlingerProperties::primary_display_orientation_values defaultValue) {
	auto temp = SurfaceFlingerProperties::primary_display_orientation();
	if (temp.has_value()) {
	return *temp;
	}
	auto configDefault = DisplayOrientation::ORIENTATION_0;
	switch (defaultValue) {
	case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_90:
	configDefault = DisplayOrientation::ORIENTATION_90;
	break;
	case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_180:
	configDefault = DisplayOrientation::ORIENTATION_180;
	break;
	case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_270:
	configDefault = DisplayOrientation::ORIENTATION_270;
	break;
	default:
	configDefault = DisplayOrientation::ORIENTATION_0;
	break;
	}
	DisplayOrientation result =
	getDisplayOrientation<V1_1::ISurfaceFlingerConfigs,
	&V1_1::ISurfaceFlingerConfigs::primaryDisplayOrientation>(
	configDefault);
	switch (result) {
	case DisplayOrientation::ORIENTATION_90:
	return SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_90;
	case DisplayOrientation::ORIENTATION_180:
	return SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_180;
	case DisplayOrientation::ORIENTATION_270:
	return SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_270;
	default:
	break;
	}
	return SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_0;
	}

	int64_t default_composition_dataspace(Dataspace defaultValue) {
	auto temp = SurfaceFlingerProperties::default_composition_dataspace();
	if (temp.has_value()) {
	return *temp;
	}
	return static_cast<int64_t>(defaultValue);
	}

	int32_t default_composition_pixel_format(PixelFormat defaultValue) {
	auto temp = SurfaceFlingerProperties::default_composition_pixel_format();
	if (temp.has_value()) {
	return *temp;
	}
	return static_cast<int32_t>(defaultValue);
	}

	int64_t wcg_composition_dataspace(Dataspace defaultValue) {
	auto temp = SurfaceFlingerProperties::wcg_composition_dataspace();
	if (temp.has_value()) {
	return *temp;
	}
	return static_cast<int64_t>(defaultValue);
	}

	int32_t wcg_composition_pixel_format(PixelFormat defaultValue) {
	auto temp = SurfaceFlingerProperties::wcg_composition_pixel_format();
	if (temp.has_value()) {
	return *temp;
	}
	return static_cast<int32_t>(defaultValue);
	}

	int64_t color_space_agnostic_dataspace(Dataspace defaultValue) {
	auto temp = SurfaceFlingerProperties::color_space_agnostic_dataspace();
	if (temp.has_value()) {
	return *temp;
	}
	return static_cast<int64_t>(defaultValue);
	}

	bool refresh_rate_switching(bool defaultValue) {
	#pragma clang diagnostic push
	#pragma clang diagnostic ignored "-Wdeprecated-declarations"
	auto temp = SurfaceFlingerProperties::refresh_rate_switching();
	#pragma clang diagnostic pop
	if (temp.has_value()) {
	ALOGW("Using deprecated refresh_rate_switching sysprop. Value: %d", *temp);
	return *temp;
	}
	return defaultValue;
	}

	int32_t set_idle_timer_ms(int32_t defaultValue) {
	auto temp = SurfaceFlingerProperties::set_idle_timer_ms();
	if (temp.has_value()) {
	return *temp;
	}
	return defaultValue;
	}

	int32_t set_touch_timer_ms(int32_t defaultValue) {
	auto temp = SurfaceFlingerProperties::set_touch_timer_ms();
	if (temp.has_value()) {
	return *temp;
	}
	return defaultValue;
	}

	int32_t set_display_power_timer_ms(int32_t defaultValue) {
	auto temp = SurfaceFlingerProperties::set_display_power_timer_ms();
	if (temp.has_value()) {
	return *temp;
	}
	return defaultValue;
	}

	bool use_content_detection_for_refresh_rate(bool defaultValue) {
	#pragma clang diagnostic push
	#pragma clang diagnostic ignored "-Wdeprecated-declarations"
	auto smart_90_deprecated = SurfaceFlingerProperties::use_smart_90_for_video();
	#pragma clang diagnostic pop
	if (smart_90_deprecated.has_value()) {
	ALOGW("Using deprecated use_smart_90_for_video sysprop. Value: %d", *smart_90_deprecated);
	return *smart_90_deprecated;
	}

	auto temp = SurfaceFlingerProperties::use_content_detection_for_refresh_rate();
	if (temp.has_value()) {
	return *temp;
	}
	return defaultValue;
	}

	bool enable_protected_contents(bool defaultValue) {
	auto temp = SurfaceFlingerProperties::enable_protected_contents();
	if (temp.has_value()) {
	return *temp;
	}
	return defaultValue;
	}

	bool support_kernel_idle_timer(bool defaultValue) {
	auto temp = SurfaceFlingerProperties::support_kernel_idle_timer();
	if (temp.has_value()) {
	return *temp;
	}
	return defaultValue;
	}

	bool enable_sdr_dimming(bool defaultValue) {
	return SurfaceFlingerProperties::enable_sdr_dimming().value_or(defaultValue);
	}

	int32_t display_update_imminent_timeout_ms(int32_t defaultValue) {
	auto temp = SurfaceFlingerProperties::display_update_imminent_timeout_ms();
	if (temp.has_value()) {
	return *temp;
	}
	return defaultValue;
	}

	#define DISPLAY_PRIMARY_SIZE 3

	constexpr float kSrgbRedX = 0.4123f;
	constexpr float kSrgbRedY = 0.2126f;
	constexpr float kSrgbRedZ = 0.0193f;
	constexpr float kSrgbGreenX = 0.3576f;
	constexpr float kSrgbGreenY = 0.7152f;
	constexpr float kSrgbGreenZ = 0.1192f;
	constexpr float kSrgbBlueX = 0.1805f;
	constexpr float kSrgbBlueY = 0.0722f;
	constexpr float kSrgbBlueZ = 0.9506f;
	constexpr float kSrgbWhiteX = 0.9505f;
	constexpr float kSrgbWhiteY = 1.0000f;
	constexpr float kSrgbWhiteZ = 1.0891f;

	DisplayPrimaries getDisplayNativePrimaries() {
	auto mDisplay_primary_red = SurfaceFlingerProperties::display_primary_red();
	auto mDisplay_primary_green = SurfaceFlingerProperties::display_primary_green();
	auto mDisplay_primary_blue = SurfaceFlingerProperties::display_primary_blue();
	auto mDisplay_primary_white = SurfaceFlingerProperties::display_primary_white();
	// To avoid null point exception.
	mDisplay_primary_red.resize(DISPLAY_PRIMARY_SIZE);
	mDisplay_primary_green.resize(DISPLAY_PRIMARY_SIZE);
	mDisplay_primary_blue.resize(DISPLAY_PRIMARY_SIZE);
	mDisplay_primary_white.resize(DISPLAY_PRIMARY_SIZE);
	DisplayPrimaries primaries =
	{{static_cast<float>(mDisplay_primary_red[0].value_or(kSrgbRedX)),
	static_cast<float>(mDisplay_primary_red[1].value_or(kSrgbRedY)),
	static_cast<float>(mDisplay_primary_red[2].value_or(kSrgbRedZ))},
	{static_cast<float>(mDisplay_primary_green[0].value_or(kSrgbGreenX)),
	static_cast<float>(mDisplay_primary_green[1].value_or(kSrgbGreenY)),
	static_cast<float>(mDisplay_primary_green[2].value_or(kSrgbGreenZ))},
	{static_cast<float>(mDisplay_primary_blue[0].value_or(kSrgbBlueX)),
	static_cast<float>(mDisplay_primary_blue[1].value_or(kSrgbBlueY)),
	static_cast<float>(mDisplay_primary_blue[2].value_or(kSrgbBlueZ))},
	{static_cast<float>(mDisplay_primary_white[0].value_or(kSrgbWhiteX)),
	static_cast<float>(mDisplay_primary_white[1].value_or(kSrgbWhiteY)),
	static_cast<float>(mDisplay_primary_white[2].value_or(kSrgbWhiteZ))}};

	return primaries;
	}

	bool update_device_product_info_on_hotplug_reconnect(bool defaultValue) {
	return SurfaceFlingerProperties::update_device_product_info_on_hotplug_reconnect().value_or(
	defaultValue);
	}

	bool enable_frame_rate_override(bool defaultValue) {
	return SurfaceFlingerProperties::enable_frame_rate_override().value_or(defaultValue);
	}

	bool enable_layer_caching(bool defaultValue) {
	return SurfaceFlingerProperties::enable_layer_caching().value_or(defaultValue);
	}

	bool ignore_hdr_camera_layers(bool defaultValue) {
	return SurfaceFlingerProperties::ignore_hdr_camera_layers().value_or(defaultValue);
	}

	bool clear_slots_with_set_layer_buffer(bool defaultValue) {
	return SurfaceFlingerProperties::clear_slots_with_set_layer_buffer().value_or(defaultValue);
	}

	} // namespace sysprop
	} // namespace android