diff --git a/res/values/strings.xml b/res/values/strings.xml
index db13443..e924c3a 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -707,6 +707,18 @@
 
     <!-- Setting option name to enable or disable DTMF tone sound [CHAR LIMIT=30] -->
     <string name="dtmf_tone_enable_title">Dialpad tones</string>
+    <!-- Label for setting to adjust the length of DTMF tone sounds. [CHAR LIMIT=40] -->
+    <string name="dtmf_tone_length_title">Dialpad tone length</string>
+    <!-- Options displayed for the length of DTMF tone sounds. [CHAR LIMIT=40] -->
+    <string-array name="dtmf_tone_length_entries">
+      <item>Normal</item>
+      <item>Long</item>
+    </string-array>
+    <!-- Do not translate. -->
+    <string-array name="dtmf_tone_length_entry_values" translatable="false">
+       <item>0</item>
+       <item>1</item>
+    </string-array>
 
     <!-- Title of settings screen for managing the "Respond via SMS" feature. [CHAR LIMIT=30] -->
     <string name="respond_via_sms_setting_title">Quick responses</string>
@@ -723,4 +735,6 @@
     <string name="vibrate_on_preference_key" translatable="false">button_vibrate_on_ring</string>
     <!-- DO NOT TRANSLATE. Internal key for vibrate when ringing preference. -->
     <string name="play_dtmf_preference_key" translatable="false">button_play_dtmf_tone</string>
+    <!-- DO NOT TRANSLATE. Internal key for DTMF tone length preference. -->
+    <string name="dtmf_tone_length_preference_key" translatable="false">button_dtmf_settings</string>
 </resources>
diff --git a/res/xml/sound_settings.xml b/res/xml/sound_settings.xml
index ebe0f51..80fad62 100644
--- a/res/xml/sound_settings.xml
+++ b/res/xml/sound_settings.xml
@@ -26,15 +26,21 @@
         android:ringtoneType="ringtone" />
 
     <CheckBoxPreference
+        android:key="@string/vibrate_on_preference_key"
+        android:title="@string/vibrate_on_ring_title"
+        android:persistent="false"
+        android:defaultValue="false" />
+
+    <CheckBoxPreference
         android:key="@string/play_dtmf_preference_key"
         android:title="@string/dtmf_tone_enable_title"
         android:persistent="false"
         android:defaultValue="true" />
 
-    <CheckBoxPreference
-        android:key="@string/vibrate_on_preference_key"
-        android:title="@string/vibrate_on_ring_title"
-        android:persistent="false"
-        android:defaultValue="false" />
+    <ListPreference
+        android:key="@string/dtmf_tone_length_preference_key"
+        android:title="@string/dtmf_tone_length_title"
+        android:entries="@array/dtmf_tone_length_entries"
+        android:entryValues="@array/dtmf_tone_length_entry_values" />
 
 </PreferenceScreen>
diff --git a/src/com/android/dialer/settings/SoundSettingsFragment.java b/src/com/android/dialer/settings/SoundSettingsFragment.java
index 83d5d7d..43297b5 100644
--- a/src/com/android/dialer/settings/SoundSettingsFragment.java
+++ b/src/com/android/dialer/settings/SoundSettingsFragment.java
@@ -23,10 +23,12 @@
 import android.os.Message;
 import android.os.Vibrator;
 import android.preference.CheckBoxPreference;
+import android.preference.ListPreference;
 import android.preference.Preference;
 import android.preference.PreferenceFragment;
 import android.preference.PreferenceScreen;
 import android.provider.Settings;
+import android.telephony.TelephonyManager;
 
 import com.android.dialer.R;
 import com.android.phone.common.util.SettingsUtil;
@@ -48,13 +50,15 @@
     private static final int NO_VIBRATION_FOR_CALLS = 0;
     private static final int DO_VIBRATION_FOR_CALLS = 1;
 
-    private static final int MSG_UPDATE_RINGTONE_SUMMARY = 1;
+    private static final int SHOW_CARRIER_SETTINGS = 0;
+    private static final int HIDE_CARRIER_SETTINGS = 1;
 
-    private Context mContext;
+    private static final int MSG_UPDATE_RINGTONE_SUMMARY = 1;
 
     private Preference mRingtonePreference;
     private CheckBoxPreference mVibrateWhenRinging;
     private CheckBoxPreference mPlayDtmfTone;
