diff --git a/java/com/android/contacts/common/list/ContactListItemView.java b/java/com/android/contacts/common/list/ContactListItemView.java
index 91abe4c..c605f4e 100644
--- a/java/com/android/contacts/common/list/ContactListItemView.java
+++ b/java/com/android/contacts/common/list/ContactListItemView.java
@@ -55,6 +55,7 @@
 import com.android.contacts.common.list.PhoneNumberListAdapter.Listener;
 import com.android.contacts.common.util.ContactDisplayUtils;
 import com.android.contacts.common.util.SearchUtil;
+import com.android.dialer.callintent.CallIntentBuilder;
 import com.android.dialer.util.ViewUtil;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
@@ -341,6 +342,7 @@
       description = R.string.description_search_video_call;
       onClickListener = v -> listener.onVideoCallIconClicked(position);
     } else if (action == LIGHTBRINGER) {
+      CallIntentBuilder.increaseLightbringerCallButtonAppearInSearchCount();
       drawable =
           ContextCompat.getDrawable(getContext(), R.drawable.quantum_ic_videocam_vd_theme_24);
       drawable.setAutoMirrored(true);
diff --git a/java/com/android/contacts/common/res/values-zh-rHK/strings.xml b/java/com/android/contacts/common/res/values-zh-rHK/strings.xml
index 122d0fe..842ac87 100644
--- a/java/com/android/contacts/common/res/values-zh-rHK/strings.xml
+++ b/java/com/android/contacts/common/res/values-zh-rHK/strings.xml
@@ -64,7 +64,7 @@
     <string name="sms_mms" msgid="5187888900503248542">"傳送短訊至 MMS 電話號碼"</string>
     <string name="sms_by_shortcut" msgid="8005496406639963582">"<xliff:g id="CONTACT_NAME">%s</xliff:g> (訊息)"</string>
     <string name="clearFrequentsConfirmation_title" msgid="7465690215775790243">"清除常用聯絡人？"</string>
-    <string name="clearFrequentsConfirmation" msgid="5750611450893399198">"您將清除「通訊錄」應用程式和「電話」應用程式中的常用聯絡人名單，並強制電子郵件應用程式重新取得您的寄件喜好設定。"</string>
+    <string name="clearFrequentsConfirmation" msgid="5750611450893399198">"您將清除「通訊錄」應用程式和「電話」應用程式中的常用聯絡人名單，並強制電子郵件應用程式重新取得您的寄件偏好設定。"</string>
     <string name="clearFrequentsProgress_title" msgid="2057183487226039454">"正在清除常用聯絡人…"</string>
     <string name="status_available" msgid="2648156525685472626">"在線"</string>
     <string name="status_away" msgid="2298688367552893953">"離開"</string>
diff --git a/java/com/android/dialer/app/calllog/CallLogAdapter.java b/java/com/android/dialer/app/calllog/CallLogAdapter.java
index 5241d9c..f4c8c90 100644
--- a/java/com/android/dialer/app/calllog/CallLogAdapter.java
+++ b/java/com/android/dialer/app/calllog/CallLogAdapter.java
@@ -63,6 +63,7 @@
 import com.android.dialer.blocking.FilteredNumberAsyncQueryHandler;
 import com.android.dialer.calldetails.CallDetailsEntries;
 import com.android.dialer.calldetails.CallDetailsEntries.CallDetailsEntry;
+import com.android.dialer.callintent.CallIntentBuilder;
 import com.android.dialer.calllogutils.PhoneAccountUtils;
 import com.android.dialer.calllogutils.PhoneCallDetails;
 import com.android.dialer.common.Assert;
@@ -293,6 +294,11 @@
         }
       };
 
+  @VisibleForTesting
+  public View.OnClickListener getExpandCollapseListener() {
+    return mExpandCollapseListener;
+  }
+
   /** The OnClickListener used to expand or collapse the action buttons of a call log entry. */
   private final View.OnClickListener mExpandCollapseListener =
       new View.OnClickListener() {
@@ -361,6 +367,17 @@
               }
             }
             expandViewHolderActions(viewHolder);
+
+            if (viewHolder.videoCallButtonView.getVisibility() == View.VISIBLE
+                && LightbringerComponent.get(mActivity)
+                    .getLightbringer()
+                    .getPackageName()
+                    .equals(
+                        ((IntentProvider) viewHolder.videoCallButtonView.getTag())
+                            .getIntent(mActivity)
+                            .getPackage())) {
+              CallIntentBuilder.increaseLightbringerCallButtonAppearInExpandedCallLogItemCount();
+            }
           }
         }
       };
diff --git a/java/com/android/dialer/app/calllog/CallLogListItemViewHolder.java b/java/com/android/dialer/app/calllog/CallLogListItemViewHolder.java
index b8b029f..27aa825 100644
--- a/java/com/android/dialer/app/calllog/CallLogListItemViewHolder.java
+++ b/java/com/android/dialer/app/calllog/CallLogListItemViewHolder.java
@@ -34,6 +34,8 @@
 import android.support.v7.widget.RecyclerView;
 import android.telecom.PhoneAccount;
 import android.telecom.PhoneAccountHandle;
+import android.telecom.TelecomManager;
+import android.telecom.VideoProfile;
 import android.telephony.PhoneNumberUtils;
 import android.text.BidiFormatter;
 import android.text.TextDirectionHeuristics;
@@ -66,6 +68,7 @@
 import com.android.dialer.callcomposer.CallComposerActivity;
 import com.android.dialer.calldetails.CallDetailsActivity;
 import com.android.dialer.calldetails.CallDetailsEntries;
+import com.android.dialer.callintent.CallIntentBuilder;
 import com.android.dialer.common.Assert;
 import com.android.dialer.common.LogUtil;
 import com.android.dialer.compat.CompatUtils;
@@ -85,6 +88,7 @@
 import com.android.dialer.phonenumbercache.ContactInfo;
 import com.android.dialer.phonenumbercache.PhoneNumberCache;
 import com.android.dialer.phonenumberutil.PhoneNumberHelper;
+import com.android.dialer.telecom.TelecomUtil;
 import com.android.dialer.util.CallUtil;
 import com.android.dialer.util.DialerUtils;
 import java.lang.annotation.Retention;
@@ -117,6 +121,7 @@
   public final ImageView primaryActionButtonView;
 
   private final Context mContext;
+  @Nullable private final PhoneAccountHandle mDefaultPhoneAccountHandle;
   private final CallLogCache mCallLogCache;
   private final CallLogListItemHelper mCallLogListItemHelper;
   private final CachedNumberLookupService mCachedNumberLookupService;
@@ -255,6 +260,10 @@
     mBlockReportListener = blockReportListener;
     mCachedNumberLookupService = PhoneNumberCache.get(mContext).getCachedNumberLookupService();
 
+    // Cache this to avoid having to look it up each time we bind to a call log entry
+    mDefaultPhoneAccountHandle =
+        TelecomUtil.getDefaultOutgoingPhoneAccount(context, PhoneAccount.SCHEME_TEL);
+
     this.rootView = rootView;
     this.quickContactView = dialerQuickContactView;
     this.primaryActionView = primaryActionView;
@@ -336,11 +345,13 @@
   }
 
   public static CallLogListItemViewHolder createForTest(Context context) {
-    return createForTest(context, null);
+    return createForTest(context, null, null);
   }
 
