Implementation of processing MediaQualityThreshold in libimsmedia

1) Implementation of procesing MediaQualityThreshold to handle the array
type of RtpInctivity, PacketLoss, Jitter threshold and additional
parameters
2) Implementation of send the notification of MediaQualityStatus
3) Change the name of legacy MediaQuality to CallQuality to prevent the
   confusion.

Bug: 255862778
Test: atest ImsMediaNativeTests, verified by loopback test using ImsMediaTestingApp
Change-Id: Id634272210ec3c21fc6e9a775bdad8d5a49273cb

8 files changed, 288 insertions, 121 deletions

diff --git a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/config/MediaQualityTest.cpp b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/config/CallQualityTest.cpp
index 796bc28f..5fcc6f9b 100644
--- a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/config/MediaQualityTest.cpp
+++ b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/config/CallQualityTest.cpp
@@ -15,7 +15,7 @@
  */
 
 #include <AudioConfig.h>
-#include <MediaQuality.h>
+#include <CallQuality.h>
 #include <gtest/gtest.h>
 
 using namespace android::telephony::imsmedia;
@@ -42,12 +42,12 @@ const int64_t kMaxPlayoutDelayMillis = 180;
 const int32_t kNumRtpSidPacketsReceived = 10;
 const int32_t kNumRtpDuplicatePackets = 1;
 
-class MediaQualityTest : public ::testing::Test
+class CallQualityTest : public ::testing::Test
 {
 public:
-    MediaQuality quality1;
-    MediaQuality quality2;
-    MediaQuality quality3;
+    CallQuality quality1;
+    CallQuality quality2;
+    CallQuality quality3;
 
 protected:
     virtual void SetUp() override
@@ -78,26 +78,26 @@ protected:
     virtual void TearDown() override {}
 };
 
-TEST_F(MediaQualityTest, TestGetterSetter) {}
+TEST_F(CallQualityTest, TestGetterSetter) {}
 
-TEST_F(MediaQualityTest, TestParcel)
+TEST_F(CallQualityTest, TestParcel)
 {
     android::Parcel parcel;
     quality1.writeToParcel(&parcel);
     parcel.setDataPosition(0);
 
-    MediaQuality testQuality;
+    CallQuality testQuality;
     testQuality.readFromParcel(&parcel);
     EXPECT_EQ(testQuality, quality1);
 }
 
-TEST_F(MediaQualityTest, TestAssign)
+TEST_F(CallQualityTest, TestAssign)
 {
-    MediaQuality testQuality = quality1;
+    CallQuality testQuality = quality1;
     EXPECT_EQ(quality1, testQuality);
 }
 
-TEST_F(MediaQualityTest, TestEqual)
+TEST_F(CallQualityTest, TestEqual)
 {
     quality2.setDownlinkCallQualityLevel(kDownlinkCallQualityLevel);
     quality2.setUplinkCallQualityLevel(kUplinkCallQualityLevel);
@@ -123,7 +123,7 @@ TEST_F(MediaQualityTest, TestEqual)
     EXPECT_EQ(quality2, quality1);
 }
 