+    private ListPreference mDtmfToneLength;
 
     private final Runnable mRingtoneLookupRunnable = new Runnable() {
         @Override
@@ -78,15 +82,17 @@
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
 
-        mContext = getActivity().getApplicationContext();
-
         addPreferencesFromResource(R.xml.sound_settings);
 
-        mRingtonePreference = findPreference(mContext.getString(R.string.ringtone_preference_key));
+        Context context = getActivity();
+
+        mRingtonePreference = findPreference(context.getString(R.string.ringtone_preference_key));
         mVibrateWhenRinging = (CheckBoxPreference) findPreference(
-                mContext.getString(R.string.vibrate_on_preference_key));
+                context.getString(R.string.vibrate_on_preference_key));
         mPlayDtmfTone = (CheckBoxPreference) findPreference(
-                mContext.getString(R.string.play_dtmf_preference_key));
+                context.getString(R.string.play_dtmf_preference_key));
+        mDtmfToneLength = (ListPreference) findPreference(
+                context.getString(R.string.dtmf_tone_length_preference_key));
 
         if (hasVibrator()) {
             mVibrateWhenRinging.setOnPreferenceChangeListener(this);
@@ -97,6 +103,19 @@
 
         mPlayDtmfTone.setOnPreferenceChangeListener(this);
         mPlayDtmfTone.setChecked(shouldPlayDtmfTone());
+
+        TelephonyManager telephonyManager =
+                (TelephonyManager) getActivity().getSystemService(Context.TELEPHONY_SERVICE);
+        if (telephonyManager.canChangeDtmfToneLength()
+                && (telephonyManager.isWorldPhone() || !shouldHideCarrierSettings())) {
+            mDtmfToneLength.setOnPreferenceChangeListener(this);
+            mDtmfToneLength.setValueIndex(
+                    Settings.System.getInt(context.getContentResolver(),
+                        Settings.System.DTMF_TONE_WHEN_DIALING, PLAY_DTMF_TONE));
+        } else {
+            getPreferenceScreen().removePreference(mDtmfToneLength);
+            mDtmfToneLength = null;
+        }
     }
 
     @Override
@@ -121,9 +140,13 @@
     public boolean onPreferenceChange(Preference preference, Object objValue) {
         if (preference == mVibrateWhenRinging) {
             boolean doVibrate = (Boolean) objValue;
-            Settings.System.putInt(mContext.getContentResolver(),
+            Settings.System.putInt(getActivity().getContentResolver(),
                     Settings.System.VIBRATE_WHEN_RINGING,
                     doVibrate ? DO_VIBRATION_FOR_CALLS : NO_VIBRATION_FOR_CALLS);
+        } else if (preference == mDtmfToneLength) {
+            int index = mDtmfToneLength.findIndexOfValue((String) objValue);
+            Settings.System.putInt(getActivity().getContentResolver(),
+                    Settings.System.DTMF_TONE_TYPE_WHEN_DIALING, index);
         }
         return true;
     }
@@ -134,7 +157,7 @@
     @Override
     public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
         if (preference == mPlayDtmfTone) {
-            Settings.System.putInt(mContext.getContentResolver(),
+            Settings.System.putInt(getActivity().getContentResolver(),
                     Settings.System.DTMF_TONE_WHEN_DIALING,
                     mPlayDtmfTone.isChecked() ? PLAY_DTMF_TONE : NO_DTMF_TONE);
         }
@@ -146,7 +169,7 @@
      */
     private void updateRingtonePreferenceSummary() {
         SettingsUtil.updateRingtoneName(
-                mContext,
+                getActivity(),
                 mRingtoneLookupComplete,
                 RingtoneManager.TYPE_RINGTONE,
                 mRingtonePreference.getKey(),
@@ -160,7 +183,7 @@
      * "vibrate on ring" setting from AudioManager, and save the previous setting to the new one.
      */
     private boolean shouldVibrateWhenRinging() {
-        int vibrateWhenRingingSetting = Settings.System.getInt(mContext.getContentResolver(),
+        int vibrateWhenRingingSetting = Settings.System.getInt(getActivity().getContentResolver(),
                 Settings.System.VIBRATE_WHEN_RINGING,
                 NO_VIBRATION_FOR_CALLS);
         return hasVibrator() && (vibrateWhenRingingSetting == DO_VIBRATION_FOR_CALLS);
@@ -170,7 +193,7 @@
      * Obtains the value for dialpad/DTMF tones. The default value is true.
      */
     private boolean shouldPlayDtmfTone() {
-        int dtmfToneSetting = Settings.System.getInt(mContext.getContentResolver(),
+        int dtmfToneSetting = Settings.System.getInt(getActivity().getContentResolver(),
                 Settings.System.DTMF_TONE_WHEN_DIALING,
                 PLAY_DTMF_TONE);
         return dtmfToneSetting == PLAY_DTMF_TONE;
@@ -180,7 +203,13 @@
      * Whether the device hardware has a vibrator.
      */
     private boolean hasVibrator() {
-        Vibrator vibrator = (Vibrator) mContext.getSystemService(Context.VIBRATOR_SERVICE);
+        Vibrator vibrator = (Vibrator) getActivity().getSystemService(Context.VIBRATOR_SERVICE);
         return vibrator != null && vibrator.hasVibrator();
     }
+
+    private boolean shouldHideCarrierSettings() {
+        int hideCarrierNetworkSetting = Settings.Global.getInt(getActivity().getContentResolver(),
+                Settings.Global.HIDE_CARRIER_NETWORK_SETTINGS, SHOW_CARRIER_SETTINGS);
+        return hideCarrierNetworkSetting == HIDE_CARRIER_SETTINGS;
+    }
 }
