Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2025-05-02 06:06:10 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Save incoming not read private chat messages in config and delete it after reading.

Browse source 
Added queue for outgoing private offline chat messages. The queue is also saved until the private chat message could be delivered.
It does not work in the short time between the shutdown of the peer and the switch of the state to offline for that peer. For this we need a response of the peer.
Need recompile.

git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@3517 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
thunder2 2010-09-21 00:08:06 +00:00
parent 412cf5f928
commit 37fe5ff3a3
19 changed files with 709 additions and 236 deletions
Download patch file Download diff file Expand all files Collapse all files

27
libretroshare/src/retroshare/rsiface.h
View file

@ -216,19 +216,20 @@ class NotifyBase
virtual std::string askForPassword(const std::string& /* key_details */ ,bool /* prev_is_bad */ ) { return "" ;}
};
const int NOTIFY_LIST_NEIGHBOURS = 1;
const int NOTIFY_LIST_FRIENDS = 2;
const int NOTIFY_LIST_SEARCHLIST = 4;
const int NOTIFY_LIST_MESSAGELIST = 5;
const int NOTIFY_LIST_CHANNELLIST = 6;
const int NOTIFY_LIST_TRANSFERLIST = 7;
const int NOTIFY_LIST_CONFIG = 8;
const int NOTIFY_LIST_DIRLIST_LOCAL = 9;
const int NOTIFY_LIST_DIRLIST_FRIENDS = 10;
const int NOTIFY_LIST_FORUMLIST_LOCKED = 11; // use connect with Qt::QueuedConnection
const int NOTIFY_LIST_MESSAGE_TAGS = 12;
const int NOTIFY_LIST_PUBLIC_CHAT = 13;
const int NOTIFY_LIST_PRIVATE_CHAT = 14;
const int NOTIFY_LIST_NEIGHBOURS = 1;
const int NOTIFY_LIST_FRIENDS = 2;
const int NOTIFY_LIST_SEARCHLIST = 4;
const int NOTIFY_LIST_MESSAGELIST = 5;
const int NOTIFY_LIST_CHANNELLIST = 6;
const int NOTIFY_LIST_TRANSFERLIST = 7;
const int NOTIFY_LIST_CONFIG = 8;
const int NOTIFY_LIST_DIRLIST_LOCAL = 9;
const int NOTIFY_LIST_DIRLIST_FRIENDS = 10;
const int NOTIFY_LIST_FORUMLIST_LOCKED = 11; // use connect with Qt::QueuedConnection
const int NOTIFY_LIST_MESSAGE_TAGS = 12;
const int NOTIFY_LIST_PUBLIC_CHAT = 13;
const int NOTIFY_LIST_PRIVATE_INCOMING_CHAT = 14;
const int NOTIFY_LIST_PRIVATE_OUTGOING_CHAT = 15;
const int NOTIFY_TYPE_SAME = 0x01;
const int NOTIFY_TYPE_MOD = 0x02; /* general purpose, check all */

8
libretroshare/src/retroshare/rsmsgs.h
View file

@ -177,10 +177,12 @@ virtual bool resetMessageStandardTagTypes(MsgTagType& tags) = 0;
/* Chat */
virtual bool sendPublicChat(std::wstring msg) = 0;
virtual bool sendPrivateChat(std::string id, std::wstring msg) = 0;
virtual int getChatQueueCount(bool privateQueue) = 0;
virtual int getPublicChatQueueCount() = 0;
virtual bool getPublicChatQueue(std::list<ChatInfo> &chats) = 0;
virtual bool getPrivateChatQueueIds(std::list<std::string> &ids) = 0;
virtual bool getPrivateChatQueue(std::string id, std::list<ChatInfo> &chats) = 0;
virtual int getPrivateChatQueueCount(bool incoming) = 0;
virtual bool getPrivateChatQueueIds(bool incoming, std::list<std::string> &ids) = 0;
virtual bool getPrivateChatQueue(bool incoming, std::string id, std::list<ChatInfo> &chats) = 0;
virtual bool clearPrivateChatQueue(bool incoming, std::string id) = 0;
virtual void sendStatusString(const std::string& id,const std::string& status_string) = 0 ;
virtual void sendGroupChatStatusString(const std::string& status_string) = 0 ;