-TEST_F(MediaQualityTest, TestNotEqual)
+TEST_F(CallQualityTest, TestNotEqual)
 {
     quality2.setDownlinkCallQualityLevel(kDownlinkCallQualityLevel);
     quality2.setUplinkCallQualityLevel(kUplinkCallQualityLevel);
diff --git a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/config/MediaQualityStatusTest.cpp b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/config/MediaQualityStatusTest.cpp
new file mode 100644
index 00000000..c32c2d2a
--- /dev/null
+++ b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/config/MediaQualityStatusTest.cpp
@@ -0,0 +1,95 @@
+/**
+ * Copyright (C) 2023 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.
+ */
+
+#include <MediaQualityStatus.h>
+#include <gtest/gtest.h>
+
+using namespace android::telephony::imsmedia;
+
+const int32_t kRtpInactivityTimeMillis = 10000;
+const int32_t kRtcpInactivityTimeMillis = 10000;
+const int32_t kRtpPacketLossRate = 1;
+const int32_t kRtpJitterMillis = 100;
+
+class MediaQualityStatusTest : public ::testing::Test
+{
+public:
+    MediaQualityStatus status;
+
+protected:
+    virtual void SetUp() override
+    {
+        status.setRtpInactivityTimeMillis(kRtpInactivityTimeMillis);
+        status.setRtcpInactivityTimeMillis(kRtcpInactivityTimeMillis);
+        status.setRtpPacketLossRate(kRtpPacketLossRate);
+        status.setRtpJitterMillis(kRtpJitterMillis);
+    }
+
+    virtual void TearDown() override {}
+};
+
+TEST_F(MediaQualityStatusTest, TestGetterSetter)
+{
+    EXPECT_EQ(status.getRtpInactivityTimeMillis(), kRtpInactivityTimeMillis);
+    EXPECT_EQ(status.getRtcpInactivityTimeMillis(), kRtcpInactivityTimeMillis);
+    EXPECT_EQ(status.getRtpPacketLossRate(), kRtpPacketLossRate);
+    EXPECT_EQ(status.getRtpJitterMillis(), kRtpJitterMillis);
+}
+
+TEST_F(MediaQualityStatusTest, TestParcel)
+{
+    android::Parcel parcel;
+    status.writeToParcel(&parcel);
+    parcel.setDataPosition(0);
+
+    MediaQualityStatus testThreshold;
+    testThreshold.readFromParcel(&parcel);
+    EXPECT_EQ(testThreshold, status);
+}
+
+TEST_F(MediaQualityStatusTest, TestAssign)
+{
+    MediaQualityStatus status2 = status;
+    EXPECT_EQ(status, status2);
+}
+
+TEST_F(MediaQualityStatusTest, TestEqual)
+{
+    MediaQualityStatus status2;
+    status2.setRtpInactivityTimeMillis(kRtpInactivityTimeMillis);
+    status2.setRtcpInactivityTimeMillis(kRtcpInactivityTimeMillis);
+    status2.setRtpPacketLossRate(kRtpPacketLossRate);
+    status2.setRtpJitterMillis(kRtpJitterMillis);
+    EXPECT_EQ(status, status2);
+}
+
+TEST_F(MediaQualityStatusTest, TestNotEqual)
+{
+    MediaQualityStatus status2;
+    status2.setRtpInactivityTimeMillis(15000);
+    status2.setRtcpInactivityTimeMillis(kRtcpInactivityTimeMillis);
+    status2.setRtpPacketLossRate(kRtpPacketLossRate);
+    status2.setRtpJitterMillis(kRtpJitterMillis);
+
+    MediaQualityStatus status3;
+    status3.setRtpInactivityTimeMillis(kRtpInactivityTimeMillis);
+    status3.setRtcpInactivityTimeMillis(kRtcpInactivityTimeMillis);
+    status3.setRtpPacketLossRate(3);
+    status3.setRtpJitterMillis(kRtpJitterMillis);
+
+    EXPECT_NE(status, status2);
+    EXPECT_NE(status, status3);
+}
\ No newline at end of file
diff --git a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/config/MediaQualityThresholdTest.cpp b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/config/MediaQualityThresholdTest.cpp
index c3090a48..1ab1ff01 100644
--- a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/config/MediaQualityThresholdTest.cpp
+++ b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/config/MediaQualityThresholdTest.cpp
@@ -19,29 +19,29 @@
 
 using namespace android::telephony::imsmedia;
 
-const int32_t kRtpInactivityTimerMillis = 10000;
+const std::vector<int32_t> kRtpInactivityTimerMillis = {10000, 20000};
 const int32_t kRtcpInactivityTimerMillis = 20000;
+const int32_t kRtpHysteresisTimeInMillis = 3000;
 const int32_t kRtpPacketLossDurationMillis = 5000;
-const int32_t kRtpPacketLossRate = 5;
-const int32_t kJitterDurationMillis = 5000;
-const int32_t kRtpJitterMillis = 300;
+const std::vector<int32_t> kRtpPacketLossRate = {3, 5};
+const std::vector<int32_t> kRtpJitterMillis = {100, 200};
+const bool kNotifyCurrentStatus = false;
 
 class MediaQualityThresholdTest : public ::testing::Test
 {
 public:
-    MediaQualityThreshold threshold1;
-    MediaQualityThreshold threshold2;
-    MediaQualityThreshold threshold3;
+    MediaQualityThreshold threshold;
 
 protected:
     virtual void SetUp() override
     {
-        threshold1.setRtpInactivityTimerMillis(kRtpInactivityTimerMillis);
-        threshold1.setRtcpInactivityTimerMillis(kRtcpInactivityTimerMillis);
-        threshold1.setRtpPacketLossDurationMillis(kRtpPacketLossDurationMillis);
-        threshold1.setRtpPacketLossRate(kRtpPacketLossRate);
-        threshold1.setJitterDurationMillis(kJitterDurationMillis);
-        threshold1.setRtpJitterMillis(kRtpJitterMillis);
+        threshold.setRtpInactivityTimerMillis(kRtpInactivityTimerMillis);
+        threshold.setRtcpInactivityTimerMillis(kRtcpInactivityTimerMillis);
+        threshold.setRtpHysteresisTimeInMillis(kRtpHysteresisTimeInMillis);
+        threshold.setRtpPacketLossDurationMillis(kRtpPacketLossDurationMillis);
+        threshold.setRtpPacketLossRate(kRtpPacketLossRate);
+        threshold.setRtpJitterMillis(kRtpJitterMillis);
+        threshold.setNotifyCurrentStatus(kNotifyCurrentStatus);
     }
 
     virtual void TearDown() override {}
@@ -49,59 +49,65 @@ protected:
 
 TEST_F(MediaQualityThresholdTest, TestGetterSetter)
 {
-    EXPECT_EQ(threshold1.getRtpInactivityTimerMillis(), kRtpInactivityTimerMillis);
-    EXPECT_EQ(threshold1.getRtcpInactivityTimerMillis(), kRtcpInactivityTimerMillis);
-    EXPECT_EQ(threshold1.getRtpPacketLossDurationMillis(), kRtpPacketLossDurationMillis);
-    EXPECT_EQ(threshold1.getRtpPacketLossRate(), kRtpPacketLossRate);
-    EXPECT_EQ(threshold1.getJitterDurationMillis(), kJitterDurationMillis);
-    EXPECT_EQ(threshold1.getRtpJitterMillis(), kRtpJitterMillis);
+    EXPECT_EQ(threshold.getRtpInactivityTimerMillis(), kRtpInactivityTimerMillis);
+    EXPECT_EQ(threshold.getRtcpInactivityTimerMillis(), kRtcpInactivityTimerMillis);
+    EXPECT_EQ(threshold.getRtpHysteresisTimeInMillis(), kRtpHysteresisTimeInMillis);
+    EXPECT_EQ(threshold.getRtpPacketLossDurationMillis(), kRtpPacketLossDurationMillis);
+    EXPECT_EQ(threshold.getRtpPacketLossRate(), kRtpPacketLossRate);
+    EXPECT_EQ(threshold.getRtpJitterMillis(), kRtpJitterMillis);
+    EXPECT_EQ(threshold.getNotifyCurrentStatus(), kNotifyCurrentStatus);
 }
 
 TEST_F(MediaQualityThresholdTest, TestParcel)
 {
     android::Parcel parcel;
-    threshold1.writeToParcel(&parcel);
+    threshold.writeToParcel(&parcel);
     parcel.setDataPosition(0);
 
     MediaQualityThreshold testThreshold;
     testThreshold.readFromParcel(&parcel);
-    EXPECT_EQ(testThreshold, threshold1);
+    EXPECT_EQ(testThreshold, threshold);
 }
 
 TEST_F(MediaQualityThresholdTest, TestAssign)
 {
-    MediaQualityThreshold threshold2 = threshold1;
-    EXPECT_EQ(threshold1, threshold2);
+    MediaQualityThreshold threshold2 = threshold;
+    EXPECT_EQ(threshold, threshold2);
 }
 
 TEST_F(MediaQualityThresholdTest, TestEqual)
 {
+    MediaQualityThreshold threshold2;
     threshold2.setRtpInactivityTimerMillis(kRtpInactivityTimerMillis);
     threshold2.setRtcpInactivityTimerMillis(kRtcpInactivityTimerMillis);
+    threshold2.setRtpHysteresisTimeInMillis(kRtpHysteresisTimeInMillis);
     threshold2.setRtpPacketLossDurationMillis(kRtpPacketLossDurationMillis);
     threshold2.setRtpPacketLossRate(kRtpPacketLossRate);
-    threshold2.setJitterDurationMillis(kJitterDurationMillis);
     threshold2.setRtpJitterMillis(kRtpJitterMillis);
-
-    EXPECT_EQ(threshold1, threshold2);
+    threshold2.setNotifyCurrentStatus(kNotifyCurrentStatus);
+    EXPECT_EQ(threshold, threshold2);
 }
 
 TEST_F(MediaQualityThresholdTest, TestNotEqual)
 {
-    threshold2.setRtpInactivityTimerMillis(5000);
+    MediaQualityThreshold threshold2;
+    threshold2.setRtpInactivityTimerMillis(std::vector<int32_t>{3000, 5000});
     threshold2.setRtcpInactivityTimerMillis(kRtcpInactivityTimerMillis);
+    threshold2.setRtpHysteresisTimeInMillis(kRtpHysteresisTimeInMillis);
     threshold2.setRtpPacketLossDurationMillis(kRtpPacketLossDurationMillis);
     threshold2.setRtpPacketLossRate(kRtpPacketLossRate);
-    threshold2.setJitterDurationMillis(kJitterDurationMillis);
     threshold2.setRtpJitterMillis(kRtpJitterMillis);
+    threshold2.setNotifyCurrentStatus(kNotifyCurrentStatus);
 
+    MediaQualityThreshold threshold3;
     threshold3.setRtpInactivityTimerMillis(kRtpInactivityTimerMillis);
     threshold3.setRtcpInactivityTimerMillis(kRtcpInactivityTimerMillis);
+    threshold3.setRtpHysteresisTimeInMillis(kRtpHysteresisTimeInMillis);
     threshold3.setRtpPacketLossDurationMillis(kRtpPacketLossDurationMillis);
-    threshold3.setRtpPacketLossRate(1);
-    threshold3.setJitterDurationMillis(kJitterDurationMillis);
+    threshold3.setRtpPacketLossRate(std::vector<int32_t>{5, 10});
     threshold3.setRtpJitterMillis(kRtpJitterMillis);
+    threshold3.setNotifyCurrentStatus(kNotifyCurrentStatus);
 
-    EXPECT_NE(threshold1, threshold2);
-    EXPECT_NE(threshold1, threshold3);
+    EXPECT_NE(threshold, threshold2);
+    EXPECT_NE(threshold, threshold3);
 }
\ No newline at end of file
diff --git a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/AudioStreamGraphRtcpTest.cpp b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/AudioStreamGraphRtcpTest.cpp
index 895f19ce..1d165c6a 100644
--- a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/AudioStreamGraphRtcpTest.cpp
+++ b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/AudioStreamGraphRtcpTest.cpp
@@ -74,7 +74,6 @@ protected:
     RtcpConfig rtcp;
     AmrParams amr;
     EvsParams evs;
-    MediaQualityThreshold threshold;
     int socketRtcpFd;
 
     virtual void SetUp() override
@@ -94,8 +93,6 @@ protected:
         evs.setUseHeaderFullOnly(kUseHeaderFullOnly);
         evs.setCodecModeRequest(kcodecModeRequest);
 
-        threshold.setRtcpInactivityTimerMillis(10000);
-
         config.setMediaDirection(kMediaDirection);
         config.setRemoteAddress(kRemoteAddress);
         config.setRemotePort(kRemotePort);
@@ -142,28 +139,9 @@ TEST_F(AudioStreamGraphRtcpTest, TestGraphError)
     EXPECT_EQ(graph->getState(), kStreamStateIdle);
 }
 
-TEST_F(AudioStreamGraphRtcpTest, TestGraphSetMediaThresholdFail)
-{
-    EXPECT_EQ(graph->setMediaQualityThreshold(&threshold), false);
-}
-
-TEST_F(AudioStreamGraphRtcpTest, TestGraphSetMediaThresholdSuccess)
-{
-    EXPECT_EQ(graph->create(&config), RESULT_SUCCESS);
-    EXPECT_EQ(graph->setMediaQualityThreshold(&threshold), true);
-    EXPECT_EQ(graph->start(), RESULT_SUCCESS);
-    EXPECT_EQ(graph->getState(), kStreamStateRunning);
-
-    // live update
-    EXPECT_EQ(graph->setMediaQualityThreshold(&threshold), true);
-    EXPECT_EQ(graph->stop(), RESULT_SUCCESS);
-    EXPECT_EQ(graph->getState(), kStreamStateCreated);
-}
-
 TEST_F(AudioStreamGraphRtcpTest, TestRtcpStreamAndUpdate)
 {
     EXPECT_EQ(graph->create(&config), RESULT_SUCCESS);
-    EXPECT_EQ(graph->setMediaQualityThreshold(&threshold), true);
     EXPECT_EQ(graph->start(), RESULT_SUCCESS);
     EXPECT_EQ(graph->getState(), kStreamStateRunning);
 
diff --git a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/AudioStreamGraphRtpRxTest.cpp b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/AudioStreamGraphRtpRxTest.cpp
index 4f8cd554..f539e88e 100644
--- a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/AudioStreamGraphRtpRxTest.cpp
+++ b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/AudioStreamGraphRtpRxTest.cpp
@@ -74,7 +74,6 @@ protected:
     RtcpConfig rtcp;
     AmrParams amr;
     EvsParams evs;
-    MediaQualityThreshold threshold;
     int socketRtpFd;
 
     virtual void SetUp() override
@@ -94,8 +93,6 @@ protected:
         evs.setUseHeaderFullOnly(kUseHeaderFullOnly);
         evs.setCodecModeRequest(kcodecModeRequest);
 
-        threshold.setRtpInactivityTimerMillis(10000);
-
         config.setMediaDirection(kMediaDirection);
         config.setRemoteAddress(kRemoteAddress);
         config.setRemotePort(kRemotePort);
@@ -142,28 +139,9 @@ TEST_F(AudioStreamGraphRtpRxTest, TestGraphError)
     EXPECT_EQ(graph->getState(), kStreamStateIdle);
 }
 
-TEST_F(AudioStreamGraphRtpRxTest, TestGraphSetMediaThresholdFail)
-{
-    EXPECT_EQ(graph->setMediaQualityThreshold(&threshold), false);
-}
-
-TEST_F(AudioStreamGraphRtpRxTest, TestGraphSetMediaThresholdSuccess)
-{
-    EXPECT_EQ(graph->create(&config), RESULT_SUCCESS);
-    EXPECT_EQ(graph->setMediaQualityThreshold(&threshold), true);
-    EXPECT_EQ(graph->start(), RESULT_SUCCESS);
-    EXPECT_EQ(graph->getState(), kStreamStateRunning);
-
-    // live update
-    EXPECT_EQ(graph->setMediaQualityThreshold(&threshold), true);
-    EXPECT_EQ(graph->stop(), RESULT_SUCCESS);
-    EXPECT_EQ(graph->getState(), kStreamStateCreated);
-}
-
 TEST_F(AudioStreamGraphRtpRxTest, TestRtpRxStreamDirectionUpdate)
 {
     EXPECT_EQ(graph->create(&config), RESULT_SUCCESS);
-    EXPECT_EQ(graph->setMediaQualityThreshold(&threshold), true);
     EXPECT_EQ(graph->start(), RESULT_SUCCESS);
     EXPECT_EQ(graph->getState(), kStreamStateRunning);
 
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 c0d7b2ea..56bed86e 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
@@ -62,26 +62,42 @@ const int32_t kEvsMode = 8;
 const int8_t kChannelAwareMode = 3;
 const bool kUseHeaderFullOnly = false;
 
+// MediaQualityThreshold
+const std::vector<int32_t> kRtpInactivityTimerMillis = {2000, 4000};
+const int32_t kRtcpInactivityTimerMillis = 2000;
+const int32_t kRtpHysteresisTimeInMillis = 2000;
+const int32_t kRtpPacketLossDurationMillis = 3000;
+const std::vector<int32_t> kRtpPacketLossRate = {3, 5};
+const std::vector<int32_t> kRtpJitterMillis = {10, 20};
+
 class FakeMediaQualityCallback : public BaseSessionCallback
 {
 public:
     FakeMediaQualityCallback() {}
     virtual ~FakeMediaQualityCallback() {}
 
-    virtual void SendEvent(int32_t type, uint64_t param1, uint64_t param2)
+    virtual void SendEvent(int32_t type, uint64_t param1, uint64_t /*param2*/)
     {
-        (void)param2;
-
         if (type == kAudioCallQualityChangedInd)
         {
-            MediaQuality* quality = reinterpret_cast<MediaQuality*>(param1);
+            CallQuality* quality = reinterpret_cast<CallQuality*>(param1);
 
             if (quality != nullptr)
             {
-                mMediaQuality = *quality;
+                mCallQuality = *quality;
                 delete quality;
             }
         }
+        else if (type == kImsMediaEventMediaQualityStatus)
+        {
+            MediaQualityStatus* status = reinterpret_cast<MediaQualityStatus*>(param1);
+
+            if (status != nullptr)
+            {
+                mStatus = *status;
+                delete status;
+            }
+        }
     }
 
     virtual void onEvent(int32_t type, uint64_t param1, uint64_t param2)
@@ -91,10 +107,12 @@ public:
         (void)param2;
     }
 
-    MediaQuality getMediaQuality() { return mMediaQuality; }
+    CallQuality getCallQuality() { return mCallQuality; }
+    MediaQualityStatus getMediaQualityStatus() { return mStatus; }
 
 private:
-    MediaQuality mMediaQuality;
+    CallQuality mCallQuality;
+    MediaQualityStatus mStatus;
 };
 
 class MediaQualityAnalyzerTest : public ::testing::Test
@@ -171,10 +189,10 @@ TEST_F(MediaQualityAnalyzerTest, TestStartStop)
     EXPECT_CALL(mCallback, onEvent(kAudioCallQualityChangedInd, _, _)).Times(1);
     mAnalyzer->start();
 
-    MediaQuality quality = mAnalyzer->getMediaQuality();
+    CallQuality quality = mAnalyzer->getCallQuality();
     mAnalyzer->stop();
 
-    EXPECT_EQ(mFakeCallback.getMediaQuality(), quality);
+    EXPECT_EQ(mFakeCallback.getCallQuality(), quality);
 }
 
 TEST_F(MediaQualityAnalyzerTest, TestCollectTxPackets)
