VPLAY-12568:Implement cancelReservation UVE-API

varshnie · varshnie · commit d11657372c06 · 2026-02-12T13:37:27.000+05:30
Reason for change:cancelReservation UVE call
Test Procedure: Refer jira ticket
Priority: P1

Signed-off-by: varshnie &lt;varshniblue14@gmail.com&gt;
diff --git a/AdManagerBase.h b/AdManagerBase.h
@@ -110,6 +110,14 @@ class CDAIObject
 	 * @param[in] reservationId The reservation identifier
 	 */
 	virtual void NotifyReservationComplete(const std::string& reservationId) {}
+
+	/**
+	 * @fn cancelReservation
+	 * @brief Cancel ad reservation
+	 * @param[in] playingReservationId The reservation identifier which is currently playing
+	 * @param[in] cancelAtReservationId The reservation identifier which needs to be cancelled
+	 */
+	virtual void CancelReservation(const std::string& playingReservationId, const std::string& cancelAtReservationId) {}
 };
 
 
diff --git a/admanager_mpd.cpp b/admanager_mpd.cpp
@@ -67,6 +67,19 @@ void CDAIObjectMPD::NotifyReservationComplete(const std::string& reservationId)
 	}
 }
 
+/**
+ * @brief Cancel ad reservation
+ * @param[in] playingReservationId The reservation identifier which is currently playing
+ * @param[in] cancelAtReservationId The reservation identifier which needs to be cancelled
+ */
+void CDAIObjectMPD::CancelReservation(const std::string& playingReservationId, const std::string& cancelAtReservationId)
+{
+    if (mPrivObj)
+	{
+        mPrivObj->CancelReservation(playingReservationId, cancelAtReservationId);
+    }
+}
+
 /**
  * @brief PrivateCDAIObjectMPD constructor
  */