22
libretroshare/src/rsserver/p3msgs.cc
View file

@ -156,9 +156,9 @@ void p3Msgs::sendStatusString(const std::string& peer_id,const std::string& stat
mChatSrv->sendStatusString(peer_id,status_string);
}
int p3Msgs::getChatQueueCount(bool privateQueue)
int p3Msgs::getPublicChatQueueCount()
{
return mChatSrv->getChatQueueCount(privateQueue);
return mChatSrv->getPublicChatQueueCount();
}
bool p3Msgs::getPublicChatQueue(std::list<ChatInfo> &chats)
@ -166,14 +166,24 @@ bool p3Msgs::getPublicChatQueue(std::list<ChatInfo> &chats)
return mChatSrv->getPublicChatQueue(chats);
}
bool p3Msgs::getPrivateChatQueueIds(std::list<std::string> &ids)
int p3Msgs::getPrivateChatQueueCount(bool incoming)
{
return mChatSrv->getPrivateChatQueueIds(ids);
return mChatSrv->getPrivateChatQueueCount(incoming);
}
bool p3Msgs::getPrivateChatQueue(std::string id, std::list<ChatInfo> &chats)
bool p3Msgs::getPrivateChatQueueIds(bool incoming, std::list<std::string> &ids)
{
return mChatSrv->getPrivateChatQueue(id, chats);
return mChatSrv->getPrivateChatQueueIds(incoming, ids);
}
bool p3Msgs::getPrivateChatQueue(bool incoming, std::string id, std::list<ChatInfo> &chats)
{
return mChatSrv->getPrivateChatQueue(incoming, id, chats);
}
bool p3Msgs::clearPrivateChatQueue(bool incoming, std::string id)
{
return mChatSrv->clearPrivateChatQueue(incoming, id);
}
void p3Msgs::getOwnAvatarData(unsigned char *& data,int& size)

18
libretroshare/src/rsserver/p3msgs.h
View file