@@ -194,30 +212,90 @@ TEST_F(MediaQualityAnalyzerTest, TestCollectTxPackets)
     EXPECT_EQ(mAnalyzer->getTxPacketSize(), numPackets);
     EXPECT_EQ(mAnalyzer->getRxPacketSize(), 0);
     EXPECT_EQ(mAnalyzer->getLostPacketSize(), 0);
-    MediaQuality quality = mAnalyzer->getMediaQuality();
+    CallQuality quality = mAnalyzer->getCallQuality();
     mAnalyzer->stop();
 
     EXPECT_EQ(mAnalyzer->getTxPacketSize(), 0);
     EXPECT_EQ(mAnalyzer->getRxPacketSize(), 0);
     EXPECT_EQ(mAnalyzer->getLostPacketSize(), 0);
 
-    // Check MediaQuality value
-    MediaQuality quality2 = mFakeCallback.getMediaQuality();
+    // Check CallQuality value
+    CallQuality quality2 = mFakeCallback.getCallQuality();
     EXPECT_EQ(quality2, quality);
     EXPECT_EQ(quality2.getNumRtpPacketsTransmitted(), numPackets);
 }
 
-TEST_F(MediaQualityAnalyzerTest, TestRxInactivityInd)
+TEST_F(MediaQualityAnalyzerTest, TestRtpInactivity)
 {
     EXPECT_CALL(mCallback, onEvent(kAudioCallQualityChangedInd, _, _)).Times(2);
+    EXPECT_CALL(mCallback, onEvent(kImsMediaEventMediaQualityStatus, _, _)).Times(3);
+    MediaQualityThreshold threshold;
+    threshold.setRtpInactivityTimerMillis(kRtpInactivityTimerMillis);
+    mAnalyzer->setMediaQualityThreshold(threshold);
     mAnalyzer->start();
-    mCondition.wait_timeout(5100);  // 5.1 sec
+    mCondition.wait_timeout(2100);  // 2.1 sec
+
+    // Check MediaQualityStatus value
+    MediaQualityStatus quality1 = mFakeCallback.getMediaQualityStatus();
+    EXPECT_EQ(quality1.getRtpInactivityTimeMillis(), 2000);
+
+    mCondition.wait_timeout(2100);  // 2.1 sec
 
-    MediaQuality quality = mAnalyzer->getMediaQuality();
+    // Check MediaQualityStatus value
+    MediaQualityStatus quality2 = mFakeCallback.getMediaQualityStatus();
+    EXPECT_EQ(quality2.getRtpInactivityTimeMillis(), 4000);
+
+    RtpPacket* packet = new RtpPacket();
+    packet->seqNum = 0;
+    mAnalyzer->SendEvent(kCollectPacketInfo, kStreamRtpRx, reinterpret_cast<uint64_t>(packet));
+
+    mCondition.wait_timeout(3100);  // 3.1 sec
+
+    MediaQualityStatus quality3 = mFakeCallback.getMediaQualityStatus();
+    EXPECT_EQ(quality3.getRtpInactivityTimeMillis(), 2000);
     mAnalyzer->stop();
+}
+
+TEST_F(MediaQualityAnalyzerTest, TestRtcpInactivity)
+{
+    EXPECT_CALL(mCallback, onEvent(kAudioCallQualityChangedInd, _, _)).Times(2);
+    EXPECT_CALL(mCallback, onEvent(kImsMediaEventMediaQualityStatus, _, _)).Times(3);
+    MediaQualityThreshold threshold;
+    threshold.setRtcpInactivityTimerMillis(kRtcpInactivityTimerMillis);
+    mAnalyzer->setMediaQualityThreshold(threshold);
+    mAnalyzer->start();
+    mCondition.wait_timeout(2100);  // 2.1 sec
+
+    // Check MediaQualityStatus value
+    MediaQualityStatus quality1 = mFakeCallback.getMediaQualityStatus();
+    EXPECT_EQ(quality1.getRtcpInactivityTimeMillis(), 2000);
+
+    mCondition.wait_timeout(2100);  // 2.1 sec
+
+    // Check MediaQualityStatus value
+    MediaQualityStatus quality2 = mFakeCallback.getMediaQualityStatus();
+    EXPECT_EQ(quality2.getRtcpInactivityTimeMillis(), 2000);
 
-    // Check MediaQuality value
-    MediaQuality quality2 = mFakeCallback.getMediaQuality();
+    mAnalyzer->SendEvent(kCollectPacketInfo, kStreamRtcp);
+
+    mCondition.wait_timeout(2100);  // 2.1 sec
+
+    MediaQualityStatus quality3 = mFakeCallback.getMediaQualityStatus();
+    EXPECT_EQ(quality3.getRtcpInactivityTimeMillis(), 2000);
+    mAnalyzer->stop();
+}
+
+TEST_F(MediaQualityAnalyzerTest, TestCallQualityInactivity)
+{
+    EXPECT_CALL(mCallback, onEvent(kAudioCallQualityChangedInd, _, _)).Times(2);
+    mAnalyzer->start();
+    mCondition.wait_timeout(4100);  // 4.1 sec
+
+    CallQuality quality = mAnalyzer->getCallQuality();
+    mAnalyzer->stop();
+
+    // Check CallQuality value
+    CallQuality quality2 = mFakeCallback.getCallQuality();
     EXPECT_EQ(quality2, quality);
     EXPECT_TRUE(quality2.getRtpInactivityDetected());
 }
