From 0313abd3d38c7cb5693c402858567493d8bf99d1 Mon Sep 17 00:00:00 2001
From: Neil Fuller <nfuller@google.com>
Date: Wed, 3 Nov 2021 15:40:43 +0000
Subject: [PATCH] Add support for tz detection telephony fallback

This adds support for a telephony fallback mode used when geolocation
time zone detection is enabled. Before this change, when geolocation tz
detection mode was enabled only geolocation signals were used. To
improve behavior when geolocation detection doesn't work or is slow
after a flight (or immediately after boot), this "latched" fallback mode
allows telephony suggestions to be used until the geolocation algorithm
makes a "certain" suggestion. See more TimeZoneDetectorStrategy for more
information.

The "flight detection" is entirely based on the user switching off
airplane mode in this version.

Bug: 197624972
Test: atest services/tests/servicestests/src/com/android/server/timezonedetector/
Change-Id: Id72108c6ccb273fb8b7dd52847e2a750cd0a676a
---
 .../timezonedetector/TimeZoneDetector.java    |   7 +
 core/res/res/values/config.xml                |   7 +
 core/res/res/values/symbols.xml               |   1 +
 .../server/timedetector/ServerFlags.java      |   9 +
 .../ConfigurationInternal.java                |  27 +-
 .../DeviceActivityMonitor.java                |  40 +++
 .../DeviceActivityMonitorImpl.java            |  94 +++++++
 .../timezonedetector/EnvironmentImpl.java     |   7 +
 .../MetricsTimeZoneDetectorState.java         |   5 +
 .../ServiceConfigAccessorImpl.java            |   9 +
 .../TimeZoneDetectorService.java              |  23 ++
 .../TimeZoneDetectorShellCommand.java         |  19 ++
 .../TimeZoneDetectorStrategy.java             |  21 ++
 .../TimeZoneDetectorStrategyImpl.java         | 162 ++++++++++-
 .../ConfigurationInternalTest.java            |  18 ++
 .../FakeTimeZoneDetectorStrategy.java         |   5 +
 .../TimeZoneDetectorServiceTest.java          |   1 +
 .../TimeZoneDetectorStrategyImplTest.java     | 255 +++++++++++++++++-
 .../location/TestSupport.java                 |   1 +
 19 files changed, 696 insertions(+), 15 deletions(-)
 create mode 100644 services/core/java/com/android/server/timezonedetector/DeviceActivityMonitor.java
 create mode 100644 services/core/java/com/android/server/timezonedetector/DeviceActivityMonitorImpl.java