@ -119,23 +119,35 @@ class p3Msgs: public RsMsgs
* returns the count of messages in public or private queue
* @param public or private queue
*/
virtual int getChatQueueCount(bool privateQueue);
virtual int getPublicChatQueueCount();
/*!
* @param chats ref to list of received public chats is stored here
*/
virtual bool getPublicChatQueue(std::list<ChatInfo> &chats);
/*!
* returns the count of messages in private queue
* @param public or private queue
*/
virtual int getPrivateChatQueueCount(bool incoming);
/*!
* @param id's of available private chat messages
*/
virtual bool getPrivateChatQueueIds(std::list<std::string> &ids);
virtual bool getPrivateChatQueueIds(bool incoming, std::list<std::string> &ids);
/*!
* @param chats ref to list of received private chats is stored here
*/
virtual bool getPrivateChatQueue(std::string id, std::list<ChatInfo> &chats);
virtual bool getPrivateChatQueue(bool incoming, std::string id, std::list<ChatInfo> &chats);
/*!
* @param clear private chat queue
*/
virtual bool clearPrivateChatQueue(bool incoming, std::string id);
/*!
* sends immediate status string to a specific peer, e.g. in a private chat
* @param peer_id peer to send status string to

1
libretroshare/src/rsserver/rsinit.cc
View file

@ -2302,6 +2302,7 @@ int RsServer::StartupRetroShare()
#ifndef MINIMAL_LIBRS
mConnMgr->addMonitor(msgSrv);
mConnMgr->addMonitor(mStatusSrv);
mConnMgr->addMonitor(chatSrv);
#endif // MINIMAL_LIBRS
/* must also add the controller as a Monitor...

133
libretroshare/src/serialiser/rsmsgitems.cc
View file

@ -56,6 +56,31 @@ std::ostream& RsChatMsgItem::print(std::ostream &out, uint16_t indent)
return out;
}
std::ostream& RsPrivateChatMsgConfigItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsPrivateChatMsgConfigItem", indent);
uint16_t int_Indent = indent + 2;
out << "peerId: " << configPeerId << std::endl;
printIndent(out, int_Indent);
out << "QblogMs " << chatFlags << std::endl;
printIndent(out, int_Indent);
out << "QblogMs " << configFlags << std::endl;
printIndent(out, int_Indent);
out << "sendTime: " << sendTime << std::endl;
printIndent(out, int_Indent);
std::string cnv_message(message.begin(), message.end());
out << "msg: " << cnv_message << std::endl;
printRsItemEnd(out, "RsPrivateChatMsgConfigItem", indent);
return out;
}
std::ostream& RsChatStatusItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsChatStatusItem", indent);
@ -110,9 +135,10 @@ RsItem *RsChatSerialiser::deserialise(void *data, uint32_t *pktsize)
switch(getRsItemSubType(rstype))
{
case RS_PKT_SUBTYPE_DEFAULT: return new RsChatMsgItem(data,*pktsize) ;
case RS_PKT_SUBTYPE_CHAT_STATUS: return new RsChatStatusItem(data,*pktsize) ;
case RS_PKT_SUBTYPE_CHAT_AVATAR: return new RsChatAvatarItem(data,*pktsize) ;
case RS_PKT_SUBTYPE_DEFAULT: return new RsChatMsgItem(data,*pktsize) ;
case RS_PKT_SUBTYPE_PRIVATECHATMSG_CONFIG: return new RsPrivateChatMsgConfigItem(data,*pktsize) ;
case RS_PKT_SUBTYPE_CHAT_STATUS: return new RsChatStatusItem(data,*pktsize) ;
case RS_PKT_SUBTYPE_CHAT_AVATAR: return new RsChatAvatarItem(data,*pktsize) ;
default:
std::cerr << "Unknown packet type in chat!" << std::endl ;
return NULL ;
@ -129,6 +155,19 @@ uint32_t RsChatMsgItem::serial_size()
return s;
}
uint32_t RsPrivateChatMsgConfigItem::serial_size()
{
uint32_t s = 8; /* header */
s += GetTlvStringSize(configPeerId);
s += 4; /* chatFlags */
s += 4; /* configFlags */
s += 4; /* sendTime */
s += GetTlvWideStringSize(message);
s += 4; /* recvTime */
return s;
}
uint32_t RsChatStatusItem::serial_size()
{
uint32_t s = 8; /* header */
@ -198,6 +237,47 @@ bool RsChatMsgItem::serialise(void *data, uint32_t& pktsize)
return ok;
}
bool RsPrivateChatMsgConfigItem::serialise(void *data, uint32_t& pktsize)
{
uint32_t tlvsize = serial_size() ;
uint32_t offset = 0;
if (pktsize < tlvsize)
return false; /* not enough space */
pktsize = tlvsize;
bool ok = true;
ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize);
#ifdef CHAT_DEBUG
std::cerr << "RsChatSerialiser::serialiseItem() Header: " << ok << std::endl;
std::cerr << "RsChatSerialiser::serialiseItem() Size: " << tlvsize << std::endl;
#endif
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_PEERID, configPeerId);
ok &= setRawUInt32(data, tlvsize, &offset, chatFlags);
ok &= setRawUInt32(data, tlvsize, &offset, configFlags);
ok &= setRawUInt32(data, tlvsize, &offset, sendTime);
ok &= SetTlvWideString(data, tlvsize, &offset, TLV_TYPE_WSTR_MSG, message);
ok &= setRawUInt32(data, tlvsize, &offset, recvTime);
if (offset != tlvsize)
{
ok = false;
#ifdef CHAT_DEBUG
std::cerr << "RsChatSerialiser::serialiseItem() Size Error! " << std::endl;
#endif
}
return ok;
}
bool RsChatStatusItem::serialise(void *data, uint32_t& pktsize)
{
uint32_t tlvsize = serial_size() ;
@ -302,6 +382,53 @@ RsChatMsgItem::RsChatMsgItem(void *data,uint32_t size)
std::cerr << "Unknown error while deserializing." << std::endl ;
}
RsPrivateChatMsgConfigItem::RsPrivateChatMsgConfigItem(void *data,uint32_t size)
: RsChatItem(RS_PKT_SUBTYPE_PRIVATECHATMSG_CONFIG)
{
uint32_t offset = 8; // skip the header
uint32_t rssize = getRsItemSize(data);
bool ok = true ;
/* get mandatory parts first */
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_PEERID, configPeerId);
ok &= getRawUInt32(data, rssize, &offset, &chatFlags);
ok &= getRawUInt32(data, rssize, &offset, &configFlags);
ok &= getRawUInt32(data, rssize, &offset, &sendTime);
ok &= GetTlvWideString(data, rssize, &offset, TLV_TYPE_WSTR_MSG, message);
ok &= getRawUInt32(data, rssize, &offset, &recvTime);
#ifdef CHAT_DEBUG
std::cerr << "Building new chat msg config item." << std::endl ;
#endif
if (offset != rssize)
std::cerr << "Size error while deserializing." << std::endl ;
if (!ok)
std::cerr << "Unknown error while deserializing." << std::endl ;
}
/* set data from RsChatMsgItem to RsPrivateChatMsgConfigItem */
void RsPrivateChatMsgConfigItem::set(RsChatMsgItem *ci, const std::string &peerId, uint32_t confFlags)
{
PeerId(ci->PeerId());
configPeerId = ci->PeerId();
chatFlags = ci->chatFlags;
configFlags = confFlags;
sendTime = ci->sendTime;
message = ci->message;
recvTime = ci->recvTime;
}
/* get data from RsPrivateChatMsgConfigItem to RsChatMsgItem */
void RsPrivateChatMsgConfigItem::get(RsChatMsgItem *ci)
{
ci->PeerId(configPeerId);
ci->chatFlags = chatFlags;
//configFlags not used
ci->sendTime = sendTime;
ci->message = message;
ci->recvTime = recvTime;
}
RsChatStatusItem::RsChatStatusItem(void *data,uint32_t size)
: RsChatItem(RS_PKT_SUBTYPE_CHAT_STATUS)
{

39
libretroshare/src/serialiser/rsmsgitems.h
View file

@ -44,8 +44,11 @@ const uint32_t RS_CHAT_FLAG_PUBLIC = 0x0020;
const uint32_t RS_CHAT_FLAG_REQUEST_CUSTOM_STATE = 0x0040;
const uint32_t RS_CHAT_FLAG_CUSTOM_STATE_AVAILABLE = 0x0080;
const uint8_t RS_PKT_SUBTYPE_CHAT_AVATAR = 0x03 ; // default is 0x01
const uint8_t RS_PKT_SUBTYPE_CHAT_STATUS = 0x04 ; // default is 0x01
const uint32_t RS_CHATMSG_CONFIGFLAG_INCOMING = 0x0001;
const uint8_t RS_PKT_SUBTYPE_CHAT_AVATAR = 0x03 ; // default is 0x01
const uint8_t RS_PKT_SUBTYPE_CHAT_STATUS = 0x04 ; // default is 0x01
const uint8_t RS_PKT_SUBTYPE_PRIVATECHATMSG_CONFIG = 0x05 ; // default is 0x01
// for defining tags themselves and msg tags
const uint8_t RS_PKT_SUBTYPE_MSG_TAG_TYPE = 0x03;
@ -86,7 +89,37 @@ class RsChatMsgItem: public RsChatItem
uint32_t sendTime;
std::wstring message;
/* not serialised */
uint32_t recvTime;
uint32_t recvTime;
};
/*!
* For saving incoming and outgoing chat msgs
* @see p3ChatService
*/
class RsPrivateChatMsgConfigItem: public RsChatItem
{
public:
RsPrivateChatMsgConfigItem() :RsChatItem(RS_PKT_SUBTYPE_PRIVATECHATMSG_CONFIG) {}
RsPrivateChatMsgConfigItem(void *data,uint32_t size) ; // deserialization
virtual ~RsPrivateChatMsgConfigItem() {}
virtual void clear() {}
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0);
virtual bool serialise(void *data,uint32_t& size) ; // Isn't it better that items can serialize themselves ?
virtual uint32_t serial_size() ; // deserialise is handled using a constructor
/* set data from RsChatMsgItem to RsPrivateChatMsgConfigItem */
void set(RsChatMsgItem *ci, const std::string &peerId, uint32_t confFlags);
/* get data from RsPrivateChatMsgConfigItem to RsChatMsgItem */
void get(RsChatMsgItem *ci);
std::string configPeerId;
uint32_t chatFlags;
uint32_t configFlags;
uint32_t sendTime;
std::wstring message;
uint32_t recvTime;
};
// This class contains activity info for the sending peer: active, idle, typing, etc.