@@ -256,26 +334,28 @@ TEST_F(MediaQualityAnalyzerTest, TestCallQualityLevelChanged)
     EXPECT_EQ(mAnalyzer->getTxPacketSize(), 0);
     EXPECT_EQ(mAnalyzer->getRxPacketSize(), numPackets - 1);
     EXPECT_EQ(mAnalyzer->getLostPacketSize(), 1);
-    MediaQuality quality = mAnalyzer->getMediaQuality();
+    CallQuality quality = mAnalyzer->getCallQuality();
     mAnalyzer->stop();
 
     EXPECT_EQ(mAnalyzer->getTxPacketSize(), 0);
     EXPECT_EQ(mAnalyzer->getRxPacketSize(), 0);
     EXPECT_EQ(mAnalyzer->getLostPacketSize(), 0);
 
-    // Check MediaQuality value
-    MediaQuality quality2 = mFakeCallback.getMediaQuality();
+    // Check CallQuality value
+    CallQuality quality2 = mFakeCallback.getCallQuality();
     EXPECT_EQ(quality2, quality);
     EXPECT_EQ(quality2.getNumRtpPacketsReceived(), numPackets - 1);
-    EXPECT_EQ(quality2.getDownlinkCallQualityLevel(), MediaQuality::kCallQualityBad);
+    EXPECT_EQ(quality2.getDownlinkCallQualityLevel(), CallQuality::kCallQualityBad);
 }
 
 TEST_F(MediaQualityAnalyzerTest, TestJitterInd)
 {
-    EXPECT_CALL(mCallback, onEvent(kImsMediaEventNotifyJitter, _, _)).Times(1);
+    EXPECT_CALL(mCallback, onEvent(kImsMediaEventMediaQualityStatus, _, _)).Times(1);
     EXPECT_CALL(mCallback, onEvent(kAudioCallQualityChangedInd, _, _)).Times(1);
-    // set 10 milliseconds jitter threshold in 1 sec interval
-    mAnalyzer->setJitterThreshold(1, 10);
+    MediaQualityThreshold threshold;
+    threshold.setRtpHysteresisTimeInMillis(kRtpHysteresisTimeInMillis);
+    threshold.setRtpJitterMillis(kRtpJitterMillis);
+    mAnalyzer->setMediaQualityThreshold(threshold);
     mAnalyzer->start();
 
     const int32_t numPackets = 20;
@@ -297,17 +377,20 @@ TEST_F(MediaQualityAnalyzerTest, TestJitterInd)
     EXPECT_EQ(mAnalyzer->getRxPacketSize(), numPackets);
     EXPECT_EQ(mAnalyzer->getLostPacketSize(), 0);
 
-    MediaQuality quality = mAnalyzer->getMediaQuality();
+    CallQuality quality = mAnalyzer->getCallQuality();
     mAnalyzer->stop();
 
     EXPECT_EQ(mAnalyzer->getTxPacketSize(), 0);
     EXPECT_EQ(mAnalyzer->getRxPacketSize(), 0);
     EXPECT_EQ(mAnalyzer->getLostPacketSize(), 0);
 
-    MediaQuality quality2 = mFakeCallback.getMediaQuality();
+    CallQuality quality2 = mFakeCallback.getCallQuality();
     EXPECT_EQ(quality2, quality);
     EXPECT_EQ(quality2.getNumRtpPacketsReceived(), numPackets);
     EXPECT_EQ(quality2.getAverageRelativeJitter(), jitter);
+
+    MediaQualityStatus status = mFakeCallback.getMediaQualityStatus();
+    EXPECT_EQ(status.getRtpJitterMillis(), jitter);
 }
 
 TEST_F(MediaQualityAnalyzerTest, TestSsrcChange)
