diff --git a/InCallUI/res/values/qtistrings.xml b/InCallUI/res/values/qtistrings.xml
index 3c28164..963276e 100644
--- a/InCallUI/res/values/qtistrings.xml
+++ b/InCallUI/res/values/qtistrings.xml
@@ -109,4 +109,28 @@
     <string name="cs_redial_yes">Yes</string>
     <!-- No option of the IMS to CS redial dialog -->
     <string name="cs_redial_no">No</string>
+    <!-- Session modify cause unspecified -->
+    <string name="session_modify_cause_unspecified"></string>
+    <!-- Session modify cause code upgrade local request -->
+    <string name="session_modify_cause_upgrade_local_request">Call upgraded on user request</string>
+    <!-- Session modify cause code upgrade remote request -->
+    <string name="session_modify_cause_upgrade_remote_request">Call upgraded on remote user request</string>
+    <!-- Session modify cause code downgrade local request -->
+    <string name="session_modify_cause_downgrade_local_request">Call downgraded on user request</string>
+    <!-- Session modify cause code downgrade remote request -->
+    <string name="session_modify_cause_downgrade_remote_request">Call downgraded on remote user request</string>
+    <!-- Session modify cause code downgrade rtp timeout -->
+    <string name="session_modify_cause_downgrade_rtp_timeout">Call downgraded due to RTP timeout</string>
+    <!-- Session modify cause code downgrade qos -->
+    <string name="session_modify_cause_downgrade_qos">Call downgraded due to quality of service</string>
+    <!-- Session modify cause code downgrade packet loss -->
+    <string name="session_modify_cause_downgrade_packet_loss">Call downgraded due to packet loss</string>
+    <!-- Session modify cause code downgrade low thrput -->
+    <string name="session_modify_cause_downgrade_low_thrput">Call downgraded due to low throughput</string>
+    <!-- Session modify cause code downgrade thermal mitigation -->
+    <string name="session_modify_cause_downgrade_thermal_mitigation">Call downgraded due to thermal mitigation</string>
+    <!-- Session modify cause code downgrade lipsync -->
+    <string name="session_modify_cause_downgrade_lipsync">Call downgraded due to lipsync</string>
+    <!-- Session modify cause code downgrade generic error -->
+    <string name="session_modify_cause_downgrade_generic_error">Call downgraded due to generic error</string>
 </resources>
diff --git a/InCallUI/src/com/android/incallui/InCallMessageController.java b/InCallUI/src/com/android/incallui/InCallMessageController.java
index d62aae3..b0a7bf7 100644
--- a/InCallUI/src/com/android/incallui/InCallMessageController.java
+++ b/InCallUI/src/com/android/incallui/InCallMessageController.java
@@ -32,10 +32,10 @@
 import android.content.res.Resources;
 import android.os.Bundle;
 
-import org.codeaurora.ims.QtiCallConstants;
 import com.android.incallui.InCallPresenter.InCallDetailsListener;
 import com.android.incallui.InCallVideoCallCallbackNotifier.VideoEventListener;
-
+import com.android.incallui.InCallVideoCallCallbackNotifier.SessionModificationListener;
+import org.codeaurora.ims.QtiCallConstants;
 
 /**
  * This class listens to incoming events for the listener classes it implements. It should
@@ -45,9 +45,12 @@
  * {@class CallSubstateNotifier} notifies it through the onCallSubstateChanged callback.
  */
 public class InCallMessageController implements InCallSubstateListener, VideoEventListener,
