Fix logic used for auto time zone settings

Fix the logic used that determines whether the automatic time
zone detection toggle is available in the Settings UI Date & Time
screen. Also, ensure that the TimeZonePreferenceController uses correct
logic for whether the user can manually enter a time zone.

This change migrates the controllers to use a existing high-level
TimeManager API rather than (incorrectly) duplicating in Settings UI the
logic for whether time zone detection is supported / enabled.

Without this change, WiFi-only devices _with_ location-based time zone
detection enabled would incorrectly hide the "auto time zone" toggle,
which would have the knock-on of making it look like the user is allowed
to enter a time zone manually when they aren't (because it is
enabled/disabled based on the presence of the toggle).

That toggle still needs to be present while there is a possible time
zone detection mechanism. All the (quite complex) logic around this is
already considered by the TimeManager API.

Possible side effects:

This change decouples the "does the toggle show true or false?"
(isEnabled()) from the "should the toggle be shown at all?"
(isAvailable()) logic by removing a call to isAvailable() inside of
isEnabled(). This is to avoid making multiple (probably more expensive
than what it was doing before) calls to the time_zone_detector service,
and avoid the extra complexity of caching / cache invalidation that
would be needed to mitigate it. Previously, as a result of the call to
isAvailable(), isEnabled() would always return false when mIsFromSUW is
true, but now it will return the underlying value of the device's
auto_time_zone setting. This means that if the UI is changed in future
to render a visible-but-can't-be-changed-by-the-user toggle for auto
time zone, it will display the current setting value, which is perfectly
reasonable.  It is assumed it will have no other side effects.

The AutoTimeZonePreferenceControllerTest.isFromSUW_notEnable test has
been changed to reflect the change in behavior. Various name changes
made to tests to reflect the new behavior.

Bug: 228247623
Bug: 186625820
Bug: 172891783
Test: treehugger
Test: Manual test on a device with telephony
Test: m ROBOTEST_FILTER=AutoTimeZonePreferenceControllerTest RunSettingsRoboTests -j40
Test: m ROBOTEST_FILTER=TimeZonePreferenceControllerTest RunSettingsRoboTests -j40
Change-Id: I4c7608e8645eee5994c8ecf85a14a27d3278ac04
(cherry picked from commit 7a8ac683d4)

tests/robotests/src/com/android/settings/datetime/TimeZonePreferenceControllerTest.java

@@ -22,7 +22,13 @@ import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.when;
 
+import android.app.time.Capabilities;
+import android.app.time.TimeManager;
+import android.app.time.TimeZoneCapabilities;
+import android.app.time.TimeZoneCapabilitiesAndConfig;
+import android.app.time.TimeZoneConfiguration;
 import android.content.Context;
+import android.os.UserHandle;
 
 import com.android.settingslib.RestrictedPreference;
 
@@ -38,8 +44,7 @@ import org.robolectric.RuntimeEnvironment;
 public class TimeZonePreferenceControllerTest {
 
     @Mock
-    private AutoTimeZonePreferenceController mAutoTimeZonePreferenceController;
-
+    private TimeManager mTimeManager;
     private Context mContext;
     private TimeZonePreferenceController mController;
     private RestrictedPreference mPreference;
@@ -47,10 +52,14 @@ public class TimeZonePreferenceControllerTest {
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
-        mContext = RuntimeEnvironment.application;
+
+        mContext = spy(RuntimeEnvironment.application);
+        doReturn(mTimeManager).when(mContext).getSystemService(TimeManager.class);
+
         mPreference = new RestrictedPreference(mContext);
-        mController = spy(new TimeZonePreferenceController(mContext,
-                mAutoTimeZonePreferenceController));
+
+        mController = spy(new TimeZonePreferenceController(mContext));
+        doReturn("test timezone").when(mController).getTimeZoneOffsetAndName();
     }
 
     @Test
@@ -59,26 +68,46 @@ public class TimeZonePreferenceControllerTest {
     }
 
     @Test
-    public void updateState_autoTimeZoneEnabled_shouldDisablePref() {
+    public void updateState_suggestManualNotAllowed_shouldDisablePref() {
         // Make sure not disabled by admin.
         mPreference.setDisabledByAdmin(null);
 
-        doReturn("test timezone").when(mController).getTimeZoneOffsetAndName();
-        when(mAutoTimeZonePreferenceController.isEnabled()).thenReturn(true);
+        TimeZoneCapabilitiesAndConfig capabilitiesAndConfig = createCapabilitiesAndConfig(
+            /* suggestManualAllowed= */false);
+        when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
+
         mController.updateState(mPreference);
 
         assertThat(mPreference.isEnabled()).isFalse();
     }
 
     @Test
-    public void updateState_autoTimeZoneDisabled_shouldEnablePref() {
+    public void updateState_suggestManualAllowed_shouldEnablePref() {
         // Make sure not disabled by admin.
         mPreference.setDisabledByAdmin(null);
 
-        doReturn("test timezone").when(mController).getTimeZoneOffsetAndName();
-        when(mAutoTimeZonePreferenceController.isEnabled()).thenReturn(false);
+        TimeZoneCapabilitiesAndConfig capabilitiesAndConfig = createCapabilitiesAndConfig(
+            /* suggestManualAllowed= */true);
+        when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
+
         mController.updateState(mPreference);
 
         assertThat(mPreference.isEnabled()).isTrue();
     }
+
+    private static TimeZoneCapabilitiesAndConfig createCapabilitiesAndConfig(
+            boolean suggestManualAllowed) {
+        int suggestManualCapability = suggestManualAllowed ? Capabilities.CAPABILITY_POSSESSED
+                : Capabilities.CAPABILITY_NOT_SUPPORTED;
+        TimeZoneCapabilities capabilities = new TimeZoneCapabilities.Builder(UserHandle.SYSTEM)
+                .setConfigureAutoDetectionEnabledCapability(Capabilities.CAPABILITY_POSSESSED)
+                .setConfigureGeoDetectionEnabledCapability(Capabilities.CAPABILITY_NOT_SUPPORTED)
+                .setSuggestManualTimeZoneCapability(suggestManualCapability)
+                .build();
+        TimeZoneConfiguration config = new TimeZoneConfiguration.Builder()
+                .setAutoDetectionEnabled(!suggestManualAllowed)
+                .setGeoDetectionEnabled(false)
+                .build();
+        return new TimeZoneCapabilitiesAndConfig(capabilities, config);
+    }
 }