Modify to notify MediaQualityStatus checking media direction am: 80fb0bc91a

Original change: https://googleplex-android-review.googlesource.com/c/platform/packages/modules/ImsMedia/+/21872461

Change-Id: Ib18e64413b68c9b5e67129b79a1b5bd52e485bf4
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

4 files changed, 145 insertions, 19 deletions

diff --git a/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/AudioSession.cpp b/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/AudioSession.cpp
index 31d44ea7..f872d730 100644
--- a/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/AudioSession.cpp
+++ b/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/AudioSession.cpp
@@ -125,10 +125,8 @@ ImsMediaResult AudioSession::startGraph(RtpConfig* config)
 
     IMLOGI1("[startGraph] state[%d]", getState());
 
-    if (mMediaQualityAnalyzer != nullptr &&
-            !mMediaQualityAnalyzer->isSameConfig(reinterpret_cast<AudioConfig*>(config)))
+    if (mMediaQualityAnalyzer != nullptr)
     {
-        mMediaQualityAnalyzer->stop();
         mMediaQualityAnalyzer->setConfig(reinterpret_cast<AudioConfig*>(config));
         mMediaQualityAnalyzer->start();
     }
diff --git a/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/MediaQualityAnalyzer.cpp b/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/MediaQualityAnalyzer.cpp
index 491d9172..4661ee0e 100644
--- a/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/MediaQualityAnalyzer.cpp
+++ b/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/MediaQualityAnalyzer.cpp
@@ -26,6 +26,8 @@
 #include <algorithm>
 #include <numeric>
 
+using namespace android::telephony::imsmedia;
+
 #define DEFAULT_PARAM                            (-1)
 #define DEFAULT_INACTIVITY_TIME_FOR_CALL_QUALITY (4)
 #define CALL_QUALITY_MONITORING_TIME             (5)
@@ -34,12 +36,17 @@
 #define TIMER_INTERVAL                           (1000)   // 1 sec
 #define STOP_TIMEOUT                             (1000)   // 1 sec
 #define MESSAGE_PROCESSING_INTERVAL              (20000)  // 20 msec