-  static CallLogListItemViewHolder createForTest(
-      Context context, VoicemailPlaybackPresenter voicemailPlaybackPresenter) {
+  public static CallLogListItemViewHolder createForTest(
+      Context context,
+      View.OnClickListener expandCollapseListener,
+      VoicemailPlaybackPresenter voicemailPlaybackPresenter) {
     Resources resources = context.getResources();
     CallLogCache callLogCache = CallLogCache.getCallLogCache(context);
     PhoneCallDetailsHelper phoneCallDetailsHelper =
@@ -350,7 +361,7 @@
         new CallLogListItemViewHolder(
             context,
             null,
-            null /* expandCollapseListener */,
+            expandCollapseListener /* expandCollapseListener */,
             null,
             null,
             callLogCache,
@@ -503,6 +514,7 @@
         boolean isVoicemailNumber = mCallLogCache.isVoicemailNumber(accountHandle, number);
 
         if (!isVoicemailNumber && showLightbringerPrimaryButton()) {
+          CallIntentBuilder.increaseLightbringerCallButtonAppearInCollapsedCallLogItemCount();
           primaryActionButtonView.setTag(IntentProvider.getLightbringerIntentProvider(number));
           primaryActionButtonView.setContentDescription(
               TextUtils.expandTemplate(
@@ -594,7 +606,8 @@
       callButtonView.setVisibility(View.VISIBLE);
     }
 
-    if (hasPlacedCarrierVideoCall() || canSupportCarrierVideoCall()) {
+    if (CallUtil.isVideoEnabled(mContext)
+        && (hasPlacedCarrierVideoCall() || canSupportCarrierVideoCall())) {
       videoCallButtonView.setTag(IntentProvider.getReturnVideoCallIntentProvider(number));
       videoCallButtonView.setVisibility(View.VISIBLE);
     } else if (showLightbringerPrimaryButton()) {
@@ -709,10 +722,10 @@
     if (accountHandle == null) {
       return false;
     }
-    if (accountHandle.getComponentName().equals(getLightbringer().getPhoneAccountComponentName())) {
+    if (mDefaultPhoneAccountHandle == null) {
       return false;
     }
-    return true;
+    return accountHandle.getComponentName().equals(mDefaultPhoneAccountHandle.getComponentName());
   }
 
   private boolean canSupportCarrierVideoCall() {
@@ -878,12 +891,20 @@
       // intents need to be started using startActivityForResult instead of the usual startActivity
       String packageName = intent.getPackage();
       if (packageName != null && packageName.equals(getLightbringer().getPackageName())) {
+        Logger.get(mContext)
+            .logImpression(DialerImpression.Type.LIGHTBRINGER_VIDEO_REQUESTED_FROM_CALL_LOG);
         startLightbringerActivity(intent);
       } else if (CallDetailsActivity.isLaunchIntent(intent)) {
         PerformanceReport.recordClick(UiAction.Type.OPEN_CALL_DETAIL);
         ((Activity) mContext)
             .startActivityForResult(intent, DialtactsActivity.ACTIVITY_REQUEST_CODE_CALL_DETAILS);
       } else {
+        if (Intent.ACTION_CALL.equals(intent.getAction())
+            && intent.getIntExtra(TelecomManager.EXTRA_START_CALL_WITH_VIDEO_STATE, -1)
+                == VideoProfile.STATE_BIDIRECTIONAL) {
+          Logger.get(mContext)
+              .logImpression(DialerImpression.Type.IMS_VIDEO_REQUESTED_FROM_CALL_LOG);
+        }
         DialerUtils.startActivityWithErrorToast(mContext, intent);
       }
     }
diff --git a/java/com/android/dialer/app/calllog/IntentProvider.java b/java/com/android/dialer/app/calllog/IntentProvider.java
index e1ec9f5..55fdbba 100644
--- a/java/com/android/dialer/app/calllog/IntentProvider.java
+++ b/java/com/android/dialer/app/calllog/IntentProvider.java
@@ -30,8 +30,6 @@
 import com.android.dialer.callintent.CallIntentBuilder;
 import com.android.dialer.dialercontact.DialerContact;
 import com.android.dialer.lightbringer.LightbringerComponent;
-import com.android.dialer.logging.DialerImpression;
-import com.android.dialer.logging.Logger;
 import com.android.dialer.util.CallUtil;
 import com.android.dialer.util.IntentUtil;
 import java.util.ArrayList;
@@ -70,7 +68,6 @@
     return new IntentProvider() {
       @Override
       public Intent getIntent(Context context) {
-        Logger.get(context).logImpression(DialerImpression.Type.IMS_VIDEO_REQUESTED_FROM_CALL_LOG);
         return new CallIntentBuilder(number, CallInitiationType.Type.CALL_LOG)
             .setPhoneAccountHandle(accountHandle)
             .setIsVideoCall(true)
@@ -83,8 +80,6 @@
     return new IntentProvider() {
       @Override
       public Intent getIntent(Context context) {
-        Logger.get(context)
-            .logImpression(DialerImpression.Type.LIGHTBRINGER_VIDEO_REQUESTED_FROM_CALL_LOG);
         return LightbringerComponent.get(context).getLightbringer().getIntent(context, number);
       }
     };
diff --git a/java/com/android/dialer/app/calllog/calllogcache/CallLogCache.java b/java/com/android/dialer/app/calllog/calllogcache/CallLogCache.java
index 6728dfb..2e7c933 100644
--- a/java/com/android/dialer/app/calllog/calllogcache/CallLogCache.java
+++ b/java/com/android/dialer/app/calllog/calllogcache/CallLogCache.java
@@ -17,6 +17,7 @@
 package com.android.dialer.app.calllog.calllogcache;
 
 import android.content.Context;
+import android.support.annotation.Nullable;
 import android.telecom.PhoneAccountHandle;
 import com.android.dialer.app.calllog.CallLogAdapter;
 import com.android.dialer.util.CallUtil;
@@ -57,20 +58,8 @@
    * Returns true if the given number is the number of the configured voicemail. To be able to
    * mock-out this, it is not a static method.
    */
-  public abstract boolean isVoicemailNumber(PhoneAccountHandle accountHandle, CharSequence number);
-
-  /**
-   * Returns {@code true} when the current sim supports video calls, regardless of the value in a
-   * contact's {@link android.provider.ContactsContract.CommonDataKinds.Phone#CARRIER_PRESENCE}
-   * column.
-   */
-  public boolean isVideoEnabled() {
-    if (!mHasCheckedForVideoAvailability) {
-      mVideoAvailability = CallUtil.getVideoCallingAvailability(mContext);
-      mHasCheckedForVideoAvailability = true;
-    }
-    return (mVideoAvailability & CallUtil.VIDEO_CALLING_ENABLED) != 0;
-  }
+  public abstract boolean isVoicemailNumber(
+      PhoneAccountHandle accountHandle, @Nullable CharSequence number);
 
   /**
    * Returns {@code true} when the current sim supports checking video calling capabilities via the
diff --git a/java/com/android/dialer/app/calllog/calllogcache/CallLogCacheLollipopMr1.java b/java/com/android/dialer/app/calllog/calllogcache/CallLogCacheLollipopMr1.java
index f856806..2424b6d 100644
--- a/java/com/android/dialer/app/calllog/calllogcache/CallLogCacheLollipopMr1.java
+++ b/java/com/android/dialer/app/calllog/calllogcache/CallLogCacheLollipopMr1.java
@@ -17,7 +17,9 @@
 package com.android.dialer.app.calllog.calllogcache;
 
 import android.content.Context;
+import android.support.annotation.Nullable;
 import android.telecom.PhoneAccountHandle;
+import android.text.TextUtils;
 import android.util.ArrayMap;
 import com.android.dialer.calllogutils.PhoneAccountUtils;
 import com.android.dialer.telecom.TelecomUtil;
@@ -50,7 +52,11 @@
   }
 
   @Override
-  public boolean isVoicemailNumber(PhoneAccountHandle accountHandle, CharSequence number) {
+  public boolean isVoicemailNumber(
+      PhoneAccountHandle accountHandle, @Nullable CharSequence number) {
+    if (TextUtils.isEmpty(number)) {
+      return false;
+    }
     return TelecomUtil.isVoicemailNumber(mContext, accountHandle, number.toString());
   }
 
diff --git a/java/com/android/dialer/app/res/values-sq/strings.xml b/java/com/android/dialer/app/res/values-sq/strings.xml
index ca3d522..8f43ba7 100644
--- a/java/com/android/dialer/app/res/values-sq/strings.xml
+++ b/java/com/android/dialer/app/res/values-sq/strings.xml
@@ -236,6 +236,6 @@
     <string name="call_composer_connection_failed" msgid="6776461585447831242">"<xliff:g id="NAME">%1$s</xliff:g> është jashtë linje dhe nuk mund të kontaktohet"</string>
     <string name="about_phone_label" msgid="582991354677973731">"Rreth"</string>
     <string name="view_conversation" msgid="7895904782094119702">"Shiko"</string>
-    <string name="ec_data_deleted" msgid="4794880345545827107">"Telefonata u fshi. Shiko dhe fshi bashkëngjitjet e ndara gjatë kësaj telefonate te \"Mesazhet\"."</string>
-    <string name="multiple_ec_data_deleted" msgid="2971579891973176316">"Telefonatat u fshinë. Shiko dhe fshi bashkëngjitjet e ndara gjatë telefonatave te \"Mesazhet\"."</string>
+    <string name="ec_data_deleted" msgid="4794880345545827107">"Telefonata u fshi. Shiko dhe fshi bashkëngjitjet e ndara gjatë kësaj telefonate te Messages."</string>
+    <string name="multiple_ec_data_deleted" msgid="2971579891973176316">"Telefonatat u fshinë. Shiko dhe fshi bashkëngjitjet e ndara gjatë telefonatave te Messages."</string>
 </resources>
diff --git a/java/com/android/dialer/app/res/values-ur/strings.xml b/java/com/android/dialer/app/res/values-ur/strings.xml
index 2b6a3eb..f713f4c 100644
--- a/java/com/android/dialer/app/res/values-ur/strings.xml
+++ b/java/com/android/dialer/app/res/values-ur/strings.xml
@@ -236,6 +236,6 @@
     <string name="call_composer_connection_failed" msgid="6776461585447831242">"<xliff:g id="NAME">%1$s</xliff:g> آف لائن ہے اور اس تک پہنچا نہیں جا سکتا"</string>
     <string name="about_phone_label" msgid="582991354677973731">"تفصیل"</string>
     <string name="view_conversation" msgid="7895904782094119702">"دیکھیں"</string>
-    <string name="ec_data_deleted" msgid="4794880345545827107">"کال حذف ہو گئی۔ اس کال کے دوران پیغامات کے اندر اشتراک کردہ منسلکہ جات ملاحظہ کریں اور حذف کریں۔"</string>
-    <string name="multiple_ec_data_deleted" msgid="2971579891973176316">"کالیں حذف ہو گئیں۔ کالوں کے دوران پیغامات کے اندر اشتراک کردہ منسلکہ جات ملاحظہ کریں اور حذف کریں۔"</string>
+    <string name="ec_data_deleted" msgid="4794880345545827107">"کال حذف ہو گئی۔ اس کال کے دوران اشتراک کردہ منسلکہ جات کو \'پیغامات \' میں ملاحظہ کریں اور حذف کریں۔"</string>
+    <string name="multiple_ec_data_deleted" msgid="2971579891973176316">"کالیں حذف ہو گئیں۔ کالوں کے دوران اشتراک کردہ منسلکہ جات کو \'پیغامات \' میں ملاحظہ کریں اور حذف کریں۔"</string>
 </resources>
diff --git a/java/com/android/dialer/app/voicemail/error/VoicemailErrorAlert.java b/java/com/android/dialer/app/voicemail/error/VoicemailErrorAlert.java
index d045b1b..dbdf0f0 100644
--- a/java/com/android/dialer/app/voicemail/error/VoicemailErrorAlert.java
+++ b/java/com/android/dialer/app/voicemail/error/VoicemailErrorAlert.java
@@ -20,6 +20,7 @@
 import android.support.annotation.VisibleForTesting;
 import android.text.util.Linkify;
 import android.view.View;
+import android.widget.ImageView;
 import android.widget.TextView;
 import com.android.dialer.app.alert.AlertManager;
 import com.android.dialer.app.voicemail.error.VoicemailErrorMessage.Action;
@@ -132,6 +133,13 @@
     TextView secondaryButton = (TextView) view.findViewById(R.id.voicemail_tos_button_accept);
     secondaryButton.setText(secondaryAction.getText());
     secondaryButton.setOnClickListener(secondaryAction.getListener());
+
+    if (message.getImageResourceId() != null) {
+      ImageView voicemailTosImage = (ImageView) view.findViewById(R.id.voicemail_image);
+      voicemailTosImage.setImageResource(message.getImageResourceId());
+      voicemailTosImage.setVisibility(View.VISIBLE);
+    }
+
     return view;
   }
 
diff --git a/java/com/android/dialer/app/voicemail/error/VoicemailErrorMessage.java b/java/com/android/dialer/app/voicemail/error/VoicemailErrorMessage.java
index a0dd30f..92c787d 100644
--- a/java/com/android/dialer/app/voicemail/error/VoicemailErrorMessage.java
+++ b/java/com/android/dialer/app/voicemail/error/VoicemailErrorMessage.java
@@ -47,6 +47,7 @@
   private final List<Action> actions;
 
   private boolean modal;
+  private Integer imageResourceId;
 
   /** Something the user can click on to resolve an error, such as retrying or calling voicemail */
   public static class Action {
@@ -100,6 +101,16 @@
     return this;
   }
 
+  @Nullable
+  public Integer getImageResourceId() {
+    return imageResourceId;
+  }
+
+  public VoicemailErrorMessage setImageResourceId(Integer imageResourceId) {
+    this.imageResourceId = imageResourceId;
+    return this;
+  }
+
   public VoicemailErrorMessage(CharSequence title, CharSequence description, Action... actions) {
     this(title, description, Arrays.asList(actions));
   }
diff --git a/java/com/android/dialer/app/voicemail/error/VoicemailTosMessageCreator.java b/java/com/android/dialer/app/voicemail/error/VoicemailTosMessageCreator.java
index 3f0ed1f..f2cdaf6 100644
--- a/java/com/android/dialer/app/voicemail/error/VoicemailTosMessageCreator.java
+++ b/java/com/android/dialer/app/voicemail/error/VoicemailTosMessageCreator.java
@@ -22,10 +22,13 @@
 import android.content.DialogInterface;
 import android.content.Intent;
 import android.content.SharedPreferences;
+import android.graphics.Typeface;
 import android.preference.PreferenceManager;
 import android.support.annotation.Nullable;
 import android.telecom.PhoneAccountHandle;
 import android.telephony.TelephonyManager;
+import android.text.SpannableString;
+import android.text.style.StyleSpan;
 import android.view.View;
 import android.view.View.OnClickListener;
 import com.android.contacts.common.compat.TelephonyManagerCompat;
@@ -114,7 +117,8 @@
                   }
                 },
                 true /* raised */))
-        .setModal(true);
+        .setModal(true)
+        .setImageResourceId(getTosImageId());
   }
 
   private void showDeclineTosDialog(final PhoneAccountHandle handle) {
@@ -274,17 +278,32 @@
     }
   }
 
-  private String getTosTitle() {
+  private CharSequence getTosTitle() {
     return isVvm3()
         ? context.getString(R.string.verizon_terms_and_conditions_title)
         : context.getString(R.string.dialer_terms_and_conditions_title);
   }
 
-  private String getTosMessage() {
-    return isVvm3()
-        ? context.getString(
-            R.string.verizon_terms_and_conditions_message, getDialerTos(), getVvm3Tos())
-        : context.getString(R.string.dialer_terms_and_conditions_message, getDialerTos());
+  private CharSequence getTosMessage() {
+    if (isVvm3()) {
+      // For verizon the TOS consist of three pieces: google dialer TOS, Verizon TOS message and
+      // Verizon TOS details.
+      CharSequence vvm3Details = getVvm3Tos();
+      CharSequence tos =
+          context.getString(
+              R.string.verizon_terms_and_conditions_message, getDialerTos(), vvm3Details);
+      // Make all text bold except the details.
+      SpannableString spannableTos = new SpannableString(tos);
+      spannableTos.setSpan(new StyleSpan(Typeface.BOLD), 0, tos.length() - vvm3Details.length(), 0);
+      return spannableTos;
+    } else {
+      // The TOS for everyone else there are no details, so just make everything bold.
+      CharSequence tos =
+          context.getString(R.string.dialer_terms_and_conditions_message, getDialerTos());
+      SpannableString spannableTos = new SpannableString(tos);
+      spannableTos.setSpan(new StyleSpan(Typeface.BOLD), 0, tos.length(), 0);
+      return spannableTos;
+    }
   }
 
   private int getTosDeclinedDialogMessageId() {
@@ -298,4 +317,8 @@
         ? R.string.verizon_terms_and_conditions_decline_dialog_downgrade
         : R.string.dialer_terms_and_conditions_decline_dialog_downgrade;
   }
+
+  private Integer getTosImageId() {
+    return isVvm3() ? null : R.drawable.voicemail_tos_image;
+  }
 }
diff --git a/java/com/android/dialer/app/voicemail/error/res/drawable/shadow.xml b/java/com/android/dialer/app/voicemail/error/res/drawable/shadow.xml
new file mode 100644
index 0000000..681c795
--- /dev/null
+++ b/java/com/android/dialer/app/voicemail/error/res/drawable/shadow.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2017 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.
+-->
+
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+       android:shape="rectangle">
+  <solid android:color="#42000000" />
+</shape>
diff --git a/java/com/android/dialer/app/voicemail/error/res/drawable/voicemail_tos_image.png b/java/com/android/dialer/app/voicemail/error/res/drawable/voicemail_tos_image.png
new file mode 100644
index 0000000..2e076c6
--- /dev/null
+++ b/java/com/android/dialer/app/voicemail/error/res/drawable/voicemail_tos_image.png
Binary files differ
diff --git a/java/com/android/dialer/app/voicemail/error/res/layout/voicemail_tos_fragment.xml b/java/com/android/dialer/app/voicemail/error/res/layout/voicemail_tos_fragment.xml
index a082e8e..ec8abed 100644
--- a/java/com/android/dialer/app/voicemail/error/res/layout/voicemail_tos_fragment.xml
+++ b/java/com/android/dialer/app/voicemail/error/res/layout/voicemail_tos_fragment.xml
@@ -23,13 +23,21 @@
     android:layout_width="match_parent"
     android:layout_height="0dp"
     android:layout_weight="1"
-    android:paddingStart="16dp"
-    android:paddingEnd="16dp"
     android:orientation="vertical">
     <LinearLayout
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
+      android:paddingLeft="16dp"
+      android:paddingRight="16dp"
       android:orientation="vertical">
+      <ImageView
+        android:id="@+id/voicemail_image"
+        android:layout_width="@dimen/voicemail_tos_image_size"
+        android:layout_height="@dimen/voicemail_tos_image_size"
+        android:layout_gravity="center"
+        android:paddingTop="24dp"
+        android:visibility="gone"
+        android:importantForAccessibility="no"/>
       <TextView
         android:id="@+id/tos_message_title"
         android:textStyle="bold"
@@ -53,8 +61,9 @@
 
   <View
     android:layout_width="match_parent"
-    android:layout_height="1dp"
-    android:background="#D2D2D2"/>
+    android:layout_height="0.5dp"
+    android:elevation="1dp"
+    android:background="@drawable/shadow"/>
 
   <LinearLayout
     android:id="@+id/voicemail_tos_button"
@@ -62,10 +71,12 @@
     android:layout_height="wrap_content"
     android:paddingStart="16dp"
     android:paddingEnd="16dp"
+    android:paddingTop="20dp"
+    android:paddingBottom="20dp"
     android:orientation="horizontal">
     <TextView
       android:id="@+id/voicemail_tos_button_decline"
-      style="@style/ErrorActionStyle"
+      style="@style/ErrorActionDeclineStyle"
       android:background="?android:attr/selectableItemBackground"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
@@ -76,7 +87,7 @@
       android:layout_weight="1"/>
     <TextView
       android:id="@+id/voicemail_tos_button_accept"
-      style="@style/RaisedErrorActionStyle"
+      style="@style/ErrorActionStyle"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="@string/verizon_terms_and_conditions_accept_english"/>
diff --git a/java/com/android/dialer/app/voicemail/error/res/values/dimens.xml b/java/com/android/dialer/app/voicemail/error/res/values/dimens.xml
index 090311f..dd815ca 100644
--- a/java/com/android/dialer/app/voicemail/error/res/values/dimens.xml
+++ b/java/com/android/dialer/app/voicemail/error/res/values/dimens.xml
@@ -1,4 +1,20 @@
 <?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 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
+  -->
+
 <resources>
   <dimen name="alert_icon_size">24dp</dimen>
   <dimen name="alert_start_padding">16dp</dimen>
@@ -22,4 +38,6 @@
   <dimen name="voicemail_promo_card_line_spacing">4dp</dimen>
   <dimen name="voicemail_promo_card_title_text_size">16sp</dimen>
   <dimen name="voicemail_promo_card_message_size">14sp</dimen>
-</resources>
\ No newline at end of file
+
+  <dimen name="voicemail_tos_image_size">200dp</dimen>
+</resources>
diff --git a/java/com/android/dialer/app/voicemail/error/res/values/strings.xml b/java/com/android/dialer/app/voicemail/error/res/values/strings.xml
index ad5240b..80349e1 100644
--- a/java/com/android/dialer/app/voicemail/error/res/values/strings.xml
+++ b/java/com/android/dialer/app/voicemail/error/res/values/strings.xml
@@ -174,16 +174,16 @@
   </string>
 
   <string translatable="false" name="dialer_terms_and_conditions_1.0_english">
-  See and listen to your messages, without having to call voicemail.\n\nGet transcripts of your voicemail using Google’s transcription service.
+  See and listen to your messages, without having to call voicemail.\nGet transcripts of your voicemail using Google’s transcription service.
   </string>
 
   <string translatable="false" name="dialer_terms_and_conditions_1.0_spanish">
-  ***TRANSLATE TO SPANISH***\nSee and listen to your messages, without having to call voicemail.\n\nGet transcripts of your voicemail using Google’s transcription service.
+  ***TRANSLATE TO SPANISH***\nSee and listen to your messages, without having to call voicemail.\nGet transcripts of your voicemail using Google’s transcription service.
   </string>
 
-  <string translatable="false" name="verizon_terms_and_conditions_accept_english">Accept</string>
+  <string translatable="false" name="verizon_terms_and_conditions_accept_english">Turn On</string>
   <string translatable="false" name="verizon_terms_and_conditions_accept_spanish">Aceptar</string>
-  <string translatable="false" name="verizon_terms_and_conditions_decline_english">Decline</string>
+  <string translatable="false" name="verizon_terms_and_conditions_decline_english">No Thanks</string>
   <string translatable="false" name="verizon_terms_and_conditions_decline_spanish">Rechazar</string>
 
   <string translatable="false" name="dialer_terms_and_conditions_accept_english">Turn On</string>
diff --git a/java/com/android/dialer/app/voicemail/error/res/values/styles.xml b/java/com/android/dialer/app/voicemail/error/res/values/styles.xml
index c4a8542..257e93d 100644
--- a/java/com/android/dialer/app/voicemail/error/res/values/styles.xml
+++ b/java/com/android/dialer/app/voicemail/error/res/values/styles.xml
@@ -1,6 +1,21 @@
 <?xml version="1.0" encoding="utf-8"?>
-<resources>
+<!--
+  ~ Copyright (C) 2017 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
+  -->
 
+<resources>
   <style name="ErrorActionStyle">
     <item name="android:layout_width">wrap_content</item>
     <item name="android:layout_height">48dp</item>
@@ -9,7 +24,23 @@
     <item name="android:paddingEnd">8dp</item>
     <item name="android:layout_marginStart">8dp</item>
     <item name="android:layout_marginEnd">8dp</item>
-    <item name="android:textColor">@color/dialtacts_theme_color</item>
+    <item name="android:textColor">@color/dialer_theme_color</item>
+    <item name="android:fontFamily">"sans-serif-medium"</item>
+    <item name="android:focusable">true</item>
+    <item name="android:singleLine">true</item>
+    <item name="android:textAllCaps">true</item>
+    <item name="android:textSize">14sp</item>
+  </style>
+
+  <style name="ErrorActionDeclineStyle">
+    <item name="android:layout_width">wrap_content</item>
+    <item name="android:layout_height">48dp</item>
+    <item name="android:gravity">end|center_vertical</item>
+    <item name="android:paddingStart">8dp</item>
+    <item name="android:paddingEnd">8dp</item>
+    <item name="android:layout_marginStart">8dp</item>
+    <item name="android:layout_marginEnd">8dp</item>
+    <item name="android:textColor">@color/dialer_secondary_text_color</item>
     <item name="android:fontFamily">"sans-serif-medium"</item>
     <item name="android:focusable">true</item>
     <item name="android:singleLine">true</item>
@@ -23,4 +54,4 @@
     <item name="android:textSize">14sp</item>
     <item name="android:layout_height">@dimen/call_log_action_height</item>
   </style>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/java/com/android/dialer/blocking/res/values-hu/strings.xml b/java/com/android/dialer/blocking/res/values-hu/strings.xml
index 1070454..7981d6c 100644
--- a/java/com/android/dialer/blocking/res/values-hu/strings.xml
+++ b/java/com/android/dialer/blocking/res/values-hu/strings.xml
@@ -33,7 +33,7 @@
     <string name="block_number_undo" msgid="5158120911892491697">"VISSZAVONÁS"</string>
     <string name="send_to_voicemail_import_failed" msgid="1012752662074208237">"Az importálás nem sikerült"</string>
     <string name="call_blocking_disabled_notification_title" msgid="7211352205255347489">"A hívások tiltása funkció kikapcsolva 48 órára"</string>
-    <string name="call_blocking_disabled_notification_text" msgid="141384084865180722">"Letiltva vészhívás miatt."</string>
+    <string name="call_blocking_disabled_notification_text" msgid="141384084865180722">"Letiltva segélyhívás miatt."</string>
     <string name="block_report_number_alert_title" msgid="2740581989824959611">"Letiltja a következő számot: <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
     <string name="block_report_number_alert_details" msgid="2652479394593143562">"A jövőben nem fogad hívásokat erről a számról."</string>
     <string name="block_number_alert_details" msgid="715942751312046429">"<xliff:g id="TEXT">%1$s</xliff:g> A hívást spamként jelentjük be."</string>
diff --git a/java/com/android/dialer/callcomposer/CallComposerActivity.java b/java/com/android/dialer/callcomposer/CallComposerActivity.java
index 314752f..df5cc29 100644
--- a/java/com/android/dialer/callcomposer/CallComposerActivity.java
+++ b/java/com/android/dialer/callcomposer/CallComposerActivity.java
@@ -64,8 +64,8 @@
 import com.android.dialer.dialercontact.DialerContact;
 import com.android.dialer.enrichedcall.EnrichedCallComponent;
 import com.android.dialer.enrichedcall.EnrichedCallManager;
-import com.android.dialer.enrichedcall.EnrichedCallManager.State;
 import com.android.dialer.enrichedcall.Session;
+import com.android.dialer.enrichedcall.Session.State;
 import com.android.dialer.enrichedcall.extensions.StateExtension;
 import com.android.dialer.logging.DialerImpression;
 import com.android.dialer.logging.Logger;
@@ -255,25 +255,25 @@
         StateExtension.toString(state));
 
     switch (state) {
-      case EnrichedCallManager.STATE_STARTING:
+      case Session.STATE_STARTING:
         timeoutHandler.postDelayed(sessionStartedTimedOut, getSessionStartedTimeoutMillis());
         if (sendAndCallReady) {
           showLoadingUi();
         }
         break;
-      case EnrichedCallManager.STATE_STARTED:
+      case Session.STATE_STARTED:
         timeoutHandler.removeCallbacks(sessionStartedTimedOut);
         if (sendAndCallReady) {
           sendAndCall();
         }
         break;
-      case EnrichedCallManager.STATE_START_FAILED:
-      case EnrichedCallManager.STATE_CLOSED:
+      case Session.STATE_START_FAILED:
+      case Session.STATE_CLOSED:
         setFailedResultAndFinish();
         break;
-      case EnrichedCallManager.STATE_MESSAGE_FAILED:
-      case EnrichedCallManager.STATE_MESSAGE_SENT:
-      case EnrichedCallManager.STATE_NONE:
+      case Session.STATE_MESSAGE_FAILED:
+      case Session.STATE_MESSAGE_SENT:
+      case Session.STATE_NONE:
       default:
         break;
     }
@@ -385,7 +385,7 @@
 
   private boolean sessionReady() {
     Session session = getEnrichedCallManager().getSession(sessionId);
-    return session != null && session.getState() == EnrichedCallManager.STATE_STARTED;
+    return session != null && session.getState() == Session.STATE_STARTED;
   }
 
   private void placeRCSCall(MultimediaData.Builder builder) {
diff --git a/java/com/android/dialer/callcomposer/res/layout/call_composer_activity.xml b/java/com/android/dialer/callcomposer/res/layout/call_composer_activity.xml
index 588cc1d..48d6368 100644
--- a/java/com/android/dialer/callcomposer/res/layout/call_composer_activity.xml
+++ b/java/com/android/dialer/callcomposer/res/layout/call_composer_activity.xml
@@ -43,6 +43,8 @@
         android:layout_marginTop="@dimen/call_composer_contact_container_margin_top"
         android:paddingTop="@dimen/call_composer_contact_container_padding_top"
         android:paddingBottom="@dimen/call_composer_contact_container_padding_bottom"
+        android:paddingStart="16dp"
+        android:paddingEnd="16dp"
         android:background="@color/dialer_theme_color">
 
         <TextView
@@ -50,6 +52,8 @@
           android:layout_width="match_parent"
           android:layout_height="wrap_content"
           android:gravity="center"
+          android:maxLines="1"
+          android:ellipsize="end"
           android:textColor="@color/background_dialer_white"
           android:textSize="@dimen/call_composer_name_text_size"/>
 
@@ -58,6 +62,8 @@
           android:layout_width="match_parent"
           android:layout_height="wrap_content"
           android:gravity="center"
+          android:maxLines="1"
+          android:ellipsize="end"
           android:textColor="@color/background_dialer_white"
           android:textSize="@dimen/call_composer_number_text_size"/>
       </LinearLayout>
diff --git a/java/com/android/dialer/callcomposer/res/values-af/strings.xml b/java/com/android/dialer/callcomposer/res/values-af/strings.xml
index ef35865..62a7457 100644
--- a/java/com/android/dialer/callcomposer/res/values-af/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-af/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Neem \'n foto"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Kies \'n foto"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Stuur \'n boodskap"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Foto is via Boodskappe gestuur"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Boodskap is via Boodskappe gestuur"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-am/strings.xml b/java/com/android/dialer/callcomposer/res/values-am/strings.xml
index 8224b1e..fe1c1e5 100644
--- a/java/com/android/dialer/callcomposer/res/values-am/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-am/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"ፎቶ ያንሱ"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"ፎቶ ይምረጡ"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"መልዕክት ይላኩ"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"ፎቶ በመልዕክቶች በኩል ተልኳል"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"መልዕክት በመልዕክቶች በኩል ተልኳል"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-ar/strings.xml b/java/com/android/dialer/callcomposer/res/values-ar/strings.xml
index 4e27f21..b70f3ff 100644
--- a/java/com/android/dialer/callcomposer/res/values-ar/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-ar/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"التقاط صورة"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"اختيار صورة"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"إرسال رسالة"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"‏صورة مرسلة عبر Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"‏رسالة مرسلة عبر Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-az/strings.xml b/java/com/android/dialer/callcomposer/res/values-az/strings.xml
index d861e66..7495555 100644
--- a/java/com/android/dialer/callcomposer/res/values-az/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-az/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Şəkil çəkin"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Foto seçin"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Mesaj göndərin"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Foto Mesajlaşma tətbiqi vasitəsilə göndərildi"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Mesaj Mesajlaşma tətbiqi vasitəsilə göndərildi"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-b+sr+Latn/strings.xml b/java/com/android/dialer/callcomposer/res/values-b+sr+Latn/strings.xml
index 0a93b22..88b8011 100644
--- a/java/com/android/dialer/callcomposer/res/values-b+sr+Latn/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-b+sr+Latn/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Slikajte"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Izaberite sliku"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Pošaljite poruku"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Slika je poslata preko Messages-a"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Poruka je poslata preko Messages-a"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-be/strings.xml b/java/com/android/dialer/callcomposer/res/values-be/strings.xml
index ba55fc7..a741ccd 100644
--- a/java/com/android/dialer/callcomposer/res/values-be/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-be/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Зрабіць фота"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Выбраць фота"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Адправіць паведамленне"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Фота адпраўлена праз праграму \"Паведамленні\""</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Паведамленне адпраўлена праз праграму \"Паведамленні\""</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-bg/strings.xml b/java/com/android/dialer/callcomposer/res/values-bg/strings.xml
index 7dad394..4348bc6 100644
--- a/java/com/android/dialer/callcomposer/res/values-bg/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-bg/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Правене на снимка"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Избиране на снимка"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Изпращане на съобщение"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Снимката е изпратена чрез Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Съобщението е изпратено чрез Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-bn/strings.xml b/java/com/android/dialer/callcomposer/res/values-bn/strings.xml
index 607f195..f2f3f11 100644
--- a/java/com/android/dialer/callcomposer/res/values-bn/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-bn/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"একটি ছবি তুলুন"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"একটি ফটো বেছে নিন"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"একটি বার্তা পাঠান"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Messages এর সাহায্যে ফটো পাঠানো হয়েছে"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Messages-এর সাহায্যে বার্তা পাঠানো হয়েছে"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-bs/strings.xml b/java/com/android/dialer/callcomposer/res/values-bs/strings.xml
index 99ca5db..a5ecb0c 100644
--- a/java/com/android/dialer/callcomposer/res/values-bs/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-bs/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Uslikaj"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Izaberi fotografiju"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Pošalji poruku"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Fotografija je poslana putem aplikacije Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Poruka je poslana putem aplikacije Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-ca/strings.xml b/java/com/android/dialer/callcomposer/res/values-ca/strings.xml
index 7b55346..1f3007d 100644
--- a/java/com/android/dialer/callcomposer/res/values-ca/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-ca/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Fes una foto"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Tria una foto"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Envia un missatge"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Foto enviada mitjançant Missatges"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Missatge enviat mitjançant Missatges"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-cs/strings.xml b/java/com/android/dialer/callcomposer/res/values-cs/strings.xml
index f30bb3c..590ab1c 100644
--- a/java/com/android/dialer/callcomposer/res/values-cs/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-cs/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Vyfotit"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Vybrat fotku"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Poslat zprávu"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Fotka poslaná v aplikaci Zprávy"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Zpráva poslaná v aplikaci Zprávy"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-da/strings.xml b/java/com/android/dialer/callcomposer/res/values-da/strings.xml
index bae4495..179e0d0 100644
--- a/java/com/android/dialer/callcomposer/res/values-da/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-da/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Tag et billede"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Vælg et billede"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Send en sms"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Fotoet blev sendt via Beskeder"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Beskeden blev sendt via Beskeder"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-de/strings.xml b/java/com/android/dialer/callcomposer/res/values-de/strings.xml
index ac7ce4e..d0c88a9 100644
--- a/java/com/android/dialer/callcomposer/res/values-de/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-de/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Bild aufnehmen"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Foto auswählen"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Nachricht senden"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Foto über Messages gesendet"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Nachricht über Messages gesendet."</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-el/strings.xml b/java/com/android/dialer/callcomposer/res/values-el/strings.xml
index 1e7659b..bfa626b 100644
--- a/java/com/android/dialer/callcomposer/res/values-el/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-el/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Λήψη φωτογραφίας"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Επιλογή φωτογραφίας"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Αποστολή μηνύματος"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Η φωτογραφία στάλθηκε μέσω του Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Το μήνυμα στάλθηκε μέσω του Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-en-rAU/strings.xml b/java/com/android/dialer/callcomposer/res/values-en-rAU/strings.xml
index 2b3f7a3..5e2807b 100644
--- a/java/com/android/dialer/callcomposer/res/values-en-rAU/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-en-rAU/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Take a picture"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Choose a photo"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Sending a message"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Photo sent via Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Message sent via Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-en-rGB/strings.xml b/java/com/android/dialer/callcomposer/res/values-en-rGB/strings.xml
index 2b3f7a3..5e2807b 100644
--- a/java/com/android/dialer/callcomposer/res/values-en-rGB/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-en-rGB/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Take a picture"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Choose a photo"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Sending a message"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Photo sent via Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Message sent via Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-en-rIN/strings.xml b/java/com/android/dialer/callcomposer/res/values-en-rIN/strings.xml
index 2b3f7a3..5e2807b 100644
--- a/java/com/android/dialer/callcomposer/res/values-en-rIN/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-en-rIN/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Take a picture"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Choose a photo"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Sending a message"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Photo sent via Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Message sent via Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-es-rUS/strings.xml b/java/com/android/dialer/callcomposer/res/values-es-rUS/strings.xml
index 67bac97..f1d4705 100644
--- a/java/com/android/dialer/callcomposer/res/values-es-rUS/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-es-rUS/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Tomar una foto"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Elegir una foto"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Enviar un mensaje"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Foto enviada por Mensajes"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Mensaje de texto enviado por Mensajes"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-es/strings.xml b/java/com/android/dialer/callcomposer/res/values-es/strings.xml
index 4b87268..cba427b 100644
--- a/java/com/android/dialer/callcomposer/res/values-es/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-es/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Hacer una foto"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Elegir una foto"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Enviar un mensaje"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Foto enviada a través de Mensajes"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Mensaje enviado a través de Mensajes"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-et/strings.xml b/java/com/android/dialer/callcomposer/res/values-et/strings.xml
index 896525d..d79ca90 100644
--- a/java/com/android/dialer/callcomposer/res/values-et/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-et/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Pildistamine"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Foto valimine"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Sõnumi saatmine"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Foto saadeti rakenduse Messages kaudu"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Sõnum saadeti rakenduse Messages kaudu"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-eu/strings.xml b/java/com/android/dialer/callcomposer/res/values-eu/strings.xml
index ce7e296..32413f9 100644
--- a/java/com/android/dialer/callcomposer/res/values-eu/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-eu/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Atera argazki bat"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Aukeratu argazki bat"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Bidali mezu bat"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Mezuak aplikazioaren bidez bidali da argazkia"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Mezuak aplikazioaren bidez bidali da mezua"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-fa/strings.xml b/java/com/android/dialer/callcomposer/res/values-fa/strings.xml
index 6f0c2e5..a2604a9 100644
--- a/java/com/android/dialer/callcomposer/res/values-fa/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-fa/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"عکس گرفتن"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"انتخاب عکس"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"ارسال پیام"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"عکس ارسال‌شده ازطریق «پیام‌ها»"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"پیام ارسال‌شده ازطریق «پیام‌ها»"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-fi/strings.xml b/java/com/android/dialer/callcomposer/res/values-fi/strings.xml
index ce0786c..482a36a 100644
--- a/java/com/android/dialer/callcomposer/res/values-fi/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-fi/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Ota kuva"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Valitse kuva"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Lähetä viesti"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Kuva lähetettiin Messages-sovelluksen kautta"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Viesti lähetettiin Messages-sovelluksen kautta"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-fr-rCA/strings.xml b/java/com/android/dialer/callcomposer/res/values-fr-rCA/strings.xml
index 0451dcf..be06baa 100644
--- a/java/com/android/dialer/callcomposer/res/values-fr-rCA/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-fr-rCA/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Prendre une photo"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Choisir une photo"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Envoyer un message"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Photo envoyée au moyen de l\'application Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Message envoyé au moyen de l\'application Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-fr/strings.xml b/java/com/android/dialer/callcomposer/res/values-fr/strings.xml
index 50e6194..f56ad7a 100644
--- a/java/com/android/dialer/callcomposer/res/values-fr/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-fr/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Prendre une photo"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Choisir une photo"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Envoyer un message"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Photo envoyée via l\'application Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Message envoyé via l\'application Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-gl/strings.xml b/java/com/android/dialer/callcomposer/res/values-gl/strings.xml
index 2ad2c9a..f2a0f15 100644
--- a/java/com/android/dialer/callcomposer/res/values-gl/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-gl/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Tira unha foto"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Escolle unha foto"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Envía unha mensaxe"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Foto enviada a través de Mensaxes"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Mensaxe enviada a través de Mensaxes"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-gu/strings.xml b/java/com/android/dialer/callcomposer/res/values-gu/strings.xml
index 8c9a521..771d148 100644
--- a/java/com/android/dialer/callcomposer/res/values-gu/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-gu/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"એક ચિત્ર લો"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"ફોટો પસંદ કરો"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"એક સંદેશ મોકલો"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Messages મારફતે ફોટો મોકલ્યો"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Messages મારફતે સંદેશ મોકલ્યો"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-hi/strings.xml b/java/com/android/dialer/callcomposer/res/values-hi/strings.xml
index 8d4f91e..4de9a6d 100644
--- a/java/com/android/dialer/callcomposer/res/values-hi/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-hi/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"चित्र लें"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"एक फ़ोटो चुनें"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"संदेश भेजें"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"संदेश ऐप्लिकेशन के ज़रिए फ़ोटो भेजा गया"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"संदेश ऐप्लिकेशन के ज़रिए संदेश भेजा गया"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-hr/strings.xml b/java/com/android/dialer/callcomposer/res/values-hr/strings.xml
index cc3219d..4bea73c 100644
--- a/java/com/android/dialer/callcomposer/res/values-hr/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-hr/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Snimi fotografiju"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Odaberi fotografiju"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Pošalji poruku"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Fotografija poslana putem Poruka"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Poruka poslana putem Poruka"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-hu/strings.xml b/java/com/android/dialer/callcomposer/res/values-hu/strings.xml
index b222c53..2a590e0 100644
--- a/java/com/android/dialer/callcomposer/res/values-hu/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-hu/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Kép készítése"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Fotó kiválasztása"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Üzenet küldése"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Fotó elküldve a Messages alkalmazásban"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Üzenet elküldve a Messages alkalmazásban"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-hy/strings.xml b/java/com/android/dialer/callcomposer/res/values-hy/strings.xml
index 01635f6..1b55234 100644
--- a/java/com/android/dialer/callcomposer/res/values-hy/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-hy/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Լուսանկարել"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Ընտրել լուսանկար"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Ուղարկել հաղորդագրություն"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Լուսանկարն ուղարկվել է Messages-ի միջոցով"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Հաղորդագրությունն ուղարկվել է Messages-ի միջոցով"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-in/strings.xml b/java/com/android/dialer/callcomposer/res/values-in/strings.xml
index 4c6d844..7983c4d 100644
--- a/java/com/android/dialer/callcomposer/res/values-in/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-in/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Jepret"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Pilih foto"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Mengirim pesan"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Foto dikirim lewat Message"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Pesan dikirim lewat Message"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-is/strings.xml b/java/com/android/dialer/callcomposer/res/values-is/strings.xml
index d951edd..3bf4a6b 100644
--- a/java/com/android/dialer/callcomposer/res/values-is/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-is/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Taka mynd"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Velja mynd"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Senda skilaboð"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Mynd send með Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Skilaboð send með Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-it/strings.xml b/java/com/android/dialer/callcomposer/res/values-it/strings.xml
index 9d26b2c..343dd84 100644
--- a/java/com/android/dialer/callcomposer/res/values-it/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-it/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Scatta una foto"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Scegli una foto"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Invia un messaggio"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Foto inviata tramite Messaggi"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Messaggio inviato tramite Messaggi"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-iw/strings.xml b/java/com/android/dialer/callcomposer/res/values-iw/strings.xml
index 26e7daf..24c6203 100644
--- a/java/com/android/dialer/callcomposer/res/values-iw/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-iw/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"צילום תמונה"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"בחירת תמונה"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"שליחת הודעה"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"‏התמונה נשלחה דרך אפליקציית Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"‏ההודעה נשלחה דרך אפליקציית Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-ja/strings.xml b/java/com/android/dialer/callcomposer/res/values-ja/strings.xml
index 96eaea5..33f48c9 100644
--- a/java/com/android/dialer/callcomposer/res/values-ja/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-ja/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"画像を撮影します"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"写真を選択します"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"メッセージを送信します"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Android メッセージで写真が送信されました"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Android メッセージでメッセージが送信されました"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-ka/strings.xml b/java/com/android/dialer/callcomposer/res/values-ka/strings.xml
index 0cef94d..65084f3 100644
--- a/java/com/android/dialer/callcomposer/res/values-ka/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-ka/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"სურათის გადაღება"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"ფოტოს არჩევა"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"შეტყობინების გაგზავნა"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"ფოტო გაიგზავნა Messages აპიდან"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"შეტყობინება გაიგზავნა Messages აპიდან"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-kk/strings.xml b/java/com/android/dialer/callcomposer/res/values-kk/strings.xml
index c95fb7b..bf41736 100644
--- a/java/com/android/dialer/callcomposer/res/values-kk/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-kk/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Суретке түсіру"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Суретті таңдау"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Хабар жіберу"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Сурет Messages арқылы жіберілді"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Хабар Messages арқылы жіберілді"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-km/strings.xml b/java/com/android/dialer/callcomposer/res/values-km/strings.xml
index 66f82c5..10c8d52 100644
--- a/java/com/android/dialer/callcomposer/res/values-km/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-km/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"ថតរូប"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"ជ្រើសរើស​រូបថត"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"ផ្ញើសារ"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"រូបថត​ដែល​បាន​ផ្ញើ​តាមរយៈ Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"សារ​ដែល​បាន​ផ្ញើ​តាមរយៈ Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-kn/strings.xml b/java/com/android/dialer/callcomposer/res/values-kn/strings.xml
index 7bb1e48..3776d9d 100644
--- a/java/com/android/dialer/callcomposer/res/values-kn/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-kn/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"ಚಿತ್ರ ತೆಗೆದುಕೊಳ್ಳಿ"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"ಒಂದು ಫೋಟೋ ಆಯ್ಕೆಮಾಡಿ"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"ಸಂದೇಶ ಕಳುಹಿಸಿ"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"ಸಂದೇಶಗಳ ಮೂಲಕ ಕಳುಹಿಸಲಾದ ಫೋಟೋ"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"ಸಂದೇಶಗಳ ಮೂಲಕ ಕಳುಹಿಸಲಾದ ಸಂದೇಶ"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-ko/strings.xml b/java/com/android/dialer/callcomposer/res/values-ko/strings.xml
index 1052d55..0e6820e 100644
--- a/java/com/android/dialer/callcomposer/res/values-ko/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-ko/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"사진 촬영"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"사진 선택"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"메시지 보내기"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"메시지를 통해 전송된 사진"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"메시지를 통해 전송된 메시지"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-ky/strings.xml b/java/com/android/dialer/callcomposer/res/values-ky/strings.xml
index 6e5889d..f96ce4d 100644
--- a/java/com/android/dialer/callcomposer/res/values-ky/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-ky/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Сүрөткө тартуу"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Сүрөттү тандоо"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Билдирүү жөнөтүү"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Сүрөт Android жазышуулары колдонмосу аркылуу жөнөтүлдү"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Билдирүү Android жазышуулары колдонмосу аркылуу жөнөтүлдү"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-lo/strings.xml b/java/com/android/dialer/callcomposer/res/values-lo/strings.xml
index 87d72db..d14f03d 100644
--- a/java/com/android/dialer/callcomposer/res/values-lo/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-lo/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"ຖ່າຍຮູບ"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"ເລືອກຮູບພາບ..."</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"ສົ່ງຂໍ້ຄວາມ"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"ສົ່ງຮູບຜ່ານ Messages ແລ້ວ"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"ສົ່ງຮູບຜ່ານ Messages ແລ້ວ"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-lt/strings.xml b/java/com/android/dialer/callcomposer/res/values-lt/strings.xml
index 07fe444..4453bcd 100644
--- a/java/com/android/dialer/callcomposer/res/values-lt/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-lt/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Fotografuoti"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Pasirinkti nuotrauką"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Siųsti pranešimą"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Nuotrauka išsiųsta naudojant „Messages“"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Pranešimas išsiųstas naudojant „Messages“"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-lv/strings.xml b/java/com/android/dialer/callcomposer/res/values-lv/strings.xml
index 9a3efc7..80e5214 100644
--- a/java/com/android/dialer/callcomposer/res/values-lv/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-lv/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Uzņemt attēlu"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Izvēlēties fotoattēlu"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Sūtīt ziņojumu"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Fotoattēls nosūtīts, izmantojot lietotni Ziņojumi"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Ziņojums nosūtīts, izmantojot lietotni Ziņojumi"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-mk/strings.xml b/java/com/android/dialer/callcomposer/res/values-mk/strings.xml
index 218c23d..bd8f0c8 100644
--- a/java/com/android/dialer/callcomposer/res/values-mk/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-mk/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Фотографирајте"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Изберете фотографија"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Испратете порака"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Фотографијата е испратена преку Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Пораката е испратена преку Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-ml/strings.xml b/java/com/android/dialer/callcomposer/res/values-ml/strings.xml
index 0e58cbb..e4931cb 100644
--- a/java/com/android/dialer/callcomposer/res/values-ml/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-ml/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"ഒരു ചിത്രമെടുക്കുക"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"ഒരു ഫോട്ടോ തിരഞ്ഞെടുക്കുക"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"ഒരു സന്ദേശം അയയ്‌ക്കുക"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"മെസേജ് വഴി ഫോട്ടോ അയച്ചു"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"മെസേജ് വഴി സന്ദേശം അയച്ചു"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-mn/strings.xml b/java/com/android/dialer/callcomposer/res/values-mn/strings.xml
index 8728740..62a7750 100644
--- a/java/com/android/dialer/callcomposer/res/values-mn/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-mn/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Зураг авах"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Зураг сонгоно уу"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Зурвас илгээх"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Зургийг Зурвасаар дамжуулан илгээсэн"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Зурвасыг Зурвасаар дамжуулан илгээсэн"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-mr/strings.xml b/java/com/android/dialer/callcomposer/res/values-mr/strings.xml
index 3ca51a2..e7a7190 100644
--- a/java/com/android/dialer/callcomposer/res/values-mr/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-mr/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"एक फोटो घ्या"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"फोटो निवडा"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"एक संदेश पाठवा"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Messages द्वारे फोटो पाठविला"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Messages द्वारे संदेश पाठविला"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-ms/strings.xml b/java/com/android/dialer/callcomposer/res/values-ms/strings.xml
index e722b88..39ed6fa 100644
--- a/java/com/android/dialer/callcomposer/res/values-ms/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-ms/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Ambil gambar"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Pilih foto"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Hantar mesej"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Photo dihantar melalui Mesej"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Mesej dihantar melalui Mesej"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-my/strings.xml b/java/com/android/dialer/callcomposer/res/values-my/strings.xml
index b49b1ea..a20dabc 100644
--- a/java/com/android/dialer/callcomposer/res/values-my/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-my/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"ဓာတ်ပုံတစ်ပုံ ရိုက်ရန်"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"ဓာတ်ပုံတစ်ပုံ ရွေးရန်"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"မက်ဆေ့ဂျ်ပို့ရန်"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"မက်ဆေ့ဂျ်များမှတစ်ဆင့် ဓာတ်ပုံပို့ပြီးပါပြီ"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"မက်ဆေ့ဂျ်များမှတစ်ဆင့် မက်ဆေ့ဂျ်ပို့ပြီးပါပြီ"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-nb/strings.xml b/java/com/android/dialer/callcomposer/res/values-nb/strings.xml
index 07caf6e..cbb1acc 100644
--- a/java/com/android/dialer/callcomposer/res/values-nb/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-nb/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Ta et bilde"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Velg et bilde"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Send en melding"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Bildet er sendt via Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Meldingen er sendt via Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-ne/strings.xml b/java/com/android/dialer/callcomposer/res/values-ne/strings.xml
index 03eac6c..f084dc9 100644
--- a/java/com/android/dialer/callcomposer/res/values-ne/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-ne/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"तस्बिर खिच्नुहोस्"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"तस्बिर छनौट गर्नुहोस्"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"सन्देश पठाउनुहोस्"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Messages मार्फत पठाइएको तस्बिर"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Messages मार्फत पठाइएको सन्देश"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-nl/strings.xml b/java/com/android/dialer/callcomposer/res/values-nl/strings.xml
index 7a73d93..5511427 100644
--- a/java/com/android/dialer/callcomposer/res/values-nl/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-nl/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Een foto nemen"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Een foto kiezen"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Een bericht verzenden"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Foto verzonden via Berichten"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Bericht verzonden via Berichten"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-no/strings.xml b/java/com/android/dialer/callcomposer/res/values-no/strings.xml
index 07caf6e..cbb1acc 100644
--- a/java/com/android/dialer/callcomposer/res/values-no/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-no/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Ta et bilde"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Velg et bilde"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Send en melding"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Bildet er sendt via Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Meldingen er sendt via Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-pa/strings.xml b/java/com/android/dialer/callcomposer/res/values-pa/strings.xml
index 25de393..5c20adc 100644
--- a/java/com/android/dialer/callcomposer/res/values-pa/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-pa/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"ਇੱਕ ਤਸਵੀਰ ਖਿੱਚੋ"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"ਇੱਕ ਫ਼ੋਟੋ ਚੁਣੋ"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"ਇੱਕ ਸੁਨੇਹਾ ਭੇਜੋ"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"ਫ਼ੋਟੋ &amp;quot;ਸੁਨੇਹੇ&amp;quot; ਐਪ ਰਾਹੀਂ ਭੇਜੀ ਗਈ"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"ਸੁਨੇਹਾ &amp;quot;ਸੁਨੇਹੇ&amp;quot; ਐਪ ਰਾਹੀਂ ਭੇਜਿਆ ਗਿਆ"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-pl/strings.xml b/java/com/android/dialer/callcomposer/res/values-pl/strings.xml
index b65ba23..eea7496 100644
--- a/java/com/android/dialer/callcomposer/res/values-pl/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-pl/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Zrób zdjęcie"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Wybierz zdjęcie"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Wyślij wiadomość"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Zdjęcie zostało wysłane przez Wiadomości"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Tekst został wysłany przez Wiadomości"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-pt-rBR/strings.xml b/java/com/android/dialer/callcomposer/res/values-pt-rBR/strings.xml
index 669e850..026cfac 100644
--- a/java/com/android/dialer/callcomposer/res/values-pt-rBR/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-pt-rBR/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Tirar uma foto"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Escolher uma foto"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Enviar uma mensagem"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Foto enviada pelo Mensagens"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Mensagem enviada pelo Mensagens"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-pt-rPT/strings.xml b/java/com/android/dialer/callcomposer/res/values-pt-rPT/strings.xml
index 45411d3..1a35ce2 100644
--- a/java/com/android/dialer/callcomposer/res/values-pt-rPT/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-pt-rPT/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Tirar uma foto"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Selecionar foto"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Enviar uma mensagem"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Foto enviada através da aplicação Mensagens"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Mensagem enviada através da aplicação Mensagens"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-pt/strings.xml b/java/com/android/dialer/callcomposer/res/values-pt/strings.xml
index 669e850..026cfac 100644
--- a/java/com/android/dialer/callcomposer/res/values-pt/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-pt/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Tirar uma foto"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Escolher uma foto"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Enviar uma mensagem"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Foto enviada pelo Mensagens"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Mensagem enviada pelo Mensagens"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-ro/strings.xml b/java/com/android/dialer/callcomposer/res/values-ro/strings.xml
index cd8359f..ac55b80 100644
--- a/java/com/android/dialer/callcomposer/res/values-ro/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-ro/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Fotografiați"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Alegeți o fotografie"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Trimiteți un mesaj"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Fotografie trimisă prin Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Mesaj trimis prin Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-ru/strings.xml b/java/com/android/dialer/callcomposer/res/values-ru/strings.xml
index 1119a0e..79d8136 100644
--- a/java/com/android/dialer/callcomposer/res/values-ru/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-ru/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Сделать фото"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Выбрать фото"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Отправить сообщение"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Фото отправлено через Android Сообщения"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Сообщение отправлено через Android Сообщения"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-si/strings.xml b/java/com/android/dialer/callcomposer/res/values-si/strings.xml
index dfae242..8c2b953 100644
--- a/java/com/android/dialer/callcomposer/res/values-si/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-si/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"පින්තුරයක් ගැනීම"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"ඡායාරූපයක් තේරීම"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"පණිවිඩයක් යැවීම"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Messages හරහා ඡායාරූපය යවන ලදී"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Messages හරහා පණිවිඩය යවන ලදී"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-sk/strings.xml b/java/com/android/dialer/callcomposer/res/values-sk/strings.xml
index f54c73e..ee062c4 100644
--- a/java/com/android/dialer/callcomposer/res/values-sk/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-sk/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Odfotiť"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Vybrať fotku"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Odoslať správu"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Fotka bola odoslaná prostredníctvom Správ"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Správa bola odoslaná prostredníctvom Správ"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-sl/strings.xml b/java/com/android/dialer/callcomposer/res/values-sl/strings.xml
index 010ad07..9d57cfd 100644
--- a/java/com/android/dialer/callcomposer/res/values-sl/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-sl/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Posnemi fotografijo"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Izberi fotografijo"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Pošlji sporočilo"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Fotografija je bila poslana prek aplikacije Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Sporočilo je bila poslano prek aplikacije Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-sq/strings.xml b/java/com/android/dialer/callcomposer/res/values-sq/strings.xml
index b106d5a..7209942 100644
--- a/java/com/android/dialer/callcomposer/res/values-sq/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-sq/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Bëj një fotografi"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Zgjidh një fotografi"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Dërgo një mesazh"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Fotografia u dërgua nëpërmjet \"Mesazheve\""</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Mesazhi u dërgua nëpërmjet \"Mesazheve\""</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-sr/strings.xml b/java/com/android/dialer/callcomposer/res/values-sr/strings.xml
index 2b85628..1eafcb7 100644
--- a/java/com/android/dialer/callcomposer/res/values-sr/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-sr/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Сликајте"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Изаберите слику"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Пошаљите поруку"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Слика је послата преко Messages-а"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Порука је послата преко Messages-а"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-sv/strings.xml b/java/com/android/dialer/callcomposer/res/values-sv/strings.xml
index e60bbe9..787d865 100644
--- a/java/com/android/dialer/callcomposer/res/values-sv/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-sv/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Ta en bild"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Välj ett foto"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Skicka ett meddelande"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Fotot har skickats via Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Meddelandet har skickats via Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-sw/strings.xml b/java/com/android/dialer/callcomposer/res/values-sw/strings.xml
index f67c899..d33ff31 100644
--- a/java/com/android/dialer/callcomposer/res/values-sw/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-sw/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Piga picha"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Chagua picha"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Tuma ujumbe"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Picha imetumwa kupitia Programu ya Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Ujumbe umetumwa kupitia Programu ya Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-ta/strings.xml b/java/com/android/dialer/callcomposer/res/values-ta/strings.xml
index ae59b3d..37c0193 100644
--- a/java/com/android/dialer/callcomposer/res/values-ta/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-ta/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"படமெடுக்கவும்"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"புகைப்படத்தைத் தேர்வு செய்யும்"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"செய்தியை அனுப்பும்"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"மெசேஜஸ் மூலம் படம் அனுப்பப்பட்டது"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"மெசேஜஸ் மூலம் செய்தி அனுப்பப்பட்டது"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-te/strings.xml b/java/com/android/dialer/callcomposer/res/values-te/strings.xml
index 01d0910..5480370 100644
--- a/java/com/android/dialer/callcomposer/res/values-te/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-te/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"చిత్రాన్ని తీస్తుంది"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"ఫోటోను ఎంచుకోండి"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"సందేశాన్ని పంపుతుంది"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"సందేశాల అనువర్తనం ద్వారా ఫోటోను పంపాము"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"సందేశాల అనువర్తనం ద్వారా సందేశాన్ని పంపాము"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-th/strings.xml b/java/com/android/dialer/callcomposer/res/values-th/strings.xml
index 53dbaea..9d98d56 100644
--- a/java/com/android/dialer/callcomposer/res/values-th/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-th/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"ถ่ายภาพ"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"เลือกรูปภาพ"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"ส่งข้อความ"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"ส่งรูปภาพผ่าน Messages แล้ว"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"ส่งข้อความผ่าน Messages แล้ว"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-tl/strings.xml b/java/com/android/dialer/callcomposer/res/values-tl/strings.xml
index 910d907..5bba942 100644
--- a/java/com/android/dialer/callcomposer/res/values-tl/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-tl/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Kumuha ng larawan"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Pumili ng larawan"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Magpadala ng mensahe"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Larawang ipinadala sa pamamagitan ng Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Mensaheng ipinadala sa pamamagitan ng Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-tr/strings.xml b/java/com/android/dialer/callcomposer/res/values-tr/strings.xml
index 51069ea..cfb8bfb 100644
--- a/java/com/android/dialer/callcomposer/res/values-tr/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-tr/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Resim çeker"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Fotoğraf seçilmesini sağlar"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Mesaj gönderir"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Fotoğraf, Mesajlar uygulaması üzerinden gönderildi"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Mesaj, Mesajlar uygulaması üzerinden gönderildi"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-uk/strings.xml b/java/com/android/dialer/callcomposer/res/values-uk/strings.xml
index 57ee722..4cb1a2d 100644
--- a/java/com/android/dialer/callcomposer/res/values-uk/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-uk/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Зробити знімок"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Вибрати фотографію"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Надіслати повідомлення"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Фотографію надіслано через додаток Повідомлення"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Текст надіслано через додаток Повідомлення"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-ur/strings.xml b/java/com/android/dialer/callcomposer/res/values-ur/strings.xml
index 28d79b8..c665cfb 100644
--- a/java/com/android/dialer/callcomposer/res/values-ur/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-ur/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"تصویر لیں"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"ایک تصویر چنیں"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"پیغام بھیجیں"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"تصویر پیغامات کے ذریعے بھیجی گئی"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"پیغام پیغامات کے ذریعے بھیجا گیا"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-uz/strings.xml b/java/com/android/dialer/callcomposer/res/values-uz/strings.xml
index a3c7346..0237ab9 100644
--- a/java/com/android/dialer/callcomposer/res/values-uz/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-uz/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Rasmga olish"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Rasm tanlash"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Xabar yuborish"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Rasm Android Xabarlar orqali yuborildi"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Xabar Android Xabarlar orqali yuborildi"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-vi/strings.xml b/java/com/android/dialer/callcomposer/res/values-vi/strings.xml
index 7be47a0..d617cfb 100644
--- a/java/com/android/dialer/callcomposer/res/values-vi/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-vi/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Chụp ảnh"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Chọn ảnh"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Gửi tin nhắn"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Đã gửi ảnh qua Messages"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Đã gửi tin nhắn qua Messages"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-zh-rCN/strings.xml b/java/com/android/dialer/callcomposer/res/values-zh-rCN/strings.xml
index 39ace9d..97017d6 100644
--- a/java/com/android/dialer/callcomposer/res/values-zh-rCN/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-zh-rCN/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"拍照"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"选择一张照片"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"发送信息"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"已通过“信息”应用发送照片"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"已通过“信息”应用发送短信"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-zh-rHK/strings.xml b/java/com/android/dialer/callcomposer/res/values-zh-rHK/strings.xml
index 87052ff..b191949 100644
--- a/java/com/android/dialer/callcomposer/res/values-zh-rHK/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-zh-rHK/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"拍照"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"選擇相片"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"傳送訊息"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"已透過「訊息」傳送相片"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"已透過「訊息」傳送訊息"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-zh-rTW/strings.xml b/java/com/android/dialer/callcomposer/res/values-zh-rTW/strings.xml
index 51cc8f6..ef2cd9d 100644
--- a/java/com/android/dialer/callcomposer/res/values-zh-rTW/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-zh-rTW/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"拍攝相片"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"選擇相片"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"傳送訊息"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"透過訊息應用程式傳送的相片"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"透過訊息應用程式傳送的訊息"</string>
 </resources>
diff --git a/java/com/android/dialer/callcomposer/res/values-zu/strings.xml b/java/com/android/dialer/callcomposer/res/values-zu/strings.xml
index 3e2db44..09845f6 100644
--- a/java/com/android/dialer/callcomposer/res/values-zu/strings.xml
+++ b/java/com/android/dialer/callcomposer/res/values-zu/strings.xml
@@ -33,8 +33,6 @@
     <string name="description_call_composer_camera" msgid="388088245837924914">"Thatha isithombe"</string>
     <string name="description_call_composer_photo" msgid="6449208314952246454">"Khetha isithombe"</string>
     <string name="description_call_composer_message" msgid="9132362446000908550">"Thumela umlayezo"</string>
-    <!-- no translation found for image_sent_messages (6520870555040566229) -->
-    <skip />
-    <!-- no translation found for message_sent_messages (6286576951151541098) -->
-    <skip />
+    <string name="image_sent_messages" msgid="6520870555040566229">"Isithombe sithunyelwe ngemilayezo"</string>
+    <string name="message_sent_messages" msgid="6286576951151541098">"Umlayezo uthunyelwe ngemilayezo"</string>
 </resources>
diff --git a/java/com/android/dialer/calldetails/CallDetailsEntryViewHolder.java b/java/com/android/dialer/calldetails/CallDetailsEntryViewHolder.java
index bc989ea..204e407 100644
--- a/java/com/android/dialer/calldetails/CallDetailsEntryViewHolder.java
+++ b/java/com/android/dialer/calldetails/CallDetailsEntryViewHolder.java
@@ -36,7 +36,6 @@
 import com.android.dialer.enrichedcall.historyquery.proto.HistoryResult;
 import com.android.dialer.enrichedcall.historyquery.proto.HistoryResult.Type;
 import com.android.dialer.oem.MotorolaUtils;
-import com.android.dialer.util.CallUtil;
 import com.android.dialer.util.DialerUtils;
 import com.android.dialer.util.IntentUtil;
 
@@ -88,9 +87,7 @@
       CallTypeHelper callTypeHelper,
       boolean showMultimediaDivider) {
     int callType = entry.getCallType();
-    boolean isVideoCall =
-        (entry.getFeatures() & Calls.FEATURES_VIDEO) == Calls.FEATURES_VIDEO
-            && CallUtil.isVideoEnabled(context);
+    boolean isVideoCall = (entry.getFeatures() & Calls.FEATURES_VIDEO) == Calls.FEATURES_VIDEO;
     boolean isPulledCall =
         (entry.getFeatures() & Calls.FEATURES_PULLED_EXTERNALLY)
             == Calls.FEATURES_PULLED_EXTERNALLY;
@@ -98,7 +95,7 @@
     callTime.setTextColor(getColorForCallType(context, callType));
     callTypeIcon.clear();
     callTypeIcon.add(callType);
-    callTypeIcon.setShowVideo((entry.getFeatures() & Calls.FEATURES_VIDEO) == Calls.FEATURES_VIDEO);
+    callTypeIcon.setShowVideo(isVideoCall);
     callTypeIcon.setShowHd(MotorolaUtils.shouldShowHdIconInCallLog(context, entry.getFeatures()));
     callTypeIcon.setShowWifi(
         MotorolaUtils.shouldShowWifiIconInCallLog(context, entry.getFeatures()));
diff --git a/java/com/android/dialer/calldetails/res/values-uz/strings.xml b/java/com/android/dialer/calldetails/res/values-uz/strings.xml
index 4f38cab..57f0526 100644
--- a/java/com/android/dialer/calldetails/res/values-uz/strings.xml
+++ b/java/com/android/dialer/calldetails/res/values-uz/strings.xml
@@ -20,7 +20,7 @@
     <string name="call_details" msgid="5063658079729839605">"Chaqiruv tafsilotlari"</string>
     <string name="delete" msgid="2141020674108406737">"O‘chirib tashlash"</string>
     <string name="call_details_copy_number" msgid="4265479408878990796">"Raqamni nusxalash"</string>
-    <string name="call_details_edit_number" msgid="8718476514903513624">"Qo‘ng‘iroq qilishdan oldin raqamni tahrirlash"</string>
+    <string name="call_details_edit_number" msgid="8718476514903513624">"Chaqiruvdan oldin raqamni tahrirlash"</string>
     <string name="call_details_report_call_id" msgid="8857541295264421217">"Raqamdagi xatolik haqida xabar berish"</string>
     <string name="sent_a_photo" msgid="3978670717462979502">"Rasm yuborildi"</string>
     <string name="received_a_photo" msgid="3528953225576480505">"Rasm qabul qilindi"</string>
diff --git a/java/com/android/dialer/callintent/CallIntentBuilder.java b/java/com/android/dialer/callintent/CallIntentBuilder.java
index e5a0be8..e5449c8 100644
--- a/java/com/android/dialer/callintent/CallIntentBuilder.java
+++ b/java/com/android/dialer/callintent/CallIntentBuilder.java
@@ -22,6 +22,7 @@
 import android.os.SystemClock;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
+import android.support.annotation.VisibleForTesting;
 import android.telecom.PhoneAccountHandle;
 import android.telecom.TelecomManager;
 import android.telecom.VideoProfile;
@@ -38,25 +39,38 @@
   private boolean isVideoCall;
   private String callSubject;
 
+  private static int lightbringerButtonAppearInExpandedCallLogItemCount = 0;
+  private static int lightbringerButtonAppearInCollapsedCallLogItemCount = 0;
+  private static int lightbringerButtonAppearInSearchCount = 0;
+
   public CallIntentBuilder(@NonNull Uri uri, @NonNull CallSpecificAppData callSpecificAppData) {
     this.uri = Assert.isNotNull(uri);
     Assert.isNotNull(callSpecificAppData);
     Assert.checkArgument(
         callSpecificAppData.getCallInitiationType() != CallInitiationType.Type.UNKNOWN_INITIATION);
 
+    CallSpecificAppData.Builder builder =
+        CallSpecificAppData.newBuilder(callSpecificAppData)
+            .setLightbringerButtonAppearInExpandedCallLogItemCount(
+                lightbringerButtonAppearInExpandedCallLogItemCount)
+            .setLightbringerButtonAppearInCollapsedCallLogItemCount(
+                lightbringerButtonAppearInCollapsedCallLogItemCount)
+            .setLightbringerButtonAppearInSearchCount(lightbringerButtonAppearInSearchCount);
+    lightbringerButtonAppearInExpandedCallLogItemCount = 0;
+    lightbringerButtonAppearInCollapsedCallLogItemCount = 0;
+    lightbringerButtonAppearInSearchCount = 0;
+
     if (PerformanceReport.isRecording()) {
-      this.callSpecificAppData =
-          CallSpecificAppData.newBuilder(callSpecificAppData)
-              .setTimeSinceAppLaunch(PerformanceReport.getTimeSinceAppLaunch())
-              .setTimeSinceFirstClick(PerformanceReport.getTimeSinceFirstClick())
-              .addAllUiActionsSinceAppLaunch(PerformanceReport.getActions())
-              .addAllUiActionTimestampsSinceAppLaunch(PerformanceReport.getActionTimestamps())
-              .setStartingTabIndex(PerformanceReport.getStartingTabIndex())
-              .build();
+      builder
+          .setTimeSinceAppLaunch(PerformanceReport.getTimeSinceAppLaunch())
+          .setTimeSinceFirstClick(PerformanceReport.getTimeSinceFirstClick())
+          .addAllUiActionsSinceAppLaunch(PerformanceReport.getActions())
+          .addAllUiActionTimestampsSinceAppLaunch(PerformanceReport.getActionTimestamps())
+          .build();
       PerformanceReport.stopRecording();
-    } else {
-      this.callSpecificAppData = callSpecificAppData;
     }
+
+    this.callSpecificAppData = builder.build();
   }
 
   public CallIntentBuilder(@NonNull Uri uri, CallInitiationType.Type callInitiationType) {
@@ -119,4 +133,31 @@
         CallSpecificAppData.newBuilder().setCallInitiationType(callInitiationType).build();
     return callSpecificAppData;
   }
+
+  public static void increaseLightbringerCallButtonAppearInExpandedCallLogItemCount() {
+    CallIntentBuilder.lightbringerButtonAppearInExpandedCallLogItemCount++;
+  }
+
+  public static void increaseLightbringerCallButtonAppearInCollapsedCallLogItemCount() {
+    CallIntentBuilder.lightbringerButtonAppearInCollapsedCallLogItemCount++;
+  }
+
+  public static void increaseLightbringerCallButtonAppearInSearchCount() {
+    CallIntentBuilder.lightbringerButtonAppearInSearchCount++;
+  }
+
+  @VisibleForTesting
+  public static int getLightbringerButtonAppearInExpandedCallLogItemCount() {
+    return lightbringerButtonAppearInExpandedCallLogItemCount;
+  }
+
+  @VisibleForTesting
+  public static int getLightbringerButtonAppearInCollapsedCallLogItemCount() {
+    return lightbringerButtonAppearInCollapsedCallLogItemCount;
+  }
+
+  @VisibleForTesting
+  public static int getLightbringerButtonAppearInSearchCount() {
+    return lightbringerButtonAppearInSearchCount;
+  }
 }
diff --git a/java/com/android/dialer/callintent/call_initiation_type.proto b/java/com/android/dialer/callintent/call_initiation_type.proto
index e1385b7..318da9c 100644
--- a/java/com/android/dialer/callintent/call_initiation_type.proto
+++ b/java/com/android/dialer/callintent/call_initiation_type.proto
@@ -57,5 +57,7 @@
     MISSED_CALL_NOTIFICATION = 15;
 
     CALL_SUBJECT_DIALOG = 16;
+
+    IMS_VIDEO_BLOCKED_FALLBACK_TO_VOICE = 17;
   }
 }
diff --git a/java/com/android/dialer/callintent/call_specific_app_data.proto b/java/com/android/dialer/callintent/call_specific_app_data.proto
index 5d23794..82547fa 100644
--- a/java/com/android/dialer/callintent/call_specific_app_data.proto
+++ b/java/com/android/dialer/callintent/call_specific_app_data.proto
@@ -14,7 +14,7 @@
 // Miscellaneous data that's included in a new outgoing call initiated by
 // Dialer. The system will pass this data to the InCallUi which can use it
 // for logging or for something else.
-// Next tag: 11
+// Next tag: 14
 message CallSpecificAppData {
   optional CallInitiationType.Type call_initiation_type = 1;
 
@@ -34,4 +34,11 @@
   repeated int64 ui_action_timestamps_since_app_launch = 9;
 
   optional int32 starting_tab_index = 10;
+
+  // For recording the appearance of video call button
+  optional int32 lightbringer_button_appear_in_expanded_call_log_item_count =
+      11;
+  optional int32 lightbringer_button_appear_in_collapsed_call_log_item_count =
+      12;
+  optional int32 lightbringer_button_appear_in_search_count = 13;
 }
diff --git a/java/com/android/dialer/calllogutils/res/values-ar/strings.xml b/java/com/android/dialer/calllogutils/res/values-ar/strings.xml
index 617d6d8..39afb6d 100644
--- a/java/com/android/dialer/calllogutils/res/values-ar/strings.xml
+++ b/java/com/android/dialer/calllogutils/res/values-ar/strings.xml
@@ -34,8 +34,8 @@
     <string name="call_details_seconds_abbreviation" msgid="5893806826648947126">"ث"</string>
     <string name="a11y_call_duration_format" msgid="2905525933361674470">"<xliff:g id="MINUTES_0">%d</xliff:g> <xliff:g id="MINUTES_TRANSLATION">%s</xliff:g> <xliff:g id="SECONDS_1">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
     <string name="a11y_call_duration_short_format" msgid="5908875871251062453">"<xliff:g id="SECONDS_0">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
-    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
-    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
+    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
     <plurals name="a11y_seconds" formatted="false" msgid="6695730844760611970">
       <item quantity="zero">ثوان</item>
       <item quantity="two">ثانيتان</item>
diff --git a/java/com/android/dialer/calllogutils/res/values-az/strings.xml b/java/com/android/dialer/calllogutils/res/values-az/strings.xml
index c280c8e..0efe1e8 100644
--- a/java/com/android/dialer/calllogutils/res/values-az/strings.xml
+++ b/java/com/android/dialer/calllogutils/res/values-az/strings.xml
@@ -34,8 +34,8 @@
     <string name="call_details_seconds_abbreviation" msgid="5893806826648947126">"san"</string>
     <string name="a11y_call_duration_format" msgid="2905525933361674470">"<xliff:g id="MINUTES_0">%d</xliff:g> <xliff:g id="MINUTES_TRANSLATION">%s</xliff:g> <xliff:g id="SECONDS_1">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
     <string name="a11y_call_duration_short_format" msgid="5908875871251062453">"<xliff:g id="SECONDS_0">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
-    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g>\"<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\" <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\"<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\""</string>
-    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\"<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\""</string>
+    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
     <plurals name="a11y_seconds" formatted="false" msgid="6695730844760611970">
       <item quantity="other">saniyə</item>
       <item quantity="one">saniyə</item>
diff --git a/java/com/android/dialer/calllogutils/res/values-da/strings.xml b/java/com/android/dialer/calllogutils/res/values-da/strings.xml
index 123002a..21c6e0e 100644
--- a/java/com/android/dialer/calllogutils/res/values-da/strings.xml
+++ b/java/com/android/dialer/calllogutils/res/values-da/strings.xml
@@ -34,8 +34,8 @@
     <string name="call_details_seconds_abbreviation" msgid="5893806826648947126">"sek."</string>
     <string name="a11y_call_duration_format" msgid="2905525933361674470">"<xliff:g id="MINUTES_0">%d</xliff:g> <xliff:g id="MINUTES_TRANSLATION">%s</xliff:g> <xliff:g id="SECONDS_1">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
     <string name="a11y_call_duration_short_format" msgid="5908875871251062453">"<xliff:g id="SECONDS_0">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
-    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g>\' <xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\' <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
-    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\' <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
     <plurals name="a11y_seconds" formatted="false" msgid="6695730844760611970">
       <item quantity="one">sekund</item>
       <item quantity="other">sekunder</item>
diff --git a/java/com/android/dialer/calllogutils/res/values-de/strings.xml b/java/com/android/dialer/calllogutils/res/values-de/strings.xml
index 5867b73..4d6f416 100644
--- a/java/com/android/dialer/calllogutils/res/values-de/strings.xml
+++ b/java/com/android/dialer/calllogutils/res/values-de/strings.xml
@@ -34,8 +34,8 @@
     <string name="call_details_seconds_abbreviation" msgid="5893806826648947126">"s"</string>
     <string name="a11y_call_duration_format" msgid="2905525933361674470">"<xliff:g id="MINUTES_0">%d</xliff:g> <xliff:g id="MINUTES_TRANSLATION">%s</xliff:g> <xliff:g id="SECONDS_1">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
     <string name="a11y_call_duration_short_format" msgid="5908875871251062453">"<xliff:g id="SECONDS_0">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
-    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g> \"<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\" <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \"<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\""</string>
-    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \"<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\""</string>
+    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
     <plurals name="a11y_seconds" formatted="false" msgid="6695730844760611970">
       <item quantity="other"> Sekunden</item>
       <item quantity="one"> Sekunde</item>
diff --git a/java/com/android/dialer/calllogutils/res/values-eu/strings.xml b/java/com/android/dialer/calllogutils/res/values-eu/strings.xml
index a097ec8..7ab37c5 100644
--- a/java/com/android/dialer/calllogutils/res/values-eu/strings.xml
+++ b/java/com/android/dialer/calllogutils/res/values-eu/strings.xml
@@ -34,7 +34,7 @@
     <string name="call_details_seconds_abbreviation" msgid="5893806826648947126">"s"</string>
     <string name="a11y_call_duration_format" msgid="2905525933361674470">"<xliff:g id="MINUTES_0">%d</xliff:g> <xliff:g id="MINUTES_TRANSLATION">%s</xliff:g> eta <xliff:g id="SECONDS_1">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
     <string name="a11y_call_duration_short_format" msgid="5908875871251062453">"<xliff:g id="SECONDS_0">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
-    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' eta <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' \'eta\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
     <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
     <plurals name="a11y_seconds" formatted="false" msgid="6695730844760611970">
       <item quantity="other">segundo</item>
diff --git a/java/com/android/dialer/calllogutils/res/values-hi/strings.xml b/java/com/android/dialer/calllogutils/res/values-hi/strings.xml
index d20e88e..b9a6241 100644
--- a/java/com/android/dialer/calllogutils/res/values-hi/strings.xml
+++ b/java/com/android/dialer/calllogutils/res/values-hi/strings.xml
@@ -34,8 +34,8 @@
     <string name="call_details_seconds_abbreviation" msgid="5893806826648947126">"से."</string>
     <string name="a11y_call_duration_format" msgid="2905525933361674470">"<xliff:g id="MINUTES_0">%d</xliff:g> <xliff:g id="MINUTES_TRANSLATION">%s</xliff:g> <xliff:g id="SECONDS_1">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
     <string name="a11y_call_duration_short_format" msgid="5908875871251062453">"<xliff:g id="SECONDS_0">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
-    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
-    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
     <plurals name="a11y_seconds" formatted="false" msgid="6695730844760611970">
       <item quantity="one">सेकंड</item>
       <item quantity="other">सेकंड</item>
diff --git a/java/com/android/dialer/calllogutils/res/values-iw/strings.xml b/java/com/android/dialer/calllogutils/res/values-iw/strings.xml
index 2f29855..1ab041a 100644
--- a/java/com/android/dialer/calllogutils/res/values-iw/strings.xml
+++ b/java/com/android/dialer/calllogutils/res/values-iw/strings.xml
@@ -34,7 +34,7 @@
     <string name="call_details_seconds_abbreviation" msgid="5893806826648947126">"שנ\'"</string>
     <string name="a11y_call_duration_format" msgid="2905525933361674470">"<xliff:g id="MINUTES_0">%d</xliff:g> <xliff:g id="MINUTES_TRANSLATION">%s</xliff:g> ו-<xliff:g id="SECONDS_1">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
     <string name="a11y_call_duration_short_format" msgid="5908875871251062453">"<xliff:g id="SECONDS_0">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
-    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' ו-<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
     <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
     <plurals name="a11y_seconds" formatted="false" msgid="6695730844760611970">
       <item quantity="two">שניות</item>
diff --git a/java/com/android/dialer/calllogutils/res/values-ky/strings.xml b/java/com/android/dialer/calllogutils/res/values-ky/strings.xml
index f758dab..76d389e 100644
--- a/java/com/android/dialer/calllogutils/res/values-ky/strings.xml
+++ b/java/com/android/dialer/calllogutils/res/values-ky/strings.xml
@@ -35,7 +35,7 @@
     <string name="a11y_call_duration_format" msgid="2905525933361674470">"<xliff:g id="MINUTES_0">%d</xliff:g> <xliff:g id="MINUTES_TRANSLATION">%s</xliff:g> <xliff:g id="SECONDS_1">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
     <string name="a11y_call_duration_short_format" msgid="5908875871251062453">"<xliff:g id="SECONDS_0">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
     <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
-    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
     <plurals name="a11y_seconds" formatted="false" msgid="6695730844760611970">
       <item quantity="other">секундалар</item>
       <item quantity="one">секунда</item>
diff --git a/java/com/android/dialer/calllogutils/res/values-mr/strings.xml b/java/com/android/dialer/calllogutils/res/values-mr/strings.xml
index c01f7c1..9a7513b 100644
--- a/java/com/android/dialer/calllogutils/res/values-mr/strings.xml
+++ b/java/com/android/dialer/calllogutils/res/values-mr/strings.xml
@@ -34,8 +34,8 @@
     <string name="call_details_seconds_abbreviation" msgid="5893806826648947126">"से"</string>
     <string name="a11y_call_duration_format" msgid="2905525933361674470">"<xliff:g id="MINUTES_0">%d</xliff:g> <xliff:g id="MINUTES_TRANSLATION">%s</xliff:g> <xliff:g id="SECONDS_1">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
     <string name="a11y_call_duration_short_format" msgid="5908875871251062453">"<xliff:g id="SECONDS_0">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
-    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
-    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
     <plurals name="a11y_seconds" formatted="false" msgid="6695730844760611970">
       <item quantity="one">सेकंद</item>
       <item quantity="other">सेकंद</item>
diff --git a/java/com/android/dialer/calllogutils/res/values-nb/strings.xml b/java/com/android/dialer/calllogutils/res/values-nb/strings.xml
index 2f74403..4ec963d 100644
--- a/java/com/android/dialer/calllogutils/res/values-nb/strings.xml
+++ b/java/com/android/dialer/calllogutils/res/values-nb/strings.xml
@@ -34,8 +34,8 @@
     <string name="call_details_seconds_abbreviation" msgid="5893806826648947126">"sek."</string>
     <string name="a11y_call_duration_format" msgid="2905525933361674470">"<xliff:g id="MINUTES_0">%d</xliff:g> <xliff:g id="MINUTES_TRANSLATION">%s</xliff:g> <xliff:g id="SECONDS_1">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
     <string name="a11y_call_duration_short_format" msgid="5908875871251062453">"<xliff:g id="SECONDS_0">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
-    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
-    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
     <plurals name="a11y_seconds" formatted="false" msgid="6695730844760611970">
       <item quantity="other">sekunder</item>
       <item quantity="one">sekund</item>
diff --git a/java/com/android/dialer/calllogutils/res/values-nl/strings.xml b/java/com/android/dialer/calllogutils/res/values-nl/strings.xml
index d156109..5239928 100644
--- a/java/com/android/dialer/calllogutils/res/values-nl/strings.xml
+++ b/java/com/android/dialer/calllogutils/res/values-nl/strings.xml
@@ -34,8 +34,8 @@
     <string name="call_details_seconds_abbreviation" msgid="5893806826648947126">"s"</string>
     <string name="a11y_call_duration_format" msgid="2905525933361674470">"<xliff:g id="MINUTES_0">%d</xliff:g> <xliff:g id="MINUTES_TRANSLATION">%s</xliff:g> <xliff:g id="SECONDS_1">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
     <string name="a11y_call_duration_short_format" msgid="5908875871251062453">"<xliff:g id="SECONDS_0">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
-    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
-    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
     <plurals name="a11y_seconds" formatted="false" msgid="6695730844760611970">
       <item quantity="other">seconden</item>
       <item quantity="one">seconde</item>
diff --git a/java/com/android/dialer/calllogutils/res/values-no/strings.xml b/java/com/android/dialer/calllogutils/res/values-no/strings.xml
index 2f74403..4ec963d 100644
--- a/java/com/android/dialer/calllogutils/res/values-no/strings.xml
+++ b/java/com/android/dialer/calllogutils/res/values-no/strings.xml
@@ -34,8 +34,8 @@
     <string name="call_details_seconds_abbreviation" msgid="5893806826648947126">"sek."</string>
     <string name="a11y_call_duration_format" msgid="2905525933361674470">"<xliff:g id="MINUTES_0">%d</xliff:g> <xliff:g id="MINUTES_TRANSLATION">%s</xliff:g> <xliff:g id="SECONDS_1">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
     <string name="a11y_call_duration_short_format" msgid="5908875871251062453">"<xliff:g id="SECONDS_0">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
-    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
-    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
     <plurals name="a11y_seconds" formatted="false" msgid="6695730844760611970">
       <item quantity="other">sekunder</item>
       <item quantity="one">sekund</item>
diff --git a/java/com/android/dialer/calllogutils/res/values-pt-rBR/strings.xml b/java/com/android/dialer/calllogutils/res/values-pt-rBR/strings.xml
index 8c13e81..ba526a8 100644
--- a/java/com/android/dialer/calllogutils/res/values-pt-rBR/strings.xml
+++ b/java/com/android/dialer/calllogutils/res/values-pt-rBR/strings.xml
@@ -34,8 +34,8 @@
     <string name="call_details_seconds_abbreviation" msgid="5893806826648947126">"s"</string>
     <string name="a11y_call_duration_format" msgid="2905525933361674470">"<xliff:g id="MINUTES_0">%d</xliff:g> <xliff:g id="MINUTES_TRANSLATION">%s</xliff:g> <xliff:g id="SECONDS_1">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
     <string name="a11y_call_duration_short_format" msgid="5908875871251062453">"<xliff:g id="SECONDS_0">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
-    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g> \"<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\" <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \"<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\""</string>
-    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \"<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\""</string>
+    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
     <plurals name="a11y_seconds" formatted="false" msgid="6695730844760611970">
       <item quantity="one"> segundo</item>
       <item quantity="other"> segundos</item>
diff --git a/java/com/android/dialer/calllogutils/res/values-pt-rPT/strings.xml b/java/com/android/dialer/calllogutils/res/values-pt-rPT/strings.xml
index e24d245..adb5dac 100644
--- a/java/com/android/dialer/calllogutils/res/values-pt-rPT/strings.xml
+++ b/java/com/android/dialer/calllogutils/res/values-pt-rPT/strings.xml
@@ -34,8 +34,8 @@
     <string name="call_details_seconds_abbreviation" msgid="5893806826648947126">"seg"</string>
     <string name="a11y_call_duration_format" msgid="2905525933361674470">"<xliff:g id="MINUTES_0">%d</xliff:g> <xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>, <xliff:g id="SECONDS_1">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
     <string name="a11y_call_duration_short_format" msgid="5908875871251062453">"<xliff:g id="SECONDS_0">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
-    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g>\"<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\", <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\"<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\""</string>
-    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \"<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\""</string>
+    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\', <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
     <plurals name="a11y_seconds" formatted="false" msgid="6695730844760611970">
       <item quantity="one">seconds</item>
       <item quantity="other">segundos</item>
diff --git a/java/com/android/dialer/calllogutils/res/values-pt/strings.xml b/java/com/android/dialer/calllogutils/res/values-pt/strings.xml
index 8c13e81..ba526a8 100644
--- a/java/com/android/dialer/calllogutils/res/values-pt/strings.xml
+++ b/java/com/android/dialer/calllogutils/res/values-pt/strings.xml
@@ -34,8 +34,8 @@
     <string name="call_details_seconds_abbreviation" msgid="5893806826648947126">"s"</string>
     <string name="a11y_call_duration_format" msgid="2905525933361674470">"<xliff:g id="MINUTES_0">%d</xliff:g> <xliff:g id="MINUTES_TRANSLATION">%s</xliff:g> <xliff:g id="SECONDS_1">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
     <string name="a11y_call_duration_short_format" msgid="5908875871251062453">"<xliff:g id="SECONDS_0">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
-    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g> \"<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\" <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \"<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\""</string>
-    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \"<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\""</string>
+    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
     <plurals name="a11y_seconds" formatted="false" msgid="6695730844760611970">
       <item quantity="one"> segundo</item>
       <item quantity="other"> segundos</item>
diff --git a/java/com/android/dialer/calllogutils/res/values-sw/strings.xml b/java/com/android/dialer/calllogutils/res/values-sw/strings.xml
index 5a5a690..46217e7 100644
--- a/java/com/android/dialer/calllogutils/res/values-sw/strings.xml
+++ b/java/com/android/dialer/calllogutils/res/values-sw/strings.xml
@@ -34,8 +34,8 @@
     <string name="call_details_seconds_abbreviation" msgid="5893806826648947126">"sek"</string>
     <string name="a11y_call_duration_format" msgid="2905525933361674470">"<xliff:g id="MINUTES_0">%d</xliff:g> <xliff:g id="MINUTES_TRANSLATION">%s</xliff:g> <xliff:g id="SECONDS_1">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
     <string name="a11y_call_duration_short_format" msgid="5908875871251062453">"<xliff:g id="SECONDS_0">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
-    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
-    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_format_pattern" msgid="7566375153243313914">"\'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\'<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>"</string>
+    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"\'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g>"</string>
     <plurals name="a11y_seconds" formatted="false" msgid="6695730844760611970">
       <item quantity="other">Sekunde</item>
       <item quantity="one">Sekunde</item>
diff --git a/java/com/android/dialer/calllogutils/res/values-tr/strings.xml b/java/com/android/dialer/calllogutils/res/values-tr/strings.xml
index 78e0b5b..93cf690 100644
--- a/java/com/android/dialer/calllogutils/res/values-tr/strings.xml
+++ b/java/com/android/dialer/calllogutils/res/values-tr/strings.xml
@@ -34,8 +34,8 @@
     <string name="call_details_seconds_abbreviation" msgid="5893806826648947126">"sn."</string>
     <string name="a11y_call_duration_format" msgid="2905525933361674470">"<xliff:g id="MINUTES_0">%d</xliff:g> <xliff:g id="MINUTES_TRANSLATION">%s</xliff:g> <xliff:g id="SECONDS_1">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
     <string name="a11y_call_duration_short_format" msgid="5908875871251062453">"<xliff:g id="SECONDS_0">%d</xliff:g> <xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>"</string>
-    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g> \"<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\" <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \"<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\""</string>
-    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \"<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\""</string>
+    <string name="call_duration_format_pattern" msgid="7566375153243313914">"<xliff:g id="MINUTES_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="MINUTES_TRANSLATION">%s</xliff:g>\' <xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
+    <string name="call_duration_short_format_pattern" msgid="1713177000235994790">"<xliff:g id="SECONDS_SPECIAL_CHARACTER">%s</xliff:g> \'<xliff:g id="SECONDS_TRANSLATION">%s</xliff:g>\'"</string>
     <plurals name="a11y_seconds" formatted="false" msgid="6695730844760611970">
       <item quantity="other">saniye</item>
       <item quantity="one">saniye</item>
diff --git a/java/com/android/dialer/constants/TrafficStatsTags.java b/java/com/android/dialer/constants/TrafficStatsTags.java
index 4e61404..13c3e2c 100644
--- a/java/com/android/dialer/constants/TrafficStatsTags.java
+++ b/java/com/android/dialer/constants/TrafficStatsTags.java
@@ -25,4 +25,5 @@
   public static final int DOWNLOAD_LOCATION_MAP_TAG = 0xd000;
   public static final int REVERSE_GEOCODE_TAG = 0xd001;
   public static final int VISUAL_VOICEMAIL_TAG = 0xd002;
+  public static final int DIALER_VOIP_TAG = 0xd003;
 }