diff --git a/core/java/android/app/timezonedetector/TimeZoneDetector.java b/core/java/android/app/timezonedetector/TimeZoneDetector.java
index a71cffe5afc0b..ceab02f510629 100644
--- a/core/java/android/app/timezonedetector/TimeZoneDetector.java
+++ b/core/java/android/app/timezonedetector/TimeZoneDetector.java
@@ -95,6 +95,13 @@ public interface TimeZoneDetector {
      */
     String SHELL_COMMAND_SUGGEST_TELEPHONY_TIME_ZONE = "suggest_telephony_time_zone";
 
+    /**
+     * A shell command that enables telephony time zone fallback. See {@link
+     * com.android.server.timezonedetector.TimeZoneDetectorStrategy} for details.
+     * @hide
+     */
+    String SHELL_COMMAND_ENABLE_TELEPHONY_FALLBACK = "enable_telephony_fallback";
+
     /**
      * A shared utility method to create a {@link ManualTimeZoneSuggestion}.
      *
diff --git a/core/res/res/values/config.xml b/core/res/res/values/config.xml
index a36785f37d3f9..7262ae4157abd 100644
--- a/core/res/res/values/config.xml
+++ b/core/res/res/values/config.xml
@@ -1767,6 +1767,13 @@
          provider services. -->
     <string name="config_secondaryLocationTimeZoneProviderPackageName" translatable="false"></string>
 
+    <!-- Whether the time zone detection logic supports fall back from geolocation suggestions to
+         telephony suggestions temporarily in certain circumstances. Reduces time zone detection
+         latency during some scenarios like air travel. Only useful when both geolocation and
+         telephony time zone detection are supported on a device.
+         See com.android.server.timezonedetector.TimeZoneDetectorStrategy for more information. -->
+    <bool name="config_supportTelephonyTimeZoneFallback" translatable="false">false</bool>
+
     <!-- Whether to enable network location overlay which allows network location provider to be
          replaced by an app at run-time. When disabled, only the
          config_networkLocationProviderPackageName package will be searched for network location
diff --git a/core/res/res/values/symbols.xml b/core/res/res/values/symbols.xml
index faa99027d9ad6..5fdbff3275027 100644
--- a/core/res/res/values/symbols.xml
+++ b/core/res/res/values/symbols.xml
@@ -2237,6 +2237,7 @@
   <java-symbol type="string" name="config_primaryLocationTimeZoneProviderPackageName" />
   <java-symbol type="bool" name="config_enableSecondaryLocationTimeZoneProvider" />
   <java-symbol type="string" name="config_secondaryLocationTimeZoneProviderPackageName" />
+  <java-symbol type="bool" name="config_supportTelephonyTimeZoneFallback" />
   <java-symbol type="bool" name="config_autoResetAirplaneMode" />
   <java-symbol type="string" name="config_notificationAccessConfirmationActivity" />
   <java-symbol type="bool" name="config_killableInputMethods" />
diff --git a/services/core/java/com/android/server/timedetector/ServerFlags.java b/services/core/java/com/android/server/timedetector/ServerFlags.java
index 477ebf6402528..d24a3df56420d 100644
--- a/services/core/java/com/android/server/timedetector/ServerFlags.java
+++ b/services/core/java/com/android/server/timedetector/ServerFlags.java
@@ -65,6 +65,7 @@ public final class ServerFlags {
             KEY_LOCATION_TIME_ZONE_DETECTION_SETTING_ENABLED_DEFAULT,
             KEY_TIME_DETECTOR_LOWER_BOUND_MILLIS_OVERRIDE,
             KEY_TIME_DETECTOR_ORIGIN_PRIORITIES_OVERRIDE,
+            KEY_TIME_ZONE_DETECTOR_TELEPHONY_FALLBACK_SUPPORTED,
     })
     @Target({ ElementType.TYPE_USE, ElementType.TYPE_PARAMETER })
     @Retention(RetentionPolicy.SOURCE)
@@ -138,6 +139,14 @@ public final class ServerFlags {
             KEY_LOCATION_TIME_ZONE_DETECTION_SETTING_ENABLED_DEFAULT =
             "location_time_zone_detection_setting_enabled_default";
 
+    /**
+     * The key to control support for time zone detection falling back to telephony detection under
+     * certain circumstances.
+     */
+    public static final @DeviceConfigKey String
+            KEY_TIME_ZONE_DETECTOR_TELEPHONY_FALLBACK_SUPPORTED =
+            "time_zone_detector_telephony_fallback_supported";
+
     /**
      * The key to override the time detector origin priorities configuration. A comma-separated list
      * of strings that will be passed to {@link TimeDetectorStrategy#stringToOrigin(String)}.
diff --git a/services/core/java/com/android/server/timezonedetector/ConfigurationInternal.java b/services/core/java/com/android/server/timezonedetector/ConfigurationInternal.java
index 1a5945e3ef81f..65f077ea60e0a 100644
--- a/services/core/java/com/android/server/timezonedetector/ConfigurationInternal.java
+++ b/services/core/java/com/android/server/timezonedetector/ConfigurationInternal.java
@@ -39,6 +39,7 @@ public final class ConfigurationInternal {
 
     private final boolean mTelephonyDetectionSupported;
     private final boolean mGeoDetectionSupported;
+    private final boolean mTelephonyFallbackSupported;
     private final boolean mAutoDetectionEnabledSetting;
     private final @UserIdInt int mUserId;
     private final boolean mUserConfigAllowed;
@@ -48,6 +49,7 @@ public final class ConfigurationInternal {
     private ConfigurationInternal(Builder builder) {
         mTelephonyDetectionSupported = builder.mTelephonyDetectionSupported;
         mGeoDetectionSupported = builder.mGeoDetectionSupported;
+        mTelephonyFallbackSupported = builder.mTelephonyFallbackSupported;
         mAutoDetectionEnabledSetting = builder.mAutoDetectionEnabledSetting;
 
         mUserId = builder.mUserId;
@@ -71,6 +73,14 @@ public final class ConfigurationInternal {
         return mGeoDetectionSupported;
     }
 
+    /**
+     * Returns true if the device supports time zone detection falling back to telephony detection
+     * under certain circumstances.
+     */
+    public boolean isTelephonyFallbackSupported() {
+        return mTelephonyFallbackSupported;
+    }
+
     /** Returns the value of the auto time zone detection enabled setting. */
     public boolean getAutoDetectionEnabledSetting() {
         return mAutoDetectionEnabledSetting;
@@ -216,6 +226,7 @@ public final class ConfigurationInternal {
                 && mUserConfigAllowed == that.mUserConfigAllowed
                 && mTelephonyDetectionSupported == that.mTelephonyDetectionSupported
                 && mGeoDetectionSupported == that.mGeoDetectionSupported
+                && mTelephonyFallbackSupported == that.mTelephonyFallbackSupported
                 && mAutoDetectionEnabledSetting == that.mAutoDetectionEnabledSetting
                 && mLocationEnabledSetting == that.mLocationEnabledSetting
                 && mGeoDetectionEnabledSetting == that.mGeoDetectionEnabledSetting;
@@ -224,8 +235,8 @@ public final class ConfigurationInternal {
     @Override
     public int hashCode() {
         return Objects.hash(mUserId, mUserConfigAllowed, mTelephonyDetectionSupported,
-                mGeoDetectionSupported, mAutoDetectionEnabledSetting, mLocationEnabledSetting,
-                mGeoDetectionEnabledSetting);
+                mGeoDetectionSupported, mTelephonyFallbackSupported, mAutoDetectionEnabledSetting,
+                mLocationEnabledSetting, mGeoDetectionEnabledSetting);
     }
 
     @Override
@@ -235,6 +246,7 @@ public final class ConfigurationInternal {
                 + ", mUserConfigAllowed=" + mUserConfigAllowed
                 + ", mTelephonyDetectionSupported=" + mTelephonyDetectionSupported
                 + ", mGeoDetectionSupported=" + mGeoDetectionSupported
+                + ", mTelephonyFallbackSupported=" + mTelephonyFallbackSupported
                 + ", mAutoDetectionEnabledSetting=" + mAutoDetectionEnabledSetting
                 + ", mLocationEnabledSetting=" + mLocationEnabledSetting
                 + ", mGeoDetectionEnabledSetting=" + mGeoDetectionEnabledSetting
@@ -251,6 +263,7 @@ public final class ConfigurationInternal {
         private boolean mUserConfigAllowed;
         private boolean mTelephonyDetectionSupported;
         private boolean mGeoDetectionSupported;
+        private boolean mTelephonyFallbackSupported;
         private boolean mAutoDetectionEnabledSetting;
         private boolean mLocationEnabledSetting;
         private boolean mGeoDetectionEnabledSetting;
@@ -269,6 +282,7 @@ public final class ConfigurationInternal {
             this.mUserId = toCopy.mUserId;
             this.mUserConfigAllowed = toCopy.mUserConfigAllowed;
             this.mTelephonyDetectionSupported = toCopy.mTelephonyDetectionSupported;
+            this.mTelephonyFallbackSupported = toCopy.mTelephonyFallbackSupported;
             this.mGeoDetectionSupported = toCopy.mGeoDetectionSupported;
             this.mAutoDetectionEnabledSetting = toCopy.mAutoDetectionEnabledSetting;
             this.mLocationEnabledSetting = toCopy.mLocationEnabledSetting;
@@ -299,6 +313,15 @@ public final class ConfigurationInternal {
             return this;
         }
 
+        /**
+         * Sets whether time zone detection supports falling back to telephony detection under
+         * certain circumstances.
+         */
+        public Builder setTelephonyFallbackSupported(boolean supported) {
+            mTelephonyFallbackSupported = supported;
+            return this;
+        }
+
         /**
          * Sets the value of the automatic time zone detection enabled setting for this device.
          */
diff --git a/services/core/java/com/android/server/timezonedetector/DeviceActivityMonitor.java b/services/core/java/com/android/server/timezonedetector/DeviceActivityMonitor.java
new file mode 100644
index 0000000000000..62092ec5b4e16
--- /dev/null
+++ b/services/core/java/com/android/server/timezonedetector/DeviceActivityMonitor.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2021 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.timezonedetector;
+
+import android.annotation.NonNull;
+
+/**
+ * The interface for the class that is responsible for detecting device activities relevant to
+ * time zone detection. This interface exists to decouple parts of the time zone detector from each
+ * other and to enable easier testing.
+ *
+ * @hide
+ */
+interface DeviceActivityMonitor extends Dumpable {
+
+    /** Adds a listener. */
+    void addListener(@NonNull Listener listener);
+
+    /**
+     * A listener for device activities. See {@link DeviceActivityMonitor#addListener(Listener)}.
+     */
+    interface Listener {
+        /** A flight has completed. */
+        void onFlightComplete();
+    }
+}
diff --git a/services/core/java/com/android/server/timezonedetector/DeviceActivityMonitorImpl.java b/services/core/java/com/android/server/timezonedetector/DeviceActivityMonitorImpl.java
new file mode 100644
index 0000000000000..8c9bd3b9d0d7b
--- /dev/null
+++ b/services/core/java/com/android/server/timezonedetector/DeviceActivityMonitorImpl.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2021 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.timezonedetector;
+
+import android.annotation.NonNull;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.database.ContentObserver;
+import android.os.Handler;
+import android.provider.Settings;
+import android.util.IndentingPrintWriter;
+import android.util.Slog;
+
+import com.android.internal.annotations.GuardedBy;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * The real implementation of {@link DeviceActivityMonitor}.
+ */
+class DeviceActivityMonitorImpl implements DeviceActivityMonitor {
+
+    private static final String LOG_TAG = TimeZoneDetectorService.TAG;
+    private static final boolean DBG = TimeZoneDetectorService.DBG;
+
+    static DeviceActivityMonitor create(@NonNull Context context, @NonNull Handler handler) {
+        return new DeviceActivityMonitorImpl(context, handler);
+    }
+
+    @GuardedBy("this")
+    @NonNull
+    private final List<Listener> mListeners = new ArrayList<>();
+
+    private DeviceActivityMonitorImpl(@NonNull Context context, @NonNull Handler handler) {
+        // The way this "detects" a flight concluding is by the user explicitly turning off airplane
+        // mode. Smarter heuristics would be nice.
+        ContentResolver contentResolver = context.getContentResolver();
+        ContentObserver airplaneModeObserver = new ContentObserver(handler) {
+            @Override
+            public void onChange(boolean unused) {
+                try {
+                    int state = Settings.Global.getInt(
+                            contentResolver, Settings.Global.AIRPLANE_MODE_ON);
+                    if (state == 0) {
+                        notifyFlightComplete();
+                    }
+                } catch (Settings.SettingNotFoundException e) {
+                    Slog.e(LOG_TAG, "Unable to read airplane mode state", e);
+                }
+            }
+        };
+        contentResolver.registerContentObserver(
+                Settings.Global.getUriFor(Settings.Global.AIRPLANE_MODE_ON),
+                true /* notifyForDescendants */,
+                airplaneModeObserver);
+    }
+
+    @Override
+    public synchronized void addListener(Listener listener) {
+        Objects.requireNonNull(listener);
+        mListeners.add(listener);
+    }
+
+    private synchronized void notifyFlightComplete() {
+        if (DBG) {
+            Slog.d(LOG_TAG, "notifyFlightComplete");
+        }
+
+        for (Listener listener : mListeners) {
+            listener.onFlightComplete();
+        }
+    }
+
+    @Override
+    public void dump(IndentingPrintWriter pw, String[] args) {
+        // No-op right now: no state to dump.
+    }
+}
diff --git a/services/core/java/com/android/server/timezonedetector/EnvironmentImpl.java b/services/core/java/com/android/server/timezonedetector/EnvironmentImpl.java
index ec620b5e2a426..0ec8826cb7eb8 100644
--- a/services/core/java/com/android/server/timezonedetector/EnvironmentImpl.java
+++ b/services/core/java/com/android/server/timezonedetector/EnvironmentImpl.java
@@ -16,11 +16,13 @@
 
 package com.android.server.timezonedetector;
 
+import android.annotation.ElapsedRealtimeLong;
 import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.app.AlarmManager;
 import android.content.Context;
 import android.os.Handler;
+import android.os.SystemClock;
 import android.os.SystemProperties;
 
 import java.util.Objects;
@@ -79,4 +81,9 @@ final class EnvironmentImpl implements TimeZoneDetectorStrategyImpl.Environment
         AlarmManager alarmManager = mContext.getSystemService(AlarmManager.class);
         alarmManager.setTimeZone(zoneId);
     }
+
+    @Override
+    public @ElapsedRealtimeLong long elapsedRealtimeMillis() {
+        return SystemClock.elapsedRealtime();
+    }
 }
diff --git a/services/core/java/com/android/server/timezonedetector/MetricsTimeZoneDetectorState.java b/services/core/java/com/android/server/timezonedetector/MetricsTimeZoneDetectorState.java
index f8ba0d21224b9..0c20586ba1d67 100644
--- a/services/core/java/com/android/server/timezonedetector/MetricsTimeZoneDetectorState.java
+++ b/services/core/java/com/android/server/timezonedetector/MetricsTimeZoneDetectorState.java
@@ -111,6 +111,11 @@ public final class MetricsTimeZoneDetectorState {
         return mConfigurationInternal.isGeoDetectionSupported();
     }
 
+    /** Returns true if the device supports telephony time zone detection fallback. */
+    public boolean isTelephonyTimeZoneFallbackSupported() {
+        return mConfigurationInternal.isTelephonyFallbackSupported();
+    }
+
     /** Returns true if user's location can be used generally. */
     public boolean getUserLocationEnabledSetting() {
         return mConfigurationInternal.getLocationEnabledSetting();
diff --git a/services/core/java/com/android/server/timezonedetector/ServiceConfigAccessorImpl.java b/services/core/java/com/android/server/timezonedetector/ServiceConfigAccessorImpl.java
index be4b6bd206bf6..b9885d237bbd7 100644
--- a/services/core/java/com/android/server/timezonedetector/ServiceConfigAccessorImpl.java
+++ b/services/core/java/com/android/server/timezonedetector/ServiceConfigAccessorImpl.java
@@ -64,6 +64,7 @@ public final class ServiceConfigAccessorImpl implements ServiceConfigAccessor {
                     ServerFlags.KEY_LOCATION_TIME_ZONE_DETECTION_FEATURE_SUPPORTED,
                     ServerFlags.KEY_LOCATION_TIME_ZONE_DETECTION_SETTING_ENABLED_DEFAULT,
                     ServerFlags.KEY_LOCATION_TIME_ZONE_DETECTION_SETTING_ENABLED_OVERRIDE,
+                    ServerFlags.KEY_TIME_ZONE_DETECTOR_TELEPHONY_FALLBACK_SUPPORTED,
             }));
 
     /**
@@ -294,6 +295,7 @@ public final class ServiceConfigAccessorImpl implements ServiceConfigAccessor {
                 .setTelephonyDetectionFeatureSupported(
                         isTelephonyTimeZoneDetectionFeatureSupported())
                 .setGeoDetectionFeatureSupported(isGeoTimeZoneDetectionFeatureSupported())
+                .setTelephonyFallbackSupported(isTelephonyFallbackSupported())
                 .setAutoDetectionEnabledSetting(getAutoDetectionEnabledSetting())
                 .setUserConfigAllowed(isUserConfigAllowed(userId))
                 .setLocationEnabledSetting(getLocationEnabledSetting(userId))
@@ -549,6 +551,13 @@ public final class ServiceConfigAccessorImpl implements ServiceConfigAccessor {
         mRecordProviderStateChanges = false;
     }
 
+    private boolean isTelephonyFallbackSupported() {
+        return mServerFlags.getBoolean(
+                ServerFlags.KEY_TIME_ZONE_DETECTOR_TELEPHONY_FALLBACK_SUPPORTED,
+                getConfigBoolean(
+                        com.android.internal.R.bool.config_supportTelephonyTimeZoneFallback));
+    }
+
     private boolean getConfigBoolean(int providerEnabledConfigId) {
         Resources resources = mContext.getResources();
         return resources.getBoolean(providerEnabledConfigId);
diff --git a/services/core/java/com/android/server/timezonedetector/TimeZoneDetectorService.java b/services/core/java/com/android/server/timezonedetector/TimeZoneDetectorService.java
index e0c39ad55f470..14784cf0d5501 100644
--- a/services/core/java/com/android/server/timezonedetector/TimeZoneDetectorService.java
+++ b/services/core/java/com/android/server/timezonedetector/TimeZoneDetectorService.java
@@ -83,6 +83,16 @@ public final class TimeZoneDetectorService extends ITimeZoneDetectorService.Stub
                     ServiceConfigAccessorImpl.getInstance(context);
             TimeZoneDetectorStrategy timeZoneDetectorStrategy =
                     TimeZoneDetectorStrategyImpl.create(context, handler, serviceConfigAccessor);
+            DeviceActivityMonitor deviceActivityMonitor =
+                    DeviceActivityMonitorImpl.create(context, handler);
+
+            // Wire up the telephony fallback behavior to activity detection.
+            deviceActivityMonitor.addListener(new DeviceActivityMonitor.Listener() {
+                @Override
+                public void onFlightComplete() {
+                    timeZoneDetectorStrategy.enableTelephonyTimeZoneFallback();
+                }
+            });
 
             // Create and publish the local service for use by internal callers.
             TimeZoneDetectorInternal internal =
@@ -93,6 +103,10 @@ public final class TimeZoneDetectorService extends ITimeZoneDetectorService.Stub
             // permissioned) processes.
             TimeZoneDetectorService service = TimeZoneDetectorService.create(
                     context, handler, serviceConfigAccessor, timeZoneDetectorStrategy);
+
+            // Dump the device activity monitor when the service is dumped.
+            service.addDumpable(deviceActivityMonitor);
+
             publishBinderService(Context.TIME_ZONE_DETECTOR_SERVICE, service);
         }
     }
@@ -331,6 +345,15 @@ public final class TimeZoneDetectorService extends ITimeZoneDetectorService.Stub
         return mServiceConfigAccessor.isGeoTimeZoneDetectionFeatureSupported();
     }
 
+    /**
+     * Sends a signal to enable telephony fallback. Provided for command-line access for use
+     * during tests. This is not exposed as a binder API.
+     */
+    void enableTelephonyFallback() {
+        enforceManageTimeZoneDetectorPermission();
+        mTimeZoneDetectorStrategy.enableTelephonyTimeZoneFallback();
+    }
+
     /**
      * Registers the supplied {@link Dumpable} for dumping. When the service is dumped
      * {@link Dumpable#dump(IndentingPrintWriter, String[])} will be called on the {@code dumpable}.
diff --git a/services/core/java/com/android/server/timezonedetector/TimeZoneDetectorShellCommand.java b/services/core/java/com/android/server/timezonedetector/TimeZoneDetectorShellCommand.java
index a4a46a3c4c731..2b912ad7ba601 100644
--- a/services/core/java/com/android/server/timezonedetector/TimeZoneDetectorShellCommand.java
+++ b/services/core/java/com/android/server/timezonedetector/TimeZoneDetectorShellCommand.java
@@ -15,6 +15,7 @@
  */
 package com.android.server.timezonedetector;
 
+import static android.app.timezonedetector.TimeZoneDetector.SHELL_COMMAND_ENABLE_TELEPHONY_FALLBACK;
 import static android.app.timezonedetector.TimeZoneDetector.SHELL_COMMAND_IS_AUTO_DETECTION_ENABLED;
 import static android.app.timezonedetector.TimeZoneDetector.SHELL_COMMAND_IS_GEO_DETECTION_ENABLED;
 import static android.app.timezonedetector.TimeZoneDetector.SHELL_COMMAND_IS_GEO_DETECTION_SUPPORTED;
@@ -30,6 +31,7 @@ import static android.provider.DeviceConfig.NAMESPACE_SYSTEM_TIME;
 import static com.android.server.timedetector.ServerFlags.KEY_LOCATION_TIME_ZONE_DETECTION_FEATURE_SUPPORTED;
 import static com.android.server.timedetector.ServerFlags.KEY_LOCATION_TIME_ZONE_DETECTION_SETTING_ENABLED_DEFAULT;
 import static com.android.server.timedetector.ServerFlags.KEY_LOCATION_TIME_ZONE_DETECTION_SETTING_ENABLED_OVERRIDE;
+import static com.android.server.timedetector.ServerFlags.KEY_TIME_ZONE_DETECTOR_TELEPHONY_FALLBACK_SUPPORTED;
 
 import android.app.time.LocationTimeZoneManager;
 import android.app.time.TimeZoneConfiguration;
@@ -76,6 +78,8 @@ class TimeZoneDetectorShellCommand extends ShellCommand {
                 return runSuggestManualTimeZone();
             case SHELL_COMMAND_SUGGEST_TELEPHONY_TIME_ZONE:
                 return runSuggestTelephonyTimeZone();
+            case SHELL_COMMAND_ENABLE_TELEPHONY_FALLBACK:
+                return runEnableTelephonyFallback();
             default: {
                 return handleDefaultCommands(cmd);
             }
@@ -169,6 +173,11 @@ class TimeZoneDetectorShellCommand extends ShellCommand {
         }
     }
 
+    private int runEnableTelephonyFallback() {
+        mInterface.enableTelephonyFallback();
+        return 1;
+    }
+
     @Override
     public void onHelp() {
         final PrintWriter pw = getOutPrintWriter();
@@ -190,6 +199,13 @@ class TimeZoneDetectorShellCommand extends ShellCommand {
                 + "\n");
         pw.printf("  %s true|false\n", SHELL_COMMAND_SET_GEO_DETECTION_ENABLED);
         pw.printf("    Sets the geolocation time zone detection enabled setting.\n");
+        pw.printf("  %s\n", SHELL_COMMAND_ENABLE_TELEPHONY_FALLBACK);
+        pw.printf("    Signals that telephony time zone detection fall back can be used if"
+                + " geolocation detection is supported and enabled. This is a temporary state until"
+                + " geolocation detection becomes \"certain\". To have an effect this requires that"
+                + " the telephony fallback feature is supported on the device, see below for"
+                + " for device_config flags.\n");
+        pw.println();
         pw.printf("  %s <geolocation suggestion opts>\n",
                 SHELL_COMMAND_SUGGEST_GEO_LOCATION_TIME_ZONE);
         pw.printf("  %s <manual suggestion opts>\n",
@@ -216,6 +232,9 @@ class TimeZoneDetectorShellCommand extends ShellCommand {
         pw.printf("  %s\n", KEY_LOCATION_TIME_ZONE_DETECTION_SETTING_ENABLED_OVERRIDE);
         pw.printf("    Used to override the device's 'geolocation time zone detection enabled'"
                 + " setting [*].\n");
+        pw.printf("  %s\n", KEY_TIME_ZONE_DETECTOR_TELEPHONY_FALLBACK_SUPPORTED);
+        pw.printf("    Used to enable / disable support for telephony detection fallback. Also see"
+                + " the %s command.\n", SHELL_COMMAND_ENABLE_TELEPHONY_FALLBACK);
         pw.println();
         pw.printf("[*] To be enabled, the user must still have location = on / auto time zone"
                 + " detection = on.\n");
diff --git a/services/core/java/com/android/server/timezonedetector/TimeZoneDetectorStrategy.java b/services/core/java/com/android/server/timezonedetector/TimeZoneDetectorStrategy.java
index ede52ba84d73b..6b04adf7de618 100644
--- a/services/core/java/com/android/server/timezonedetector/TimeZoneDetectorStrategy.java
+++ b/services/core/java/com/android/server/timezonedetector/TimeZoneDetectorStrategy.java
@@ -69,6 +69,20 @@ import android.util.IndentingPrintWriter;
  * users enter areas without the necessary signals. Ultimately, with no perfect algorithm available,
  * the user is left to choose which algorithm works best for their circumstances.
  *
+ * <p>When geolocation detection is supported and enabled, in certain circumstances, such as during
+ * international travel, it makes sense to prioritize speed of detection via telephony (when
+ * available) Vs waiting for the geolocation algorithm to reach certainty. Geolocation detection can
+ * sometimes be slow to get a location fix and can require network connectivity (which cannot be
+ * assumed when users are travelling) for server-assisted location detection or time zone lookup.
+ * Therefore, as a restricted form of prioritization between geolocation and telephony algorithms,
+ * the strategy provides "telephony fallback" behavior, which can be set to "supported" via device
+ * config. Fallback mode is toggled on at runtime via {@link #enableTelephonyTimeZoneFallback()} in
+ * response to signals outside of the scope of this class. Telephony fallback allows the use of
+ * telephony suggestions to help with faster detection but only until geolocation detection
+ * provides a concrete, "certain" suggestion. After geolocation has made the first certain
+ * suggestion, telephony fallback is disabled until the next call to {@link
+ * #enableTelephonyTimeZoneFallback()}.
+ *
  * <p>Threading:
  *
  * <p>Implementations of this class must be thread-safe as calls calls like {@link
@@ -100,6 +114,13 @@ public interface TimeZoneDetectorStrategy extends Dumpable {
      */
     void suggestTelephonyTimeZone(@NonNull TelephonyTimeZoneSuggestion suggestion);
 
+    /**
+     * Tells the strategy that it can fall back to telephony detection while geolocation detection
+     * remains uncertain. {@link #suggestGeolocationTimeZone(GeolocationTimeZoneSuggestion)} can
+     * disable it again. See {@link TimeZoneDetectorStrategy} for details.
+     */
+    void enableTelephonyTimeZoneFallback();
+
     /** Generates a state snapshot for metrics. */
     @NonNull
     MetricsTimeZoneDetectorState generateMetricsState();
diff --git a/services/core/java/com/android/server/timezonedetector/TimeZoneDetectorStrategyImpl.java b/services/core/java/com/android/server/timezonedetector/TimeZoneDetectorStrategyImpl.java
index 3b6c1ead3388f..92dddacbcff5f 100644
--- a/services/core/java/com/android/server/timezonedetector/TimeZoneDetectorStrategyImpl.java
+++ b/services/core/java/com/android/server/timezonedetector/TimeZoneDetectorStrategyImpl.java
@@ -22,6 +22,7 @@ import static android.app.timezonedetector.TelephonyTimeZoneSuggestion.QUALITY_M
 import static android.app.timezonedetector.TelephonyTimeZoneSuggestion.QUALITY_MULTIPLE_ZONES_WITH_SAME_OFFSET;
 import static android.app.timezonedetector.TelephonyTimeZoneSuggestion.QUALITY_SINGLE_ZONE;
 
+import android.annotation.ElapsedRealtimeLong;
 import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.annotation.UserIdInt;
@@ -31,6 +32,7 @@ import android.app.timezonedetector.ManualTimeZoneSuggestion;
 import android.app.timezonedetector.TelephonyTimeZoneSuggestion;
 import android.content.Context;
 import android.os.Handler;
+import android.os.TimestampedValue;
 import android.util.IndentingPrintWriter;
 import android.util.LocalLog;
 import android.util.Slog;
@@ -38,6 +40,7 @@ import android.util.Slog;
 import com.android.internal.annotations.GuardedBy;
 import com.android.internal.annotations.VisibleForTesting;
 
+import java.time.Duration;
 import java.util.List;
 import java.util.Objects;
 
@@ -83,6 +86,13 @@ public final class TimeZoneDetectorStrategyImpl implements TimeZoneDetectorStrat
          * Sets the device's time zone.
          */
         void setDeviceTimeZone(@NonNull String zoneId);
+
+        /**
+         * Returns the time according to the elapsed realtime clock, the same as {@link
+         * android.os.SystemClock#elapsedRealtime()}.
+         */
+        @ElapsedRealtimeLong
+        long elapsedRealtimeMillis();
     }
 
     private static final String LOG_TAG = TimeZoneDetectorService.TAG;
@@ -190,6 +200,21 @@ public final class TimeZoneDetectorStrategyImpl implements TimeZoneDetectorStrat
     @NonNull
     private ConfigurationInternal mCurrentConfigurationInternal;
 
+    /**
+     * Whether telephony time zone detection fallback is currently enabled (when device config also
+     * allows).
+     *
+     * <p>This field is only actually used when telephony time zone fallback is supported, but the
+     * value is maintained even when it isn't supported as it can be turned on at any time via
+     * server flags. The reference time is the elapsed realtime when the mode last changed to help
+     * ordering between fallback mode switches and suggestions.
+     *
+     * <p>See {@link TimeZoneDetectorStrategy} for more information.
+     */
+    @GuardedBy("this")
+    @NonNull
+    private TimestampedValue<Boolean> mTelephonyTimeZoneFallbackEnabled;
+
     /**
      * Creates a new instance of {@link TimeZoneDetectorStrategyImpl}.
      */
@@ -205,6 +230,10 @@ public final class TimeZoneDetectorStrategyImpl implements TimeZoneDetectorStrat
     public TimeZoneDetectorStrategyImpl(@NonNull Environment environment) {
         mEnvironment = Objects.requireNonNull(environment);
 
+        // Start with telephony fallback enabled.
+        mTelephonyTimeZoneFallbackEnabled =
+                new TimestampedValue<>(mEnvironment.elapsedRealtimeMillis(), true);
+
         synchronized (this) {
             mEnvironment.setConfigurationInternalChangeListener(
                     this::handleConfigurationInternalChanged);
@@ -233,6 +262,10 @@ public final class TimeZoneDetectorStrategyImpl implements TimeZoneDetectorStrat
         // are made in a sensible order and the most recent is always the best one to use.
         mLatestGeoLocationSuggestion.set(suggestion);
 
+        // Update the mTelephonyTimeZoneFallbackEnabled state if needed: a certain suggestion
+        // will usually disable telephony fallback mode if it is currently enabled.
+        disableTelephonyFallbackIfNeeded();
+
         // Now perform auto time zone detection. The new suggestion may be used to modify the
         // time zone setting.
         String reason = "New geolocation time zone suggested. suggestion=" + suggestion;
@@ -303,6 +336,43 @@ public final class TimeZoneDetectorStrategyImpl implements TimeZoneDetectorStrat
         doAutoTimeZoneDetection(currentUserConfig, reason);
     }
 
+    @Override
+    public synchronized void enableTelephonyTimeZoneFallback() {
+        // Only do any work if fallback is currently not enabled.
+        if (!mTelephonyTimeZoneFallbackEnabled.getValue()) {
+            ConfigurationInternal currentUserConfig = mCurrentConfigurationInternal;
+            if (DBG) {
+                Slog.d(LOG_TAG, "enableTelephonyTimeZoneFallbackMode"
+                        + ": currentUserConfig=" + currentUserConfig);
+            }
+
+            final boolean fallbackEnabled = true;
+            mTelephonyTimeZoneFallbackEnabled = new TimestampedValue<>(
+                    mEnvironment.elapsedRealtimeMillis(), fallbackEnabled);
+
+            // mTelephonyTimeZoneFallbackEnabled and mLatestGeoLocationSuggestion interact.
+            // If there is currently a certain geolocation suggestion, then the telephony fallback
+            // value needs to be considered after changing it.
+            // With the way that the mTelephonyTimeZoneFallbackEnabled time is currently chosen
+            // above, and the fact that geolocation suggestions should never have a time in the
+            // future, the following call will be a no-op, and telephony fallback will remain
+            // enabled. This comment / call is left as a reminder that it is possible for there to
+            // be a current, "certain" geolocation suggestion when this signal arrives and it is
+            // intentional that fallback stays enabled in this case. The choice to do this
+            // is mostly for symmetry WRT the case where fallback is enabled and an old "certain"
+            // geolocation is received; that would also leave telephony fallback enabled.
+            // This choice means that telephony fallback will remain enabled until a new "certain"
+            // geolocation suggestion is received. If, instead, the next geolocation is "uncertain",
+            // then telephony fallback will occur.
+            disableTelephonyFallbackIfNeeded();
+
+            if (currentUserConfig.isTelephonyFallbackSupported()) {
+                String reason = "enableTelephonyTimeZoneFallbackMode";
+                doAutoTimeZoneDetection(currentUserConfig, reason);
+            }
+        }
+    }
+
     @Override
     @NonNull
     public synchronized MetricsTimeZoneDetectorState generateMetricsState() {
@@ -361,7 +431,32 @@ public final class TimeZoneDetectorStrategyImpl implements TimeZoneDetectorStrat
         // Use the correct algorithm based on the user's current configuration. If it changes, then
         // detection will be re-run.
         if (currentUserConfig.getGeoDetectionEnabledBehavior()) {
-            doGeolocationTimeZoneDetection(detectionReason);
+            boolean isGeoDetectionCertain = doGeolocationTimeZoneDetection(detectionReason);
+
+            // When geolocation detection is uncertain of the time zone, telephony detection
+            // can be used if telephony fallback is enabled and supported.
+            if (!isGeoDetectionCertain
+                    && mTelephonyTimeZoneFallbackEnabled.getValue()
+                    && currentUserConfig.isTelephonyFallbackSupported()) {
+
+                // This "only look at telephony if geolocation is uncertain" approach is
+                // deliberate to try to keep the logic simple and keep telephony and geolocation
+                // detection decoupled: when geolocation detection is in use, it is fully
+                // trusted and the most recent "certain" geolocation suggestion available will
+                // be used, even if the information it is based on is quite old.
+                // There could be newer telephony suggestions available, but telephony
+                // suggestions tend not to be withdrawn when they should be, and are based on
+                // combining information like MCC and NITZ signals, which could have been
+                // received at different times; thus it is hard to say what time the suggestion
+                // is actually "for" and reason clearly about ordering between telephony and
+                // geolocation suggestions.
+                //
+                // This approach is reliant on the location_time_zone_manager (and the location
+                // time zone providers it manages) correctly sending "uncertain" suggestions
+                // when the current location is unknown so that telephony fallback will actually be
+                // used.
+                doTelephonyTimeZoneDetection(detectionReason + ", telephony fallback mode");
+            }
         } else  {
             doTelephonyTimeZoneDetection(detectionReason);
         }
@@ -371,21 +466,29 @@ public final class TimeZoneDetectorStrategyImpl implements TimeZoneDetectorStrat
      * Detects the time zone using the latest available geolocation time zone suggestion, if one is
      * available. The outcome can be that this strategy becomes / remains un-opinionated and nothing
      * is set.
+     *
+     * @return true if geolocation time zone detection was certain of the time zone, false if it is
+     * uncertain
      */
     @GuardedBy("this")
-    private void doGeolocationTimeZoneDetection(@NonNull String detectionReason) {
+    private boolean doGeolocationTimeZoneDetection(@NonNull String detectionReason) {
         GeolocationTimeZoneSuggestion latestGeolocationSuggestion =
                 mLatestGeoLocationSuggestion.get();
         if (latestGeolocationSuggestion == null) {
-            return;
+            return false;
         }
 
         List<String> zoneIds = latestGeolocationSuggestion.getZoneIds();
-        if (zoneIds == null || zoneIds.isEmpty()) {
-            // This means the client has become uncertain about the time zone or it is certain there
-            // is no known zone. In either case we must leave the existing time zone setting as it
-            // is.
-            return;
+        if (zoneIds == null) {
+            // This means the originator of the suggestion is uncertain about the time zone. The
+            // existing time zone setting must be left as it is but detection can go on looking for
+            // a different answer elsewhere.
+            return false;
+        } else if (zoneIds.isEmpty()) {
+            // This means the originator is certain there is no time zone. The existing time zone
+            // setting must be left as it is and detection must not go looking for a different
+            // answer elsewhere.
+            return true;
         }
 
         // GeolocationTimeZoneSuggestion has no measure of quality. We assume all suggestions are
@@ -404,6 +507,34 @@ public final class TimeZoneDetectorStrategyImpl implements TimeZoneDetectorStrat
             zoneId = zoneIds.get(0);
         }
         setDeviceTimeZoneIfRequired(zoneId, detectionReason);
+        return true;
+    }
+
+    /**
+     * Sets the mTelephonyTimeZoneFallbackEnabled state to {@code false} if the latest geo
+     * suggestion is a "certain" suggestion that comes after the time when telephony fallback was
+     * enabled.
+     */
+    @GuardedBy("this")
+    private void disableTelephonyFallbackIfNeeded() {
+        GeolocationTimeZoneSuggestion suggestion = mLatestGeoLocationSuggestion.get();
+        boolean isLatestSuggestionCertain = suggestion != null && suggestion.getZoneIds() != null;
+        if (isLatestSuggestionCertain && mTelephonyTimeZoneFallbackEnabled.getValue()) {
+            // This transition ONLY changes mTelephonyTimeZoneFallbackEnabled from
+            // true -> false. See mTelephonyTimeZoneFallbackEnabled javadocs for details.
+
+            // Telephony fallback will be disabled after a "certain" suggestion is processed
+            // if and only if the location information it is based on is from after telephony
+            // fallback was enabled.
+            boolean latestSuggestionIsNewerThanFallbackEnabled =
+                    suggestion.getEffectiveFromElapsedMillis()
+                            > mTelephonyTimeZoneFallbackEnabled.getReferenceTimeMillis();
+            if (latestSuggestionIsNewerThanFallbackEnabled) {
+                final boolean fallbackEnabled = false;
+                mTelephonyTimeZoneFallbackEnabled = new TimestampedValue<>(
+                        mEnvironment.elapsedRealtimeMillis(), fallbackEnabled);
+            }
+        }
     }
 
     /**
@@ -556,6 +687,12 @@ public final class TimeZoneDetectorStrategyImpl implements TimeZoneDetectorStrat
                 + mEnvironment.isDeviceTimeZoneInitialized());
         ipw.println("mEnvironment.getDeviceTimeZone()=" + mEnvironment.getDeviceTimeZone());
 
+        ipw.println("Misc state:");
+        ipw.increaseIndent(); // level 2
+        ipw.println("mTelephonyTimeZoneFallbackEnabled="
+                + formatDebugString(mTelephonyTimeZoneFallbackEnabled));
+        ipw.decreaseIndent(); // level 2
+
         ipw.println("Time zone change log:");
         ipw.increaseIndent(); // level 2
         mTimeZoneChangesLog.dump(ipw);
@@ -603,6 +740,11 @@ public final class TimeZoneDetectorStrategyImpl implements TimeZoneDetectorStrat
         return mLatestGeoLocationSuggestion.get();
     }
 
+    @VisibleForTesting
+    public synchronized boolean isTelephonyFallbackEnabledForTests() {
+        return mTelephonyTimeZoneFallbackEnabled.getValue();
+    }
+
     /**
      * A {@link TelephonyTimeZoneSuggestion} with additional qualifying metadata.
      */
@@ -652,4 +794,8 @@ public final class TimeZoneDetectorStrategyImpl implements TimeZoneDetectorStrat
                     + '}';
         }
     }
+
+    private static String formatDebugString(TimestampedValue<?> value) {
+        return value.getValue() + " @ " + Duration.ofMillis(value.getReferenceTimeMillis());
+    }
 }
diff --git a/services/tests/servicestests/src/com/android/server/timezonedetector/ConfigurationInternalTest.java b/services/tests/servicestests/src/com/android/server/timezonedetector/ConfigurationInternalTest.java
index 809b2f9f977af..6ee6020c79852 100644
--- a/services/tests/servicestests/src/com/android/server/timezonedetector/ConfigurationInternalTest.java
+++ b/services/tests/servicestests/src/com/android/server/timezonedetector/ConfigurationInternalTest.java
@@ -48,6 +48,7 @@ public class ConfigurationInternalTest {
                 .setUserConfigAllowed(true)
                 .setTelephonyDetectionFeatureSupported(true)
                 .setGeoDetectionFeatureSupported(true)
+                .setTelephonyFallbackSupported(false)
                 .setAutoDetectionEnabledSetting(true)
                 .setLocationEnabledSetting(true)
                 .setGeoDetectionEnabledSetting(true)
@@ -110,6 +111,7 @@ public class ConfigurationInternalTest {
                 .setUserConfigAllowed(false)
                 .setTelephonyDetectionFeatureSupported(true)
                 .setGeoDetectionFeatureSupported(true)
+                .setTelephonyFallbackSupported(false)
                 .setAutoDetectionEnabledSetting(true)
                 .setLocationEnabledSetting(true)
                 .setGeoDetectionEnabledSetting(true)
@@ -174,6 +176,7 @@ public class ConfigurationInternalTest {
                 .setUserConfigAllowed(true)
                 .setTelephonyDetectionFeatureSupported(false)
                 .setGeoDetectionFeatureSupported(false)
+                .setTelephonyFallbackSupported(false)
                 .setAutoDetectionEnabledSetting(true)
                 .setLocationEnabledSetting(true)
                 .setGeoDetectionEnabledSetting(true)
@@ -236,6 +239,7 @@ public class ConfigurationInternalTest {
                 .setUserConfigAllowed(true)
                 .setTelephonyDetectionFeatureSupported(true)
                 .setGeoDetectionFeatureSupported(false)
+                .setTelephonyFallbackSupported(false)
                 .setAutoDetectionEnabledSetting(true)
                 .setLocationEnabledSetting(true)
                 .setGeoDetectionEnabledSetting(true)
@@ -288,4 +292,18 @@ public class ConfigurationInternalTest {
             assertTrue(configuration.isGeoDetectionEnabled());
         }
     }
+
+    @Test
+    public void test_telephonyFallbackSupported() {
+        ConfigurationInternal config = new ConfigurationInternal.Builder(ARBITRARY_USER_ID)
+                .setUserConfigAllowed(true)
+                .setTelephonyDetectionFeatureSupported(true)
+                .setGeoDetectionFeatureSupported(false)
+                .setTelephonyFallbackSupported(true)
+                .setAutoDetectionEnabledSetting(true)
+                .setLocationEnabledSetting(true)
+                .setGeoDetectionEnabledSetting(true)
+                .build();
+        assertTrue(config.isTelephonyFallbackSupported());
+    }
 }
diff --git a/services/tests/servicestests/src/com/android/server/timezonedetector/FakeTimeZoneDetectorStrategy.java b/services/tests/servicestests/src/com/android/server/timezonedetector/FakeTimeZoneDetectorStrategy.java
index ee3195e92c6da..2d0dca25465b9 100644
--- a/services/tests/servicestests/src/com/android/server/timezonedetector/FakeTimeZoneDetectorStrategy.java
+++ b/services/tests/servicestests/src/com/android/server/timezonedetector/FakeTimeZoneDetectorStrategy.java
@@ -50,6 +50,11 @@ class FakeTimeZoneDetectorStrategy implements TimeZoneDetectorStrategy {
         mLastTelephonySuggestion = timeZoneSuggestion;
     }
 
+    @Override
+    public void enableTelephonyTimeZoneFallback() {
+        throw new UnsupportedOperationException();
+    }
+
     @Override
     public MetricsTimeZoneDetectorState generateMetricsState() {
         throw new UnsupportedOperationException();
diff --git a/services/tests/servicestests/src/com/android/server/timezonedetector/TimeZoneDetectorServiceTest.java b/services/tests/servicestests/src/com/android/server/timezonedetector/TimeZoneDetectorServiceTest.java
index ce3b78e2b5f78..13317747c95cc 100644
--- a/services/tests/servicestests/src/com/android/server/timezonedetector/TimeZoneDetectorServiceTest.java
+++ b/services/tests/servicestests/src/com/android/server/timezonedetector/TimeZoneDetectorServiceTest.java
@@ -375,6 +375,7 @@ public class TimeZoneDetectorServiceTest {
         return new ConfigurationInternal.Builder(ARBITRARY_USER_ID)
                 .setTelephonyDetectionFeatureSupported(true)
                 .setGeoDetectionFeatureSupported(true)
+                .setTelephonyFallbackSupported(false)
                 .setUserConfigAllowed(true)
                 .setAutoDetectionEnabledSetting(autoDetectionEnabled)
                 .setLocationEnabledSetting(geoDetectionEnabled)
diff --git a/services/tests/servicestests/src/com/android/server/timezonedetector/TimeZoneDetectorStrategyImplTest.java b/services/tests/servicestests/src/com/android/server/timezonedetector/TimeZoneDetectorStrategyImplTest.java
index 91e8d165f4bea..ef1b4f58dd769 100644
--- a/services/tests/servicestests/src/com/android/server/timezonedetector/TimeZoneDetectorStrategyImplTest.java
+++ b/services/tests/servicestests/src/com/android/server/timezonedetector/TimeZoneDetectorStrategyImplTest.java
@@ -60,6 +60,7 @@ import java.util.function.Function;
 public class TimeZoneDetectorStrategyImplTest {
 
     private static final @UserIdInt int USER_ID = 9876;
+    private static final long ARBITRARY_ELAPSED_REALTIME_MILLIS = 1234;
     /** A time zone used for initialization that does not occur elsewhere in tests. */
     private static final String ARBITRARY_TIME_ZONE_ID = "Etc/UTC";
     private static final int SLOT_INDEX1 = 10000;
@@ -89,6 +90,7 @@ public class TimeZoneDetectorStrategyImplTest {
                     .setUserConfigAllowed(false)
                     .setTelephonyDetectionFeatureSupported(true)
                     .setGeoDetectionFeatureSupported(true)
+                    .setTelephonyFallbackSupported(false)
                     .setAutoDetectionEnabledSetting(false)
                     .setLocationEnabledSetting(true)
                     .setGeoDetectionEnabledSetting(false)
@@ -99,6 +101,7 @@ public class TimeZoneDetectorStrategyImplTest {
                     .setUserConfigAllowed(false)
                     .setTelephonyDetectionFeatureSupported(true)
                     .setGeoDetectionFeatureSupported(true)
+                    .setTelephonyFallbackSupported(false)
                     .setAutoDetectionEnabledSetting(true)
                     .setLocationEnabledSetting(true)
                     .setGeoDetectionEnabledSetting(true)
@@ -109,6 +112,7 @@ public class TimeZoneDetectorStrategyImplTest {
                     .setUserConfigAllowed(true)
                     .setTelephonyDetectionFeatureSupported(false)
                     .setGeoDetectionFeatureSupported(false)
+                    .setTelephonyFallbackSupported(false)
                     .setAutoDetectionEnabledSetting(false)
                     .setLocationEnabledSetting(true)
                     .setGeoDetectionEnabledSetting(false)
@@ -119,6 +123,7 @@ public class TimeZoneDetectorStrategyImplTest {
                     .setUserConfigAllowed(true)
                     .setTelephonyDetectionFeatureSupported(true)
                     .setGeoDetectionFeatureSupported(true)
+                    .setTelephonyFallbackSupported(false)
                     .setAutoDetectionEnabledSetting(false)
                     .setLocationEnabledSetting(true)
                     .setGeoDetectionEnabledSetting(false)
@@ -128,6 +133,7 @@ public class TimeZoneDetectorStrategyImplTest {
             new ConfigurationInternal.Builder(USER_ID)
                     .setTelephonyDetectionFeatureSupported(true)
                     .setGeoDetectionFeatureSupported(true)
+                    .setTelephonyFallbackSupported(false)
                     .setUserConfigAllowed(true)
                     .setAutoDetectionEnabledSetting(true)
                     .setLocationEnabledSetting(true)
@@ -138,6 +144,7 @@ public class TimeZoneDetectorStrategyImplTest {
             new ConfigurationInternal.Builder(USER_ID)
                     .setTelephonyDetectionFeatureSupported(true)
                     .setGeoDetectionFeatureSupported(true)
+                    .setTelephonyFallbackSupported(false)
                     .setUserConfigAllowed(true)
                     .setAutoDetectionEnabledSetting(true)
                     .setLocationEnabledSetting(true)
@@ -147,9 +154,6 @@ public class TimeZoneDetectorStrategyImplTest {
     private TimeZoneDetectorStrategyImpl mTimeZoneDetectorStrategy;
     private FakeEnvironment mFakeEnvironment;
 
-    // A fake source of time for suggestions. This will typically be incremented after every use.
-    @ElapsedRealtimeLong private long mElapsedRealtimeMillis;
-
     @Before
     public void setUp() {
         mFakeEnvironment = new FakeEnvironment();
@@ -752,6 +756,204 @@ public class TimeZoneDetectorStrategyImplTest {
                 mTimeZoneDetectorStrategy.getLatestGeolocationSuggestion());
     }
 
+    @Test
+    public void testTelephonyFallback() {
+        ConfigurationInternal config = new ConfigurationInternal.Builder(
+                CONFIG_AUTO_ENABLED_GEO_ENABLED)
+                .setTelephonyFallbackSupported(true)
+                .build();
+
+        Script script = new Script()
+                .initializeClock(ARBITRARY_ELAPSED_REALTIME_MILLIS)
+                .initializeTimeZoneSetting(ARBITRARY_TIME_ZONE_ID)
+                .simulateConfigurationInternalChange(config)
+                .resetConfigurationTracking();
+
+        // Confirm initial state is as expected.
+        script.verifyTelephonyFallbackIsEnabled(true)
+                .verifyTimeZoneNotChanged();
+
+        // Although geolocation detection is enabled, telephony fallback should be used initially
+        // and until a suitable "certain" geolocation suggestion is received.
+        {
+            TelephonyTimeZoneSuggestion telephonySuggestion = createTelephonySuggestion(
+                    SLOT_INDEX1, MATCH_TYPE_NETWORK_COUNTRY_AND_OFFSET, QUALITY_SINGLE_ZONE,
+                    "Europe/Paris");
+            script.simulateIncrementClock()
+                    .simulateTelephonyTimeZoneSuggestion(telephonySuggestion)
+                    .verifyTimeZoneChangedAndReset(telephonySuggestion)
+                    .verifyTelephonyFallbackIsEnabled(true);
+        }
+
+        // Receiving an "uncertain" geolocation suggestion should have no effect.
+        {
+            GeolocationTimeZoneSuggestion uncertainGeolocationSuggestion =
+                    createUncertainGeolocationSuggestion();
+            script.simulateIncrementClock()
+                    .simulateGeolocationTimeZoneSuggestion(uncertainGeolocationSuggestion)
+                    .verifyTimeZoneNotChanged()
+                    .verifyTelephonyFallbackIsEnabled(true);
+        }
+
+        // Receiving a "certain" geolocation suggestion should disable telephony fallback mode.
+        {
+            GeolocationTimeZoneSuggestion geolocationSuggestion =
+                    createCertainGeolocationSuggestion("Europe/London");
+            script.simulateIncrementClock()
+                    .simulateGeolocationTimeZoneSuggestion(geolocationSuggestion)
+                    .verifyTimeZoneChangedAndReset(geolocationSuggestion)
+                    .verifyTelephonyFallbackIsEnabled(false);
+        }
+
+        // Used to record the last telephony suggestion received, which will be used when fallback
+        // takes place.
+        TelephonyTimeZoneSuggestion lastTelephonySuggestion;
+
+        // Telephony suggestions should now be ignored and geolocation detection is "in control".
+        {
+            TelephonyTimeZoneSuggestion telephonySuggestion = createTelephonySuggestion(
+                    SLOT_INDEX1, MATCH_TYPE_NETWORK_COUNTRY_AND_OFFSET, QUALITY_SINGLE_ZONE,
+                    "Europe/Berlin");
+            script.simulateIncrementClock()
+                    .simulateTelephonyTimeZoneSuggestion(telephonySuggestion)
+                    .verifyTimeZoneNotChanged()
+                    .verifyTelephonyFallbackIsEnabled(false);
+            lastTelephonySuggestion = telephonySuggestion;
+        }
+
+        // Geolocation suggestions should continue to be used as normal (previous telephony
+        // suggestions are not used, even when the geolocation suggestion is uncertain).
+        {
+            GeolocationTimeZoneSuggestion geolocationSuggestion =
+                    createCertainGeolocationSuggestion("Europe/Rome");
+            script.simulateIncrementClock()
+                    .simulateGeolocationTimeZoneSuggestion(geolocationSuggestion)
+                    .verifyTimeZoneChangedAndReset(geolocationSuggestion)
+                    .verifyTelephonyFallbackIsEnabled(false);
+
+            GeolocationTimeZoneSuggestion uncertainGeolocationSuggestion =
+                    createUncertainGeolocationSuggestion();
+            script.simulateIncrementClock()
+                    .simulateGeolocationTimeZoneSuggestion(uncertainGeolocationSuggestion)
+                    .verifyTimeZoneNotChanged()
+                    .verifyTelephonyFallbackIsEnabled(false);
+
+            script.simulateIncrementClock()
+                    .simulateGeolocationTimeZoneSuggestion(geolocationSuggestion)
+                    // No change needed, device will already be set to Europe/Rome.
+                    .verifyTimeZoneNotChanged()
+                    .verifyTelephonyFallbackIsEnabled(false);
+        }
+
+        // Enable telephony fallback. Nothing will change, because the geolocation is still certain,
+        // but fallback will remain enabled.
+        {
+            script.simulateIncrementClock()
+                    .simulateEnableTelephonyFallback()
+                    .verifyTimeZoneNotChanged()
+                    .verifyTelephonyFallbackIsEnabled(true);
+        }
+
+        // Make the geolocation algorithm uncertain.
+        {
+            GeolocationTimeZoneSuggestion uncertainGeolocationSuggestion =
+                    createUncertainGeolocationSuggestion();
+            script.simulateIncrementClock()
+                    .simulateGeolocationTimeZoneSuggestion(uncertainGeolocationSuggestion)
+                    .verifyTimeZoneChangedAndReset(lastTelephonySuggestion)
+                    .verifyTelephonyFallbackIsEnabled(true);
+        }
+
+        // Make the geolocation algorithm certain, disabling telephony fallback.
+        {
+            GeolocationTimeZoneSuggestion geolocationSuggestion =
+                    createCertainGeolocationSuggestion("Europe/Lisbon");
+            script.simulateIncrementClock()
+                    .simulateGeolocationTimeZoneSuggestion(geolocationSuggestion)
+                    .verifyTimeZoneChangedAndReset(geolocationSuggestion)
+                    .verifyTelephonyFallbackIsEnabled(false);
+
+        }
+
+        // Demonstrate what happens when geolocation is uncertain when telephony fallback is
+        // enabled.
+        {
+            GeolocationTimeZoneSuggestion uncertainGeolocationSuggestion =
+                    createUncertainGeolocationSuggestion();
+            script.simulateIncrementClock()
+                    .simulateGeolocationTimeZoneSuggestion(uncertainGeolocationSuggestion)
+                    .verifyTimeZoneNotChanged()
+                    .verifyTelephonyFallbackIsEnabled(false)
+                    .simulateEnableTelephonyFallback()
+                    .verifyTimeZoneChangedAndReset(lastTelephonySuggestion)
+                    .verifyTelephonyFallbackIsEnabled(true);
+        }
+    }
+
+    @Test
+    public void testTelephonyFallback_noTelephonySuggestionToFallBackTo() {
+        ConfigurationInternal config = new ConfigurationInternal.Builder(
+                CONFIG_AUTO_ENABLED_GEO_ENABLED)
+                .setTelephonyFallbackSupported(true)
+                .build();
+
+        Script script = new Script()
+                .initializeClock(ARBITRARY_ELAPSED_REALTIME_MILLIS)
+                .initializeTimeZoneSetting(ARBITRARY_TIME_ZONE_ID)
+                .simulateConfigurationInternalChange(config)
+                .resetConfigurationTracking();
+
+        // Confirm initial state is as expected.
+        script.verifyTelephonyFallbackIsEnabled(true)
+                .verifyTimeZoneNotChanged();
+
+        // Receiving an "uncertain" geolocation suggestion should have no effect.
+        {
+            GeolocationTimeZoneSuggestion uncertainGeolocationSuggestion =
+                    createUncertainGeolocationSuggestion();
+            script.simulateIncrementClock()
+                    .simulateGeolocationTimeZoneSuggestion(uncertainGeolocationSuggestion)
+                    .verifyTimeZoneNotChanged()
+                    .verifyTelephonyFallbackIsEnabled(true);
+        }
+
+        // Make an uncertain geolocation suggestion, there is no telephony suggestion to fall back
+        // to
+        {
+            GeolocationTimeZoneSuggestion uncertainGeolocationSuggestion =
+                    createUncertainGeolocationSuggestion();
+            script.simulateIncrementClock()
+                    .simulateGeolocationTimeZoneSuggestion(uncertainGeolocationSuggestion)
+                    .verifyTimeZoneNotChanged()
+                    .verifyTelephonyFallbackIsEnabled(true);
+        }
+
+        // Similar to the case above, but force a fallback attempt after making a "certain"
+        // geolocation suggestion.
+        // Geolocation suggestions should continue to be used as normal (previous telephony
+        // suggestions are not used, even when the geolocation suggestion is uncertain).
+        {
+            GeolocationTimeZoneSuggestion geolocationSuggestion =
+                    createCertainGeolocationSuggestion("Europe/Rome");
+            script.simulateIncrementClock()
+                    .simulateGeolocationTimeZoneSuggestion(geolocationSuggestion)
+                    .verifyTimeZoneChangedAndReset(geolocationSuggestion)
+                    .verifyTelephonyFallbackIsEnabled(false);
+
+            GeolocationTimeZoneSuggestion uncertainGeolocationSuggestion =
+                    createUncertainGeolocationSuggestion();
+            script.simulateIncrementClock()
+                    .simulateGeolocationTimeZoneSuggestion(uncertainGeolocationSuggestion)
+                    .verifyTimeZoneNotChanged()
+                    .verifyTelephonyFallbackIsEnabled(false);
+
+            script.simulateIncrementClock()
+                    .simulateEnableTelephonyFallback()
+                    .verifyTimeZoneNotChanged()
+                    .verifyTelephonyFallbackIsEnabled(true);
+        }
+    }
+
     @Test
     public void testGenerateMetricsState() {
         ConfigurationInternal expectedInternalConfig = CONFIG_AUTO_DISABLED_GEO_DISABLED;
@@ -835,6 +1037,8 @@ public class TimeZoneDetectorStrategyImplTest {
         assertEquals(config.isTelephonyDetectionSupported(),
                 actualState.isTelephonyDetectionSupported());
         assertEquals(config.isGeoDetectionSupported(), actualState.isGeoDetectionSupported());
+        assertEquals(config.isTelephonyFallbackSupported(),
+                actualState.isTelephonyTimeZoneFallbackSupported());
         assertEquals(config.getAutoDetectionEnabledSetting(),
                 actualState.getAutoDetectionEnabledSetting());
         assertEquals(config.getGeoDetectionEnabledSetting(),
@@ -865,7 +1069,7 @@ public class TimeZoneDetectorStrategyImplTest {
 
     private GeolocationTimeZoneSuggestion createUncertainGeolocationSuggestion() {
         return GeolocationTimeZoneSuggestion.createCertainSuggestion(
-                mElapsedRealtimeMillis++, null);
+                mFakeEnvironment.elapsedRealtimeMillis(), null);
     }
 
     private GeolocationTimeZoneSuggestion createCertainGeolocationSuggestion(
@@ -874,7 +1078,7 @@ public class TimeZoneDetectorStrategyImplTest {
 
         GeolocationTimeZoneSuggestion suggestion =
                 GeolocationTimeZoneSuggestion.createCertainSuggestion(
-                        mElapsedRealtimeMillis++, Arrays.asList(zoneIds));
+                        mFakeEnvironment.elapsedRealtimeMillis(), Arrays.asList(zoneIds));
         suggestion.addDebugInfo("Test suggestion");
         return suggestion;
     }
@@ -883,16 +1087,25 @@ public class TimeZoneDetectorStrategyImplTest {
 
         private final TestState<String> mTimeZoneId = new TestState<>();
         private ConfigurationInternal mConfigurationInternal;
+        private @ElapsedRealtimeLong long mElapsedRealtimeMillis;
         private ConfigurationChangeListener mConfigurationInternalChangeListener;
 
         void initializeConfig(ConfigurationInternal configurationInternal) {
             mConfigurationInternal = configurationInternal;
         }
 
+        void initializeClock(@ElapsedRealtimeLong long elapsedRealtimeMillis) {
+            mElapsedRealtimeMillis = elapsedRealtimeMillis;
+        }
+
         void initializeTimeZoneSetting(String zoneId) {
             mTimeZoneId.init(zoneId);
         }
 
+        void incrementClock() {
+            mElapsedRealtimeMillis++;
+        }
+
         @Override
         public void setConfigurationInternalChangeListener(ConfigurationChangeListener listener) {
             mConfigurationInternalChangeListener = listener;
@@ -936,6 +1149,12 @@ public class TimeZoneDetectorStrategyImplTest {
         void commitAllChanges() {
             mTimeZoneId.commitLatest();
         }
+
+        @Override
+        @ElapsedRealtimeLong
+        public long elapsedRealtimeMillis() {
+            return mElapsedRealtimeMillis;
+        }
     }
 
     /**
@@ -949,6 +1168,16 @@ public class TimeZoneDetectorStrategyImplTest {
             return this;
         }
 
+        Script initializeClock(long elapsedRealtimeMillis) {
+            mFakeEnvironment.initializeClock(elapsedRealtimeMillis);
+            return this;
+        }
+
+        Script simulateIncrementClock() {
+            mFakeEnvironment.incrementClock();
+            return this;
+        }
+
         /**
          * Simulates the user / user's configuration changing.
          */
@@ -1008,6 +1237,15 @@ public class TimeZoneDetectorStrategyImplTest {
             return this;
         }
 
+        /**
+         * Simulates the time zone detection strategty receiving a signal that allows it to do
+         * telephony fallback.
+         */
+        Script simulateEnableTelephonyFallback() {
+            mTimeZoneDetectorStrategy.enableTelephonyTimeZoneFallback();
+            return this;
+        }
+
         /**
          * Confirms that the device's time zone has not been set by previous actions since the test
          * state was last reset.
@@ -1044,6 +1282,13 @@ public class TimeZoneDetectorStrategyImplTest {
             return this;
         }
 
+        /** Verifies the state for telephony fallback. */
+        Script verifyTelephonyFallbackIsEnabled(boolean expectedEnabled) {
+            assertEquals(expectedEnabled,
+                    mTimeZoneDetectorStrategy.isTelephonyFallbackEnabledForTests());
+            return this;
+        }
+
         Script resetConfigurationTracking() {
             mFakeEnvironment.commitAllChanges();
             return this;
diff --git a/services/tests/servicestests/src/com/android/server/timezonedetector/location/TestSupport.java b/services/tests/servicestests/src/com/android/server/timezonedetector/location/TestSupport.java
index e3da90e343ed8..a2df31305c2f7 100644
--- a/services/tests/servicestests/src/com/android/server/timezonedetector/location/TestSupport.java
+++ b/services/tests/servicestests/src/com/android/server/timezonedetector/location/TestSupport.java
@@ -46,6 +46,7 @@ final class TestSupport {
                 .setUserConfigAllowed(true)
                 .setTelephonyDetectionFeatureSupported(true)
                 .setGeoDetectionFeatureSupported(true)
+                .setTelephonyFallbackSupported(false)
                 .setAutoDetectionEnabledSetting(true)
                 .setLocationEnabledSetting(true)
                 .setGeoDetectionEnabledSetting(geoDetectionEnabledSetting)