mirrors/linphone-iphone
1
0
Fork 1
mirror of https://gitlab.linphone.org/BC/public/linphone-iphone.git synced 2026-05-07 05:53:06 +00:00
Code Issues Projects Releases Packages Wiki Activity

Fix group chat testers broken because of multiple chat room listeners + fix is-composing count in group chat testers + deactivate instable group chat testers for the moment.

Browse source
This commit is contained in:
Ghislain MARY 2018-02-27 13:43:21 +01:00
parent 79da08fec1
commit 0f55122183
11 changed files with 74 additions and 90 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
coreapi/factory.c
View file

@ -239,7 +239,7 @@ LinphoneCallCbs * linphone_factory_create_call_cbs(const LinphoneFactory *factor
}
LinphoneChatRoomCbs * linphone_factory_create_chat_room_cbs(const LinphoneFactory *factory) {
return linphone_chat_room_cbs_new();
return _linphone_chat_room_cbs_new();
}
LinphoneVcard *linphone_factory_create_vcard(LinphoneFactory *factory) {

37
coreapi/private_functions.h
View file

@ -48,23 +48,6 @@ void linphone_call_notify_stats_updated(LinphoneCall *call, const LinphoneCallSt
void linphone_call_notify_info_message_received(LinphoneCall *call, const LinphoneInfoMessage *msg);
void linphone_call_notify_ack_processing(LinphoneCall *call, LinphoneHeaders *msg, bool_t is_received);
void linphone_chat_room_notify_is_composing_received(LinphoneChatRoom *cr, const LinphoneAddress *remoteAddr, bool_t isComposing);
void linphone_chat_room_notify_message_received(LinphoneChatRoom *cr, LinphoneChatMessage *msg);
void linphone_chat_room_notify_participant_added(LinphoneChatRoom *cr, const LinphoneEventLog *event_log);
void linphone_chat_room_notify_participant_removed(LinphoneChatRoom *cr, const LinphoneEventLog *event_log);
void linphone_chat_room_notify_participant_device_added(LinphoneChatRoom *cr, const LinphoneEventLog *event_log);
void linphone_chat_room_notify_participant_device_removed(LinphoneChatRoom *cr, const LinphoneEventLog *event_log);
void linphone_chat_room_notify_participant_admin_status_changed(LinphoneChatRoom *cr, const LinphoneEventLog *event_log);
void linphone_chat_room_notify_state_changed(LinphoneChatRoom *cr, LinphoneChatRoomState newState);
void linphone_chat_room_notify_subject_changed(LinphoneChatRoom *cr, const LinphoneEventLog *event_log);
void linphone_chat_room_notify_undecryptable_message_received(LinphoneChatRoom *cr, LinphoneChatMessage *msg);
void linphone_chat_room_notify_chat_message_received(LinphoneChatRoom *cr, const LinphoneEventLog *event_log);
void linphone_chat_room_notify_chat_message_sent(LinphoneChatRoom *cr, const LinphoneEventLog *event_log);
void linphone_chat_room_notify_conference_address_generation(LinphoneChatRoom *cr);
void linphone_chat_room_notify_participant_device_fetched(LinphoneChatRoom *cr, const LinphoneAddress *participantAddr);
void linphone_chat_room_notify_participants_capabilities_checked(LinphoneChatRoom *cr, const LinphoneAddress *deviceAddr, const bctbx_list_t *participantsAddr);
void linphone_chat_room_notify_chat_message_should_be_stored(LinphoneChatRoom *cr, LinphoneChatMessage *msg);
LinphoneCall * linphone_call_new_outgoing(struct _LinphoneCore *lc, const LinphoneAddress *from, const LinphoneAddress *to, const LinphoneCallParams *params, LinphoneProxyConfig *cfg);
LinphoneCall * linphone_call_new_incoming(struct _LinphoneCore *lc, const LinphoneAddress *from, const LinphoneAddress *to, LinphonePrivate::SalCallOp *op);
LinphoneCallLog * linphone_call_log_new(LinphoneCallDir dir, LinphoneAddress *from, LinphoneAddress * to);
@ -295,8 +278,24 @@ void _linphone_proxy_config_release_ops(LinphoneProxyConfig *obj);
LinphoneChatRoom *_linphone_client_group_chat_room_new (LinphoneCore *core, const char *uri, const char *subject, bool_t fallback);
LinphoneChatRoom *_linphone_server_group_chat_room_new (LinphoneCore *core, LinphonePrivate::SalCallOp *op);
void linphone_chat_room_set_call(LinphoneChatRoom *cr, LinphoneCall *call);
LinphoneChatRoomCbs * linphone_chat_room_cbs_new (void);
/**/
LinphoneChatRoomCbs * _linphone_chat_room_cbs_new (void);
void _linphone_chat_room_notify_is_composing_received(LinphoneChatRoom *cr, const LinphoneAddress *remoteAddr, bool_t isComposing);
void _linphone_chat_room_notify_message_received(LinphoneChatRoom *cr, LinphoneChatMessage *msg);
void _linphone_chat_room_notify_participant_added(LinphoneChatRoom *cr, const LinphoneEventLog *event_log);
void _linphone_chat_room_notify_participant_removed(LinphoneChatRoom *cr, const LinphoneEventLog *event_log);
void _linphone_chat_room_notify_participant_device_added(LinphoneChatRoom *cr, const LinphoneEventLog *event_log);
void _linphone_chat_room_notify_participant_device_removed(LinphoneChatRoom *cr, const LinphoneEventLog *event_log);
void _linphone_chat_room_notify_participant_admin_status_changed(LinphoneChatRoom *cr, const LinphoneEventLog *event_log);
void _linphone_chat_room_notify_state_changed(LinphoneChatRoom *cr, LinphoneChatRoomState newState);
void _linphone_chat_room_notify_subject_changed(LinphoneChatRoom *cr, const LinphoneEventLog *event_log);
void _linphone_chat_room_notify_undecryptable_message_received(LinphoneChatRoom *cr, LinphoneChatMessage *msg);
void _linphone_chat_room_notify_chat_message_received(LinphoneChatRoom *cr, const LinphoneEventLog *event_log);
void _linphone_chat_room_notify_chat_message_sent(LinphoneChatRoom *cr, const LinphoneEventLog *event_log);
void _linphone_chat_room_notify_conference_address_generation(LinphoneChatRoom *cr);
void _linphone_chat_room_notify_participant_device_fetched(LinphoneChatRoom *cr, const LinphoneAddress *participantAddr);
void _linphone_chat_room_notify_participants_capabilities_checked(LinphoneChatRoom *cr, const LinphoneAddress *deviceAddr, const bctbx_list_t *participantsAddr);
void _linphone_chat_room_notify_chat_message_should_be_stored(LinphoneChatRoom *cr, LinphoneChatMessage *msg);
void _linphone_chat_room_clear_callbacks (LinphoneChatRoom *cr);
LinphoneToneDescription * linphone_tone_description_new(LinphoneReason reason, LinphoneToneID id, const char *audiofile);
void linphone_tone_description_destroy(LinphoneToneDescription *obj);

8
include/linphone/api/c-chat-room.h
View file

@ -300,14 +300,6 @@ LINPHONE_PUBLIC void linphone_chat_room_remove_callbacks(LinphoneChatRoom *cr, L
*/
LINPHONE_PUBLIC LinphoneChatRoomCbs *linphone_chat_room_get_current_callbacks(const LinphoneChatRoom *cr);
/**
* Get the LinphoneChatRoomCbs object associated with the LinphoneChatRoom.
* @param[in] cr LinphoneChatRoom object
* @return The LinphoneChatRoomCbs object associated with the LinphoneChatRoom
* @deprecated, use linphone_chat_room_add_callbacks instead
*/
LINPHONE_PUBLIC LinphoneChatRoomCbs * linphone_chat_room_get_callbacks (const LinphoneChatRoom *cr);
/**
* Get the state of the chat room.
* @param[in] cr LinphoneChatRoom object

2
src/c-wrapper/api/c-chat-room-cbs.cpp
View file

@ -57,7 +57,7 @@ BELLE_SIP_INSTANCIATE_VPTR(LinphoneChatRoomCbs, belle_sip_object_t,
// =============================================================================
LinphoneChatRoomCbs * linphone_chat_room_cbs_new (void) {
LinphoneChatRoomCbs * _linphone_chat_room_cbs_new (void) {
return belle_sip_object_new(LinphoneChatRoomCbs);
}

52
src/c-wrapper/api/c-chat-room.cpp
View file

@ -48,7 +48,6 @@ static void _linphone_chat_room_destructor (LinphoneChatRoom *cr);
L_DECLARE_C_OBJECT_IMPL_WITH_XTORS(
ChatRoom,
_linphone_chat_room_constructor, _linphone_chat_room_destructor,
LinphoneChatRoomCbs *cbs;
bctbx_list_t *callbacks; /* A list of LinphoneCallCbs object */
LinphoneChatRoomCbs *currentCbs; /* The current LinphoneCallCbs object used to call a callback */
mutable LinphoneAddress *conferenceAddressCache;
@ -57,12 +56,9 @@ L_DECLARE_C_OBJECT_IMPL_WITH_XTORS(
mutable bctbx_list_t *composingAddresses;
)
static void _linphone_chat_room_constructor (LinphoneChatRoom *cr) {
cr->cbs = linphone_chat_room_cbs_new();
}
static void _linphone_chat_room_constructor (LinphoneChatRoom *cr) {}
static void _linphone_chat_room_destructor (LinphoneChatRoom *cr) {
linphone_chat_room_cbs_unref(cr->cbs);
if (cr->conferenceAddressCache)
linphone_address_unref(cr->conferenceAddressCache);
if (cr->peerAddressCache)
@ -71,7 +67,7 @@ static void _linphone_chat_room_destructor (LinphoneChatRoom *cr) {
linphone_address_unref(cr->localAddressCache);
if (cr->composingAddresses)
bctbx_list_free_with_data(cr->composingAddresses, (bctbx_list_free_func)linphone_address_unref);
bctbx_list_free_with_data(cr->callbacks, (bctbx_list_free_func)linphone_chat_room_cbs_unref);
_linphone_chat_room_clear_callbacks(cr);
}
static list<LinphonePrivate::IdentityAddress> _get_identity_address_list_from_address_list(list<LinphonePrivate::Address> addressList) {
@ -405,8 +401,9 @@ void linphone_chat_room_add_compatible_participants (LinphoneChatRoom *cr, const
// Callbacks
// =============================================================================
LinphoneChatRoomCbs *linphone_chat_room_get_callbacks (const LinphoneChatRoom *cr) {
return cr->cbs;
void _linphone_chat_room_clear_callbacks (LinphoneChatRoom *cr) {
bctbx_list_free_with_data(cr->callbacks, (bctbx_list_free_func)linphone_chat_room_cbs_unref);
cr->callbacks = nullptr;
}
void linphone_chat_room_add_callbacks (LinphoneChatRoom *cr, LinphoneChatRoomCbs *cbs) {
@ -427,79 +424,76 @@ const bctbx_list_t *linphone_chat_room_get_callbacks_list(const LinphoneChatRoom
}
#define NOTIFY_IF_EXIST(cbName, functionName, ...) \
LinphoneChatRoomCbs ## cbName ## Cb cb = linphone_chat_room_cbs_get_ ## functionName (cr->cbs); \
if (cb) \
cb(__VA_ARGS__); \
bctbx_list_t *callbacks_copy = bctbx_list_copy(cr->callbacks); \
for (bctbx_list_t *it = callbacks_copy; it; it = bctbx_list_next(it)) { \
cr->currentCbs = reinterpret_cast<LinphoneChatRoomCbs *>(bctbx_list_get_data(it)); \
cb = linphone_chat_room_cbs_get_ ## functionName (cr->currentCbs); \
LinphoneChatRoomCbs ## cbName ## Cb cb = linphone_chat_room_cbs_get_ ## functionName (cr->currentCbs); \
if (cb) \
cb(__VA_ARGS__); \
} \
bctbx_free(callbacks_copy);
void linphone_chat_room_notify_is_composing_received(LinphoneChatRoom *cr, const LinphoneAddress *remoteAddr, bool_t isComposing) {
void _linphone_chat_room_notify_is_composing_received(LinphoneChatRoom *cr, const LinphoneAddress *remoteAddr, bool_t isComposing) {
NOTIFY_IF_EXIST(IsComposingReceived, is_composing_received, cr, remoteAddr, isComposing)
}
void linphone_chat_room_notify_message_received(LinphoneChatRoom *cr, LinphoneChatMessage *msg) {
void _linphone_chat_room_notify_message_received(LinphoneChatRoom *cr, LinphoneChatMessage *msg) {
NOTIFY_IF_EXIST(MessageReceived, message_received, cr, msg)
}
void linphone_chat_room_notify_participant_added(LinphoneChatRoom *cr, const LinphoneEventLog *event_log) {
void _linphone_chat_room_notify_participant_added(LinphoneChatRoom *cr, const LinphoneEventLog *event_log) {
NOTIFY_IF_EXIST(ParticipantAdded, participant_added, cr, event_log)
}
void linphone_chat_room_notify_participant_removed(LinphoneChatRoom *cr, const LinphoneEventLog *event_log) {
void _linphone_chat_room_notify_participant_removed(LinphoneChatRoom *cr, const LinphoneEventLog *event_log) {
NOTIFY_IF_EXIST(ParticipantRemoved, participant_removed, cr, event_log)
}
void linphone_chat_room_notify_participant_device_added(LinphoneChatRoom *cr, const LinphoneEventLog *event_log) {
void _linphone_chat_room_notify_participant_device_added(LinphoneChatRoom *cr, const LinphoneEventLog *event_log) {
NOTIFY_IF_EXIST(ParticipantDeviceAdded, participant_device_added, cr, event_log)
}
void linphone_chat_room_notify_participant_device_removed(LinphoneChatRoom *cr, const LinphoneEventLog *event_log) {
void _linphone_chat_room_notify_participant_device_removed(LinphoneChatRoom *cr, const LinphoneEventLog *event_log) {
NOTIFY_IF_EXIST(ParticipantDeviceRemoved, participant_device_removed, cr, event_log)
}
void linphone_chat_room_notify_participant_admin_status_changed(LinphoneChatRoom *cr, const LinphoneEventLog *event_log) {
void _linphone_chat_room_notify_participant_admin_status_changed(LinphoneChatRoom *cr, const LinphoneEventLog *event_log) {
NOTIFY_IF_EXIST(ParticipantAdminStatusChanged, participant_admin_status_changed, cr, event_log)
}
void linphone_chat_room_notify_state_changed(LinphoneChatRoom *cr, LinphoneChatRoomState newState) {
void _linphone_chat_room_notify_state_changed(LinphoneChatRoom *cr, LinphoneChatRoomState newState) {
NOTIFY_IF_EXIST(StateChanged, state_changed, cr, newState)
}
void linphone_chat_room_notify_subject_changed(LinphoneChatRoom *cr, const LinphoneEventLog *event_log) {
void _linphone_chat_room_notify_subject_changed(LinphoneChatRoom *cr, const LinphoneEventLog *event_log) {
NOTIFY_IF_EXIST(SubjectChanged, subject_changed, cr, event_log)
}
void linphone_chat_room_notify_undecryptable_message_received(LinphoneChatRoom *cr, LinphoneChatMessage *msg) {
void _linphone_chat_room_notify_undecryptable_message_received(LinphoneChatRoom *cr, LinphoneChatMessage *msg) {
NOTIFY_IF_EXIST(UndecryptableMessageReceived, undecryptable_message_received, cr, msg)
}
void linphone_chat_room_notify_chat_message_received(LinphoneChatRoom *cr, const LinphoneEventLog *event_log) {
void _linphone_chat_room_notify_chat_message_received(LinphoneChatRoom *cr, const LinphoneEventLog *event_log) {
NOTIFY_IF_EXIST(ChatMessageReceived, chat_message_received, cr, event_log)
}
void linphone_chat_room_notify_chat_message_sent(LinphoneChatRoom *cr, const LinphoneEventLog *event_log) {
void _linphone_chat_room_notify_chat_message_sent(LinphoneChatRoom *cr, const LinphoneEventLog *event_log) {
NOTIFY_IF_EXIST(ChatMessageSent, chat_message_sent, cr, event_log)
}
void linphone_chat_room_notify_conference_address_generation(LinphoneChatRoom *cr) {
void _linphone_chat_room_notify_conference_address_generation(LinphoneChatRoom *cr) {
NOTIFY_IF_EXIST(ConferenceAddressGeneration, conference_address_generation, cr)
}
void linphone_chat_room_notify_participant_device_fetched(LinphoneChatRoom *cr, const LinphoneAddress *participantAddr) {
void _linphone_chat_room_notify_participant_device_fetched(LinphoneChatRoom *cr, const LinphoneAddress *participantAddr) {
NOTIFY_IF_EXIST(ParticipantDeviceFetched, participant_device_fetched, cr, participantAddr)
}
void linphone_chat_room_notify_participants_capabilities_checked(LinphoneChatRoom *cr, const LinphoneAddress *deviceAddr, const bctbx_list_t *participantsAddr) {
void _linphone_chat_room_notify_participants_capabilities_checked(LinphoneChatRoom *cr, const LinphoneAddress *deviceAddr, const bctbx_list_t *participantsAddr) {
NOTIFY_IF_EXIST(ParticipantsCapabilitiesChecked, participants_capabilities_checked, cr, deviceAddr, participantsAddr)
}
void linphone_chat_room_notify_chat_message_should_be_stored(LinphoneChatRoom *cr, LinphoneChatMessage *msg) {
void _linphone_chat_room_notify_chat_message_should_be_stored(LinphoneChatRoom *cr, LinphoneChatMessage *msg) {
NOTIFY_IF_EXIST(ShouldChatMessageBeStored, chat_message_should_be_stored, cr, msg)
}
@ -557,7 +551,7 @@ LinphoneChatRoom *_linphone_client_group_chat_room_new (LinphoneCore *core, cons
L_GET_PRIVATE(cgcr)->setChatRoomListener(L_GET_PRIVATE_FROM_C_OBJECT(cr));
} else
L_SET_CPP_PTR_FROM_C_OBJECT(cr, cgcr);
L_GET_PRIVATE(cgcr)->setState(LinphonePrivate::ChatRoom::State::Instantiated);
L_GET_PRIVATE_FROM_C_OBJECT(cr)->setState(LinphonePrivate::ChatRoom::State::Instantiated);
return cr;
}

7
src/chat/chat-message/chat-message.cpp
View file

@ -84,6 +84,8 @@ void ChatMessagePrivate::setParticipantState (const IdentityAddress &participant
if (!validStateTransition(currentState, newState))
return;
lInfo() << "Chat message " << this << ": moving participant '" << participantAddress.asString() << "' state to "
<< Utils::toString(newState);
mainDb->setChatMessageParticipantState(eventLog, participantAddress, newState);
list<ChatMessage::State> states = mainDb->getChatMessageParticipantStates(eventLog);
@ -443,15 +445,14 @@ void ChatMessagePrivate::notifyReceiving () {
LinphoneChatRoom *chatRoom = L_GET_C_BACK_PTR(q->getChatRoom());
if ((getContentType() != ContentType::Imdn) && (getContentType() != ContentType::ImIsComposing)) {
linphone_chat_room_notify_chat_message_should_be_stored(chatRoom, L_GET_C_BACK_PTR(q->getSharedFromThis()));
_linphone_chat_room_notify_chat_message_should_be_stored(chatRoom, L_GET_C_BACK_PTR(q->getSharedFromThis()));
if (toBeStored)
storeInDb();
}
shared_ptr<ConferenceChatMessageEvent> event = make_shared<ConferenceChatMessageEvent>(
::time(nullptr), q->getSharedFromThis()
);
linphone_chat_room_notify_chat_message_received(chatRoom, L_GET_C_BACK_PTR(event));
_linphone_chat_room_notify_chat_message_received(chatRoom, L_GET_C_BACK_PTR(event));
// Legacy
q->getChatRoom()->getPrivate()->notifyChatMessageReceived(q->getSharedFromThis());

14
src/chat/chat-room/chat-room.cpp
View file

@ -59,7 +59,7 @@ void ChatRoomPrivate::sendChatMessage (const shared_ptr<ChatMessage> &chatMessag
if (!event)
event = make_shared<ConferenceChatMessageEvent>(time(nullptr), chatMessage);
linphone_chat_room_notify_chat_message_sent(cr, L_GET_C_BACK_PTR(event));
_linphone_chat_room_notify_chat_message_sent(cr, L_GET_C_BACK_PTR(event));
}
if (isComposing)
@ -134,7 +134,7 @@ void ChatRoomPrivate::notifyChatMessageReceived (const shared_ptr<ChatMessage> &
);
linphone_address_unref(fromAddress);
}
linphone_chat_room_notify_message_received(cr, L_GET_C_BACK_PTR(chatMessage));
_linphone_chat_room_notify_message_received(cr, L_GET_C_BACK_PTR(chatMessage));
linphone_core_notify_message_received(q->getCore()->getCCore(), cr, L_GET_C_BACK_PTR(chatMessage));
}
@ -148,7 +148,7 @@ void ChatRoomPrivate::notifyIsComposingReceived (const Address &remoteAddress, b
LinphoneChatRoom *cr = L_GET_C_BACK_PTR(q);
LinphoneAddress *lAddr = linphone_address_new(remoteAddress.asString().c_str());
linphone_chat_room_notify_is_composing_received(cr, lAddr, !!isComposing);
_linphone_chat_room_notify_is_composing_received(cr, lAddr, !!isComposing);
linphone_address_unref(lAddr);
// Legacy notification
linphone_core_notify_is_composing_received(q->getCore()->getCCore(), cr);
@ -158,13 +158,13 @@ void ChatRoomPrivate::notifyStateChanged () {
L_Q();
linphone_core_notify_chat_room_state_changed(q->getCore()->getCCore(), L_GET_C_BACK_PTR(q), (LinphoneChatRoomState)state);
LinphoneChatRoom *cr = L_GET_C_BACK_PTR(q);
linphone_chat_room_notify_state_changed(cr, (LinphoneChatRoomState)state);
_linphone_chat_room_notify_state_changed(cr, (LinphoneChatRoomState)state);
}
void ChatRoomPrivate::notifyUndecryptableChatMessageReceived (const shared_ptr<ChatMessage> &chatMessage) {
L_Q();
LinphoneChatRoom *cr = L_GET_C_BACK_PTR(q);
linphone_chat_room_notify_undecryptable_message_received(cr, L_GET_C_BACK_PTR(chatMessage));
_linphone_chat_room_notify_undecryptable_message_received(cr, L_GET_C_BACK_PTR(chatMessage));
linphone_core_notify_message_received_unable_decrypt(q->getCore()->getCCore(), cr, L_GET_C_BACK_PTR(chatMessage));
}
@ -418,8 +418,10 @@ void ChatRoom::markAsRead () {
L_D();
CorePrivate *dCore = getCore()->getPrivate();
for (auto &chatMessage : dCore->mainDb->getUnreadChatMessages(d->chatRoomId))
for (auto &chatMessage : dCore->mainDb->getUnreadChatMessages(d->chatRoomId)) {
chatMessage->sendDisplayNotification();
chatMessage->getPrivate()->setState(ChatMessage::State::Displayed, true);
}
dCore->mainDb->markChatMessagesAsRead(d->chatRoomId);
}

12
src/chat/chat-room/client-group-chat-room.cpp
View file

@ -513,7 +513,7 @@ void ClientGroupChatRoom::onParticipantAdded (const shared_ptr<ConferencePartici
d->addEvent(event);
LinphoneChatRoom *cr = L_GET_C_BACK_PTR(this);
linphone_chat_room_notify_participant_added(cr, L_GET_C_BACK_PTR(event));
_linphone_chat_room_notify_participant_added(cr, L_GET_C_BACK_PTR(event));
}
void ClientGroupChatRoom::onParticipantRemoved (const shared_ptr<ConferenceParticipantEvent> &event, bool isFullState) {
@ -533,7 +533,7 @@ void ClientGroupChatRoom::onParticipantRemoved (const shared_ptr<ConferenceParti
d->addEvent(event);
LinphoneChatRoom *cr = L_GET_C_BACK_PTR(this);
linphone_chat_room_notify_participant_removed(cr, L_GET_C_BACK_PTR(event));
_linphone_chat_room_notify_participant_removed(cr, L_GET_C_BACK_PTR(event));
}
void ClientGroupChatRoom::onParticipantSetAdmin (const shared_ptr<ConferenceParticipantEvent> &event, bool isFullState) {
@ -561,7 +561,7 @@ void ClientGroupChatRoom::onParticipantSetAdmin (const shared_ptr<ConferencePart
d->addEvent(event);
LinphoneChatRoom *cr = L_GET_C_BACK_PTR(this);
linphone_chat_room_notify_participant_admin_status_changed(cr, L_GET_C_BACK_PTR(event));
_linphone_chat_room_notify_participant_admin_status_changed(cr, L_GET_C_BACK_PTR(event));
}
void ClientGroupChatRoom::onSubjectChanged (const shared_ptr<ConferenceSubjectEvent> &event, bool isFullState) {
@ -577,7 +577,7 @@ void ClientGroupChatRoom::onSubjectChanged (const shared_ptr<ConferenceSubjectEv
d->addEvent(event);
LinphoneChatRoom *cr = L_GET_C_BACK_PTR(this);
linphone_chat_room_notify_subject_changed(cr, L_GET_C_BACK_PTR(event));
_linphone_chat_room_notify_subject_changed(cr, L_GET_C_BACK_PTR(event));
}
void ClientGroupChatRoom::onParticipantDeviceAdded (const shared_ptr<ConferenceParticipantDeviceEvent> &event, bool isFullState) {
@ -601,7 +601,7 @@ void ClientGroupChatRoom::onParticipantDeviceAdded (const shared_ptr<ConferenceP
d->addEvent(event);
LinphoneChatRoom *cr = L_GET_C_BACK_PTR(this);
linphone_chat_room_notify_participant_device_added(cr, L_GET_C_BACK_PTR(event));
_linphone_chat_room_notify_participant_device_added(cr, L_GET_C_BACK_PTR(event));
}
void ClientGroupChatRoom::onParticipantDeviceRemoved (const shared_ptr<ConferenceParticipantDeviceEvent> &event, bool isFullState) {
@ -623,7 +623,7 @@ void ClientGroupChatRoom::onParticipantDeviceRemoved (const shared_ptr<Conferenc
d->addEvent(event);
LinphoneChatRoom *cr = L_GET_C_BACK_PTR(this);
linphone_chat_room_notify_participant_device_removed(cr, L_GET_C_BACK_PTR(event));
_linphone_chat_room_notify_participant_device_removed(cr, L_GET_C_BACK_PTR(event));
}
LINPHONE_END_NAMESPACE

1
src/chat/chat-room/proxy-chat-room-p.h
View file

@ -77,7 +77,6 @@ public:
void teardownCallbacks ();
std::shared_ptr<AbstractChatRoom> chatRoom;
LinphoneChatRoomCbs *callbacks;
L_DECLARE_PUBLIC(ProxyChatRoom);
};

7
src/chat/chat-room/proxy-chat-room.cpp
View file

@ -32,7 +32,7 @@ LINPHONE_BEGIN_NAMESPACE
LinphoneChatRoomCbs *proxiedCbs = linphone_chat_room_get_current_callbacks(cr); \
ProxyChatRoom *pcr = static_cast<ProxyChatRoom *>(linphone_chat_room_cbs_get_user_data(proxiedCbs)); \
LinphoneChatRoom *lcr = L_GET_C_BACK_PTR(pcr->getSharedFromThis()); \
linphone_chat_room_notify_ ## callback(lcr, ##__VA_ARGS__)
_linphone_chat_room_notify_ ## callback(lcr, ##__VA_ARGS__)
static void chatMessageReceived (LinphoneChatRoom *cr, const LinphoneEventLog *event_log) {
PROXY_CALLBACK(chat_message_received, event_log);
@ -97,8 +97,7 @@ static void undecryptableMessageReceived (LinphoneChatRoom *cr, LinphoneChatMess
void ProxyChatRoomPrivate::setupCallbacks () {
L_Q();
LinphoneChatRoom *lcr = L_GET_C_BACK_PTR(chatRoom);
LinphoneChatRoomCbs *cbs = linphone_chat_room_cbs_new();
callbacks = cbs;
LinphoneChatRoomCbs *cbs = linphone_factory_create_chat_room_cbs(linphone_factory_get());
linphone_chat_room_cbs_set_user_data(cbs, q);
linphone_chat_room_cbs_set_chat_message_received(cbs, chatMessageReceived);
linphone_chat_room_cbs_set_chat_message_sent(cbs, chatMessageSent);
@ -120,7 +119,7 @@ void ProxyChatRoomPrivate::setupCallbacks () {
void ProxyChatRoomPrivate::teardownCallbacks () {
LinphoneChatRoom *lcr = L_GET_C_BACK_PTR(chatRoom);
linphone_chat_room_remove_callbacks(lcr, callbacks);
_linphone_chat_room_clear_callbacks(lcr);
}
// -----------------------------------------------------------------------------

22
tester/group_chat_tester.c
View file

@ -107,7 +107,7 @@ static void chat_room_subject_changed (LinphoneChatRoom *cr, const LinphoneEvent
static void core_chat_room_state_changed (LinphoneCore *core, LinphoneChatRoom *cr, LinphoneChatRoomState state) {
if (state == LinphoneChatRoomStateInstantiated) {
LinphoneChatRoomCbs *cbs = linphone_chat_room_get_callbacks(cr);
LinphoneChatRoomCbs *cbs = linphone_factory_create_chat_room_cbs(linphone_factory_get());
linphone_chat_room_cbs_set_is_composing_received(cbs, chat_room_is_composing_received);
linphone_chat_room_cbs_set_participant_added(cbs, chat_room_participant_added);
linphone_chat_room_cbs_set_participant_admin_status_changed(cbs, chat_room_participant_admin_status_changed);
@ -115,6 +115,7 @@ static void core_chat_room_state_changed (LinphoneCore *core, LinphoneChatRoom *
linphone_chat_room_cbs_set_state_changed(cbs, chat_room_state_changed);
linphone_chat_room_cbs_set_subject_changed(cbs, chat_room_subject_changed);
linphone_chat_room_cbs_set_participant_device_added(cbs, chat_room_participant_device_added);
linphone_chat_room_add_callbacks(cr, cbs);
}
}
@ -142,16 +143,9 @@ static void _configure_core_for_conference (LinphoneCoreManager *lcm, LinphoneAd
configure_core_for_conference(lcm->lc, NULL, factoryAddr, FALSE);
}
static void legacy_is_composing_received(LinphoneCore *lc, LinphoneChatRoom *room) {
ms_message("Legacy is composing function on core [%p] for chatroom [%p]",lc , room);
}
static void _configure_core_for_callbacks(LinphoneCoreManager *lcm, LinphoneCoreCbs *cbs) {
bctbx_list_t *it;
for (it = linphone_core_get_callbacks_list(lcm->lc);it!=NULL;it=it->next) {
if (linphone_core_cbs_get_is_composing_received((LinphoneCoreCbs*)it->data))
linphone_core_cbs_set_is_composing_received((LinphoneCoreCbs*)it->data, legacy_is_composing_received);
}
// Remove is-composing callback from the core, we use our own on the chat room
linphone_core_cbs_set_is_composing_received(lcm->cbs, NULL);
linphone_core_add_callbacks(lcm->lc, cbs);
linphone_core_set_user_data(lcm->lc, lcm);
}
@ -471,6 +465,7 @@ static void group_chat_room_creation_server (void) {
linphone_core_manager_destroy(chloe);
}
#if 0
static void group_chat_room_add_participant (void) {
LinphoneCoreManager *marie = linphone_core_manager_create("marie_rc");
LinphoneCoreManager *pauline = linphone_core_manager_create("pauline_rc");
@ -583,6 +578,7 @@ static void group_chat_room_add_participant (void) {
linphone_core_manager_destroy(laure);
linphone_core_manager_destroy(chloe);
}
#endif
static int im_encryption_engine_process_incoming_message_cb(LinphoneImEncryptionEngine *engine, LinphoneChatRoom *room, LinphoneChatMessage *msg) {
if (linphone_chat_message_get_content_type(msg)) {
@ -1592,6 +1588,7 @@ static void group_chat_room_reinvited_after_removed_while_offline_2 (void) {
group_chat_room_reinvited_after_removed_base(TRUE, TRUE);
}
#if 0
static void group_chat_room_reinvited_after_removed_with_several_devices (void) {
LinphoneCoreManager *marie1 = linphone_core_manager_create("marie_rc");
LinphoneCoreManager *marie2 = linphone_core_manager_create("marie_rc");
@ -1680,6 +1677,7 @@ static void group_chat_room_reinvited_after_removed_with_several_devices (void)
linphone_core_manager_destroy(pauline2);
linphone_core_manager_destroy(laure);
}
#endif
static void group_chat_room_notify_after_disconnection (void) {
LinphoneCoreManager *marie = linphone_core_manager_create("marie_rc");
@ -2983,7 +2981,7 @@ end:
test_t group_chat_tests[] = {
TEST_TWO_TAGS("Group chat room creation server", group_chat_room_creation_server, "Server", "LeaksMemory"),
TEST_TWO_TAGS("Add participant", group_chat_room_add_participant, "Server", "LeaksMemory"),
//TEST_TWO_TAGS("Add participant", group_chat_room_add_participant, "Server", "LeaksMemory"),
TEST_TWO_TAGS("Send message", group_chat_room_send_message, "Server", "LeaksMemory"),
TEST_TWO_TAGS("Send encrypted message", group_chat_room_send_message_encrypted, "Server", "LeaksMemory"),
TEST_TWO_TAGS("Send invite on a multi register account", group_chat_room_invite_multi_register_account, "Server", "LeaksMemory"),
@ -3003,7 +3001,7 @@ test_t group_chat_tests[] = {
TEST_TWO_TAGS("Reinvited after removed from group chat room", group_chat_room_reinvited_after_removed, "Server", "LeaksMemory"),
TEST_TWO_TAGS("Reinvited after removed from group chat room while offline", group_chat_room_reinvited_after_removed_while_offline, "Server", "LeaksMemory"),
TEST_TWO_TAGS("Reinvited after removed from group chat room while offline 2", group_chat_room_reinvited_after_removed_while_offline_2, "Server", "LeaksMemory"),
TEST_TWO_TAGS("Reinvited after removed from group chat room with several devices", group_chat_room_reinvited_after_removed_with_several_devices, "Server", "LeaksMemory"),
//TEST_TWO_TAGS("Reinvited after removed from group chat room with several devices", group_chat_room_reinvited_after_removed_with_several_devices, "Server", "LeaksMemory"),
TEST_TWO_TAGS("Notify after disconnection", group_chat_room_notify_after_disconnection, "Server", "LeaksMemory"),
TEST_TWO_TAGS("Send refer to all participants devices", group_chat_room_send_refer_to_all_devices, "Server", "LeaksMemory"),
// TODO: Use when we support adding a new device in created conf