@@ -864,6 +877,7 @@ bool PrivateCDAIObjectMPD::CheckForAdTerminate(double currOffset)
 		uint64_t fragOffset = (uint64_t)(currOffset * 1000);
 		if (mCurAds && (mCurAdIdx < mCurAds->size()))
 		{
+
 			if (fragOffset >= (mCurAds->at(mCurAdIdx).duration + OFFSET_ALIGN_FACTOR))
 			{
 				//Current Ad is playing beyond the AdBreak + OFFSET_ALIGN_FACTOR
@@ -1585,7 +1599,7 @@ void PrivateCDAIObjectMPD::CacheAdData(const std::string &periodId, const std::s
 		std::lock_guard<std::mutex> guard(mAdFulfillMtx);
 		if(isAdBreakObjectExist(periodId))
 		{
-			mAdBreaks[periodId].ads->emplace_back(AdNode{false, false, false, adId, url, 0, "", 0, NULL});
+			mAdBreaks[periodId].ads->emplace_back(AdNode{false, false, false, adId, url, 0, "", 0, NULL, ""});
 			mAdFulfillQ.push(AdFulfillObj(periodId, adId, url));
 			notify = true;
 		}
@@ -1909,3 +1923,47 @@ void PrivateCDAIObjectMPD::NotifyReservationComplete(const std::string& reservat
 		AAMPLOG_WARN("[CDAI] NotifyReservationComplete: adBreakId %s not found", reservationId.c_str());
 	}
 }
+
+/**
+ * @brief Cancel the reservation for the ad break
+ * @param[in] playingReservationId Ad break ID to be cancelled
+ * @param[in] cancelAtReservationId Ad break ID at which the cancellation should happen
+ */
+void PrivateCDAIObjectMPD::CancelReservation(const std::string& playingReservationId, const std::string& cancelAtReservationId)
+{
+    std::lock_guard<std::mutex> lock(mDaiMtx); // Ensure thread safety if ad state is shared
+
+    // Log the action for audit/debug
+    AAMPLOG_INFO("[CDAI] PrivateCDAIObjectMPD::CancelReservation called: playingReservationId=%s, cancelAtReservationId=%s",
+        playingReservationId.c_str(), cancelAtReservationId.c_str());
+
+	// Identify the break currently being played based on the ads vector pointer
+	std::string currentBreakId;
+	if (mCurAds)
+	{
+		for (const auto &entry : mAdBreaks)
+		{
+			const AdBreakObject &abObj = entry.second;
+			if (abObj.ads && (abObj.ads.get() == mCurAds.get()))
+			{
+				currentBreakId = entry.first;
+				break;
+			}
+		}
+	}
+
+	// Validate that the request targets the currently playing reservation/break
+	if (!currentBreakId.empty() && (playingReservationId == currentBreakId) &&
+		mCurAds && mCurAdIdx >= 0 && mCurAdIdx < (int)mCurAds->size())
+	{
+		mCurAds->at(mCurAdIdx).cancelAtReservationId = cancelAtReservationId;
+		AAMPLOG_INFO("[CDAI] AD under reservationId=%s will be truncated at %s.",
+			playingReservationId.c_str(), cancelAtReservationId.c_str());
+	}
+	else
+	{
+		// Either not in an ad break or mismatched reservation; avoid mutating wrong state
+		AAMPLOG_WARN("[CDAI] CancelReservation ignored: currentBreakId=%s does not match playingReservationId=%s",
+			currentBreakId.c_str(), playingReservationId.c_str());
+	}
+}
diff --git a/admanager_mpd.h b/admanager_mpd.h
@@ -98,6 +98,14 @@ class CDAIObjectMPD: public CDAIObject
 	 * @param[in] reservationId The reservation identifier
 	 */
 	virtual void NotifyReservationComplete(const std::string& reservationId) override;
+
+	/**
+	 * @fn CancelReservation
+	 * @brief Cancel ad reservation
+	 * @param[in] playingReservationId The reservation identifier which is currently playing
+	 * @param[in] cancelAtReservationId The reservation identifier which needs to be cancelled
+	 */
+	virtual void CancelReservation(const std::string& playingReservationId, const std::string& cancelAtReservationId) override;
 };
 
 
@@ -130,11 +138,12 @@ struct AdNode {
 	std::string  basePeriodId;     /**< Id of the base period at the beginning of the Ad */
 	int          basePeriodOffset; /**< Offset of the base period at the beginning of the Ad in milliseconds */
 	MPD*         mpd;              /**< Pointer to the MPD object */
+	std::string  cancelAtReservationId;
 
 	/**
 	* @brief AdNode default constructor
 	*/
-	AdNode() : invalid(false), placed(false), resolved(false), adId(), url(), duration(0), basePeriodId(), basePeriodOffset(0), mpd(nullptr)
+	AdNode() : invalid(false), placed(false), resolved(false), adId(), url(), duration(0), basePeriodId(), basePeriodOffset(0), mpd(nullptr), cancelAtReservationId()
 	{
 
 	}
@@ -153,9 +162,9 @@ struct AdNode {
 	* @param[in] mpd - Pointer to the MPD object
 	*/
 	AdNode(bool invalid, bool placed, bool resolved, std::string adId, std::string url, uint64_t duration,
-		std::string basePeriodId, int basePeriodOffset, MPD* mpd)
+		std::string basePeriodId, int basePeriodOffset, MPD* mpd, std::string cancelAtReservationId="")
 		: invalid(invalid), placed(placed), resolved(resolved), adId(std::move(adId)), url(std::move(url)), duration(duration), basePeriodId(std::move(basePeriodId)),
-		basePeriodOffset(basePeriodOffset), mpd(mpd)
+		basePeriodOffset(basePeriodOffset), mpd(mpd), cancelAtReservationId(std::move(cancelAtReservationId))
 	{
 
 	}
@@ -168,7 +177,7 @@ struct AdNode {
 	AdNode(const AdNode& adNode)
 		: invalid(adNode.invalid), placed(adNode.placed), resolved(adNode.resolved), adId(adNode.adId),
 		url(adNode.url), duration(adNode.duration), basePeriodId(adNode.basePeriodId),
-		basePeriodOffset(adNode.basePeriodOffset), mpd(adNode.mpd)
+		basePeriodOffset(adNode.basePeriodOffset), mpd(adNode.mpd), cancelAtReservationId(adNode.cancelAtReservationId)
 	{
 	}
 
@@ -413,6 +422,13 @@ class PrivateCDAIObjectMPD
 	 */
 	void NotifyReservationComplete(const std::string& reservationId);
 
+	/**
+	 * @fn CancelReservation
+	 * @brief Cancel ad reservation
+	 * @param[in] playingReservationId The reservation identifier which is currently playing
+	 * @param[in] cancelAtReservationId The reservation identifier which needs to be cancelled
+	 */
+	void CancelReservation(const std::string& playingReservationId, const std::string& cancelAtReservationId);
 	/**
 	 * @fn FulFillAdObject
 	 *
diff --git a/jsbindings/jsmediaplayer.cpp b/jsbindings/jsmediaplayer.cpp
@@ -3567,6 +3567,53 @@ JSValueRef AAMPMediaPlayerJS_isOOBCCRenderingSupported (JSContextRef ctx, JSObje
 	return JSValueMakeBoolean(ctx, bRet);
 }
 
+/**
+ * @brief Callback invoked from JS to cancel ad reservation
+ * @param[in] ctx JS execution context
+ * @param[in] function JSObject that is the function being called
+ * @param[in] thisObject JSObject that is the 'this' variable in the function's scope
+ * @param[in] argumentCount number of args
+ * @param[in] arguments[] JSValue array of args
+ * @param[out] exception pointer to a JSValueRef in which to return an exception, if any
+ * @retval JSValue that is the function's return value
+ */
+static JSValueRef AAMPMediaPlayer_JS_cancelReservation(JSContextRef ctx, JSObjectRef function,
+                                     JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[],
+                                     JSValueRef* exception)
+{
+    LOG_TRACE("Enter");
+
+	AAMPMediaPlayer_JS* privObj = (AAMPMediaPlayer_JS*)JSObjectGetPrivate(thisObject);
+	if(!privObj || !privObj->_aamp)
+	{
+		LOG_ERROR_EX("JSObjectGetPrivate returned NULL!");
+		*exception = aamp_GetException(ctx, AAMPJS_MISSING_OBJECT, "Can only call CancelReservation() on instances of AAMPPlayer");
+		return JSValueMakeUndefined(ctx);
+	}
+
+	if (argumentCount != 2)
+	{
+		LOG_ERROR(privObj,"InvalidArgument - argumentCount=%zu, expected: 2",  argumentCount);
+		*exception = aamp_GetException(ctx, AAMPJS_INVALID_ARGUMENT, "Failed to execute CancelReservation() - 2 arguments required");
+		return JSValueMakeUndefined(ctx);
+	}
+
+	char* playingReservationId_c = aamp_JSValueToCString(ctx, arguments[0], exception);
+	char* cancelAtReservationId_c = aamp_JSValueToCString(ctx, arguments[1], exception);
+
+	std::string playingReservationId = playingReservationId_c ? playingReservationId_c : "";
+	std::string cancelAtReservationId = cancelAtReservationId_c ? cancelAtReservationId_c : "";
+
+	SAFE_DELETE_ARRAY(playingReservationId_c);
+	SAFE_DELETE_ARRAY(cancelAtReservationId_c);
+
+	LOG_INFO(privObj, "CancelReservation called with playingReservationId=%s, cancelAtReservationId=%s", playingReservationId.c_str(), cancelAtReservationId.c_str());
+	privObj->_aamp->CancelReservation(playingReservationId, cancelAtReservationId);
+
+	LOG_TRACE("EXIT");
+	return JSValueMakeUndefined(ctx);
+}
+
 /**
  * @brief Array containing the AAMPMediaPlayer's statically declared functions
  */
@@ -3643,7 +3690,7 @@ static const JSStaticFunction AAMPMediaPlayer_JS_static_functions[] = {
 
 	{ "getSessionID", AAMPMediaPlayerJS_getSessionID, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly},
 	{ "updateManifest", AAMPMediaPlayerJS_updateManifest, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },
-
+	{ "cancelReservation", AAMPMediaPlayer_JS_cancelReservation, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },
 	{ NULL, NULL, 0 },
 };
 
diff --git a/main_aamp.cpp b/main_aamp.cpp
@@ -280,6 +280,17 @@ void PlayerInstanceAAMP::NotifyReservationComplete(const std::string& reservatio
 	aamp->NotifyReservationComplete(reservationId);
 }
 
+/**
+ *  @brief Cancel an ad reservation.
+ */
+void PlayerInstanceAAMP::CancelReservation(const std::string& playingReservationId, const std::string& cancelAtReservationId)
+{
+    if (aamp)
+    {
+        aamp->CancelReservation(playingReservationId, cancelAtReservationId);
+    }
+}
+
 /**
  *   @brief API to reset configuration across tunes for single player instance
  */
diff --git a/main_aamp.h b/main_aamp.h
@@ -188,6 +188,15 @@ class PlayerInstanceAAMP
 	 */
 	void NotifyReservationComplete(const std::string& reservationId);
 
+	/**
+	 *   @fn CancelReservation
+	 *
+	 *   @param[in]  playingReservationId - Reservation Id which is currently playing.
+	 *   @param[in]  cancelAtReservationId - Reservation Id at which the cancellation has to be done.
+	 *   @return void
+	 */
+	void CancelReservation(const std::string& playingReservationId, const std::string& cancelAtReservationId);
+
 	/**
 	 *   @fn SetUserAgent
 	 *
diff --git a/priv_aamp.cpp b/priv_aamp.cpp
@@ -9245,6 +9245,22 @@ void PrivateInstanceAAMP::NotifyReservationComplete(const std::string& reservati
 	}
 }
 
+/**
+ * @brief Cancel ad reservation
+ * @param[in] playingReservationId The reservation identifier of the currently playing ad, if any. This can be used by the CDAIObject to determine if the cancellation is for an ad that is currently playing.
+ * @param[in] cancelAtReservationId The reservation identifier of the ad reservation to be cancelled. This is the reservation that the CDAIObject should cancel. If this matches the playingReservationId, it indicates that the currently playing ad reservation should be cancelled.
+ */
+void PrivateInstanceAAMP::CancelReservation(const std::string& playingReservationId, const std::string& cancelAtReservationId)
+{
+    if (mCdaiObject) {
+        mCdaiObject->CancelReservation(playingReservationId, cancelAtReservationId);
+    }
+	else
+	{
+		AAMPLOG_WARN("[AAMP] CDAIObject not set. Cannot cancel reservation for reservationId: %s ", cancelAtReservationId.c_str());
+	}
+}
+
 /**
  * @brief updates download metrics to VideoStat object, this is used for VideoFragment as it takes duration for calculation purpose.
  */
diff --git a/priv_aamp.h b/priv_aamp.h
@@ -1599,6 +1599,15 @@ class PrivateInstanceAAMP : public DrmCallbacks, public std::enable_shared_from_
 	 */
 	void NotifyReservationComplete(const std::string& reservationId);
 
+	/**
+	 * @fn CancelReservation
+	 *
+	 * @param[in] playingReservationId The reservation identifier which is currently playing
+	 * @param[in] cancelAtReservationId The reservation identifier which needs to be cancelled
+	 * @return void
+	 */
+	void CancelReservation(const std::string& playingReservationId, const std::string& cancelAtReservationId);
+
 	/**
 	 * @fn getLastInjectedPosition
 	 *
diff --git a/test/utests/fakes/FakeAdManager.cpp b/test/utests/fakes/FakeAdManager.cpp
@@ -161,4 +161,8 @@ void CDAIObjectMPD::NotifyReservationComplete(const std::string& reservationId)
 	{
 		g_MockPrivateCDAIObjectMPD->NotifyReservationComplete(reservationId);
 	}
+}
+
+void CDAIObjectMPD::CancelReservation(const std::string& playingReservationId, const std::string& cancelAtReservationId)
+{
 }
diff --git a/test/utests/fakes/FakePlayerInstanceAamp.cpp b/test/utests/fakes/FakePlayerInstanceAamp.cpp
@@ -169,6 +169,7 @@ const std::vector<TimedMetadata> & PlayerInstanceAAMP::GetTimedMetadata( void )
 	void PlayerInstanceAAMP::ProcessContentProtectionDataConfig(const char *jsonbuffer) {  }
 	void PlayerInstanceAAMP::SetRuntimeDRMConfigSupport(bool DynamicDRMSupported) {  }
 	void PlayerInstanceAAMP::NotifyReservationComplete(const std::string& reservationId) {  }
+	void PlayerInstanceAAMP::CancelReservation(const std::string& playingReservationId, const std::string& cancelAtReservationId) { }
 	bool PlayerInstanceAAMP::IsLive() { return false; }
 	bool PlayerInstanceAAMP::GetVideoMute(void) { return false; }
 	bool PlayerInstanceAAMP::GetCCStatus(void) { return false; }
diff --git a/test/utests/fakes/FakePrivateInstanceAAMP.cpp b/test/utests/fakes/FakePrivateInstanceAAMP.cpp
@@ -286,6 +286,11 @@ void PrivateInstanceAAMP::NotifyReservationComplete(const std::string& reservati
 	}
 }
 
+void PrivateInstanceAAMP::CancelReservation(const std::string& playingReservationId, const std::string& cancelAtReservationId)
+{
+
+}
+
 void PrivateInstanceAAMP::LogPlayerPreBuffered(void)
 {
 }
diff --git a/test/utests/tests/AdManagerMPDTests/FunctionalTests.cpp b/test/utests/tests/AdManagerMPDTests/FunctionalTests.cpp
@@ -4274,4 +4274,61 @@ TEST_F(AdManagerMPDTests, NotifyReservationComplete_EmptyAdBreak_NotifiesAndReso
     EXPECT_TRUE(mPrivateCDAIObjectMPD->mAdBreaks[periodId].resolved);
     // The waiting thread should have completed (not timed out)
     EXPECT_TRUE(completed);
+}
+
+/**
+ * @brief CancelReservation should set cancelAtReservationId on the current ad.
+ */
+TEST_F(AdManagerMPDTests, CancelReservation_SetsCancelIdOnCurrentAd)
+{
+  const std::string playingReservationId = "playingBrk";
+  const std::string cancelAtReservationId = "nextBrk";
+  const std::string periodId = playingReservationId;
+
+  // Prepare a break with one current ad and make it the current ads list
+  mPrivateCDAIObjectMPD->mAdBreaks[periodId] = AdBreakObject(30000, std::make_shared<std::vector<AdNode>>(), "", 0, 0);
+  AdNode ad; // use default ctor to avoid signature drift
+  ad.adId = "ad-1";
+  mPrivateCDAIObjectMPD->mAdBreaks[periodId].ads->push_back(ad);
+
+  mPrivateCDAIObjectMPD->mCurPlayingBreakId = periodId;
+  mPrivateCDAIObjectMPD->mCurAds = mPrivateCDAIObjectMPD->mAdBreaks[periodId].ads;
+  mPrivateCDAIObjectMPD->mCurAdIdx = 0;
+
+  ASSERT_EQ(mPrivateCDAIObjectMPD->mCurAds->size(), 1u);
+  EXPECT_TRUE(mPrivateCDAIObjectMPD->mCurAds->at(0).cancelAtReservationId.empty());
+
+  // Act
+  mPrivateCDAIObjectMPD->CancelReservation(playingReservationId, cancelAtReservationId);
+
+  // Assert
+  EXPECT_EQ(mPrivateCDAIObjectMPD->mCurAds->at(0).cancelAtReservationId, cancelAtReservationId);
+}
+
+/**
+ * @brief CancelReservation with out-of-range index should not modify ads.
+ */
+TEST_F(AdManagerMPDTests, CancelReservation_OutOfRangeIndex_NoChange)
+{
+  const std::string playingReservationId = "playingBrk";
+  const std::string cancelAtReservationId = "nextBrk";
+  const std::string periodId = playingReservationId;
+
+  // Prepare a break with one ad but set index out of range
+  mPrivateCDAIObjectMPD->mAdBreaks[periodId] = AdBreakObject(30000, std::make_shared<std::vector<AdNode>>(), "", 0, 0);
+  AdNode ad; ad.adId = "ad-1";
+  mPrivateCDAIObjectMPD->mAdBreaks[periodId].ads->push_back(ad);
+
+  mPrivateCDAIObjectMPD->mCurPlayingBreakId = periodId;
+  mPrivateCDAIObjectMPD->mCurAds = mPrivateCDAIObjectMPD->mAdBreaks[periodId].ads;
+  mPrivateCDAIObjectMPD->mCurAdIdx = 5; // out of range
+
+  ASSERT_EQ(mPrivateCDAIObjectMPD->mCurAds->size(), 1u);
+  EXPECT_TRUE(mPrivateCDAIObjectMPD->mCurAds->at(0).cancelAtReservationId.empty());
+
+  // Act
+  mPrivateCDAIObjectMPD->CancelReservation(playingReservationId, cancelAtReservationId);
+
+  // Assert: unchanged
+  EXPECT_TRUE(mPrivateCDAIObjectMPD->mCurAds->at(0).cancelAtReservationId.empty());
 }

Original file line number	Diff line number	Diff line change
`@@ -161,4 +161,8 @@ void CDAIObjectMPD::NotifyReservationComplete(const std::string& reservationId)`
`161`	`161`	`{`
`162`	`162`	`g_MockPrivateCDAIObjectMPD->NotifyReservationComplete(reservationId);`
`163`	`163`	`}`
	`164`	`+}`
	`165`	`+`
	`166`	`+void CDAIObjectMPD::CancelReservation(const std::string& playingReservationId, const std::string& cancelAtReservationId)`
	`167`	`+{`
`164`	`168`	`}`