-        CallList.Listener {
+        CallList.Listener, InCallSessionModificationCauseListener {
 
     private static InCallMessageController sInCallMessageController;
+
+    private PrimaryCallTracker mPrimaryCallTracker;
+
     private Context mContext;
 
     /**
@@ -57,25 +60,33 @@
     }
 
     /**
-     * Handles set up of the {@class InCallSubstateListener}. Instantiates the context needed by
-     * the class and adds a listener to listen to call substate changes.
+     * Handles set up of the {@class InCallMessageController}. Instantiates the context needed by
+     * the class and adds a listener to listen to call substate changes, video event changes,
+     * session modification cause changes, call state changes.
      */
     public void setUp(Context context) {
         mContext = context;
+        mPrimaryCallTracker = new PrimaryCallTracker();
         CallSubstateNotifier.getInstance().addListener(this);
         InCallVideoCallCallbackNotifier.getInstance().addVideoEventListener(this);
         CallList.getInstance().addListener(this);
+        SessionModificationCauseNotifier.getInstance().addListener(this);
+        InCallPresenter.getInstance().addListener(mPrimaryCallTracker);
     }
 
     /**
-     * Handles tear down of the {@class InCallSubstateListener}. Sets the context to null and
-     * unregisters it's call substate listener.
+     * Handles tear down of the {@class InCallMessageController}. Sets the context to null and
+     * unregisters it's call substate,  video event, session modification cause, call state
+     * listeners.
      */
     public void tearDown() {
         mContext = null;
         CallSubstateNotifier.getInstance().removeListener(this);
         InCallVideoCallCallbackNotifier.getInstance().removeVideoEventListener(this);
         CallList.getInstance().removeListener(this);
+        SessionModificationCauseNotifier.getInstance().removeListener(this);
+        InCallPresenter.getInstance().removeListener(mPrimaryCallTracker);
+        mPrimaryCallTracker = null;
     }
 
     /**
@@ -97,8 +108,8 @@
         Log.d(this, "onCallSubstateChanged - Call : " + call + " call substate changed to " +
                 callSubstate);
 
-        if (mContext == null) {
-            Log.e(this, "onCallSubstateChanged - Context is null. Return");
+        if (mContext == null || !mPrimaryCallTracker.isPrimaryCall(call)) {
+            Log.e(this, "onCallSubstateChanged - Context is null/not primary call.");
             return;
         }
 
@@ -141,11 +152,11 @@
      */
     @Override
     public void onVideoQualityChanged(final Call call, final int videoQuality) {
-        Log.d(this, "Call : " + call + " onVideoQualityChanged. Video quality changed to " +
+        Log.d(this, "onVideoQualityChanged: - Call : " + call + " Video quality changed to " +
                 videoQuality);
 
-        if (mContext == null) {
-            Log.e(this, "onVideoQualityChanged - Context is null. Return");
+        if (mContext == null || !mPrimaryCallTracker.isPrimaryCall(call)) {
+            Log.e(this, "onVideoQualityChanged - Context is null/not primary call.");
             return;
         }
         final Resources resources = mContext.getResources();
@@ -166,7 +177,7 @@
         Log.d(this, "onCallSessionEvent: event = " + event);
 
         if (mContext == null) {
-            Log.e(this, "onCallSessionEvent - Context is null. Return");
+            Log.e(this, "onCallSessionEvent - Context is null.");
             return;
         }
         final Resources resources = mContext.getResources();
@@ -258,4 +269,59 @@
              break;
        }
     }
+
+    /*
+     * Handles any session modifictaion cause changes in the call.
+     *
+     * @param call The call for which orientation mode changed.
+     * @param sessionModificationCause The new session modifictaion cause
+     */
+    @Override
+    public void onSessionModificationCauseChanged(Call call, int sessionModificationCause) {
+        Log.d(this, "onSessionModificationCauseChanged: Call : " + call +
+                " Call modified due to "  + sessionModificationCause);
+
+        if (mContext == null || !mPrimaryCallTracker.isPrimaryCall(call)) {
+            Log.e(this,
+                    "onSessionModificationCauseChanged- Context is null/not primary call.");
+            return;
+        }
+
+        QtiCallUtils.displayToast(mContext,
+                getSessionModificationCauseResourceId(sessionModificationCause));
+    }
+
+    /**
+     * This method returns the string resource id (i.e. display string) that corresponds to the
+     * session modification cause code.
+     */
+    private static int getSessionModificationCauseResourceId(int cause) {
+        switch(cause) {
+            case QtiCallConstants.CAUSE_CODE_UNSPECIFIED:
+                return R.string.session_modify_cause_unspecified;
+            case QtiCallConstants.CAUSE_CODE_SESSION_MODIFY_UPGRADE_LOCAL_REQ:
+                return R.string.session_modify_cause_upgrade_local_request;
+            case QtiCallConstants.CAUSE_CODE_SESSION_MODIFY_UPGRADE_REMOTE_REQ:
+                return R.string.session_modify_cause_upgrade_remote_request;
+            case QtiCallConstants.CAUSE_CODE_SESSION_MODIFY_DOWNGRADE_LOCAL_REQ:
+                return R.string.session_modify_cause_downgrade_local_request;
+            case QtiCallConstants.CAUSE_CODE_SESSION_MODIFY_DOWNGRADE_REMOTE_REQ:
+                return R.string.session_modify_cause_downgrade_remote_request;
+            case QtiCallConstants.CAUSE_CODE_SESSION_MODIFY_DOWNGRADE_RTP_TIMEOUT:
+                return R.string.session_modify_cause_downgrade_rtp_timeout;
+            case QtiCallConstants.CAUSE_CODE_SESSION_MODIFY_DOWNGRADE_QOS:
+                return R.string.session_modify_cause_downgrade_qos;
+            case QtiCallConstants.CAUSE_CODE_SESSION_MODIFY_DOWNGRADE_PACKET_LOSS:
+                return R.string.session_modify_cause_downgrade_packet_loss;
+            case QtiCallConstants.CAUSE_CODE_SESSION_MODIFY_DOWNGRADE_LOW_THRPUT:
+                return R.string.session_modify_cause_downgrade_low_thrput;
+            case QtiCallConstants.CAUSE_CODE_SESSION_MODIFY_DOWNGRADE_THERM_MITIGATION:
+                return R.string.session_modify_cause_downgrade_thermal_mitigation;
+            case QtiCallConstants.CAUSE_CODE_SESSION_MODIFY_DOWNGRADE_LIPSYNC:
+                return R.string.session_modify_cause_downgrade_lipsync;
+            case QtiCallConstants.CAUSE_CODE_SESSION_MODIFY_DOWNGRADE_GENERIC_ERROR:
+            default:
+                return R.string.session_modify_cause_downgrade_generic_error;
+        }
+    }
 }
diff --git a/InCallUI/src/com/android/incallui/InCallPresenter.java b/InCallUI/src/com/android/incallui/InCallPresenter.java
index 9142a8a..14f143a 100644
--- a/InCallUI/src/com/android/incallui/InCallPresenter.java
+++ b/InCallUI/src/com/android/incallui/InCallPresenter.java
@@ -23,6 +23,7 @@
 import android.content.ActivityNotFoundException;
 import android.content.Context;
 import android.content.Intent;
+
 import android.content.res.Resources;
 import android.database.ContentObserver;
 import android.graphics.Point;
@@ -349,7 +350,9 @@
         mCallList.setFilteredNumberQueryHandler(mFilteredQueryHandler);
 
         InCallMessageController.getInstance().setUp(mContext);
+        OrientationModeHandler.getInstance().setUp();
         addDetailsListener(CallSubstateNotifier.getInstance());
+        addDetailsListener(SessionModificationCauseNotifier.getInstance());
 
         InCallZoomController.getInstance().setUp(mContext);
         Log.d(this, "Finished InCallPresenter.setUp");
@@ -375,9 +378,11 @@
         InCallUiStateNotifier.getInstance().tearDown();
         InCallVideoCallCallbackNotifier.getInstance().removeSessionModificationListener(this);
         InCallMessageController.getInstance().tearDown();
+        OrientationModeHandler.getInstance().tearDown();
         removeDetailsListener(CallSubstateNotifier.getInstance());
 
         InCallZoomController.getInstance().tearDown();
+        removeDetailsListener(SessionModificationCauseNotifier.getInstance());
     }
 
     private void attemptFinishActivity() {
@@ -920,6 +925,9 @@
         Call call = mCallList.getIncomingCall();
         if (call != null) {
             TelecomAdapter.getInstance().answerCall(call.getId(), videoState);
+            if (VideoUtils.isVideoCall(videoState)) {
+                showInCall(false, false/* newOutgoingCall */);
+            }
         }
     }
 
@@ -1752,25 +1760,17 @@
      * Configures the in-call UI activity so it can change orientations or not. Enables the
      * orientation event listener if allowOrientationChange is true, disables it if false.
      *
-     * @param allowOrientationChange {@code True} if the in-call UI can change between portrait
-     *      and landscape.  {@Code False} if the in-call UI should be locked in portrait.
+     * @param orientation {@link ActivityInfo#screenOrientation} Actual orientation value to set
      */
-    public void setInCallAllowsOrientationChange(boolean allowOrientationChange) {
+    public void setInCallAllowsOrientationChange(int orientation) {
         if (mInCallActivity == null) {
             Log.e(this, "InCallActivity is null. Can't set requested orientation.");
             return;
         }
 
-        if (!allowOrientationChange) {
-            mInCallActivity.setRequestedOrientation(
-                    InCallOrientationEventListener.NO_SENSOR_SCREEN_ORIENTATION);
-        } else {
-            // Using SCREEN_ORIENTATION_FULL_SENSOR allows for reverse-portrait orientation, where
-            // SCREEN_ORIENTATION_SENSOR does not.
-            mInCallActivity.setRequestedOrientation(
-                    InCallOrientationEventListener.FULL_SENSOR_SCREEN_ORIENTATION);
-        }
-        mInCallActivity.enableInCallOrientationEventListener(allowOrientationChange);
+        mInCallActivity.setRequestedOrientation(orientation);
+        mInCallActivity.enableInCallOrientationEventListener(
+                orientation == InCallOrientationEventListener.FULL_SENSOR_SCREEN_ORIENTATION);
     }
 
     public void enableScreenTimeout(boolean enable) {
diff --git a/InCallUI/src/com/android/incallui/InCallSessionModificationCauseListener.java b/InCallUI/src/com/android/incallui/InCallSessionModificationCauseListener.java
new file mode 100644
index 0000000..e6ad761
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/InCallSessionModificationCauseListener.java
@@ -0,0 +1,37 @@
+/* Copyright (c) 2015, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.android.incallui;
+
+/**
+ * This interface will be implemented by classes that wish to listen to session modification cause
+ * updates.
+ */
+public interface InCallSessionModificationCauseListener {
+    public void onSessionModificationCauseChanged(Call call, int sessionModificationCause);
+}
diff --git a/InCallUI/src/com/android/incallui/OrientationModeHandler.java b/InCallUI/src/com/android/incallui/OrientationModeHandler.java
new file mode 100644
index 0000000..bbb1a6c
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/OrientationModeHandler.java
@@ -0,0 +1,189 @@
+/* Copyright (c) 2015, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.android.incallui;
+
+import android.content.pm.ActivityInfo;
+import android.os.Bundle;
+import com.android.incallui.InCallPresenter.InCallDetailsListener;
+import com.android.incallui.InCallPresenter.InCallUiListener;
+import org.codeaurora.ims.QtiCallConstants;
+
+/**
+ * This class listens to incoming events from the {@class InCallDetailsListener}.
+ * When call details change, this class is notified and we parse the extras from the details to
+ * figure out if orientation mode has changed and if changed, we call setRequestedOrientation
+ * on the activity to set the orientation mode for the device.
+ *
+ */
+public class OrientationModeHandler implements InCallDetailsListener, InCallUiListener {
+
+    private static OrientationModeHandler sOrientationModeHandler;
+
+    private PrimaryCallTracker mPrimaryCallTracker;
+
+    private int mOrientationMode = QtiCallConstants.ORIENTATION_MODE_UNSPECIFIED;
+
+    /**
+     * Returns a singleton instance of {@class OrientationModeHandler}
+     */
+    public static synchronized OrientationModeHandler getInstance() {
+        if (sOrientationModeHandler == null) {
+            sOrientationModeHandler = new OrientationModeHandler();
+        }
+        return sOrientationModeHandler;
+    }
+
+    /**
+     * Private constructor. Must use getInstance() to get this singleton.
+     */
+    private OrientationModeHandler() {
+    }
+
+    /**
+     * Handles set up of the {@class OrientationModeHandler}. Registers primary call tracker to
+     * listen to call state changes and registers this class to listen to call details changes.
+     */
+    public void setUp() {
+        mPrimaryCallTracker = new PrimaryCallTracker();
+        InCallPresenter.getInstance().addListener(mPrimaryCallTracker);
+        InCallPresenter.getInstance().addDetailsListener(this);
+        InCallPresenter.getInstance().addInCallUiListener(this);
+    }
+
+    /**
+     * Handles tear down of the {@class OrientationModeHandler}. Unregisters primary call tracker
+     * from listening to call state changes and unregisters this class from listening to call
+     * details changes.
+     */
+    public void tearDown() {
+        InCallPresenter.getInstance().removeListener(mPrimaryCallTracker);
+        InCallPresenter.getInstance().removeDetailsListener(this);
+        InCallPresenter.getInstance().removeInCallUiListener(this);
+        mOrientationMode = QtiCallConstants.ORIENTATION_MODE_UNSPECIFIED;
+        mPrimaryCallTracker = null;
+    }
+
+    /**
+     * Overrides onDetailsChanged method of {@class InCallDetailsListener}. We are
+     * notified when call details change and extract the orientation mode from the
+     * extras, detect if the mode has changed and set the orientation mode for the device.
+     */
+    @Override
+    public void onDetailsChanged(Call call, android.telecom.Call.Details details) {
+        Log.d(this, "onDetailsChanged: - call: " + call + "details: " + details);
+        mayBeUpdateOrientationMode(call, details);
+    }
+
+    /**
+     * This API conveys if incall experience is showing or not.
+     *
+     * @param showing TRUE if incall experience is showing else FALSE
+     */
+    @Override
+    public void onUiShowing(boolean showing) {
+        Call call = mPrimaryCallTracker.getPrimaryCall();
+        Log.d(this, "onUiShowing showing: " + showing + " call = " + call);
+
+        if (!showing || call == null) {
+            return;
+        }
+
+        mayBeUpdateOrientationMode(call, call.getTelecomCall().getDetails());
+    }
+
+    private void mayBeUpdateOrientationMode(Call call, android.telecom.Call.Details details) {
+        final Bundle extras =  (call != null && details != null) ? details.getExtras() : null;
+        final int orientationMode = (extras != null) ? extras.getInt(
+                QtiCallConstants.ORIENTATION_MODE_EXTRA_KEY,
+                QtiCallConstants.ORIENTATION_MODE_UNSPECIFIED) :
+                QtiCallConstants.ORIENTATION_MODE_UNSPECIFIED;
+
+        Log.d(this, "mayBeUpdateOrientationMode : orientationMode: " + orientationMode +
+                " mOrientationMode : " + mOrientationMode);
+        if (InCallPresenter.getInstance().getActivity() == null) {
+            Log.w(this, "mayBeUpdateOrientationMode : InCallActivity is null");
+            return;
+        }
+
+        if (orientationMode != mOrientationMode && orientationMode !=
+                QtiCallConstants.ORIENTATION_MODE_UNSPECIFIED) {
+            mOrientationMode = orientationMode;
+            onOrientationModeChanged(call, mOrientationMode);
+        }
+    }
+
+    /**
+     * Handles any orientation mode changes in the call.
+     *
+     * @param call The call for which orientation mode changed.
+     * @param orientationMode The new orientation mode of the device
+     */
+    private void onOrientationModeChanged(Call call, int orientationMode) {
+        Log.d(this, "onOrientationModeChanged: Call : " + call + " orientation mode = " +
+                orientationMode);
+
+        if (!mPrimaryCallTracker.isPrimaryCall(call)) {
+            Log.e(this, "Can't set requested orientation on a non-primary call");
+            return;
+        }
+        final InCallActivity inCallActivity = InCallPresenter.getInstance().getActivity();
+        if (inCallActivity != null) {
+            inCallActivity.setRequestedOrientation(QtiCallUtils.toUiOrientationMode(
+                    orientationMode));
+        }
+    }
+
+    /**
+     * Returns the current orientation mode based on the receipt of DISPLAY_MODE_EVT from lower
+     * layers and whether the call is a video call or not. If we have a video call and we
+     * did receive a valid orientation mode, return the corresponding
+     * {@link ActivityInfo#ScreenOrientation} else return
+     * ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR. If we are in a voice call, return
+     * ActivityInfo.SCREEN_ORIENTATION_NOSENSOR.
+     *
+     * @param call The current call.
+     */
+    public int getOrientation(Call call) {
+        if (VideoUtils.isVideoCall(call)) {
+            return (mOrientationMode == QtiCallConstants.ORIENTATION_MODE_UNSPECIFIED) ?
+                    ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR :
+                    QtiCallUtils.toUiOrientationMode(mOrientationMode);
+        } else {
+            return ActivityInfo.SCREEN_ORIENTATION_NOSENSOR;
+        }
+    }
+
+    /**
+     * Returns the current orientation mode.
+     * @see #getOrientation(Call)
+     */
+    public int getCurrentOrientation() {
+        return QtiCallUtils.toUiOrientationMode(mOrientationMode);
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/PrimaryCallTracker.java b/InCallUI/src/com/android/incallui/PrimaryCallTracker.java
new file mode 100644
index 0000000..4212bbc
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/PrimaryCallTracker.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2015, The Linux Foundation. All rights reserved.
+ * Not a Contribution.
+ *
+ * Copyright (C) 2014 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;
+
+import com.android.incallui.InCallPresenter.InCallStateListener;
+import com.android.incallui.InCallPresenter.IncomingCallListener;
+import java.util.Objects;
+
+/**
+ * Listens to call state changes from {@class InCallStateListener} and keeps track of the current
+ * primary call.
+ */
+public class PrimaryCallTracker implements InCallStateListener, IncomingCallListener {
+
+    private Call mPrimaryCall;
+
+    public PrimaryCallTracker() {
+    }
+
+    @Override
+    public void onIncomingCall(InCallPresenter.InCallState oldState,
+            InCallPresenter.InCallState newState, Call call) {
+        // same logic should happen as with onStateChange()
+        onStateChange(oldState, InCallPresenter.InCallState.INCOMING, CallList.getInstance());
+    }
+
+    /**
+     * Handles state changes (including incoming calls)
+     *
+     * @param newState The in call state.
+     * @param callList The call list.
+     */
+    @Override
+    public void onStateChange(InCallPresenter.InCallState oldState,
+            InCallPresenter.InCallState newState, CallList callList) {
+        Log.d(this, "onStateChange: oldState" + oldState + " newState=" + newState +
+                "callList =" + callList);
+
+        // Determine the primary active call.
+        Call primaryCall = null;
+
+        if (newState == InCallPresenter.InCallState.INCOMING) {
+            primaryCall = callList.getIncomingCall();
+        } else if (newState == InCallPresenter.InCallState.OUTGOING) {
+            primaryCall = callList.getOutgoingCall();
+        } else if (newState == InCallPresenter.InCallState.PENDING_OUTGOING) {
+            primaryCall = callList.getPendingOutgoingCall();
+        } else if (newState == InCallPresenter.InCallState.INCALL) {
+            primaryCall = callList.getActiveCall();
+        } else {
+            primaryCall = callList.getBackgroundCall();
+        }
+
+        if (!Objects.equals(mPrimaryCall, primaryCall)) {
+            mPrimaryCall = primaryCall;
+        }
+    }
+
+    /**
+     * Returns the current primary call.
+     */
+    public Call getPrimaryCall() {
+        return mPrimaryCall;
+    }
+
+    /**
+     * Checks if the current call passed in is a primary call. Returns true if it is, false
+     * otherwise
+     *
+     * @param Call The call to be compared with the primary call.
+     */
+    public boolean isPrimaryCall(final Call call) {
+        return Objects.equals(mPrimaryCall, call);
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/QtiCallUtils.java b/InCallUI/src/com/android/incallui/QtiCallUtils.java
index e741e67..f6016b6 100644
--- a/InCallUI/src/com/android/incallui/QtiCallUtils.java
+++ b/InCallUI/src/com/android/incallui/QtiCallUtils.java
@@ -41,6 +41,7 @@
 import android.content.DialogInterface;
 import android.os.IBinder;
 import android.os.RemoteException;
+import android.content.pm.ActivityInfo;
 import android.telecom.InCallService.VideoCall;
 import android.telephony.SubscriptionManager;
 import android.telephony.TelephonyManager;
@@ -49,6 +50,7 @@
 import java.util.ArrayList;
 
 import org.codeaurora.internal.IExtTelephony;
+import org.codeaurora.ims.QtiCallConstants;
 
 /**
  * This class contains Qti specific utiltity functions.
@@ -420,4 +422,21 @@
         }
         return (dsdaEnabled == null) ? false : dsdaEnabled;
     }
+
+    /**
+     * This method converts the QtiCallConstants' Orientation modes to the ActivityInfo
+     * screen orientation mode.
+     */
+    public static int toUiOrientationMode(int orientationMode) {
+        switch(orientationMode) {
+            case QtiCallConstants.ORIENTATION_MODE_LANDSCAPE:
+                return ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
+            case QtiCallConstants.ORIENTATION_MODE_PORTRAIT:
+                return ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
+            case QtiCallConstants.ORIENTATION_MODE_DYNAMIC:
+                return ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR;
+            default:
+                return ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
+        }
+    }
 }
diff --git a/InCallUI/src/com/android/incallui/SessionModificationCauseNotifier.java b/InCallUI/src/com/android/incallui/SessionModificationCauseNotifier.java
new file mode 100644
index 0000000..034e029
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/SessionModificationCauseNotifier.java
@@ -0,0 +1,112 @@
+/* Copyright (c) 2015, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.android.incallui;
+
+import android.os.Bundle;
+import com.android.incallui.InCallPresenter.InCallDetailsListener;
+import com.google.common.base.Preconditions;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.List;
+
+import org.codeaurora.ims.QtiCallConstants;
+
+/**
+ * This class listens to incoming events from the {@class InCallDetailsListener}.
+ * When call details change, this class is notified and we parse the extras from the details to
+ * figure out if session modification cause has been sent when a call upgrades/downgrades and
+ * notify the {@class InCallMessageController} to display the indication on UI.
+ */
+public class SessionModificationCauseNotifier implements InCallDetailsListener{
+
+    private final List<InCallSessionModificationCauseListener> mSessionModificationCauseListeners
+            = new CopyOnWriteArrayList<>();
+
+    private static SessionModificationCauseNotifier sSessionModificationCauseNotifier;
+
+    /**
+     * Returns a singleton instance of {@class SessionModificationCauseNotifier}
+     */
+    public static synchronized SessionModificationCauseNotifier getInstance() {
+        if (sSessionModificationCauseNotifier == null) {
+            sSessionModificationCauseNotifier = new SessionModificationCauseNotifier();
+        }
+        return sSessionModificationCauseNotifier;
+    }
+
+    /**
+     * Adds a new session modification cause listener. Users interested in this cause
+     * should add a listener of type {@class InCallSessionModificationCauseListener}
+     */
+    public void addListener(InCallSessionModificationCauseListener listener) {
+        Preconditions.checkNotNull(listener);
+        mSessionModificationCauseListeners.add(listener);
+    }
+
+    /**
+     * Removes an existing session modification cause listener. Users listening to any cause
+     * changes when not interested any more can de-register an existing listener of type
+     * {@class InCallSessionModificationCauseListener}
+     */
+    public void removeListener(InCallSessionModificationCauseListener listener) {
+        if (listener != null) {
+            mSessionModificationCauseListeners.remove(listener);
+        } else {
+            Log.e(this, "Can't remove null listener");
+        }
+    }
+
+    /**
+     * Private constructor. Must use getInstance() to get this singleton.
+     */
+    private SessionModificationCauseNotifier() {
+    }
+
+    /**
+     * Overrides onDetailsChanged method of {@class InCallDetailsListener}. We are
+     * notified when call details change and extract the session modification cause from the
+     * extras, detect if the cause has changed and notify all registered listeners.
+     */
+    @Override
+    public void onDetailsChanged(Call call, android.telecom.Call.Details details) {
+        Log.d(this, "onDetailsChanged: - call: " + call + "details: " + details);
+        final Bundle extras =  (call != null && details != null) ? details.getExtras() : null;
+        final int sessionModificationCause = (extras != null) ? extras.getInt(
+                QtiCallConstants.SESSION_MODIFICATION_CAUSE_EXTRA_KEY,
+                QtiCallConstants.CAUSE_CODE_UNSPECIFIED) :
+                QtiCallConstants.CAUSE_CODE_UNSPECIFIED;
+
+        if (sessionModificationCause != QtiCallConstants.CAUSE_CODE_UNSPECIFIED) {
+            Preconditions.checkNotNull(mSessionModificationCauseListeners);
+            for (InCallSessionModificationCauseListener listener :
+                    mSessionModificationCauseListeners) {
+                listener.onSessionModificationCauseChanged(call, sessionModificationCause);
+            }
+        }
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/VideoCallPresenter.java b/InCallUI/src/com/android/incallui/VideoCallPresenter.java
index df4060e..7d71078 100644
--- a/InCallUI/src/com/android/incallui/VideoCallPresenter.java
+++ b/InCallUI/src/com/android/incallui/VideoCallPresenter.java
@@ -574,6 +574,7 @@
         } else if (isVideoCall) {
             Log.d(this, "onPrimaryCallChanged: Entering video mode...");
 
+            checkForOrientationAllowedChange(newPrimaryCall);
             updateCameraSelection(newPrimaryCall);
             enterVideoMode(newPrimaryCall);
         }
@@ -631,8 +632,12 @@
     }
 
     private void checkForOrientationAllowedChange(Call call) {
-        InCallPresenter.getInstance().setInCallAllowsOrientationChange(
-                VideoUtils.isVideoCall(call));
+        final int currMode = OrientationModeHandler.getInstance().getCurrentOrientation();
+        final int newMode = OrientationModeHandler.getInstance().getOrientation(call);
+
+        if (newMode != currMode) {
+            InCallPresenter.getInstance().setInCallAllowsOrientationChange(newMode);
+        }
     }
 
     /**