diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index 73e9c2a..677e757 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -63,6 +63,7 @@
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
     <uses-permission android:name="android.permission.BROADCAST_STICKY" />
     <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+    <uses-permission android:name="android.permission.RECEIVE_SMS" />
     <uses-permission android:name="android.permission.SEND_SMS" />
     <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
     <uses-permission android:name="android.permission.CONNECTIVITY_USE_RESTRICTED_NETWORKS" />
@@ -658,6 +659,16 @@
         </receiver>
 
         <receiver
+            android:name="com.android.voicemail.impl.sms.AdvvmSmsReceiver"
+            android:exported="true"
+            android:directBootAware="true">
+            <intent-filter>
+                <action android:name="android.intent.action.DATA_SMS_RECEIVED"/>
+                <data android:host="localhost" android:port="5499" android:scheme="sms"/>
+            </intent-filter>
+        </receiver>
+
+        <receiver
             android:name="com.android.voicemail.impl.VoicemailClientReceiver"
             android:exported="false">
             <intent-filter>
diff --git a/java/com/android/dialer/app/res/values-cy/cm_strings.xml b/java/com/android/dialer/app/res/values-cy/cm_strings.xml
index 922734c..c61db39 100644
--- a/java/com/android/dialer/app/res/values-cy/cm_strings.xml
+++ b/java/com/android/dialer/app/res/values-cy/cm_strings.xml
@@ -32,4 +32,5 @@
     <string name="call_via_dialog_title">Galu gyda\u2026</string>
     <string name="call_log_stats_title">Ystadegau</string>
     <string name="action_menu_helplines">Llinellau Cymorth</string>
+    <string name="default_dialer_action">Gosod fel rhagosodiad</string>
 </resources>
diff --git a/java/com/android/dialer/callstats/res/values-pl/cm_strings.xml b/java/com/android/dialer/callstats/res/values-pl/cm_strings.xml
index f5a3c14..ddd3545 100644
--- a/java/com/android/dialer/callstats/res/values-pl/cm_strings.xml
+++ b/java/com/android/dialer/callstats/res/values-pl/cm_strings.xml
@@ -37,8 +37,8 @@
     <string name="date_qs_lastyear">Ostatni rok</string>
     <string name="call_stats_date_filter">Dostosuj zakres czasu</string>
     <string name="call_stats_reset_filter">Zresetuj zakres czasu</string>
-    <string name="call_stats_sort_by_duration">Sortuj po długości połączenia</string>
-    <string name="call_stats_sort_by_count">Sortuj po liczbie połączeń</string>
+    <string name="call_stats_sort_by_duration">Sortuj według długości połączenia</string>
+    <string name="call_stats_sort_by_count">Sortuj według liczby połączeń</string>
     <string name="call_stats_title_for_number">Ten numer</string>
     <string name="call_stats_title_of_total">Wszystkich</string>
     <string name="call_stats_title_durations">Czasy połączeń</string>
diff --git a/java/com/android/dialer/database/CallLogQueryHandler.java b/java/com/android/dialer/database/CallLogQueryHandler.java
index 4c19e2d..99125ca 100644
--- a/java/com/android/dialer/database/CallLogQueryHandler.java
+++ b/java/com/android/dialer/database/CallLogQueryHandler.java
@@ -157,12 +157,8 @@
     StringBuilder where = new StringBuilder();
     List<String> selectionArgs = new ArrayList<>();
 
-    // Always hide blocked calls.
-    where.append("(").append(Calls.TYPE).append(" != ?)");
-    selectionArgs.add(Integer.toString(Calls.BLOCKED_TYPE));
-
     // Ignore voicemails marked as deleted
