Merge "Extract RefreshRateData from DisplayDeviceConfig" into main (7b905381) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/display/DisplayDeviceConfig.java

+12 −101

Original line number	Diff line number	Diff line
		@@ -70,6 +70,7 @@ import com.android.server.display.config.PowerThrottlingMap;
		import com.android.server.display.config.PowerThrottlingPoint;
		import com.android.server.display.config.PredefinedBrightnessLimitNames;
		import com.android.server.display.config.RefreshRateConfigs;
		import com.android.server.display.config.RefreshRateData;
		import com.android.server.display.config.RefreshRateRange;
		import com.android.server.display.config.RefreshRateThrottlingMap;
		import com.android.server.display.config.RefreshRateThrottlingPoint;
		@@ -617,9 +618,7 @@ public class DisplayDeviceConfig {
		private static final String STABLE_ID_SUFFIX_FORMAT = "id_%d";
		private static final String NO_SUFFIX_FORMAT = "%d";
		private static final long STABLE_FLAG = 1L << 62;
		private static final int DEFAULT_PEAK_REFRESH_RATE = 0;
		private static final int DEFAULT_REFRESH_RATE = 60;
		private static final int DEFAULT_REFRESH_RATE_IN_HBM = 0;

		private static final int DEFAULT_HIGH_REFRESH_RATE = 0;
		private static final float[] DEFAULT_BRIGHTNESS_THRESHOLDS = new float[]{};

		@@ -753,32 +752,6 @@ public class DisplayDeviceConfig {
		// This stores the raw value loaded from the config file - true if not written.
		private boolean mDdcAutoBrightnessAvailable = true;

		/**
		* The default peak refresh rate for a given device. This value prevents the framework from
		* using higher refresh rates, even if display modes with higher refresh rates are available
		* from hardware composer. Only has an effect if the value is non-zero.
		*/
		private int mDefaultPeakRefreshRate = DEFAULT_PEAK_REFRESH_RATE;

		/**
		* The default refresh rate for a given device. This value sets the higher default
		* refresh rate. If the hardware composer on the device supports display modes with
		* a higher refresh rate than the default value specified here, the framework may use those
		* higher refresh rate modes if an app chooses one by setting preferredDisplayModeId or calling
		* setFrameRate(). We have historically allowed fallback to mDefaultPeakRefreshRate if
		* mDefaultRefreshRate is set to 0, but this is not supported anymore.
		*/
		private int mDefaultRefreshRate = DEFAULT_REFRESH_RATE;

		/**
		* Default refresh rate while the device has high brightness mode enabled for HDR.
		*/
		private int mDefaultRefreshRateInHbmHdr = DEFAULT_REFRESH_RATE_IN_HBM;

		/**
		* Default refresh rate while the device has high brightness mode enabled for Sunlight.
		*/
		private int mDefaultRefreshRateInHbmSunlight = DEFAULT_REFRESH_RATE_IN_HBM;
		/**
		* Default refresh rate in the high zone defined by brightness and ambient thresholds.
		* If non-positive, then the refresh rate is unchanged even if thresholds are configured.
		@@ -867,6 +840,8 @@ public class DisplayDeviceConfig {
		@Nullable
		public EvenDimmerBrightnessData mEvenDimmerBrightnessData;

		private RefreshRateData mRefreshRateData = RefreshRateData.DEFAULT_REFRESH_RATE_DATA;

		/**
		* Maximum screen brightness setting when screen brightness capped in Wear Bedtime mode.
		*/
		@@ -1450,33 +1425,8 @@ public class DisplayDeviceConfig {
		return mDisplayBrightnessMapping.getBrightnessArray(mode, preset);
		}

		/**
		* @return Default peak refresh rate of the associated display
		*/
		public int getDefaultPeakRefreshRate() {
		return mDefaultPeakRefreshRate;
		}

		/**
		* @return Default refresh rate of the associated display
		*/
		public int getDefaultRefreshRate() {
		return mDefaultRefreshRate;
		}

		/**
		* @return Default refresh rate while the device has high brightness mode enabled for HDR.
		*/
		public int getDefaultRefreshRateInHbmHdr() {
		return mDefaultRefreshRateInHbmHdr;
		}

		/**
		* @return Default refresh rate while the device has high brightness mode enabled because of
		* high lux.
		*/
		public int getDefaultRefreshRateInHbmSunlight() {
		return mDefaultRefreshRateInHbmSunlight;
		public RefreshRateData getRefreshRateData() {
		return mRefreshRateData;
		}

		/**
		@@ -1687,11 +1637,8 @@ public class DisplayDeviceConfig {
		+ "\n"
		+ "mDefaultLowBlockingZoneRefreshRate= " + mDefaultLowBlockingZoneRefreshRate
		+ ", mDefaultHighBlockingZoneRefreshRate= " + mDefaultHighBlockingZoneRefreshRate
		+ ", mDefaultPeakRefreshRate= " + mDefaultPeakRefreshRate
		+ ", mDefaultRefreshRate= " + mDefaultRefreshRate
		+ ", mRefreshRateData= " + mRefreshRateData
		+ ", mRefreshRateZoneProfiles= " + mRefreshRateZoneProfiles
		+ ", mDefaultRefreshRateInHbmHdr= " + mDefaultRefreshRateInHbmHdr
		+ ", mDefaultRefreshRateInHbmSunlight= " + mDefaultRefreshRateInHbmSunlight
		+ ", mRefreshRateThrottlingMap= " + mRefreshRateThrottlingMap
		+ ", mLowBlockingZoneThermalMapId= " + mLowBlockingZoneThermalMapId
		+ ", mHighBlockingZoneThermalMapId= " + mHighBlockingZoneThermalMapId
		@@ -1782,6 +1729,8 @@ public class DisplayDeviceConfig {
		mScreenOffBrightnessSensor = SensorData.loadScreenOffBrightnessSensorConfig(config);
		mProximitySensor = SensorData.loadProxSensorConfig(mFlags, config);
		mTempSensor = SensorData.loadTempSensorConfig(mFlags, config);
		mRefreshRateData = RefreshRateData
		.loadRefreshRateData(config, mContext.getResources());
		loadAmbientHorizonFromDdc(config);
		loadBrightnessChangeThresholds(config);
		loadAutoBrightnessConfigValues(config);
		@@ -1812,6 +1761,8 @@ public class DisplayDeviceConfig {
		mAmbientLightSensor = SensorData.loadAmbientLightSensorConfig(mContext.getResources());
		mProximitySensor = SensorData.loadSensorUnspecifiedConfig();
		mTempSensor = SensorData.loadTempSensorUnspecifiedConfig();
		mRefreshRateData = RefreshRateData
		.loadRefreshRateData(null, mContext.getResources());
		loadBrightnessChangeThresholdsFromXml();
		loadAutoBrightnessConfigsFromConfigXml();
		loadAutoBrightnessAvailableFromConfigXml();
		@@ -2162,33 +2113,13 @@ public class DisplayDeviceConfig {
		BlockingZoneConfig higherBlockingZoneConfig =
		(refreshRateConfigs == null) ? null
		: refreshRateConfigs.getHigherBlockingZoneConfigs();
		loadPeakDefaultRefreshRate(refreshRateConfigs);
		loadDefaultRefreshRate(refreshRateConfigs);
		loadDefaultRefreshRateInHbm(refreshRateConfigs);
		loadLowerRefreshRateBlockingZones(lowerBlockingZoneConfig);
		loadHigherRefreshRateBlockingZones(higherBlockingZoneConfig);
		loadRefreshRateZoneProfiles(refreshRateConfigs);
		}

		private void loadPeakDefaultRefreshRate(RefreshRateConfigs refreshRateConfigs) {
		if (refreshRateConfigs == null \|\| refreshRateConfigs.getDefaultPeakRefreshRate() == null) {
		mDefaultPeakRefreshRate = mContext.getResources().getInteger(
		R.integer.config_defaultPeakRefreshRate);
		} else {
		mDefaultPeakRefreshRate =
		refreshRateConfigs.getDefaultPeakRefreshRate().intValue();
		}
		}

		private void loadDefaultRefreshRate(RefreshRateConfigs refreshRateConfigs) {
		if (refreshRateConfigs == null \|\| refreshRateConfigs.getDefaultRefreshRate() == null) {
		mDefaultRefreshRate = mContext.getResources().getInteger(
		R.integer.config_defaultRefreshRate);
		} else {
		mDefaultRefreshRate =
		refreshRateConfigs.getDefaultRefreshRate().intValue();
		}
		}


		/** Loads the refresh rate profiles. */
		private void loadRefreshRateZoneProfiles(RefreshRateConfigs refreshRateConfigs) {
		@@ -2205,26 +2136,6 @@ public class DisplayDeviceConfig {
		}
		}

		private void loadDefaultRefreshRateInHbm(RefreshRateConfigs refreshRateConfigs) {
		if (refreshRateConfigs != null
		&& refreshRateConfigs.getDefaultRefreshRateInHbmHdr() != null) {
		mDefaultRefreshRateInHbmHdr = refreshRateConfigs.getDefaultRefreshRateInHbmHdr()
		.intValue();
		} else {
		mDefaultRefreshRateInHbmHdr = mContext.getResources().getInteger(
		R.integer.config_defaultRefreshRateInHbmHdr);
		}

		if (refreshRateConfigs != null
		&& refreshRateConfigs.getDefaultRefreshRateInHbmSunlight() != null) {
		mDefaultRefreshRateInHbmSunlight =
		refreshRateConfigs.getDefaultRefreshRateInHbmSunlight().intValue();
		} else {
		mDefaultRefreshRateInHbmSunlight = mContext.getResources().getInteger(
		R.integer.config_defaultRefreshRateInHbmSunlight);
		}
		}

		/**
		* Loads the refresh rate configurations pertaining to the lower blocking zones.
		*/

services/core/java/com/android/server/display/config/RefreshRateData.java

0 → 100644

+138 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2024 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.
		*/

		package com.android.server.display.config;

		import android.annotation.Nullable;
		import android.content.res.Resources;

		import com.android.internal.R;

		/**
		* RefreshRates config for display
		*/
		public class RefreshRateData {
		public static RefreshRateData DEFAULT_REFRESH_RATE_DATA = loadRefreshRateData(null, null);

		private static final int DEFAULT_REFRESH_RATE = 60;
		private static final int DEFAULT_PEAK_REFRESH_RATE = 0;
		private static final int DEFAULT_REFRESH_RATE_IN_HBM = 0;

		/**
		* The default refresh rate for a given device. This value sets the higher default
		* refresh rate. If the hardware composer on the device supports display modes with
		* a higher refresh rate than the default value specified here, the framework may use those
		* higher refresh rate modes if an app chooses one by setting preferredDisplayModeId or calling
		* setFrameRate(). We have historically allowed fallback to mDefaultPeakRefreshRate if
		* defaultRefreshRate is set to 0, but this is not supported anymore.
		*/
		public final int defaultRefreshRate;

		/**
		* The default peak refresh rate for a given device. This value prevents the framework from
		* using higher refresh rates, even if display modes with higher refresh rates are available
		* from hardware composer. Only has an effect if the value is non-zero.
		*/
		public final int defaultPeakRefreshRate;

		/**
		* Default refresh rate while the device has high brightness mode enabled for HDR.
		*/
		public final int defaultRefreshRateInHbmHdr;

		/**
		* Default refresh rate while the device has high brightness mode enabled for Sunlight.
		*/
		public final int defaultRefreshRateInHbmSunlight;

		public RefreshRateData(int defaultRefreshRate, int defaultPeakRefreshRate,
		int defaultRefreshRateInHbmHdr, int defaultRefreshRateInHbmSunlight) {
		this.defaultRefreshRate = defaultRefreshRate;
		this.defaultPeakRefreshRate = defaultPeakRefreshRate;
		this.defaultRefreshRateInHbmHdr = defaultRefreshRateInHbmHdr;
		this.defaultRefreshRateInHbmSunlight = defaultRefreshRateInHbmSunlight;
		}


		@Override
		public String toString() {
		return "RefreshRateData {"
		+ "defaultRefreshRate: " + defaultRefreshRate
		+ "defaultPeakRefreshRate: " + defaultPeakRefreshRate
		+ "defaultRefreshRateInHbmHdr: " + defaultRefreshRateInHbmHdr
		+ "defaultRefreshRateInHbmSunlight: " + defaultRefreshRateInHbmSunlight
		+ "} ";
		}

		/**
		* Loads RefreshRateData from DisplayConfiguration and Resources
		*/
		public static RefreshRateData loadRefreshRateData(
		@Nullable DisplayConfiguration config, @Nullable Resources resources) {
		RefreshRateConfigs refreshRateConfigs = config == null ? null : config.getRefreshRate();

		int defaultRefreshRate = loadDefaultRefreshRate(refreshRateConfigs, resources);
		int defaultPeakRefreshRate = loadDefaultPeakRefreshRate(refreshRateConfigs, resources);
		int defaultRefreshRateInHbmHdr = loadDefaultRefreshRateInHbm(refreshRateConfigs, resources);
		int defaultRefreshRateInHbmSunlight = loadDefaultRefreshRateInHbmSunlight(
		refreshRateConfigs, resources);

		return new RefreshRateData(defaultRefreshRate, defaultPeakRefreshRate,
		defaultRefreshRateInHbmHdr, defaultRefreshRateInHbmSunlight);
		}

		private static int loadDefaultRefreshRate(
		@Nullable RefreshRateConfigs refreshRateConfigs, @Nullable Resources resources) {
		if (refreshRateConfigs != null && refreshRateConfigs.getDefaultRefreshRate() != null) {
		return refreshRateConfigs.getDefaultRefreshRate().intValue();
		} else if (resources != null) {
		return resources.getInteger(R.integer.config_defaultRefreshRate);
		}
		return DEFAULT_REFRESH_RATE;
		}

		private static int loadDefaultPeakRefreshRate(
		@Nullable RefreshRateConfigs refreshRateConfigs, @Nullable Resources resources) {
		if (refreshRateConfigs != null && refreshRateConfigs.getDefaultPeakRefreshRate() != null) {
		return refreshRateConfigs.getDefaultPeakRefreshRate().intValue();
		} else if (resources != null) {
		return resources.getInteger(R.integer.config_defaultPeakRefreshRate);
		}
		return DEFAULT_PEAK_REFRESH_RATE;
		}

		private static int loadDefaultRefreshRateInHbm(
		@Nullable RefreshRateConfigs refreshRateConfigs, @Nullable Resources resources) {
		if (refreshRateConfigs != null
		&& refreshRateConfigs.getDefaultRefreshRateInHbmHdr() != null) {
		return refreshRateConfigs.getDefaultRefreshRateInHbmHdr().intValue();
		} else if (resources != null) {
		return resources.getInteger(R.integer.config_defaultRefreshRateInHbmHdr);
		}
		return DEFAULT_REFRESH_RATE_IN_HBM;
		}

		private static int loadDefaultRefreshRateInHbmSunlight(
		@Nullable RefreshRateConfigs refreshRateConfigs, @Nullable Resources resources) {
		if (refreshRateConfigs != null
		&& refreshRateConfigs.getDefaultRefreshRateInHbmSunlight() != null) {
		return refreshRateConfigs.getDefaultRefreshRateInHbmSunlight().intValue();
		} else if (resources != null) {
		return resources.getInteger(R.integer.config_defaultRefreshRateInHbmSunlight);
		}
		return DEFAULT_REFRESH_RATE_IN_HBM;
		}
		}

services/core/java/com/android/server/display/mode/DisplayModeDirector.java

+11 −7

Original line number	Diff line number	Diff line
		@@ -77,6 +77,7 @@ import com.android.internal.os.BackgroundThread;
		import com.android.server.LocalServices;
		import com.android.server.display.DisplayDeviceConfig;
		import com.android.server.display.config.IdleScreenRefreshRateTimeoutLuxThresholdPoint;
		import com.android.server.display.config.RefreshRateData;
		import com.android.server.display.feature.DeviceConfigParameterProvider;
		import com.android.server.display.feature.DisplayManagerFlags;
		import com.android.server.display.utils.AmbientFilter;
		@@ -961,13 +962,15 @@ public class DisplayModeDirector {
		* This is used to update the refresh rate configs from the DeviceConfig, which
		* if missing from DisplayDeviceConfig, and finally fallback to config.xml.
		*/
		public void setRefreshRates(DisplayDeviceConfig displayDeviceConfig,
		void setRefreshRates(DisplayDeviceConfig displayDeviceConfig,
		boolean attemptReadFromFeatureParams) {
		RefreshRateData refreshRateData = displayDeviceConfig == null ? null
		: displayDeviceConfig.getRefreshRateData();
		setDefaultPeakRefreshRate(displayDeviceConfig, attemptReadFromFeatureParams);
		mDefaultRefreshRate =
		(displayDeviceConfig == null) ? (float) mContext.getResources().getInteger(
		(refreshRateData == null) ? (float) mContext.getResources().getInteger(
		R.integer.config_defaultRefreshRate)
		: (float) displayDeviceConfig.getDefaultRefreshRate();
		: (float) refreshRateData.defaultRefreshRate;
		}

		public void observe() {
		@@ -1049,7 +1052,8 @@ public class DisplayModeDirector {
		defaultPeakRefreshRate =
		(displayDeviceConfig == null) ? (float) mContext.getResources().getInteger(
		R.integer.config_defaultPeakRefreshRate)
		: (float) displayDeviceConfig.getDefaultPeakRefreshRate();
		: (float) displayDeviceConfig.getRefreshRateData()
		.defaultPeakRefreshRate;
		}
		mDefaultPeakRefreshRate = defaultPeakRefreshRate;
		}
		@@ -2809,7 +2813,7 @@ public class DisplayModeDirector {
		private int getRefreshRateInHbmHdr(DisplayDeviceConfig displayDeviceConfig) {
		return getRefreshRate(
		() -> mConfigParameterProvider.getRefreshRateInHbmHdr(),
		() -> displayDeviceConfig.getDefaultRefreshRateInHbmHdr(),
		() -> displayDeviceConfig.getRefreshRateData().defaultRefreshRateInHbmHdr,
		R.integer.config_defaultRefreshRateInHbmHdr,
		displayDeviceConfig
		);
		@@ -2818,7 +2822,7 @@ public class DisplayModeDirector {
		private int getRefreshRateInHbmSunlight(DisplayDeviceConfig displayDeviceConfig) {
		return getRefreshRate(
		() -> mConfigParameterProvider.getRefreshRateInHbmSunlight(),
		() -> displayDeviceConfig.getDefaultRefreshRateInHbmSunlight(),
		() -> displayDeviceConfig.getRefreshRateData().defaultRefreshRateInHbmSunlight,
		R.integer.config_defaultRefreshRateInHbmSunlight,
		displayDeviceConfig
		);

services/tests/displayservicetests/src/com/android/server/display/DisplayDeviceConfigTest.java

+13 −9

Original line number	Diff line number	Diff line
		@@ -57,6 +57,7 @@ import com.android.internal.R;
		import com.android.server.display.config.HdrBrightnessData;
		import com.android.server.display.config.HysteresisLevels;
		import com.android.server.display.config.IdleScreenRefreshRateTimeoutLuxThresholdPoint;
		import com.android.server.display.config.RefreshRateData;
		import com.android.server.display.config.ThermalStatus;
		import com.android.server.display.feature.DisplayManagerFlags;
		import com.android.server.display.feature.flags.Flags;
		@@ -222,17 +223,18 @@ public final class DisplayDeviceConfigTest {
		assertArrayEquals(new float[]{0.23f, 0.24f, 0.25f},
		ambientIdleHysteresis.getDarkeningThresholdsPercentages(), ZERO_DELTA);

		RefreshRateData refreshRateData = mDisplayDeviceConfig.getRefreshRateData();
		assertEquals(75, mDisplayDeviceConfig.getDefaultLowBlockingZoneRefreshRate());
		assertEquals(90, mDisplayDeviceConfig.getDefaultHighBlockingZoneRefreshRate());
		assertEquals(85, mDisplayDeviceConfig.getDefaultPeakRefreshRate());
		assertEquals(45, mDisplayDeviceConfig.getDefaultRefreshRate());
		assertEquals(85, refreshRateData.defaultPeakRefreshRate);
		assertEquals(45, refreshRateData.defaultRefreshRate);
		assertEquals(2, mDisplayDeviceConfig.getRefreshRangeProfiles().size());
		assertEquals(60, mDisplayDeviceConfig.getRefreshRange("test1").min, SMALL_DELTA);
		assertEquals(60, mDisplayDeviceConfig.getRefreshRange("test1").max, SMALL_DELTA);
		assertEquals(80, mDisplayDeviceConfig.getRefreshRange("test2").min, SMALL_DELTA);
		assertEquals(90, mDisplayDeviceConfig.getRefreshRange("test2").max, SMALL_DELTA);
		assertEquals(82, mDisplayDeviceConfig.getDefaultRefreshRateInHbmHdr());
		assertEquals(83, mDisplayDeviceConfig.getDefaultRefreshRateInHbmSunlight());
		assertEquals(82, refreshRateData.defaultRefreshRateInHbmHdr);
		assertEquals(83, refreshRateData.defaultRefreshRateInHbmSunlight);

		assertNotNull(mDisplayDeviceConfig.getHostUsiVersion());
		assertEquals(mDisplayDeviceConfig.getHostUsiVersion().getMajorVersion(), 2);
		@@ -697,6 +699,7 @@ public final class DisplayDeviceConfigTest {
		HysteresisLevels screenHysteresis = mDisplayDeviceConfig.getScreenBrightnessHysteresis();
		HysteresisLevels screenIdleHysteresis =
		mDisplayDeviceConfig.getScreenBrightnessIdleHysteresis();

		// Test thresholds
		assertEquals(0, ambientHysteresis.getMinBrightening(), ZERO_DELTA);
		assertEquals(0, ambientIdleHysteresis.getMinBrightening(), ZERO_DELTA);
		@@ -737,6 +740,8 @@ public final class DisplayDeviceConfigTest {
		assertArrayEquals(new float[]{0.37f, 0.38f, 0.39f},
		screenIdleHysteresis.getDarkeningThresholdsPercentages(), ZERO_DELTA);

		RefreshRateData refreshRateData = mDisplayDeviceConfig.getRefreshRateData();

		assertArrayEquals(new float[]{0, 30, 31},
		ambientIdleHysteresis.getBrighteningThresholdLevels(), ZERO_DELTA);
		assertArrayEquals(new float[]{0.27f, 0.28f, 0.29f},
		@@ -749,13 +754,12 @@ public final class DisplayDeviceConfigTest {
		DEFAULT_LOW_BLOCKING_ZONE_REFRESH_RATE);
		assertEquals(mDisplayDeviceConfig.getDefaultHighBlockingZoneRefreshRate(),
		DEFAULT_HIGH_BLOCKING_ZONE_REFRESH_RATE);
		assertEquals(mDisplayDeviceConfig.getDefaultPeakRefreshRate(), DEFAULT_PEAK_REFRESH_RATE);
		assertEquals(mDisplayDeviceConfig.getDefaultRefreshRate(), DEFAULT_REFRESH_RATE);
		assertEquals(refreshRateData.defaultPeakRefreshRate, DEFAULT_PEAK_REFRESH_RATE);
		assertEquals(refreshRateData.defaultRefreshRate, DEFAULT_REFRESH_RATE);
		assertEquals(0, mDisplayDeviceConfig.getRefreshRangeProfiles().size());
		assertEquals(mDisplayDeviceConfig.getDefaultRefreshRateInHbmSunlight(),
		assertEquals(refreshRateData.defaultRefreshRateInHbmSunlight,
		DEFAULT_REFRESH_RATE_IN_HBM_SUNLIGHT);
		assertEquals(mDisplayDeviceConfig.getDefaultRefreshRateInHbmHdr(),
		DEFAULT_REFRESH_RATE_IN_HBM_HDR);
		assertEquals(refreshRateData.defaultRefreshRateInHbmHdr, DEFAULT_REFRESH_RATE_IN_HBM_HDR);

		assertEquals("test_light_sensor", mDisplayDeviceConfig.getAmbientLightSensor().type);
		assertEquals("", mDisplayDeviceConfig.getAmbientLightSensor().name);

services/tests/displayservicetests/src/com/android/server/display/mode/DisplayModeDirectorTest.java

+17 −4

File changed.

Preview size limit exceeded, changes collapsed.