diff --git a/InCallUI/src/com/android/incallui/StatusBarNotifier.java b/InCallUI/src/com/android/incallui/StatusBarNotifier.java
index e0bca44..985c885 100644
--- a/InCallUI/src/com/android/incallui/StatusBarNotifier.java
+++ b/InCallUI/src/com/android/incallui/StatusBarNotifier.java
@@ -45,13 +45,13 @@
 
 import com.android.contacts.common.ContactsUtils;
 import com.android.contacts.common.ContactsUtils.UserType;
-import com.android.contacts.common.compat.CompatUtils;
 import com.android.contacts.common.preference.ContactsPreferences;
 import com.android.contacts.common.util.BitmapUtil;
 import com.android.contacts.common.util.ContactDisplayUtils;
 import com.android.incallui.ContactInfoCache.ContactCacheEntry;
 import com.android.incallui.ContactInfoCache.ContactInfoCacheCallback;
 import com.android.incallui.InCallPresenter.InCallState;
+import com.android.incallui.ringtone.DialerRingtoneManager;
 
 import java.util.Objects;
 
@@ -61,11 +61,6 @@
 public class StatusBarNotifier implements InCallPresenter.InCallStateListener,
         CallList.CallUpdateListener {
 
-    /*
-     * Flag used to determine if the Dialer is responsible for playing ringtones for incoming calls.
-     */
-    private static final boolean IS_DIALER_RINGING_ENABLED = false;
-
     // Notification types
     // Indicates that no notification is currently showing.
     private static final int NOTIFICATION_NONE = 0;
@@ -80,6 +75,7 @@
     private final ContactsPreferences mContactsPreferences;
     private final ContactInfoCache mContactInfoCache;
     private final NotificationManager mNotificationManager;
+    private final DialerRingtoneManager mDialerRingtoneManager;
     private int mCurrentNotification = NOTIFICATION_NONE;
     private int mCallState = Call.State.INVALID;
     private int mSavedIcon = 0;
@@ -97,6 +93,7 @@
         mContactInfoCache = contactInfoCache;
         mNotificationManager =
                 (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
+        mDialerRingtoneManager = new DialerRingtoneManager();
         mCurrentNotification = NOTIFICATION_NONE;
     }
 
@@ -233,7 +230,7 @@
             return;
         }
 
-        final int state = call.getState();
+        final int callState = call.getState();
 
         // Check if data has changed; if nothing is different, don't issue another notification.
         final int iconResId = getIconToDisplay(call);
@@ -243,13 +240,13 @@
         final String contentTitle = getContentTitle(contactInfo, call);
 
         final int notificationType;