diff --git a/java/com/android/dialer/enrichedcall/EnrichedCallManager.java b/java/com/android/dialer/enrichedcall/EnrichedCallManager.java
index d341b43..f1057be 100644
--- a/java/com/android/dialer/enrichedcall/EnrichedCallManager.java
+++ b/java/com/android/dialer/enrichedcall/EnrichedCallManager.java
@@ -16,7 +16,6 @@
 
 package com.android.dialer.enrichedcall;
 
-import android.support.annotation.IntDef;
 import android.support.annotation.MainThread;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
@@ -25,8 +24,6 @@
 import com.android.dialer.enrichedcall.historyquery.proto.HistoryResult;
 import com.android.dialer.enrichedcall.videoshare.VideoShareListener;
 import com.android.dialer.multimedia.MultimediaData;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
 import java.util.List;
 import java.util.Map;
 
@@ -81,27 +78,6 @@
   @MainThread
   void clearCachedData();
 
-  /** Possible states for call composer sessions. */
-  @Retention(RetentionPolicy.SOURCE)
-  @IntDef({
-    STATE_NONE,
-    STATE_STARTING,
-    STATE_STARTED,
-    STATE_START_FAILED,
-    STATE_MESSAGE_SENT,
-    STATE_MESSAGE_FAILED,
-    STATE_CLOSED,
-  })
-  @interface State {}
-
-  int STATE_NONE = 0;
-  int STATE_STARTING = STATE_NONE + 1;
-  int STATE_STARTED = STATE_STARTING + 1;
-  int STATE_START_FAILED = STATE_STARTED + 1;
-  int STATE_MESSAGE_SENT = STATE_START_FAILED + 1;
-  int STATE_MESSAGE_FAILED = STATE_MESSAGE_SENT + 1;
-  int STATE_CLOSED = STATE_MESSAGE_FAILED + 1;
-
   /**
    * Starts a call composer session with the given remote number.
    *
@@ -119,7 +95,7 @@
    * @param sessionId the id for the session. See {@link #startCallComposerSession(String)}
    * @param data the {@link MultimediaData}
    * @throws IllegalArgumentException if there's no open session with the given number
-   * @throws IllegalStateException if the session isn't in the {@link #STATE_STARTED} state
+   * @throws IllegalStateException if the session isn't in the {@link Session#STATE_STARTED} state
    */
   @MainThread
   void sendCallComposerData(long sessionId, @NonNull MultimediaData data);
