kopete/protocols/skype/skypeaccount.h

   1 /*  This file is part of the KDE project
   2     Copyright (C) 2005 Michal Vaner <michal.vaner@kdemail.net>
   3     Copyright (C) 2008-2009 Pali Rohár <pali.rohar@gmail.com>
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Library General Public
   7     License version 2 as published by the Free Software Foundation.
   8
   9     This library is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12     Library General Public License for more details.
  13
  14     You should have received a copy of the GNU Library General Public License
  15     along with this library; see the file COPYING.LIB.  If not, write to
  16     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17     Boston, MA 02111-1307, USA.
  18
  19 */
  20 #ifndef SKYPEACCOUNT_H
  21 #define SKYPEACCOUNT_H
  22
  23 #include <kopeteaccount.h>
  24 #include <kactionmenu.h>
  25 #include <kmenu.h>
  26
  27 class SkypeProtocol;
  28 class QString;
  29 class SkypeAccountPrivate;
  30 class SkypeContact;
  31 class SkypeChatSession;
  32
  33 namespace Kopete {
  34         class MetaContact;
  35         class OnlineStatus;
  36         class Message;
  37 }
  38
  39 #define DBUS_SESSION 0
  40 #define DBUS_SYSTEM 1
  41
  42 /**
  43  * @author Michal Vaner
  44  * @author Pali Rohár
  45  * @short Skype account
  46  * Account to use external skype program. At this time, it only supports one skype account at one, may be more in future.
  47  */
  48 class SkypeAccount : public Kopete::Account
  49 {
  50 Q_OBJECT
  51         private:
  52                 ///Some internal things
  53                 SkypeAccountPrivate *d;
  54                 ///Constructs list of users from their ID list. Have to be deleted later!
  55                 QList<Kopete::Contact*> *constructContactList(const QStringList &users);
  56         private slots:
  57                 /**
  58                  * This sets the right icon for the status - online
  59                  */
  60                 void wentOnline();
  61                 /**
  62                  * This changes the account icon to offline
  63                  */
  64                 void wentOffline();
  65                 /**
  66                  * This changes the account icon to away
  67                  */
  68                 void wentAway();
  69                 /**
  70                  * This changes the account icon to not available
  71                  */
  72                 void wentNotAvailable();
  73                 /**
  74                  * This changes the account icon to Do not disturb
  75                  */
  76                 void wentDND();
  77                 /**
  78                  * This changes the status icon of account to Invisible
  79                  */
  80                 void wentInvisible();
  81                 /**
  82                  * This changes the status indicator to Skype me
  83                  */
  84                 void wentSkypeMe();
  85                 /**
  86                  * The status changed to actually connecting
  87                  */
  88                 void statusConnecting();
  89                 /**
  90                  * This adds user to the contact list if it is not there
  91                  * @param name The skype name of the contact
  92                  * @param group The skype group name, where is user
  93                  */
  94                 void newUser(const QString &name, int group);
  95                 /**
  96                  * This is used for receiving messages from skype network
  97                  * @param user The user that sent it
  98                  * @param message The text of the message
  99                  * @param messageId Id of that message
 100                  */
 101                 void receivedIm(const QString &user, const QString &message, const QString &messageId);
 102                 /**
 103                  * New cal to show (or not, depending on setup) the call control window.
 104                  * @param callId ID of the new call
 105                  * @param userId User that is on the other end. If conference, list of IDs divided by spaces.
 106                  */
 107                 void newCall(const QString &callId, const QString &userId);
 108                 /**
 109                  * This one sets name of myself
 110                  * @param name What the new name is.
 111                  */
 112                 void setMyselfName(const QString &name);
 113                 /**
 114                  * This one keeps track of chat sessions that know their chat id
 115                  * @param oldId The old chat ID, or empty if no chat ID was known before
 116                  * @param newId The new chat ID, or empty if the chat just exists
 117                  * @param sender Pointer to the session
 118                  */
 119                 void setChatId(const QString &oldId, const QString &newId, SkypeChatSession *sender);
 120                 /**
 121                  * Some message is meing sent out by Skype, it should be showed
 122                  * @param body Text of the message
 123                  * @param chat Id of the chat it was sent to
 124                  */
 125                 void sentMessage(const QString &body, const QString &chat);
 126                 /**
 127                  * An Id of some message is known, use it
 128                  * @param messageId New id of that message
 129                  */
 130                 void gotMessageId(const QString &messageId);
 131                 /**
 132                  * This is used to group conference call participants together
 133                  * @param callId What call to add to the group
 134                  * @param groupIt to what group to add it
 135                  */
 136                 void groupCall(const QString &callId, const QString &groupId);
 137                 /**
 138                  * Remove that call from list
 139                  * @param callId what call
 140                  */
 141                 void removeCall(const QString &callId);
 142                 /**
 143                  * Remove reference to a call group
 144                  * @param groupId What group to remove
 145                  */
 146                 void removeCallGroup(const QString &groupId);
 147                 /**
 148                  * Delete skype group
 149                  * @param group kopete group
 150                  */
 151                 void deleteGroup (Kopete::Group * group);
 152                 /**
 153                  * Rename skype group
 154                  * @param group kopete group
 155                  * @param oldname old kopete group name
 156                  */
 157                 void renameGroup (Kopete::Group * group, const QString &oldname );
 158         protected:
 159                 /**
 160                  * Creates new skype contact and adds it into the parentContact.
 161                  * @param contactID ID of the contact (the skype name)
 162                  * @param parentContact Metacontact to add it into.
 163                  * @return True if it worked, false otherwise.
 164                  */
 165                 virtual bool createContact(const QString &contactID, Kopete::MetaContact *parentContact);
 166                 /**
 167                 * This simulates contacts going on and offline in sync with the account's status changes
 168                 */
 169                 void updateContactStatus();
 170         public:
 171                 /**
 172                  * Constructor.
 173                  * @param protocol The skype protocol pointer.
 174                  */
 175                 SkypeAccount(SkypeProtocol *protocol, const QString& accountID);
 176                 /**
 177                  * Destructor
 178                  */
 179                 ~SkypeAccount();
 180                 /**
 181                  * Finds contact of given id
 182                  * @param id id of the wanted contact
 183                  * @return eather pointer to that contact or 0L of it was not found.
 184                  */
 185                 SkypeContact *contact(const QString &id);
 186                 /**
 187                  * How to launch the Skype
 188                  */
 189                 int launchType;
 190                 /**
 191                  * Is this verson of protocol able to create call conferences?
 192                  */
 193                 bool ableMultiCall();
 194                 /**
 195                  * Is it possible to alter the authorization now?
 196                  */
 197                 bool canAlterAuth();
 198                 /**
 199                  * How shoul kopete authorize it self? (empty means as Kopete)
 200                  */
 201                 QString author;
 202                 /**
 203                  * This saves properties to the config file
 204                  */
 205                 void save();
 206                 /**
 207                  * Prepares this contact for life and integrates it into this account. Should be called only by the contact in its constructor.
 208                  * @param conntact The contact to prepare
 209                  */
 210                 void prepareContact(SkypeContact *contact);
 211                 ///Can we comunicate with the skype? (not with the network, just with the program)
 212                 bool canComunicate();
 213                 ///returns the protocol
 214                 SkypeProtocol * protocol();
 215                 /**
 216                  * @return Is the HitchHike mode enabled or not?
 217                  * @see setHitchHike
 218                  */
 219                 bool getHitchHike() const;
 220                 /**
 221                  * @return Is the MarkRead mode enabled or not?
 222                  * @see setMarkRead
 223                  */
 224                 bool getMarkRead() const;
 225                 /**
 226                  * Is the scan for unread message on login enabled?
 227                  * @return Is it enabled or not?
 228                  * @see setSearchForUnread
 229                  */
 230                 bool getScanForUnread() const;
 231                 /**
 232                  * @return true if this user already has opened chat session, false if he doesn't have opened chat session or the user do not exist
 233                  * @param userId ID of the user in interest
 234                  */
 235                 bool userHasChat(const QString &userId);
 236                 /**
 237                  * @return Should a control window be showed for calls?
 238                  */
 239                 bool getCallControl() const;
 240                 /**
 241                  * Is that call incoming or not?
 242                  * @param callId What call you want to know?
 243                  * @return true if the call is incoming call (someone calls you), false otherwise (outgoing, not a call at all..)
 244                  */
 245                 bool isCallIncoming(const QString &callId);
 246                 /**
 247                  * @return The time after the call finished to auto-closing the window. If auto-closing is disabled, 0 is returned
 248                  * @see setCallWindowTimeout
 249                  */
 250                 int closeCallWindowTimeout() const;
 251                 /**
 252                  * @return Returns name that shouls be showed by a call window
 253                  */
 254                 QString getUserLabel(const QString &userId);
 255                 /**
 256                  * Are pings to Skype enabled?
 257                  * @return You guess..
 258                  */
 259                 bool getPings() const;
 260                 /**
 261                  * What bus is set to use now?
 262                  * @return 0 as session bus, 1 as system wide
 263                  */
 264                 int getBus() const;
 265                 /**
 266                  * How long does it try to connect to newly started skype, until it gives up (seconds)
 267                  */
 268                 int getLaunchTimeout() const;
 269                 /**
 270                  * What is the command that launches skype?
 271                  */
 272                 const QString &getSkypeCommand() const;
 273                 /**
 274                  * Do we wait before connecting?
 275                  */
 276                 int getWaitBeforeConnect() const;
 277                 /**
 278                  * Do we have that chat opened?
 279                  * @param chatId What chat are you interested in?
 280                  */
 281                 bool chatExists(const QString &chatId);
 282                 /**
 283                  * This one returns contact of that name. If that contact does not exist in the contact list, a temporary one is created
 284                  * @param userId ID of that user
 285                  */
 286                 SkypeContact *getContact(const QString &userId);
 287                 /**
 288                  * @param messageId ID of a message
 289                  * @return ID of chat the message belongs to. If no such message exists, the result is not defined.
 290                  */
 291                 QString getMessageChat(const QString &messageId);
 292                 /**
 293                  * This will mark last active chat (last that sent out some message). It will be set an ID soon after that, user will not have time to write another message anyway
 294                  * @param session Pointer to that chat session
 295                  */
 296                 void registerLastSession(SkypeChatSession *session);
 297                 /**
 298                  * Create a chat with given members
 299                  * @param users Comma sepparated list of members
 300                  * @return ID of the chat
 301                  */
 302                 QString createChat(const QString &users);
 303                 /**
 304                  * Should chat leave when it's window is closed?
 305                  */
 306                 bool leaveOnExit() const;
 307                 /**
 308                  * Returns the call that should be executed before making a call.
 309                  * @return The command or empty string if nothing should be executed
 310                  */
 311                 QString startCallCommand() const;
 312                 /**
 313                  * Should we wait for the startCallCommand to finish before making the call.
 314                  */
 315                 bool waitForStartCallCommand() const;
 316                 /**
 317                  * The command that should be executed after the call is finished.
 318                  * @return The command or empty string if user does not want to execute anything.
 319                  */
 320                 QString endCallCommand() const;
 321                 /**
 322                  * Should be tha command executed only for the last call?
 323                  */
 324                 bool endCallCommandOnlyLast() const;
 325                 /**
 326                  * Command that should be executed on incoming call, or empty string if nothing to execute
 327                  */
 328                 QString incomingCommand() const;
 329                 /**
 330                  * Registers this contact to the skype contact list
 331                  * @param contactId What user should be added?
 332                  */
 333                 void registerContact(const QString &contactId);
 334                 /**
 335                  * returns how is user authorized
 336                  * @return 0 if he is authorized, 1 if not and 2 if he is blocked
 337                  */
 338                 int getAuthor(const QString &contactId);
 339                 /**
 340                  * Disconnects from server.
 341                  */
 342                 virtual void disconnect();
 343                 /**
 344                  * Sets online status to away/online.
 345                  * @param away If true, it sets to away, otherwise it sets to online.
 346                  * @param reason Message to set. Ignored with skype as it does not support away messages. (Or I don't know about it))
 347                  */
 348                 virtual void setAway(bool away, const QString &reason);
 349                 /**
 350                  * Skype account has costum status menu
 351                  */
 352                 virtual bool hasCustomStatusMenu() const;
 353                 /**
 354                  * Per-protocol actions for the systray and the status bar
 355                  */
 356                 virtual void fillActionMenu( KActionMenu *actionMenu );
 357                 /**
 358                  * This will return ID of the actual user this one that uses this skype)
 359                  */
 360                 QString getMyselfSkypeName();
 361                 /**
 362                  * Call it when contact move between group
 363                  */
 364                 void MovedBetweenGroup(SkypeContact *contact);
 365                 /**
 366                  * Open skype file transfer dilog to send file via skype
 367                  */
 368                 void openFileTransfer(const QString &user, const QString &url = QString::null);
 369         public slots:
 370                 /**
 371                  * Sets online status for the account.
 372                  * @param status Status to set.
 373                  * @param reason Away message. Ignored by skype.
 374                  */
 375                 virtual void setOnlineStatus( const Kopete::OnlineStatus &status , const Kopete::StatusMessage &reason = Kopete::StatusMessage(), const OnlineStatusOptions& options = None);
 376                 virtual void setStatusMessage(const Kopete::StatusMessage& statusMessage);
 377                 /**
 378                  * Connect to the skype with given status
 379                  * @param status The status to connect with. If it is something unusual (like offline or something unknown), online is used
 380                  */
 381                 virtual void connect( const Kopete::OnlineStatus& Status = Kopete::OnlineStatus() );
 382                 /**
 383                  * This notifies contact of some change of its information
 384                  * @param contact What contact is it?
 385                  * @param change And what happende.
 386                  */
 387                 void updateContactInfo(const QString &contact, const QString &change);
 388                 /**
 389                  * This will send message by the skype connection. Will take care of all notifications when it is done and so. (means it will emit messageSent when it is sent)
 390                  * @param message What to send.
 391                  * @param chat Chat to send it to. If it is empty, it is sent just to that person listed in the message
 392                  */
 393                 void sendMessage(Kopete::Message &message, const QString &chat);
 394                 /**
 395                  * Enables or disables the HitchHike mode of getting messages. If it is enabled, a new message to unstarted chat will be showed. If not, they will be ignored and you will have to open them in Skype
 396                  * @param value True enables HitchHike mode, false disables.
 397                  * @see getHitchHike
 398                  */
 399                 void setHitchHike(bool value);
 400                 /**
 401                  * Enables reading messages by kopete. If it is on, all messages showed in Kopete will be marked as read, if disable, you will have to read them in Skype/something else.
 402                  * If HitchHike mode is disabled, messages that creates chats are NOT marked as read, because they are not showed.
 403                  * @param value Enable or disable the mode
 404                  * @see getMarkRead
 405                  * @see getHitchHake
 406                  * @see setHitchHike
 407                  */
 408                 void setMarkRead(bool value);
 409                 /**
 410                  * Set if there should be scan for unread messages when kopete connects to Skype.
 411                  * @param value Enable or disable the scan.
 412                  * @see getScanForUnread
 413                  */
 414                 void setScanForUnread(bool value);
 415                 /**
 416                  * Make a call to that user
 417                  * @param user To who we call.
 418                  */
 419                 void makeCall(SkypeContact *user);
 420                 /**
 421                  * Make conference call to more than one user (possibly)
 422                  * @param users comma separated list of user IDs
 423                  */
 424                 void makeCall(const QString &users);
 425                 /**
 426                  * Make Test Call - call contact echo123
 427                  */
 428                 void makeTestCall();
 429                 /**
 430                  * Set if a control window will be showed for calls.
 431                  * @param value Is it enabled or disabled now?
 432                  */
 433                 void setCallControl(bool value);
 434                 /**
 435                  * Sets timeout in seconds how long will be call window visible after the call finished. If you want to disable it, set to 0.
 436                  */
 437                 void setCloseWindowTimeout(int timeout);
 438                 /**
 439                  * Turns pinging skype on/off
 440                  * If it is on, every second a ping message is sent to skype so track of if Skype is running is still hold. f it is off, skype can be turned off and you won't know it.
 441                  * @param enabled Are they on or off from now?
 442                  */
 443                 void setPings(bool enabled);
 444                 /**
 445                  * Sets bus on which Skype listens
 446                  * @param bus 0 -> session bus, 1 -> system wide bus
 447                  */
 448                 void setBus(int bus);
 449                 /**
 450                  * Set the timeout for giving up launching Skype
 451                  */
 452                 void setLaunchTimeout(int seconds);
 453                 /**
 454                  * Set command by what the Skype will be started
 455                  */
 456                 void setSkypeCommand(const QString &command);
 457                 /**
 458                  * Set if we wait a while before connecting to just started skype
 459                  */
 460                 void setWaitBeforeConnect(int value);
 461                 /**
 462                  * This should be called with all new chat sessions to connect all signals to them
 463                  * @param session The chat session
 464                  */
 465                 void prepareChatSession(SkypeChatSession *session);
 466                 /**
 467                  * This receives a multi-user chat message and delivers it to the chat session
 468                  * @param chatId What chat should get it
 469                  * @param boty Text of that message
 470                  * @param messageId ID of the received message
 471                  * @param user The one who sent it
 472                  */
 473                 void receiveMultiIm(const QString &chatId, const QString &body, const QString &messageId, const QString &user);
 474                 /**
 475                  * Set if chat window should close a chat window when you close it
 476                  */
 477                 void setLeaveOnExit(bool value);
 478                 /**
 479                  * Open chat to the user
 480                  * @param userId
 481                  */
 482                 void chatUser(const QString &userId);
 483                 /**
 484                  * Sets the command to be executed before making/accepting call (or empty if nothing)
 485                  */
 486                 void setStartCallCommand(const QString &value);
 487                 /**
 488                  * Set the command that will be executed when a call is finished
 489                  */
 490                 void setEndCallCommand(const QString &value);
 491                 /**
 492                  * Do we wait for the command to be executed before making the call?
 493                  */
 494                 void setWaitForStartCallCommand(bool value);
 495                 /**
 496                  * Should be the end command executed only for the last closed call or for every call that is closed?
 497                  */
 498                 void setEndCallCommandOnlyForLast(bool value);
 499                 /**
 500                  * Notify me when a call has begun and I should run the start call command
 501                  */
 502                 void startCall();
 503                 /**
 504                  * Notify me when the call ends to run the end call command
 505                  */
 506                 void endCall();
 507                 /**
 508                  * Sets a command to be executed for incoming call
 509                  */
 510                 void setIncomingCommand(const QString &command);
 511                 /**
 512                  * Removes a given contact from skype
 513                  */
 514                 void removeContact(const QString &contactId);
 515                 /**
 516                  * authorizes a user
 517                  * @param userId what user
 518                  */
 519                 void authorizeUser(const QString &userId);
 520                 /**
 521                  * removes authorization from user
 522                  * @param userId what user
 523                  */
 524                 void disAuthorUser(const QString &userId);
 525                 /**
 526                  * Blocks a user (no more messages will be accepted)
 527                  * @param userId what user
 528                  */
 529                 void blockUser(const QString &userId);
 530         signals:
 531                 /**
 532                  * This is emited when the message has been sent by skype
 533                  * @param messageId Id of the message that has been sent
 534                  */
 535                 void sentMessage(const QString &messageId);
 536                 /**
 537                  * This slot notifies of connecting/disconnecting. Needed to be sure, if alling is possible.
 538                  * @param online Are we online now?
 539                  */
 540                 void connectionStatus(bool online);
 541
 542 };
 543
 544 #endif