@@ -347,10 +430,13 @@ TEST_F(MediaQualityAnalyzerTest, TestSsrcChange)
 
 TEST_F(MediaQualityAnalyzerTest, TestPacketLossInd)
 {
-    EXPECT_CALL(mCallback, onEvent(kImsMediaEventPacketLoss, _, _)).Times(1);
+    EXPECT_CALL(mCallback, onEvent(kImsMediaEventMediaQualityStatus, _, _)).Times(1);
     EXPECT_CALL(mCallback, onEvent(kAudioCallQualityChangedInd, _, _)).Times(1);
-    // 1 percent packet loss threshold in 1 sec interval
-    mAnalyzer->setPacketLossThreshold(1, 1);
+    MediaQualityThreshold threshold;
+    threshold.setRtpHysteresisTimeInMillis(kRtpHysteresisTimeInMillis);
+    threshold.setRtpPacketLossDurationMillis(kRtpPacketLossDurationMillis);
+    threshold.setRtpPacketLossRate(kRtpPacketLossRate);
+    mAnalyzer->setMediaQualityThreshold(threshold);
     mAnalyzer->start();
 
     const int32_t numPackets = 10;
@@ -366,6 +452,7 @@ TEST_F(MediaQualityAnalyzerTest, TestPacketLossInd)
 
         packet->seqNum = i;
         packet->jitter = 10;
+        packet->arrival = ImsMediaTimer::GetTimeInMilliSeconds();
         mAnalyzer->SendEvent(kCollectPacketInfo, kStreamRtpRx, reinterpret_cast<uint64_t>(packet));
     }
 
