Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2025-05-14 03:52:39 -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

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.