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

Added "peer is typing" functionality to private chat. This shoudld be extended to additional stuff like "idle", and to public chat. Also the display is the status bar of the chat window could be made nicer, e.g. directly in the msg window. Suppressed ChatDialog class that is not more used

Browse source 
git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@1164 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
csoler 2009-05-05 13:18:53 +00:00
parent ce3db07a63
commit e144e75ba6
18 changed files with 495 additions and 975 deletions
Download patch file Download diff file Expand all files Collapse all files

1
libretroshare/src/rsiface/rsiface.h
View file

@ -200,6 +200,7 @@ class NotifyBase
virtual void notifyListChange(int list, int type) { (void) list; (void) type; return; }
virtual void notifyErrorMsg(int list, int sev, std::string msg) { (void) list; (void) sev; (void) msg; return; }
virtual void notifyChat() { return; }
virtual void notifyChatStatus(const std::string& peer_id,const std::string& status_string) {}
virtual void notifyHashingInfo(std::string fileinfo) { (void)fileinfo; return ; }
virtual void notifyTurtleSearchResult(uint32_t search_id,const std::list<TurtleFileInfo>& files) { (void)files; }
};

1
libretroshare/src/rsiface/rsmsgs.h
View file

@ -131,6 +131,7 @@ virtual bool MessageRead(std::string mid) = 0;
virtual bool chatAvailable() = 0;
virtual bool ChatSend(ChatInfo &ci) = 0;
virtual bool getNewChat(std::list<ChatInfo> &chats) = 0;
virtual void sendStatusString(const std::string& id,const std::string& status_string) = 0 ;
// get avatar data for peer pid
virtual void getAvatarData(std::string pid,unsigned char *& data,int& size) = 0 ;

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

