Remove const in CallSessionListener methods to allow the session to be modified.

src/call/call-p.h

@@ -74,44 +74,44 @@ private:
 	void terminateBecauseOfLostMedia ();
 
 	/* CallSessionListener */
-	void onAckBeingSent (const std::shared_ptr<const CallSession> &session, LinphoneHeaders *headers) override;
-	void onAckReceived (const std::shared_ptr<const CallSession> &session, LinphoneHeaders *headers) override;
-	void onBackgroundTaskToBeStarted (const std::shared_ptr<const CallSession> &session) override;
-	void onBackgroundTaskToBeStopped (const std::shared_ptr<const CallSession> &session) override;
-	bool onCallSessionAccepted (const std::shared_ptr<const CallSession> &session) override;
-	void onCallSessionConferenceStreamStarting (const std::shared_ptr<const CallSession> &session, bool mute) override;
-	void onCallSessionConferenceStreamStopping (const std::shared_ptr<const CallSession> &session) override;
-	void onCallSessionEarlyFailed (const std::shared_ptr<const CallSession> &session, LinphoneErrorInfo *ei) override;
-	void onCallSessionSetReleased (const std::shared_ptr<const CallSession> &session) override;
-	void onCallSessionSetTerminated (const std::shared_ptr<const CallSession> &session) override;
-	void onCallSessionStartReferred (const std::shared_ptr<const CallSession> &session) override;
-	void onCallSessionStateChanged (const std::shared_ptr<const CallSession> &session, CallSession::State state, const std::string &message) override;
-	void onCallSessionTransferStateChanged (const std::shared_ptr<const CallSession> &session, CallSession::State state) override;
-	void onCheckForAcceptation (const std::shared_ptr<const CallSession> &session) override;
-	void onDtmfReceived (const std::shared_ptr<const CallSession> &session, char dtmf) override;
-	void onIncomingCallSessionNotified (const std::shared_ptr<const CallSession> &session) override;
-	void onIncomingCallSessionStarted (const std::shared_ptr<const CallSession> &session) override;
-	void onIncomingCallSessionTimeoutCheck (const std::shared_ptr<const CallSession> &session, int elapsed, bool oneSecondElapsed) override;
-	void onInfoReceived (const std::shared_ptr<const CallSession> &session, const LinphoneInfoMessage *im) override;
-	void onNoMediaTimeoutCheck (const std::shared_ptr<const CallSession> &session, bool oneSecondElapsed) override;
-	void onEncryptionChanged (const std::shared_ptr<const CallSession> &session, bool activated, const std::string &authToken) override;
-	void onCallSessionStateChangedForReporting (const std::shared_ptr<const CallSession> &session) override;
-	void onRtcpUpdateForReporting (const std::shared_ptr<const CallSession> &session, SalStreamType type) override;
-	void onStatsUpdated (const std::shared_ptr<const CallSession> &session, const LinphoneCallStats *stats) override;
-	void onUpdateMediaInfoForReporting (const std::shared_ptr<const CallSession> &session, int statsType) override;
-	void onResetCurrentSession (const std::shared_ptr<const CallSession> &session) override;
-	void onSetCurrentSession (const std::shared_ptr<const CallSession> &session) override;
-	void onFirstVideoFrameDecoded (const std::shared_ptr<const CallSession> &session) override;
-	void onResetFirstVideoFrameDecoded (const std::shared_ptr<const CallSession> &session) override;
-	void onPlayErrorTone (const std::shared_ptr<const CallSession> &session, LinphoneReason reason) override;
-	void onRingbackToneRequested (const std::shared_ptr<const CallSession> &session, bool requested) override;
-	void onStartRinging (const std::shared_ptr<const CallSession> &session) override;
-	void onStopRinging (const std::shared_ptr<const CallSession> &session) override;
-	void onStopRingingIfInCall (const std::shared_ptr<const CallSession> &session) override;
-	void onStopRingingIfNeeded (const std::shared_ptr<const CallSession> &session) override;
-	bool areSoundResourcesAvailable (const std::shared_ptr<const CallSession> &session) override;
-	bool isPlayingRingbackTone (const std::shared_ptr<const CallSession> &session) override;
-	void onRealTimeTextCharacterReceived (const std::shared_ptr<const CallSession> &session, RealtimeTextReceivedCharacter *character) override;
+	void onAckBeingSent (const std::shared_ptr<CallSession> &session, LinphoneHeaders *headers) override;
+	void onAckReceived (const std::shared_ptr<CallSession> &session, LinphoneHeaders *headers) override;
+	void onBackgroundTaskToBeStarted (const std::shared_ptr<CallSession> &session) override;
+	void onBackgroundTaskToBeStopped (const std::shared_ptr<CallSession> &session) override;
+	bool onCallSessionAccepted (const std::shared_ptr<CallSession> &session) override;
+	void onCallSessionConferenceStreamStarting (const std::shared_ptr<CallSession> &session, bool mute) override;
+	void onCallSessionConferenceStreamStopping (const std::shared_ptr<CallSession> &session) override;
+	void onCallSessionEarlyFailed (const std::shared_ptr<CallSession> &session, LinphoneErrorInfo *ei) override;
+	void onCallSessionSetReleased (const std::shared_ptr<CallSession> &session) override;
+	void onCallSessionSetTerminated (const std::shared_ptr<CallSession> &session) override;
+	void onCallSessionStartReferred (const std::shared_ptr<CallSession> &session) override;
+	void onCallSessionStateChanged (const std::shared_ptr<CallSession> &session, CallSession::State state, const std::string &message) override;
+	void onCallSessionTransferStateChanged (const std::shared_ptr<CallSession> &session, CallSession::State state) override;
+	void onCheckForAcceptation (const std::shared_ptr<CallSession> &session) override;
+	void onDtmfReceived (const std::shared_ptr<CallSession> &session, char dtmf) override;
+	void onIncomingCallSessionNotified (const std::shared_ptr<CallSession> &session) override;
+	void onIncomingCallSessionStarted (const std::shared_ptr<CallSession> &session) override;
+	void onIncomingCallSessionTimeoutCheck (const std::shared_ptr<CallSession> &session, int elapsed, bool oneSecondElapsed) override;
+	void onInfoReceived (const std::shared_ptr<CallSession> &session, const LinphoneInfoMessage *im) override;
+	void onNoMediaTimeoutCheck (const std::shared_ptr<CallSession> &session, bool oneSecondElapsed) override;
+	void onEncryptionChanged (const std::shared_ptr<CallSession> &session, bool activated, const std::string &authToken) override;
+	void onCallSessionStateChangedForReporting (const std::shared_ptr<CallSession> &session) override;
+	void onRtcpUpdateForReporting (const std::shared_ptr<CallSession> &session, SalStreamType type) override;
+	void onStatsUpdated (const std::shared_ptr<CallSession> &session, const LinphoneCallStats *stats) override;
+	void onUpdateMediaInfoForReporting (const std::shared_ptr<CallSession> &session, int statsType) override;
+	void onResetCurrentSession (const std::shared_ptr<CallSession> &session) override;
+	void onSetCurrentSession (const std::shared_ptr<CallSession> &session) override;
+	void onFirstVideoFrameDecoded (const std::shared_ptr<CallSession> &session) override;
+	void onResetFirstVideoFrameDecoded (const std::shared_ptr<CallSession> &session) override;
+	void onPlayErrorTone (const std::shared_ptr<CallSession> &session, LinphoneReason reason) override;
+	void onRingbackToneRequested (const std::shared_ptr<CallSession> &session, bool requested) override;
+	void onStartRinging (const std::shared_ptr<CallSession> &session) override;
+	void onStopRinging (const std::shared_ptr<CallSession> &session) override;
+	void onStopRingingIfInCall (const std::shared_ptr<CallSession> &session) override;
+	void onStopRingingIfNeeded (const std::shared_ptr<CallSession> &session) override;
+	bool areSoundResourcesAvailable (const std::shared_ptr<CallSession> &session) override;
+	bool isPlayingRingbackTone (const std::shared_ptr<CallSession> &session) override;
+	void onRealTimeTextCharacterReceived (const std::shared_ptr<CallSession> &session, RealtimeTextReceivedCharacter *character) override;
 
 	mutable LinphonePlayer *player = nullptr;
 

