diff --git a/src/com/android/phone/EccShortcutAdapter.java b/src/com/android/phone/EccShortcutAdapter.java
index 19b1fec..53fa702 100644
--- a/src/com/android/phone/EccShortcutAdapter.java
+++ b/src/com/android/phone/EccShortcutAdapter.java
@@ -138,6 +138,19 @@
         }
     }
 
+    boolean hasShortcut(String number) {
+        if (mEccDisplayMaterialList == null) {
+            return false;
+        }
+
+        for (EccDisplayMaterial displayMaterial : mEccDisplayMaterialList) {
+            if (displayMaterial.number.equals(number)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     @Nullable
     private String pickEmergencyNumberForCategory(int category,
             @NonNull List<EmergencyNumber> emergencyNumbers) {
diff --git a/src/com/android/phone/EmergencyDialer.java b/src/com/android/phone/EmergencyDialer.java
index d6b7b41..3cf74c8 100644
--- a/src/com/android/phone/EmergencyDialer.java
+++ b/src/com/android/phone/EmergencyDialer.java
@@ -23,7 +23,6 @@
 import android.app.Activity;
 import android.app.AlertDialog;
 import android.app.Dialog;
-import android.app.KeyguardManager;
 import android.app.WallpaperManager;
 import android.content.BroadcastReceiver;
 import android.content.Context;
@@ -32,18 +31,12 @@
 import android.database.DataSetObserver;
 import android.graphics.Color;
 import android.graphics.Point;
-import android.hardware.Sensor;
-import android.hardware.SensorEvent;
-import android.hardware.SensorEventListener;
-import android.hardware.SensorManager;
 import android.media.AudioManager;
 import android.media.ToneGenerator;
-import android.metrics.LogMaker;
 import android.net.Uri;
 import android.os.AsyncTask;
 import android.os.Bundle;
 import android.os.PersistableBundle;
-import android.os.SystemClock;
 import android.provider.Settings;
 import android.telecom.ParcelableCallAnalytics;
 import android.telecom.PhoneAccount;
@@ -78,8 +71,9 @@
 import com.android.internal.colorextraction.ColorExtractor;
 import com.android.internal.colorextraction.ColorExtractor.GradientColors;
 import com.android.internal.colorextraction.drawable.ScrimDrawable;
-import com.android.internal.logging.MetricsLogger;
-import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
+import com.android.phone.EmergencyDialerMetricsLogger.DialedFrom;
+import com.android.phone.EmergencyDialerMetricsLogger.PhoneNumberType;
+import com.android.phone.EmergencyDialerMetricsLogger.UiModeErrorCode;
 import com.android.phone.common.dialpad.DialpadKeyButton;
 import com.android.phone.common.util.ViewUtil;
 import com.android.phone.common.widget.ResizingTextEditText;
@@ -107,72 +101,9 @@
 public class EmergencyDialer extends Activity implements View.OnClickListener,
         View.OnLongClickListener, View.OnKeyListener, TextWatcher,
         DialpadKeyButton.OnPressedListener, ColorExtractor.OnColorsChangedListener,
-        EmergencyShortcutButton.OnConfirmClickListener, SensorEventListener,
+        EmergencyShortcutButton.OnConfirmClickListener,
         EmergencyInfoGroup.OnConfirmClickListener {
 
-    private class MetricsWriter {
-        // Metrics constants indicating the UI that user made phone call.
-        public static final int CALL_SOURCE_DIALPAD = 0;
-        public static final int CALL_SOURCE_SHORTCUT = 1;
-
-        // Metrics constants indicating the phone number type of a call user made.
-        public static final int PHONE_NUMBER_TYPE_GENERAL = 0;
-        public static final int PHONE_NUMBER_TYPE_EMERGENCY = 1;
-
-        // Metrics constants indicating the actions performed by user.
-        public static final int USER_ACTION_NONE = 0x0;
-        public static final int USER_ACTION_OPEN_DIALPAD = 0x1;
-        public static final int USER_ACTION_OPEN_EMERGENCY_INFO = 0x2;
-        public static final int USER_ACTION_MAKE_CALL_VIA_DIALPAD = 0x4;
-        public static final int USER_ACTION_MAKE_CALL_VIA_SHORTCUT = 0x8;
-
-        private MetricsLogger mMetricsLogger = new MetricsLogger();
-
-        public void writeMetricsForEnter() {
-            if (!mShortcutViewConfig.isEnabled()) {
-                return;
-            }
-
-            KeyguardManager keyguard = (KeyguardManager) getSystemService(Context.KEYGUARD_SERVICE);
-            mMetricsLogger.write(new LogMaker(MetricsEvent.EMERGENCY_DIALER)
-                    .setType(MetricsEvent.TYPE_OPEN)
-                    .setSubtype(mEntryType)
-                    .addTaggedData(MetricsEvent.FIELD_EMERGENCY_DIALER_IS_SCREEN_LOCKED,
-                            keyguard.isKeyguardLocked() ? 1 : 0));
-        }
-
-        public void writeMetricsForExit() {
-            if (!mShortcutViewConfig.isEnabled()) {
-                return;
-            }
-
-            long userStayDuration = SystemClock.elapsedRealtime() - mUserEnterTimeMillis;
-            mMetricsLogger.write(new LogMaker(MetricsEvent.EMERGENCY_DIALER)
-                    .setType(MetricsEvent.TYPE_CLOSE)
-                    .setSubtype(mEntryType)
-                    .addTaggedData(MetricsEvent.FIELD_EMERGENCY_DIALER_USER_ACTIONS, mUserActions)
-                    .addTaggedData(
-                            MetricsEvent.FIELD_EMERGENCY_DIALER_DURATION_MS, userStayDuration));
-        }
-
-        public void writeMetricsForMakingCall(int callSource, int phoneNumberType,
-                boolean hasShortcut) {
-            if (!mShortcutViewConfig.isEnabled()) {
-                return;
-            }
-
-            mMetricsLogger.write(new LogMaker(MetricsEvent.EMERGENCY_DIALER_MAKE_CALL)
-                    .setType(MetricsEvent.TYPE_ACTION)
-                    .setSubtype(callSource)
-                    .addTaggedData(MetricsEvent.FIELD_EMERGENCY_DIALER_PHONE_NUMBER_TYPE,
-                            phoneNumberType)
-                    .addTaggedData(MetricsEvent.FIELD_EMERGENCY_DIALER_PHONE_NUMBER_HAS_SHORTCUT,
-                            hasShortcut ? 1 : 0)
-                    .addTaggedData(MetricsEvent.FIELD_EMERGENCY_DIALER_IN_POCKET,
-                            mIsProximityNear ? 1 : 0));
-        }
-    }
-
     // Keys used with onSaveInstanceState().
     private static final String LAST_NUMBER = "lastNumber";
 
@@ -291,21 +222,7 @@
     private int mEntryType;
     private ShortcutViewUtils.Config mShortcutViewConfig;
 
-    private MetricsWriter mMetricsWriter;
-    private SensorManager mSensorManager;
-    private Sensor mProximitySensor;
-    private boolean mIsProximityNear = false;
-
-    /**
-     * The time, in millis, since boot when user opened emergency dialer.
-     * This is used when calculating the user stay duration for metrics data.
-     */
-    private long mUserEnterTimeMillis = 0;
-
-    /**
-     * Bit flag indicating the actions performed by user. This is used for metrics data.
-     */
-    private int mUserActions = MetricsWriter.USER_ACTION_NONE;
+    private EmergencyDialerMetricsLogger mMetricsLogger;
 
     @Override
     public void beforeTextChanged(CharSequence s, int start, int count, int after) {
@@ -341,15 +258,11 @@
     protected void onCreate(Bundle icicle) {
         super.onCreate(icicle);
 
+        mMetricsLogger = new EmergencyDialerMetricsLogger(this);
+
         mEntryType = getIntent().getIntExtra(EXTRA_ENTRY_TYPE, ENTRY_TYPE_UNKNOWN);
         Log.d(LOG_TAG, "Launched from " + entryTypeToString(mEntryType));
 
-        mMetricsWriter = new MetricsWriter();
-        mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
-        if (mSensorManager != null) {
-            mProximitySensor = mSensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);
-        }
-
         // Allow this activity to be displayed in front of the keyguard / lockscreen.
         setShowWhenLocked(true);
         // Allow turning screen on
@@ -583,18 +496,15 @@
     @Override
     public void onConfirmClick(EmergencyShortcutButton button) {
         if (button == null) return;
-
-        mUserActions |= MetricsWriter.USER_ACTION_MAKE_CALL_VIA_SHORTCUT;
-
-        // We interest on the context when user has intention to make phone call,
-        // so write metrics here for shortcut number even the call may not be created.
-        mMetricsWriter.writeMetricsForMakingCall(MetricsWriter.CALL_SOURCE_SHORTCUT,
-                MetricsWriter.PHONE_NUMBER_TYPE_EMERGENCY, true);
-
         String phoneNumber = button.getPhoneNumber();
 
         if (!TextUtils.isEmpty(phoneNumber)) {
             if (DBG) Log.d(LOG_TAG, "dial emergency number: " + Rlog.pii(LOG_TAG, phoneNumber));
+
+            // Write metrics when user has intention to make a call from a shortcut button.
+            mMetricsLogger.logPlaceCall(DialedFrom.SHORTCUT, PhoneNumberType.HAS_SHORTCUT,
+                    mShortcutViewConfig.getPhoneInfo());
+
             placeCall(phoneNumber, ParcelableCallAnalytics.CALL_SOURCE_EMERGENCY_SHORTCUT,
                     mShortcutViewConfig.getPhoneInfo());
         } else {
@@ -606,7 +516,6 @@
     public void onConfirmClick(EmergencyInfoGroup button) {
         if (button == null) return;
 
-        mUserActions |= MetricsWriter.USER_ACTION_OPEN_EMERGENCY_INFO;
         Intent intent = (Intent) button.getTag(R.id.tag_intent);
         if (intent != null) {
             startActivity(intent);
@@ -632,7 +541,6 @@
                 return;
             }
             case R.id.floating_action_button_dialpad: {
-                mUserActions |= MetricsWriter.USER_ACTION_OPEN_DIALPAD;
                 mDigits.getText().clear();
                 switchView(mDialpadView, mEmergencyShortcutView, true);
                 return;
@@ -733,9 +641,9 @@
     protected void onStart() {
         super.onStart();
 
-        mUserEnterTimeMillis = SystemClock.elapsedRealtime();
-        mUserActions = MetricsWriter.USER_ACTION_NONE;
-        mMetricsWriter.writeMetricsForEnter();
+        mMetricsLogger.logLaunchEmergencyDialer(mEntryType,
+                mShortcutViewConfig.isEnabled() ? UiModeErrorCode.SUCCESS
+                        : UiModeErrorCode.UNSPECIFIED_ERROR);
 
         if (mShortcutViewConfig.isEnabled()) {
             // Shortcut view doesn't support dark text theme.
@@ -759,11 +667,6 @@
     protected void onResume() {
         super.onResume();
 
-        if (mProximitySensor != null) {
-            mSensorManager.registerListener(
-                    this, mProximitySensor, SensorManager.SENSOR_DELAY_NORMAL);
-        }
-
         // retrieve the DTMF tone play back setting.
         mDTMFToneEnabled = Settings.System.getInt(getContentResolver(),
                 Settings.System.DTMF_TONE_WHEN_DIALING, 1) == 1;
@@ -788,15 +691,11 @@
     @Override
     public void onPause() {
         super.onPause();
-        if (mProximitySensor != null) {
-            mSensorManager.unregisterListener(this, mProximitySensor);
-        }
     }
 
     @Override
     protected void onStop() {
         super.onStop();
-        mMetricsWriter.writeMetricsForExit();
         mColorExtractor.removeOnColorsChangedListener(this);
     }
 
@@ -835,7 +734,6 @@
      * place the call, but check to make sure it is a viable number.
      */
     private void placeCall() {
-        mUserActions |= MetricsWriter.USER_ACTION_MAKE_CALL_VIA_DIALPAD;
         mLastNumber = mDigits.getText().toString();
 
         // Convert into emergency number according to emergency conversion map.
@@ -843,14 +741,28 @@
         // nothing and just returns input number.
         mLastNumber = PhoneNumberUtils.convertToEmergencyNumber(this, mLastNumber);
 
+        @DialedFrom final int dialedFrom =
+                mShortcutViewConfig.isEnabled() ? DialedFrom.FASTER_LAUNCHER_DIALPAD
+                        : DialedFrom.TRADITIONAL_DIALPAD;
+        @PhoneNumberType final int phoneNumberType;
+
         boolean isEmergencyNumber;
         ShortcutViewUtils.PhoneInfo phoneToMakeCall = null;
-        if (mShortcutViewConfig.hasPromotedEmergencyNumber(mLastNumber)) {
+        if (mShortcutAdapter != null && mShortcutAdapter.hasShortcut(mLastNumber)) {
             isEmergencyNumber = true;
             phoneToMakeCall = mShortcutViewConfig.getPhoneInfo();
+            phoneNumberType = PhoneNumberType.HAS_SHORTCUT;
+        } else if (mShortcutViewConfig.hasPromotedEmergencyNumber(mLastNumber)) {
+            // If a number from SIM/network/... is categoried as police/ambulance/fire,
+            // hasPromotedEmergencyNumber() will return true, but it maybe not promoted as a
+            // shortcut button because a number provided by database has higher priority.
+            isEmergencyNumber = true;
+            phoneToMakeCall = mShortcutViewConfig.getPhoneInfo();
+            phoneNumberType = PhoneNumberType.NO_SHORTCUT;
         } else {
-            TelephonyManager tm = getSystemService(TelephonyManager.class);
-            isEmergencyNumber = tm.isEmergencyNumber(mLastNumber);
+            isEmergencyNumber = getSystemService(TelephonyManager.class)
+                    .isEmergencyNumber(mLastNumber);
+            phoneNumberType = PhoneNumberType.NO_SHORTCUT;
         }
 
         if (isEmergencyNumber) {
@@ -863,18 +775,18 @@
                 return;
             }
 
-            mMetricsWriter.writeMetricsForMakingCall(MetricsWriter.CALL_SOURCE_DIALPAD,
-                    MetricsWriter.PHONE_NUMBER_TYPE_EMERGENCY, isShortcutNumber(mLastNumber));
+            // Write metrics when user has intention to make a call from dialpad
+            mMetricsLogger.logPlaceCall(dialedFrom, phoneNumberType, phoneToMakeCall);
 
             placeCall(mLastNumber, ParcelableCallAnalytics.CALL_SOURCE_EMERGENCY_DIALPAD,
                     phoneToMakeCall);
         } else {
             if (DBG) Log.d(LOG_TAG, "rejecting bad requested number " + mLastNumber);
 
-            // We interest on the context when user has intention to make phone call,
-            // so write metrics here for non-emergency numbers even these numbers are rejected.
-            mMetricsWriter.writeMetricsForMakingCall(MetricsWriter.CALL_SOURCE_DIALPAD,
-                    MetricsWriter.PHONE_NUMBER_TYPE_GENERAL, false);
+            // Write metrics when user has intention to make a call of a non-emergency number, even
+            // this number is rejected.
+            mMetricsLogger.logPlaceCall(dialedFrom, PhoneNumberType.NOT_EMERGENCY_NUMBER,
+                    phoneToMakeCall);
 
             showDialog(BAD_EMERGENCY_NUMBER_DIALOG);
         }
@@ -1288,17 +1200,6 @@
                 });
     }
 
-    @Override
-    public void onSensorChanged(SensorEvent event) {
-        float distance = event.values[0];
-        mIsProximityNear = (distance < mProximitySensor.getMaximumRange());
-    }
-
-    @Override
-    public void onAccuracyChanged(Sensor sensor, int accuracy) {
-        // Not used.
-    }
-
     private boolean isShortcutNumber(String number) {
         if (TextUtils.isEmpty(number) || mEmergencyShortcutButtonList == null) {
             return false;
diff --git a/src/com/android/phone/EmergencyDialerMetricsLogger.java b/src/com/android/phone/EmergencyDialerMetricsLogger.java
new file mode 100644
index 0000000..b9ba352
--- /dev/null
+++ b/src/com/android/phone/EmergencyDialerMetricsLogger.java
@@ -0,0 +1,289 @@
+/*
+ * Copyright (C) 2019 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.phone;
+
+import android.annotation.IntDef;
+import android.app.KeyguardManager;
+import android.content.Context;
+import android.metrics.LogMaker;
+import android.os.Build;
+import android.telephony.TelephonyManager;
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+
+import com.android.internal.logging.MetricsLogger;
+import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * EmergencyCallMetricsLogger is a utility to collect metrics of emergency calls
+ */
+class EmergencyDialerMetricsLogger {
+    private static final String LOG_TAG = "EmergencyDialerLogger";
+
+    @IntDef({
+            DialedFrom.TRADITIONAL_DIALPAD,
+            DialedFrom.SHORTCUT,
+            DialedFrom.FASTER_LAUNCHER_DIALPAD,
+    })
+    @Retention(RetentionPolicy.SOURCE)
+    @interface DialedFrom {
+        int TRADITIONAL_DIALPAD = 0;
+        int SHORTCUT = 1;
+        int FASTER_LAUNCHER_DIALPAD = 2;
+    }
+
+    @IntDef({
+            LaunchedFrom.UNDEFINED,
+            LaunchedFrom.LOCK_SCREEN,
+            LaunchedFrom.POWER_KEY_MENU,
+    })
+    @Retention(RetentionPolicy.SOURCE)
+    @interface LaunchedFrom {
+        int UNDEFINED = 0;
+        int LOCK_SCREEN = 1;
+        int POWER_KEY_MENU = 2;
+    }
+
+    @IntDef({
+            PhoneNumberType.HAS_SHORTCUT,
+            PhoneNumberType.NO_SHORTCUT,
+            PhoneNumberType.NOT_EMERGENCY_NUMBER,
+    })
+    @Retention(RetentionPolicy.SOURCE)
+    @interface PhoneNumberType {
+        int HAS_SHORTCUT = 0;
+        int NO_SHORTCUT = 1;
+        int NOT_EMERGENCY_NUMBER = 2;
+    }
+
+    @IntDef({
+            UiModeErrorCode.UNSPECIFIED_ERROR,
+            UiModeErrorCode.SUCCESS,
+            UiModeErrorCode.CONFIG_ENTRY_POINT,
+            UiModeErrorCode.CONFIG_SIM_OPERATOR,
+            UiModeErrorCode.UNSUPPORTED_COUNTRY,
+            UiModeErrorCode.AIRPLANE_MODE,
+            UiModeErrorCode.NO_PROMOTED_NUMBER,
+            UiModeErrorCode.NO_CAPABLE_PHONE,
+    })
+    @Retention(RetentionPolicy.SOURCE)
+    @interface UiModeErrorCode {
+        int UNSPECIFIED_ERROR = -1;
+        int SUCCESS = 0;
+        int CONFIG_ENTRY_POINT = 1;
+        int CONFIG_SIM_OPERATOR = 2;
+        int UNSUPPORTED_COUNTRY = 3;
+        int AIRPLANE_MODE = 4;
+        int NO_PROMOTED_NUMBER = 5;
+        int NO_CAPABLE_PHONE = 6;
+    }
+
+    private class TelephonyInfo {
+        private final String mNetworkCountryIso;
+        private final String mNetworkOperator;
+
+        TelephonyInfo(String networkCountryIso, String networkOperator) {
+            mNetworkCountryIso = networkCountryIso;
+            mNetworkOperator = networkOperator;
+        }
+    }
+
+    private final MetricsLogger mMetricsLogger = new MetricsLogger();
+
+    private final Context mAppContext;
+
+    @LaunchedFrom
+    private int mLaunchedFrom;
+    @UiModeErrorCode
+    private int mUiModeErrorCode;
+
+    EmergencyDialerMetricsLogger(Context context) {
+        mAppContext = context.getApplicationContext();
+    }
+
+    /**
+     * Log when Emergency Dialer is launched.
+     * - Where the user launch Emergency Dialer from.
+     * - Whether shortcut view is enabled, and the reason why it's not enabled.
+     *
+     * @param entryType
+     * @param uiModeErrorCode
+     */
+    public void logLaunchEmergencyDialer(int entryType,
+            @UiModeErrorCode int uiModeErrorCode) {
+        final @EmergencyDialerMetricsLogger.LaunchedFrom int launchedFrom;
+        if (entryType == EmergencyDialer.ENTRY_TYPE_LOCKSCREEN_BUTTON) {
+            launchedFrom = EmergencyDialerMetricsLogger.LaunchedFrom.LOCK_SCREEN;
+        } else if (entryType == EmergencyDialer.ENTRY_TYPE_POWER_MENU) {
+            launchedFrom = EmergencyDialerMetricsLogger.LaunchedFrom.POWER_KEY_MENU;
+        } else {
+            launchedFrom = EmergencyDialerMetricsLogger.LaunchedFrom.UNDEFINED;
+        }
+
+        mLaunchedFrom = launchedFrom;
+        mUiModeErrorCode = uiModeErrorCode;
+    }
+
+    /**
+     * Log when user tring to place an emergency call.
+     * - Which UI (traditional dialpad, shortcut button, dialpad in shortcut view) the user place
+     *   the call from.
+     * - The number is promoted in shortcut view or not, or not even an emergency number?
+     * - Whether the device is locked.
+     * - Network country ISO and network operator.
+     *
+     * @param dialedFrom
+     * @param phoneNumberType
+     * @param phoneInfo
+     */
+    public void logPlaceCall(@DialedFrom int dialedFrom,
+            @PhoneNumberType int phoneNumberType,
+            @Nullable ShortcutViewUtils.PhoneInfo phoneInfo) {
+        TelephonyInfo telephonyInfo = getTelephonyInfo(phoneNumberType, phoneInfo);
+        final KeyguardManager keyguard = mAppContext.getSystemService(KeyguardManager.class);
+
+        logBeforeMakeCall(dialedFrom, phoneNumberType, keyguard.isKeyguardLocked(),
+                telephonyInfo.mNetworkCountryIso, telephonyInfo.mNetworkOperator);
+    }
+
+    private TelephonyInfo getTelephonyInfo(@PhoneNumberType int phoneNumberType,
+            @Nullable ShortcutViewUtils.PhoneInfo phoneInfo) {
+        final TelephonyManager telephonyManager = mAppContext.getSystemService(
+                TelephonyManager.class);
+        final TelephonyManager subTelephonyManager;
+        final String networkCountryIso;
+        final String networkOperator;
+        if (phoneNumberType == PhoneNumberType.HAS_SHORTCUT && phoneInfo != null) {
+            subTelephonyManager = telephonyManager.createForSubscriptionId(phoneInfo.getSubId());
+            networkCountryIso = phoneInfo.getCountryIso();
+        } else {
+            // No specific phone to make this call. Take information of default network.
+            subTelephonyManager = null;
+            networkCountryIso = telephonyManager.getNetworkCountryIso();
+        }
+        if (subTelephonyManager != null) {
+            networkOperator = subTelephonyManager.getNetworkOperator();
+        } else {
+            // This could be:
+            // - No specific phone to make this call.
+            // - Subscription changed! Maybe the device roamed to another network?
+            // Take information of default network.
+            networkOperator = telephonyManager.getNetworkOperator();
+        }
+
+        return new TelephonyInfo(networkCountryIso, networkOperator);
+    }
+
+    private void logBeforeMakeCall(@DialedFrom int dialedFrom,
+            @PhoneNumberType int phoneNumberType,
+            boolean isDeviceLocked,
+            String networkCountryIso,
+            String networkOperator) {
+        if (Log.isLoggable(LOG_TAG, Log.DEBUG)) {
+            Log.d(LOG_TAG, "EmergencyDialer session: dialedFrom=" + dialFromToString(dialedFrom)
+                    + ", launchedFrom=" + launchedFromToString(mLaunchedFrom)
+                    + ", uimode=" + uiModeErrorCodeToString(mUiModeErrorCode)
+                    + ", type=" + phoneNumberTypeToString(phoneNumberType)
+                    + ", locked=" + isDeviceLocked
+                    + ", country=" + networkCountryIso
+                    + ", operator=" + networkOperator);
+        }
+        mMetricsLogger.write(new LogMaker(MetricsEvent.EMERGENCY_DIALER_MAKE_CALL_V2)
+                .setType(MetricsEvent.TYPE_ACTION)
+                .setSubtype(dialedFrom)
+                .addTaggedData(MetricsEvent.FIELD_EMERGENCY_DIALER_LAUNCH_FROM, mLaunchedFrom)
+                .addTaggedData(MetricsEvent.FIELD_EMERGENCY_DIALER_UI_MODE_ERROR_CODE,
+                        mUiModeErrorCode)
+                .addTaggedData(MetricsEvent.FIELD_EMERGENCY_DIALER_PHONE_NUMBER_TYPE,
+                        phoneNumberType)
+                .addTaggedData(MetricsEvent.FIELD_EMERGENCY_DIALER_IS_DEVICE_LOCKED,
+                        isDeviceLocked ? 1 : 0)
+                .addTaggedData(MetricsEvent.FIELD_EMERGENCY_DIALER_NETWORK_COUNTRY_ISO,
+                        networkCountryIso)
+                .addTaggedData(MetricsEvent.FIELD_EMERGENCY_DIALER_NETWORK_OPERATOR,
+                        networkOperator)
+                .addTaggedData(MetricsEvent.FIELD_EMERGENCY_DIALER_RADIO_VERSION,
+                        Build.getRadioVersion())
+        );
+    }
+
+    private String dialFromToString(@DialedFrom int dialedFrom) {
+        switch (dialedFrom) {
+            case DialedFrom.TRADITIONAL_DIALPAD:
+                return "traditional";
+            case DialedFrom.SHORTCUT:
+                return "shortcut";
+            case DialedFrom.FASTER_LAUNCHER_DIALPAD:
+                return "dialpad";
+            default:
+                return "unknown_error";
+        }
+    }
+
+    private String launchedFromToString(@LaunchedFrom int launchedFrom) {
+        switch (launchedFrom) {
+            case LaunchedFrom.UNDEFINED:
+                return "undefined";
+            case LaunchedFrom.LOCK_SCREEN:
+                return "lockscreen";
+            case LaunchedFrom.POWER_KEY_MENU:
+                return "powermenu";
+            default:
+                return "unknown_error";
+        }
+    }
+
+    private String phoneNumberTypeToString(@PhoneNumberType int phoneNumberType) {
+        switch (phoneNumberType) {
+            case PhoneNumberType.HAS_SHORTCUT:
+                return "has_shortcut";
+            case PhoneNumberType.NO_SHORTCUT:
+                return "no_shortcut";
+            case PhoneNumberType.NOT_EMERGENCY_NUMBER:
+                return "not_emergency";
+            default:
+                return "unknown_error";
+        }
+    }
+
+    private String uiModeErrorCodeToString(@UiModeErrorCode int uiModeErrorCode) {
+        switch (uiModeErrorCode) {
+            case UiModeErrorCode.UNSPECIFIED_ERROR:
+                return "unspecified_error";
+            case UiModeErrorCode.SUCCESS:
+                return "success";
+            case UiModeErrorCode.CONFIG_ENTRY_POINT:
+                return "config_entry_point";
+            case UiModeErrorCode.CONFIG_SIM_OPERATOR:
+                return "config_sim_operator";
+            case UiModeErrorCode.UNSUPPORTED_COUNTRY:
+                return "unsupported_country";
+            case UiModeErrorCode.AIRPLANE_MODE:
+                return "airplane_mode";
+            case UiModeErrorCode.NO_PROMOTED_NUMBER:
+                return "no_promoted_number";
+            case UiModeErrorCode.NO_CAPABLE_PHONE:
+                return "no_capable_phone";
+            default:
+                return "unknown_error";
+        }
+    }
+}