+#define MEDIA_DIRECTION_CONTAINS_RECEIVE(a)            \
+    ((a) == RtpConfig::MEDIA_DIRECTION_SEND_RECEIVE || \
+            (a) == RtpConfig::MEDIA_DIRECTION_RECEIVE_ONLY)
 
 MediaQualityAnalyzer::MediaQualityAnalyzer()
 {
     mTimeStarted = 0;
     mCodecType = 0;
     mCodecAttribute = 0;
+    mIsRxRtpEnabled = false;
+    mIsRtcpEnabled = false;
     mCallback = nullptr;
     std::unique_ptr<RtcpXrEncoder> analyzer(new RtcpXrEncoder());
     mRtcpXrEncoder = std::move(analyzer);
@@ -67,10 +74,17 @@ MediaQualityAnalyzer::~MediaQualityAnalyzer()
 
 void MediaQualityAnalyzer::setConfig(AudioConfig* config)
 {
+    if (!isSameConfig(config))
+    {
+        reset();
+    }
+
+    mIsRxRtpEnabled = MEDIA_DIRECTION_CONTAINS_RECEIVE(config->getMediaDirection());
     mCodecType = config->getCodecType();
     mCodecAttribute = config->getEvsParams().getEvsBandwidth();
 
-    IMLOGD2("[setCodecType] type[%d], bandwidth[%d]", mCodecType, mCodecAttribute);
+    mCallQuality.setCodecType(convertAudioCodecType(
+            mCodecType, ImsMediaAudioUtil::FindMaxEvsBandwidthFromRange(mCodecAttribute)));
 
     if (mCodecType == AudioConfig::CODEC_AMR)
     {
@@ -80,6 +94,20 @@ void MediaQualityAnalyzer::setConfig(AudioConfig* config)
     {
         mRtcpXrEncoder->setSamplingRate(16);
     }
+
+    // Enable RTCP if both interval and direction is valid
+    bool isRtcpEnabled = (config->getRtcpConfig().getIntervalSec() > 0 &&
+            config->getMediaDirection() != RtpConfig::MEDIA_DIRECTION_NO_FLOW);
+
+    if (mIsRtcpEnabled != isRtcpEnabled)
+    {
+        mIsRtcpEnabled = isRtcpEnabled;
+        mCountRtcpInactivity = 0;
+        mNumRtcpPacketReceived = 0;
+    }
+
+    IMLOGI4("[setConfig] codec type[%d], bandwidth[%d], rxRtp[%d], rtcp[%d]", mCodecType,
+            mCodecAttribute, mIsRxRtpEnabled, mIsRtcpEnabled);
 }
 
 void MediaQualityAnalyzer::setCallback(BaseSessionCallback* callback)
@@ -112,16 +140,18 @@ void MediaQualityAnalyzer::setMediaQualityThreshold(const MediaQualityThreshold&
 bool MediaQualityAnalyzer::isSameConfig(AudioConfig* config)
 {
     return (mCodecType == config->getCodecType() &&
-            mCodecAttribute == config->getEvsParams().getEvsBandwidth());
+            mCodecAttribute == config->getEvsParams().getEvsBandwidth() &&
+            mIsRxRtpEnabled == MEDIA_DIRECTION_CONTAINS_RECEIVE(config->getMediaDirection()));
 }
 
 void MediaQualityAnalyzer::start()
 {
-    IMLOGD0("[start]");
-    mCallQuality.setCodecType(convertAudioCodecType(
-            mCodecType, ImsMediaAudioUtil::FindMaxEvsBandwidthFromRange(mCodecAttribute)));
-    mTimeStarted = ImsMediaTimer::GetTimeInMilliSeconds();
-    StartThread();
+    if (IsThreadStopped())
+    {
+        IMLOGD0("[start]");
+        mTimeStarted = ImsMediaTimer::GetTimeInMilliSeconds();
+        StartThread();
+    }
 }
 
 void MediaQualityAnalyzer::stop()
@@ -392,7 +422,7 @@ void MediaQualityAnalyzer::processData(const int32_t timeCount)
 void MediaQualityAnalyzer::processMediaQuality()
 {
     // media quality rtp inactivity
-    if (mNumRxPacket == 0)
+    if (mNumRxPacket == 0 && mIsRxRtpEnabled)
     {
         mCountRtpInactivity += 1000;
     }
@@ -404,7 +434,7 @@ void MediaQualityAnalyzer::processMediaQuality()
     }
 
     // media quality rtcp inactivity
-    if (mNumRtcpPacketReceived == 0)
+    if (mNumRtcpPacketReceived == 0 && mIsRtcpEnabled)
     {
         mCountRtcpInactivity += 1000;
     }
@@ -468,7 +498,7 @@ void MediaQualityAnalyzer::processMediaQuality()
     bool shouldNotify = false;
 
     // check jitter notification
-    if (!mJitterThreshold.empty())
+    if (!mJitterThreshold.empty() && mIsRxRtpEnabled)
     {
         if (mJitterChecker.checkNotifiable(mJitterThreshold, mQualityStatus.getRtpJitterMillis()))
         {
@@ -477,7 +507,7 @@ void MediaQualityAnalyzer::processMediaQuality()
     }
 
     // check packet loss notification
-    if (!mPacketLossThreshold.empty())
+    if (!mPacketLossThreshold.empty() && mIsRxRtpEnabled)
     {
         if (mPacketLossChecker.checkNotifiable(
                     mPacketLossThreshold, mQualityStatus.getRtpPacketLossRate()))
@@ -500,7 +530,7 @@ void MediaQualityAnalyzer::processMediaQuality()
         return;
     }
 
-    if (!mCurrentRtpInactivityTimes.empty())
+    if (!mCurrentRtpInactivityTimes.empty() && mIsRxRtpEnabled)
     {
         std::vector<int32_t>::iterator rtpIter = std::find_if(mCurrentRtpInactivityTimes.begin(),
                 mCurrentRtpInactivityTimes.end(),
@@ -518,7 +548,7 @@ void MediaQualityAnalyzer::processMediaQuality()
         }
     }
 
-    if (mRtcpInactivityTime != 0 && mCountRtcpInactivity == mRtcpInactivityTime)
+    if (mRtcpInactivityTime != 0 && mCountRtcpInactivity == mRtcpInactivityTime && mIsRtcpEnabled)
     {
         notifyMediaQualityStatus();
         mCountRtcpInactivity = 0;
@@ -754,6 +784,17 @@ void MediaQualityAnalyzer::reset()
     mNumRxPacket = 0;
     mNumLostPacket = 0;
     mJitterRxPacket = 0.0;
+
+    // rtp and rtcp inactivity
+    mCountRtpInactivity = 0;
+    mCountRtcpInactivity = 0;
+    mNumRtcpPacketReceived = 0;
+
+    // reset the status
+    mQualityStatus = MediaQualityStatus();
+
+    mPacketLossChecker.initialize(mRtpHysteresisTime);
+    mJitterChecker.initialize(mRtpHysteresisTime);
 }
 
 void MediaQualityAnalyzer::clearPacketList(std::list<RtpPacket*>& list, const int32_t seq)
diff --git a/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/include/audio/MediaQualityAnalyzer.h b/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/include/audio/MediaQualityAnalyzer.h
index f83ea088..feff4892 100644
--- a/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/include/audio/MediaQualityAnalyzer.h
+++ b/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/include/audio/MediaQualityAnalyzer.h
@@ -256,6 +256,10 @@ protected:
     int32_t mCodecType;
     /** The codec attribute of the audio session, it could be bandwidth in evs codec */
     int32_t mCodecAttribute;
+    /** Whether RTP is activated for the receiver or not */
+    bool mIsRxRtpEnabled;
+    /** Whether RTCP is activated for both sender and receiver */
+    bool mIsRtcpEnabled;
     /** The begin of the rx rtp packet sequence number for Rtcp-Xr report */
     int32_t mBeginSeq;
     /** The end of the rx rtp packet sequence number for Rtcp-Xr report */
diff --git a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/MediaQualityAnalyzerTest.cpp b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/MediaQualityAnalyzerTest.cpp
index bedb63bb..ba468406 100644
--- a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/MediaQualityAnalyzerTest.cpp
+++ b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/MediaQualityAnalyzerTest.cpp
@@ -26,7 +26,7 @@ using namespace android::telephony::imsmedia;
 using ::testing::_;
 
 // RtpConfig
-const int32_t kMediaDirection = RtpConfig::MEDIA_DIRECTION_INACTIVE;
+const int32_t kMediaDirection = RtpConfig::MEDIA_DIRECTION_SEND_RECEIVE;
 const android::String8 kRemoteAddress("127.0.0.1");
 const int32_t kRemotePort = 10000;
 const int8_t kDscp = 0;
@@ -128,6 +128,7 @@ public:
     {
         notifyCallQuality();
         reset();
+        counter = 0;
     }
 
     void testProcessCycle(const int32_t numCycle)
@@ -293,7 +294,7 @@ TEST_F(MediaQualityAnalyzerTest, TestCollectTxPackets)
 
 TEST_F(MediaQualityAnalyzerTest, TestRtpInactivityNotRunning)
 {
-    EXPECT_CALL(mCallback, onEvent(kAudioCallQualityChangedInd, _, _)).Times(1);
+    EXPECT_CALL(mCallback, onEvent(kAudioCallQualityChangedInd, _, _)).Times(2);
     EXPECT_CALL(mCallback, onEvent(kImsMediaEventMediaQualityStatus, _, _)).Times(0);
     MediaQualityThreshold threshold;
     threshold.setRtpInactivityTimerMillis(std::vector<int32_t>{0});
@@ -301,9 +302,61 @@ TEST_F(MediaQualityAnalyzerTest, TestRtpInactivityNotRunning)
     mAnalyzer->start();
     mAnalyzer->testProcessCycle(2);
     mAnalyzer->stop();
+
+    threshold.setRtpInactivityTimerMillis(std::vector<int32_t>{2000});
+    mConfig.setMediaDirection(RtpConfig::MEDIA_DIRECTION_INACTIVE);
+    mAnalyzer->setConfig(&mConfig);
+    mAnalyzer->setMediaQualityThreshold(threshold);
+    mAnalyzer->start();
+    mAnalyzer->testProcessCycle(2);
+    mAnalyzer->stop();
+}
+
+TEST_F(MediaQualityAnalyzerTest, TestRtpInactivityNoUpdateByDirection)
+{
+    EXPECT_CALL(mCallback, onEvent(kAudioCallQualityChangedInd, _, _)).Times(2);
+    EXPECT_CALL(mCallback, onEvent(kImsMediaEventMediaQualityStatus, _, _)).Times(1);
+    MediaQualityThreshold threshold;
+    threshold.setRtpInactivityTimerMillis(std::vector<int32_t>{4000});
+    mAnalyzer->setMediaQualityThreshold(threshold);
+    mAnalyzer->testProcessCycle(2);
+
+    mConfig.setMediaDirection(RtpConfig::MEDIA_DIRECTION_RECEIVE_ONLY);
+
+    if (!mAnalyzer->isSameConfig(&mConfig))
+    {
+        mAnalyzer->stop();
+        mAnalyzer->start();
+    }
+
+    mAnalyzer->testProcessCycle(2);
+    mAnalyzer->stop();
+    MediaQualityStatus quality = mFakeCallback.getMediaQualityStatus();
+    EXPECT_EQ(quality.getRtpInactivityTimeMillis(), 4000);
+}
+
+TEST_F(MediaQualityAnalyzerTest, TestRtpInactivityUpdateByDirection)
+{
+    EXPECT_CALL(mCallback, onEvent(kAudioCallQualityChangedInd, _, _)).Times(2);
+    EXPECT_CALL(mCallback, onEvent(kImsMediaEventMediaQualityStatus, _, _)).Times(1);
+    MediaQualityThreshold threshold;
+    threshold.setRtpInactivityTimerMillis(std::vector<int32_t>{2000});
+    mAnalyzer->setMediaQualityThreshold(threshold);
+    mAnalyzer->testProcessCycle(2);
+
+    mConfig.setMediaDirection(RtpConfig::MEDIA_DIRECTION_INACTIVE);
+
+    if (!mAnalyzer->isSameConfig(&mConfig))
+    {
+        mAnalyzer->stop();
+        mAnalyzer->start();
+    }
+
+    mAnalyzer->testProcessCycle(2);
+    mAnalyzer->stop();
 }
 
-TEST_F(MediaQualityAnalyzerTest, TestRtpInactivityRunning)
+TEST_F(MediaQualityAnalyzerTest, TestRtpInactivityUpdate)
 {
     EXPECT_CALL(mCallback, onEvent(kAudioCallQualityChangedInd, _, _)).Times(2);
     EXPECT_CALL(mCallback, onEvent(kImsMediaEventMediaQualityStatus, _, _)).Times(3);
@@ -334,6 +387,36 @@ TEST_F(MediaQualityAnalyzerTest, TestRtpInactivityRunning)
     mAnalyzer->stop();
 }
 
+TEST_F(MediaQualityAnalyzerTest, TestRtcpInactivityNotRunning)
+{
+    EXPECT_CALL(mCallback, onEvent(kAudioCallQualityChangedInd, _, _)).Times(3);
+    EXPECT_CALL(mCallback, onEvent(kImsMediaEventMediaQualityStatus, _, _)).Times(0);
+    MediaQualityThreshold threshold;
+    threshold.setRtcpInactivityTimerMillis(0);
+    mAnalyzer->setMediaQualityThreshold(threshold);
+    mAnalyzer->start();
+    mAnalyzer->testProcessCycle(2);
+    mAnalyzer->stop();
+
+    threshold.setRtcpInactivityTimerMillis(2000);
+    mConfig.setMediaDirection(RtpConfig::MEDIA_DIRECTION_NO_FLOW);
+    mAnalyzer->setConfig(&mConfig);
+    mAnalyzer->setMediaQualityThreshold(threshold);
+    mAnalyzer->start();
+    mAnalyzer->testProcessCycle(2);
+    mAnalyzer->stop();
+
+    threshold.setRtcpInactivityTimerMillis(2000);
+    mRtcpConfig.setIntervalSec(0);
+    mConfig.setMediaDirection(RtpConfig::MEDIA_DIRECTION_INACTIVE);
+    mConfig.setRtcpConfig(mRtcpConfig);
+    mAnalyzer->setConfig(&mConfig);
+    mAnalyzer->setMediaQualityThreshold(threshold);
+    mAnalyzer->start();
+    mAnalyzer->testProcessCycle(2);
+    mAnalyzer->stop();
+}
+
 TEST_F(MediaQualityAnalyzerTest, TestRtcpInactivity)
 {
     EXPECT_CALL(mCallback, onEvent(kAudioCallQualityChangedInd, _, _)).Times(2);