diff --git a/src/call/call-listener.h b/src/call/call-listener.h index f20ac5c2b..90027833d 100644 --- a/src/call/call-listener.h +++ b/src/call/call-listener.h @@ -29,23 +29,23 @@ LINPHONE_BEGIN_NAMESPACE class CallListener { public: - virtual void ackBeingSent (LinphoneHeaders *headers) = 0; - virtual void ackReceived (LinphoneHeaders *headers) = 0; - virtual void callSetReleased () = 0; - virtual void callSetTerminated () = 0; - virtual void callStateChanged (LinphoneCallState state, const std::string &message) = 0; - virtual void incomingCallStarted () = 0; - virtual void incomingCallToBeAdded () = 0; + virtual void onAckBeingSent (LinphoneHeaders *headers) = 0; + virtual void onAckReceived (LinphoneHeaders *headers) = 0; + virtual void onCallSetReleased () = 0; + virtual void onCallSetTerminated () = 0; + virtual void onCallStateChanged (LinphoneCallState state, const std::string &message) = 0; + virtual void onIncomingCallStarted () = 0; + virtual void onIncomingCallToBeAdded () = 0; - virtual void encryptionChanged (bool activated, const std::string &authToken) = 0; + virtual void onEncryptionChanged (bool activated, const std::string &authToken) = 0; - virtual void statsUpdated (const LinphoneCallStats *stats) = 0; + virtual void onStatsUpdated (const LinphoneCallStats *stats) = 0; - virtual void resetCurrentCall () = 0; - virtual void setCurrentCall () = 0; + virtual void onResetCurrentCall () = 0; + virtual void onSetCurrentCall () = 0; - virtual void firstVideoFrameDecoded () = 0; - virtual void resetFirstVideoFrameDecoded () = 0; + virtual void onFirstVideoFrameDecoded () = 0; + virtual void onResetFirstVideoFrameDecoded () = 0; }; LINPHONE_END_NAMESPACE diff --git a/src/call/call-p.h b/src/call/call-p.h index 5233a0863..78e7a69de 100644 --- a/src/call/call-p.h +++ b/src/call/call-p.h @@ -57,23 +57,21 @@ public: SalOp * getOp () const; void setAudioMuted (bool value); - void ackBeingSent (LinphoneHeaders *headers); - void ackReceived (LinphoneHeaders *headers); - void callSetReleased (); - void callSetTerminated (); - void callStateChanged (LinphoneCallState state, const std::string &message); - void incomingCallStarted (); - void incomingCallToBeAdded (); - - void encryptionChanged (bool activated, const std::string &authToken); - - void statsUpdated (const LinphoneCallStats *stats); - - void resetCurrentCall (); - void setCurrentCall (); - - void firstVideoFrameDecoded (); - void resetFirstVideoFrameDecoded (); +private: + /* CallListener */ + void onAckBeingSent (LinphoneHeaders *headers); + void onAckReceived (LinphoneHeaders *headers); + void onCallSetReleased (); + void onCallSetTerminated (); + void onCallStateChanged (LinphoneCallState state, const std::string &message); + void onIncomingCallStarted (); + void onIncomingCallToBeAdded (); + void onEncryptionChanged (bool activated, const std::string &authToken); + void onStatsUpdated (const LinphoneCallStats *stats); + void onResetCurrentCall (); + void onSetCurrentCall (); + void onFirstVideoFrameDecoded (); + void onResetFirstVideoFrameDecoded (); private: LinphoneCall *lcall = nullptr; diff --git a/src/call/call.cpp b/src/call/call.cpp index 8c638c909..e3da64617 100644 --- a/src/call/call.cpp +++ b/src/call/call.cpp @@ -99,22 +99,22 @@ int CallPrivate::startInvite (const Address *destination) { // ----------------------------------------------------------------------------- -void CallPrivate::ackBeingSent (LinphoneHeaders *headers) { +void CallPrivate::onAckBeingSent (LinphoneHeaders *headers) { if (lcall) linphone_call_notify_ack_processing(lcall, headers, false); } -void CallPrivate::ackReceived (LinphoneHeaders *headers) { +void CallPrivate::onAckReceived (LinphoneHeaders *headers) { if (lcall) linphone_call_notify_ack_processing(lcall, headers, true); } -void CallPrivate::callSetReleased () { +void CallPrivate::onCallSetReleased () { if (lcall) linphone_call_unref(lcall); } -void CallPrivate::callSetTerminated () { +void CallPrivate::onCallSetTerminated () { if (lcall) { if (lcall == core->current_call) { lInfo() << "Resetting the current call"; @@ -137,41 +137,41 @@ void CallPrivate::callSetTerminated () { } } -void CallPrivate::callStateChanged (LinphoneCallState state, const std::string &message) { +void CallPrivate::onCallStateChanged (LinphoneCallState state, const std::string &message) { if (lcall) linphone_call_notify_state_changed(lcall, state, message.c_str()); } -void CallPrivate::incomingCallStarted () { +void CallPrivate::onIncomingCallStarted () { if (lcall) linphone_core_notify_incoming_call(core, lcall); } -void CallPrivate::incomingCallToBeAdded () { +void CallPrivate::onIncomingCallToBeAdded () { if (lcall) /* The call is acceptable so we can now add it to our list */ linphone_core_add_call(core, lcall); } -void CallPrivate::encryptionChanged (bool activated, const std::string &authToken) { +void CallPrivate::onEncryptionChanged (bool activated, const std::string &authToken) { if (lcall) linphone_call_notify_encryption_changed(lcall, activated, authToken.empty() ? nullptr : authToken.c_str()); } -void CallPrivate::statsUpdated (const LinphoneCallStats *stats) { +void CallPrivate::onStatsUpdated (const LinphoneCallStats *stats) { if (lcall) linphone_call_notify_stats_updated(lcall, stats); } -void CallPrivate::resetCurrentCall () { +void CallPrivate::onResetCurrentCall () { core->current_call = nullptr; } -void CallPrivate::setCurrentCall () { +void CallPrivate::onSetCurrentCall () { if (lcall) core->current_call = lcall; } -void CallPrivate::firstVideoFrameDecoded () { +void CallPrivate::onFirstVideoFrameDecoded () { if (lcall && nextVideoFrameDecoded._func) { nextVideoFrameDecoded._func(lcall, nextVideoFrameDecoded._user_data); nextVideoFrameDecoded._func = nullptr; @@ -179,7 +179,7 @@ void CallPrivate::firstVideoFrameDecoded () { } } -void CallPrivate::resetFirstVideoFrameDecoded () { +void CallPrivate::onResetFirstVideoFrameDecoded () { #ifdef VIDEO_ENABLED if (lcall && nextVideoFrameDecoded._func) static_cast(getActiveSession().get())->resetFirstVideoFrameDecoded(); @@ -491,7 +491,7 @@ void Call::setNextVideoFrameDecodedCallback (LinphoneCallCbFunc cb, void *user_d L_D(Call); d->nextVideoFrameDecoded._func = cb; d->nextVideoFrameDecoded._user_data = user_data; - d->resetFirstVideoFrameDecoded(); + d->onResetFirstVideoFrameDecoded(); } void Call::setSpeakerVolumeGain (float value) { diff --git a/src/chat/chat-room-p.h b/src/chat/chat-room-p.h index 6d480f77f..2e6f88bb0 100644 --- a/src/chat/chat-room-p.h +++ b/src/chat/chat-room-p.h @@ -84,9 +84,10 @@ protected: void isComposingReceived (const std::string &text); private: - void isComposingStateChanged (bool isComposing); - void isRemoteComposingStateChanged (bool isComposing); - void isComposingRefreshNeeded (); + /* IsComposingListener */ + void onIsComposingStateChanged (bool isComposing); + void onIsRemoteComposingStateChanged (bool isComposing); + void onIsComposingRefreshNeeded (); public: LinphoneChatRoom *cBackPointer = nullptr; diff --git a/src/chat/chat-room.cpp b/src/chat/chat-room.cpp index a3e7f4030..8e1158644 100644 --- a/src/chat/chat-room.cpp +++ b/src/chat/chat-room.cpp @@ -522,17 +522,17 @@ void ChatRoomPrivate::isComposingReceived (const string &text) { // ----------------------------------------------------------------------------- -void ChatRoomPrivate::isComposingStateChanged (bool isComposing) { +void ChatRoomPrivate::onIsComposingStateChanged (bool isComposing) { this->isComposing = isComposing; sendIsComposingNotification(); } -void ChatRoomPrivate::isRemoteComposingStateChanged (bool isComposing) { +void ChatRoomPrivate::onIsRemoteComposingStateChanged (bool isComposing) { remoteIsComposing = isComposing; linphone_core_notify_is_composing_received(core, cBackPointer); } -void ChatRoomPrivate::isComposingRefreshNeeded () { +void ChatRoomPrivate::onIsComposingRefreshNeeded () { sendIsComposingNotification(); } diff --git a/src/chat/is-composing-listener.h b/src/chat/is-composing-listener.h index 730fc9761..9d8c2a40b 100644 --- a/src/chat/is-composing-listener.h +++ b/src/chat/is-composing-listener.h @@ -27,9 +27,9 @@ LINPHONE_BEGIN_NAMESPACE class IsComposingListener { public: - virtual void isComposingStateChanged (bool isComposing) = 0; - virtual void isRemoteComposingStateChanged (bool isComposing) = 0; - virtual void isComposingRefreshNeeded () = 0; + virtual void onIsComposingStateChanged (bool isComposing) = 0; + virtual void onIsRemoteComposingStateChanged (bool isComposing) = 0; + virtual void onIsComposingRefreshNeeded () = 0; }; LINPHONE_END_NAMESPACE diff --git a/src/chat/is-composing.cpp b/src/chat/is-composing.cpp index efc1c685d..09bd1ba2a 100644 --- a/src/chat/is-composing.cpp +++ b/src/chat/is-composing.cpp @@ -226,7 +226,7 @@ void IsComposing::parse (xmlparsing_context_t *xmlCtx) { stopRemoteRefreshTimer(); } - listener->isRemoteComposingStateChanged(state); + listener->onIsRemoteComposingStateChanged(state); linphone_free_xml_text_content(stateStr); } if (refreshStr) @@ -234,18 +234,18 @@ void IsComposing::parse (xmlparsing_context_t *xmlCtx) { } int IsComposing::idleTimerExpired (unsigned int revents) { - listener->isComposingStateChanged(false); + listener->onIsComposingStateChanged(false); return BELLE_SIP_STOP; } int IsComposing::refreshTimerExpired (unsigned int revents) { - listener->isComposingRefreshNeeded(); + listener->onIsComposingRefreshNeeded(); return BELLE_SIP_CONTINUE; } int IsComposing::remoteRefreshTimerExpired (unsigned int revents) { stopRemoteRefreshTimer(); - listener->isRemoteComposingStateChanged(false); + listener->onIsRemoteComposingStateChanged(false); return BELLE_SIP_STOP; } diff --git a/src/conference/conference-listener.h b/src/conference/conference-listener.h index 4bed6f68a..c68f634a4 100644 --- a/src/conference/conference-listener.h +++ b/src/conference/conference-listener.h @@ -25,11 +25,11 @@ LINPHONE_BEGIN_NAMESPACE class ConferenceListener { public: - virtual void conferenceCreated (LinphoneAddress *addr) = 0; - virtual void conferenceTerminated (LinphoneAddress *addr) = 0; - virtual void participantAdded (LinphoneAddress *addr) = 0; - virtual void participantRemoved (LinphoneAddress *addr) = 0; - virtual void participantSetAdmin (LinphoneAddress *addr, bool isAdmin) = 0; + virtual void onConferenceCreated (LinphoneAddress *addr) = 0; + virtual void onConferenceTerminated (LinphoneAddress *addr) = 0; + virtual void onParticipantAdded (LinphoneAddress *addr) = 0; + virtual void onParticipantRemoved (LinphoneAddress *addr) = 0; + virtual void onParticipantSetAdmin (LinphoneAddress *addr, bool isAdmin) = 0; }; LINPHONE_END_NAMESPACE diff --git a/src/conference/conference-p.h b/src/conference/conference-p.h index 52036702b..e2341de01 100644 --- a/src/conference/conference-p.h +++ b/src/conference/conference-p.h @@ -39,23 +39,21 @@ public: LinphoneCore * getCore () const { return core; } - virtual void ackBeingSent (const CallSession &session, LinphoneHeaders *headers); - virtual void ackReceived (const CallSession &session, LinphoneHeaders *headers); - virtual void callSessionAccepted (const CallSession &session); - virtual void callSessionSetReleased (const CallSession &session); - virtual void callSessionSetTerminated (const CallSession &session); - virtual void callSessionStateChanged (const CallSession &session, LinphoneCallState state, const std::string &message); - virtual void incomingCallSessionStarted (const CallSession &session); - - virtual void encryptionChanged (const CallSession &session, bool activated, const std::string &authToken); - - virtual void statsUpdated (const LinphoneCallStats *stats); - - virtual void resetCurrentSession (const CallSession &session); - virtual void setCurrentSession (const CallSession &session); - - virtual void firstVideoFrameDecoded (const CallSession &session); - virtual void resetFirstVideoFrameDecoded (const CallSession &session); +private: + /* CallSessionListener */ + virtual void onAckBeingSent (const CallSession &session, LinphoneHeaders *headers); + virtual void onAckReceived (const CallSession &session, LinphoneHeaders *headers); + virtual void onCallSessionAccepted (const CallSession &session); + virtual void onCallSessionSetReleased (const CallSession &session); + virtual void onCallSessionSetTerminated (const CallSession &session); + virtual void onCallSessionStateChanged (const CallSession &session, LinphoneCallState state, const std::string &message); + virtual void onIncomingCallSessionStarted (const CallSession &session); + virtual void onEncryptionChanged (const CallSession &session, bool activated, const std::string &authToken); + virtual void onStatsUpdated (const LinphoneCallStats *stats); + virtual void onResetCurrentSession (const CallSession &session); + virtual void onSetCurrentSession (const CallSession &session); + virtual void onFirstVideoFrameDecoded (const CallSession &session); + virtual void onResetFirstVideoFrameDecoded (const CallSession &session); private: LinphoneCore *core = nullptr; diff --git a/src/conference/conference.cpp b/src/conference/conference.cpp index affe724ec..856a6e587 100644 --- a/src/conference/conference.cpp +++ b/src/conference/conference.cpp @@ -27,69 +27,69 @@ LINPHONE_BEGIN_NAMESPACE // ============================================================================= -void ConferencePrivate::ackBeingSent (const CallSession &session, LinphoneHeaders *headers) { +void ConferencePrivate::onAckBeingSent (const CallSession &session, LinphoneHeaders *headers) { if (callListener) - callListener->ackBeingSent(headers); + callListener->onAckBeingSent(headers); } -void ConferencePrivate::ackReceived (const CallSession &session, LinphoneHeaders *headers) { +void ConferencePrivate::onAckReceived (const CallSession &session, LinphoneHeaders *headers) { if (callListener) - callListener->ackReceived(headers); + callListener->onAckReceived(headers); } -void ConferencePrivate::callSessionAccepted (const CallSession &session) { +void ConferencePrivate::onCallSessionAccepted (const CallSession &session) { if (callListener) - callListener->incomingCallToBeAdded(); + callListener->onIncomingCallToBeAdded(); } -void ConferencePrivate::callSessionSetReleased (const CallSession &session) { +void ConferencePrivate::onCallSessionSetReleased (const CallSession &session) { if (callListener) - callListener->callSetReleased(); + callListener->onCallSetReleased(); } -void ConferencePrivate::callSessionSetTerminated (const CallSession &session) { +void ConferencePrivate::onCallSessionSetTerminated (const CallSession &session) { if (callListener) - callListener->callSetTerminated(); + callListener->onCallSetTerminated(); } -void ConferencePrivate::callSessionStateChanged (const CallSession &session, LinphoneCallState state, const string &message) { +void ConferencePrivate::onCallSessionStateChanged (const CallSession &session, LinphoneCallState state, const string &message) { if (callListener) - callListener->callStateChanged(state, message); + callListener->onCallStateChanged(state, message); } -void ConferencePrivate::incomingCallSessionStarted (const CallSession &session) { +void ConferencePrivate::onIncomingCallSessionStarted (const CallSession &session) { if (callListener) - callListener->incomingCallStarted(); + callListener->onIncomingCallStarted(); } -void ConferencePrivate::encryptionChanged (const CallSession &session, bool activated, const string &authToken) { +void ConferencePrivate::onEncryptionChanged (const CallSession &session, bool activated, const string &authToken) { if (callListener) - callListener->encryptionChanged(activated, authToken); + callListener->onEncryptionChanged(activated, authToken); } -void ConferencePrivate::statsUpdated (const LinphoneCallStats *stats) { +void ConferencePrivate::onStatsUpdated (const LinphoneCallStats *stats) { if (callListener) - callListener->statsUpdated(stats); + callListener->onStatsUpdated(stats); } -void ConferencePrivate::resetCurrentSession (const CallSession &session) { +void ConferencePrivate::onResetCurrentSession (const CallSession &session) { if (callListener) - callListener->resetCurrentCall(); + callListener->onResetCurrentCall(); } -void ConferencePrivate::setCurrentSession (const CallSession &session) { +void ConferencePrivate::onSetCurrentSession (const CallSession &session) { if (callListener) - callListener->setCurrentCall(); + callListener->onSetCurrentCall(); } -void ConferencePrivate::firstVideoFrameDecoded (const CallSession &session) { +void ConferencePrivate::onFirstVideoFrameDecoded (const CallSession &session) { if (callListener) - callListener->firstVideoFrameDecoded(); + callListener->onFirstVideoFrameDecoded(); } -void ConferencePrivate::resetFirstVideoFrameDecoded (const CallSession &session) { +void ConferencePrivate::onResetFirstVideoFrameDecoded (const CallSession &session) { if (callListener) - callListener->resetFirstVideoFrameDecoded(); + callListener->onResetFirstVideoFrameDecoded(); } // ============================================================================= diff --git a/src/conference/session/call-session-listener.h b/src/conference/session/call-session-listener.h index 96d96d6f9..29f574559 100644 --- a/src/conference/session/call-session-listener.h +++ b/src/conference/session/call-session-listener.h @@ -25,23 +25,23 @@ LINPHONE_BEGIN_NAMESPACE class CallSessionListener { public: - virtual void ackBeingSent (const CallSession &session, LinphoneHeaders *headers) = 0; - virtual void ackReceived (const CallSession &session, LinphoneHeaders *headers) = 0; - virtual void callSessionAccepted (const CallSession &session) = 0; - virtual void callSessionSetReleased (const CallSession &session) = 0; - virtual void callSessionSetTerminated (const CallSession &session) = 0; - virtual void callSessionStateChanged (const CallSession &session, LinphoneCallState state, const std::string &message) = 0; - virtual void incomingCallSessionStarted (const CallSession &session) = 0; + virtual void onAckBeingSent (const CallSession &session, LinphoneHeaders *headers) = 0; + virtual void onAckReceived (const CallSession &session, LinphoneHeaders *headers) = 0; + virtual void onCallSessionAccepted (const CallSession &session) = 0; + virtual void onCallSessionSetReleased (const CallSession &session) = 0; + virtual void onCallSessionSetTerminated (const CallSession &session) = 0; + virtual void onCallSessionStateChanged (const CallSession &session, LinphoneCallState state, const std::string &message) = 0; + virtual void onIncomingCallSessionStarted (const CallSession &session) = 0; - virtual void encryptionChanged (const CallSession &session, bool activated, const std::string &authToken) = 0; + virtual void onEncryptionChanged (const CallSession &session, bool activated, const std::string &authToken) = 0; - virtual void statsUpdated (const LinphoneCallStats *stats) = 0; + virtual void onStatsUpdated (const LinphoneCallStats *stats) = 0; - virtual void resetCurrentSession (const CallSession &session) = 0; - virtual void setCurrentSession (const CallSession &session) = 0; + virtual void onResetCurrentSession (const CallSession &session) = 0; + virtual void onSetCurrentSession (const CallSession &session) = 0; - virtual void firstVideoFrameDecoded (const CallSession &session) = 0; - virtual void resetFirstVideoFrameDecoded (const CallSession &session) = 0; + virtual void onFirstVideoFrameDecoded (const CallSession &session) = 0; + virtual void onResetFirstVideoFrameDecoded (const CallSession &session) = 0; }; LINPHONE_END_NAMESPACE diff --git a/src/conference/session/call-session.cpp b/src/conference/session/call-session.cpp index b88a80ae8..ef902e8eb 100644 --- a/src/conference/session/call-session.cpp +++ b/src/conference/session/call-session.cpp @@ -184,7 +184,7 @@ void CallSessionPrivate::setState(LinphoneCallState newState, const string &mess linphone_call_state_to_string(prevState) << " to " << linphone_call_state_to_string(state) << ")"; } if (listener) - listener->callSessionStateChanged(*q, state, message); + listener->onCallSessionStateChanged(*q, state, message); if (newState == LinphoneCallReleased) setReleased(); /* Shall be performed after app notification */ } @@ -247,13 +247,13 @@ void CallSessionPrivate::accepted () { void CallSessionPrivate::ackBeingSent (LinphoneHeaders *headers) { L_Q(CallSession); if (listener) - listener->ackBeingSent(*q, headers); + listener->onAckBeingSent(*q, headers); } void CallSessionPrivate::ackReceived (LinphoneHeaders *headers) { L_Q(CallSession); if (listener) - listener->ackReceived(*q, headers); + listener->onAckReceived(*q, headers); } bool CallSessionPrivate::failure () { @@ -488,7 +488,7 @@ void CallSessionPrivate::accept (const shared_ptr params) { sal_call_accept(op); linphone_core_notify_display_status(core, _("Connected.")); if (listener) - listener->setCurrentSession(*q); + listener->onSetCurrentSession(*q); setState(LinphoneCallConnected, "Connected"); } @@ -615,7 +615,7 @@ void CallSessionPrivate::setReleased () { } #endif if (listener) - listener->callSessionSetReleased(*q); + listener->onCallSessionSetReleased(*q); } /* This method is called internally to get rid of a call that was notified to the application, @@ -627,7 +627,7 @@ void CallSessionPrivate::setTerminated() { L_Q(CallSession); completeLog(); if (listener) - listener->callSessionSetTerminated(*q); + listener->onCallSessionSetTerminated(*q); } LinphoneStatus CallSessionPrivate::startAcceptUpdate (LinphoneCallState nextState, const std::string &stateInfo) { @@ -882,7 +882,7 @@ void CallSession::iterate (time_t currentRealTime, bool oneSecondElapsed) { void CallSession::startIncomingNotification () { L_D(CallSession); if (d->listener) - d->listener->callSessionAccepted(*this); + d->listener->onCallSessionAccepted(*this); /* Prevent the CallSession from being destroyed while we are notifying, if the user declines within the state callback */ shared_ptr ref = shared_from_this(); #if 0 @@ -904,7 +904,7 @@ void CallSession::startIncomingNotification () { ms_free(msg); if (d->listener) - d->listener->incomingCallSessionStarted(*this); + d->listener->onIncomingCallSessionStarted(*this); d->setState(LinphoneCallIncomingReceived, "Incoming call"); diff --git a/src/conference/session/media-session.cpp b/src/conference/session/media-session.cpp index e74ee7cca..615f1bdf4 100644 --- a/src/conference/session/media-session.cpp +++ b/src/conference/session/media-session.cpp @@ -158,7 +158,7 @@ void MediaSessionPrivate::accepted () { nextStateMsg = "Call paused by remote"; } else { if (!params->getPrivate()->getInConference() && listener) - listener->setCurrentSession(*q); + listener->onSetCurrentSession(*q); nextState = LinphoneCallStreamsRunning; nextStateMsg = "Streams running"; } @@ -865,7 +865,7 @@ void MediaSessionPrivate::notifyStatsUpdated (int streamIndex) const { break; } if (listener) - listener->statsUpdated(stats); + listener->onStatsUpdated(stats); stats->updated = 0; } } @@ -2926,7 +2926,7 @@ void MediaSessionPrivate::startVideoStream (LinphoneCallState targetState) { } ms_media_stream_sessions_set_encryption_mandatory(&videoStream->ms.sessions, isEncryptionMandatory()); if (listener) - listener->resetFirstVideoFrameDecoded(*q); + listener->onResetFirstVideoFrameDecoded(*q); /* Start ZRTP engine if needed : set here or remote have a zrtp-hash attribute */ SalMediaDescription *remote = sal_call_get_remote_media_description(op); const SalStreamDescription *remoteStream = sal_media_description_find_best_stream(remote, SalVideo); @@ -3357,7 +3357,7 @@ void MediaSessionPrivate::propagateEncryptionChanged () { lInfo() << "Some streams are not encrypted"; q->getCurrentParams()->setMediaEncryption(LinphoneMediaEncryptionNone); if (listener) - listener->encryptionChanged(*q, false, authToken); + listener->onEncryptionChanged(*q, false, authToken); } else { if (!authToken.empty()) { /* ZRTP only is using auth_token */ @@ -3370,7 +3370,7 @@ void MediaSessionPrivate::propagateEncryptionChanged () { << ((q->getCurrentParams()->getMediaEncryption() == LinphoneMediaEncryptionZRTP) ? "ZRTP" : (q->getCurrentParams()->getMediaEncryption() == LinphoneMediaEncryptionDTLS) ? "DTLS" : "Unknown mechanism"); if (listener) - listener->encryptionChanged(*q, true, authToken); + listener->onEncryptionChanged(*q, true, authToken); #ifdef VIDEO_ENABLED if (isEncryptionMandatory() && videoStream && media_stream_started(&videoStream->ms)) { /* Nothing could have been sent yet so generating key frame */ @@ -3621,7 +3621,7 @@ void MediaSessionPrivate::reportBandwidthForStream (MediaStream *ms, LinphoneStr linphone_call_stats_update(stats, ms); stats->updated |= LINPHONE_CALL_STATS_PERIODICAL_UPDATE; if (listener) - listener->statsUpdated(stats); + listener->onStatsUpdated(stats); stats->updated = 0; } } @@ -3684,7 +3684,7 @@ LinphoneStatus MediaSessionPrivate::pause () { if (sal_call_update(op, subject.c_str(), false) != 0) linphone_core_notify_display_warning(core, "Could not pause the call"); if (listener) - listener->resetCurrentSession(*q); + listener->onResetCurrentSession(*q); linphone_core_notify_display_status(core, "Pausing the current call..."); if (audioStream || videoStream || textStream) stopStreams(); @@ -3940,7 +3940,7 @@ void MediaSessionPrivate::videoStreamEventCb (const MSFilter *f, const unsigned case MS_VIDEO_DECODER_FIRST_IMAGE_DECODED: lInfo() << "First video frame decoded successfully"; if (listener) - listener->firstVideoFrameDecoded(*q); + listener->onFirstVideoFrameDecoded(*q); break; case MS_VIDEO_DECODER_SEND_PLI: case MS_VIDEO_DECODER_SEND_SLI: @@ -4202,7 +4202,7 @@ LinphoneStatus MediaSession::resume () { return -1; d->setState(LinphoneCallResuming,"Resuming"); if (!d->params->getPrivate()->getInConference() && d->listener) - d->listener->setCurrentSession(*this); + d->listener->onSetCurrentSession(*this); ostringstream os; os << "Resuming the call with " << getRemoteAddressAsString(); linphone_core_notify_display_status(d->core, os.str().c_str());