@@ -378,14 +465,31 @@ TEST_F(MediaQualityAnalyzerTest, TestPacketLossInd)
     EXPECT_EQ(mAnalyzer->getRxPacketSize(), numPackets - 1);
     EXPECT_EQ(mAnalyzer->getLostPacketSize(), 1);
 
-    MediaQuality quality = mAnalyzer->getMediaQuality();
+    CallQuality quality = mAnalyzer->getCallQuality();
     mAnalyzer->stop();
 
     EXPECT_EQ(mAnalyzer->getTxPacketSize(), 0);
     EXPECT_EQ(mAnalyzer->getRxPacketSize(), 0);
     EXPECT_EQ(mAnalyzer->getLostPacketSize(), 0);
 
-    MediaQuality quality2 = mFakeCallback.getMediaQuality();
+    CallQuality quality2 = mFakeCallback.getCallQuality();
     EXPECT_EQ(quality2, quality);
     EXPECT_EQ(quality2.getNumRtpPacketsNotReceived(), 1);
+
+    MediaQualityStatus status = mFakeCallback.getMediaQualityStatus();
+    EXPECT_EQ(status.getRtpPacketLossRate(), 10);
+}
+
+TEST_F(MediaQualityAnalyzerTest, TestNotifyMediaQualityStatus)
+{
+    EXPECT_CALL(mCallback, onEvent(kImsMediaEventMediaQualityStatus, _, _)).Times(1);
+    EXPECT_CALL(mCallback, onEvent(kAudioCallQualityChangedInd, _, _)).Times(1);
+    MediaQualityThreshold threshold;
+    threshold.setNotifyCurrentStatus(true);
+    mAnalyzer->setMediaQualityThreshold(threshold);
+    mAnalyzer->start();
+
+    mCondition.wait_timeout(2100);  // 2.1 sec
+
+    mAnalyzer->stop();
 }