-    where.append(" AND (").append(Voicemails.DELETED).append(" = 0)");
+    where.append("(").append(Voicemails.DELETED).append(" = 0)");
 
     if (newOnly) {
       where.append(" AND (").append(Calls.NEW).append(" = 1)");
diff --git a/java/com/android/dialer/helplines/res/values-is/strings.xml b/java/com/android/dialer/helplines/res/values-is/strings.xml
index 3f509e5..ea9a9ff 100644
--- a/java/com/android/dialer/helplines/res/values-is/strings.xml
+++ b/java/com/android/dialer/helplines/res/values-is/strings.xml
@@ -20,6 +20,8 @@
     <string name="helplines_empty">Engar hjálparlínur fundust.\nSettu inn SIM-kort og prófaðu aftur</string>
     <string name="helplines_help">Hjálp</string>
     <string name="helplines_help_title">Það er öruggt að hringja í þessi númer</string>
+    <string name="helplines_help_message">Ekkert þessara númera kemur fram í símtalaferlinum þínum.\nÞú getur smellt á atriðin til að fá meiri upplýsingar</string>
+    <string name="helplines_help_more_message">Listinn yfir hjálparlínur byggist á upplýsingum sem þáttakendur fylla er inn handvirkt. Ef þú rekst á upplýsingar sem vantar eða eru rangar, skaltu endilega hafa samband við <xliff:g id="helplines_contact_url" example="www.lineageos.org">%1$s</xliff:g></string>
     <string name="helpline_button_more">Meira</string>
     <string name="unknown_helpline_name">Óþekktur aðili</string>
     <string name="helpline_name">Heiti</string>
diff --git a/java/com/android/dialer/lookup/res/values-da/cm_strings.xml b/java/com/android/dialer/lookup/res/values-da/cm_strings.xml
index d4f7a6a..70583b3 100644
--- a/java/com/android/dialer/lookup/res/values-da/cm_strings.xml
+++ b/java/com/android/dialer/lookup/res/values-da/cm_strings.xml
@@ -19,6 +19,6 @@
     <string name="lookup_settings_label">Slå telefonnummer op</string>
     <string name="enable_forward_lookup_title">Slå telefonnummer op, når du ringer</string>
     <string name="enable_forward_lookup_summary">Vis nærliggende steder, ved søgning i telefonen</string>
-    <string name="enable_reverse_lookup_title">Slå telefonnummer op, når du modtager opkald</string>
+    <string name="enable_reverse_lookup_title">Omvendt opslag</string>
     <string name="enable_reverse_lookup_summary">Slå information op om personen, eller stedet, for ukendte numre, ved indgående opkald</string>
 </resources>
diff --git a/java/com/android/dialer/util/PermissionsUtil.java b/java/com/android/dialer/util/PermissionsUtil.java
index 3844380..7db383f 100644
--- a/java/com/android/dialer/util/PermissionsUtil.java
+++ b/java/com/android/dialer/util/PermissionsUtil.java
@@ -26,6 +26,7 @@
 import static android.Manifest.permission.READ_CONTACTS;
 import static android.Manifest.permission.READ_PHONE_STATE;
 import static android.Manifest.permission.READ_VOICEMAIL;
+import static android.Manifest.permission.RECEIVE_SMS;
 import static android.Manifest.permission.SEND_SMS;
 import static android.Manifest.permission.WRITE_CALL_LOG;
 import static android.Manifest.permission.WRITE_CONTACTS;
@@ -70,6 +71,7 @@
               WRITE_CALL_LOG,
               READ_PHONE_STATE,
               MODIFY_PHONE_STATE,
+              RECEIVE_SMS,
               SEND_SMS,
               CALL_PHONE,
               ADD_VOICEMAIL,
@@ -138,6 +140,10 @@
     return hasPermission(context, permission.ADD_VOICEMAIL);
   }
 
+  public static boolean hasReceiveSmsPermissions(Context context) {
+    return hasPermission(context, permission.RECEIVE_SMS);
+  }
+
   public static boolean hasSendSmsPermissions(Context context) {
     return hasPermission(context, permission.SEND_SMS);
   }
