Merge "Change TimeDetectorStrategy.Environment API" (8e40ded4) · Commits · e / os / android_frameworks_base

core/java/android/app/time/TimeCapabilities.java

+61 −38

Original line number	Diff line number	Diff line
		@@ -16,7 +16,10 @@

		package android.app.time;

		import static android.app.time.Capabilities.CAPABILITY_NOT_APPLICABLE;

		import android.annotation.NonNull;
		import android.annotation.Nullable;
		import android.app.time.Capabilities.CapabilityState;
		import android.os.Parcel;
		import android.os.Parcelable;
		@@ -54,40 +57,40 @@ public final class TimeCapabilities implements Parcelable {
		*/
		@NonNull
		private final UserHandle mUserHandle;
		private final @CapabilityState int mConfigureAutoTimeDetectionEnabledCapability;
		private final @CapabilityState int mSuggestTimeManuallyCapability;
		private final @CapabilityState int mConfigureAutoDetectionEnabledCapability;
		private final @CapabilityState int mSuggestManualTimeCapability;

		private TimeCapabilities(@NonNull Builder builder) {
		this.mUserHandle = Objects.requireNonNull(builder.mUserHandle);
		this.mConfigureAutoTimeDetectionEnabledCapability =
		this.mConfigureAutoDetectionEnabledCapability =
		builder.mConfigureAutoDetectionEnabledCapability;
		this.mSuggestTimeManuallyCapability =
		builder.mSuggestTimeManuallyCapability;
		this.mSuggestManualTimeCapability = builder.mSuggestManualTimeCapability;
		}

		@NonNull
		private static TimeCapabilities createFromParcel(Parcel in) {
		UserHandle userHandle = UserHandle.readFromParcel(in);
		return new TimeCapabilities.Builder(userHandle)
		.setConfigureAutoTimeDetectionEnabledCapability(in.readInt())
		.setSuggestTimeManuallyCapability(in.readInt())
		.setConfigureAutoDetectionEnabledCapability(in.readInt())
		.setSuggestManualTimeCapability(in.readInt())
		.build();
		}

		@Override
		public void writeToParcel(@NonNull Parcel dest, int flags) {
		UserHandle.writeToParcel(mUserHandle, dest);
		dest.writeInt(mConfigureAutoTimeDetectionEnabledCapability);
		dest.writeInt(mSuggestTimeManuallyCapability);
		dest.writeInt(mConfigureAutoDetectionEnabledCapability);
		dest.writeInt(mSuggestManualTimeCapability);
		}

		/**
		* Returns the capability state associated with the user's ability to modify the automatic time
		* detection setting.
		* detection setting. The setting can be updated via {@link
		* TimeManager#updateTimeConfiguration(TimeConfiguration)}.
		*/
		@CapabilityState
		public int getConfigureAutoTimeDetectionEnabledCapability() {
		return mConfigureAutoTimeDetectionEnabledCapability;
		public int getConfigureAutoDetectionEnabledCapability() {
		return mConfigureAutoDetectionEnabledCapability;
		}

		/**
		@@ -95,8 +98,31 @@ public final class TimeCapabilities implements Parcelable {
		* device.
		*/
		@CapabilityState
		public int getSuggestTimeManuallyCapability() {
		return mSuggestTimeManuallyCapability;
		public int getSuggestManualTimeCapability() {
		return mSuggestManualTimeCapability;
		}

		/**
		* Tries to create a new {@link TimeConfiguration} from the {@code config} and the set of
		* {@code requestedChanges}, if {@code this} capabilities allow. The new configuration is
		* returned. If the capabilities do not permit one or more of the requested changes then {@code
		* null} is returned.
		*
		* @hide
		*/
		@Nullable
		public TimeConfiguration tryApplyConfigChanges(
		@NonNull TimeConfiguration config,
		@NonNull TimeConfiguration requestedChanges) {
		TimeConfiguration.Builder newConfigBuilder = new TimeConfiguration.Builder(config);
		if (requestedChanges.hasIsAutoDetectionEnabled()) {
		if (this.getConfigureAutoDetectionEnabledCapability() < CAPABILITY_NOT_APPLICABLE) {
		return null;
		}
		newConfigBuilder.setAutoDetectionEnabled(requestedChanges.isAutoDetectionEnabled());
		}

		return newConfigBuilder.build();
		}

		@Override
		@@ -109,25 +135,25 @@ public final class TimeCapabilities implements Parcelable {
		if (this == o) return true;
		if (o == null \|\| getClass() != o.getClass()) return false;
		TimeCapabilities that = (TimeCapabilities) o;
		return mConfigureAutoTimeDetectionEnabledCapability
		== that.mConfigureAutoTimeDetectionEnabledCapability
		&& mSuggestTimeManuallyCapability == that.mSuggestTimeManuallyCapability
		return mConfigureAutoDetectionEnabledCapability
		== that.mConfigureAutoDetectionEnabledCapability
		&& mSuggestManualTimeCapability == that.mSuggestManualTimeCapability
		&& mUserHandle.equals(that.mUserHandle);
		}

		@Override
		public int hashCode() {
		return Objects.hash(mUserHandle, mConfigureAutoTimeDetectionEnabledCapability,
		mSuggestTimeManuallyCapability);
		return Objects.hash(mUserHandle, mConfigureAutoDetectionEnabledCapability,
		mSuggestManualTimeCapability);
		}

		@Override
		public String toString() {
		return "TimeCapabilities{"
		+ "mUserHandle=" + mUserHandle
		+ ", mConfigureAutoTimeDetectionEnabledCapability="
		+ mConfigureAutoTimeDetectionEnabledCapability
		+ ", mSuggestTimeManuallyCapability=" + mSuggestTimeManuallyCapability
		+ ", mConfigureAutoDetectionEnabledCapability="
		+ mConfigureAutoDetectionEnabledCapability
		+ ", mSuggestManualTimeCapability=" + mSuggestManualTimeCapability
		+ '}';
		}

		@@ -137,35 +163,32 @@ public final class TimeCapabilities implements Parcelable {
		* @hide
		*/
		public static class Builder {

		@NonNull private final UserHandle mUserHandle;
		private @CapabilityState int mConfigureAutoDetectionEnabledCapability;
		private @CapabilityState int mSuggestTimeManuallyCapability;
		private @CapabilityState int mSuggestManualTimeCapability;

		public Builder(@NonNull UserHandle userHandle) {
		this.mUserHandle = Objects.requireNonNull(userHandle);
		}

		public Builder(@NonNull TimeCapabilities timeCapabilities) {
		Objects.requireNonNull(timeCapabilities);
		this.mUserHandle = timeCapabilities.mUserHandle;
		this.mConfigureAutoDetectionEnabledCapability =
		timeCapabilities.mConfigureAutoTimeDetectionEnabledCapability;
		this.mSuggestTimeManuallyCapability =
		timeCapabilities.mSuggestTimeManuallyCapability;
		}

		public Builder(@NonNull UserHandle userHandle) {
		this.mUserHandle = Objects.requireNonNull(userHandle);
		timeCapabilities.mConfigureAutoDetectionEnabledCapability;
		this.mSuggestManualTimeCapability = timeCapabilities.mSuggestManualTimeCapability;
		}

		/** Sets the state for automatic time detection config. */
		public Builder setConfigureAutoTimeDetectionEnabledCapability(
		@CapabilityState int setConfigureAutoTimeDetectionEnabledCapability) {
		this.mConfigureAutoDetectionEnabledCapability =
		setConfigureAutoTimeDetectionEnabledCapability;
		public Builder setConfigureAutoDetectionEnabledCapability(@CapabilityState int value) {
		this.mConfigureAutoDetectionEnabledCapability = value;
		return this;
		}

		/** Sets the state for manual time change. */
		public Builder setSuggestTimeManuallyCapability(
		@CapabilityState int suggestTimeManuallyCapability) {
		this.mSuggestTimeManuallyCapability = suggestTimeManuallyCapability;
		public Builder setSuggestManualTimeCapability(@CapabilityState int value) {
		this.mSuggestManualTimeCapability = value;
		return this;
		}

		@@ -173,7 +196,7 @@ public final class TimeCapabilities implements Parcelable {
		public TimeCapabilities build() {
		verifyCapabilitySet(mConfigureAutoDetectionEnabledCapability,
		"configureAutoDetectionEnabledCapability");
		verifyCapabilitySet(mSuggestTimeManuallyCapability, "suggestTimeManuallyCapability");
		verifyCapabilitySet(mSuggestManualTimeCapability, "mSuggestManualTimeCapability");
		return new TimeCapabilities(this);
		}

core/java/android/app/time/TimeConfiguration.java

+79 −21

Original line number	Diff line number	Diff line
		@@ -27,8 +27,16 @@ import java.lang.annotation.RetentionPolicy;
		import java.util.Objects;

		/**
		* User visible settings that control the behavior of the time zone detector / manual time zone
		* entry.
		* User visible settings that control the behavior of the time detector / manual time entry.
		*
		* <p>When reading the configuration, values for all settings will be provided. In some cases, such
		* as when the device behavior relies on optional hardware / OEM configuration, or the value of
		* several settings, the device behavior may not be directly affected by the setting value.
		*
		* <p>Settings can be left absent when updating configuration via {@link
		* TimeManager#updateTimeConfiguration(TimeConfiguration)} and those settings will not be
		* changed. Not all configuration settings can be modified by all users: see {@link
		* TimeManager#getTimeCapabilitiesAndConfig()} and {@link TimeCapabilities} for details.
		*
		* @hide
		*/
		@@ -61,29 +69,53 @@ public final class TimeConfiguration implements Parcelable {
		this.mBundle = builder.mBundle;
		}

		private static TimeConfiguration readFromParcel(Parcel in) {
		return new TimeConfiguration.Builder()
		.setPropertyBundleInternal(in.readBundle())
		.build();
		}

		@Override
		public void writeToParcel(@NonNull Parcel dest, int flags) {
		dest.writeBundle(mBundle);
		}

		/**
		* Returns {@code true} if all known settings are present.
		*
		* @hide
		*/
		public boolean isComplete() {
		return hasIsAutoDetectionEnabled();
		}

		/**
		* Returns the value of the {@link #SETTING_AUTO_DETECTION_ENABLED} setting. This
		* controls whether a device will attempt to determine the time automatically using
		* contextual information if the device supports auto detection.
		*
		* <p>See {@link TimeCapabilities#getConfigureAutoDetectionEnabledCapability()} for how to
		* tell if the setting is meaningful for the current user at this time.
		*
		* @throws IllegalStateException if the setting is not present
		*/
		public boolean isAutoDetectionEnabled() {
		enforceSettingPresent(SETTING_AUTO_DETECTION_ENABLED);
		return mBundle.getBoolean(SETTING_AUTO_DETECTION_ENABLED);
		}

		@Override
		public int describeContents() {
		return 0;
		/**
		* Returns {@code true} if the {@link #isAutoDetectionEnabled()} setting is present.
		*
		* @hide
		*/
		public boolean hasIsAutoDetectionEnabled() {
		return mBundle.containsKey(SETTING_AUTO_DETECTION_ENABLED);
		}

		@Override
		public void writeToParcel(@NonNull Parcel dest, int flags) {
		dest.writeBundle(mBundle);
		}

		private static TimeConfiguration readFromParcel(Parcel in) {
		return new TimeConfiguration.Builder()
		.merge(in.readBundle())
		.build();
		public int describeContents() {
		return 0;
		}

		@Override
		@@ -106,33 +138,59 @@ public final class TimeConfiguration implements Parcelable {
		+ '}';
		}

		private void enforceSettingPresent(@TimeZoneConfiguration.Setting String setting) {
		if (!mBundle.containsKey(setting)) {
		throw new IllegalStateException(setting + " is not set");
		}
		}

		/**
		* A builder for {@link TimeConfiguration} objects.
		*
		* @hide
		*/
		public static final class Builder {

		private final Bundle mBundle = new Bundle();

		/**
		* Creates a new Builder with no settings held.
		*/
		public Builder() {}

		public Builder(@NonNull TimeConfiguration configuration) {
		mBundle.putAll(configuration.mBundle);
		/**
		* Creates a new Builder by copying the settings from an existing instance.
		*/
		public Builder(@NonNull TimeConfiguration toCopy) {
		mergeProperties(toCopy);
		}

		/** Sets whether auto detection is enabled or not. */
		/**
		* Merges {@code other} settings into this instances, replacing existing values in this
		* where the settings appear in both.
		*
		* @hide
		*/
		@NonNull
		public Builder setAutoDetectionEnabled(boolean enabled) {
		mBundle.putBoolean(SETTING_AUTO_DETECTION_ENABLED, enabled);
		public Builder mergeProperties(@NonNull TimeConfiguration toCopy) {
		mBundle.putAll(toCopy.mBundle);
		return this;
		}

		@NonNull
		Builder setPropertyBundleInternal(@NonNull Bundle bundle) {
		this.mBundle.putAll(bundle);
		return this;
		}

		Builder merge(@NonNull Bundle bundle) {
		mBundle.putAll(bundle);
		/** Sets whether auto detection is enabled or not. */
		@NonNull
		public Builder setAutoDetectionEnabled(boolean enabled) {
		mBundle.putBoolean(SETTING_AUTO_DETECTION_ENABLED, enabled);
		return this;
		}

		/** Returns {@link TimeConfiguration} object. */
		/** Returns the {@link TimeConfiguration}. */
		@NonNull
		public TimeConfiguration build() {
		return new TimeConfiguration(this);

core/tests/coretests/src/android/app/time/TimeCapabilitiesTest.java

+151 −29

Original line number	Diff line number	Diff line
		@@ -17,6 +17,7 @@
		package android.app.time;


		import static android.app.time.Capabilities.CAPABILITY_NOT_ALLOWED;
		import static android.app.time.Capabilities.CAPABILITY_NOT_APPLICABLE;
		import static android.app.time.Capabilities.CAPABILITY_NOT_SUPPORTED;
		import static android.app.time.Capabilities.CAPABILITY_POSSESSED;
		@@ -24,6 +25,9 @@ import static android.app.timezonedetector.ParcelableTestSupport.assertRoundTrip

		import static com.google.common.truth.Truth.assertThat;

		import static org.junit.Assert.assertEquals;
		import static org.junit.Assert.assertNotEquals;
		import static org.junit.Assert.assertNull;
		import static org.junit.Assert.fail;

		import android.os.UserHandle;
		@@ -38,22 +42,80 @@ import org.junit.runner.RunWith;
		@SmallTest
		public class TimeCapabilitiesTest {

		private static final UserHandle USER_HANDLE = UserHandle.of(332211);
		private static final UserHandle TEST_USER_HANDLE = UserHandle.of(332211);

		@Test
		public void testEquals() {
		TimeCapabilities.Builder builder1 = new TimeCapabilities.Builder(TEST_USER_HANDLE)
		.setConfigureAutoDetectionEnabledCapability(CAPABILITY_POSSESSED)
		.setSuggestManualTimeCapability(CAPABILITY_POSSESSED);
		TimeCapabilities.Builder builder2 = new TimeCapabilities.Builder(TEST_USER_HANDLE)
		.setConfigureAutoDetectionEnabledCapability(CAPABILITY_POSSESSED)
		.setSuggestManualTimeCapability(CAPABILITY_POSSESSED);
		{
		TimeCapabilities one = builder1.build();
		TimeCapabilities two = builder2.build();
		assertEquals(one, two);
		}

		builder2.setConfigureAutoDetectionEnabledCapability(CAPABILITY_NOT_ALLOWED);
		{
		TimeCapabilities one = builder1.build();
		TimeCapabilities two = builder2.build();
		assertNotEquals(one, two);
		}

		builder1.setConfigureAutoDetectionEnabledCapability(CAPABILITY_NOT_ALLOWED);
		{
		TimeCapabilities one = builder1.build();
		TimeCapabilities two = builder2.build();
		assertEquals(one, two);
		}

		builder2.setSuggestManualTimeCapability(CAPABILITY_NOT_ALLOWED);
		{
		TimeCapabilities one = builder1.build();
		TimeCapabilities two = builder2.build();
		assertNotEquals(one, two);
		}

		builder1.setSuggestManualTimeCapability(CAPABILITY_NOT_ALLOWED);
		{
		TimeCapabilities one = builder1.build();
		TimeCapabilities two = builder2.build();
		assertEquals(one, two);
		}
		}

		@Test
		public void userHandle_notIgnoredInEquals() {
		TimeCapabilities firstUserCapabilities = new TimeCapabilities.Builder(UserHandle.of(1))
		.setConfigureAutoDetectionEnabledCapability(CAPABILITY_POSSESSED)
		.setSuggestManualTimeCapability(CAPABILITY_POSSESSED)
		.build();

		TimeCapabilities secondUserCapabilities = new TimeCapabilities.Builder(UserHandle.of(2))
		.setConfigureAutoDetectionEnabledCapability(CAPABILITY_POSSESSED)
		.setSuggestManualTimeCapability(CAPABILITY_POSSESSED)
		.build();

		assertThat(firstUserCapabilities).isNotEqualTo(secondUserCapabilities);
		}

		@Test
		public void testBuilder() {
		TimeCapabilities capabilities = new TimeCapabilities.Builder(USER_HANDLE)
		.setConfigureAutoTimeDetectionEnabledCapability(CAPABILITY_NOT_APPLICABLE)
		.setSuggestTimeManuallyCapability(CAPABILITY_NOT_SUPPORTED)
		TimeCapabilities capabilities = new TimeCapabilities.Builder(TEST_USER_HANDLE)
		.setConfigureAutoDetectionEnabledCapability(CAPABILITY_NOT_APPLICABLE)
		.setSuggestManualTimeCapability(CAPABILITY_NOT_SUPPORTED)
		.build();

		assertThat(capabilities.getConfigureAutoTimeDetectionEnabledCapability())
		assertThat(capabilities.getConfigureAutoDetectionEnabledCapability())
		.isEqualTo(CAPABILITY_NOT_APPLICABLE);
		assertThat(capabilities.getSuggestTimeManuallyCapability())
		assertThat(capabilities.getSuggestManualTimeCapability())
		.isEqualTo(CAPABILITY_NOT_SUPPORTED);

		try {
		new TimeCapabilities.Builder(USER_HANDLE)
		new TimeCapabilities.Builder(TEST_USER_HANDLE)
		.build();
		fail("Should throw IllegalStateException");
		} catch (IllegalStateException ignored) {
		@@ -61,8 +123,8 @@ public class TimeCapabilitiesTest {
		}

		try {
		new TimeCapabilities.Builder(USER_HANDLE)
		.setConfigureAutoTimeDetectionEnabledCapability(CAPABILITY_NOT_APPLICABLE)
		new TimeCapabilities.Builder(TEST_USER_HANDLE)
		.setConfigureAutoDetectionEnabledCapability(CAPABILITY_NOT_APPLICABLE)
		.build();
		fail("Should throw IllegalStateException");
		} catch (IllegalStateException ignored) {
		@@ -70,8 +132,8 @@ public class TimeCapabilitiesTest {
		}

		try {
		new TimeCapabilities.Builder(USER_HANDLE)
		.setSuggestTimeManuallyCapability(CAPABILITY_NOT_APPLICABLE)
		new TimeCapabilities.Builder(TEST_USER_HANDLE)
		.setSuggestManualTimeCapability(CAPABILITY_NOT_APPLICABLE)
		.build();
		fail("Should throw IllegalStateException");
		} catch (IllegalStateException ignored) {
		@@ -80,33 +142,93 @@ public class TimeCapabilitiesTest {
		}

		@Test
		public void userHandle_notIgnoredInEquals() {
		TimeCapabilities firstUserCapabilities = new TimeCapabilities.Builder(UserHandle.of(1))
		.setConfigureAutoTimeDetectionEnabledCapability(CAPABILITY_POSSESSED)
		.setSuggestTimeManuallyCapability(CAPABILITY_POSSESSED)
		public void testParcelable() {
		TimeCapabilities.Builder builder = new TimeCapabilities.Builder(TEST_USER_HANDLE)
		.setConfigureAutoDetectionEnabledCapability(CAPABILITY_NOT_SUPPORTED)
		.setSuggestManualTimeCapability(CAPABILITY_NOT_SUPPORTED);

		assertRoundTripParcelable(builder.build());

		builder.setSuggestManualTimeCapability(CAPABILITY_POSSESSED);
		assertRoundTripParcelable(builder.build());

		builder.setConfigureAutoDetectionEnabledCapability(CAPABILITY_POSSESSED);
		assertRoundTripParcelable(builder.build());
		}

		@Test
		public void testTryApplyConfigChanges_permitted() {
		TimeConfiguration oldConfiguration =
		new TimeConfiguration.Builder()
		.setAutoDetectionEnabled(true)
		.build();
		TimeCapabilities capabilities = new TimeCapabilities.Builder(TEST_USER_HANDLE)
		.setConfigureAutoDetectionEnabledCapability(CAPABILITY_POSSESSED)
		.setSuggestManualTimeCapability(CAPABILITY_POSSESSED)
		.build();

		TimeCapabilities secondUserCapabilities = new TimeCapabilities.Builder(UserHandle.of(2))
		.setConfigureAutoTimeDetectionEnabledCapability(CAPABILITY_POSSESSED)
		.setSuggestTimeManuallyCapability(CAPABILITY_POSSESSED)
		TimeConfiguration configChange = new TimeConfiguration.Builder()
		.setAutoDetectionEnabled(false)
		.build();

		assertThat(firstUserCapabilities).isNotEqualTo(secondUserCapabilities);
		TimeConfiguration expected = new TimeConfiguration.Builder(oldConfiguration)
		.setAutoDetectionEnabled(false)
		.build();
		assertEquals(expected, capabilities.tryApplyConfigChanges(oldConfiguration, configChange));
		}

		@Test
		public void testParcelable() {
		TimeCapabilities.Builder builder = new TimeCapabilities.Builder(USER_HANDLE)
		.setConfigureAutoTimeDetectionEnabledCapability(CAPABILITY_NOT_SUPPORTED)
		.setSuggestTimeManuallyCapability(CAPABILITY_NOT_SUPPORTED);
		public void testTryApplyConfigChanges_notPermitted() {
		TimeConfiguration oldConfiguration =
		new TimeConfiguration.Builder()
		.setAutoDetectionEnabled(true)
		.build();
		TimeCapabilities capabilities = new TimeCapabilities.Builder(TEST_USER_HANDLE)
		.setConfigureAutoDetectionEnabledCapability(CAPABILITY_NOT_ALLOWED)
		.setSuggestManualTimeCapability(CAPABILITY_NOT_ALLOWED)
		.build();

		assertRoundTripParcelable(builder.build());
		TimeConfiguration configChange = new TimeConfiguration.Builder()
		.setAutoDetectionEnabled(false)
		.build();

		builder.setSuggestTimeManuallyCapability(CAPABILITY_POSSESSED);
		assertRoundTripParcelable(builder.build());
		assertNull(capabilities.tryApplyConfigChanges(oldConfiguration, configChange));
		}

		builder.setConfigureAutoTimeDetectionEnabledCapability(CAPABILITY_POSSESSED);
		assertRoundTripParcelable(builder.build());
		@Test
		public void copyBuilder_copiesAllFields() {
		TimeCapabilities capabilities = new TimeCapabilities.Builder(TEST_USER_HANDLE)
		.setConfigureAutoDetectionEnabledCapability(CAPABILITY_NOT_ALLOWED)
		.setSuggestManualTimeCapability(CAPABILITY_NOT_ALLOWED)
		.build();

		{
		TimeCapabilities updatedCapabilities =
		new TimeCapabilities.Builder(capabilities)
		.setConfigureAutoDetectionEnabledCapability(CAPABILITY_POSSESSED)
		.build();
		TimeCapabilities expectedCapabilities =
		new TimeCapabilities.Builder(TEST_USER_HANDLE)
		.setConfigureAutoDetectionEnabledCapability(CAPABILITY_POSSESSED)
		.setSuggestManualTimeCapability(CAPABILITY_NOT_ALLOWED)
		.build();

		assertThat(updatedCapabilities).isEqualTo(expectedCapabilities);
		}

		{
		TimeCapabilities updatedCapabilities =
		new TimeCapabilities.Builder(capabilities)
		.setSuggestManualTimeCapability(CAPABILITY_POSSESSED)
		.build();

		TimeCapabilities expectedCapabilities =
		new TimeCapabilities.Builder(TEST_USER_HANDLE)
		.setConfigureAutoDetectionEnabledCapability(CAPABILITY_NOT_ALLOWED)
		.setSuggestManualTimeCapability(CAPABILITY_POSSESSED)
		.build();

		assertThat(updatedCapabilities).isEqualTo(expectedCapabilities);
		}
		}
		}

services/core/java/com/android/server/timedetector/ConfigurationInternal.java

+130 −27

File changed.

Preview size limit exceeded, changes collapsed.

services/core/java/com/android/server/timedetector/EnvironmentImpl.java

+7 −58

File changed.

Preview size limit exceeded, changes collapsed.