From bcb704366cb5e333a626c18c308c7e0448a8e69f Mon Sep 17 00:00:00 2001 From: toma Date: Wed, 25 Nov 2009 17:56:58 +0000 Subject: Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features. BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdenetwork@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- kopete/protocols/jabber/jabbercontact.cpp | 1328 +++++++++++++++++++++++++++++ 1 file changed, 1328 insertions(+) create mode 100644 kopete/protocols/jabber/jabbercontact.cpp (limited to 'kopete/protocols/jabber/jabbercontact.cpp') diff --git a/kopete/protocols/jabber/jabbercontact.cpp b/kopete/protocols/jabber/jabbercontact.cpp new file mode 100644 index 00000000..c8589e1e --- /dev/null +++ b/kopete/protocols/jabber/jabbercontact.cpp @@ -0,0 +1,1328 @@ + /* + * jabbercontact.cpp - Regular Kopete Jabber protocol contact + * + * Copyright (c) 2002-2004 by Till Gerken + * Copyright (c) 2006 by Olivier Goffart + * + * Kopete (c) by the Kopete developers + * + * ************************************************************************* + * * * + * * This program is free software; you can redistribute it and/or modify * + * * it under the terms of the GNU General Public License as published by * + * * the Free Software Foundation; either version 2 of the License, or * + * * (at your option) any later version. * + * * * + * ************************************************************************* + */ + +#include "jabbercontact.h" + +#include "xmpp_tasks.h" +#include "im.h" + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "kopetecontactlist.h" +#include "kopetegroup.h" +#include "kopeteuiglobal.h" +#include "kopetechatsessionmanager.h" +#include "kopeteaccountmanager.h" +#include "jabberprotocol.h" +#include "jabberaccount.h" +#include "jabberclient.h" +#include "jabberchatsession.h" +#include "jabberresource.h" +#include "jabberresourcepool.h" +#include "jabberfiletransfer.h" +#include "jabbertransport.h" +#include "dlgjabbervcard.h" + +#ifdef SUPPORT_JINGLE +// #include "jinglesessionmanager.h" +// #include "jinglevoicesession.h" +#include "jinglevoicesessiondialog.h" +#endif + +/** + * JabberContact constructor + */ +JabberContact::JabberContact (const XMPP::RosterItem &rosterItem, Kopete::Account *_account, Kopete::MetaContact * mc, const QString &legacyId) + : JabberBaseContact ( rosterItem, _account, mc, legacyId) , mDiscoDone(false), m_syncTimer(0L) +{ + kdDebug(JABBER_DEBUG_GLOBAL) << k_funcinfo << contactId() << " is created - " << this << endl; + // this contact is able to transfer files + setFileCapable ( true ); + + /* + * Catch when we're going online for the first time to + * update our properties from a vCard. (properties are + * not available during startup, so we need to read + * them later - this also serves as a random update + * feature) + * Note: The only time account->myself() could be a + * NULL pointer is if this contact here is the myself() + * instance itself. Since in that case we wouldn't + * get updates at all, we need to treat that as a + * special case. + */ + + mVCardUpdateInProgress = false; + + if ( !account()->myself () ) + { + // this contact is a regular contact + connect ( this, + SIGNAL ( onlineStatusChanged ( Kopete::Contact *, const Kopete::OnlineStatus &, const Kopete::OnlineStatus & ) ), + this, SLOT ( slotCheckVCard () ) ); + } + else + { + // this contact is the myself instance + connect ( account()->myself (), + SIGNAL ( onlineStatusChanged ( Kopete::Contact *, const Kopete::OnlineStatus &, const Kopete::OnlineStatus & ) ), + this, SLOT ( slotCheckVCard () ) ); + + connect ( account()->myself (), + SIGNAL ( onlineStatusChanged ( Kopete::Contact *, const Kopete::OnlineStatus &, const Kopete::OnlineStatus & ) ), + this, SLOT ( slotCheckLastActivity ( Kopete::Contact *, const Kopete::OnlineStatus &, const Kopete::OnlineStatus & ) ) ); + + /* + * Trigger update once if we're already connected for contacts + * that are being added while we are online. + */ + if ( account()->myself()->onlineStatus().isDefinitelyOnline() ) + { + slotGetTimedVCard (); + } + } + + mRequestOfflineEvent = false; + mRequestDisplayedEvent = false; + mRequestDeliveredEvent = false; + mRequestComposingEvent = false; + mRequestGoneEvent = false; +} + + + +JabberContact::~JabberContact() +{ + kdDebug(JABBER_DEBUG_GLOBAL) << k_funcinfo << contactId() << " is destroyed - " << this << endl; +} + +QPtrList *JabberContact::customContextMenuActions () +{ + + QPtrList *actionCollection = new QPtrList(); + + KActionMenu *actionAuthorization = new KActionMenu ( i18n ("Authorization"), "connect_established", this, "jabber_authorization"); + + KAction *resendAuthAction, *requestAuthAction, *removeAuthAction; + + resendAuthAction = new KAction (i18n ("(Re)send Authorization To"), "mail_forward", 0, + this, SLOT (slotSendAuth ()), actionAuthorization, "actionSendAuth"); + resendAuthAction->setEnabled( mRosterItem.subscription().type() == XMPP::Subscription::To || mRosterItem.subscription().type() == XMPP::Subscription::None ); + actionAuthorization->insert(resendAuthAction); + + requestAuthAction = new KAction (i18n ("(Re)request Authorization From"), "mail_reply", 0, + this, SLOT (slotRequestAuth ()), actionAuthorization, "actionRequestAuth"); + requestAuthAction->setEnabled( mRosterItem.subscription().type() == XMPP::Subscription::From || mRosterItem.subscription().type() == XMPP::Subscription::None ); + actionAuthorization->insert(requestAuthAction); + + removeAuthAction = new KAction (i18n ("Remove Authorization From"), "mail_delete", 0, + this, SLOT (slotRemoveAuth ()), actionAuthorization, "actionRemoveAuth"); + removeAuthAction->setEnabled( mRosterItem.subscription().type() == XMPP::Subscription::Both || mRosterItem.subscription().type() == XMPP::Subscription::From ); + actionAuthorization->insert(removeAuthAction); + + KActionMenu *actionSetAvailability = new KActionMenu (i18n ("Set Availability"), "kopeteavailable", this, "jabber_online"); + + actionSetAvailability->insert(new KAction (i18n ("Online"), protocol()->JabberKOSOnline.iconFor(this), + 0, this, SLOT (slotStatusOnline ()), actionSetAvailability, "actionOnline")); + actionSetAvailability->insert(new KAction (i18n ("Free to Chat"), protocol()->JabberKOSChatty.iconFor(this), + 0, this, SLOT (slotStatusChatty ()), actionSetAvailability, "actionChatty")); + actionSetAvailability->insert(new KAction (i18n ("Away"), protocol()->JabberKOSAway.iconFor(this), + 0, this, SLOT (slotStatusAway ()), actionSetAvailability, "actionAway")); + actionSetAvailability->insert(new KAction (i18n ("Extended Away"), protocol()->JabberKOSXA.iconFor(this), + 0, this, SLOT (slotStatusXA ()), actionSetAvailability, "actionXA")); + actionSetAvailability->insert(new KAction (i18n ("Do Not Disturb"), protocol()->JabberKOSDND.iconFor(this), + 0, this, SLOT (slotStatusDND ()), actionSetAvailability, "actionDND")); + actionSetAvailability->insert(new KAction (i18n ("Invisible"), protocol()->JabberKOSInvisible.iconFor(this), + 0, this, SLOT (slotStatusInvisible ()), actionSetAvailability, "actionInvisible")); + + KActionMenu *actionSelectResource = new KActionMenu (i18n ("Select Resource"), "connect_no", this, "actionSelectResource"); + + // if the contact is online, display the resources we have for it, + // otherwise disable the menu + if (onlineStatus ().status () == Kopete::OnlineStatus::Offline) + { + actionSelectResource->setEnabled ( false ); + } + else + { + QStringList items; + XMPP::ResourceList availableResources; + + int activeItem = 0, i = 1; + const XMPP::Resource lockedResource = account()->resourcePool()->lockedResource ( mRosterItem.jid () ); + + // put default resource first + items.append (i18n ("Automatic (best/default resource)")); + + account()->resourcePool()->findResources ( mRosterItem.jid (), availableResources ); + + XMPP::ResourceList::const_iterator resourcesEnd = availableResources.end (); + for ( XMPP::ResourceList::const_iterator it = availableResources.begin(); it != resourcesEnd; ++it, i++) + { + items.append ( (*it).name() ); + + if ( (*it).name() == lockedResource.name() ) + activeItem = i; + } + + // now go through the string list and add the resources with their icons + i = 0; + QStringList::const_iterator itemsEnd = items.end (); + for(QStringList::const_iterator it = items.begin(); it != itemsEnd; ++it) + { + if( i == activeItem ) + { + actionSelectResource->insert ( new KAction( ( *it ), "button_ok", 0, this, SLOT( slotSelectResource() ), + actionSelectResource, QString::number( i ).latin1() ) ); + } + else + { + /* + * Select icon, using bestResource() without lock for the automatic entry + * and the resources' respective status icons for the rest. + */ + QIconSet iconSet ( !i ? + protocol()->resourceToKOS ( account()->resourcePool()->bestResource ( mRosterItem.jid(), false ) ).iconFor ( account () ) : protocol()->resourceToKOS ( *availableResources.find(*it) ).iconFor ( account () )); + + actionSelectResource->insert ( new KAction( ( *it ), iconSet, 0, this, SLOT( slotSelectResource() ), + actionSelectResource, QString::number( i ).latin1() ) ); + } + + i++; + } + + } + + actionCollection->append( actionAuthorization ); + actionCollection->append( actionSetAvailability ); + actionCollection->append( actionSelectResource ); + + +#ifdef SUPPORT_JINGLE + KAction *actionVoiceCall = new KAction (i18n ("Voice call"), "voicecall", 0, this, SLOT (voiceCall ()), this, "jabber_voicecall"); + actionVoiceCall->setEnabled( false ); + + actionCollection->append( actionVoiceCall ); + + // Check if the current contact support Voice calls, also honour lock by default. + JabberResource *bestResource = account()->resourcePool()->bestJabberResource( mRosterItem.jid() ); + if( bestResource && bestResource->features().canVoice() ) + { + actionVoiceCall->setEnabled( true ); + } +#endif + + return actionCollection; +} + +void JabberContact::handleIncomingMessage (const XMPP::Message & message) +{ + QString viewPlugin; + Kopete::Message *newMessage = 0L; + + kdDebug (JABBER_DEBUG_GLOBAL) << k_funcinfo << "Received Message Type:" << message.type () << endl; + + // fetch message manager + JabberChatSession *mManager = manager ( message.from().resource (), Kopete::Contact::CanCreate ); + + // evaluate notifications + if ( message.type () != "error" ) + { + if (!message.invite().isEmpty()) + { + QString room=message.invite(); + QString originalBody=message.body().isEmpty() ? QString() : + i18n( "The original message is : \" %1 \"
" ).arg(QStyleSheet::escape(message.body())); + QString mes=i18n("%1 invited you to join the conference %2
%3
" + "If you want to accept and join, just enter your nickname and press ok
" + "If you want to decline, press cancel") + .arg(message.from().full(), room , originalBody); + + bool ok=false; + QString futureNewNickName = KInputDialog::getText( i18n( "Invited to a conference - Jabber Plugin" ), + mes, QString() , &ok , (mManager ? dynamic_cast(mManager->view(false)) : 0) ); + if ( !ok || !account()->isConnected() || futureNewNickName.isEmpty() ) + return; + + XMPP::Jid roomjid(room); + account()->client()->joinGroupChat( roomjid.host() , roomjid.user() , futureNewNickName ); + return; + } + else if (message.body().isEmpty()) + // Then here could be event notifications + { + if (message.containsEvent ( XMPP::CancelEvent ) ) + mManager->receivedTypingMsg ( this, false ); + else if (message.containsEvent ( XMPP::ComposingEvent ) ) + mManager->receivedTypingMsg ( this, true ); + else if (message.containsEvent ( XMPP::DisplayedEvent ) ) + mManager->receivedEventNotification ( i18n("Message has been displayed") ); + else if (message.containsEvent ( XMPP::DeliveredEvent ) ) + mManager->receivedEventNotification ( i18n("Message has been delivered") ); + else if (message.containsEvent ( XMPP::OfflineEvent ) ) + { + mManager->receivedEventNotification( i18n("Message stored on the server, contact offline") ); + } + else if (message.containsEvent ( XMPP::GoneEvent ) ) + { + if(mManager->view( Kopete::Contact::CannotCreate )) + { //show an internal message if the user has not already closed his window + Kopete::Message m=Kopete::Message ( this, mManager->members(), + i18n("%1 has ended their participation in the chat session.").arg(metaContact()->displayName()), + Kopete::Message::Internal ); + m.setImportance(Kopete::Message::Low); + mManager->view()->appendMessage ( m ); //use KopeteView::AppendMessage to bypass notifications + } + } + } + else + // Then here could be event notification requests + { + mRequestComposingEvent = message.containsEvent ( XMPP::ComposingEvent ); + mRequestOfflineEvent = message.containsEvent ( XMPP::OfflineEvent ); + mRequestDeliveredEvent = message.containsEvent ( XMPP::DeliveredEvent ); + mRequestDisplayedEvent = message.containsEvent ( XMPP::DisplayedEvent); + mRequestGoneEvent= message.containsEvent ( XMPP::GoneEvent); + } + } + + /** + * Don't display empty messages, these were most likely just carrying + * event notifications or other payload. + */ + if ( message.body().isEmpty () && message.urlList().isEmpty () && message.xHTMLBody().isEmpty() && !message.xencrypted() ) + return; + + // determine message type + if (message.type () == "chat") + viewPlugin = "kopete_chatwindow"; + else + viewPlugin = "kopete_emailwindow"; + + Kopete::ContactPtrList contactList; + contactList.append ( account()->myself () ); + + // check for errors + if ( message.type () == "error" ) + { + newMessage = new Kopete::Message( message.timeStamp (), this, contactList, + i18n("Your message could not be delivered: \"%1\", Reason: \"%2\""). + arg ( message.body () ).arg ( message.error().text ), + message.subject(), Kopete::Message::Inbound, Kopete::Message::PlainText, viewPlugin ); + } + else + { + // store message id for outgoing notifications + mLastReceivedMessageId = message.id (); + + // retrieve and reformat body + QString body = message.body (); + QString xHTMLBody; + if( !message.xencrypted().isEmpty () ) + { + body = QString ("-----BEGIN PGP MESSAGE-----\n\n") + message.xencrypted () + QString ("\n-----END PGP MESSAGE-----\n"); + } + else + { + xHTMLBody = message.xHTMLBody (); + } + + // convert XMPP::Message into Kopete::Message + if (!xHTMLBody.isEmpty()) { + kdDebug ( JABBER_DEBUG_GLOBAL ) << k_funcinfo << "Received a xHTML message" << endl; + newMessage = new Kopete::Message ( message.timeStamp (), this, contactList, xHTMLBody, + message.subject (), Kopete::Message::Inbound, + Kopete::Message::RichText, viewPlugin ); + } + else if ( !body.isEmpty () ) + { + kdDebug ( JABBER_DEBUG_GLOBAL ) << k_funcinfo << "Received a plain text message" << endl; + newMessage = new Kopete::Message ( message.timeStamp (), this, contactList, body, + message.subject (), Kopete::Message::Inbound, + Kopete::Message::PlainText, viewPlugin ); + } + } + + // append message to (eventually new) manager and preselect the originating resource + if ( newMessage ) + { + mManager->appendMessage ( *newMessage, message.from().resource () ); + + delete newMessage; + } + + // append URLs as separate messages + if ( !message.urlList().isEmpty () ) + { + /* + * We need to copy it here because Iris returns a copy + * and we can't work with a returned copy in a for() loop. + */ + XMPP::UrlList urlList = message.urlList(); + + for ( XMPP::UrlList::const_iterator it = urlList.begin (); it != urlList.end (); ++it ) + { + QString description = (*it).desc().isEmpty() ? (*it).url() : QStyleSheet::escape ( (*it).desc() ); + QString url = (*it).url (); + + newMessage = new Kopete::Message ( message.timeStamp (), this, contactList, + QString ( "%2" ).arg ( url, description ), + message.subject (), Kopete::Message::Inbound, + Kopete::Message::RichText, viewPlugin ); + + mManager->appendMessage ( *newMessage, message.from().resource () ); + + delete newMessage; + } + } + +} + +void JabberContact::slotCheckVCard () +{ + QDateTime cacheDate; + Kopete::ContactProperty cacheDateString = property ( protocol()->propVCardCacheTimeStamp ); + + // don't do anything while we are offline + if ( !account()->myself()->onlineStatus().isDefinitelyOnline () ) + { + return; + } + + if(!mDiscoDone) + { + if(transport()) //no need to disco if this is a legacy contact + mDiscoDone = true; + else if(!rosterItem().jid().node().isEmpty()) + mDiscoDone = true; //contact with an @ are not transport for sure + else + { + mDiscoDone = true; //or it will happen twice, we don't want that. + //disco to see if it's not a transport + XMPP::JT_DiscoInfo *jt = new XMPP::JT_DiscoInfo(account()->client()->rootTask()); + QObject::connect(jt, SIGNAL(finished()),this, SLOT(slotDiscoFinished())); + jt->get(rosterItem().jid(), QString()); + jt->go(true); + } + } + + + // avoid warning if key does not exist in configuration file + if ( cacheDateString.isNull () ) + cacheDate = QDateTime::currentDateTime().addDays ( -2 ); + else + cacheDate = QDateTime::fromString ( cacheDateString.value().toString (), Qt::ISODate ); + + kdDebug ( JABBER_DEBUG_GLOBAL ) << k_funcinfo << "Cached vCard data for " << contactId () << " from " << cacheDate.toString () << endl; + + if ( !mVCardUpdateInProgress && ( cacheDate.addDays ( 1 ) < QDateTime::currentDateTime () ) ) + { + kdDebug ( JABBER_DEBUG_GLOBAL ) << k_funcinfo << "Scheduling update." << endl; + + mVCardUpdateInProgress = true; + + // current data is older than 24 hours, request a new one + QTimer::singleShot ( account()->client()->getPenaltyTime () * 1000, this, SLOT ( slotGetTimedVCard () ) ); + } + +} + +void JabberContact::slotGetTimedVCard () +{ + mVCardUpdateInProgress = false; + + // check if we are still connected - eventually we lost our connection in the meantime + if ( !account()->myself()->onlineStatus().isDefinitelyOnline () ) + { + // we are not connected, discard this update + return; + } + + if(!mDiscoDone) + { + if(transport()) //no need to disco if this is a legacy contact + mDiscoDone = true; + else if(!rosterItem().jid().node().isEmpty()) + mDiscoDone = true; //contact with an @ are not transport for sure + else + { + //disco to see if it's not a transport + XMPP::JT_DiscoInfo *jt = new XMPP::JT_DiscoInfo(account()->client()->rootTask()); + QObject::connect(jt, SIGNAL(finished()),this, SLOT(slotDiscoFinished())); + jt->get(rosterItem().jid(), QString()); + jt->go(true); + } + } + + kdDebug ( JABBER_DEBUG_GLOBAL ) << k_funcinfo << "Requesting vCard for " << contactId () << " from update timer." << endl; + + mVCardUpdateInProgress = true; + + // request vCard + XMPP::JT_VCard *task = new XMPP::JT_VCard ( account()->client()->rootTask () ); + // signal to ourselves when the vCard data arrived + QObject::connect ( task, SIGNAL ( finished () ), this, SLOT ( slotGotVCard () ) ); + task->get ( mRosterItem.jid () ); + task->go ( true ); + +} + +void JabberContact::slotGotVCard () +{ + + XMPP::JT_VCard * vCard = (XMPP::JT_VCard *) sender (); + + // update timestamp of last vCard retrieval + if ( metaContact() && !metaContact()->isTemporary () ) + { + setProperty ( protocol()->propVCardCacheTimeStamp, QDateTime::currentDateTime().toString ( Qt::ISODate ) ); + } + + mVCardUpdateInProgress = false; + + if ( !vCard->success() ) + { + /* + * A vCard for the user does not exist or the + * request was unsuccessful or incomplete. + * The timestamp was already updated when + * requesting the vCard, so it's safe to + * just do nothing here. + */ + return; + } + + setPropertiesFromVCard ( vCard->vcard () ); + +} + +void JabberContact::slotCheckLastActivity ( Kopete::Contact *, const Kopete::OnlineStatus &newStatus, const Kopete::OnlineStatus &oldStatus ) +{ + + /* + * Checking the last activity only makes sense if a contact is offline. + * So, this check should only be done in the following cases: + * - Kopete goes online for the first time and this contact is offline, or + * - Kopete is already online and this contact went offline. + * + * Since Kopete already takes care of maintaining the lastSeen property + * if the contact changes its state while we are online, we don't need + * to query its activity after we are already connected. + */ + + if ( onlineStatus().isDefinitelyOnline () ) + { + // Kopete already deals with lastSeen if the contact is online + return; + } + + if ( ( oldStatus.status () == Kopete::OnlineStatus::Connecting ) && newStatus.isDefinitelyOnline () ) + { + kdDebug ( JABBER_DEBUG_GLOBAL ) << k_funcinfo << "Scheduling request for last activity for " << mRosterItem.jid().bare () << endl; + + QTimer::singleShot ( account()->client()->getPenaltyTime () * 1000, this, SLOT ( slotGetTimedLastActivity () ) ); + } + +} + +void JabberContact::slotGetTimedLastActivity () +{ + /* + * We have been called from @ref slotCheckLastActivity. + * We could have lost our connection in the meantime, + * so make sure we are online. Additionally, the contact + * itself could have gone online, so make sure it is + * still offline. (otherwise the last seen property is + * maintained by Kopete) + */ + + if ( onlineStatus().isDefinitelyOnline () ) + { + // Kopete already deals with setting lastSeen if the contact is online + return; + } + + if ( account()->myself()->onlineStatus().isDefinitelyOnline () ) + { + kdDebug ( JABBER_DEBUG_GLOBAL ) << k_funcinfo << "Requesting last activity from timer for " << mRosterItem.jid().bare () << endl; + + XMPP::JT_GetLastActivity *task = new XMPP::JT_GetLastActivity ( account()->client()->rootTask () ); + QObject::connect ( task, SIGNAL ( finished () ), this, SLOT ( slotGotLastActivity () ) ); + task->get ( mRosterItem.jid () ); + task->go ( true ); + } + +} + +void JabberContact::slotGotLastActivity () +{ + XMPP::JT_GetLastActivity *task = (XMPP::JT_GetLastActivity *) sender (); + + if ( task->success () ) + { + setProperty ( protocol()->propLastSeen, QDateTime::currentDateTime().addSecs ( -task->seconds () ) ); + if( !task->message().isEmpty() ) + { + setProperty( protocol()->propAwayMessage, task->message() ); + } + } + +} + +void JabberContact::slotSendVCard() +{ + XMPP::VCard vCard; + XMPP::VCard::AddressList addressList; + XMPP::VCard::EmailList emailList; + XMPP::VCard::PhoneList phoneList; + + if ( !account()->isConnected () ) + { + account()->errorConnectFirst (); + return; + } + + // General information + vCard.setNickName (property(protocol()->propNickName).value().toString()); + vCard.setFullName (property(protocol()->propFullName).value().toString()); + vCard.setJid (property(protocol()->propJid).value().toString()); + vCard.setBdayStr (property(protocol()->propBirthday).value().toString()); + vCard.setTimezone (property(protocol()->propTimezone).value().toString()); + vCard.setUrl (property(protocol()->propHomepage).value().toString()); + + // home address tab + XMPP::VCard::Address homeAddress; + + homeAddress.home = true; + homeAddress.street = property(protocol()->propHomeStreet).value().toString(); + homeAddress.extaddr = property(protocol()->propHomeExtAddr).value().toString(); + homeAddress.pobox = property(protocol()->propHomePOBox).value().toString(); + homeAddress.locality = property(protocol()->propHomeCity).value().toString(); + homeAddress.pcode = property(protocol()->propHomePostalCode).value().toString(); + homeAddress.country = property(protocol()->propHomeCountry).value().toString(); + + // work address tab + XMPP::VCard::Address workAddress; + + workAddress.work = true; + workAddress.street = property(protocol()->propWorkStreet).value().toString(); + workAddress.extaddr = property(protocol()->propWorkExtAddr).value().toString(); + workAddress.pobox = property(protocol()->propWorkPOBox).value().toString(); + workAddress.locality = property(protocol()->propWorkCity).value().toString(); + workAddress.pcode = property(protocol()->propWorkPostalCode).value().toString(); + workAddress.country = property(protocol()->propWorkCountry).value().toString(); + + addressList.append(homeAddress); + addressList.append(workAddress); + + vCard.setAddressList(addressList); + + // home email + XMPP::VCard::Email homeEmail; + + homeEmail.home = true; + homeEmail.userid = property(protocol()->propEmailAddress).value().toString(); + + // work email + XMPP::VCard::Email workEmail; + + workEmail.work = true; + workEmail.userid = property(protocol()->propWorkEmailAddress).value().toString(); + + emailList.append(homeEmail); + emailList.append(workEmail); + + vCard.setEmailList(emailList); + + // work information tab + XMPP::VCard::Org org; + org.name = property(protocol()->propCompanyName).value().toString(); + org.unit = QStringList::split(",", property(protocol()->propCompanyDepartement).value().toString()); + vCard.setOrg(org); + vCard.setTitle (property(protocol()->propCompanyPosition).value().toString()); + vCard.setRole (property(protocol()->propCompanyRole).value().toString()); + + // phone numbers tab + XMPP::VCard::Phone phoneHome; + phoneHome.home = true; + phoneHome.number = property(protocol()->propPrivatePhone).value().toString(); + + XMPP::VCard::Phone phoneWork; + phoneWork.work = true; + phoneWork.number = property(protocol()->propWorkPhone).value().toString(); + + XMPP::VCard::Phone phoneFax; + phoneFax.fax = true; + phoneFax.number = property(protocol()->propPhoneFax).value().toString(); + + XMPP::VCard::Phone phoneCell; + phoneCell.cell = true; + phoneCell.number = property(protocol()->propPrivateMobilePhone).value().toString(); + + phoneList.append(phoneHome); + phoneList.append(phoneWork); + phoneList.append(phoneFax); + phoneList.append(phoneCell); + + vCard.setPhoneList(phoneList); + + // about tab + vCard.setDesc(property(protocol()->propAbout).value().toString()); + + // Set contact photo as a binary value (if he has set a photo) + if( hasProperty( protocol()->propPhoto.key() ) ) + { + QString photoPath = property( protocol()->propPhoto ).value().toString(); + QImage image( photoPath ); + QByteArray ba; + QBuffer buffer( ba ); + buffer.open( IO_WriteOnly ); + image.save( &buffer, "PNG" ); + vCard.setPhoto( ba ); + } + + vCard.setVersion("3.0"); + vCard.setProdId("Kopete"); + + XMPP::JT_VCard *task = new XMPP::JT_VCard (account()->client()->rootTask ()); + // signal to ourselves when the vCard data arrived + QObject::connect (task, SIGNAL (finished ()), this, SLOT (slotSentVCard ())); + task->set (vCard); + task->go (true); +} + +void JabberContact::setPhoto( const QString &photoPath ) +{ + QImage contactPhoto(photoPath); + QString newPhotoPath = photoPath; + if(contactPhoto.width() > 96 || contactPhoto.height() > 96) + { + // Save image to a new location if the image isn't the correct format. + QString newLocation( locateLocal( "appdata", "jabberphotos/"+ KURL(photoPath).fileName().lower() ) ); + + // Scale and crop the picture. + contactPhoto = contactPhoto.smoothScale( 96, 96, QImage::ScaleMin ); + // crop image if not square + if(contactPhoto.width() < contactPhoto.height()) + contactPhoto = contactPhoto.copy((contactPhoto.width()-contactPhoto.height())/2, 0, 96, 96); + else if (contactPhoto.width() > contactPhoto.height()) + contactPhoto = contactPhoto.copy(0, (contactPhoto.height()-contactPhoto.width())/2, 96, 96); + + // Use the cropped/scaled image now. + if(!contactPhoto.save(newLocation, "PNG")) + newPhotoPath = QString::null; + else + newPhotoPath = newLocation; + } + else if (contactPhoto.width() < 32 || contactPhoto.height() < 32) + { + // Save image to a new location if the image isn't the correct format. + QString newLocation( locateLocal( "appdata", "jabberphotos/"+ KURL(photoPath).fileName().lower() ) ); + + // Scale and crop the picture. + contactPhoto = contactPhoto.smoothScale( 32, 32, QImage::ScaleMin ); + // crop image if not square + if(contactPhoto.width() < contactPhoto.height()) + contactPhoto = contactPhoto.copy((contactPhoto.width()-contactPhoto.height())/2, 0, 32, 32); + else if (contactPhoto.width() > contactPhoto.height()) + contactPhoto = contactPhoto.copy(0, (contactPhoto.height()-contactPhoto.width())/2, 32, 32); + + // Use the cropped/scaled image now. + if(!contactPhoto.save(newLocation, "PNG")) + newPhotoPath = QString::null; + else + newPhotoPath = newLocation; + } + else if (contactPhoto.width() != contactPhoto.height()) + { + // Save image to a new location if the image isn't the correct format. + QString newLocation( locateLocal( "appdata", "jabberphotos/"+ KURL(photoPath).fileName().lower() ) ); + + if(contactPhoto.width() < contactPhoto.height()) + contactPhoto = contactPhoto.copy((contactPhoto.width()-contactPhoto.height())/2, 0, contactPhoto.height(), contactPhoto.height()); + else if (contactPhoto.width() > contactPhoto.height()) + contactPhoto = contactPhoto.copy(0, (contactPhoto.height()-contactPhoto.width())/2, contactPhoto.height(), contactPhoto.height()); + + // Use the cropped/scaled image now. + if(!contactPhoto.save(newLocation, "PNG")) + newPhotoPath = QString::null; + else + newPhotoPath = newLocation; + } + + setProperty( protocol()->propPhoto, newPhotoPath ); +} + +void JabberContact::slotSentVCard () +{ + +} + +void JabberContact::slotChatSessionDeleted ( QObject *sender ) +{ + kdDebug(JABBER_DEBUG_GLOBAL) << k_funcinfo << "Message manager deleted, collecting the pieces..." << endl; + + JabberChatSession *manager = static_cast(sender); + + mManagers.remove ( mManagers.find ( manager ) ); + +} + +JabberChatSession *JabberContact::manager ( Kopete::ContactPtrList chatMembers, Kopete::Contact::CanCreateFlags canCreate ) +{ + kdDebug(JABBER_DEBUG_GLOBAL) << k_funcinfo << "called, canCreate: " << canCreate << endl; + + Kopete::ChatSession *_manager = Kopete::ChatSessionManager::self()->findChatSession ( account()->myself(), chatMembers, protocol() ); + JabberChatSession *manager = dynamic_cast( _manager ); + + /* + * If we didn't find a message manager for this contact, + * instantiate a new one if we are allowed to. (otherwise return 0) + */ + if ( !manager && canCreate ) + { + XMPP::Jid jid = rosterItem().jid(); + + /* + * If we have no hardwired JID, set any eventually + * locked resource as preselected resource. + * If there is no locked resource, the resource field + * will stay empty. + */ + if ( jid.resource().isEmpty () ) + jid.setResource ( account()->resourcePool()->lockedResource ( jid ).name () ); + + kdDebug(JABBER_DEBUG_GLOBAL) << k_funcinfo << "No manager found, creating a new one with resource '" << jid.resource () << "'" << endl; + + manager = new JabberChatSession ( protocol(), static_cast(account()->myself()), chatMembers, jid.resource () ); + connect ( manager, SIGNAL ( destroyed ( QObject * ) ), this, SLOT ( slotChatSessionDeleted ( QObject * ) ) ); + mManagers.append ( manager ); + } + + return manager; + +} + +Kopete::ChatSession *JabberContact::manager ( Kopete::Contact::CanCreateFlags canCreate ) +{ + kdDebug(JABBER_DEBUG_GLOBAL) << k_funcinfo << "called, canCreate: " << canCreate << endl; + + Kopete::ContactPtrList chatMembers; + chatMembers.append ( this ); + + return manager ( chatMembers, canCreate ); + +} + +JabberChatSession *JabberContact::manager ( const QString &resource, Kopete::Contact::CanCreateFlags canCreate ) +{ + kdDebug(JABBER_DEBUG_GLOBAL) << k_funcinfo << "called, canCreate: " << canCreate << ", Resource: '" << resource << "'" << endl; + + /* + * First of all, see if we already have a manager matching + * the requested resource or if there are any managers with + * an empty resource. + */ + if ( !resource.isEmpty () ) + { + for ( JabberChatSession *mManager = mManagers.first (); mManager; mManager = mManagers.next () ) + { + if ( mManager->resource().isEmpty () || ( mManager->resource () == resource ) ) + { + // we found a matching manager, return this one + kdDebug(JABBER_DEBUG_GLOBAL) << k_funcinfo << "Found an existing message manager for this resource." << endl; + return mManager; + } + } + + kdDebug(JABBER_DEBUG_GLOBAL) << k_funcinfo << "No manager found for this resource, creating a new one." << endl; + + /* + * If we have come this far, we were either supposed to create + * a manager with a preselected resource but have found + * no available manager. (not even one with an empty resource) + * This means, we will have to create a new one with a + * preselected resource. + */ + Kopete::ContactPtrList chatmembers; + chatmembers.append ( this ); + JabberChatSession *manager = new JabberChatSession ( protocol(), + static_cast(account()->myself()), + chatmembers, resource ); + connect ( manager, SIGNAL ( destroyed ( QObject * ) ), this, SLOT ( slotChatSessionDeleted ( QObject * ) ) ); + mManagers.append ( manager ); + + return manager; + } + + kdDebug(JABBER_DEBUG_GLOBAL) << k_funcinfo << "Resource is empty, grabbing first available manager." << endl; + + /* + * The resource is empty, so just return first available manager. + */ + return dynamic_cast( manager ( canCreate ) ); + +} + +void JabberContact::deleteContact () +{ + kdDebug (JABBER_DEBUG_GLOBAL) << k_funcinfo << "Removing user " << contactId () << endl; + + if ( !account()->isConnected () ) + { + account()->errorConnectFirst (); + return; + } + + /* + * Follow the recommendation of + * JEP-0162: Best Practices for Roster and Subscription Management + * http://www.jabber.org/jeps/jep-0162.html#removal + */ + + bool remove_from_roster=false; + + if( mRosterItem.subscription().type() == XMPP::Subscription::Both || mRosterItem.subscription().type() == XMPP::Subscription::From ) + { + int result = KMessageBox::questionYesNoCancel (Kopete::UI::Global::mainWidget(), + i18n ( "Do you also want to remove the authorization from user %1 to see your status?" ). + arg ( mRosterItem.jid().bare () ), i18n ("Notification"), + KStdGuiItem::del (), i18n("Keep"), "JabberRemoveAuthorizationOnDelete" ); + if(result == KMessageBox::Yes ) + remove_from_roster = true; + else if( result == KMessageBox::Cancel) + return; + } + else if( mRosterItem.subscription().type() == XMPP::Subscription::None || mRosterItem.subscription().type() == XMPP::Subscription::To ) + remove_from_roster = true; + + if( remove_from_roster ) + { + XMPP::JT_Roster * rosterTask = new XMPP::JT_Roster ( account()->client()->rootTask () ); + rosterTask->remove ( mRosterItem.jid () ); + rosterTask->go ( true ); + } + else + { + sendSubscription("unsubscribe"); + + XMPP::JT_Roster * rosterTask = new XMPP::JT_Roster ( account()->client()->rootTask () ); + rosterTask->set ( mRosterItem.jid (), QString() , QStringList() ); + rosterTask->go (true); + } + +} + +void JabberContact::sync ( unsigned int ) +{ + // if we are offline or this is a temporary contact or we should not synch, don't bother + if ( dontSync () || !account()->isConnected () || metaContact()->isTemporary () || metaContact() == Kopete::ContactList::self()->myself() ) + return; + + kdDebug ( JABBER_DEBUG_GLOBAL ) << k_funcinfo << contactId () /*<< " - " <start(2*1000,true); + /* + the sync operation is delayed, because when we are doing a move to group operation, + kopete first add the contact to the group, then removes it. + Theses two operations should anyway be done in only one pass. + + if there is two jabber contact in one metacontact, this may result in an infinite change of + groups between theses two contacts, and the server is being flooded. + */ +} + +void JabberContact::slotDelayedSync( ) +{ + m_syncTimer->deleteLater(); + m_syncTimer=0L; + // if we are offline or this is a temporary contact or we should not synch, don't bother + if ( dontSync () || !account()->isConnected () || metaContact()->isTemporary () ) + return; + + bool changed=metaContact()->displayName() != mRosterItem.name(); + + + QStringList groups; + Kopete::GroupList groupList = metaContact ()->groups (); + + kdDebug ( JABBER_DEBUG_GLOBAL ) << k_funcinfo << "Synchronizing contact " << contactId () << endl; + + for ( Kopete::Group * g = groupList.first (); g; g = groupList.next () ) + { + if ( g->type () != Kopete::Group::TopLevel ) + groups += g->displayName (); + } + + if(mRosterItem.groups() != groups) + { + changed=true; + mRosterItem.setGroups ( groups ); + } + + if(!changed) + { + kdDebug ( JABBER_DEBUG_GLOBAL ) << k_funcinfo << "contact has not changed, abort sync" << endl; + return; + } + + XMPP::JT_Roster * rosterTask = new XMPP::JT_Roster ( account()->client()->rootTask () ); + + rosterTask->set ( mRosterItem.jid (), metaContact()->displayName (), mRosterItem.groups () ); + rosterTask->go (true); + +} + +void JabberContact::sendFile ( const KURL &sourceURL, const QString &/*fileName*/, uint /*fileSize*/ ) +{ + QString filePath; + + // if the file location is null, then get it from a file open dialog + if ( !sourceURL.isValid () ) + filePath = KFileDialog::getOpenFileName( QString::null , "*", 0L, i18n ( "Kopete File Transfer" ) ); + else + filePath = sourceURL.path(-1); + + QFile file ( filePath ); + + if ( file.exists () ) + { + // send the file + new JabberFileTransfer ( account (), this, filePath ); + } + +} + + +void JabberContact::slotSendAuth () +{ + + kdDebug (JABBER_DEBUG_GLOBAL) << k_funcinfo << "(Re)send auth " << contactId () << endl; + + sendSubscription ("subscribed"); + +} + +void JabberContact::slotRequestAuth () +{ + + kdDebug (JABBER_DEBUG_GLOBAL) << k_funcinfo << "(Re)request auth " << contactId () << endl; + + sendSubscription ("subscribe"); + +} + +void JabberContact::slotRemoveAuth () +{ + + kdDebug (JABBER_DEBUG_GLOBAL) << k_funcinfo << "Remove auth " << contactId () << endl; + + sendSubscription ("unsubscribed"); + +} + +void JabberContact::sendSubscription ( const QString& subType ) +{ + + if ( !account()->isConnected () ) + { + account()->errorConnectFirst (); + return; + } + + XMPP::JT_Presence * task = new XMPP::JT_Presence ( account()->client()->rootTask () ); + + task->sub ( mRosterItem.jid().full (), subType ); + task->go ( true ); + +} + +void JabberContact::slotSelectResource () +{ + int currentItem = QString ( static_cast( sender() )->name () ).toUInt (); + + /* + * Warn the user if there is already an active chat window. + * The resource selection will only apply for newly opened + * windows. + */ + if ( manager ( Kopete::Contact::CannotCreate ) != 0 ) + { + KMessageBox::queuedMessageBox ( Kopete::UI::Global::mainWidget (), + KMessageBox::Information, + i18n ("You have preselected a resource for contact %1, " + "but you still have open chat windows for this contact. " + "The preselected resource will only apply to newly opened " + "chat windows.").arg ( contactId () ), + i18n ("Jabber Resource Selector") ); + } + + if (currentItem == 0) + { + kdDebug (JABBER_DEBUG_GLOBAL) << k_funcinfo << "Removing active resource, trusting bestResource()." << endl; + + account()->resourcePool()->removeLock ( rosterItem().jid() ); + } + else + { + QString selectedResource = static_cast(sender())->text(); + + kdDebug (JABBER_DEBUG_GLOBAL) << k_funcinfo << "Moving to resource " << selectedResource << endl; + + account()->resourcePool()->lockToResource ( rosterItem().jid() , XMPP::Resource ( selectedResource ) ); + } + +} + +void JabberContact::sendPresence ( const XMPP::Status status ) +{ + + if ( !account()->isConnected () ) + { + account()->errorConnectFirst (); + return; + } + + XMPP::Status newStatus = status; + + // honour our priority + if(newStatus.isAvailable()) + newStatus.setPriority ( account()->configGroup()->readNumEntry ( "Priority", 5 ) ); + + XMPP::JT_Presence * task = new XMPP::JT_Presence ( account()->client()->rootTask () ); + + task->pres ( bestAddress (), newStatus); + task->go ( true ); + +} + + +void JabberContact::slotStatusOnline () +{ + + XMPP::Status status; + status.setShow(""); + + sendPresence ( status ); + +} + +void JabberContact::slotStatusChatty () +{ + + XMPP::Status status; + status.setShow ("chat"); + + sendPresence ( status ); + +} + +void JabberContact::slotStatusAway () +{ + + XMPP::Status status; + status.setShow ("away"); + + sendPresence ( status ); + +} + +void JabberContact::slotStatusXA () +{ + + XMPP::Status status; + status.setShow ("xa"); + + sendPresence ( status ); + +} + +void JabberContact::slotStatusDND () +{ + + XMPP::Status status; + status.setShow ("dnd"); + + sendPresence ( status ); + + +} + +void JabberContact::slotStatusInvisible () +{ + + XMPP::Status status; + status.setIsAvailable( false ); + + sendPresence ( status ); + +} + +bool JabberContact::isContactRequestingEvent( XMPP::MsgEvent event ) +{ + if ( event == OfflineEvent ) + return mRequestOfflineEvent; + else if ( event == DeliveredEvent ) + return mRequestDeliveredEvent; + else if ( event == DisplayedEvent ) + return mRequestDisplayedEvent; + else if ( event == ComposingEvent ) + return mRequestComposingEvent; + else if ( event == CancelEvent ) + return mRequestComposingEvent; + else if ( event == GoneEvent ) + return mRequestGoneEvent; + else + return false; +} + +QString JabberContact::lastReceivedMessageId () const +{ + return mLastReceivedMessageId; +} + +void JabberContact::voiceCall( ) +{ +#ifdef SUPPORT_JINGLE + Jid jid = mRosterItem.jid(); + + // It's honour lock by default. + JabberResource *bestResource = account()->resourcePool()->bestJabberResource( jid ); + if( bestResource ) + { + if( jid.resource().isEmpty() ) + { + // If the jid resource is empty, get the JID from best resource for this contact. + jid = bestResource->jid(); + } + + // Check if the voice caller exist and the current resource support voice. + if( account()->voiceCaller() && bestResource->features().canVoice() ) + { + JingleVoiceSessionDialog *voiceDialog = new JingleVoiceSessionDialog( jid, account()->voiceCaller() ); + voiceDialog->show(); + voiceDialog->start(); + } +#if 0 + if( account()->sessionManager() && bestResource->features().canVoice() ) + { + JingleVoiceSession *session = static_cast(account()->sessionManager()->createSession("http://www.google.com/session/phone", jid)); + + JingleVoiceSessionDialog *voiceDialog = new JingleVoiceSessionDialog(session); + voiceDialog->show(); + voiceDialog->start(); + } +#endif + } + else + { + // Shouldn't never go there. + } +#endif +} + +void JabberContact::slotDiscoFinished( ) +{ + mDiscoDone = true; + JT_DiscoInfo *jt = (JT_DiscoInfo *)sender(); + + bool is_transport=false; + QString tr_type; + + if ( jt->success() ) + { + QValueList identities = jt->item().identities(); + QValueList::Iterator it; + for ( it = identities.begin(); it != identities.end(); ++it ) + { + XMPP::DiscoItem::Identity ident=*it; + if(ident.category == "gateway") + { + is_transport=true; + tr_type=ident.type; + //name=ident.name; + + break; //(we currently only support gateway) + } + else if (ident.category == "service") + { + //The ApaSMSAgent is reporting itself as service (instead of gateway) which is broken. + //we anyway support it. See bug 127811 + if(ident.type == "sms") + { + is_transport=true; + tr_type=ident.type; + } + } + } + } + + if(is_transport && !transport()) + { //ok, we are not a contact, we are a transport.... + + XMPP::RosterItem ri = rosterItem(); + Kopete::MetaContact *mc=metaContact(); + JabberAccount *parentAccount=account(); + Kopete::OnlineStatus status=onlineStatus(); + + kdDebug(JABBER_DEBUG_GLOBAL) << k_funcinfo << ri.jid().full() << " is not a contact but a gateway - " << this << endl; + + if( Kopete::AccountManager::self()->findAccount( protocol()->pluginId() , account()->accountId() + "/" + ri.jid().bare() ) ) + { + kdDebug(JABBER_DEBUG_GLOBAL) << k_funcinfo << "oops, transport already exists, abort operation " << endl; + return; + } + + delete this; //we are not a contact i said ! + + if(mc->contacts().count() == 0) + Kopete::ContactList::self()->removeMetaContact( mc ); + + //we need to create the transport when 'this' is already deleted, so transport->myself() will not conflict with it + JabberTransport *transport = new JabberTransport( parentAccount , ri , tr_type ); + if(!Kopete::AccountManager::self()->registerAccount( transport )) + return; + transport->myself()->setOnlineStatus( status ); //push back the online status + return; + } +} + + + +#include "jabbercontact.moc" -- cgit v1.2.1