224
libretroshare/src/services/p3chatservice.cc
View file

@ -203,7 +203,7 @@ void p3ChatService::sendStatusString( const std::string& id , const std::string&
sendItem(cs);
}
int p3ChatService::sendPrivateChat(std::string &id, std::wstring &msg)
bool p3ChatService::sendPrivateChat(std::string &id, std::wstring &msg)
{
// make chat item....
#ifdef CHAT_DEBUG
@ -218,6 +218,20 @@ int p3ChatService::sendPrivateChat(std::string &id, std::wstring &msg)
ci->sendTime = time(NULL);
ci->message = msg;
if (!mConnMgr->isOnline(id)) {
/* peer is offline, add to outgoing list */
{
RsStackMutex stack(mChatMtx); /********** STACK LOCKED MTX ******/
privateOutgoingList.push_back(ci);
}
rsicontrol->getNotify().notifyListChange(NOTIFY_LIST_PRIVATE_OUTGOING_CHAT, NOTIFY_TYPE_ADD);
IndicateConfigChanged();
return false;
}
{
RsStackMutex stack(mChatMtx); /********** STACK LOCKED MTX ******/
std::map<std::string,AvatarInfo*>::iterator it = _avatars.find(id) ;
@ -278,7 +292,7 @@ int p3ChatService::sendPrivateChat(std::string &id, std::wstring &msg)
sendItem(cs) ;
}
return 1;
return true;
}
void p3ChatService::receiveChatQueue()
@ -288,7 +302,7 @@ void p3ChatService::receiveChatQueue()
time_t now = time(NULL);
RsItem *item ;
while(NULL != (item=recvItem()))
{
#ifdef CHAT_DEBUG
@ -348,7 +362,7 @@ void p3ChatService::receiveChatQueue()
if (ci->chatFlags & RS_CHAT_FLAG_PRIVATE) {
privateChanged = true;
privateList.push_back(ci); // don't delete the item !!
privateIncomingList.push_back(ci); // don't delete the item !!
} else {
publicChanged = true;
publicList.push_back(ci); // don't delete the item !!
@ -413,18 +427,16 @@ void p3ChatService::receiveChatQueue()
rsicontrol->getNotify().notifyListChange(NOTIFY_LIST_PUBLIC_CHAT, NOTIFY_TYPE_ADD);
}
if (privateChanged) {
rsicontrol->getNotify().notifyListChange(NOTIFY_LIST_PRIVATE_CHAT, NOTIFY_TYPE_ADD);
rsicontrol->getNotify().notifyListChange(NOTIFY_LIST_PRIVATE_INCOMING_CHAT, NOTIFY_TYPE_ADD);
IndicateConfigChanged(); // only private chat messages are saved
}
}
int p3ChatService::getChatQueueCount(bool privateQueue)
int p3ChatService::getPublicChatQueueCount()
{
RsStackMutex stack(mChatMtx); /********** STACK LOCKED MTX ******/
if (privateQueue) {
return privateList.size();
}
return publicList.size();
}
@ -462,19 +474,38 @@ bool p3ChatService::getPublicChatQueue(std::list<ChatInfo> &chats)
return true;
}
bool p3ChatService::getPrivateChatQueueIds(std::list<std::string> &ids)
int p3ChatService::getPrivateChatQueueCount(bool incoming)
{
RsStackMutex stack(mChatMtx); /********** STACK LOCKED MTX ******/
if (incoming) {
return privateIncomingList.size();
}
return privateOutgoingList.size();
}
bool p3ChatService::getPrivateChatQueueIds(bool incoming, std::list<std::string> &ids)
{
ids.clear();
RsStackMutex stack(mChatMtx); /********** STACK LOCKED MTX ******/
std::list<RsChatMsgItem *> *list;
if (incoming) {
list = &privateIncomingList;
} else {
list = &privateOutgoingList;
}
// get the items from the private list.
if (privateList.size() == 0) {
if (list->size() == 0) {
return false;
}
std::list<RsChatMsgItem *>::iterator it;
for (it = privateList.begin(); it != privateList.end(); it++) {
for (it = list->begin(); it != list->end(); it++) {
RsChatMsgItem *c = *it;
if (std::find(ids.begin(), ids.end(), c->PeerId()) == ids.end()) {
@ -485,34 +516,69 @@ bool p3ChatService::getPrivateChatQueueIds(std::list<std::string> &ids)
return true;
}
bool p3ChatService::getPrivateChatQueue(std::string id, std::list<ChatInfo> &chats)
bool p3ChatService::getPrivateChatQueue(bool incoming, const std::string &id, std::list<ChatInfo> &chats)
{
RsStackMutex stack(mChatMtx); /********** STACK LOCKED MTX ******/
std::list<RsChatMsgItem *> *list;
if (incoming) {
list = &privateIncomingList;
} else {
list = &privateOutgoingList;
}
// get the items from the private list.
if (list->size() == 0) {
return false;
}
std::list<RsChatMsgItem *>::iterator it;
for (it = list->begin(); it != list->end(); it++) {
RsChatMsgItem *c = *it;
if (c->PeerId() == id) {
ChatInfo ci;
initRsChatInfo(c, ci);
chats.push_back(ci);
}
}
return (chats.size() > 0);
}
bool p3ChatService::clearPrivateChatQueue(bool incoming, const std::string &id)
{
bool changed = false;
{
RsStackMutex stack(mChatMtx); /********** STACK LOCKED MTX ******/
std::list<RsChatMsgItem *> *list;
if (incoming) {
list = &privateIncomingList;
} else {
list = &privateOutgoingList;
}
// get the items from the private list.
if (privateList.size() == 0) {
if (list->size() == 0) {
return false;
}
std::list<RsChatMsgItem *>::iterator it = privateList.begin();
while (it != privateList.end()) {
std::list<RsChatMsgItem *>::iterator it = list->begin();
while (it != list->end()) {
RsChatMsgItem *c = *it;
if (c->PeerId() == id) {
ChatInfo ci;
initRsChatInfo(c, ci);
chats.push_back(ci);
changed = true;
delete c;
changed = true;
std::list<RsChatMsgItem *>::iterator it1 = it;
it++;
privateList.erase(it1);
list->erase(it1);
continue;
}
@ -521,7 +587,9 @@ bool p3ChatService::getPrivateChatQueue(std::string id, std::list<ChatInfo> &cha
} /* UNLOCKED */
if (changed) {
rsicontrol->getNotify().notifyListChange(NOTIFY_LIST_PRIVATE_CHAT, NOTIFY_TYPE_DEL);
rsicontrol->getNotify().notifyListChange(incoming ? NOTIFY_LIST_PRIVATE_INCOMING_CHAT : NOTIFY_LIST_PRIVATE_OUTGOING_CHAT, NOTIFY_TYPE_DEL);
IndicateConfigChanged();
}
return true;
@ -833,6 +901,10 @@ bool p3ChatService::loadList(std::list<RsItem*> load)
RsStackMutex stack(mChatMtx); /********** STACK LOCKED MTX ******/
_own_avatar = new AvatarInfo(ai->image_data,ai->image_size) ;
delete *it;
continue;
}
RsChatStatusItem *mitem = NULL ;
@ -842,9 +914,38 @@ bool p3ChatService::loadList(std::list<RsItem*> load)
RsStackMutex stack(mChatMtx); /********** STACK LOCKED MTX ******/
_custom_status_string = mitem->status_string ;
delete *it;
continue;
}
RsPrivateChatMsgConfigItem *citem = NULL ;
if(NULL != (citem = dynamic_cast<RsPrivateChatMsgConfigItem *>(*it)))
{
RsStackMutex stack(mChatMtx); /********** STACK LOCKED MTX ******/
if (citem->chatFlags & RS_CHAT_FLAG_PRIVATE) {
RsChatMsgItem *ci = new RsChatMsgItem();
citem->get(ci);
if (citem->configFlags & RS_CHATMSG_CONFIGFLAG_INCOMING) {
privateIncomingList.push_back(ci);
} else {
privateOutgoingList.push_back(ci);
}
} else {
// ignore all other items
}
delete *it;
continue;
}
// delete unknown items
delete *it;
}
return true;
@ -852,7 +953,10 @@ bool p3ChatService::loadList(std::list<RsItem*> load)
std::list<RsItem*> p3ChatService::saveList(bool& cleanup)
{
cleanup = true ;
cleanup = true;
mChatMtx.lock(); /****** MUTEX LOCKED *******/
/* now we create a pqistore, and stream all the msgs into it */
std::list<RsItem*> list ;
@ -871,9 +975,36 @@ std::list<RsItem*> p3ChatService::saveList(bool& cleanup)
list.push_back(di) ;
/* save incoming private chat messages */
std::list<RsChatMsgItem *>::iterator it;
for (it = privateIncomingList.begin(); it != privateIncomingList.end(); it++) {
RsPrivateChatMsgConfigItem *ci = new RsPrivateChatMsgConfigItem;
ci->set(*it, (*it)->PeerId(), RS_CHATMSG_CONFIGFLAG_INCOMING);
list.push_back(ci);
}
/* save outgoing private chat messages */
for (it = privateOutgoingList.begin(); it != privateOutgoingList.end(); it++) {
RsPrivateChatMsgConfigItem *ci = new RsPrivateChatMsgConfigItem;
ci->set(*it, (*it)->PeerId(), 0);
list.push_back(ci);
}
return list;
}
void p3ChatService::saveDone()
{
/* unlock mutex */
mChatMtx.unlock(); /****** MUTEX UNLOCKED *******/
}
RsSerialiser *p3ChatService::setupSerialiser()
{
RsSerialiser *rss = new RsSerialiser ;
@ -882,5 +1013,46 @@ RsSerialiser *p3ChatService::setupSerialiser()
return rss ;
}
/*************** pqiMonitor callback ***********************/
void p3ChatService::statusChange(const std::list<pqipeer> &plist)
{
std::list<pqipeer>::const_iterator it;
for (it = plist.begin(); it != plist.end(); it++) {
if (it->state & RS_PEER_S_FRIEND) {
if (it->actions & RS_PEER_CONNECTED) {
/* send the saved outgoing messages */
bool changed = false;
if (privateOutgoingList.size()) {
RsStackMutex stack(mChatMtx); /********** STACK LOCKED MTX ******/
std::list<RsChatMsgItem *>::iterator cit = privateOutgoingList.begin();
while (cit != privateOutgoingList.end()) {
RsChatMsgItem *c = *cit;
if (c->PeerId() == it->id) {
sendItem(c); // delete item
changed = true;
std::list<RsChatMsgItem *>::iterator cit1 = cit;
cit++;
privateOutgoingList.erase(cit1);
continue;
}
cit++;
}
} /* UNLOCKED */
if (changed) {
rsicontrol->getNotify().notifyListChange(NOTIFY_LIST_PRIVATE_OUTGOING_CHAT, NOTIFY_TYPE_DEL);
IndicateConfigChanged();
}
}
}
}
}

34
libretroshare/src/services/p3chatservice.h
View file

@ -42,12 +42,12 @@
* This service uses rsnotify (callbacks librs clients (e.g. rs-gui))
* @see NotifyBase
*/
class p3ChatService: public p3Service, public p3Config
class p3ChatService: public p3Service, public p3Config, public pqiMonitor
{
public:
p3ChatService(p3ConnectMgr *cm);
/* overloaded */
/***** overloaded from p3Service *****/
/*!
* This retrieves all chat msg items and also (important!)
* processes chat-status items that are in service item queue. chat msg item requests are also processed and not returned
@ -58,16 +58,20 @@ class p3ChatService: public p3Service, public p3Config
virtual int tick();
virtual int status();
/*************** pqiMonitor callback ***********************/
virtual void statusChange(const std::list<pqipeer> &plist);
/*!
* public chat sent to all peers
*/
int sendPublicChat(std::wstring &msg);
/********* RsMsgs ***********/
/*!
* chat is sent to specifc peer
* @param id peer to send chat msg to
*/
int sendPrivateChat(std::string &id, std::wstring &msg);
bool sendPrivateChat(std::string &id, std::wstring &msg);
/*!
* can be used to send 'immediate' status msgs, these status updates are meant for immediate use by peer (not saved by rs)
@ -115,27 +119,37 @@ class p3ChatService: public p3Service, public p3Config
*/
void getOwnAvatarJpegData(unsigned char *& data,int& size) ;
/*!
* returns the count of messages in public or private queue
* returns the count of messages in public queue
* @param public or private queue
*/
int getChatQueueCount(bool privateQueue);
int getPublicChatQueueCount();
/*!
* This retrieves all public chat msg items
*/
bool getPublicChatQueue(std::list<ChatInfo> &chats);
/*!
* returns the count of messages in private queue
* @param public or private queue
*/
int getPrivateChatQueueCount(bool incoming);
/*!
* @param id's of available private chat messages
*/
bool getPrivateChatQueueIds(std::list<std::string> &ids);
bool getPrivateChatQueueIds(bool incoming, std::list<std::string> &ids);
/*!
* This retrieves all private chat msg items for peer
*/
bool getPrivateChatQueue(std::string id, std::list<ChatInfo> &chats);
bool getPrivateChatQueue(bool incoming, const std::string &id, std::list<ChatInfo> &chats);
/*!
* @param clear private chat queue
*/
bool clearPrivateChatQueue(bool incoming, const std::string &id);
/************* from p3Config *******************/
virtual RsSerialiser *setupSerialiser() ;
@ -144,6 +158,7 @@ class p3ChatService: public p3Service, public p3Config
* chat msg items and custom status are saved
*/
virtual std::list<RsItem*> saveList(bool& cleanup) ;
virtual void saveDone();
virtual bool loadList(std::list<RsItem*> load) ;
private:
@ -180,7 +195,8 @@ class p3ChatService: public p3Service, public p3Config
p3ConnectMgr *mConnMgr;
std::list<RsChatMsgItem *> publicList;
std::list<RsChatMsgItem *> privateList;
std::list<RsChatMsgItem *> privateIncomingList;
std::list<RsChatMsgItem *> privateOutgoingList;
AvatarInfo *_own_avatar ;
std::map<std::string,AvatarInfo *> _avatars ;