@ -109,6 +109,11 @@ bool p3Msgs::ChatSend(ChatInfo &ci)
return true;
}
void p3Msgs::sendStatusString(const std::string& peer_id,const std::string& status_string)
{
mChatSrv->sendStatusString(peer_id,status_string);
}
bool p3Msgs::chatAvailable()
{
return mChatSrv->receivedItems();
@ -119,13 +124,13 @@ bool p3Msgs::getNewChat(std::list<ChatInfo> &chats)
/* get any messages and push them to iface */
// get the items from the list.
std::list<RsChatItem *> clist = mChatSrv -> getChatQueue();
std::list<RsChatMsgItem *> clist = mChatSrv -> getChatQueue();
if (clist.size() < 1)
{
return false;
}
std::list<RsChatItem *>::iterator it;
std::list<RsChatMsgItem *>::iterator it;
for(it = clist.begin(); it != clist.end(); it++)
{
ChatInfo ci;
@ -142,7 +147,7 @@ bool p3Msgs::getNewChat(std::list<ChatInfo> &chats)
* for intAddChannel / intAddChannelMsg.
*/
void p3Msgs::initRsChatInfo(RsChatItem *c, ChatInfo &i)
void p3Msgs::initRsChatInfo(RsChatMsgItem *c, ChatInfo &i)
{
i.rsid = c -> PeerId();
i.name = mAuthMgr->getName(i.rsid);

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

@ -32,7 +32,7 @@ class p3AuthMgr;
class p3MsgService;
class p3ChatService;
class RsChatItem;
class RsChatMsgItem;
class p3Msgs: public RsMsgs
{
@ -62,13 +62,14 @@ class p3Msgs: public RsMsgs
virtual bool chatAvailable();
virtual bool ChatSend(ChatInfo &ci);
virtual bool getNewChat(std::list<ChatInfo> &chats);
virtual void sendStatusString(const std::string& peer_id,const std::string& status_string) ;
/****************************************/
private:
void initRsChatInfo(RsChatItem *c, ChatInfo &i);
void initRsChatInfo(RsChatMsgItem *c, ChatInfo &i);
p3AuthMgr *mAuthMgr;
p3MsgService *mMsgSrv;

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

@ -24,6 +24,7 @@
*
*/
#include <stdexcept>
#include "serialiser/rsbaseserial.h"
#include "serialiser/rsmsgitems.h"
#include "serialiser/rstlvbase.h"
@ -36,64 +37,118 @@
/*************************************************************************/
RsChatItem::~RsChatItem()
std::ostream& RsChatMsgItem::print(std::ostream &out, uint16_t indent)
{
return;
}
void RsChatItem::clear()
{
chatFlags = 0;
sendTime = 0;
message.clear();
}
std::ostream &RsChatItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsChatItem", indent);
printRsItemBase(out, "RsChatMsgItem", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "QblogMs " << chatFlags << std::endl;
printIndent(out, int_Indent);
out << "QblogMs " << chatFlags << std::endl;
printIndent(out, int_Indent);
out << "sendTime: " << sendTime << std::endl;
printIndent(out, int_Indent);
out << "sendTime: " << sendTime << std::endl;
printIndent(out, int_Indent);
printIndent(out, int_Indent);
std::string cnv_message(message.begin(), message.end());
out << "msg: " << cnv_message << std::endl;
out << "msg: " << cnv_message << std::endl;
printRsItemEnd(out, "RsChatItem", indent);
return out;
printRsItemEnd(out, "RsChatMsgItem", indent);
return out;
}
std::ostream& RsChatStatusItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsChatStatusItem", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "Status string: " << status_string << std::endl;
uint32_t RsChatSerialiser::sizeItem(RsChatItem *item)
printRsItemEnd(out, "RsChatStatusItem", indent);
return out;
}
RsItem *RsChatSerialiser::deserialise(void *data, uint32_t *pktsize)
{
uint32_t rstype = getRsItemId(data);
uint32_t rssize = getRsItemSize(data);
#ifdef CHAT_DEBUG
std::cerr << "deserializing packet..."<< std::endl ;
#endif
// look what we have...
if (*pktsize < rssize) /* check size */
{
#ifdef CHAT_DEBUG
std::cerr << "chat deserialisation: not enough size: pktsize=" << *pktsize << ", rssize=" << rssize << std::endl ;
#endif
return NULL; /* not enough data */
}
/* set the packet length */
*pktsize = rssize;
/* ready to load */
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || (RS_SERVICE_TYPE_CHAT != getRsItemService(rstype)))
{
#ifdef CHAT_DEBUG
std::cerr << "chat deserialisation: wrong type !" << std::endl ;
#endif
return NULL; /* wrong type */
}
try
{
switch(getRsItemSubType(rstype))
{
case RS_PKT_SUBTYPE_DEFAULT: return new RsChatMsgItem(data,*pktsize) ;
case RS_PKT_SUBTYPE_CHAT_STATUS: return new RsChatStatusItem(data,*pktsize) ;
default:
std::cerr << "Unknown packet type in chat!" << std::endl ;
return NULL ;
}
}
catch(std::exception& e)
{
std::cerr << "Exception raised: " << e.what() << std::endl ;
return NULL ;
}
}
uint32_t RsChatMsgItem::serial_size()
{
uint32_t s = 8; /* header */
s += 4; /* chatFlags */
s += 4; /* sendTime */
s += GetTlvWideStringSize(item->message);
s += GetTlvWideStringSize(message);
return s;
}
uint32_t RsChatStatusItem::serial_size()
{
uint32_t s = 8; /* header */
s += GetTlvStringSize(status_string); /* status */
return s;
}
/* serialise the data to the buffer */
bool RsChatSerialiser::serialiseItem(RsChatItem *item, void *data, uint32_t *pktsize)
bool RsChatMsgItem::serialise(void *data, uint32_t& pktsize)
{
uint32_t tlvsize = sizeItem(item);
uint32_t tlvsize = serial_size() ;
uint32_t offset = 0;
if (*pktsize < tlvsize)
if (pktsize < tlvsize)
return false; /* not enough space */
*pktsize = tlvsize;
pktsize = tlvsize;
bool ok = true;
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize);
#ifdef RSSERIAL_DEBUG
#ifdef CHAT_DEBUG
std::cerr << "RsChatSerialiser::serialiseItem() Header: " << ok << std::endl;
std::cerr << "RsChatSerialiser::serialiseItem() Size: " << tlvsize << std::endl;
#endif
@ -102,94 +157,104 @@ bool RsChatSerialiser::serialiseItem(RsChatItem *item, void *data, uint32_t
offset += 8;
/* add mandatory parts first */
ok &= setRawUInt32(data, tlvsize, &offset, item->chatFlags);
ok &= setRawUInt32(data, tlvsize, &offset, item->sendTime);
ok &= SetTlvWideString(data, tlvsize, &offset, TLV_TYPE_WSTR_MSG, item->message);
ok &= setRawUInt32(data, tlvsize, &offset, chatFlags);
ok &= setRawUInt32(data, tlvsize, &offset, sendTime);
ok &= SetTlvWideString(data, tlvsize, &offset, TLV_TYPE_WSTR_MSG, message);
if (offset != tlvsize)
{
ok = false;
#ifdef RSSERIAL_DEBUG
#ifdef CHAT_DEBUG
std::cerr << "RsChatSerialiser::serialiseItem() Size Error! " << std::endl;
#endif
}
#ifdef RSSERIAL_DEBUG
#ifdef CHAT_DEBUG
std::cerr << "computed size: " << 256*((unsigned char*)data)[6]+((unsigned char*)data)[7] << std::endl ;
#endif
return ok;
}
RsChatItem *RsChatSerialiser::deserialiseItem(void *data, uint32_t *pktsize)
bool RsChatStatusItem::serialise(void *data, uint32_t& pktsize)
{
/* get the type and size */
uint32_t rstype = getRsItemId(data);
uint32_t rssize = getRsItemSize(data);
uint32_t tlvsize = serial_size() ;
uint32_t offset = 0;
if (pktsize < tlvsize)
return false; /* not enough space */
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
(RS_SERVICE_TYPE_CHAT != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_DEFAULT != getRsItemSubType(rstype)))
{
return NULL; /* wrong type */
}
if (*pktsize < rssize) /* check size */
return NULL; /* not enough data */
/* set the packet length */
*pktsize = rssize;
pktsize = tlvsize;
bool ok = true;
/* ready to load */
RsChatItem *item = new RsChatItem();
item->clear();
ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize);
#ifdef CHAT_DEBUG
std::cerr << "RsChatSerialiser serialising chat status item." << std::endl;
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_MSG, status_string);
if (offset != tlvsize)
{
ok = false;
#ifdef CHAT_DEBUG
std::cerr << "RsChatSerialiser::serialiseItem() Size Error! " << std::endl;
#endif
}
#ifdef CHAT_DEBUG
std::cerr << "computed size: " << 256*((unsigned char*)data)[6]+((unsigned char*)data)[7] << std::endl ;
#endif
return ok;
}
RsChatMsgItem::RsChatMsgItem(void *data,uint32_t size)
: RsChatItem(RS_PKT_SUBTYPE_DEFAULT)
{
uint32_t offset = 8; // skip the header
uint32_t rssize = getRsItemSize(data);
bool ok = true ;
/* get mandatory parts first */
ok &= getRawUInt32(data, rssize, &offset, &(item->chatFlags));
ok &= getRawUInt32(data, rssize, &offset, &(item->sendTime));
ok &= GetTlvWideString(data, rssize, &offset, TLV_TYPE_WSTR_MSG, item->message);
ok &= getRawUInt32(data, rssize, &offset, &chatFlags);
ok &= getRawUInt32(data, rssize, &offset, &sendTime);
ok &= GetTlvWideString(data, rssize, &offset, TLV_TYPE_WSTR_MSG, message);
#ifdef CHAT_DEBUG
std::cerr << "Building new chat msg item." << std::endl ;
#endif
if (offset != rssize)
throw std::runtime_error("Size error while deserializing.") ;
if (!ok)
throw std::runtime_error("Unknown error while deserializing.") ;
}
RsChatStatusItem::RsChatStatusItem(void *data,uint32_t size)
: RsChatItem(RS_PKT_SUBTYPE_CHAT_STATUS)
{
uint32_t offset = 8; // skip the header
uint32_t rssize = getRsItemSize(data);
bool ok = true ;
#ifdef CHAT_DEBUG
std::cerr << "Building new chat status item." << std::endl ;
#endif
/* get mandatory parts first */
ok &= GetTlvString(data, rssize, &offset,TLV_TYPE_STR_MSG, status_string);
if (offset != rssize)
{
/* error */
delete item;
return NULL;
}
throw std::runtime_error("Size error while deserializing.") ;
if (!ok)
{
delete item;
return NULL;
}
return item;
throw std::runtime_error("Unknown error while deserializing.") ;
}
uint32_t RsChatSerialiser::size(RsItem *item)
{
return sizeItem((RsChatItem *) item);
}
bool RsChatSerialiser::serialise(RsItem *item, void *data, uint32_t *pktsize)
{
return serialiseItem((RsChatItem *) item, data, pktsize);
}
RsItem *RsChatSerialiser::deserialise(void *data, uint32_t *pktsize)
{
return deserialiseItem(data, pktsize);
}
/*************************************************************************/

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