diff --git a/java/com/android/voicemail/VisualVoicemailTypeExtensions.java b/java/com/android/voicemail/VisualVoicemailTypeExtensions.java
index 0564810..051f393 100644
--- a/java/com/android/voicemail/VisualVoicemailTypeExtensions.java
+++ b/java/com/android/voicemail/VisualVoicemailTypeExtensions.java
@@ -26,4 +26,6 @@
 
   // Protocol used by Verizon wireless
   public static final String VVM_TYPE_VVM3 = "vvm_type_vvm3";
+  // Protocol used by AT&T
+  public static final String VVM_TYPE_ADVVM = "vvm_type_advvm";
 }
diff --git a/java/com/android/voicemail/VoicemailPermissionHelper.java b/java/com/android/voicemail/VoicemailPermissionHelper.java
index b7cdbca..b8b0d90 100644
--- a/java/com/android/voicemail/VoicemailPermissionHelper.java
+++ b/java/com/android/voicemail/VoicemailPermissionHelper.java
@@ -37,6 +37,7 @@
     permission.WRITE_VOICEMAIL,
     permission.READ_VOICEMAIL,
     permission.READ_PHONE_STATE,
+    permission.RECEIVE_SMS,
     permission.SEND_SMS
   };
 
diff --git a/java/com/android/voicemail/impl/OmtpVvmCarrierConfigHelper.java b/java/com/android/voicemail/impl/OmtpVvmCarrierConfigHelper.java
index 8c91ebf..1224789 100644
--- a/java/com/android/voicemail/impl/OmtpVvmCarrierConfigHelper.java
+++ b/java/com/android/voicemail/impl/OmtpVvmCarrierConfigHelper.java
@@ -91,6 +91,7 @@
 
   public static final String KEY_VVM_CLIENT_PREFIX_STRING = "vvm_client_prefix_string";
   private static final String KEY_IGNORE_TRANSCRIPTION_BOOL = "vvm_ignore_transcription";
+  private static final String KEY_USE_DIRECT_TLS_CONNECTION_BOOL = "vvm_use_direct_tls_connection";
 
   private final Context context;
   private final PersistableBundle carrierConfig;
@@ -254,6 +255,10 @@
   /** @return Port to start a SSL IMAP connection directly. */
   public int getSslPort() {
     Assert.checkArgument(isValid());
+    if (useDirectTlsConnection()) {
+      VvmLog.i(TAG, "vvm_use_direct_tls_connection = true");
+      return 993;
+    }
     return (int) getValue(KEY_VVM_SSL_PORT_NUMBER_INT, 0);
   }
 
@@ -502,4 +507,12 @@
     Assert.checkArgument(isValid());
     return (boolean) getValue(KEY_IGNORE_TRANSCRIPTION_BOOL, false);
   }
+
+  /**
+   * Allow forcing direct TLS, default to false.
+   */
+  public boolean useDirectTlsConnection() {
+    Assert.checkArgument(isValid());
+    return (boolean) getValue(KEY_USE_DIRECT_TLS_CONNECTION_BOOL, false);
+  }
 }
diff --git a/java/com/android/voicemail/impl/configui/ConfigOverrideFragment.java b/java/com/android/voicemail/impl/configui/ConfigOverrideFragment.java
index 6597593..263ae6a 100644
--- a/java/com/android/voicemail/impl/configui/ConfigOverrideFragment.java
+++ b/java/com/android/voicemail/impl/configui/ConfigOverrideFragment.java
@@ -54,10 +54,9 @@
   private static final String CONFIG_OVERRIDE_KEY_PREFIX = "vvm_config_override_key_";
 
   @Override