src/call/call.cpp

@@ -187,25 +187,25 @@ void CallPrivate::terminateBecauseOfLostMedia () {
 
 // -----------------------------------------------------------------------------
 
-void CallPrivate::onAckBeingSent (const shared_ptr<const CallSession> &session, LinphoneHeaders *headers) {
+void CallPrivate::onAckBeingSent (const shared_ptr<CallSession> &session, LinphoneHeaders *headers) {
 	L_Q();
 	linphone_call_notify_ack_processing(L_GET_C_BACK_PTR(q), headers, false);
 }
 
-void CallPrivate::onAckReceived (const shared_ptr<const CallSession> &session, LinphoneHeaders *headers) {
+void CallPrivate::onAckReceived (const shared_ptr<CallSession> &session, LinphoneHeaders *headers) {
 	L_Q();
 	linphone_call_notify_ack_processing(L_GET_C_BACK_PTR(q), headers, true);
 }
 
-void CallPrivate::onBackgroundTaskToBeStarted (const shared_ptr<const CallSession> &session) {
+void CallPrivate::onBackgroundTaskToBeStarted (const shared_ptr<CallSession> &session) {
 	bgTask.start();
 }
 
-void CallPrivate::onBackgroundTaskToBeStopped (const shared_ptr<const CallSession> &session) {
+void CallPrivate::onBackgroundTaskToBeStopped (const shared_ptr<CallSession> &session) {
 	bgTask.stop();
 }
 
-bool CallPrivate::onCallSessionAccepted (const shared_ptr<const CallSession> &session) {
+bool CallPrivate::onCallSessionAccepted (const shared_ptr<CallSession> &session) {
 	L_Q();
 	LinphoneCore *lc = q->getCore()->getCCore();
 	bool wasRinging = false;
@@ -226,21 +226,21 @@ bool CallPrivate::onCallSessionAccepted (const shared_ptr<const CallSession> &se
 	return wasRinging;
 }
 
-void CallPrivate::onCallSessionConferenceStreamStarting (const shared_ptr<const CallSession> &session, bool mute) {
+void CallPrivate::onCallSessionConferenceStreamStarting (const shared_ptr<CallSession> &session, bool mute) {
 	L_Q();
 	if (q->getCore()->getCCore()->conf_ctx) {
 		linphone_conference_on_call_stream_starting(q->getCore()->getCCore()->conf_ctx, L_GET_C_BACK_PTR(q), mute);
 	}
 }
 
-void CallPrivate::onCallSessionConferenceStreamStopping (const shared_ptr<const CallSession> &session) {
+void CallPrivate::onCallSessionConferenceStreamStopping (const shared_ptr<CallSession> &session) {
 	L_Q();
 	LinphoneCore *lc = q->getCore()->getCCore();
 	if (lc->conf_ctx && _linphone_call_get_endpoint(L_GET_C_BACK_PTR(q)))
 		linphone_conference_on_call_stream_stopping(lc->conf_ctx, L_GET_C_BACK_PTR(q));
 }
 
-void CallPrivate::onCallSessionEarlyFailed (const shared_ptr<const CallSession> &session, LinphoneErrorInfo *ei) {
+void CallPrivate::onCallSessionEarlyFailed (const shared_ptr<CallSession> &session, LinphoneErrorInfo *ei) {
 	L_Q();
 	LinphoneCallLog *log = session->getLog();
 	linphone_core_report_early_failed_call(q->getCore()->getCCore(),
@@ -251,12 +251,12 @@ void CallPrivate::onCallSessionEarlyFailed (const shared_ptr<const CallSession>
 	linphone_call_unref(L_GET_C_BACK_PTR(q));
 }
 
-void CallPrivate::onCallSessionSetReleased (const shared_ptr<const CallSession> &session) {
+void CallPrivate::onCallSessionSetReleased (const shared_ptr<CallSession> &session) {
 	L_Q();
 	linphone_call_unref(L_GET_C_BACK_PTR(q));
 }
 
-void CallPrivate::onCallSessionSetTerminated (const shared_ptr<const CallSession> &session) {
+void CallPrivate::onCallSessionSetTerminated (const shared_ptr<CallSession> &session) {
 	L_Q();
 	LinphoneCore *core = q->getCore()->getCCore();
 	if (q->getSharedFromThis() == q->getCore()->getCurrentCall()) {
@@ -279,21 +279,21 @@ void CallPrivate::onCallSessionSetTerminated (const shared_ptr<const CallSession
 		ms_bandwidth_controller_reset_state(core->bw_controller);
 }
 
-void CallPrivate::onCallSessionStartReferred (const shared_ptr<const CallSession> &session) {
+void CallPrivate::onCallSessionStartReferred (const shared_ptr<CallSession> &session) {
 	startReferredCall(nullptr);
 }
 
-void CallPrivate::onCallSessionStateChanged (const shared_ptr<const CallSession> &session, CallSession::State state, const string &message) {
+void CallPrivate::onCallSessionStateChanged (const shared_ptr<CallSession> &session, CallSession::State state, const string &message) {
 	L_Q();
 	linphone_call_notify_state_changed(L_GET_C_BACK_PTR(q), static_cast<LinphoneCallState>(state), message.c_str());
 }
 
-void CallPrivate::onCallSessionTransferStateChanged (const shared_ptr<const CallSession> &session, CallSession::State state) {
+void CallPrivate::onCallSessionTransferStateChanged (const shared_ptr<CallSession> &session, CallSession::State state) {
 	L_Q();
 	linphone_call_notify_transfer_state_changed(L_GET_C_BACK_PTR(q), static_cast<LinphoneCallState>(state));
 }
 
-void CallPrivate::onCheckForAcceptation (const shared_ptr<const CallSession> &session) {
+void CallPrivate::onCheckForAcceptation (const shared_ptr<CallSession> &session) {
 	L_Q();
 	LinphoneCall *lcall = L_GET_C_BACK_PTR(q);
 	bctbx_list_t *copy = bctbx_list_copy(linphone_core_get_calls(q->getCore()->getCCore()));
@@ -316,23 +316,23 @@ void CallPrivate::onCheckForAcceptation (const shared_ptr<const CallSession> &se
 	bctbx_list_free(copy);
 }
 
-void CallPrivate::onDtmfReceived (const shared_ptr<const CallSession> &session, char dtmf) {
+void CallPrivate::onDtmfReceived (const shared_ptr<CallSession> &session, char dtmf) {
 	L_Q();
 	linphone_call_notify_dtmf_received(L_GET_C_BACK_PTR(q), dtmf);
 }
 
-void CallPrivate::onIncomingCallSessionNotified (const shared_ptr<const CallSession> &session) {
+void CallPrivate::onIncomingCallSessionNotified (const shared_ptr<CallSession> &session) {
 	L_Q();
 	/* The call is acceptable so we can now add it to our list */
 	q->getCore()->getPrivate()->addCall(q->getSharedFromThis());
 }
 
-void CallPrivate::onIncomingCallSessionStarted (const shared_ptr<const CallSession> &session) {
+void CallPrivate::onIncomingCallSessionStarted (const shared_ptr<CallSession> &session) {
 	L_Q();
 	linphone_core_notify_incoming_call(q->getCore()->getCCore(), L_GET_C_BACK_PTR(q));
 }
 
-void CallPrivate::onIncomingCallSessionTimeoutCheck (const shared_ptr<const CallSession> &session, int elapsed, bool oneSecondElapsed) {
+void CallPrivate::onIncomingCallSessionTimeoutCheck (const shared_ptr<CallSession> &session, int elapsed, bool oneSecondElapsed) {
 	L_Q();
 	if (oneSecondElapsed)
 		lInfo() << "Incoming call ringing for " << elapsed << " seconds";
@@ -344,12 +344,12 @@ void CallPrivate::onIncomingCallSessionTimeoutCheck (const shared_ptr<const Call
 	}
 }
 
-void CallPrivate::onInfoReceived (const shared_ptr<const CallSession> &session, const LinphoneInfoMessage *im) {
+void CallPrivate::onInfoReceived (const shared_ptr<CallSession> &session, const LinphoneInfoMessage *im) {
 	L_Q();
 	linphone_call_notify_info_message_received(L_GET_C_BACK_PTR(q), im);
 }
 
-void CallPrivate::onNoMediaTimeoutCheck (const shared_ptr<const CallSession> &session, bool oneSecondElapsed) {
+void CallPrivate::onNoMediaTimeoutCheck (const shared_ptr<CallSession> &session, bool oneSecondElapsed) {
 	L_Q();
 	int disconnectTimeout = linphone_core_get_nortp_timeout(q->getCore()->getCCore());
 	bool disconnected = false;
@@ -361,42 +361,42 @@ void CallPrivate::onNoMediaTimeoutCheck (const shared_ptr<const CallSession> &se
 		terminateBecauseOfLostMedia();
 }
 
-void CallPrivate::onEncryptionChanged (const shared_ptr<const CallSession> &session, bool activated, const string &authToken) {
+void CallPrivate::onEncryptionChanged (const shared_ptr<CallSession> &session, bool activated, const string &authToken) {
 	L_Q();
 	linphone_call_notify_encryption_changed(L_GET_C_BACK_PTR(q), activated, authToken.empty() ? nullptr : authToken.c_str());
 }
 
-void CallPrivate::onCallSessionStateChangedForReporting (const shared_ptr<const CallSession> &session) {
+void CallPrivate::onCallSessionStateChangedForReporting (const shared_ptr<CallSession> &session) {
 	L_Q();
 	linphone_reporting_call_state_updated(L_GET_C_BACK_PTR(q));
 }
 
-void CallPrivate::onRtcpUpdateForReporting (const shared_ptr<const CallSession> &session, SalStreamType type) {
+void CallPrivate::onRtcpUpdateForReporting (const shared_ptr<CallSession> &session, SalStreamType type) {
 	L_Q();
 	linphone_reporting_on_rtcp_update(L_GET_C_BACK_PTR(q), type);
 }
 
-void CallPrivate::onStatsUpdated (const shared_ptr<const CallSession> &session, const LinphoneCallStats *stats) {
+void CallPrivate::onStatsUpdated (const shared_ptr<CallSession> &session, const LinphoneCallStats *stats) {
 	L_Q();
 	linphone_call_notify_stats_updated(L_GET_C_BACK_PTR(q), stats);
 }
 
-void CallPrivate::onUpdateMediaInfoForReporting (const std::shared_ptr<const CallSession> &session, int statsType) {
+void CallPrivate::onUpdateMediaInfoForReporting (const shared_ptr<CallSession> &session, int statsType) {
 	L_Q();
 	linphone_reporting_update_media_info(L_GET_C_BACK_PTR(q), statsType);
 }
 
-void CallPrivate::onResetCurrentSession (const shared_ptr<const CallSession> &session) {
+void CallPrivate::onResetCurrentSession (const shared_ptr<CallSession> &session) {
 	L_Q();
 	q->getCore()->getPrivate()->setCurrentCall(nullptr);
 }
 
-void CallPrivate::onSetCurrentSession (const shared_ptr<const CallSession> &session) {
+void CallPrivate::onSetCurrentSession (const shared_ptr<CallSession> &session) {
 	L_Q();
 	q->getCore()->getPrivate()->setCurrentCall(q->getSharedFromThis());
 }
 
-void CallPrivate::onFirstVideoFrameDecoded (const shared_ptr<const CallSession> &session) {
+void CallPrivate::onFirstVideoFrameDecoded (const shared_ptr<CallSession> &session) {
 	L_Q();
 	if (nextVideoFrameDecoded._func) {
 		nextVideoFrameDecoded._func(L_GET_C_BACK_PTR(q), nextVideoFrameDecoded._user_data);
@@ -405,16 +405,16 @@ void CallPrivate::onFirstVideoFrameDecoded (const shared_ptr<const CallSession>
 	}
 }
 
-void CallPrivate::onResetFirstVideoFrameDecoded (const shared_ptr<const CallSession> &session) {
+void CallPrivate::onResetFirstVideoFrameDecoded (const shared_ptr<CallSession> &session) {
 	resetFirstVideoFrameDecoded();
 }
 
-void CallPrivate::onPlayErrorTone (const shared_ptr<const CallSession> &session, LinphoneReason reason) {
+void CallPrivate::onPlayErrorTone (const shared_ptr<CallSession> &session, LinphoneReason reason) {
 	L_Q();
 	linphone_core_play_call_error_tone(q->getCore()->getCCore(), reason);
 }
 
-void CallPrivate::onRingbackToneRequested (const shared_ptr<const CallSession> &session, bool requested) {
+void CallPrivate::onRingbackToneRequested (const shared_ptr<CallSession> &session, bool requested) {
 	L_Q();
 	if (requested && linphone_core_get_remote_ringback_tone(q->getCore()->getCCore()))
 		playingRingbackTone = true;
@@ -422,7 +422,7 @@ void CallPrivate::onRingbackToneRequested (const shared_ptr<const CallSession> &
 		playingRingbackTone = false;
 }
 
-void CallPrivate::onStartRinging (const shared_ptr<const CallSession> &session) {
+void CallPrivate::onStartRinging (const shared_ptr<CallSession> &session) {
 	L_Q();
 	LinphoneCore *lc = q->getCore()->getCCore();
 	if (lc->ringstream)
@@ -430,12 +430,12 @@ void CallPrivate::onStartRinging (const shared_ptr<const CallSession> &session)
 	startRemoteRing();
 }
 
-void CallPrivate::onStopRinging (const shared_ptr<const CallSession> &session) {
+void CallPrivate::onStopRinging (const shared_ptr<CallSession> &session) {
 	L_Q();
 	linphone_core_stop_ringing(q->getCore()->getCCore());
 }
 
-void CallPrivate::onStopRingingIfInCall (const shared_ptr<const CallSession> &session) {
+void CallPrivate::onStopRingingIfInCall (const shared_ptr<CallSession> &session) {
 	L_Q();
 	LinphoneCore *lc = q->getCore()->getCCore();
 	// We stop the ring only if we have this current call or if we are in call
@@ -444,7 +444,7 @@ void CallPrivate::onStopRingingIfInCall (const shared_ptr<const CallSession> &se
 	}
 }
 
-void CallPrivate::onStopRingingIfNeeded (const shared_ptr<const CallSession> &session) {
+void CallPrivate::onStopRingingIfNeeded (const shared_ptr<CallSession> &session) {
 	L_Q();
 	LinphoneCore *lc = q->getCore()->getCCore();
 	bool stopRinging = true;
@@ -460,18 +460,18 @@ void CallPrivate::onStopRingingIfNeeded (const shared_ptr<const CallSession> &se
 		linphone_core_stop_ringing(lc);
 }
 
-bool CallPrivate::areSoundResourcesAvailable (const shared_ptr<const CallSession> &session) {
+bool CallPrivate::areSoundResourcesAvailable (const shared_ptr<CallSession> &session) {
 	L_Q();
 	LinphoneCore *lc = q->getCore()->getCCore();
 	shared_ptr<Call> currentCall = q->getCore()->getCurrentCall();
 	return !linphone_core_is_in_conference(lc) && (!currentCall || (currentCall == q->getSharedFromThis()));
 }
 
-bool CallPrivate::isPlayingRingbackTone (const shared_ptr<const CallSession> &session) {
+bool CallPrivate::isPlayingRingbackTone (const shared_ptr<CallSession> &session) {
 	return playingRingbackTone;
 }
 
-void CallPrivate::onRealTimeTextCharacterReceived (const shared_ptr<const CallSession> &session, RealtimeTextReceivedCharacter *data) {
+void CallPrivate::onRealTimeTextCharacterReceived (const shared_ptr<CallSession> &session, RealtimeTextReceivedCharacter *data) {
 	L_Q();
 	getChatRoom()->getPrivate()->realtimeTextReceived(data->character, q->getSharedFromThis());
 }
@@ -538,7 +538,7 @@ LinphoneStatus Call::pause () {
 	return static_pointer_cast<MediaSession>(d->getActiveSession())->pause();
 }
 
-LinphoneStatus Call::redirect (const std::string &redirectUri) {
+LinphoneStatus Call::redirect (const string &redirectUri) {
 	L_D();
 	return d->getActiveSession()->redirect(redirectUri);
 }
@@ -553,7 +553,7 @@ LinphoneStatus Call::sendDtmf (char dtmf) {
 	return static_pointer_cast<MediaSession>(d->getActiveSession())->sendDtmf(dtmf);
 }
 
-LinphoneStatus Call::sendDtmfs (const std::string &dtmfs) {
+LinphoneStatus Call::sendDtmfs (const string &dtmfs) {
 	L_D();
 	return static_pointer_cast<MediaSession>(d->getActiveSession())->sendDtmfs(dtmfs);
 }
@@ -840,7 +840,7 @@ const Address &Call::getToAddress () const {
 	return d->getActiveSession()->getToAddress();
 }
 
-string Call::getToHeader (const std::string &name) const {
+string Call::getToHeader (const string &name) const {
 	L_D();
 	return d->getActiveSession()->getToHeader(name);
 }

src/chat/chat-room/basic-to-client-group-chat-room.cpp

@@ -77,7 +77,7 @@ public:
 	}
 
 	void onCallSessionStateChanged (
-		const shared_ptr<const CallSession> &session,
+		const shared_ptr<CallSession> &session,
 		CallSession::State newState,
 		const string &message
 	) override {

src/chat/chat-room/client-group-chat-room-p.h

@@ -46,8 +46,8 @@ public:
 	void onChatRoomDeleteRequested (const std::shared_ptr<AbstractChatRoom> &chatRoom) override;
 
 	// CallSessionListener
-	void onCallSessionSetReleased (const std::shared_ptr<const CallSession> &session) override;
-	void onCallSessionStateChanged (const std::shared_ptr<const CallSession> &session, CallSession::State state, const std::string &message) override;
+	void onCallSessionSetReleased (const std::shared_ptr<CallSession> &session) override;
+	void onCallSessionStateChanged (const std::shared_ptr<CallSession> &session, CallSession::State state, const std::string &message) override;
 
 private:
 	CallSessionListener *callSessionListener = this;

src/chat/chat-room/client-group-chat-room.cpp

@@ -119,7 +119,7 @@ void ClientGroupChatRoomPrivate::onChatRoomDeleteRequested (const shared_ptr<Abs
 
 // -----------------------------------------------------------------------------
 
-void ClientGroupChatRoomPrivate::onCallSessionSetReleased (const shared_ptr<const CallSession> &session) {
+void ClientGroupChatRoomPrivate::onCallSessionSetReleased (const shared_ptr<CallSession> &session) {
 	L_Q_T(RemoteConference, qConference);
 
 	ParticipantPrivate *participantPrivate = qConference->getPrivate()->focus->getPrivate();
@@ -128,7 +128,7 @@ void ClientGroupChatRoomPrivate::onCallSessionSetReleased (const shared_ptr<cons
 }
 
 void ClientGroupChatRoomPrivate::onCallSessionStateChanged (
-	const shared_ptr<const CallSession> &session,
+	const shared_ptr<CallSession> &session,
 	CallSession::State newState,
 	const string &message
 ) {

src/chat/chat-room/client-group-to-basic-chat-room.cpp

@@ -52,14 +52,14 @@ public:
 		setState(AbstractChatRoom::State::Deleted);
 	}
 
-	void onCallSessionSetReleased (const std::shared_ptr<const CallSession> &session) override {
+	void onCallSessionSetReleased (const shared_ptr<CallSession> &session) override {
 		if (!(chatRoom->getCapabilities() & ChatRoom::Capabilities::Conference))
 			return;
 		static_pointer_cast<ClientGroupChatRoom>(chatRoom)->getPrivate()->onCallSessionSetReleased(session);
 	}
 
 	void onCallSessionStateChanged (
-		const shared_ptr<const CallSession> &session,
+		const shared_ptr<CallSession> &session,
 		CallSession::State newState,
 		const string &message
 	) override {
@@ -111,7 +111,7 @@ void ClientGroupToBasicChatRoom::addParticipant (
 	ProxyChatRoom::addParticipant(participantAddress, params, hasMedia);
 }
 void ClientGroupToBasicChatRoom::addParticipants (
-	const std::list<IdentityAddress> &addresses,
+	const list<IdentityAddress> &addresses,
 	const CallSessionParams *params,
 	bool hasMedia
 ) {

src/chat/chat-room/server-group-chat-room-p.h

@@ -45,6 +45,7 @@ public:
 	ParticipantDevice::State getParticipantDeviceState (const std::shared_ptr<const ParticipantDevice> &device) const;
 	void setParticipantDeviceState (const std::shared_ptr<ParticipantDevice> &device, ParticipantDevice::State state);
 
+	void acceptSession (const std::shared_ptr<CallSession> &session);
 	void confirmCreation ();
 	void confirmJoining (SalCallOp *op);
 	void confirmRecreation (SalCallOp *op);
@@ -93,7 +94,7 @@ private:
 
 	// CallSessionListener
 	void onCallSessionStateChanged (
-		const std::shared_ptr<const CallSession> &session,
+		const std::shared_ptr<CallSession> &session,
 		CallSession::State newState,
 		const std::string &message
 	) override;

src/chat/chat-room/server-group-chat-room-stub.cpp

@@ -52,6 +52,8 @@ void ServerGroupChatRoomPrivate::setParticipantDeviceState (const std::shared_pt
 
 // -----------------------------------------------------------------------------
 
+void ServerGroupChatRoomPrivate::acceptSession (const shared_ptr<CallSession> &session) {}
+
 void ServerGroupChatRoomPrivate::confirmCreation () {}
 
 void ServerGroupChatRoomPrivate::confirmJoining (SalCallOp *) {}
@@ -117,7 +119,7 @@ void ServerGroupChatRoomPrivate::onChatRoomDeleteRequested (const shared_ptr<Abs
 // -----------------------------------------------------------------------------
 
 void ServerGroupChatRoomPrivate::onCallSessionStateChanged (
-	const shared_ptr<const CallSession> &,
+	const shared_ptr<CallSession> &,
 	CallSession::State,
 	const string &
 ) {}

src/conference/session/call-session-listener.h

@@ -34,51 +34,51 @@ class LINPHONE_PUBLIC CallSessionListener {
 public:
 	virtual ~CallSessionListener() = default;
 
-	virtual void onAckBeingSent (const std::shared_ptr<const CallSession> &session, LinphoneHeaders *headers) {}
-	virtual void onAckReceived (const std::shared_ptr<const CallSession> &session, LinphoneHeaders *headers) {}
-	virtual void onBackgroundTaskToBeStarted (const std::shared_ptr<const CallSession> &session) {}
-	virtual void onBackgroundTaskToBeStopped (const std::shared_ptr<const CallSession> &session) {}
-	virtual bool onCallSessionAccepted (const std::shared_ptr<const CallSession> &session) { return false; }
-	virtual void onCallSessionConferenceStreamStarting (const std::shared_ptr<const CallSession> &session, bool mute) {}
-	virtual void onCallSessionConferenceStreamStopping (const std::shared_ptr<const CallSession> &session) {}
-	virtual void onCallSessionEarlyFailed (const std::shared_ptr<const CallSession> &session, LinphoneErrorInfo *ei) {}
-	virtual void onCallSessionSetReleased (const std::shared_ptr<const CallSession> &session) {}
-	virtual void onCallSessionSetTerminated (const std::shared_ptr<const CallSession> &session) {}
-	virtual void onCallSessionStartReferred (const std::shared_ptr<const CallSession> &session) {}
-	virtual void onCallSessionStateChanged (const std::shared_ptr<const CallSession> &session, CallSession::State state, const std::string &message) {}
-	virtual void onCallSessionTransferStateChanged (const std::shared_ptr<const CallSession> &session, CallSession::State state) {}
-	virtual void onCheckForAcceptation (const std::shared_ptr<const CallSession> &session) {}
-	virtual void onDtmfReceived (const std::shared_ptr<const CallSession> &session, char dtmf) {}
-	virtual void onIncomingCallSessionNotified (const std::shared_ptr<const CallSession> &session) {}
-	virtual void onIncomingCallSessionStarted (const std::shared_ptr<const CallSession> &session) {}
-	virtual void onIncomingCallSessionTimeoutCheck (const std::shared_ptr<const CallSession> &session, int elapsed, bool oneSecondElapsed) {}
-	virtual void onInfoReceived (const std::shared_ptr<const CallSession> &session, const LinphoneInfoMessage *im) {}
-	virtual void onNoMediaTimeoutCheck (const std::shared_ptr<const CallSession> &session, bool oneSecondElapsed) {}
-
-	virtual void onEncryptionChanged (const std::shared_ptr<const CallSession> &session, bool activated, const std::string &authToken) {}
-
-	virtual void onCallSessionStateChangedForReporting (const std::shared_ptr<const CallSession> &session) {}
-	virtual void onRtcpUpdateForReporting (const std::shared_ptr<const CallSession> &session, SalStreamType type) {}
-	virtual void onStatsUpdated (const std::shared_ptr<const CallSession> &session, const LinphoneCallStats *stats) {}
-	virtual void onUpdateMediaInfoForReporting (const std::shared_ptr<const CallSession> &session, int statsType) {}
-
-	virtual void onResetCurrentSession (const std::shared_ptr<const CallSession> &session) {}
-	virtual void onSetCurrentSession (const std::shared_ptr<const CallSession> &session) {}
-
-	virtual void onFirstVideoFrameDecoded (const std::shared_ptr<const CallSession> &session) {}
-	virtual void onResetFirstVideoFrameDecoded (const std::shared_ptr<const CallSession> &session) {}
-
-	virtual void onPlayErrorTone (const std::shared_ptr<const CallSession> &session, LinphoneReason reason) {}
-	virtual void onRingbackToneRequested (const std::shared_ptr<const CallSession> &session, bool requested) {}
-	virtual void onStartRinging (const std::shared_ptr<const CallSession> &session) {}
-	virtual void onStopRinging (const std::shared_ptr<const CallSession> &session) {}
-	virtual void onStopRingingIfInCall (const std::shared_ptr<const CallSession> &session) {}
-	virtual void onStopRingingIfNeeded (const std::shared_ptr<const CallSession> &session) {}
-
-	virtual bool areSoundResourcesAvailable (const std::shared_ptr<const CallSession> &session) { return true; }
-	virtual bool isPlayingRingbackTone (const std::shared_ptr<const CallSession> &session) { return false; }
-
-	virtual void onRealTimeTextCharacterReceived (const std::shared_ptr<const CallSession> &session, RealtimeTextReceivedCharacter *data) {}
+	virtual void onAckBeingSent (const std::shared_ptr<CallSession> &session, LinphoneHeaders *headers) {}
+	virtual void onAckReceived (const std::shared_ptr<CallSession> &session, LinphoneHeaders *headers) {}
+	virtual void onBackgroundTaskToBeStarted (const std::shared_ptr<CallSession> &session) {}
+	virtual void onBackgroundTaskToBeStopped (const std::shared_ptr<CallSession> &session) {}
+	virtual bool onCallSessionAccepted (const std::shared_ptr<CallSession> &session) { return false; }
+	virtual void onCallSessionConferenceStreamStarting (const std::shared_ptr<CallSession> &session, bool mute) {}
+	virtual void onCallSessionConferenceStreamStopping (const std::shared_ptr<CallSession> &session) {}
+	virtual void onCallSessionEarlyFailed (const std::shared_ptr<CallSession> &session, LinphoneErrorInfo *ei) {}
+	virtual void onCallSessionSetReleased (const std::shared_ptr<CallSession> &session) {}
+	virtual void onCallSessionSetTerminated (const std::shared_ptr<CallSession> &session) {}
+	virtual void onCallSessionStartReferred (const std::shared_ptr<CallSession> &session) {}
+	virtual void onCallSessionStateChanged (const std::shared_ptr<CallSession> &session, CallSession::State state, const std::string &message) {}
+	virtual void onCallSessionTransferStateChanged (const std::shared_ptr<CallSession> &session, CallSession::State state) {}
+	virtual void onCheckForAcceptation (const std::shared_ptr<CallSession> &session) {}
+	virtual void onDtmfReceived (const std::shared_ptr<CallSession> &session, char dtmf) {}
+	virtual void onIncomingCallSessionNotified (const std::shared_ptr<CallSession> &session) {}
+	virtual void onIncomingCallSessionStarted (const std::shared_ptr<CallSession> &session) {}
+	virtual void onIncomingCallSessionTimeoutCheck (const std::shared_ptr<CallSession> &session, int elapsed, bool oneSecondElapsed) {}
+	virtual void onInfoReceived (const std::shared_ptr<CallSession> &session, const LinphoneInfoMessage *im) {}
+	virtual void onNoMediaTimeoutCheck (const std::shared_ptr<CallSession> &session, bool oneSecondElapsed) {}
+
+	virtual void onEncryptionChanged (const std::shared_ptr<CallSession> &session, bool activated, const std::string &authToken) {}
+
+	virtual void onCallSessionStateChangedForReporting (const std::shared_ptr<CallSession> &session) {}
+	virtual void onRtcpUpdateForReporting (const std::shared_ptr<CallSession> &session, SalStreamType type) {}
+	virtual void onStatsUpdated (const std::shared_ptr<CallSession> &session, const LinphoneCallStats *stats) {}
+	virtual void onUpdateMediaInfoForReporting (const std::shared_ptr<CallSession> &session, int statsType) {}
+
+	virtual void onResetCurrentSession (const std::shared_ptr<CallSession> &session) {}
+	virtual void onSetCurrentSession (const std::shared_ptr<CallSession> &session) {}
+
+	virtual void onFirstVideoFrameDecoded (const std::shared_ptr<CallSession> &session) {}
+	virtual void onResetFirstVideoFrameDecoded (const std::shared_ptr<CallSession> &session) {}
+
+	virtual void onPlayErrorTone (const std::shared_ptr<CallSession> &session, LinphoneReason reason) {}
+	virtual void onRingbackToneRequested (const std::shared_ptr<CallSession> &session, bool requested) {}
+	virtual void onStartRinging (const std::shared_ptr<CallSession> &session) {}
+	virtual void onStopRinging (const std::shared_ptr<CallSession> &session) {}