\ No newline at end of file
diff --git a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/text/TextStreamGraphRtpRxTest.cpp b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/text/TextStreamGraphRtpRxTest.cpp
index 37641bcb..202a1581 100644
--- a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/text/TextStreamGraphRtpRxTest.cpp
+++ b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/text/TextStreamGraphRtpRxTest.cpp
@@ -45,6 +45,9 @@ const int8_t kRedundantPayload = 102;
 const int8_t kRedundantLevel = 3;
 const bool kKeepRedundantLevel = true;
 
+// inactivity timer
+const std::vector<int32_t> kRtpInactivityTimerMillis = {10000};
+
 class TextStreamGraphRtpRxTest : public ::testing::Test
 {
 public:
@@ -68,7 +71,7 @@ protected:
         rtcp.setTransmitPort(kTransmitPort);
         rtcp.setIntervalSec(kIntervalSec);
         rtcp.setRtcpXrBlockTypes(kRtcpXrBlockTypes);
-        threshold.setRtpInactivityTimerMillis(10000);
+        threshold.setRtpInactivityTimerMillis(kRtpInactivityTimerMillis);
         config.setMediaDirection(kMediaDirection);
         config.setRemoteAddress(kRemoteAddress);
         config.setRemotePort(kRemotePort);
diff --git a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/video/VideoStreamGraphRtpRxTest.cpp b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/video/VideoStreamGraphRtpRxTest.cpp
index e5e0b2ef..800f0d23 100644
--- a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/video/VideoStreamGraphRtpRxTest.cpp
+++ b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/video/VideoStreamGraphRtpRxTest.cpp
@@ -58,6 +58,9 @@ const int32_t kDeviceOrientationDegree = 0;
 const int32_t kCvoValue = 1;
 const int32_t kRtcpFbTypes = VideoConfig::RTP_FB_NONE;
 
+// inactivity timer
+const std::vector<int32_t> kRtpInactivityTimerMillis = {10000};
+
 class VideoStreamGraphRtpRxTest : public ::testing::Test
 {
 public:
@@ -85,7 +88,7 @@ protected:
         rtcp.setTransmitPort(kTransmitPort);
         rtcp.setIntervalSec(kIntervalSec);
         rtcp.setRtcpXrBlockTypes(kRtcpXrBlockTypes);
-        threshold.setRtpInactivityTimerMillis(10000);
+        threshold.setRtpInactivityTimerMillis(kRtpInactivityTimerMillis);
         config.setMediaDirection(kMediaDirection);
         config.setRemoteAddress(kRemoteAddress);
         config.setRemotePort(kRemotePort);