diff --git a/java/com/android/dialer/enrichedcall/Session.java b/java/com/android/dialer/enrichedcall/Session.java
index b3f2914..06837e3 100644
--- a/java/com/android/dialer/enrichedcall/Session.java
+++ b/java/com/android/dialer/enrichedcall/Session.java
@@ -16,14 +16,37 @@
 
 package com.android.dialer.enrichedcall;
 
+import android.support.annotation.IntDef;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
-import com.android.dialer.enrichedcall.EnrichedCallManager.State;
 import com.android.dialer.multimedia.MultimediaData;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
 
 /** Holds state information and data about enriched calling sessions. */
 public interface Session {
 
+  /** Possible states for call composer sessions. */
+  @Retention(RetentionPolicy.SOURCE)
+  @IntDef({
+    STATE_NONE,
+    STATE_STARTING,
+    STATE_STARTED,
+    STATE_START_FAILED,
+    STATE_MESSAGE_SENT,
+    STATE_MESSAGE_FAILED,
+    STATE_CLOSED,
+  })
+  @interface State {}
+
+  int STATE_NONE = 0;
+  int STATE_STARTING = STATE_NONE + 1;
+  int STATE_STARTED = STATE_STARTING + 1;
+  int STATE_START_FAILED = STATE_STARTED + 1;
+  int STATE_MESSAGE_SENT = STATE_START_FAILED + 1;
+  int STATE_MESSAGE_FAILED = STATE_MESSAGE_SENT + 1;
+  int STATE_CLOSED = STATE_MESSAGE_FAILED + 1;
+
   /** Id used for sessions that fail to start. */
   long NO_SESSION_ID = -1;
 
diff --git a/java/com/android/dialer/enrichedcall/extensions/StateExtension.java b/java/com/android/dialer/enrichedcall/extensions/StateExtension.java
index 8a4f640..5d90829 100644
--- a/java/com/android/dialer/enrichedcall/extensions/StateExtension.java
+++ b/java/com/android/dialer/enrichedcall/extensions/StateExtension.java
@@ -18,8 +18,8 @@
 
 import android.support.annotation.NonNull;
 import com.android.dialer.common.Assert;
-import com.android.dialer.enrichedcall.EnrichedCallManager;
-import com.android.dialer.enrichedcall.EnrichedCallManager.State;
+import com.android.dialer.enrichedcall.Session;
+import com.android.dialer.enrichedcall.Session.State;
 
 /** Extends the {@link State} to include a toString method. */
 public class StateExtension {
@@ -27,25 +27,25 @@
   /** Returns the string representation for the given {@link State}. */
   @NonNull
   public static String toString(@State int callComposerState) {
-    if (callComposerState == EnrichedCallManager.STATE_NONE) {
+    if (callComposerState == Session.STATE_NONE) {
       return "STATE_NONE";
     }
-    if (callComposerState == EnrichedCallManager.STATE_STARTING) {
+    if (callComposerState == Session.STATE_STARTING) {
       return "STATE_STARTING";
     }
-    if (callComposerState == EnrichedCallManager.STATE_STARTED) {
+    if (callComposerState == Session.STATE_STARTED) {
       return "STATE_STARTED";
     }
-    if (callComposerState == EnrichedCallManager.STATE_START_FAILED) {
+    if (callComposerState == Session.STATE_START_FAILED) {
       return "STATE_START_FAILED";
     }
-    if (callComposerState == EnrichedCallManager.STATE_MESSAGE_SENT) {
+    if (callComposerState == Session.STATE_MESSAGE_SENT) {
       return "STATE_MESSAGE_SENT";
     }
-    if (callComposerState == EnrichedCallManager.STATE_MESSAGE_FAILED) {
+    if (callComposerState == Session.STATE_MESSAGE_FAILED) {
       return "STATE_MESSAGE_FAILED";
     }
-    if (callComposerState == EnrichedCallManager.STATE_CLOSED) {
+    if (callComposerState == Session.STATE_CLOSED) {
       return "STATE_CLOSED";
     }
     Assert.checkArgument(false, "Unexpected callComposerState: %d", callComposerState);
diff --git a/java/com/android/dialer/logging/dialer_impression.proto b/java/com/android/dialer/logging/dialer_impression.proto
index 6db9037..2f89a3a 100644
--- a/java/com/android/dialer/logging/dialer_impression.proto
+++ b/java/com/android/dialer/logging/dialer_impression.proto
@@ -6,11 +6,11 @@
 option optimize_for = LITE_RUNTIME;
 
 
+
 message DialerImpression {
   // Event enums to be used for Impression Logging in Dialer.
   // It's perfectly acceptable for this enum to be large
   // Values should be from 1000 to 100000.
-  // Next Tag:1229
   enum Type {
 
     UNKNOWN_AOSP_EVENT_TYPE = 1000;
@@ -400,9 +400,10 @@
     BUBBLE_END_CALL = 1195;
 
     LIGHTBRINGER_VIDEO_REQUESTED_FROM_SEARCH = 1196;
-    LIGHTBRINGER_VIDEO_REQUESTED_FROM_CALL_LOG = 1197;
+    LIGHTBRINGER_VIDEO_REQUESTED_FROM_CALL_LOG =
+        1197;  // Including call history
     IMS_VIDEO_REQUESTED_FROM_SEARCH = 1198;
-    IMS_VIDEO_REQUESTED_FROM_CALL_LOG = 1199;
+    IMS_VIDEO_REQUESTED_FROM_CALL_LOG = 1199;  // Including call history
 
     // Multi select impressions
     MULTISELECT_LONG_PRESS_ENTER_MULTI_SELECT_MODE = 1200;
@@ -442,5 +443,17 @@
     // Impressions for dialer reporting caller id as inaccurate
     CALLER_ID_REPORTED = 1227;
     CALLER_ID_REPORT_FAILED = 1228;
+
+    // Impressions for interactions with the voicemail transcription server
+    VVM_TRANSCRIPTION_REQUEST_SENT = 1229;
+    VVM_TRANSCRIPTION_REQUEST_RETRY = 1230;
+    VVM_TRANSCRIPTION_RESPONSE_SUCCESS = 1231;
+    VVM_TRANSCRIPTION_RESPONSE_EMPTY = 1232;
+    VVM_TRANSCRIPTION_RESPONSE_INVALID = 1233;
+    VVM_TRANSCRIPTION_RESPONSE_RECOVERABLE_ERROR = 1234;
+    VVM_TRANSCRIPTION_RESPONSE_FATAL_ERROR = 1235;
+
+    // In in call UI
+    UPGRADE_TO_VIDEO_CALL_BUTTON_SHOWN = 1236;
   }
 }
diff --git a/java/com/android/dialer/shortcuts/IconFactory.java b/java/com/android/dialer/shortcuts/IconFactory.java
index a8c4ada..4ec964c 100644
--- a/java/com/android/dialer/shortcuts/IconFactory.java
+++ b/java/com/android/dialer/shortcuts/IconFactory.java
@@ -20,11 +20,16 @@
 import android.content.pm.ShortcutInfo;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
+import android.graphics.drawable.AdaptiveIconDrawable;
 import android.graphics.drawable.Drawable;
 import android.graphics.drawable.Icon;
 import android.net.Uri;
+import android.os.Build.VERSION;
+import android.os.Build.VERSION_CODES;
 import android.provider.ContactsContract;
 import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.annotation.RequiresApi;
 import android.support.annotation.WorkerThread;
 import android.support.v4.graphics.drawable.RoundedBitmapDrawable;
 import android.support.v4.graphics.drawable.RoundedBitmapDrawableFactory;
@@ -83,6 +88,38 @@
         ContactsContract.Contacts.openContactPhotoInputStream(
             context.getContentResolver(), lookupUri, false /* preferHighres */);
 
+    return VERSION.SDK_INT >= VERSION_CODES.O
+        ? createAdaptiveIcon(displayName, lookupKey, inputStream)
+        : createFlatIcon(displayName, lookupKey, inputStream);
+  }
+
+  @RequiresApi(VERSION_CODES.O)
+  private Icon createAdaptiveIcon(
+      @NonNull String displayName, @NonNull String lookupKey, @Nullable InputStream inputStream) {
+    if (inputStream == null) {
+      LetterTileDrawable letterTileDrawable = new LetterTileDrawable(context.getResources());
+      // The adaptive icons clip the drawable to a safe area inside the drawable. Scale the letter
+      // so it fits inside the safe area.
+      letterTileDrawable.setScale(1f / (1f + AdaptiveIconDrawable.getExtraInsetFraction()));
+      letterTileDrawable.setCanonicalDialerLetterTileDetails(
+          displayName,
+          lookupKey,
+          LetterTileDrawable.SHAPE_RECTANGLE,
+          LetterTileDrawable.TYPE_DEFAULT);
+
+      int iconSize =
+          context
+              .getResources()
+              .getDimensionPixelSize(R.dimen.launcher_shortcut_adaptive_icon_size);
+      return Icon.createWithAdaptiveBitmap(
+          DrawableConverter.drawableToBitmap(letterTileDrawable, iconSize, iconSize));
+    }
+    Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
+    return Icon.createWithAdaptiveBitmap(bitmap);
+  }
+
+  private Icon createFlatIcon(
+      @NonNull String displayName, @NonNull String lookupKey, @Nullable InputStream inputStream) {
     Drawable drawable;
     if (inputStream == null) {
       // No photo for contact; use a letter tile.
diff --git a/java/com/android/dialer/shortcuts/res/drawable-anydpi-v26/ic_shortcut_add_contact.xml b/java/com/android/dialer/shortcuts/res/drawable-anydpi-v26/ic_shortcut_add_contact.xml
new file mode 100644
index 0000000..07ed172
--- /dev/null
+++ b/java/com/android/dialer/shortcuts/res/drawable-anydpi-v26/ic_shortcut_add_contact.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 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
+  -->
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+  <background android:drawable="@color/shortcut_add_contact_background_color"/>
+
+  <foreground android:drawable="@drawable/ic_add_contact_foreground"/>
+</adaptive-icon>
diff --git a/java/com/android/dialer/shortcuts/res/drawable/ic_add_contact_foreground.xml b/java/com/android/dialer/shortcuts/res/drawable/ic_add_contact_foreground.xml
new file mode 100644
index 0000000..6bc1727
--- /dev/null
+++ b/java/com/android/dialer/shortcuts/res/drawable/ic_add_contact_foreground.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 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
+  -->
+
+<bitmap xmlns:android="http://schemas.android.com/apk/res/android"
+    android:gravity="center"
+    android:src="@drawable/quantum_ic_person_add_white_24"
+    android:tint="@color/shortcut_add_contact_foreground_color">
+
+</bitmap>
diff --git a/java/com/android/dialer/shortcuts/res/values/dimens.xml b/java/com/android/dialer/shortcuts/res/values/dimens.xml
index 2321256..369d38c 100644
--- a/java/com/android/dialer/shortcuts/res/values/dimens.xml
+++ b/java/com/android/dialer/shortcuts/res/values/dimens.xml
@@ -16,4 +16,5 @@
   -->
 <resources>
   <dimen name="launcher_shortcut_icon_size">48dp</dimen>
+  <dimen name="launcher_shortcut_adaptive_icon_size">108dp</dimen>
 </resources>
diff --git a/java/com/android/dialer/simulator/impl/SimulatorContacts.java b/java/com/android/dialer/simulator/impl/SimulatorContacts.java
index e77788f..5bd2898 100644
--- a/java/com/android/dialer/simulator/impl/SimulatorContacts.java
+++ b/java/com/android/dialer/simulator/impl/SimulatorContacts.java
@@ -37,7 +37,7 @@
 import java.util.List;
 
 /** Populates the device database with contacts. */
-final class SimulatorContacts {
+public final class SimulatorContacts {
   // Phone numbers from https://www.google.com/about/company/facts/locations/
   private static final Contact[] SIMPLE_CONTACTS = {
     // US, contact with e164 number.
@@ -114,7 +114,7 @@
   };
 
   @WorkerThread
-  static void populateContacts(@NonNull Context context) {
+  public static void populateContacts(@NonNull Context context) {
     Assert.isWorkerThread();
     ArrayList<ContentProviderOperation> operations = new ArrayList<>();
     for (Contact contact : SIMPLE_CONTACTS) {
diff --git a/java/com/android/dialershared/bubble/ChangeOnScreenBounds.java b/java/com/android/dialershared/bubble/ChangeOnScreenBounds.java
index 4da6a35..37c8204 100644
--- a/java/com/android/dialershared/bubble/ChangeOnScreenBounds.java
+++ b/java/com/android/dialershared/bubble/ChangeOnScreenBounds.java
@@ -22,6 +22,7 @@
 import android.graphics.Path;
 import android.graphics.PointF;
 import android.graphics.Rect;
+import android.support.annotation.VisibleForTesting;
 import android.transition.Transition;
 import android.transition.TransitionValues;
 import android.util.Property;
@@ -31,9 +32,14 @@
 /** Similar to {@link android.transition.ChangeBounds ChangeBounds} but works across windows */
 public class ChangeOnScreenBounds extends Transition {
 
-  private static final String PROPNAME_BOUNDS = "bubble:changeScreenBounds:bounds";
-  private static final String PROPNAME_SCREEN_X = "bubble:changeScreenBounds:screenX";
-  private static final String PROPNAME_SCREEN_Y = "bubble:changeScreenBounds:screenY";
+  @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
+  static final String PROPNAME_BOUNDS = "bubble:changeScreenBounds:bounds";
+
+  @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
+  static final String PROPNAME_SCREEN_X = "bubble:changeScreenBounds:screenX";
+
+  @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
+  static final String PROPNAME_SCREEN_Y = "bubble:changeScreenBounds:screenY";
 
   private static final Property<ViewBounds, PointF> TOP_LEFT_PROPERTY =
       new Property<ViewBounds, PointF>(PointF.class, "topLeft") {
@@ -89,6 +95,12 @@
   public Animator createAnimator(
       ViewGroup sceneRoot, TransitionValues startValues, TransitionValues endValues) {
     Rect startBounds = (Rect) startValues.values.get(PROPNAME_BOUNDS);
+    Rect endBounds = (Rect) endValues.values.get(PROPNAME_BOUNDS);
+
+    if (startBounds == null || endBounds == null) {
+      // start or end values were not captured, so don't animate.
+      return null;
+    }
 
     // Offset the startBounds by the difference in screen position
     int startScreenX = (Integer) startValues.values.get(PROPNAME_SCREEN_X);
@@ -97,7 +109,6 @@
     int endScreenY = (Integer) endValues.values.get(PROPNAME_SCREEN_Y);
     startBounds.offset(startScreenX - endScreenX, startScreenY - endScreenY);
 
-    Rect endBounds = (Rect) endValues.values.get(PROPNAME_BOUNDS);
     final int startLeft = startBounds.left;
     final int endLeft = endBounds.left;
     final int startTop = startBounds.top;
diff --git a/java/com/android/incallui/InCallActivity.java b/java/com/android/incallui/InCallActivity.java
index 6ea31fc..c95086c 100644
--- a/java/com/android/incallui/InCallActivity.java
+++ b/java/com/android/incallui/InCallActivity.java
@@ -28,7 +28,6 @@
 import android.support.v4.app.FragmentManager;
 import android.support.v4.app.FragmentTransaction;
 import android.support.v4.graphics.ColorUtils;
-import android.telecom.DisconnectCause;
 import android.telephony.TelephonyManager;
 import android.view.KeyEvent;
 import android.view.MenuItem;
@@ -48,6 +47,7 @@
 import com.android.incallui.call.CallList;
 import com.android.incallui.call.DialerCall;
 import com.android.incallui.call.DialerCall.State;
+import com.android.incallui.disconnectdialog.DisconnectMessage;
 import com.android.incallui.incall.bindings.InCallBindings;
 import com.android.incallui.incall.protocol.InCallButtonUiDelegate;
 import com.android.incallui.incall.protocol.InCallButtonUiDelegateFactory;
@@ -393,8 +393,8 @@
     common.showPostCharWaitDialog(callId, chars);
   }
 
-  public void maybeShowErrorDialogOnDisconnect(DisconnectCause disconnectCause) {
-    common.maybeShowErrorDialogOnDisconnect(disconnectCause);
+  public void maybeShowErrorDialogOnDisconnect(DisconnectMessage disconnectMessage) {
+    common.maybeShowErrorDialogOnDisconnect(disconnectMessage);
   }
 
   public void dismissPendingDialogs() {
diff --git a/java/com/android/incallui/InCallActivityCommon.java b/java/com/android/incallui/InCallActivityCommon.java
index 4b0a3cd..3a264be 100644
--- a/java/com/android/incallui/InCallActivityCommon.java
+++ b/java/com/android/incallui/InCallActivityCommon.java
@@ -21,7 +21,6 @@
 import android.app.ActivityManager.TaskDescription;
 import android.app.AlertDialog;
 import android.app.Dialog;
-import android.content.Context;
 import android.content.DialogInterface;
 import android.content.DialogInterface.OnCancelListener;
 import android.content.DialogInterface.OnDismissListener;
@@ -36,10 +35,7 @@
 import android.support.v4.app.FragmentManager;
 import android.support.v4.app.FragmentTransaction;
 import android.support.v4.content.res.ResourcesCompat;
-import android.telecom.DisconnectCause;
 import android.telecom.PhoneAccountHandle;
-import android.text.TextUtils;
-import android.util.Pair;
 import android.view.KeyEvent;
 import android.view.View;
 import android.view.Window;
@@ -62,9 +58,9 @@
 import com.android.incallui.call.DialerCall;
 import com.android.incallui.call.DialerCall.State;
 import com.android.incallui.call.TelecomAdapter;
+import com.android.incallui.disconnectdialog.DisconnectMessage;
 import com.android.incallui.telecomeventui.InternationalCallOnWifiDialogFragment;
 import com.android.incallui.telecomeventui.InternationalCallOnWifiDialogFragment.Callback;
-import com.android.incallui.wifi.EnableWifiCallingPrompt;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.util.ArrayList;
@@ -497,18 +493,15 @@
     }
   }
 
-  public void maybeShowErrorDialogOnDisconnect(DisconnectCause cause) {
+  public void maybeShowErrorDialogOnDisconnect(DisconnectMessage disconnectMessage) {
     LogUtil.i(
-        "InCallActivityCommon.maybeShowErrorDialogOnDisconnect", "disconnect cause: %s", cause);
+        "InCallActivityCommon.maybeShowErrorDialogOnDisconnect",
+        "disconnect cause: %s",
+        disconnectMessage);
 
     if (!inCallActivity.isFinishing()) {
-      if (EnableWifiCallingPrompt.shouldShowPrompt(cause)) {
-        Pair<Dialog, CharSequence> pair =
-            EnableWifiCallingPrompt.createDialog(inCallActivity, cause);
-        showErrorDialog(pair.first, pair.second);
-      } else if (shouldShowDisconnectErrorDialog(cause)) {
-        Pair<Dialog, CharSequence> pair = getDisconnectErrorDialog(inCallActivity, cause);
-        showErrorDialog(pair.first, pair.second);
+      if (disconnectMessage.dialog != null) {
+        showErrorDialog(disconnectMessage.dialog, disconnectMessage.toastMessage);
       }
     }
   }
@@ -557,23 +550,6 @@
     }
   }
 
-  private static boolean shouldShowDisconnectErrorDialog(@NonNull DisconnectCause cause) {
-    return !TextUtils.isEmpty(cause.getDescription())
-        && (cause.getCode() == DisconnectCause.ERROR
-            || cause.getCode() == DisconnectCause.RESTRICTED);
-  }
-
-  private static Pair<Dialog, CharSequence> getDisconnectErrorDialog(
-      @NonNull Context context, @NonNull DisconnectCause cause) {
-    CharSequence message = cause.getDescription();
-    Dialog dialog =
-        new AlertDialog.Builder(context)
-            .setMessage(message)
-            .setPositiveButton(android.R.string.ok, null)
-            .create();
-    return new Pair<>(dialog, message);
-  }
-
   private void showErrorDialog(Dialog dialog, CharSequence message) {
     LogUtil.i("InCallActivityCommon.showErrorDialog", "message: %s", message);
     inCallActivity.dismissPendingDialogs();
diff --git a/java/com/android/incallui/InCallPresenter.java b/java/com/android/incallui/InCallPresenter.java
index 0bfd67e..1528e7d 100644
--- a/java/com/android/incallui/InCallPresenter.java
+++ b/java/com/android/incallui/InCallPresenter.java
@@ -54,6 +54,7 @@
 import com.android.incallui.call.DialerCall;
 import com.android.incallui.call.ExternalCallList;
 import com.android.incallui.call.TelecomAdapter;
+import com.android.incallui.disconnectdialog.DisconnectMessage;
 import com.android.incallui.latencyreport.LatencyReport;
 import com.android.incallui.legacyblocking.BlockedNumberContentObserver;
 import com.android.incallui.spam.SpamCallListListener;
@@ -133,7 +134,9 @@
             android.telecom.Call telecomCall, String remainingPostDialSequence) {
           final DialerCall call = mCallList.getDialerCallFromTelecomCall(telecomCall);
           if (call == null) {
-            Log.w(this, "DialerCall not found in call list: " + telecomCall);
+            LogUtil.w(
+                "InCallPresenter.onPostDialWait",
+                "DialerCall not found in call list: " + telecomCall);
             return;
           }
           onPostDialCharWait(call.getId(), remainingPostDialSequence);
@@ -144,7 +147,9 @@
             android.telecom.Call telecomCall, android.telecom.Call.Details details) {
           final DialerCall call = mCallList.getDialerCallFromTelecomCall(telecomCall);
           if (call == null) {
-            Log.w(this, "DialerCall not found in call list: " + telecomCall);
+            LogUtil.w(
+                "InCallPresenter.onDetailsChanged",
+                "DialerCall not found in call list: " + telecomCall);
             return;
           }
 
@@ -152,7 +157,7 @@
               && !mExternalCallList.isCallTracked(telecomCall)) {
 
             // A regular call became an external call so swap call lists.
-            Log.i(this, "Call became external: " + telecomCall);
+            LogUtil.i("InCallPresenter.onDetailsChanged", "Call became external: " + telecomCall);
             mCallList.onInternalCallMadeExternal(mContext, telecomCall);
             mExternalCallList.onCallAdded(telecomCall);
             return;
@@ -166,7 +171,9 @@
         @Override
         public void onConferenceableCallsChanged(
             android.telecom.Call telecomCall, List<android.telecom.Call> conferenceableCalls) {
-          Log.i(this, "onConferenceableCallsChanged: " + telecomCall);
+          LogUtil.i(
+              "InCallPresenter.onConferenceableCallsChanged",
+              "onConferenceableCallsChanged: " + telecomCall);
           onDetailsChanged(telecomCall, telecomCall.getDetails());
         }
       };
@@ -289,7 +296,8 @@
 
       if ((call.getAccountHandle() == null
           && (phoneAccountHandles == null || phoneAccountHandles.isEmpty()))) {
-        Log.i(InCallPresenter.getInstance(), "No valid accounts for call " + call);
+        LogUtil.i(
+            "InCallPresenter.isCallWithNoValidAccounts", "No valid accounts for call " + call);
         return true;
       }
     }
@@ -314,7 +322,7 @@
       ProximitySensor proximitySensor,
       FilteredNumberAsyncQueryHandler filteredNumberQueryHandler) {
     if (mServiceConnected) {
-      Log.i(this, "New service connection replacing existing one.");
+      LogUtil.i("InCallPresenter.setUp", "New service connection replacing existing one.");
       if (context != mContext || callList != mCallList) {
         throw new IllegalStateException();
       }
@@ -362,7 +370,7 @@
         .getSystemService(TelephonyManager.class)
         .listen(mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
 
-    Log.d(this, "Finished InCallPresenter.setUp");
+    LogUtil.d("InCallPresenter.setUp", "Finished InCallPresenter.setUp");
   }
 
   /**
@@ -373,7 +381,7 @@
    * secondary method that performs the aforementioned logic.
    */
   public void tearDown() {
-    Log.d(this, "tearDown");
+    LogUtil.d("InCallPresenter.tearDown", "tearDown");
     mCallList.clearOnDisconnect();
 
     mServiceConnected = false;
@@ -388,7 +396,7 @@
 
   private void attemptFinishActivity() {
     final boolean doFinish = (mInCallActivity != null && isActivityStarted());
-    Log.i(this, "Hide in call UI: " + doFinish);
+    LogUtil.i("InCallPresenter.attemptFinishActivity", "Hide in call UI: " + doFinish);
     if (doFinish) {
       mInCallActivity.setExcludeFromRecents(true);
       mInCallActivity.finish();
@@ -404,12 +412,13 @@
       throw new IllegalArgumentException("unregisterActivity cannot be called with null");
     }
     if (mInCallActivity == null) {
-      Log.i(this, "No InCallActivity currently set, no need to unset.");
+      LogUtil.i(
+          "InCallPresenter.unsetActivity", "No InCallActivity currently set, no need to unset.");
       return;
     }
     if (mInCallActivity != inCallActivity) {
-      Log.w(
-          this,
+      LogUtil.w(
+          "InCallPresenter.unsetActivity",
           "Second instance of InCallActivity is trying to unregister when another"
               + " instance is active. Ignoring.");
       return;
@@ -428,7 +437,7 @@
     if (inCallActivity != null) {
       if (mInCallActivity == null) {
         updateListeners = true;
-        Log.i(this, "UI Initialized");
+        LogUtil.i("InCallPresenter.updateActivity", "UI Initialized");
       } else {
         // since setActivity is called onStart(), it can be called multiple times.
         // This is fine and ignorable, but we do not want to update the world every time
@@ -451,12 +460,12 @@
       // NOTE: This code relies on {@link #mInCallActivity} being set so we run it after
       // it has been set.
       if (mInCallState == InCallState.NO_CALLS) {
-        Log.i(this, "UI Initialized, but no calls left.  shut down.");
+        LogUtil.i("InCallPresenter.updateActivity", "UI Initialized, but no calls left. Shut down");
         attemptFinishActivity();
         return;
       }
     } else {
-      Log.i(this, "UI Destroyed");
+      LogUtil.i("InCallPresenter.updateActivity", "UI Destroyed");
       updateListeners = true;
       mInCallActivity = null;
 
@@ -496,7 +505,7 @@
   }
 
   public void onBringToForeground(boolean showDialpad) {
-    Log.i(this, "Bringing UI to foreground.");
+    LogUtil.i("InCallPresenter.onBringToForeground", "Bringing UI to foreground.");
     bringToForeground(showDialpad);
   }
 
@@ -529,11 +538,15 @@
       return false;
     }
     if (TelecomCallUtil.isEmergencyCall(call)) {
-      Log.i(this, "Not attempting to block incoming emergency call");
+      LogUtil.i(
+          "InCallPresenter.shouldAttemptBlocking",
+          "Not attempting to block incoming emergency call");
       return false;
     }
     if (FilteredNumbersUtil.hasRecentEmergencyCall(mContext)) {
-      Log.i(this, "Not attempting to block incoming call due to recent emergency call");
+      LogUtil.i(
+          "InCallPresenter.shouldAttemptBlocking",
+          "Not attempting to block incoming call due to recent emergency call");
       return false;
     }
     if (call.getDetails().hasProperty(CallCompat.Details.PROPERTY_IS_EXTERNAL_CALL)) {
@@ -583,7 +596,7 @@
           @Override
           public void onCheckComplete(final Integer id) {
             if (isReadyForTearDown()) {
-              Log.i(this, "InCallPresenter is torn down, not adding call");
+              LogUtil.i("InCallPresenter.onCheckComplete", "torn down, not adding call");
               return;
             }
             if (!hasTimedOut.get()) {
@@ -595,7 +608,8 @@
                 mCallList.onCallAdded(mContext, call, latencyReport);
               }
             } else if (id == FilteredNumberAsyncQueryHandler.INVALID_ID) {
-              Log.d(this, "checkForBlockedCall: invalid number, skipping block checking");
+              LogUtil.d(
+                  "InCallPresenter.onCheckComplete", "invalid number, skipping block checking");
               if (!hasTimedOut.get()) {
                 handler.removeCallbacks(runnable);
 
@@ -603,7 +617,8 @@
                 mCallList.onCallAdded(mContext, call, latencyReport);
               }
             } else {
-              Log.i(this, "Rejecting incoming call from blocked number");
+              LogUtil.i(
+                  "InCallPresenter.onCheckComplete", "Rejecting incoming call from blocked number");
               call.reject(false, null);
               Logger.get(mContext).logInteraction(InteractionEvent.Type.CALL_BLOCKED);
 
@@ -684,7 +699,9 @@
 
     InCallState newState = getPotentialStateFromCallList(callList);
     InCallState oldState = mInCallState;
-    Log.d(this, "onCallListChange oldState= " + oldState + " newState=" + newState);
+    LogUtil.d(
+        "InCallPresenter.onCallListChange",
+        "onCallListChange oldState= " + oldState + " newState=" + newState);
 
     // If the user placed a call and was asked to choose the account, but then pressed "Home", the
     // incall activity for that call will still exist (even if it's not visible). In the case of
@@ -702,15 +719,20 @@
     }
 
     newState = startOrFinishUi(newState);
-    Log.d(this, "onCallListChange newState changed to " + newState);
+    LogUtil.d(
+        "InCallPresenter.onCallListChange", "onCallListChange newState changed to " + newState);
 
     // Set the new state before announcing it to the world
-    Log.i(this, "Phone switching state: " + oldState + " -> " + newState);
+    LogUtil.i(
+        "InCallPresenter.onCallListChange",
+        "Phone switching state: " + oldState + " -> " + newState);
     mInCallState = newState;
 
     // notify listeners of new state
     for (InCallStateListener listener : mListeners) {
-      Log.d(this, "Notify " + listener + " of state " + mInCallState.toString());
+      LogUtil.d(
+          "InCallPresenter.onCallListChange",
+          "Notify " + listener + " of state " + mInCallState.toString());
       listener.onStateChange(oldState, mInCallState, callList);
     }
 
@@ -727,7 +749,8 @@
     InCallState newState = startOrFinishUi(InCallState.INCOMING);
     InCallState oldState = mInCallState;
 
-    Log.i(this, "Phone switching state: " + oldState + " -> " + newState);
+    LogUtil.i(
+        "InCallPresenter.onIncomingCall", "Phone switching state: " + oldState + " -> " + newState);
     mInCallState = newState;
 
     for (IncomingCallListener listener : mIncomingCallListeners) {
@@ -841,7 +864,9 @@
   }
 
   public void setBoundAndWaitingForOutgoingCall(boolean isBound, PhoneAccountHandle handle) {
-    Log.i(this, "setBoundAndWaitingForOutgoingCall: " + isBound);
+    LogUtil.i(
+        "InCallPresenter.setBoundAndWaitingForOutgoingCall",
+        "setBoundAndWaitingForOutgoingCall: " + isBound);
     mBoundAndWaitingForOutgoingCall = isBound;
     mThemeColorManager.setPendingPhoneAccountHandle(handle);
     if (isBound && mInCallState == InCallState.NO_CALLS) {
@@ -970,7 +995,9 @@
     if (mInCallActivity != null) {
       mIsChangingConfigurations = mInCallActivity.isChangingConfigurations();
     }
-    Log.v(this, "updateIsChangingConfigurations = " + mIsChangingConfigurations);
+    LogUtil.v(
+        "InCallPresenter.updateIsChangingConfigurations",
+        "updateIsChangingConfigurations = " + mIsChangingConfigurations);
   }
 
   /** Called when the activity goes in/out of the foreground. */
@@ -990,10 +1017,10 @@
       broadcastIntent.putExtra(EXTRA_FIRST_TIME_SHOWN, !mIsActivityPreviouslyStarted);
 
       if (showing) {
-        Log.d(this, "Sending sticky broadcast: ", broadcastIntent);
+        LogUtil.d("InCallPresenter.onUiShowing", "Sending sticky broadcast: ", broadcastIntent);
         mContext.sendStickyBroadcast(broadcastIntent);
       } else {
-        Log.d(this, "Removing sticky broadcast: ", broadcastIntent);
+        LogUtil.d("InCallPresenter.onUiShowing", "Removing sticky broadcast: ", broadcastIntent);
         mContext.removeStickyBroadcast(broadcastIntent);
       }
     }
@@ -1031,7 +1058,7 @@
 
   /*package*/
   void onActivityStarted() {
-    Log.d(this, "onActivityStarted");
+    LogUtil.d("InCallPresenter.onActivityStarted", "onActivityStarted");
     notifyVideoPauseController(true);
     if (mStatusBarNotifier != null) {
       // TODO - b/36649622: Investigate this redundant call
@@ -1041,13 +1068,14 @@
 
   /*package*/
   void onActivityStopped() {
-    Log.d(this, "onActivityStopped");
+    LogUtil.d("InCallPresenter.onActivityStopped", "onActivityStopped");
     notifyVideoPauseController(false);
   }
 
   private void notifyVideoPauseController(boolean showing) {
-    Log.d(
-        this, "notifyVideoPauseController: mIsChangingConfigurations=" + mIsChangingConfigurations);
+    LogUtil.d(
+        "InCallPresenter.notifyVideoPauseController",
+        "mIsChangingConfigurations=" + mIsChangingConfigurations);
     if (!mIsChangingConfigurations) {
       VideoPauseController.getInstance().onUiShowing(showing);
     }
@@ -1106,8 +1134,9 @@
       final boolean canSwap =
           activeCall.can(android.telecom.Call.Details.CAPABILITY_SWAP_CONFERENCE);
 
-      Log.v(
-          this, "activeCall: " + activeCall + ", canMerge: " + canMerge + ", canSwap: " + canSwap);
+      LogUtil.v(
+          "InCallPresenter.handleCallKey",
+          "activeCall: " + activeCall + ", canMerge: " + canMerge + ", canSwap: " + canSwap);
 
       // (2) Attempt actions on conference calls
       if (canMerge) {
@@ -1126,7 +1155,7 @@
       // there is no harm in double checking.
       final boolean canHold = heldCall.can(android.telecom.Call.Details.CAPABILITY_HOLD);
 
-      Log.v(this, "heldCall: " + heldCall + ", canHold: " + canHold);
+      LogUtil.v("InCallPresenter.handleCallKey", "heldCall: " + heldCall + ", canHold: " + canHold);
 
       // (4) unhold call
       if (heldCall.getState() == DialerCall.State.ONHOLD && canHold) {
@@ -1144,7 +1173,7 @@
    * checks to see if there should be any UI left and if not attempts to tear down the UI.
    */
   public void onDismissDialog() {
-    Log.i(this, "Dialog dismissed");
+    LogUtil.i("InCallPresenter.onDismissDialog", "Dialog dismissed");
     if (mInCallState == InCallState.NO_CALLS) {
       attemptFinishActivity();
       attemptCleanup();
@@ -1174,16 +1203,18 @@
    * @param force {@code true} if fullscreen mode should be set regardless of its current state.
    */
   public void setFullScreen(boolean isFullScreen, boolean force) {
-    Log.i(this, "setFullScreen = " + isFullScreen);
+    LogUtil.i("InCallPresenter.setFullScreen", "setFullScreen = " + isFullScreen);
 
     // As a safeguard, ensure we cannot enter fullscreen if the dialpad is shown.
     if (isDialpadVisible()) {
       isFullScreen = false;
-      Log.v(this, "setFullScreen overridden as dialpad is shown = " + isFullScreen);
+      LogUtil.v(
+          "InCallPresenter.setFullScreen",
+          "setFullScreen overridden as dialpad is shown = " + isFullScreen);
     }
 
     if (mIsFullScreen == isFullScreen && !force) {
-      Log.v(this, "setFullScreen ignored as already in that state.");
+      LogUtil.v("InCallPresenter.setFullScreen", "setFullScreen ignored as already in that state.");
       return;
     }
     mIsFullScreen = isFullScreen;
@@ -1219,7 +1250,8 @@
       if (call.getAccountHandle() == null && !call.isConferenceCall()) {
         setDisconnectCauseForMissingAccounts(call);
       }
-      mInCallActivity.maybeShowErrorDialogOnDisconnect(call.getDisconnectCause());
+      mInCallActivity.maybeShowErrorDialogOnDisconnect(
+          new DisconnectMessage(mInCallActivity, call));
     }
   }
 
@@ -1228,7 +1260,8 @@
    * UI needs to be started or finished depending on the new state and does it.
    */
   private InCallState startOrFinishUi(InCallState newState) {
-    Log.d(this, "startOrFinishUi: " + mInCallState + " -> " + newState);
+    LogUtil.d(
+        "InCallPresenter.startOrFinishUi", "startOrFinishUi: " + mInCallState + " -> " + newState);
 
     // TODO: Consider a proper state machine implementation
 
@@ -1310,7 +1343,9 @@
     // up so we aren't going to lose anything by avoiding a second startup here.
     boolean activityIsFinishing = mInCallActivity != null && !isActivityStarted();
     if (activityIsFinishing) {
-      Log.i(this, "Undo the state change: " + newState + " -> " + mInCallState);
+      LogUtil.i(
+          "InCallPresenter.startOrFinishUi",
+          "Undo the state change: " + newState + " -> " + mInCallState);
       return mInCallState;
     }
 
@@ -1325,10 +1360,10 @@
     }
 
     if (showCallUi || showAccountPicker) {
-      Log.i(this, "Start in call UI");
+      LogUtil.i("InCallPresenter.startOrFinishUi", "Start in call UI");
       showInCall(false /* showDialpad */, !showAccountPicker /* newOutgoingCall */);
     } else if (startIncomingCallSequence) {
-      Log.i(this, "Start Full Screen in call UI");
+      LogUtil.i("InCallPresenter.startOrFinishUi", "Start Full Screen in call UI");
 
       mStatusBarNotifier.updateNotification(mCallList);
     } else if (newState == InCallState.NO_CALLS) {
@@ -1381,7 +1416,7 @@
    */
   private void attemptCleanup() {
     if (isReadyForTearDown()) {
-      Log.i(this, "Cleaning up");
+      LogUtil.i("InCallPresenter.attemptCleanup", "Cleaning up");
 
       cleanupSurfaces();
 
@@ -1431,12 +1466,12 @@
       mInCallEventListeners.clear();
       mInCallUiListeners.clear();
 
-      Log.d(this, "Finished InCallPresenter.CleanUp");
+      LogUtil.d("InCallPresenter.attemptCleanup", "finished");
     }
   }
 
   public void showInCall(boolean showDialpad, boolean newOutgoingCall) {
-    Log.i(this, "Showing InCallActivity");
+    LogUtil.i("InCallPresenter.showInCall", "Showing InCallActivity");
     mContext.startActivity(
         InCallActivity.getIntent(
             mContext, showDialpad, newOutgoingCall, false /* forFullScreen */));
@@ -1507,12 +1542,14 @@
    *     InCallOrientationEventListener#SCREEN_ORIENTATION_270}).
    */
   public void onDeviceOrientationChange(@ScreenOrientation int orientation) {
-    Log.d(this, "onDeviceOrientationChange: orientation= " + orientation);
+    LogUtil.d(
+        "InCallPresenter.onDeviceOrientationChange",
+        "onDeviceOrientationChange: orientation= " + orientation);
 
     if (mCallList != null) {
       mCallList.notifyCallsOfDeviceRotation(orientation);
     } else {
-      Log.w(this, "onDeviceOrientationChange: CallList is null.");
+      LogUtil.w("InCallPresenter.onDeviceOrientationChange", "CallList is null.");
     }
 
     // Notify listeners of device orientation changed.
@@ -1530,16 +1567,18 @@
    */
   public void setInCallAllowsOrientationChange(boolean allowOrientationChange) {
     if (mInCallActivity == null) {
-      Log.e(this, "InCallActivity is null. Can't set requested orientation.");
+      LogUtil.e(
+          "InCallPresenter.setInCallAllowsOrientationChange",
+          "InCallActivity is null. Can't set requested orientation.");
       return;
     }
     mInCallActivity.setAllowOrientationChange(allowOrientationChange);
   }
 
   public void enableScreenTimeout(boolean enable) {
-    Log.v(this, "enableScreenTimeout: value=" + enable);
+    LogUtil.v("InCallPresenter.enableScreenTimeout", "enableScreenTimeout: value=" + enable);
     if (mInCallActivity == null) {
-      Log.e(this, "enableScreenTimeout: InCallActivity is null.");
+      LogUtil.e("InCallPresenter.enableScreenTimeout", "InCallActivity is null.");
       return;
     }
 
@@ -1600,7 +1639,8 @@
       throw new IllegalArgumentException("registerActivity cannot be called with null");
     }
     if (mInCallActivity != null && mInCallActivity != inCallActivity) {
-      Log.w(this, "Setting a second activity before destroying the first.");
+      LogUtil.w(
+          "InCallPresenter.setActivity", "Setting a second activity before destroying the first.");
     }
     updateActivity(inCallActivity);
   }
diff --git a/java/com/android/incallui/ReturnToCallController.java b/java/com/android/incallui/ReturnToCallController.java
index 9972e6f..33154c5 100644
--- a/java/com/android/incallui/ReturnToCallController.java
+++ b/java/com/android/incallui/ReturnToCallController.java
@@ -113,7 +113,6 @@
   private Bubble startNewBubble() {
     if (!Bubble.canShowBubbles(context)) {
       LogUtil.i("ReturnToCallController.startNewBubble", "can't show bubble, no permission");
-      context.startActivity(Bubble.getRequestPermissionIntent(context));
       return null;
     }
     Bubble returnToCallBubble = Bubble.createBubble(context, generateBubbleInfo());
diff --git a/java/com/android/incallui/VideoPauseController.java b/java/com/android/incallui/VideoPauseController.java
index 2595e2f..36c9ef3 100644
--- a/java/com/android/incallui/VideoPauseController.java
+++ b/java/com/android/incallui/VideoPauseController.java
@@ -66,11 +66,6 @@
     return sVideoPauseController;
   }
 
-  private boolean wasIncomingCall() {
-    return (mPrevCallState == DialerCall.State.CALL_WAITING
-        || mPrevCallState == DialerCall.State.INCOMING);
-  }
-
   /**
    * Determines if a call is in incoming/waiting state.
    *
@@ -198,7 +193,7 @@
     }
     final boolean canVideoPause = videoCanPause(call);
 
-    if ((wasIncomingCall() || wasDialing()) && canVideoPause && !mIsInBackground) {
+    if (canVideoPause && !mIsInBackground) {
       // Send resume request for the active call, if user rejects incoming call, ends dialing
       // call, or the call was previously in a paused state and UI is in the foreground.
       sendRequest(call, true);
diff --git a/java/com/android/incallui/contactgrid/res/values-uz/strings.xml b/java/com/android/incallui/contactgrid/res/values-uz/strings.xml
index a5ce1ca..f4569de 100644
--- a/java/com/android/incallui/contactgrid/res/values-uz/strings.xml
+++ b/java/com/android/incallui/contactgrid/res/values-uz/strings.xml
@@ -34,7 +34,7 @@
     <string name="contact_grid_incoming_wifi_video_request" msgid="4516902096577976768">"Bu foydalanuvchi Wi-Fi orqali video suhbatga o‘tishni so‘ramoqda:"</string>
     <string name="contact_grid_incoming_voice_call" msgid="7165853925114955346">"Kimdan qo‘ng‘iroq:"</string>
     <string name="contact_grid_incoming_work_call" msgid="837605505036615004">"Ish telefoniga kimdan qo‘ng‘iroq:"</string>
-    <string name="contact_grid_incoming_via_template" msgid="7747391077955623969">"Kiruvchi qo‘ng‘iroq (operator: <xliff:g id="PROVIDER_NAME">%s</xliff:g>)"</string>
+    <string name="contact_grid_incoming_via_template" msgid="7747391077955623969">"Kiruvchi chaqiruv (operator: <xliff:g id="PROVIDER_NAME">%s</xliff:g>)"</string>
     <string name="contact_grid_incoming_suspected_spam" msgid="285365265897630425">"Shubhali abonent"</string>
     <string name="contact_grid_callback_number" msgid="1284649030313415807">"Teskari qo‘ng‘iroq uchun raqam: <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
 </resources>
diff --git a/java/com/android/incallui/disconnectdialog/AndroidManifest.xml b/java/com/android/incallui/disconnectdialog/AndroidManifest.xml
new file mode 100644
index 0000000..eec9807
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/AndroidManifest.xml
@@ -0,0 +1,19 @@
+<!--
+  ~ Copyright (C) 2017 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
+  -->
+
+<manifest
+  package="com.android.incallui.disconnectdialog">
+</manifest>
diff --git a/java/com/android/incallui/disconnectdialog/DefaultErrorDialog.java b/java/com/android/incallui/disconnectdialog/DefaultErrorDialog.java
new file mode 100644
index 0000000..2ce2387
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/DefaultErrorDialog.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2017 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.incallui.disconnectdialog;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.Context;
+import android.support.annotation.NonNull;
+import android.telecom.DisconnectCause;
+import android.text.TextUtils;
+import android.util.Pair;
+import com.android.incallui.call.DialerCall;
+
+/** Default error dialog shown to user after disconnect. */
+public class DefaultErrorDialog implements DisconnectDialog {
+
+  @Override
+  public boolean shouldShow(DisconnectCause disconnectCause) {
+    return !TextUtils.isEmpty(disconnectCause.getDescription())
+        && (disconnectCause.getCode() == DisconnectCause.ERROR
+            || disconnectCause.getCode() == DisconnectCause.RESTRICTED);
+  }
+
+  @Override
+  public Pair<Dialog, CharSequence> createDialog(@NonNull Context context, DialerCall call) {
+    DisconnectCause disconnectCause = call.getDisconnectCause();
+    CharSequence message = disconnectCause.getDescription();
+
+    Dialog dialog =
+        new AlertDialog.Builder(context)
+            .setMessage(message)
+            .setPositiveButton(android.R.string.cancel, null)
+            .create();
+    return new Pair<>(dialog, message);
+  }
+}
diff --git a/java/com/android/incallui/disconnectdialog/DisconnectDialog.java b/java/com/android/incallui/disconnectdialog/DisconnectDialog.java
new file mode 100644
index 0000000..0b2b8cc
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/DisconnectDialog.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2017 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.incallui.disconnectdialog;
+
+import android.app.Dialog;
+import android.content.Context;
+import android.support.annotation.NonNull;
+import android.telecom.DisconnectCause;
+import android.util.Pair;
+import com.android.incallui.call.DialerCall;
+
+/** Interface for disconnect dialog. */
+public interface DisconnectDialog {
+
+  boolean shouldShow(DisconnectCause disconnectCause);
+
+  Pair<Dialog, CharSequence> createDialog(@NonNull Context context, DialerCall call);
+}
diff --git a/java/com/android/incallui/disconnectdialog/DisconnectMessage.java b/java/com/android/incallui/disconnectdialog/DisconnectMessage.java
new file mode 100644
index 0000000..97d58f2
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/DisconnectMessage.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2017 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.incallui.disconnectdialog;
+
+import android.app.Dialog;
+import android.content.Context;
+import android.telecom.DisconnectCause;
+import android.util.Pair;
+import com.android.incallui.call.DialerCall;
+import java.util.Locale;
+
+/**
+ * Wrapper class around @Code{android.telecom.DisconnectCause} to provide more information to user.
+ */
+public class DisconnectMessage {
+
+  // Disconnect dialog catalog. Default error dialog MUST be last one.
+  private static final DisconnectDialog[] DISCONNECT_DIALOGS =
+      new DisconnectDialog[] {
+        new EnableWifiCallingPrompt(), new VideoCallNotAvailablePrompt(), new DefaultErrorDialog()
+      };
+
+  public final Dialog dialog;
+  public final CharSequence toastMessage;
+  private final DisconnectCause cause;
+
+  public DisconnectMessage(Context context, DialerCall call) {
+    cause = call.getDisconnectCause();
+
+    for (DisconnectDialog disconnectDialog : DISCONNECT_DIALOGS) {
+      if (disconnectDialog.shouldShow(cause)) {
+        Pair<Dialog, CharSequence> pair = disconnectDialog.createDialog(context, call);
+        dialog = pair.first;
+        toastMessage = pair.second;
+        return;
+      }
+    }
+    dialog = null;
+    toastMessage = null;
+  }
+
+  @Override
+  public String toString() {
+    return String.format(
+        Locale.ENGLISH,
+        "DisconnectMessage {code: %d, description: %s, reason: %s, message: %s}",
+        cause.getCode(),
+        cause.getDescription(),
+        cause.getReason(),
+        toastMessage);
+  }
+}
diff --git a/java/com/android/incallui/wifi/EnableWifiCallingPrompt.java b/java/com/android/incallui/disconnectdialog/EnableWifiCallingPrompt.java
similarity index 73%
rename from java/com/android/incallui/wifi/EnableWifiCallingPrompt.java
rename to java/com/android/incallui/disconnectdialog/EnableWifiCallingPrompt.java
index 85603bf..da0c9d6 100644
--- a/java/com/android/incallui/wifi/EnableWifiCallingPrompt.java
+++ b/java/com/android/incallui/disconnectdialog/EnableWifiCallingPrompt.java
@@ -14,12 +14,11 @@
  * limitations under the License
  */
 
-package com.android.incallui.wifi;
+package com.android.incallui.disconnectdialog;
 
 import android.app.AlertDialog;
 import android.app.Dialog;
 import android.content.Context;
-import android.content.DialogInterface;
 import android.content.DialogInterface.OnClickListener;
 import android.content.Intent;
 import android.support.annotation.NonNull;
@@ -27,9 +26,10 @@
 import android.util.Pair;
 import com.android.dialer.common.Assert;
 import com.android.dialer.common.LogUtil;
+import com.android.incallui.call.DialerCall;
 
 /** Prompts the user to enable Wi-Fi calling. */
-public class EnableWifiCallingPrompt {
+public class EnableWifiCallingPrompt implements DisconnectDialog {
   // This is a hidden constant in android.telecom.DisconnectCause. Telecom sets this as a disconnect
   // reason if it wants us to prompt the user to enable Wi-Fi calling. In Android-O we might
   // consider using a more explicit way to signal this.
@@ -38,38 +38,33 @@
       "android.settings.WIFI_CALLING_SETTINGS";
   private static final String ANDROID_SETTINGS_PACKAGE = "com.android.settings";
 
-  public static boolean shouldShowPrompt(@NonNull DisconnectCause cause) {
-    Assert.isNotNull(cause);
-    if (cause.getReason() != null && cause.getReason().startsWith(REASON_WIFI_ON_BUT_WFC_OFF)) {
+  @Override
+  public boolean shouldShow(DisconnectCause disconnectCause) {
+    String reason = disconnectCause.getReason();
+    if (reason.startsWith(REASON_WIFI_ON_BUT_WFC_OFF)) {
       LogUtil.i(
           "EnableWifiCallingPrompt.shouldShowPrompt",
           "showing prompt for disconnect cause: %s",
-          cause);
+          reason);
       return true;
     }
     return false;
   }
 
-  @NonNull
-  public static Pair<Dialog, CharSequence> createDialog(
-      final @NonNull Context context, @NonNull DisconnectCause cause) {
+  @Override
+  public Pair<Dialog, CharSequence> createDialog(final @NonNull Context context, DialerCall call) {
     Assert.isNotNull(context);
-    Assert.isNotNull(cause);
+    DisconnectCause cause = call.getDisconnectCause();
     CharSequence message = cause.getDescription();
     Dialog dialog =
         new AlertDialog.Builder(context)
             .setMessage(message)
             .setPositiveButton(
                 R.string.incall_enable_wifi_calling_button,
-                new OnClickListener() {
-                  @Override
-                  public void onClick(DialogInterface dialog, int which) {
-                    openWifiCallingSettings(context);
-                  }
-                })
+                (OnClickListener) (dialog1, which) -> openWifiCallingSettings(context))
             .setNegativeButton(android.R.string.cancel, null)
             .create();
-    return new Pair<Dialog, CharSequence>(dialog, message);
+    return new Pair<>(dialog, message);
   }
 
   private static void openWifiCallingSettings(@NonNull Context context) {
@@ -77,6 +72,4 @@
     context.startActivity(
         new Intent(ACTION_WIFI_CALLING_SETTINGS).setPackage(ANDROID_SETTINGS_PACKAGE));
   }
-
-  private EnableWifiCallingPrompt() {}
 }
diff --git a/java/com/android/incallui/disconnectdialog/VideoCallNotAvailablePrompt.java b/java/com/android/incallui/disconnectdialog/VideoCallNotAvailablePrompt.java
new file mode 100644
index 0000000..34db976
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/VideoCallNotAvailablePrompt.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2017 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.incallui.disconnectdialog;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.Context;
+import android.content.Intent;
+import android.support.annotation.NonNull;
+import android.telecom.DisconnectCause;
+import android.telecom.PhoneAccountHandle;
+import android.util.Pair;
+import com.android.dialer.callintent.CallInitiationType;
+import com.android.dialer.callintent.CallIntentBuilder;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.util.DialerUtils;
+import com.android.incallui.call.DialerCall;
+
+/** Prompt user to make voice call if video call is not currently available. */
+public class VideoCallNotAvailablePrompt implements DisconnectDialog {
+
+  private static final String REASON_IMS_ACCESS_BLOCKED = "IMS_ACCESS_BLOCKED";
+
+  @Override
+  public boolean shouldShow(DisconnectCause disconnectCause) {
+    if (disconnectCause.getCode() == DisconnectCause.ERROR
+        && REASON_IMS_ACCESS_BLOCKED.equals(disconnectCause.getReason())) {
+      LogUtil.i(
+          "VideoCallNotAvailablePrompt.shouldShowPrompt",
+          "showing prompt for disconnect cause: %s",
+          disconnectCause.getReason());
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  @Override
+  public Pair<Dialog, CharSequence> createDialog(@NonNull Context context, DialerCall call) {
+    CharSequence title = context.getString(R.string.video_call_not_available_title);
+
+    Dialog dialog =
+        new AlertDialog.Builder(context)
+            .setTitle(title)
+            .setMessage(context.getString(R.string.video_call_not_available_message))
+            .setPositiveButton(
+                R.string.voice_call,
+                (dialog1, which) ->
+                    makeVoiceCall(context, call.getNumber(), call.getAccountHandle()))
+            .setNegativeButton(android.R.string.cancel, null)
+            .create();
+    return new Pair<>(dialog, title);
+  }
+
+  private void makeVoiceCall(Context context, String number, PhoneAccountHandle accountHandle) {
+    LogUtil.enterBlock("VideoCallNotAvailablePrompt.makeVoiceCall");
+    Intent intent =
+        new CallIntentBuilder(number, CallInitiationType.Type.IMS_VIDEO_BLOCKED_FALLBACK_TO_VOICE)
+            .setPhoneAccountHandle(accountHandle)
+            .build();
+    DialerUtils.startActivityWithErrorToast(context, intent);
+  }
+}
diff --git a/java/com/android/incallui/disconnectdialog/res/values-af/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-af/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-af/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-am/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-am/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-am/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-ar/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-ar/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-ar/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-az/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-az/strings.xml
new file mode 100644
index 0000000..5a72e4c
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-az/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Aktiv edin"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Video zəng hazırda əlçatan deyil"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Daha sonra yenidən cəhd edin və ya audio zənglə davam edin."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Video zəng"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-b+sr+Latn/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-b+sr+Latn/strings.xml
new file mode 100644
index 0000000..e782e70
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-b+sr+Latn/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Omogući"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Video poziv trenutno nije dostupan"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Probajte ponovo da uputite poziv kasnije ili ga nastavite kao audio poziv."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Audio poziv"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-be/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-be/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-be/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-bg/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-bg/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-bg/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-bn/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-bn/strings.xml
new file mode 100644
index 0000000..dd0297c
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-bn/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"সক্ষম করুন"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"ভিডিও কলিং বর্তমানে উপলব্ধ নয়"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"পরে আবার কল করার চেষ্টা করুন বা কলটিকে একটি ভয়েস কল হিসাবে চালিয়ে যান৷"</string>
+    <string name="voice_call" msgid="6748636104112578475">"ভয়েস কল"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-bs/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-bs/strings.xml
new file mode 100644
index 0000000..309427a
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-bs/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Omogući"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Videopozivanje trenutno nije dostupno"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Pozovite ponovo kasnije ili nastavite poziv kao glasovni poziv."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Glasovni poziv"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-ca/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-ca/strings.xml
new file mode 100644
index 0000000..dca9551
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-ca/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Activa"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Les videotrucades no estan disponibles actualment"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Torna-ho a provar més tard o continua com a trucada de veu."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Trucada de veu"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-cs/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-cs/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-cs/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-da/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-da/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-da/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-de/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-de/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-de/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-el/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-el/strings.xml
new file mode 100644
index 0000000..1e182be
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-el/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Ενεργοποίηση"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Η βιντεοκλήσεις δεν είναι προς το παρόν διαθέσιμες"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Δοκιμάστε να καλέσετε ξανά αργότερα ή συνεχίστε την κλήση ως φωνητική κλήση."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Φωνητική κλήση"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-en-rAU/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-en-rAU/strings.xml
new file mode 100644
index 0000000..4665e11
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-en-rAU/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Enable"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Video calling is currently not available"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Try calling again later or continue the call as a voice call."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Voice call"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-en-rGB/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-en-rGB/strings.xml
new file mode 100644
index 0000000..4665e11
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-en-rGB/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Enable"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Video calling is currently not available"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Try calling again later or continue the call as a voice call."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Voice call"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-en-rIN/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-en-rIN/strings.xml
new file mode 100644
index 0000000..4665e11
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-en-rIN/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Enable"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Video calling is currently not available"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Try calling again later or continue the call as a voice call."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Voice call"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-es-rUS/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-es-rUS/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-es-rUS/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-es/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-es/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-es/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-et/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-et/strings.xml
new file mode 100644
index 0000000..dae212d
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-et/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Luba"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Vidokõned pole praegu saadaval"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Proovige hiljem uuesti helistada või jätkake helistamist häälkõnena."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Häälkõne"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-eu/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-eu/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-eu/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-fa/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-fa/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-fa/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-fi/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-fi/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-fi/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-fr-rCA/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-fr-rCA/strings.xml
new file mode 100644
index 0000000..e2bd4b1
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-fr-rCA/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Activer"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Les appels vidéo ne sont pas disponibles pour le moment"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Essayez de rappeler plus tard ou passez à un appel vocal."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Appel vocal"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-fr/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-fr/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-fr/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-gl/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-gl/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-gl/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-gu/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-gu/strings.xml
new file mode 100644
index 0000000..28825da
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-gu/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"સક્ષમ કરો"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"વિડિઓ કૉલિંગ હાલમાં ઉપલબ્ધ નથી"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"પછીથી ફરી કૉલ કરવાનો પ્રયાસ કરો અથવા કૉલને વૉઇસ કૉલ તરીકે ચાલુ રાખો."</string>
+    <string name="voice_call" msgid="6748636104112578475">"વૉઇસ કૉલ"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-hi/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-hi/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-hi/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-hr/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-hr/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-hr/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-hu/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-hu/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-hu/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-hy/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-hy/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-hy/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-in/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-in/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-in/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-is/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-is/strings.xml
new file mode 100644
index 0000000..b16b431
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-is/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Kveikja"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Myndsímtal er ekki í boði sem stendur"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Prófaðu að hringja aftur seinna eða hringdu hefðbundið símtal í staðinn"</string>
+    <string name="voice_call" msgid="6748636104112578475">"Símtal"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-it/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-it/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-it/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-iw/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-iw/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-iw/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-ja/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-ja/strings.xml
new file mode 100644
index 0000000..8e196f2
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-ja/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"有効にする"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"ビデオハングアウトは現在利用できません"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"しばらくしてからもう一度試すか、音声通話で続けてください。"</string>
+    <string name="voice_call" msgid="6748636104112578475">"音声通話"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-ka/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-ka/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-ka/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-kk/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-kk/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-kk/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-km/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-km/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-km/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-kn/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-kn/strings.xml
new file mode 100644
index 0000000..384e92b
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-kn/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"ಸಕ್ರಿಯಗೊಳಿಸಿ"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"ವೀಡಿಯೊ ಕರೆ ಪ್ರಸ್ತುತವಾಗಿ ಲಭ್ಯವಿಲ್ಲ"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"ನಂತರ ಮತ್ತೆ ಕರೆ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿ ಅಥವಾ ಧ್ವನಿ ಕರೆಯಂತೆ ಕರೆಯನ್ನು ಮುಂದುವರಿಸಿ."</string>
+    <string name="voice_call" msgid="6748636104112578475">"ಧ್ವನಿ ಕರೆ"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-ko/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-ko/strings.xml
new file mode 100644
index 0000000..30e1565
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-ko/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"사용"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"현재 화상 통화를 사용할 수 없음"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"나중에 다시 전화하거나, 계속하려면 음성 통화를 이용하세요."</string>
+    <string name="voice_call" msgid="6748636104112578475">"음성 통화"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-ky/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-ky/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-ky/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-lo/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-lo/strings.xml
new file mode 100644
index 0000000..c3f8b96
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-lo/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"ເປິດນຳໃຊ້"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"ຕອນນີ້ບໍ່ສາມາດໃຊ້ການໂທວິດີໂອໄດ້"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"ກະລຸນາລອງໂທໃໝ່ໃນພາຍຫຼັງ ຫຼື ສືບຕໍ່ສາຍເປັນການໂທແບບສຽງ."</string>
+    <string name="voice_call" msgid="6748636104112578475">"ການໂທດ້ວຍສຽງ"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-lt/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-lt/strings.xml
new file mode 100644
index 0000000..38d6ef8
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-lt/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Įgalinti"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Vaizdo skambučių funkcija šiuo metu nepasiekiama"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Vėliau pabandykite skambinti dar kartą arba tęskite skambutį kaip balso skambutį."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Balso skambutis"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-lv/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-lv/strings.xml
new file mode 100644
index 0000000..279f0f5
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-lv/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Iespējot"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Videozvani pašlaik nav pieejami"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Vēlāk mēģiniet zvanīt vēlreiz vai turpiniet sarunu kā balss zvanu."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Balss zvans"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-mk/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-mk/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-mk/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-ml/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-ml/strings.xml
new file mode 100644
index 0000000..719d6e8
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-ml/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"പ്രവർത്തനക്ഷമമാക്കുക"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"വീഡിയോ കോളിംഗ് നിലവിൽ ലഭ്യമല്ല"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"പിന്നീട് വീണ്ടും വിളിക്കുന്നതോ വോയ്‌സ് കോളായി കോൾ തുടരുന്നതോ പരീക്ഷിക്കൂ."</string>
+    <string name="voice_call" msgid="6748636104112578475">"വോയ്‌സ് കോൾ"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-mn/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-mn/strings.xml
new file mode 100644
index 0000000..fae6708
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-mn/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Идэвхжүүлэх"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Одоогоор видео дуудлага хийх боломжгүй"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Дараа дахин залгаж үзэх буюу энгийн дуудлагаар үргэлжлүүлнэ үү."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Дуудлага"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-mr/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-mr/strings.xml
new file mode 100644
index 0000000..8549785
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-mr/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"चालू करा"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"व्हिडिओ कॉलिंग सध्या उपलब्ध नाही"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"नंतर पुन्हा कॉल करून पहा किंवा कॉल व्हॉइस कॉल म्हणून सुरू ठेवा."</string>
+    <string name="voice_call" msgid="6748636104112578475">"व्हॉईस कॉल"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-ms/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-ms/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-ms/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-my/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-my/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-my/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-nb/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-nb/strings.xml
new file mode 100644
index 0000000..14a41fa
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-nb/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Slå på"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Videoanrop er ikke tilgjengelige akkurat nå"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Prøv å ringe på nytt senere eller fortsett anropet som taleanrop."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Taleanrop"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-ne/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-ne/strings.xml
new file mode 100644
index 0000000..9cc63fd
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-ne/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"सक्षम पार्नुहोस्"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"भिडियो कल हाल उपलब्ध छैन"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"पछि फेरि कल गर्ने प्रयास गर्नुहोस् वा भ्वाइस कलका रूपमा कल जारी राख्नुहोस्।"</string>
+    <string name="voice_call" msgid="6748636104112578475">"भ्वाइस कल"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-nl/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-nl/strings.xml
new file mode 100644
index 0000000..c3380db
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-nl/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Inschakelen"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Videobellen is momenteel niet beschikbaar"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Probeer later opnieuw te bellen of start een spraakoproep."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Spraakoproep"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-no/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-no/strings.xml
new file mode 100644
index 0000000..14a41fa
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-no/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Slå på"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Videoanrop er ikke tilgjengelige akkurat nå"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Prøv å ringe på nytt senere eller fortsett anropet som taleanrop."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Taleanrop"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-pa/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-pa/strings.xml
new file mode 100644
index 0000000..722183b
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-pa/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"ਯੋਗ ਬਣਾਓ"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"ਵੀਡੀਓ ਕਾਲਿੰਗ ਇਸ ਵੇਲੇ ਉਪਲਬਧ ਨਹੀਂ ਹੈ"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"ਬਾਅਦ ਵਿੱਚ ਦੁਬਾਰਾ ਕਾਲ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ ਜਾਂ ਕਾਲ ਨੂੰ ਵੌਇਸ ਕਾਲ ਵਜੋਂ ਜਾਰੀ ਰੱਖੋ।"</string>
+    <string name="voice_call" msgid="6748636104112578475">"ਵੌਇਸ ਕਾਲ"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-pl/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-pl/strings.xml
new file mode 100644
index 0000000..b8307e9
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-pl/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Włącz"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Rozmowy wideo nie są obecnie dostępne"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Spróbuj zadzwonić później, aby kontynuować rozmowę w trybie wideo."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Połączenie głosowe"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-pt-rBR/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-pt-rBR/strings.xml
new file mode 100644
index 0000000..ce249f6
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-pt-rBR/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Ativar"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"O recurso de videochamada não está disponível no momento"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Ligue novamente mais tarde ou continue esta chamada sem o vídeo."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Chamada de voz"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-pt-rPT/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-pt-rPT/strings.xml
new file mode 100644
index 0000000..7d11ede
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-pt-rPT/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Ativar"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Neste momento, as videochamadas não estão disponíveis"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Experimente efetuar a videochamada mais tarde ou continue a chamada como uma chamada de voz."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Chamada de voz"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-pt/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-pt/strings.xml
new file mode 100644
index 0000000..ce249f6
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-pt/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Ativar"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"O recurso de videochamada não está disponível no momento"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Ligue novamente mais tarde ou continue esta chamada sem o vídeo."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Chamada de voz"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-ro/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-ro/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-ro/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-ru/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-ru/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-ru/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-si/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-si/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-si/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-sk/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-sk/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-sk/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-sl/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-sl/strings.xml
new file mode 100644
index 0000000..6afd14c
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-sl/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Omogoči"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Videoklicanje trenutno ni na voljo"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Poskusite klicati znova pozneje ali pa klic nadaljujte kot glasovni klic."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Glasovni klic"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-sq/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-sq/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-sq/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-sr/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-sr/strings.xml
new file mode 100644
index 0000000..620c39e
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-sr/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Омогући"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Видео позив тренутно није доступан"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Пробајте поново да упутите позив касније или га наставите као аудио позив."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Аудио позив"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-sv/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-sv/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-sv/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-sw/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-sw/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-sw/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-ta/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-ta/strings.xml
new file mode 100644
index 0000000..626d0d6
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-ta/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"இயக்கு"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"தற்போது வீடியோவில் அழைக்க முடியாது"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"பிறகு அழைக்க முயற்சிக்கவும் அல்லது குரல் அழைப்பைச் செய்யவும்."</string>
+    <string name="voice_call" msgid="6748636104112578475">"குரல் அழைப்பு"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-te/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-te/strings.xml
new file mode 100644
index 0000000..737d677
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-te/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"ప్రారంభించు"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"ప్రస్తుతం వీడియో కాలింగ్ అందుబాటులో లేదు"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"మళ్లీ కాల్ చేసి ప్రయత్నించండి లేదా కాల్‌ను వాయిస్ కాల్ వలె కొనసాగించండి."</string>
+    <string name="voice_call" msgid="6748636104112578475">"వాయిస్ కాల్"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-th/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-th/strings.xml
new file mode 100644
index 0000000..a6fa2b1
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-th/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"เปิดใช้"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"วิดีโอคอลไม่พร้อมใช้งานในตอนนี้"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"ลองโทรอีกครั้งในภายหลัง หรือโทรด้วยเสียงต่อไป"</string>
+    <string name="voice_call" msgid="6748636104112578475">"การโทรด้วยเสียง"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-tl/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-tl/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-tl/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-tr/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-tr/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-tr/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-uk/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-uk/strings.xml
new file mode 100644
index 0000000..36a3c45
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-uk/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Увімкнути"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Наразі не можна здійснювати відеодзвінки"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Спробуйте пізніше або перейдіть у режим голосового дзвінка."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Голосовий дзвінок"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-ur/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-ur/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-ur/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-uz/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-uz/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-uz/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-vi/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-vi/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-vi/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-zh-rCN/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-zh-rCN/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-zh-rCN/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-zh-rHK/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-zh-rHK/strings.xml
new file mode 100644
index 0000000..605c847
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-zh-rHK/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"啟用"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"視像通話目前無法使用"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"請稍後再撥，或是以語音通話的形式繼續通話。"</string>
+    <string name="voice_call" msgid="6748636104112578475">"語音通話"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-zh-rTW/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-zh-rTW/strings.xml
new file mode 100644
index 0000000..dae2426
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-zh-rTW/strings.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for incall_enable_wifi_calling_button (3295230556186542328) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_title (987490011944013201) -->
+    <skip />
+    <!-- no translation found for video_call_not_available_message (2284146863894603221) -->
+    <skip />
+    <!-- no translation found for voice_call (6748636104112578475) -->
+    <skip />
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values-zu/strings.xml b/java/com/android/incallui/disconnectdialog/res/values-zu/strings.xml
new file mode 100644
index 0000000..1c0dd48
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values-zu/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+  ~ Copyright (C) 2017 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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="incall_enable_wifi_calling_button" msgid="3295230556186542328">"Nika amandla"</string>
+    <string name="video_call_not_available_title" msgid="987490011944013201">"Ukushaya kwevidiyo manje akutholakali"</string>
+    <string name="video_call_not_available_message" msgid="2284146863894603221">"Zama ukushaya emuva kwesikhathi noma qhuba ikholi njengekholi yezwi."</string>
+    <string name="voice_call" msgid="6748636104112578475">"Ikholi yezwi"</string>
+</resources>
diff --git a/java/com/android/incallui/disconnectdialog/res/values/strings.xml b/java/com/android/incallui/disconnectdialog/res/values/strings.xml
new file mode 100644
index 0000000..91389db
--- /dev/null
+++ b/java/com/android/incallui/disconnectdialog/res/values/strings.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 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
+  -->
+
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+
+  <!-- Button to enable Wi-Fi calling. This is displayed in a dialog after a phone call disconnects
+      because there is no cellular service.
+      [CHAR LIMIT=20] -->
+  <string name="incall_enable_wifi_calling_button">Enable</string>
+
+  <!-- Title of alert dialog displayed when video call is not available. [CHAR LIMIT=NONE] -->
+  <string name="video_call_not_available_title">Video calling is currently not available</string>
+  <!-- Message of alert dialog displayed when video call is not available. [CHAR LIMIT=NONE] -->
+  <string name="video_call_not_available_message">Try calling again later or continue the call as a voice call.</string>
+  <!-- Voice call button label of alert dialog displayed when video call is not available. [CHAR LIMIT=20] -->
+  <string name="voice_call">Voice call</string>
+
+</resources>
diff --git a/java/com/android/incallui/incall/impl/InCallFragment.java b/java/com/android/incallui/incall/impl/InCallFragment.java
index e102ee0..54d01e7 100644
--- a/java/com/android/incallui/incall/impl/InCallFragment.java
+++ b/java/com/android/incallui/incall/impl/InCallFragment.java
@@ -41,6 +41,8 @@
 import com.android.dialer.common.Assert;
 import com.android.dialer.common.FragmentUtils;
 import com.android.dialer.common.LogUtil;
+import com.android.dialer.logging.DialerImpression;
+import com.android.dialer.logging.Logger;
 import com.android.dialer.multimedia.MultimediaData;
 import com.android.dialer.widget.LockableViewPager;
 import com.android.incallui.audioroute.AudioRouteSelectorDialogFragment;
@@ -385,6 +387,10 @@
         show);
     if (isSupportedButton(buttonId)) {
       getButtonController(buttonId).setAllowed(show);
+      if (buttonId == InCallButtonIds.BUTTON_UPGRADE_TO_VIDEO && show) {
+        Logger.get(getContext())
+            .logImpression(DialerImpression.Type.UPGRADE_TO_VIDEO_CALL_BUTTON_SHOWN);
+      }
     }
   }
 
diff --git a/java/com/android/incallui/res/values-pl/strings.xml b/java/com/android/incallui/res/values-pl/strings.xml
index 451c8ba..cb27c73 100644
--- a/java/com/android/incallui/res/values-pl/strings.xml
+++ b/java/com/android/incallui/res/values-pl/strings.xml
@@ -76,7 +76,7 @@
     <string name="incall_error_out_of_service" msgid="5027539470868484145">"Sieć komórkowa jest niedostępna."</string>
     <string name="incall_error_no_phone_number_supplied" msgid="293343960362630925">"Aby zadzwonić, wybierz prawidłowy numer."</string>
     <string name="incall_error_call_failed" msgid="5560521345862514733">"Nie można dzwonić."</string>
-    <string name="incall_status_dialed_mmi" msgid="3341365334358686873">"Rozpoczynanie sekwencji MMI..."</string>
+    <string name="incall_status_dialed_mmi" msgid="3341365334358686873">"Uruchamiam sekwencję MMI..."</string>
     <string name="incall_error_supp_service_unknown" msgid="3062751096566282959">"Usługa nie jest obsługiwana."</string>
     <string name="incall_error_supp_service_switch" msgid="759346040980722884">"Nie można przełączyć połączeń."</string>
     <string name="incall_error_supp_service_separate" msgid="5250304200901095519">"Nie można rozdzielić połączenia."</string>
diff --git a/java/com/android/incallui/res/values-uz/strings.xml b/java/com/android/incallui/res/values-uz/strings.xml
index 26120f1..2341da3 100644
--- a/java/com/android/incallui/res/values-uz/strings.xml
+++ b/java/com/android/incallui/res/values-uz/strings.xml
@@ -31,7 +31,7 @@
     <string name="voicemail_settings_number_label" msgid="8935904934161608885">"Ovozli pochta raqami"</string>
     <string name="notification_dialing" msgid="9072177265772083826">"Raqam terilmoqda"</string>
     <string name="notification_missedCallTicker" msgid="238492086972857643">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g> chaqiruvi javobsiz qoldi"</string>
-    <string name="notification_ongoing_call" msgid="8712641937577776125">"Joriy qo‘ng‘iroq"</string>
+    <string name="notification_ongoing_call" msgid="8712641937577776125">"Joriy chaqiruv"</string>
     <string name="notification_ongoing_work_call" msgid="3189581218078981547">"Chiquvchi ishchi qo‘ng‘irog‘i"</string>
     <string name="notification_ongoing_call_wifi" msgid="4393238962909277019">"Joriy Wi-Fi qo‘ng‘iroq"</string>
     <string name="notification_ongoing_work_call_wifi" msgid="3169378605818323964">"Joriy Wi-Fi qo‘ng‘iroq (ish)"</string>
@@ -55,9 +55,9 @@
     <string name="important_notification_incoming_call_with_photo_message_location" msgid="513692941317253479">"Surat, xabar va joy. ax. ega muhim kiruv. chaqiruv"</string>
     <string name="important_notification_incoming_call_attachments" msgid="4594375776340303751">"Biriktirmalarga ega muhim kiruvchi chaqiruv"</string>
     <string name="notification_incoming_work_call" msgid="5291275092734261918">"Kiruvchi ishchi qo‘ng‘irog‘i"</string>
-    <string name="notification_incoming_call_wifi" msgid="1020138378061234203">"Kiruvchi Wi-Fi qo‘ng‘iroq"</string>
-    <string name="notification_incoming_work_call_wifi" msgid="3549264481033044684">"Kiruvchi Wi-Fi qo‘ng‘iroq (ish)"</string>
-    <string name="notification_incoming_spam_call" msgid="7591506944666791937">"Shubhali kiruvchi qo‘ng‘iroq"</string>
+    <string name="notification_incoming_call_wifi" msgid="1020138378061234203">"Kiruvchi Wi-Fi chaqiruv"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3549264481033044684">"Kiruvchi Wi-Fi chaqiruv (ish)"</string>
+    <string name="notification_incoming_spam_call" msgid="7591506944666791937">"Kiruvchi chaqiruv: shubhali spam"</string>
     <string name="notification_requesting_video_call" msgid="1807679328811515758">"Kiruvchi video so\'rovi"</string>
     <string name="notification_network_selection_title" msgid="8639159088474275747">"Xizmat mavjud emas"</string>
     <string name="notification_network_selection_text" msgid="7190860774239009625">"Tanlangan tarmoq (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) mavjud emas"</string>
diff --git a/java/com/android/incallui/sessiondata/res/layout/fragment_composer_text.xml b/java/com/android/incallui/sessiondata/res/layout/fragment_composer_text.xml
index d2147ea..b93db63 100644
--- a/java/com/android/incallui/sessiondata/res/layout/fragment_composer_text.xml
+++ b/java/com/android/incallui/sessiondata/res/layout/fragment_composer_text.xml
@@ -16,29 +16,34 @@
   -->
 
 <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
     android:paddingTop="16dp"
     android:paddingStart="@dimen/answer_message_margin_start_end"
     android:paddingEnd="@dimen/answer_message_margin_start_end">
 
-  <TextView
+  <android.support.v7.widget.AppCompatTextView
       android:id="@id/answer_message_text"
-      android:layout_width="match_parent"
+      android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:layout_marginTop="@dimen/answer_message_contents_margin_top"
       android:layout_marginBottom="4dp"
       android:layout_centerHorizontal="true"
       android:layout_alignTop="@+id/answer_message_avatar"
-      android:paddingTop="44dp"
-      android:paddingBottom="44dp"
-      android:paddingStart="18dp"
-      android:paddingEnd="18dp"
-      android:background="@drawable/answer_text_only_background"
       android:elevation="@dimen/answer_data_elevation"
-      android:gravity="center_horizontal"
+      android:gravity="center"
+      android:paddingTop="22dp"
+      android:paddingBottom="22dp"
+      android:paddingStart="32dp"
+      android:paddingEnd="32dp"
+      android:minHeight="108dp"
+      android:lineSpacingMultiplier="1.2"
       android:textColor="@color/background_dialer_white"
-      android:textAppearance="@style/Dialer.Incall.TextAppearance.Message"/>
+      android:textAppearance="@style/Dialer.Incall.TextAppearance.Message"
+      android:background="@drawable/answer_text_only_background"
+      app:autoSizeTextType="uniform"
+      app:autoSizeMaxTextSize="44sp"/>
 
   <ImageView
       android:id="@id/answer_message_avatar"
diff --git a/java/com/android/incallui/videotech/ims/ImsVideoCallCallback.java b/java/com/android/incallui/videotech/ims/ImsVideoCallCallback.java
index f4e0a01..b839293 100644
--- a/java/com/android/incallui/videotech/ims/ImsVideoCallCallback.java
+++ b/java/com/android/incallui/videotech/ims/ImsVideoCallCallback.java
@@ -173,11 +173,9 @@
     switch (event) {
       case Connection.VideoProvider.SESSION_EVENT_RX_PAUSE:
         LogUtil.i("ImsVideoCallCallback.onCallSessionEvent", "rx_pause");
-        videoTech.onPausedEvent();
         break;
       case Connection.VideoProvider.SESSION_EVENT_RX_RESUME:
         LogUtil.i("ImsVideoCallCallback.onCallSessionEvent", "rx_resume");
-        videoTech.onResumedEvent();
         break;
       case Connection.VideoProvider.SESSION_EVENT_CAMERA_FAILURE:
         LogUtil.i("ImsVideoCallCallback.onCallSessionEvent", "camera_failure");
diff --git a/java/com/android/incallui/videotech/ims/ImsVideoTech.java b/java/com/android/incallui/videotech/ims/ImsVideoTech.java
index 3d73e4e..8fa983a 100644
--- a/java/com/android/incallui/videotech/ims/ImsVideoTech.java
+++ b/java/com/android/incallui/videotech/ims/ImsVideoTech.java
@@ -19,7 +19,6 @@
 import android.content.Context;
 import android.os.Build;
 import android.support.annotation.Nullable;
-import android.support.annotation.VisibleForTesting;
 import android.telecom.Call;
 import android.telecom.Call.Details;
 import android.telecom.VideoProfile;
@@ -27,6 +26,7 @@
 import com.android.dialer.common.LogUtil;
 import com.android.dialer.logging.DialerImpression;
 import com.android.dialer.logging.LoggingBindings;
+import com.android.dialer.util.CallUtil;
 import com.android.incallui.video.protocol.VideoCallScreen;
 import com.android.incallui.video.protocol.VideoCallScreenDelegate;
 import com.android.incallui.videotech.VideoTech;
@@ -41,8 +41,13 @@
   private @SessionModificationState int sessionModificationState =
       SessionModificationState.NO_REQUEST;
   private int previousVideoState = VideoProfile.STATE_AUDIO_ONLY;
+  private boolean paused = false;
 
-  @VisibleForTesting boolean paused = false;
+  // Hold onto a flag of whether or not stopTransmission was called but resumeTransmission has not
+  // been. This is needed because there is time between calling stopTransmission and
+  // call.getDetails().getVideoState() reflecting the change. During that time, pause() and
+  // unpause() will send the incorrect VideoProfile.
+  private boolean transmissionStopped = false;
 
   public ImsVideoTech(LoggingBindings logger, VideoTechListener listener, Call call) {
     this.logger = logger;
@@ -56,12 +61,31 @@
       return false;
     }
 
-    boolean hasCapabilities =
-        call.getDetails().can(Call.Details.CAPABILITY_SUPPORTS_VT_LOCAL_TX)
-            && call.getDetails().can(Call.Details.CAPABILITY_SUPPORTS_VT_REMOTE_RX);
+    if (call.getVideoCall() == null) {
+      return false;
+    }
 
-    return call.getVideoCall() != null
-        && (hasCapabilities || VideoProfile.isVideo(call.getDetails().getVideoState()));
+    // We are already in an IMS video call
+    if (VideoProfile.isVideo(call.getDetails().getVideoState())) {
+      return true;
+    }
+
+    // The user has disabled IMS video calling in system settings
+    if (!CallUtil.isVideoEnabled(context)) {
+      return false;
+    }
+
+    // The current call doesn't support transmitting video
+    if (!call.getDetails().can(Call.Details.CAPABILITY_SUPPORTS_VT_LOCAL_TX)) {
+      return false;
+    }
+
+    // The current call remote device doesn't support receiving video
+    if (!call.getDetails().can(Call.Details.CAPABILITY_SUPPORTS_VT_REMOTE_RX)) {
+      return false;
+    }
+
+    return true;
   }
 
   @Override
@@ -189,6 +213,8 @@
   public void stopTransmission() {
     LogUtil.enterBlock("ImsVideoTech.stopTransmission");
 
+    transmissionStopped = true;
+
     int unpausedVideoState = getUnpausedVideoState(call.getDetails().getVideoState());
     call.getVideoCall()
         .sendSessionModifyRequest(
@@ -199,6 +225,8 @@
   public void resumeTransmission() {
     LogUtil.enterBlock("ImsVideoTech.resumeTransmission");
 
+    transmissionStopped = false;
+
     int unpausedVideoState = getUnpausedVideoState(call.getDetails().getVideoState());
     call.getVideoCall()
         .sendSessionModifyRequest(
@@ -212,6 +240,10 @@
       LogUtil.i("ImsVideoTech.pause", "sending pause request");
       paused = true;
       int pausedVideoState = call.getDetails().getVideoState() | VideoProfile.STATE_PAUSED;
+      if (transmissionStopped && VideoProfile.isTransmissionEnabled(pausedVideoState)) {
+        LogUtil.i("ImsVideoTech.pause", "overriding TX to false due to user request");
+        pausedVideoState &= ~VideoProfile.STATE_TX_ENABLED;
+      }
       call.getVideoCall().sendSessionModifyRequest(new VideoProfile(pausedVideoState));
     } else {
       LogUtil.i(
@@ -228,6 +260,10 @@
       LogUtil.i("ImsVideoTech.unpause", "sending unpause request");
       paused = false;
       int unpausedVideoState = getUnpausedVideoState(call.getDetails().getVideoState());
+      if (transmissionStopped && VideoProfile.isTransmissionEnabled(unpausedVideoState)) {
+        LogUtil.i("ImsVideoTech.unpause", "overriding TX to false due to user request");
+        unpausedVideoState &= ~VideoProfile.STATE_TX_ENABLED;
+      }
       call.getVideoCall().sendSessionModifyRequest(new VideoProfile(unpausedVideoState));
     } else {
       LogUtil.i(
@@ -249,24 +285,6 @@
     call.getVideoCall().setDeviceOrientation(rotation);
   }
 
-  /**
-   * Called when we receive an rx_pause from the IMS stack. Update our state so we know we are
-   * currently paused. This is important in the cases where we swap calls since pause() and
-   * unpause() are not called.
-   */
-  void onPausedEvent() {
-    paused = true;
-  }
-
-  /**
-   * Called when we receive an rx_resume from the IMS stack. Update our state so we know we are
-   * currently not paused. This is important in the cases where we swap calls since pause() and
-   * unpause() are not called.
-   */
-  void onResumedEvent() {
-    paused = false;
-  }
-
   private boolean canPause() {
     return call.getDetails().can(Details.CAPABILITY_CAN_PAUSE_VIDEO)
         && call.getState() == Call.STATE_ACTIVE
diff --git a/java/com/android/incallui/wifi/AndroidManifest.xml b/java/com/android/incallui/wifi/AndroidManifest.xml
deleted file mode 100644
index 843f8f3..0000000
--- a/java/com/android/incallui/wifi/AndroidManifest.xml
+++ /dev/null
@@ -1,3 +0,0 @@
-<manifest
-  package="com.android.incallui.wifi">
-</manifest>
diff --git a/java/com/android/incallui/wifi/res/values-af/strings.xml b/java/com/android/incallui/wifi/res/values-af/strings.xml
deleted file mode 100644
index d9df5c6..0000000
--- a/java/com/android/incallui/wifi/res/values-af/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Aktiveer"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-am/strings.xml b/java/com/android/incallui/wifi/res/values-am/strings.xml
deleted file mode 100644
index 1aa5673..0000000
--- a/java/com/android/incallui/wifi/res/values-am/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"አንቃ"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-ar/strings.xml b/java/com/android/incallui/wifi/res/values-ar/strings.xml
deleted file mode 100644
index 972cd37..0000000
--- a/java/com/android/incallui/wifi/res/values-ar/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"تمكين"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-az/strings.xml b/java/com/android/incallui/wifi/res/values-az/strings.xml
deleted file mode 100644
index 46bbda1..0000000
--- a/java/com/android/incallui/wifi/res/values-az/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Aktiv edin"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-b+sr+Latn/strings.xml b/java/com/android/incallui/wifi/res/values-b+sr+Latn/strings.xml
deleted file mode 100644
index 51a57e4..0000000
--- a/java/com/android/incallui/wifi/res/values-b+sr+Latn/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Omogući"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-be/strings.xml b/java/com/android/incallui/wifi/res/values-be/strings.xml
deleted file mode 100644
index a8277a1..0000000
--- a/java/com/android/incallui/wifi/res/values-be/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Уключыць"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-bg/strings.xml b/java/com/android/incallui/wifi/res/values-bg/strings.xml
deleted file mode 100644
index ff5b94d..0000000
--- a/java/com/android/incallui/wifi/res/values-bg/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Активиране"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-bn/strings.xml b/java/com/android/incallui/wifi/res/values-bn/strings.xml
deleted file mode 100644
index 94e84c3..0000000
--- a/java/com/android/incallui/wifi/res/values-bn/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"সক্ষম করুন"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-bs/strings.xml b/java/com/android/incallui/wifi/res/values-bs/strings.xml
deleted file mode 100644
index 51a57e4..0000000
--- a/java/com/android/incallui/wifi/res/values-bs/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Omogući"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-ca/strings.xml b/java/com/android/incallui/wifi/res/values-ca/strings.xml
deleted file mode 100644
index 8af77c9..0000000
--- a/java/com/android/incallui/wifi/res/values-ca/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Activa"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-cs/strings.xml b/java/com/android/incallui/wifi/res/values-cs/strings.xml
deleted file mode 100644
index b057d1c..0000000
--- a/java/com/android/incallui/wifi/res/values-cs/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Zapnout"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-da/strings.xml b/java/com/android/incallui/wifi/res/values-da/strings.xml
deleted file mode 100644
index 81f837f..0000000
--- a/java/com/android/incallui/wifi/res/values-da/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Aktivér"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-de/strings.xml b/java/com/android/incallui/wifi/res/values-de/strings.xml
deleted file mode 100644
index d6dda7e..0000000
--- a/java/com/android/incallui/wifi/res/values-de/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Aktivieren"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-el/strings.xml b/java/com/android/incallui/wifi/res/values-el/strings.xml
deleted file mode 100644
index c181743..0000000
--- a/java/com/android/incallui/wifi/res/values-el/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Ενεργοποίηση"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-en-rAU/strings.xml b/java/com/android/incallui/wifi/res/values-en-rAU/strings.xml
deleted file mode 100644
index 6877c49..0000000
--- a/java/com/android/incallui/wifi/res/values-en-rAU/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Enable"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-en-rGB/strings.xml b/java/com/android/incallui/wifi/res/values-en-rGB/strings.xml
deleted file mode 100644
index 6877c49..0000000
--- a/java/com/android/incallui/wifi/res/values-en-rGB/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Enable"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-en-rIN/strings.xml b/java/com/android/incallui/wifi/res/values-en-rIN/strings.xml
deleted file mode 100644
index 6877c49..0000000
--- a/java/com/android/incallui/wifi/res/values-en-rIN/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Enable"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-es-rUS/strings.xml b/java/com/android/incallui/wifi/res/values-es-rUS/strings.xml
deleted file mode 100644
index f460251..0000000
--- a/java/com/android/incallui/wifi/res/values-es-rUS/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Habilitar"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-es/strings.xml b/java/com/android/incallui/wifi/res/values-es/strings.xml
deleted file mode 100644
index f460251..0000000
--- a/java/com/android/incallui/wifi/res/values-es/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Habilitar"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-et/strings.xml b/java/com/android/incallui/wifi/res/values-et/strings.xml
deleted file mode 100644
index ae447bd..0000000
--- a/java/com/android/incallui/wifi/res/values-et/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Luba"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-eu/strings.xml b/java/com/android/incallui/wifi/res/values-eu/strings.xml
deleted file mode 100644
index 557bdfb..0000000
--- a/java/com/android/incallui/wifi/res/values-eu/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Gaitu"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-fa/strings.xml b/java/com/android/incallui/wifi/res/values-fa/strings.xml
deleted file mode 100644
index a1bf8da..0000000
--- a/java/com/android/incallui/wifi/res/values-fa/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"فعال کردن"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-fi/strings.xml b/java/com/android/incallui/wifi/res/values-fi/strings.xml
deleted file mode 100644
index 06aac1d..0000000
--- a/java/com/android/incallui/wifi/res/values-fi/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Ota käyttöön"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-fr-rCA/strings.xml b/java/com/android/incallui/wifi/res/values-fr-rCA/strings.xml
deleted file mode 100644
index ff7bc8b..0000000
--- a/java/com/android/incallui/wifi/res/values-fr-rCA/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Activer"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-fr/strings.xml b/java/com/android/incallui/wifi/res/values-fr/strings.xml
deleted file mode 100644
index ff7bc8b..0000000
--- a/java/com/android/incallui/wifi/res/values-fr/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Activer"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-gl/strings.xml b/java/com/android/incallui/wifi/res/values-gl/strings.xml
deleted file mode 100644
index eb6e939..0000000
--- a/java/com/android/incallui/wifi/res/values-gl/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Activar"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-gu/strings.xml b/java/com/android/incallui/wifi/res/values-gu/strings.xml
deleted file mode 100644
index 39b9849..0000000
--- a/java/com/android/incallui/wifi/res/values-gu/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"સક્ષમ કરો"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-hi/strings.xml b/java/com/android/incallui/wifi/res/values-hi/strings.xml
deleted file mode 100644
index f6c6b78..0000000
--- a/java/com/android/incallui/wifi/res/values-hi/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"सक्षम करें"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-hr/strings.xml b/java/com/android/incallui/wifi/res/values-hr/strings.xml
deleted file mode 100644
index 51a57e4..0000000
--- a/java/com/android/incallui/wifi/res/values-hr/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Omogući"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-hu/strings.xml b/java/com/android/incallui/wifi/res/values-hu/strings.xml
deleted file mode 100644
index c1daa24..0000000
--- a/java/com/android/incallui/wifi/res/values-hu/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Engedélyezés"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-hy/strings.xml b/java/com/android/incallui/wifi/res/values-hy/strings.xml
deleted file mode 100644
index e9390bd..0000000
--- a/java/com/android/incallui/wifi/res/values-hy/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Միացնել"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-in/strings.xml b/java/com/android/incallui/wifi/res/values-in/strings.xml
deleted file mode 100644
index c6ed43c..0000000
--- a/java/com/android/incallui/wifi/res/values-in/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Aktifkan"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-is/strings.xml b/java/com/android/incallui/wifi/res/values-is/strings.xml
deleted file mode 100644
index 03316aa..0000000
--- a/java/com/android/incallui/wifi/res/values-is/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Kveikja"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-it/strings.xml b/java/com/android/incallui/wifi/res/values-it/strings.xml
deleted file mode 100644
index d53ccdc..0000000
--- a/java/com/android/incallui/wifi/res/values-it/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Abilita"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-iw/strings.xml b/java/com/android/incallui/wifi/res/values-iw/strings.xml
deleted file mode 100644
index c624f64..0000000
--- a/java/com/android/incallui/wifi/res/values-iw/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"הפעל"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-ja/strings.xml b/java/com/android/incallui/wifi/res/values-ja/strings.xml
deleted file mode 100644
index e918153..0000000
--- a/java/com/android/incallui/wifi/res/values-ja/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"有効にする"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-ka/strings.xml b/java/com/android/incallui/wifi/res/values-ka/strings.xml
deleted file mode 100644
index bd778d5..0000000
--- a/java/com/android/incallui/wifi/res/values-ka/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"ჩართვა"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-kk/strings.xml b/java/com/android/incallui/wifi/res/values-kk/strings.xml
deleted file mode 100644
index c0c62a4..0000000
--- a/java/com/android/incallui/wifi/res/values-kk/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Қосу"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-km/strings.xml b/java/com/android/incallui/wifi/res/values-km/strings.xml
deleted file mode 100644
index 73f194f..0000000
--- a/java/com/android/incallui/wifi/res/values-km/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"បើក"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-kn/strings.xml b/java/com/android/incallui/wifi/res/values-kn/strings.xml
deleted file mode 100644
index 2f776cf..0000000
--- a/java/com/android/incallui/wifi/res/values-kn/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"ಸಕ್ರಿಯಗೊಳಿಸಿ"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-ko/strings.xml b/java/com/android/incallui/wifi/res/values-ko/strings.xml
deleted file mode 100644
index 354efe6..0000000
--- a/java/com/android/incallui/wifi/res/values-ko/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"사용"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-ky/strings.xml b/java/com/android/incallui/wifi/res/values-ky/strings.xml
deleted file mode 100644
index 6cf39db..0000000
--- a/java/com/android/incallui/wifi/res/values-ky/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Иштетүү"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-lo/strings.xml b/java/com/android/incallui/wifi/res/values-lo/strings.xml
deleted file mode 100644
index a34d48e..0000000
--- a/java/com/android/incallui/wifi/res/values-lo/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"ເປິດນຳໃຊ້"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-lt/strings.xml b/java/com/android/incallui/wifi/res/values-lt/strings.xml
deleted file mode 100644
index b473b2d..0000000
--- a/java/com/android/incallui/wifi/res/values-lt/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Įgalinti"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-lv/strings.xml b/java/com/android/incallui/wifi/res/values-lv/strings.xml
deleted file mode 100644
index 6704846..0000000
--- a/java/com/android/incallui/wifi/res/values-lv/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Iespējot"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-mk/strings.xml b/java/com/android/incallui/wifi/res/values-mk/strings.xml
deleted file mode 100644
index 30e6e84..0000000
--- a/java/com/android/incallui/wifi/res/values-mk/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Овозможи"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-ml/strings.xml b/java/com/android/incallui/wifi/res/values-ml/strings.xml
deleted file mode 100644
index d20daa1..0000000
--- a/java/com/android/incallui/wifi/res/values-ml/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"പ്രവർത്തനക്ഷമമാക്കുക"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-mn/strings.xml b/java/com/android/incallui/wifi/res/values-mn/strings.xml
deleted file mode 100644
index a0b6bb4..0000000
--- a/java/com/android/incallui/wifi/res/values-mn/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Идэвхжүүлэх"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-mr/strings.xml b/java/com/android/incallui/wifi/res/values-mr/strings.xml
deleted file mode 100644
index e45dda1..0000000
--- a/java/com/android/incallui/wifi/res/values-mr/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"सक्षम करा"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-ms/strings.xml b/java/com/android/incallui/wifi/res/values-ms/strings.xml
deleted file mode 100644
index d87f96c..0000000
--- a/java/com/android/incallui/wifi/res/values-ms/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Dayakan"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-my/strings.xml b/java/com/android/incallui/wifi/res/values-my/strings.xml
deleted file mode 100644
index 93fba1c..0000000
--- a/java/com/android/incallui/wifi/res/values-my/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"ဖွင့်ရန်"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-nb/strings.xml b/java/com/android/incallui/wifi/res/values-nb/strings.xml
deleted file mode 100644
index 0afafec..0000000
--- a/java/com/android/incallui/wifi/res/values-nb/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Slå på"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-ne/strings.xml b/java/com/android/incallui/wifi/res/values-ne/strings.xml
deleted file mode 100644
index 0f15de7..0000000
--- a/java/com/android/incallui/wifi/res/values-ne/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"सक्षम पार्नुहोस्"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-nl/strings.xml b/java/com/android/incallui/wifi/res/values-nl/strings.xml
deleted file mode 100644
index 4fed4b3..0000000
--- a/java/com/android/incallui/wifi/res/values-nl/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Inschakelen"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-no/strings.xml b/java/com/android/incallui/wifi/res/values-no/strings.xml
deleted file mode 100644
index 0afafec..0000000
--- a/java/com/android/incallui/wifi/res/values-no/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Slå på"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-pa/strings.xml b/java/com/android/incallui/wifi/res/values-pa/strings.xml
deleted file mode 100644
index 3397491..0000000
--- a/java/com/android/incallui/wifi/res/values-pa/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"ਯੋਗ ਬਣਾਓ"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-pl/strings.xml b/java/com/android/incallui/wifi/res/values-pl/strings.xml
deleted file mode 100644
index 43ff017..0000000
--- a/java/com/android/incallui/wifi/res/values-pl/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Włącz"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-pt-rBR/strings.xml b/java/com/android/incallui/wifi/res/values-pt-rBR/strings.xml
deleted file mode 100644
index 4f1a423..0000000
--- a/java/com/android/incallui/wifi/res/values-pt-rBR/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Ativar"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-pt-rPT/strings.xml b/java/com/android/incallui/wifi/res/values-pt-rPT/strings.xml
deleted file mode 100644
index 4f1a423..0000000
--- a/java/com/android/incallui/wifi/res/values-pt-rPT/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Ativar"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-pt/strings.xml b/java/com/android/incallui/wifi/res/values-pt/strings.xml
deleted file mode 100644
index 4f1a423..0000000
--- a/java/com/android/incallui/wifi/res/values-pt/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Ativar"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-ro/strings.xml b/java/com/android/incallui/wifi/res/values-ro/strings.xml
deleted file mode 100644
index af90045..0000000
--- a/java/com/android/incallui/wifi/res/values-ro/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Activați"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-ru/strings.xml b/java/com/android/incallui/wifi/res/values-ru/strings.xml
deleted file mode 100644
index 00ae00e..0000000
--- a/java/com/android/incallui/wifi/res/values-ru/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Включить"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-si/strings.xml b/java/com/android/incallui/wifi/res/values-si/strings.xml
deleted file mode 100644
index a19c389..0000000
--- a/java/com/android/incallui/wifi/res/values-si/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"සබල කරන්න"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-sk/strings.xml b/java/com/android/incallui/wifi/res/values-sk/strings.xml
deleted file mode 100644
index 252f6e5..0000000
--- a/java/com/android/incallui/wifi/res/values-sk/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Povoliť"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-sl/strings.xml b/java/com/android/incallui/wifi/res/values-sl/strings.xml
deleted file mode 100644
index f1efb71..0000000
--- a/java/com/android/incallui/wifi/res/values-sl/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Omogoči"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-sq/strings.xml b/java/com/android/incallui/wifi/res/values-sq/strings.xml
deleted file mode 100644
index c69185d..0000000
--- a/java/com/android/incallui/wifi/res/values-sq/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Aktivizo"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-sr/strings.xml b/java/com/android/incallui/wifi/res/values-sr/strings.xml
deleted file mode 100644
index 8bd22f6..0000000
--- a/java/com/android/incallui/wifi/res/values-sr/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Омогући"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-sv/strings.xml b/java/com/android/incallui/wifi/res/values-sv/strings.xml
deleted file mode 100644
index d0dbc40..0000000
--- a/java/com/android/incallui/wifi/res/values-sv/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Aktivera"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-sw/strings.xml b/java/com/android/incallui/wifi/res/values-sw/strings.xml
deleted file mode 100644
index f0cb245..0000000
--- a/java/com/android/incallui/wifi/res/values-sw/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Washa"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-ta/strings.xml b/java/com/android/incallui/wifi/res/values-ta/strings.xml
deleted file mode 100644
index 38628af..0000000
--- a/java/com/android/incallui/wifi/res/values-ta/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"இயக்கு"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-te/strings.xml b/java/com/android/incallui/wifi/res/values-te/strings.xml
deleted file mode 100644
index 40fd08f..0000000
--- a/java/com/android/incallui/wifi/res/values-te/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"ప్రారంభించు"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-th/strings.xml b/java/com/android/incallui/wifi/res/values-th/strings.xml
deleted file mode 100644
index f201a20..0000000
--- a/java/com/android/incallui/wifi/res/values-th/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"เปิดใช้"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-tl/strings.xml b/java/com/android/incallui/wifi/res/values-tl/strings.xml
deleted file mode 100644
index b182eec..0000000
--- a/java/com/android/incallui/wifi/res/values-tl/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"I-enable"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-tr/strings.xml b/java/com/android/incallui/wifi/res/values-tr/strings.xml
deleted file mode 100644
index 65e70e2..0000000
--- a/java/com/android/incallui/wifi/res/values-tr/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Etkinleştir"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-uk/strings.xml b/java/com/android/incallui/wifi/res/values-uk/strings.xml
deleted file mode 100644
index db64076..0000000
--- a/java/com/android/incallui/wifi/res/values-uk/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Увімкнути"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-ur/strings.xml b/java/com/android/incallui/wifi/res/values-ur/strings.xml
deleted file mode 100644
index a788280..0000000
--- a/java/com/android/incallui/wifi/res/values-ur/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"فعال کریں"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-uz/strings.xml b/java/com/android/incallui/wifi/res/values-uz/strings.xml
deleted file mode 100644
index dd5c475..0000000
--- a/java/com/android/incallui/wifi/res/values-uz/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Yoqish"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-vi/strings.xml b/java/com/android/incallui/wifi/res/values-vi/strings.xml
deleted file mode 100644
index 003d5ad..0000000
--- a/java/com/android/incallui/wifi/res/values-vi/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Bật"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-zh-rCN/strings.xml b/java/com/android/incallui/wifi/res/values-zh-rCN/strings.xml
deleted file mode 100644
index a198042..0000000
--- a/java/com/android/incallui/wifi/res/values-zh-rCN/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"启用"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-zh-rHK/strings.xml b/java/com/android/incallui/wifi/res/values-zh-rHK/strings.xml
deleted file mode 100644
index b7cf926..0000000
--- a/java/com/android/incallui/wifi/res/values-zh-rHK/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"啟用"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-zh-rTW/strings.xml b/java/com/android/incallui/wifi/res/values-zh-rTW/strings.xml
deleted file mode 100644
index b7cf926..0000000
--- a/java/com/android/incallui/wifi/res/values-zh-rTW/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"啟用"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values-zu/strings.xml b/java/com/android/incallui/wifi/res/values-zu/strings.xml
deleted file mode 100644
index 6c516e7..0000000
--- a/java/com/android/incallui/wifi/res/values-zu/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="incall_enable_wifi_calling_button" msgid="2741166159276797490">"Vumela"</string>
-</resources>
diff --git a/java/com/android/incallui/wifi/res/values/strings.xml b/java/com/android/incallui/wifi/res/values/strings.xml
deleted file mode 100644
index 1b52b9f..0000000
--- a/java/com/android/incallui/wifi/res/values/strings.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-
-  <!-- Button to enable Wi-Fi calling. This is displayed in a dialog after a phone call disconnects
-      because there is no cellular service.
-      [CHAR LIMIT=20] -->
-  <string name="incall_enable_wifi_calling_button">Enable</string>
-
-</resources>
diff --git a/java/com/android/voicemail/impl/OmtpConstants.java b/java/com/android/voicemail/impl/OmtpConstants.java
index 599d0d5..97da2a8 100644
--- a/java/com/android/voicemail/impl/OmtpConstants.java
+++ b/java/com/android/voicemail/impl/OmtpConstants.java
@@ -234,6 +234,39 @@
   public static final int CHANGE_PIN_INVALID_CHARACTER = 5;
   public static final int CHANGE_PIN_SYSTEM_ERROR = 6;
 
-  /** Indicates the client is Google visual voicemail version 1.0. */
-  public static final String CLIENT_TYPE_GOOGLE_10 = "google.vvm.10";
+  public static String getClientType() {
+    String manufacturer =
+        truncate(
+            android.os.Build.MANUFACTURER
+                .replace('=', '_')
+                .replace(';', '_')
+                .replace('.', '_')
+                .replace(' ', '_'),
+            12);
+
+    String version =
+        truncate(
+            android.os.Build.VERSION
+                .RELEASE
+                .replace('=', '_')
+                .replace(';', '_')
+                .replace('.', '_')
+                .replace(' ', '_'),
+            8);
+
+    String model =
+        truncate(
+            android.os.Build.MODEL
+                .replace('=', '_')
+                .replace(';', '_')
+                .replace('.', '_')
+                .replace(' ', '_'),
+            28 - manufacturer.length() - version.length());
+
+    return String.format("%s.%s.%s", manufacturer, model, version);
+  }
+
+  private static final String truncate(String string, int length) {
+    return string.substring(0, Math.min(length, string.length()));
+  }
 }
diff --git a/java/com/android/voicemail/impl/protocol/OmtpProtocol.java b/java/com/android/voicemail/impl/protocol/OmtpProtocol.java
index 27aab8a..971edcf 100644
--- a/java/com/android/voicemail/impl/protocol/OmtpProtocol.java
+++ b/java/com/android/voicemail/impl/protocol/OmtpProtocol.java
@@ -35,7 +35,7 @@
         phoneAccountHandle,
         applicationPort,
         destinationNumber,
-        OmtpConstants.CLIENT_TYPE_GOOGLE_10,
+        OmtpConstants.getClientType(),
         OmtpConstants.PROTOCOL_VERSION1_1,
         null /*clientPrefix*/);
   }
diff --git a/java/com/android/voicemail/impl/transcribe/TranscriptionTask.java b/java/com/android/voicemail/impl/transcribe/TranscriptionTask.java
index 0fbc33a..a14b6df 100644
--- a/java/com/android/voicemail/impl/transcribe/TranscriptionTask.java
+++ b/java/com/android/voicemail/impl/transcribe/TranscriptionTask.java
@@ -21,6 +21,8 @@
 import android.net.Uri;
 import android.text.TextUtils;
 import com.android.dialer.common.concurrent.ThreadUtil;
+import com.android.dialer.logging.DialerImpression;
+import com.android.dialer.logging.Logger;
 import com.android.voicemail.impl.VvmLog;
 import com.android.voicemail.impl.transcribe.TranscriptionService.JobCallback;
 import com.android.voicemail.impl.transcribe.grpc.TranscriptionClient;
@@ -98,24 +100,37 @@
     String transcript = null;
     for (int i = 0; transcript == null && i < MAX_RETRIES; i++) {
       VvmLog.i(TAG, "transcribeVoicemail, try: " + (i + 1));
+      if (i == 0) {
+        Logger.get(context).logImpression(DialerImpression.Type.VVM_TRANSCRIPTION_REQUEST_SENT);
+      } else {
+        Logger.get(context).logImpression(DialerImpression.Type.VVM_TRANSCRIPTION_REQUEST_RETRY);
+      }
       TranscriptionClient.TranscriptionResponseWrapper responseWrapper =
           client.transcribeVoicemail(request);
       if (responseWrapper.status != null) {
         VvmLog.i(TAG, "transcribeVoicemail, status: " + responseWrapper.status.getCode());
         if (shouldRetryRequest(responseWrapper.status)) {
+          Logger.get(context)
+              .logImpression(DialerImpression.Type.VVM_TRANSCRIPTION_RESPONSE_RECOVERABLE_ERROR);
           backoff(i);
         } else {
+          Logger.get(context)
+              .logImpression(DialerImpression.Type.VVM_TRANSCRIPTION_RESPONSE_FATAL_ERROR);
           break;
         }
       } else if (responseWrapper.response != null) {
         if (!TextUtils.isEmpty(responseWrapper.response.getTranscript())) {
           VvmLog.i(TAG, "transcribeVoicemail, got response");
           transcript = responseWrapper.response.getTranscript();
+          Logger.get(context)
+              .logImpression(DialerImpression.Type.VVM_TRANSCRIPTION_RESPONSE_SUCCESS);
         } else {
           VvmLog.i(TAG, "transcribeVoicemail, empty transcription");
+          Logger.get(context).logImpression(DialerImpression.Type.VVM_TRANSCRIPTION_RESPONSE_EMPTY);
         }
       } else {
         VvmLog.w(TAG, "transcribeVoicemail, no response");
+        Logger.get(context).logImpression(DialerImpression.Type.VVM_TRANSCRIPTION_RESPONSE_INVALID);
       }
     }
 