-        if (state == Call.State.INCOMING || state == Call.State.CALL_WAITING) {
+        if (callState == Call.State.INCOMING || callState == Call.State.CALL_WAITING) {
             notificationType = NOTIFICATION_INCOMING_CALL;
         } else {
             notificationType = NOTIFICATION_IN_CALL;
         }
 
-        if (!checkForChangeAndSaveData(iconResId, content, largeIcon, contentTitle, state,
+        if (!checkForChangeAndSaveData(iconResId, content, largeIcon, contentTitle, callState,
                 notificationType, contactInfo.contactRingtoneUri)) {
             return;
         }
@@ -289,7 +286,7 @@
             addDismissUpgradeRequestAction(builder);
             addAcceptUpgradeRequestAction(builder);
         } else {
-            createIncomingCallNotification(call, state, builder);
+            createIncomingCallNotification(call, callState, builder);
         }
 
         addPersonReference(builder, contactInfo, call);
@@ -299,7 +296,7 @@
          */
         Notification notification = builder.build();
 
-        if (shouldNotificationPlayRingtone(notificationType, contactInfo.contactRingtoneUri)) {
+        if (mDialerRingtoneManager.shouldPlayRingtone(callState, contactInfo.contactRingtoneUri)) {
             notification.flags |= Notification.FLAG_INSISTENT;
             notification.sound = contactInfo.contactRingtoneUri;
             AudioAttributes.Builder audioAttributes = new AudioAttributes.Builder();
@@ -308,6 +305,9 @@
             notification.audioAttributes = audioAttributes.build();
             notification.vibrate = VIBRATE_PATTERN;
         }
+        if (mDialerRingtoneManager.shouldPlayCallWaitingTone(callState)) {
+            // TODO (maxwelb) play call waiting
+        }
         if (mCurrentNotification != notificationType && mCurrentNotification != NOTIFICATION_NONE) {
             Log.i(this, "Previous notification already showing - cancelling "
                     + mCurrentNotification);
@@ -318,16 +318,6 @@
         mCurrentNotification = notificationType;
     }
 
-    /*
-     * The Notification should only play the ringtone once it's had a chance to look up the contact.
-     * Until the lookup is complete, the ringtone Uri is null
-     */
-    private boolean shouldNotificationPlayRingtone(int notificationType, Uri ringtoneUri) {
-        return CompatUtils.isNCompatible() && IS_DIALER_RINGING_ENABLED
-                && notificationType == NOTIFICATION_INCOMING_CALL
-                && ringtoneUri != null;
-    }
-
     private void createIncomingCallNotification(
             Call call, int state, Notification.Builder builder) {
         if (state == Call.State.ACTIVE) {
diff --git a/InCallUI/src/com/android/incallui/ringtone/DialerRingtoneManager.java b/InCallUI/src/com/android/incallui/ringtone/DialerRingtoneManager.java
new file mode 100644
index 0000000..8d4d068
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/ringtone/DialerRingtoneManager.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2016 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.ringtone;
+
+import android.net.Uri;
+import android.support.annotation.Nullable;
+
+import com.android.contacts.common.compat.CompatUtils;
+import com.android.contacts.common.testing.NeededForTesting;
+import com.android.incallui.Call.State;
+
+/**
+ * Class that determines when ringtones should be played and can play the call waiting tone when
+ * necessary.
+ */
+public class DialerRingtoneManager {
+
+    /*
+     * Flag used to determine if the Dialer is responsible for playing ringtones for incoming calls.
+     */
+    private static final boolean IS_DIALER_RINGING_ENABLED = false;
+    private boolean mForceDialerRingingEnabled = false;
+
+    /**
+     * Determines if a ringtone should be played for the given call state (see {@link State}) and
+     * {@link Uri}.
+     *
+     * @param callState the call state for the call being checked.
+     * @param ringtoneUri the ringtone to potentially play.
+     * @return {@code true} if the ringtone should be played, {@code false} otherwise.
+     */
+    public boolean shouldPlayRingtone(int callState, @Nullable Uri ringtoneUri) {
+        return CompatUtils.isNCompatible()
+                && isDialerRingingEnabled()
+                && callState == State.INCOMING
+                && ringtoneUri != null;
+    }
+
+    private boolean isDialerRingingEnabled() {
+        return mForceDialerRingingEnabled || IS_DIALER_RINGING_ENABLED;
+    }
+
+    /**
+     * Determines if a call waiting tone should be played for the the given call state
+     * (see {@link State}).
+     *
+     * @param callState the call state for the call being checked.
+     * @return {@code true} if the call waiting tone should be played, {@code false} otherwise.
+     */
+    public boolean shouldPlayCallWaitingTone(int callState) {
+        return CompatUtils.isNCompatible()
+                && isDialerRingingEnabled()
+                && callState == State.CALL_WAITING;
+    }
+
+    @NeededForTesting
+    void forceDialerRingingEnabled() {
+        mForceDialerRingingEnabled = true;
+    }
+}
diff --git a/InCallUI/tests/src/com/android/incallui/ringtone/RingtoneManagerTest.java b/InCallUI/tests/src/com/android/incallui/ringtone/RingtoneManagerTest.java
new file mode 100644
index 0000000..f94f71d
--- /dev/null
+++ b/InCallUI/tests/src/com/android/incallui/ringtone/RingtoneManagerTest.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2016 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.ringtone;
+
+import android.media.RingtoneManager;
+import android.test.AndroidTestCase;
+
+import com.android.contacts.common.compat.CompatUtils;
+import com.android.incallui.Call.State;
+
+public class RingtoneManagerTest extends AndroidTestCase {
+
+    private DialerRingtoneManager mRingtoneManager;
+
+    @Override
+    public void setUp() {
+        mRingtoneManager = new DialerRingtoneManager();
+        mRingtoneManager.forceDialerRingingEnabled();
+    }
+
+    @Override
+    public void tearDown() {
+        mRingtoneManager = null;
+    }
+
+    public void testShouldPlayRingtone_M() {
+        if (CompatUtils.isNCompatible()) {
+            return;
+        }
+        assertFalse(mRingtoneManager.shouldPlayRingtone(0, null));
+    }
+
+    public void testShouldPlayRingtone_N_NullUri() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        assertFalse(mRingtoneManager.shouldPlayRingtone(State.INCOMING, null));
+    }
+
+    public void testShouldPlayRingtone_N_NotIncoming() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        assertFalse(mRingtoneManager.shouldPlayRingtone(State.ACTIVE, null));
+    }
+
+    // Specific case for call waiting since that needs its own sound
+    public void testShouldPlayRingtone_N_CallWaiting() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        assertFalse(mRingtoneManager.shouldPlayRingtone(State.CALL_WAITING, null));
+    }
+
+    public void testShouldPlayRingtone_N() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        assertTrue(mRingtoneManager.shouldPlayRingtone(State.INCOMING,
+                RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)));
+    }
+
+    public void testShouldPlayCallWaitingTone_M() {
+        if (CompatUtils.isNCompatible()) {
+            return;
+        }
+        assertFalse(mRingtoneManager.shouldPlayCallWaitingTone(0));
+    }
+
+    public void testShouldPlayCallWaitingTone_N_NotCallWaiting() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        assertFalse(mRingtoneManager.shouldPlayCallWaitingTone(State.ACTIVE));
+    }
+
+    // Specific case for incoming since it plays its own sound
+    public void testShouldPlayCallWaitingTone_N_Incoming() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        assertFalse(mRingtoneManager.shouldPlayCallWaitingTone(State.INCOMING));
+    }
+
+    public void testShouldPlayCallWaitingTone_N() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        assertTrue(mRingtoneManager.shouldPlayCallWaitingTone(State.CALL_WAITING));
+    }
+}