@ -35,51 +35,78 @@
/**************************************************************************/
/* chat Flags */
const uint32_t RS_CHAT_FLAG_PRIVATE = 0x0001;
const uint32_t RS_CHAT_FLAG_REQUESTS_AVATAR = 0x0002;
const uint32_t RS_CHAT_FLAG_CONTAINS_AVATAR = 0x0004;
const uint32_t RS_CHAT_FLAG_PRIVATE = 0x0001;
const uint32_t RS_CHAT_FLAG_REQUESTS_AVATAR = 0x0002;
const uint32_t RS_CHAT_FLAG_CONTAINS_AVATAR = 0x0004;
const uint32_t RS_CHAT_FLAG_AVATAR_AVAILABLE = 0x0008;
const uint8_t RS_PKT_SUBTYPE_CHAT_STATUS = 0x02 ; // default is 0x01
class RsChatItem: public RsItem
{
public:
RsChatItem()
:RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_CHAT,
RS_PKT_SUBTYPE_DEFAULT)
{ return; }
virtual ~RsChatItem();
virtual void clear();
std::ostream &print(std::ostream &out, uint16_t indent = 0);
RsChatItem(uint8_t chat_subtype) : RsItem(RS_PKT_VERSION_SERVICE,RS_SERVICE_TYPE_CHAT,chat_subtype) {}
uint32_t chatFlags;
uint32_t sendTime;
virtual ~RsChatItem() {}
virtual void clear() {}
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0) = 0 ;
std::wstring message;
virtual bool serialise(void *data,uint32_t& size) = 0 ; // Isn't it better that items can serialize themselves ?
virtual uint32_t serial_size() = 0 ; // deserialise is handled using a constructor
};
/* not serialised */
uint32_t recvTime;
class RsChatMsgItem: public RsChatItem
{
public:
RsChatMsgItem() :RsChatItem(RS_PKT_SUBTYPE_DEFAULT) {}
RsChatMsgItem(void *data,uint32_t size) ; // deserialization
virtual ~RsChatMsgItem() {}
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
uint32_t chatFlags;
uint32_t sendTime;
std::wstring message;
/* not serialised */
uint32_t recvTime;
};
// This class contains activity info for the sending peer: active, idle, typing, etc.
//
class RsChatStatusItem: public RsChatItem
{
public:
RsChatStatusItem() :RsChatItem(RS_PKT_SUBTYPE_CHAT_STATUS) {}
RsChatStatusItem(void *data,uint32_t size) ; // deserialization
virtual ~RsChatStatusItem() {}
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
std::string status_string;
};
class RsChatSerialiser: public RsSerialType
{
public:
RsChatSerialiser()
:RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_CHAT)
{ return; }
virtual ~RsChatSerialiser()
{ return; }
virtual uint32_t size(RsItem *);
virtual bool serialise (RsItem *item, void *data, uint32_t *size);
virtual RsItem * deserialise(void *data, uint32_t *size);
private:
virtual uint32_t sizeItem(RsChatItem *);
virtual bool serialiseItem (RsChatItem *item, void *data, uint32_t *size);
virtual RsChatItem *deserialiseItem(void *data, uint32_t *size);
RsChatSerialiser() :RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_CHAT) {}
virtual uint32_t size (RsItem *item)
{
return static_cast<RsChatItem *>(item)->serial_size() ;
}
virtual bool serialise(RsItem *item, void *data, uint32_t *size)
{
return static_cast<RsChatItem *>(item)->serialise(data,*size) ;
}
virtual RsItem *deserialise (void *data, uint32_t *size) ;
};
/**************************************************************************/

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

