diff --git a/src/com/android/server/telecom/Call.java b/src/com/android/server/telecom/Call.java
index 18c9c05..99a1c8c 100644
--- a/src/com/android/server/telecom/Call.java
+++ b/src/com/android/server/telecom/Call.java
@@ -110,7 +110,7 @@
         void onConnectionManagerPhoneAccountChanged(Call call);
         void onPhoneAccountChanged(Call call);
         void onConferenceableCallsChanged(Call call);
-        boolean onCanceledViaNewOutgoingCallBroadcast(Call call);
+        boolean onCanceledViaNewOutgoingCallBroadcast(Call call, long disconnectionTimeout);
         void onHoldToneRequested(Call call);
         void onConnectionEvent(Call call, String event, Bundle extras);
         void onExternalCallChanged(Call call, boolean isExternalCall);
@@ -172,7 +172,7 @@
         @Override
         public void onConferenceableCallsChanged(Call call) {}
         @Override
-        public boolean onCanceledViaNewOutgoingCallBroadcast(Call call) {
+        public boolean onCanceledViaNewOutgoingCallBroadcast(Call call, long disconnectionTimeout) {
             return false;
         }
 
@@ -1314,14 +1314,14 @@
 
     @VisibleForTesting
     public void disconnect() {
-        disconnect(false);
+        disconnect(0);
     }
 
     /**
      * Attempts to disconnect the call through the connection service.
      */
     @VisibleForTesting
-    public void disconnect(boolean wasViaNewOutgoingCallBroadcaster) {
+    public void disconnect(long disconnectionTimeout) {
         Log.event(this, Log.Events.REQUEST_DISCONNECT);
 
         // Track that the call is now locally disconnecting.
@@ -1330,7 +1330,7 @@
         if (mState == CallState.NEW || mState == CallState.SELECT_PHONE_ACCOUNT ||
                 mState == CallState.CONNECTING) {
             Log.v(this, "Aborting call %s", this);
-            abort(wasViaNewOutgoingCallBroadcaster);
+            abort(disconnectionTimeout);
         } else if (mState != CallState.ABORTED && mState != CallState.DISCONNECTED) {
             if (mConnectionService == null) {
                 Log.e(this, new Exception(), "disconnect() request on a call without a"
@@ -1346,22 +1346,25 @@
         }
     }
 
-    void abort(boolean wasViaNewOutgoingCallBroadcaster) {
+    void abort(long disconnectionTimeout) {
         if (mCreateConnectionProcessor != null &&
                 !mCreateConnectionProcessor.isProcessingComplete()) {
             mCreateConnectionProcessor.abort();
         } else if (mState == CallState.NEW || mState == CallState.SELECT_PHONE_ACCOUNT
                 || mState == CallState.CONNECTING) {
-            if (wasViaNewOutgoingCallBroadcaster) {
-                // If the cancelation was from NEW_OUTGOING_CALL, then we do not automatically
-                // destroy the call.  Instead, we announce the cancelation and CallsManager handles
+            if (disconnectionTimeout > 0) {
+                // If the cancelation was from NEW_OUTGOING_CALL with a timeout of > 0
+                // milliseconds, do not destroy the call.
+                // Instead, we announce the cancellation and CallsManager handles
                 // it through a timer. Since apps often cancel calls through NEW_OUTGOING_CALL and
                 // then re-dial them quickly using a gateway, allowing the first call to end
                 // causes jank. This timeout allows CallsManager to transition the first call into
                 // the second call so that in-call only ever sees a single call...eliminating the
-                // jank altogether.
+                // jank altogether. The app will also be able to set the timeout via an extra on
+                // the ordered broadcast.
                 for (Listener listener : mListeners) {
-                    if (listener.onCanceledViaNewOutgoingCallBroadcast(this)) {
+                    if (listener.onCanceledViaNewOutgoingCallBroadcast(
+                            this, disconnectionTimeout)) {
                         // The first listener to handle this wins. A return value of true means that
                         // the listener will handle the disconnection process later and so we
                         // should not continue it here.
diff --git a/src/com/android/server/telecom/CallsManager.java b/src/com/android/server/telecom/CallsManager.java
index d6462d7..cd2aa85 100644
--- a/src/com/android/server/telecom/CallsManager.java
+++ b/src/com/android/server/telecom/CallsManager.java
@@ -552,7 +552,8 @@
     }
 
     @Override
-    public boolean onCanceledViaNewOutgoingCallBroadcast(final Call call) {
+    public boolean onCanceledViaNewOutgoingCallBroadcast(final Call call,
+            long disconnectionTimeout) {
         mPendingCallsToDisconnect.add(call);
         mHandler.postDelayed(new Runnable("CM.oCVNOCB", mLock) {
             @Override
@@ -562,7 +563,7 @@
                     call.disconnect();
                 }
             }
-        }.prepare(), Timeouts.getNewOutgoingCallCancelMillis(mContext.getContentResolver()));
+        }.prepare(), disconnectionTimeout);
 
         return true;
     }
diff --git a/src/com/android/server/telecom/NewOutgoingCallIntentBroadcaster.java b/src/com/android/server/telecom/NewOutgoingCallIntentBroadcaster.java
index 8b5604b..b63baaf 100644
--- a/src/com/android/server/telecom/NewOutgoingCallIntentBroadcaster.java
+++ b/src/com/android/server/telecom/NewOutgoingCallIntentBroadcaster.java
@@ -24,6 +24,7 @@
 import android.content.Intent;
 import android.content.res.Resources;
 import android.net.Uri;
+import android.os.Bundle;
 import android.os.Trace;
 import android.os.UserHandle;
 import android.telecom.GatewayInfo;
@@ -112,19 +113,24 @@
                             Log.pii(resultNumber));
 
                     boolean endEarly = false;
+                    long disconnectTimeout =
+                            Timeouts.getNewOutgoingCallCancelMillis(mContext.getContentResolver());
                     if (resultNumber == null) {
                         Log.v(this, "Call cancelled (null number), returning...");
+                        disconnectTimeout = getDisconnectTimeoutFromApp(
+                                getResultExtras(false), disconnectTimeout);
                         endEarly = true;
                     } else if (mPhoneNumberUtilsAdapter.isPotentialLocalEmergencyNumber(
                             mContext, resultNumber)) {
                         Log.w(this, "Cannot modify outgoing call to emergency number %s.",
                                 resultNumber);
+                        disconnectTimeout = 0;
                         endEarly = true;
                     }
 
                     if (endEarly) {
                         if (mCall != null) {
-                            mCall.disconnect(true /* wasViaNewOutgoingCall */);
+                            mCall.disconnect(disconnectTimeout);
                         }
                         return;
                     }
@@ -445,4 +451,18 @@
             intent.setAction(action);
         }
     }
+
+    private long getDisconnectTimeoutFromApp(Bundle resultExtras, long defaultTimeout) {
+        if (resultExtras != null) {
+            long disconnectTimeout = resultExtras.getLong(
+                    TelecomManager.EXTRA_NEW_OUTGOING_CALL_CANCEL_TIMEOUT, defaultTimeout);
+            if (disconnectTimeout < 0) {
+                disconnectTimeout = 0;
+            }
+            return Math.min(disconnectTimeout,
+                    Timeouts.getMaxNewOutgoingCallCancelMillis(mContext.getContentResolver()));
+        } else {
+            return defaultTimeout;
+        }
+    }
 }
diff --git a/src/com/android/server/telecom/Timeouts.java b/src/com/android/server/telecom/Timeouts.java
index 7be59c3..b2f4b6d 100644
--- a/src/com/android/server/telecom/Timeouts.java
+++ b/src/com/android/server/telecom/Timeouts.java
@@ -63,7 +63,16 @@
      * in-call UI.
      */
     public static long getNewOutgoingCallCancelMillis(ContentResolver contentResolver) {
-        return get(contentResolver, "new_outgoing_call_cancel_ms", 100000L);
+        return get(contentResolver, "new_outgoing_call_cancel_ms", 500L);
+    }
+
+    /**
+     * Returns the maximum amount of time to wait before disconnecting a call that was canceled via
+     * NEW_OUTGOING_CALL broadcast. This prevents malicious or poorly configured apps from
+     * forever tying up the Telecom stack.
+     */
+    public static long getMaxNewOutgoingCallCancelMillis(ContentResolver contentResolver) {
+        return get(contentResolver, "max_new_outgoing_call_cancel_ms", 10000L);
     }
 
     /**
diff --git a/tests/src/com/android/server/telecom/tests/NewOutgoingCallIntentBroadcasterTest.java b/tests/src/com/android/server/telecom/tests/NewOutgoingCallIntentBroadcasterTest.java
index 54613d4..9b7dc37 100644
--- a/tests/src/com/android/server/telecom/tests/NewOutgoingCallIntentBroadcasterTest.java
+++ b/tests/src/com/android/server/telecom/tests/NewOutgoingCallIntentBroadcasterTest.java
@@ -313,7 +313,28 @@
 
         result.receiver.onReceive(mContext, result.intent);
         verifyNoCallPlaced();
-        verify(mCall).disconnect(true);
+        ArgumentCaptor<Long> timeoutCaptor = ArgumentCaptor.forClass(Long.class);
+        verify(mCall).disconnect(timeoutCaptor.capture());
+        assertTrue(timeoutCaptor.getValue() > 0);
+    }
+
+    @SmallTest
+    public void testCallNumberModifiedToNullWithLongCustomTimeout() {
+        Uri handle = Uri.parse("tel:6505551234");
+        Intent callIntent = buildIntent(handle, Intent.ACTION_CALL, null);
+        ReceiverIntentPair result = regularCallTestHelper(callIntent, null);
+
+        long customTimeout = 100000000;
+        Bundle bundle = new Bundle();
+        bundle.putLong(TelecomManager.EXTRA_NEW_OUTGOING_CALL_CANCEL_TIMEOUT, customTimeout);
+        result.receiver.setResultData(null);
+        result.receiver.setResultExtras(bundle);
+
+        result.receiver.onReceive(mContext, result.intent);
+        verifyNoCallPlaced();
+        ArgumentCaptor<Long> timeoutCaptor = ArgumentCaptor.forClass(Long.class);
+        verify(mCall).disconnect(timeoutCaptor.capture());
+        assertTrue(timeoutCaptor.getValue() < customTimeout);
     }
 
     @SmallTest
@@ -328,7 +349,7 @@
         doReturn(true).when(mPhoneNumberUtilsAdapterSpy).isPotentialLocalEmergencyNumber(
                 any(Context.class), eq(newEmergencyNumber));
         result.receiver.onReceive(mContext, result.intent);
-        verify(mCall).disconnect(true);
+        verify(mCall).disconnect(eq(0L));
     }
 
     private ReceiverIntentPair regularCallTestHelper(Intent intent,