-  public void onCreate(@Nullable Bundle savedInstanceState) {
-    super.onCreate(savedInstanceState);
+  public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {
     PreferenceManager.setDefaultValues(getActivity(), R.xml.vvm_config_override, false);
-    addPreferencesFromResource(R.xml.vvm_config_override);
+    setPreferencesFromResource(R.xml.vvm_config_override, rootKey);
 
     // add listener so the value of a EditTextPreference will be updated to the summary.
     for (int i = 0; i < getPreferenceScreen().getPreferenceCount(); i++) {
@@ -82,17 +81,6 @@
   }
 
   @Override
-  public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {
-      setPreferencesFromResource(R.xml.vvm_config_override, rootKey);
-
-      for (int i = 0; i < getPreferenceScreen().getPreferenceCount(); i++) {
-        Preference preference = getPreferenceScreen().getPreference(i);
-        preference.setOnPreferenceChangeListener(this);
-        updatePreference(preference);
-      }
-  }
-
-  @Override
   public boolean onPreferenceTreeClick(Preference preference) {
       if (TextUtils.equals(
           preference.getKey(), getString(R.string.vvm_config_override_load_current_key))) {
diff --git a/java/com/android/voicemail/impl/configui/VoicemailSecretCodeActivity.java b/java/com/android/voicemail/impl/configui/VoicemailSecretCodeActivity.java
index d6b0c4b..aa7e263 100644
--- a/java/com/android/voicemail/impl/configui/VoicemailSecretCodeActivity.java
+++ b/java/com/android/voicemail/impl/configui/VoicemailSecretCodeActivity.java
@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2017 The Android Open Source Project
- * Copyright (C) 2023 The LineageOS Project
+ * Copyright (C) 2024 The LineageOS Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,44 +17,21 @@
 
 package com.android.voicemail.impl.configui;
 
-import android.content.Intent;
-import android.preference.PreferenceActivity;
-import android.provider.VoicemailContract;
+import android.os.Bundle;
 
-import java.util.List;
+import androidx.appcompat.app.AppCompatActivity;
+import com.android.dialer.R;
 
 /** Activity launched by simulator->voicemail, provides debug features. */
 @SuppressWarnings("FragmentInjection") // not exported
-public class VoicemailSecretCodeActivity extends PreferenceActivity {
-
-  private Header syncHeader;
+public class VoicemailSecretCodeActivity extends AppCompatActivity {
 
   @Override
-  public void onBuildHeaders(List<Header> target) {
-    super.onBuildHeaders(target);
-    syncHeader = new Header();
-    syncHeader.title = "Sync";
-    target.add(syncHeader);
-
-    Header configOverride = new Header();
-    configOverride.fragment = ConfigOverrideFragment.class.getName();
-    configOverride.title = "VVM config override";
-    target.add(configOverride);
-  }
-
-  @Override
-  public void onHeaderClick(Header header, int position) {
-    if (header == syncHeader) {
-      Intent intent = new Intent(VoicemailContract.ACTION_SYNC_VOICEMAIL);
-      intent.setPackage(getPackageName());
-      sendBroadcast(intent);
-      return;
-    }
-    super.onHeaderClick(header, position);
-  }
-
-  @Override
-  protected boolean isValidFragment(String fragmentName) {
-    return true;
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    setTheme(R.style.SettingsStyle);
+    getSupportFragmentManager().beginTransaction()
+      .replace(android.R.id.content, new VoicemailSecretCodeFragment())
+      .commit();
   }
 }
diff --git a/java/com/android/voicemail/impl/configui/VoicemailSecretCodeFragment.java b/java/com/android/voicemail/impl/configui/VoicemailSecretCodeFragment.java
new file mode 100644
index 0000000..f34fe5a
--- /dev/null
+++ b/java/com/android/voicemail/impl/configui/VoicemailSecretCodeFragment.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2024 The LineageOS 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.voicemail.impl.configui;
+
+import android.os.Bundle;
+import android.text.TextUtils;
+
+import androidx.preference.Preference;
+import androidx.preference.Preference.OnPreferenceClickListener;
+import androidx.preference.PreferenceFragmentCompat;
+
+import android.content.Intent;
+import android.provider.VoicemailContract;
+
+public class VoicemailSecretCodeFragment extends PreferenceFragmentCompat
+    implements OnPreferenceClickListener {
+
+  private Preference syncPreference;
+  private Preference configOverridePreference;
+  private static final String SYNC_KEY = "sync_preference";
+  private static final String CONFIG_OVERRIDE_KEY =
+    "config_override_preference";
+
+  @Override
+  public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {
+    setPreferencesFromResource(R.xml.vvm_secret_main, rootKey);
+
+    syncPreference = findPreference(SYNC_KEY);
+    syncPreference.setOnPreferenceClickListener(this);
+
+    configOverridePreference = findPreference(CONFIG_OVERRIDE_KEY);
+    configOverridePreference.setOnPreferenceClickListener(this);
+  }
+
+  @Override
+  public boolean onPreferenceClick(Preference preference) {
+    if (TextUtils.equals(preference.getKey(), SYNC_KEY)) {
+      Intent intent = new Intent(VoicemailContract.ACTION_SYNC_VOICEMAIL);
+      intent.setPackage(requireContext().getPackageName());
+      requireContext().sendBroadcast(intent);
+    } else {
+      getParentFragmentManager().beginTransaction()
+        .replace(android.R.id.content, new ConfigOverrideFragment())
+        .addToBackStack(null)
+        .commit();
+    }
+    return true;
+  }
+}
diff --git a/java/com/android/voicemail/impl/configui/res/values/lineage_strings.xml b/java/com/android/voicemail/impl/configui/res/values/lineage_strings.xml
new file mode 100644
index 0000000..274064a
--- /dev/null
+++ b/java/com/android/voicemail/impl/configui/res/values/lineage_strings.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2024 The LineageOS 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.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="sync_preference_title">Sync</string>
+  <string name="config_override_preference_title">VVM config override</string>
+</resources>
diff --git a/java/com/android/voicemail/impl/configui/res/values/strings.xml b/java/com/android/voicemail/impl/configui/res/values/strings.xml
index fea76be..7410f1f 100644
--- a/java/com/android/voicemail/impl/configui/res/values/strings.xml
+++ b/java/com/android/voicemail/impl/configui/res/values/strings.xml
@@ -17,5 +17,4 @@
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
   <string name="vvm_config_override_load_current_key" translatable="false">vvm_config_override_load_current</string>
   <string name="vvm_config_override_enabled_key" translatable="false">vvm_config_override_enabled</string>
-
 </resources>
diff --git a/java/com/android/voicemail/impl/configui/res/xml/vvm_secret_main.xml b/java/com/android/voicemail/impl/configui/res/xml/vvm_secret_main.xml
new file mode 100644
index 0000000..969b22c
--- /dev/null
+++ b/java/com/android/voicemail/impl/configui/res/xml/vvm_secret_main.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android">
+  <Preference
+    android:key="sync_preference"
+    android:title="@string/sync_preference_title" />
+  <Preference
+    android:key="config_override_preference"
+    android:title="@string/config_override_preference_title" />
+</PreferenceScreen>
diff --git a/java/com/android/voicemail/impl/imap/ImapHelper.java b/java/com/android/voicemail/impl/imap/ImapHelper.java
index 95e7bbb..955eba9 100644
--- a/java/com/android/voicemail/impl/imap/ImapHelper.java
+++ b/java/com/android/voicemail/impl/imap/ImapHelper.java
@@ -125,6 +125,10 @@
       int port = Integer.parseInt(prefs.getString(OmtpConstants.IMAP_PORT, null));
       int auth = ImapStore.FLAG_NONE;
 
+      if (serverName != null) {
+        serverName = serverName.replaceFirst("[12]:", "");
+      }
+
       int sslPort = this.config.getSslPort();
       if (sslPort != 0) {
         port = sslPort;
diff --git a/java/com/android/voicemail/impl/mail/store/ImapConnection.java b/java/com/android/voicemail/impl/mail/store/ImapConnection.java
index 4a4debb..8b1ee83 100644
--- a/java/com/android/voicemail/impl/mail/store/ImapConnection.java
+++ b/java/com/android/voicemail/impl/mail/store/ImapConnection.java
@@ -171,6 +171,9 @@
 
   /** Attempts to convert the connection into secure connection. */
   private void maybeDoStartTls() throws IOException, MessagingException {
+    if (imapStore.getImapHelper().getConfig().useDirectTlsConnection()) {
+      return;
+    }
     // STARTTLS is required in the OMTP standard but not every implementation support it.
     // Make sure the server does have this capability
     if (hasCapability(ImapConstants.CAPABILITY_STARTTLS)) {
diff --git a/java/com/android/voicemail/impl/protocol/VisualVoicemailProtocolFactory.java b/java/com/android/voicemail/impl/protocol/VisualVoicemailProtocolFactory.java
index 7f635f1..57f1e1f 100644
--- a/java/com/android/voicemail/impl/protocol/VisualVoicemailProtocolFactory.java
+++ b/java/com/android/voicemail/impl/protocol/VisualVoicemailProtocolFactory.java
@@ -39,6 +39,7 @@
       case TelephonyManager.VVM_TYPE_CVVM:
         return new CvvmProtocol();
       case VisualVoicemailTypeExtensions.VVM_TYPE_VVM3:
+      case VisualVoicemailTypeExtensions.VVM_TYPE_ADVVM:
         return new Vvm3Protocol();
       default:
         VvmLog.e(TAG, "Unexpected visual voicemail type: " + type);
diff --git a/java/com/android/voicemail/impl/sms/AdvvmSmsReceiver.java b/java/com/android/voicemail/impl/sms/AdvvmSmsReceiver.java
new file mode 100644
index 0000000..384b8ce
--- /dev/null
+++ b/java/com/android/voicemail/impl/sms/AdvvmSmsReceiver.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2024 The LineageOS 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.voicemail.impl.sms;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.provider.Telephony;
+import android.telephony.SmsMessage;
+import com.android.dialer.telecom.TelecomUtil;
+import android.telecom.PhoneAccount;
+import android.telecom.PhoneAccountHandle;
+import com.android.voicemail.impl.sync.SyncTask;
+
+/** Receive data SMS messages for the ADVVM protocol used by AT&T and others. */
+public class AdvvmSmsReceiver extends BroadcastReceiver {
+
+  private static final String TAG = "AdvvmSmsReceiver";
+
+  @Override
+  public void onReceive(Context context, Intent intent) {
+    SmsMessage[] messages = Telephony.Sms.Intents.getMessagesFromIntent(intent);
+    for (SmsMessage msg: messages) {
+      // in order to query parameters we need to have a `scheme://`
+      Uri bodyUri = Uri.parse("advvm://" + msg.getMessageBody());
+      // TODO: once AT&T's protocol is better understood, we probably will need
+      // to handle the actual parameters of this. For now, just trigger a sync
+      // since that is apparently the only time we will receive these messages
+      // currently.
+      PhoneAccountHandle phone =
+          TelecomUtil.getDefaultOutgoingPhoneAccount(context, PhoneAccount.SCHEME_VOICEMAIL);
+      SyncTask.start(context, phone);
+    }
+  }
+}
diff --git a/privapp_whitelist_com.android.dialer-ext.xml b/privapp_whitelist_com.android.dialer-ext.xml
index 814e88e..c13d9c7 100644
--- a/privapp_whitelist_com.android.dialer-ext.xml
+++ b/privapp_whitelist_com.android.dialer-ext.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!--
-     Copyright (C) 2019-2023 The LineageOS Project
+     Copyright (C) 2019-2024 The LineageOS Project
 
      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
@@ -19,5 +19,6 @@
     <privapp-permissions package="com.android.dialer">
         <permission name="android.permission.CAPTURE_AUDIO_OUTPUT"/>
         <permission name="android.permission.BROADCAST_CLOSE_SYSTEM_DIALOGS"/>
+        <permission name="android.permission.RECEIVE_SMS"/>
     </privapp-permissions>
 </permissions>