@ -24,6 +24,7 @@
*/
#include "util/rsdir.h"
#include "rsiface/rsiface.h"
#include "pqi/pqibin.h"
#include "pqi/pqinotify.h"
#include "pqi/pqiarchive.h"
@ -90,7 +91,7 @@ int p3ChatService::sendChat(std::wstring msg)
for(it = ids.begin(); it != ids.end(); it++)
{
RsChatItem *ci = new RsChatItem();
RsChatMsgItem *ci = new RsChatMsgItem();
ci->PeerId(*it);
ci->chatFlags = 0;
@ -170,7 +171,21 @@ class p3ChatService::AvatarInfo
};
int p3ChatService::sendPrivateChat(std::wstring msg, std::string id)
void p3ChatService::sendStatusString( const std::string& id , const std::string& status_string)
{
RsChatStatusItem *cs = new RsChatStatusItem ;
cs->status_string = status_string ;
cs->PeerId(id);
#ifdef CHAT_DEBUG
std::cerr << "sending chat status packet:" << std::endl ;
cs->print(std::cerr) ;
#endif
sendItem(cs);
}
int p3ChatService::sendPrivateChat( std::wstring msg, std::string id)
{
// make chat item....
#ifdef CHAT_DEBUG
@ -178,7 +193,7 @@ int p3ChatService::sendPrivateChat(std::wstring msg, std::string id)
std::cerr << std::endl;
#endif
RsChatItem *ci = new RsChatItem();
RsChatMsgItem *ci = new RsChatMsgItem();
ci->PeerId(id);
ci->chatFlags = RS_CHAT_FLAG_PRIVATE;
@ -215,50 +230,70 @@ int p3ChatService::sendPrivateChat(std::wstring msg, std::string id)
return 1;
}
std::list<RsChatItem *> p3ChatService::getChatQueue()
std::list<RsChatMsgItem *> p3ChatService::getChatQueue()
{
time_t now = time(NULL);
RsChatItem *ci = NULL;
std::list<RsChatItem *> ilist;
RsItem *item ;
std::list<RsChatMsgItem *> ilist;
while(NULL != (ci = (RsChatItem *) recvItem()))
while(NULL != (item=recvItem()))
{
#ifdef CHAT_DEBUG
std::cerr << "p3ChatService::getChatQueue() Item:";
std::cerr << std::endl;
ci->print(std::cerr);
std::cerr << std::endl;
std::cerr << "Got msg. Flags = " << ci->chatFlags << std::endl ;
std::cerr << "p3ChatService::getChatQueue() Item:" << (void*)item << std::endl ;
#endif
RsChatMsgItem *ci = dynamic_cast<RsChatMsgItem*>(item) ;
if(ci != NULL)
{
#ifdef CHAT_DEBUG
std::cerr << "p3ChatService::getChatQueue() Item:";
std::cerr << std::endl;
ci->print(std::cerr);
std::cerr << std::endl;
std::cerr << "Got msg. Flags = " << ci->chatFlags << std::endl ;
#endif
if(ci->chatFlags & RS_CHAT_FLAG_CONTAINS_AVATAR) // no msg here. Just an avatar.
receiveAvatarJpegData(ci) ;
else if(ci->chatFlags & RS_CHAT_FLAG_REQUESTS_AVATAR) // no msg here. Just an avatar request.
sendAvatarJpegData(ci->PeerId()) ;
else // normal msg. Return it normally.
{
// Check if new avatar is available at peer's. If so, send a request to get the avatar.
if(ci->chatFlags & RS_CHAT_FLAG_AVATAR_AVAILABLE)
{
std::cerr << "New avatar is available for peer " << ci->PeerId() << ", sending request" << std::endl ;
sendAvatarRequest(ci->PeerId()) ;
ci->chatFlags &= ~RS_CHAT_FLAG_AVATAR_AVAILABLE ;
}
std::map<std::string,AvatarInfo *>::const_iterator it = _avatars.find(ci->PeerId()) ;
std::cerr << "p3chatservice:: avatar requested from above. " << std::endl ;
// has avatar. Return it strait away.
//
if(it!=_avatars.end() && it->second->_peer_is_new)
if(ci->chatFlags & RS_CHAT_FLAG_CONTAINS_AVATAR) // no msg here. Just an avatar.
receiveAvatarJpegData(ci) ;
else if(ci->chatFlags & RS_CHAT_FLAG_REQUESTS_AVATAR) // no msg here. Just an avatar request.
sendAvatarJpegData(ci->PeerId()) ;
else // normal msg. Return it normally.
{
std::cerr << "Adatar is new for peer. ending info above" << std::endl ;
ci->chatFlags |= RS_CHAT_FLAG_AVATAR_AVAILABLE ;
}
// Check if new avatar is available at peer's. If so, send a request to get the avatar.
if(ci->chatFlags & RS_CHAT_FLAG_AVATAR_AVAILABLE)
{
std::cerr << "New avatar is available for peer " << ci->PeerId() << ", sending request" << std::endl ;
sendAvatarRequest(ci->PeerId()) ;
ci->chatFlags &= ~RS_CHAT_FLAG_AVATAR_AVAILABLE ;
}
ci->recvTime = now;
ilist.push_back(ci);
std::map<std::string,AvatarInfo *>::const_iterator it = _avatars.find(ci->PeerId()) ;
std::cerr << "p3chatservice:: avatar requested from above. " << std::endl ;
// has avatar. Return it strait away.
//
if(it!=_avatars.end() && it->second->_peer_is_new)
{
std::cerr << "Adatar is new for peer. ending info above" << std::endl ;
ci->chatFlags |= RS_CHAT_FLAG_AVATAR_AVAILABLE ;
}
ci->recvTime = now;
ilist.push_back(ci);
}
}
RsChatStatusItem *cs = dynamic_cast<RsChatStatusItem*>(item) ;
if(cs != NULL)
{
// we should notify for a status string for the current peer.
#ifdef CHAT_DEBUG
std::cerr << "Received status string \"" << cs->status_string << "\"" << std::endl ;
#endif
rsicontrol->getNotify().notifyChatStatus(cs->PeerId(),cs->status_string) ;
delete item ;
}
}
@ -284,7 +319,7 @@ void p3ChatService::setOwnAvatarJpegData(const unsigned char *data,int size)
IndicateConfigChanged();
}
void p3ChatService::receiveAvatarJpegData(RsChatItem *ci)
void p3ChatService::receiveAvatarJpegData(RsChatMsgItem *ci)
{
RsStackMutex stack(mChatMtx); /********** STACK LOCKED MTX ******/
std::cerr << "p3chatservice: received avatar jpeg data for peer " << ci->PeerId() << ". Storing it." << std::endl ;
@ -339,7 +374,7 @@ void p3ChatService::sendAvatarRequest(const std::string& peer_id)
{
// Doesn't have avatar. Request it.
//
RsChatItem *ci = new RsChatItem();
RsChatMsgItem *ci = new RsChatMsgItem();
ci->PeerId(peer_id);
ci->chatFlags = RS_CHAT_FLAG_PRIVATE | RS_CHAT_FLAG_REQUESTS_AVATAR ;
@ -352,10 +387,10 @@ void p3ChatService::sendAvatarRequest(const std::string& peer_id)
sendItem(ci);
}
RsChatItem *p3ChatService::makeOwnAvatarItem()
RsChatMsgItem *p3ChatService::makeOwnAvatarItem()
{
RsStackMutex stack(mChatMtx); /********** STACK LOCKED MTX ******/
RsChatItem *ci = new RsChatItem();
RsChatMsgItem *ci = new RsChatMsgItem();
ci->chatFlags = RS_CHAT_FLAG_PRIVATE | RS_CHAT_FLAG_CONTAINS_AVATAR ;
ci->sendTime = time(NULL);
@ -371,7 +406,7 @@ void p3ChatService::sendAvatarJpegData(const std::string& peer_id)
if(_own_avatar != NULL)
{
RsChatItem *ci = makeOwnAvatarItem();
RsChatMsgItem *ci = makeOwnAvatarItem();
ci->PeerId(peer_id);
// take avatar, and embed it into a std::wstring.
@ -396,11 +431,11 @@ bool p3ChatService::loadConfiguration(std::string &loadHash)
BinFileInterface *in = new BinFileInterface(msgfile.c_str(), BIN_FLAGS_READABLE | BIN_FLAGS_HASH_DATA);
pqiarchive *pa_in = new pqiarchive(rss, in, BIN_FLAGS_READABLE);
RsItem *item;
RsChatItem *mitem;
RsChatMsgItem *mitem;
while((item = pa_in -> GetItem()))
{
if(NULL != (mitem = dynamic_cast<RsChatItem *>(item)))
if(NULL != (mitem = dynamic_cast<RsChatMsgItem *>(item)))
{
RsStackMutex stack(mChatMtx); /********** STACK LOCKED MTX ******/
@ -451,7 +486,7 @@ bool p3ChatService::saveConfiguration()
if(_own_avatar != NULL)
{
std::cerr << "Saving avatar config to file " << msgfile << std::endl ;
RsChatItem *ci = makeOwnAvatarItem() ;
RsChatMsgItem *ci = makeOwnAvatarItem() ;
ci->PeerId(mConnMgr->getOwnId());
if(!pa_out -> SendItem(ci))

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

@ -50,6 +50,7 @@ class p3ChatService: public p3Service, public pqiConfig
int sendChat(std::wstring msg);
int sendPrivateChat(std::wstring msg, std::string id);
void sendStatusString(const std::string& peer_id,const std::string& status_str) ;
/// gets the peer's avatar in jpeg format, if available. Null otherwise. Also asks the peer to send
/// its avatar, if not already available. Creates a new unsigned char array. It's the caller's
@ -61,7 +62,7 @@ class p3ChatService: public p3Service, public pqiConfig
void setOwnAvatarJpegData(const unsigned char *data,int size) ;
void getOwnAvatarJpegData(unsigned char *& data,int& size) ;
std::list<RsChatItem *> getChatQueue();
std::list<RsChatMsgItem *> getChatQueue();
/*** Overloaded from pqiConfig ****/
virtual bool loadConfiguration(std::string &loadHash);
@ -76,12 +77,12 @@ class p3ChatService: public p3Service, public pqiConfig
void sendAvatarJpegData(const std::string& peer_id) ;
/// Receive the avatar in a chat item, with RS_CHAT_RECEIVE_AVATAR flag.
void receiveAvatarJpegData(RsChatItem *ci) ;
void receiveAvatarJpegData(RsChatMsgItem *ci) ;
/// Sends a request for an avatar to the peer of given id
void sendAvatarRequest(const std::string& peer_id) ;
RsChatItem *makeOwnAvatarItem() ;
RsChatMsgItem *makeOwnAvatarItem() ;
p3ConnectMgr *mConnMgr;