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

12 files changed, 1476 insertions, 0 deletions

diff --git a/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/Makefile.am b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/Makefile.am
new file mode 100644
index 00000000..81cf9345
--- /dev/null
+++ b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/Makefile.am
@@ -0,0 +1,16 @@
+bin_PROGRAMS = call 
+call_CXXFLAGS = $(AM_CXXFLAGS)
+call_SOURCES = call_main.cc callclient.cc console.cc presencepushtask.cc presenceouttask.cc
+noinst_HEADERS = callclient.h  console.h  presenceouttask.h  presencepushtask.h  status.h
+call_LDADD =  \
+	       $(srcdir)/../../../talk/examples/login/libcricketexampleslogin.la \
+	       $(srcdir)/../../../talk/session/phone/libcricketsessionphone.la \
+	       $(srcdir)/../../../talk/p2p/client/libcricketp2pclient.la \
+	       $(srcdir)/../../../talk/p2p/base/libcricketp2pbase.la \
+	       $(srcdir)/../../../talk/xmpp/libcricketxmpp.la \
+	       $(srcdir)/../../../talk/xmllite/libcricketxmllite.la \
+	       $(srcdir)/../../../talk/base/libcricketbase.la \
+	       $(srcdir)/../../../talk/third_party/mediastreamer/libmediastreamer.la \
+	       $(EXPAT_LIBS) $(ORTP_LIBS) -lpthread $(ILBC_LIBS) $(SPEEX_LIBS) $(GLIB_LIBS) -lasound 
+AM_CPPFLAGS  = -DPOSIX
+DEFAULT_INCLUDES = -I$(srcdir)/../../..
\ No newline at end of file
diff --git a/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/call.pro b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/call.pro
new file mode 100644
index 00000000..ccf0638b
--- /dev/null
+++ b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/call.pro
@@ -0,0 +1,19 @@
+TEMPLATE = app
+INCLUDEPATH = ../../..
+DEFINES += POSIX
+
+include(../../../../../conf.pri)
+
+# Input
+SOURCES += \
+	call_main.cc \
+	callclient.cc \
+	console.cc \
+	presenceouttask.cc \
+	presencepushtask.cc \
+	../login/xmppauth.cc \
+	../login/xmpppump.cc \
+	../login/xmppsocket.cc \
+	../login/xmppthread.cc
+
+LIBS += ../../../liblibjingle.a
diff --git a/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/call_main.cc b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/call_main.cc
new file mode 100644
index 00000000..1a965326
--- /dev/null
+++ b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/call_main.cc
@@ -0,0 +1,62 @@
+/*
+ * Jingle call example
+ * Copyright 2004--2005, Google Inc.
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "talk/xmpp/xmppclientsettings.h"
+#include "talk/examples/login/xmppthread.h"
+#include "talk/examples/login/xmppauth.h"
+#include "talk/examples/call/callclient.h"
+#include "talk/examples/call/console.h"
+
+void GetString(const char* desc, char* out) {
+  printf("%s: ", desc);
+  fflush(stdout);
+  scanf("%s", out);
+}
+
+int main(int argc, char **argv) {
+  // TODO: Make this into a console task
+  char username[256], auth_cookie[256];
+  GetString("Username", username);
+  GetString("Auth Cookie", auth_cookie);
+
+  printf("Logging in as %s@gmail.com\n", username);
+
+  // We will run the console and the XMPP client on the main thread.  The
+  // CallClient maintains a separate worker thread for voice.
+
+  cricket::PhysicalSocketServer ss;
+  cricket::Thread main_thread(&ss);
+  cricket::ThreadManager::SetCurrent(&main_thread);
+
+  InitConsole(&ss);
+  XmppPump pump;
+  CallClient client(pump.client());
+
+  buzz::XmppClientSettings xcs;
+  xcs.set_user(username);
+  xcs.set_host("gmail.com");
+  xcs.set_use_tls(false);
+  xcs.set_auth_cookie(auth_cookie);
+  xcs.set_server(cricket::SocketAddress("talk.google.com", 5222));
+  pump.DoLogin(xcs, new XmppSocket(false), new XmppAuth());
+
+  main_thread.Loop();
+
+  return 0;
+}
diff --git a/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/callclient.cc b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/callclient.cc
new file mode 100644
index 00000000..c8c28310
--- /dev/null
+++ b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/callclient.cc
@@ -0,0 +1,390 @@
+/*
+ * Jingle call example
+ * Copyright 2004--2005, Google Inc.
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <string>
+#include <vector>
+
+#include "talk/xmpp/constants.h"
+#include "talk/base/thread.h"
+#include "talk/base/network.h"
+#include "talk/base/socketaddress.h"
+#include "talk/p2p/base/sessionmanager.h"
+#include "talk/p2p/base/helpers.h"
+#include "talk/p2p/client/basicportallocator.h"
+#include "talk/session/receiver.h"
+#include "talk/session/sessionsendtask.h"
+#include "talk/session/phone/phonesessionclient.h"
+#include "talk/examples/call/callclient.h"
+#include "talk/examples/call/console.h"
+#include "talk/examples/call/presencepushtask.h"
+#include "talk/examples/call/presenceouttask.h"
+
+namespace {
+
+const char* CALL_COMMANDS =
+"Available commands:\n"
+"\n"
+"  hangup  Ends the call.\n"
+"  mute    Stops sending voice.\n"
+"  unmute  Re-starts sending voice.\n"
+"";
+
+class CallTask: public ConsoleTask, public sigslot::has_slots<> {
+public:
+  CallTask(CallClient* call_client, const buzz::Jid& jid, cricket::Call* call)
+      : call_client_(call_client), jid_(jid), call_(call) {
+  }
+
+  virtual ~CallTask() {}
+
+  virtual void Start() {
+    call_client_->phone_client()->SignalCallDestroy.connect(
+        this, &CallTask::OnCallDestroy);
+    if (!call_) {
+      call_ = call_client_->phone_client()->CreateCall();
+      call_->SignalSessionState.connect(this, &CallTask::OnSessionState);
+      session_ = call_->InitiateSession(jid_);
+    }
+    call_client_->phone_client()->SetFocus(call_);
+  }
+
+  virtual std::string GetPrompt() { return jid_.node(); }
+
+  virtual void ProcessLine(const std::string& line) {
+    std::vector<std::string> words;
+    ParseLine(line, &words);
+
+    if ((words.size() == 1) && (words[0] == "hangup")) {
+      call_->Terminate();
+      SignalDone(this);
+    } else if ((words.size() == 1) && (words[0] == "mute")) {
+      call_->Mute(true);
+    } else if ((words.size() == 1) && (words[0] == "unmute")) {
+      call_->Mute(false);
+    } else {
+      console()->Print(CALL_COMMANDS);
+    }
+  }
+
+private:
+  CallClient* call_client_;
+  buzz::Jid jid_;
+  cricket::Call* call_;
+  cricket::Session* session_;
+
+  void OnCallDestroy(cricket::Call* call) {
+    if (call == call_) {
+      console()->Print("call destroyed");
+      SignalDone(this);
+    }
+  }
+
+  void OnSessionState(cricket::Call* call,
+                      cricket::Session* session,
+                      cricket::Session::State state) {
+    if (state == cricket::Session::STATE_SENTINITIATE) {
+      console()->Print("calling...");
+    } else if (state == cricket::Session::STATE_RECEIVEDACCEPT) {
+      console()->Print("call answered");
+    } else if (state == cricket::Session::STATE_RECEIVEDREJECT) {
+      console()->Print("call not answered");
+      SignalDone(this);
+    } else if (state == cricket::Session::STATE_INPROGRESS) {
+      console()->Print("call in progress");
+    } else if (state == cricket::Session::STATE_RECEIVEDTERMINATE) {
+      console()->Print("other side hung up");
+      SignalDone(this);
+    }
+  }
+};
+
+const char* RECEIVE_COMMANDS =
+"Available commands:\n"
+"\n"
+"  accept  Accepts the incoming call and switches to it.\n"
+"  reject  Rejects the incoming call and stays with the current call.\n"
+"";
+
+class ReceiveTask: public ConsoleTask {
+public:
+  ReceiveTask(CallClient* call_client,
+              const buzz::Jid& jid,
+              cricket::Call* call)
+      : call_client_(call_client), jid_(jid), call_(call) {
+  }
+
+  virtual std::string GetPrompt() { return jid_.node(); }
+
+  virtual void ProcessLine(const std::string& line) {
+    std::vector<std::string> words;
+    ParseLine(line, &words);
+
+    if ((words.size() == 1) && (words[0] == "accept")) {
+      assert(call_->sessions().size() == 1);
+      call_->AcceptSession(call_->sessions()[0]);
+      Console()->Push(new CallTask(call_client_, jid_, call_));
+      SignalDone(this);
+    } else if ((words.size() == 1) && (words[0] == "reject")) {
+      call_->RejectSession(call_->sessions()[0]);
+      SignalDone(this);
+    } else {
+      console()->Print(RECEIVE_COMMANDS);
+    }
+  }
+
+private:
+  CallClient* call_client_;
+  buzz::Jid jid_;
+  cricket::Call* call_;
+};
+
+const char* CONSOLE_COMMANDS =
+"Available commands:\n"
+"\n"
+"  roster       Prints the online friends from your roster.\n"
+"  call <name>  Initiates a call to the friend with the given name.\n"
+"  quit         Quits the application.\n"
+"";
+
+class CallConsoleTask: public ConsoleTask {
+public:
+  CallConsoleTask(CallClient* call_client) : call_client_(call_client) {}
+  virtual ~CallConsoleTask() {}
+
+  virtual std::string GetPrompt() { return "console"; }
+
+  virtual void ProcessLine(const std::string& line) {
+    std::vector<std::string> words;
+    ParseLine(line, &words);
+
+    if ((words.size() == 1) && (words[0] == "quit")) {
+      SignalDone(this);
+    } else if ((words.size() == 1) && (words[0] == "roster")) {
+      call_client_->PrintRoster();
+    } else if ((words.size() == 2) && (words[0] == "call")) {
+      call_client_->MakeCallTo(words[1]);
+    } else {
+      console()->Print(CONSOLE_COMMANDS);
+    }
+  }
+
+private:
+  CallClient* call_client_;
+};
+
+const char* DescribeStatus(buzz::Status::Show show, const std::string& desc) {
+  switch (show) {
+  case buzz::Status::SHOW_XA:      return desc.c_str();
+  case buzz::Status::SHOW_ONLINE:  return "online";
+  case buzz::Status::SHOW_AWAY:    return "away";
+  case buzz::Status::SHOW_DND:     return "do not disturb";
+  case buzz::Status::SHOW_CHAT:    return "ready to chat";
+  delault:                         return "offline";
+  }
+}
+
+} // namespace
+
+CallClient::CallClient(buzz::XmppClient* xmpp_client)
+    : xmpp_client_(xmpp_client), roster_(new RosterMap) {
+  xmpp_client_->SignalStateChange.connect(this, &CallClient::OnStateChange);
+  Console()->Push(new CallConsoleTask(this));
+}
+
+CallClient::~CallClient() {
+  delete roster_;
+}
+
+const std::string CallClient::strerror(buzz::XmppEngine::Error err) {
+  switch (err) {
+   case  buzz::XmppEngine::ERROR_NONE: 
+     return "";
+   case  buzz::XmppEngine::ERROR_XML:  
+     return "Malformed XML or encoding error";
+   case  buzz::XmppEngine::ERROR_STREAM: 
+     return "XMPP stream error";
+   case  buzz::XmppEngine::ERROR_VERSION:
+     return "XMPP version error";
+   case  buzz::XmppEngine::ERROR_UNAUTHORIZED:
+     return "User is not authorized (Confirm your GX cookie at mail.google.com)";
+   case  buzz::XmppEngine::ERROR_TLS:
+     return "TLS could not be negotiated";
+   case	 buzz::XmppEngine::ERROR_AUTH:
+     return "Authentication could not be negotiated";
+   case  buzz::XmppEngine::ERROR_BIND:
+     return "Resource or session binding could not be negotiated";
+   case  buzz::XmppEngine::ERROR_CONNECTION_CLOSED:
+     return "Connection closed by output handler.";
+   case  buzz::XmppEngine::ERROR_DOCUMENT_CLOSED:
+     return "Closed by </stream:stream>";
+   case  buzz::XmppEngine::ERROR_SOCKET:
+     return "Socket error";
+  }
+}
+
+void CallClient::OnStateChange(buzz::XmppEngine::State state) {
+  switch (state) {
+  case buzz::XmppEngine::STATE_START:
+    Console()->Print("connecting...");
+    break;
+
+  case buzz::XmppEngine::STATE_OPENING:
+    Console()->Print("logging in...");
+    break;
+
+  case buzz::XmppEngine::STATE_OPEN:
+    Console()->Print("logged in...");
+    InitPhone();
+    InitPresence();
+    break;
+
+  case buzz::XmppEngine::STATE_CLOSED:
+    buzz::XmppEngine::Error error = xmpp_client_->GetError();
+    Console()->Print("logged out..." + strerror(error));
+    exit(0);
+  }
+}
+
+void CallClient::InitPhone() {
+  std::string client_unique = xmpp_client_->jid().Str();
+  cricket::InitRandom(client_unique.c_str(), client_unique.size());
+
+  worker_thread_ = new cricket::Thread();
+
+  network_manager_ = new cricket::NetworkManager();
+  
+  cricket::SocketAddress *stun_addr = new cricket::SocketAddress("64.233.167.126", 19302);
+  port_allocator_ = new cricket::BasicPortAllocator(network_manager_, stun_addr, NULL);
+
+  session_manager_ = new cricket::SessionManager(
+      port_allocator_, worker_thread_);
+  session_manager_->SignalRequestSignaling.connect(
+      this, &CallClient::OnRequestSignaling);
+  session_manager_->OnSignalingReady();
+
+  phone_client_ = new cricket::PhoneSessionClient(
+      xmpp_client_->jid(),session_manager_);
+  phone_client_->SignalCallCreate.connect(this, &CallClient::OnCallCreate);
+  phone_client_->SignalSendStanza.connect(this, &CallClient::OnSendStanza);
+
+  receiver_ = new cricket::Receiver(xmpp_client_, phone_client_);
+  receiver_->Start();
+
+  worker_thread_->Start();
+}
+
+void CallClient::OnRequestSignaling() {
+  session_manager_->OnSignalingReady();
+}
+
+void CallClient::OnCallCreate(cricket::Call* call) {
+  call->SignalSessionState.connect(this, &CallClient::OnSessionState);
+}
+
+void CallClient::OnSessionState(cricket::Call* call,
+                                cricket::Session* session,
+                                cricket::Session::State state) {
+  if (state == cricket::Session::STATE_RECEIVEDINITIATE) {
+    buzz::Jid jid(session->remote_address());
+    Console()->Printf("Incoming call from '%s'", jid.Str().c_str());
+    Console()->Push(new ReceiveTask(this, jid, call));
+  }
+}
+
+void CallClient::OnSendStanza(cricket::SessionClient *client, const buzz::XmlElement* stanza) {
+  cricket::SessionSendTask* sender =
+      new cricket::SessionSendTask(xmpp_client_, phone_client_);
+  sender->Send(stanza);
+  sender->Start();
+}
+
+void CallClient::InitPresence() {
+  presence_push_ = new buzz::PresencePushTask(xmpp_client_);
+  presence_push_->SignalStatusUpdate.connect(
+    this, &CallClient::OnStatusUpdate);
+  presence_push_->Start();
+
+  buzz::Status my_status;
+  my_status.set_jid(xmpp_client_->jid());
+  my_status.set_available(true);
+  my_status.set_invisible(false);
+  my_status.set_show(buzz::Status::SHOW_ONLINE);
+  my_status.set_priority(0);
+  my_status.set_know_capabilities(true);
+  my_status.set_phone_capability(true);
+  my_status.set_is_google_client(true);
+  my_status.set_version("1.0.0.66");
+
+  buzz::PresenceOutTask* presence_out_ =
+      new buzz::PresenceOutTask(xmpp_client_);
+  presence_out_->Send(my_status);
+  presence_out_->Start();
+}
+
+void CallClient::OnStatusUpdate(const buzz::Status& status) {
+  RosterItem item;
+  item.jid = status.jid();
+  item.show = status.show();
+  item.status = status.status();
+
+  std::string key = item.jid.Str();
+
+  if (status.available() && status.phone_capability()) {
+    Console()->Printf("Adding to roster: %s", key.c_str());
+    (*roster_)[key] = item;
+  } else {
+    Console()->Printf("Removing from roster: %s", key.c_str());
+    RosterMap::iterator iter = roster_->find(key);
+    if (iter != roster_->end())
+      roster_->erase(iter);
+  }
+}
+
+void CallClient::PrintRoster() {
+  Console()->Printf("Roster contains %d callable", roster_->size());
+  RosterMap::iterator iter = roster_->begin();
+  while (iter != roster_->end()) {
+    Console()->Printf("%s - %s",
+                      iter->second.jid.BareJid().Str().c_str(),
+                      DescribeStatus(iter->second.show, iter->second.status));
+    iter++;
+  }
+}
+
+void CallClient::MakeCallTo(const std::string& name) {
+  bool found = false;
+  buzz::Jid found_jid;
+
+  RosterMap::iterator iter = roster_->begin();
+  while (iter != roster_->end()) {
+    if (iter->second.jid.node() == name) {
+      found = true;
+      found_jid = iter->second.jid;
+      break;
+    }
+    ++iter;
+  }
+
+  if (found) {
+    Console()->Printf("Found online friend '%s'", found_jid.Str().c_str());
+    Console()->Push(new CallTask(this, found_jid, NULL));
+  } else {
+    Console()->Printf("Could not find online friend '%s'", name.c_str());
+  } 
+}
diff --git a/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/callclient.h b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/callclient.h
new file mode 100644
index 00000000..2400b7db
--- /dev/null
+++ b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/callclient.h
@@ -0,0 +1,88 @@
+/*
+ * Jingle call example
+ * Copyright 2004--2005, Google Inc.
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef CRICKET_EXAMPLES_CALL_CALLCLIENT_H__
+#define CRICKET_EXAMPLES_CALL_CALLCLIENT_H__
+
+#include <map>
+#include <string>
+#include "talk/p2p/base/session.h"
+#include "talk/p2p/client/sessionclient.h"
+#include "talk/xmpp/xmppclient.h"
+#include "talk/examples/call/status.h"
+
+namespace buzz {
+class PresencePushTask;
+class Status;
+}
+
+namespace cricket {
+class Thread;
+class NetworkManager;
+class PortAllocator;
+class PhoneSessionClient;
+class Receiver;
+class Call;
+}
+
+struct RosterItem {
+  buzz::Jid jid;
+  buzz::Status::Show show;
+  std::string status;
+};
+
+class CallClient: public sigslot::has_slots<> {
+public:
+  CallClient(buzz::XmppClient* xmpp_client);
+  ~CallClient();
+
+  cricket::PhoneSessionClient* phone_client() const { return phone_client_; }
+
+  void PrintRoster();
+  void MakeCallTo(const std::string& name);
+
+private:
+  typedef std::map<std::string,RosterItem> RosterMap;
+
+  buzz::XmppClient* xmpp_client_;
+  cricket::Thread* worker_thread_;
+  cricket::NetworkManager* network_manager_;
+  cricket::PortAllocator* port_allocator_;
+  cricket::SessionManager* session_manager_;
+  cricket::PhoneSessionClient* phone_client_;
+  cricket::Receiver* receiver_;
+  buzz::PresencePushTask* presence_push_;
+  RosterMap* roster_;
+
+  void OnStateChange(buzz::XmppEngine::State state);
+
+  void InitPhone();
+  void OnRequestSignaling();
+  void OnCallCreate(cricket::Call* call);
+  const std::string strerror(buzz::XmppEngine::Error err);
+  void OnSessionState(cricket::Call* call,
+                      cricket::Session* session,
+                      cricket::Session::State state);
+  void OnSendStanza(cricket::SessionClient *client, const buzz::XmlElement* stanza);
+
+  void InitPresence();
+  void OnStatusUpdate(const buzz::Status& status);
+};
+
+#endif // CRICKET_EXAMPLES_CALL_CALLCLIENT_H__
diff --git a/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/console.cc b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/console.cc
new file mode 100644
index 00000000..4150f281
--- /dev/null
+++ b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/console.cc
@@ -0,0 +1,196 @@
+/*
+ * Jingle call example
+ * Copyright 2004--2005, Google Inc.
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+extern "C" {
+#include <sys/types.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <ctype.h>
+}
+#include <cassert>
+#include <cstdio>
+#include <cstdlib>
+#include <cstdarg>
+
+#include "talk/examples/call/console.h"
+
+namespace {
+
+void PError(const char* desc) {
+  perror(desc);
+  exit(1);
+}
+
+CConsole* gConsole = NULL;
+
+const uint32 MSG_UPDATE = 1;
+
+} // namespace
+
+void InitConsole(cricket::PhysicalSocketServer* ss) {
+  assert(gConsole == NULL);
+  assert(ss);
+  gConsole = new CConsole(ss);
+}
+
+CConsole* Console() {
+  assert(gConsole);
+  return gConsole;
+}
+
+CConsole::CConsole(cricket::PhysicalSocketServer* ss)
+    : prompting_(false), prompt_dirty_(false) {
+  stdin_ = ss->CreateFile(0);
+  stdin_->SignalReadEvent.connect(this, &CConsole::OnReadInput);
+
+  tasks_ = new std::vector<ConsoleTask*>;
+}
+
+CConsole::~CConsole() {
+  delete stdin_;
+  delete tasks_;
+}
+
+void CConsole::Push(ConsoleTask* task) {
+  task->set_console(this);
+  task->SignalDone.connect(this, &CConsole::OnTaskDone);
+  tasks_->push_back(task);
+  task->Start();
+  UpdatePrompt();
+}
+
+void CConsole::Remove(ConsoleTask* task) {
+  int index = -1;
+  for (size_t i = 0; i < tasks_->size(); ++i) {
+    if ((*tasks_)[i] == task)
+      index = i;
+  }
+
+  assert(index >= 0);
+  tasks_->erase(tasks_->begin() + index);
+  if (static_cast<int>(tasks_->size()) == index)
+    UpdatePrompt();
+
+  delete task;
+
+  if (tasks_->size() == 0)
+    exit(0);
+}
+
+void CConsole::Print(const char* str) {
+  if (prompting_)
+    printf("\r");
+  printf("%s\n", str);
+  prompting_ = false;
+  UpdatePrompt();
+}
+
+void CConsole::Print(const std::string& str) {
+  Print(str.c_str());
+}
+
+void CConsole::Printf(const char* format, ...) {
+  va_list ap;
+  va_start(ap, format);
+
+  char buf[4096];
+  int size = vsnprintf(buf, sizeof(buf), format, ap);
+  assert(size >= 0);
+  assert(size < static_cast<int>(sizeof(buf)));
+  buf[size] = '\0';
+  Print(buf);
+
+  va_end(ap);
+}
+
+void CConsole::OnTaskDone(ConsoleTask* task) {
+  Remove(task);
+}
+
+void CConsole::OnReadInput(cricket::AsyncFile* file) {
+  assert(file == stdin_);
+
+  char buf[4096];
+  int size = read(0, buf, sizeof(buf));
+  if (size < 0)
+    PError("read");
+
+  prompting_ = (buf[size-1] != '\n');
+
+  int start = 0;
+  for (int i = 0; i < size; ++i) {
+    if (buf[i] == '\n') {
+      std::string line = input_;
+      line.append(buf + start, i + 1 - start);
+      input_.clear();
+
+      assert(tasks_->size() > 0);
+      tasks_->back()->ProcessLine(line);
+
+      start = i + 1;
+    }
+  }
+
+  input_.append(buf + start, size - start);
+}
+
+void CConsole::OnMessage(cricket::Message* pmsg) {
+  assert(pmsg->message_id == MSG_UPDATE);
+  assert(tasks_->size() > 0);
+  if (prompting_)
+    printf("\n");
+  printf("%s: %s", tasks_->back()->GetPrompt().c_str(), input_.c_str());
+  fflush(stdout);
+  prompting_ = true;
+  prompt_dirty_ = false;
+}
+
+void CConsole::UpdatePrompt() {
+  if (!prompt_dirty_) {
+    prompt_dirty_ = true;
+    cricket::Thread::Current()->Post(this, MSG_UPDATE);
+  }
+}
+
+void ConsoleTask::ParseLine(const std::string& line,
+                            std::vector<std::string>* words) {
+  assert(line.size() > 0);
+  assert(line[line.size() - 1] == '\n');
+
+  int start = -1;
+  int state = 0;
+  for (int index = 0; index <= static_cast<int>(line.size()); ++index) {
+    if (state == 0) {
+      if (!isspace(line[index])) {
+        start = index;
+        state = 1;
+      }
+    } else {
+      assert(state == 1);
+      assert(start >= 0);
+      if (isspace(line[index])) {
+        std::string word(line, start, index - start);
+        words->push_back(word);
+        start = -1;
+        state = 0;
+      }
+    }
+  }
+}
diff --git a/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/console.h b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/console.h
new file mode 100644
index 00000000..aca229b9
--- /dev/null
+++ b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/console.h
@@ -0,0 +1,82 @@
+/*
+ * Jingle call example
+ * Copyright 2004--2005, Google Inc.
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef CRICKET_EXAMPLES_CALL_CONSOLE_H__
+#define CRICKET_EXAMPLES_CALL_CONSOLE_H__
+
+#include <string>
+#include <vector>
+
+#include "talk/base/sigslot.h"
+#include "talk/base/thread.h"
+#include "talk/base/physicalsocketserver.h"
+
+class CConsole;
+
+class ConsoleTask {
+public:
+  ConsoleTask() : console_(NULL) {}
+  virtual ~ConsoleTask() {}
+
+  CConsole* console() const { return console_; } 
+  void set_console(CConsole* console) { console_ = console; }
+
+  virtual void Start() {}
+  virtual std::string GetPrompt() = 0;
+  virtual void ProcessLine(const std::string& line) = 0; // includes newline
+
+  sigslot::signal1<ConsoleTask*> SignalDone;
+
+protected:
+  void ParseLine(const std::string& line, std::vector<std::string>* words);
+
+private:
+  CConsole* console_;
+};
+
+class CConsole: public cricket::MessageHandler, public sigslot::has_slots<> {
+public:
+  CConsole(cricket::PhysicalSocketServer* ss);
+  ~CConsole();
+
+  void Push(ConsoleTask* task);
+  void Remove(ConsoleTask* task);
+
+  // final newline should not be included
+  void Print(const char* str);
+  void Print(const std::string& str);
+  void Printf(const char* format, ...);
+
+private:
+  cricket::AsyncFile* stdin_;
+  std::vector<ConsoleTask*>* tasks_;
+  std::string input_;
+  bool prompting_;
+  bool prompt_dirty_;
+
+  void OnTaskDone(ConsoleTask* task);
+  void OnReadInput(cricket::AsyncFile* file);
+  void OnMessage(cricket::Message* pmsg);
+  void UpdatePrompt();
+};
+
+void InitConsole(cricket::PhysicalSocketServer* ss);
+CConsole* Console();
+
+#endif // CRICKET_EXAMPLES_CALL_CONSOLE_H__
diff --git a/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/presenceouttask.cc b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/presenceouttask.cc
new file mode 100644
index 00000000..3ecdb420
--- /dev/null
+++ b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/presenceouttask.cc
@@ -0,0 +1,148 @@
+/*
+ * Jingle call example
+ * Copyright 2004--2005, Google Inc.
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <sstream>
+#include <time.h>
+#include "talk/xmpp/constants.h"
+#include "talk/xmpp/xmppclient.h"
+#include "talk/examples/call/presenceouttask.h"
+
+namespace buzz {
+
+// string helper functions -----------------------------------------------------
+template <class T> static
+bool FromString(const std::string& s,
+                 T * t) {
+  std::istringstream iss(s);
+  return !(iss>>*t).fail();
+}
+
+template <class T> static
+bool ToString(const T &t,
+               std::string* s) {
+  std::ostringstream oss;
+  oss << t;
+  *s = oss.str();
+  return !oss.fail();
+}
+
+XmppReturnStatus
+PresenceOutTask::Send(const Status & s) {
+  if (GetState() != STATE_INIT)
+    return XMPP_RETURN_BADSTATE;
+
+  stanza_.reset(TranslateStatus(s));
+  return XMPP_RETURN_OK;
+}
+
+XmppReturnStatus
+PresenceOutTask::SendDirected(const Jid & j, const Status & s) {
+  if (GetState() != STATE_INIT)
+    return XMPP_RETURN_BADSTATE;
+
+  XmlElement * presence = TranslateStatus(s);
+  presence->AddAttr(QN_TO, j.Str());
+  stanza_.reset(presence);
+  return XMPP_RETURN_OK;
+}
+
+XmppReturnStatus PresenceOutTask::SendProbe(const Jid & jid) {
+  if (GetState() != STATE_INIT)
+    return XMPP_RETURN_BADSTATE;
+
+  XmlElement * presence = new XmlElement(QN_PRESENCE);
+  presence->AddAttr(QN_TO, jid.Str());
+  presence->AddAttr(QN_TYPE, "probe");
+
+  stanza_.reset(presence);
+  return XMPP_RETURN_OK;
+}
+
+int
+PresenceOutTask::ProcessStart() {
+  if (SendStanza(stanza_.get()) != XMPP_RETURN_OK)
+    return STATE_ERROR;
+  return STATE_DONE;
+}
+
+XmlElement *
+PresenceOutTask::TranslateStatus(const Status & s) {
+  XmlElement * result = new XmlElement(QN_PRESENCE);
+  if (!s.available()) {
+    result->AddAttr(QN_TYPE, STR_UNAVAILABLE);
+  }
+  else {
+    if (s.invisible()) {
+      result->AddAttr(QN_TYPE, STR_INVISIBLE);
+    }
+
+    if (s.show() != Status::SHOW_ONLINE && s.show() != Status::SHOW_OFFLINE) {
+      result->AddElement(new XmlElement(QN_SHOW));
+      switch (s.show()) {
+        default:
+          result->AddText(STR_SHOW_AWAY, 1);
+          break;
+        case Status::SHOW_XA:
+          result->AddText(STR_SHOW_XA, 1);
+          break;
+        case Status::SHOW_DND:
+          result->AddText(STR_SHOW_DND, 1);
+          break;
+        case Status::SHOW_CHAT:
+          result->AddText(STR_SHOW_CHAT, 1);
+          break;
+      }
+    }
+
+    result->AddElement(new XmlElement(QN_STATUS));
+    result->AddText(s.status(), 1);
+
+    std::string pri;
+    ToString(s.priority(), &pri);
+
+    result->AddElement(new XmlElement(QN_PRIORITY));
+    result->AddText(pri, 1);
+
+    if (s.know_capabilities() && s.is_google_client()) {
+      result->AddElement(new XmlElement(QN_CAPS_C, true));
+      result->AddAttr(QN_NODE, GOOGLE_CLIENT_NODE, 1);
+      result->AddAttr(QN_VER, s.version(), 1);
+      result->AddAttr(QN_EXT, s.phone_capability() ? "voice-v1" : "", 1);
+    }
+
+    // Put the delay mark on the presence according to JEP-0091
+    {
+      result->AddElement(new XmlElement(kQnDelayX, true));
+
+      // This here is why we *love* the C runtime
+      time_t current_time_seconds;
+      time(&current_time_seconds);
+      struct tm* current_time = gmtime(&current_time_seconds);
+      char output[256];
+      strftime(output, ARRAY_SIZE(output), "%Y%m%dT%H:%M:%S", current_time);
+      result->AddAttr(kQnStamp, output, 1);
+    }
+
+  }
+
+  return result;
+}
+
+
+}
diff --git a/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/presenceouttask.h b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/presenceouttask.h
new file mode 100644
index 00000000..868bda59
--- /dev/null
+++ b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/presenceouttask.h
@@ -0,0 +1,46 @@
+/*
+ * Jingle call example
+ * Copyright 2004--2005, Google Inc.
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _PRESENCEOUTTASK_H_
+#define _PRESENCEOUTTASK_H_
+
+#include "talk/xmpp/xmppengine.h"
+#include "talk/xmpp/xmpptask.h"
+#include "talk/examples/call/status.h"
+
+namespace buzz {
+
+class PresenceOutTask : public XmppTask {
+public:
+  PresenceOutTask(Task * parent) : XmppTask(parent) {}
+  virtual ~PresenceOutTask() {}
+
+  XmppReturnStatus Send(const Status & s);
+  XmppReturnStatus SendDirected(const Jid & j, const Status & s);
+  XmppReturnStatus SendProbe(const Jid& jid);
+
+  virtual int ProcessStart();
+private:
+  XmlElement * TranslateStatus(const Status & s);
+  scoped_ptr<XmlElement> stanza_;
+};
+
+}
+
+#endif
diff --git a/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/presencepushtask.cc b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/presencepushtask.cc
new file mode 100644
index 00000000..d0543b99
--- /dev/null
+++ b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/presencepushtask.cc
@@ -0,0 +1,172 @@
+/*
+ * Jingle call example
+ * Copyright 2004--2005, Google Inc.
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "talk/examples/call/presencepushtask.h"
+#include "talk/xmpp/constants.h"
+#include <sstream>
+
+
+namespace buzz {
+
+// string helper functions -----------------------------------------------------
+template <class T> static
+bool FromString(const std::string& s,
+                 T * t) {
+  std::istringstream iss(s);
+  return !(iss>>*t).fail();
+}
+
+template <class T> static
+bool ToString(const T &t,
+               std::string* s) {
+  std::ostringstream oss;
+  oss << t;
+  *s = oss.str();
+  return !oss.fail();
+}
+
+static bool
+IsXmlSpace(int ch) {
+  return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
+}
+
+static bool
+ListContainsToken(const std::string & list, const std::string & token) {
+  size_t i = list.find(token);
+  if (i == std::string::npos || token.empty())
+    return false;
+  bool boundary_before = (i == 0 || IsXmlSpace(list[i - 1]));
+  bool boundary_after = (i == list.length() - token.length() || IsXmlSpace(list[i + token.length()]));
+  return boundary_before && boundary_after;
+}
+
+
+bool
+PresencePushTask::HandleStanza(const XmlElement * stanza) {
+  if (stanza->Name() != QN_PRESENCE)
+    return false;
+  if (stanza->HasAttr(QN_TYPE) && stanza->Attr(QN_TYPE) != STR_UNAVAILABLE)
+    return false;
+  QueueStanza(stanza);
+  return true;
+}
+
+static bool IsUtf8FirstByte(int c) {
+  return (((c)&0x80)==0) || // is single byte
+    ((unsigned char)((c)-0xc0)<0x3e); // or is lead byte
+}
+
+int
+PresencePushTask::ProcessStart() {
+  const XmlElement * stanza = NextStanza();
+  if (stanza == NULL)
+    return STATE_BLOCKED;
+  Status s;
+
+  s.set_jid(Jid(stanza->Attr(QN_FROM)));
+
+  if (stanza->Attr(QN_TYPE) == STR_UNAVAILABLE) {
+    s.set_available(false);
+    SignalStatusUpdate(s);
+  }
+  else {
+    s.set_available(true);
+    const XmlElement * status = stanza->FirstNamed(QN_STATUS);
+    if (status != NULL) {
+      s.set_status(status->BodyText());
+
+      // Truncate status messages longer than 300 bytes
+      if (s.status().length() > 300) {
+        size_t len = 300;
+
+        // Be careful not to split legal utf-8 chars in half
+        while (!IsUtf8FirstByte(s.status()[len]) && len > 0) {
+          len -= 1;
+        }
+        std::string truncated(s.status(), 0, len);
+        s.set_status(truncated);
+      }
+    }
+
+    const XmlElement * priority = stanza->FirstNamed(QN_PRIORITY);
+    if (priority != NULL) {
+      int pri;
+      if (FromString(priority->BodyText(), &pri)) {
+        s.set_priority(pri);
+      }
+    }
+
+    const XmlElement * show = stanza->FirstNamed(QN_SHOW);
+    if (show == NULL || show->FirstChild() == NULL) {
+      s.set_show(Status::SHOW_ONLINE);
+    }
+    else {
+      if (show->BodyText() == "away") {
+        s.set_show(Status::SHOW_AWAY);
+      }
+      else if (show->BodyText() == "xa") {
+        s.set_show(Status::SHOW_XA);
+      }
+      else if (show->BodyText() == "dnd") {
+        s.set_show(Status::SHOW_DND);
+      }
+      else if (show->BodyText() == "chat") {
+        s.set_show(Status::SHOW_CHAT);
+      }
+      else {
+        s.set_show(Status::SHOW_ONLINE);
+      }
+    }
+
+    const XmlElement * caps = stanza->FirstNamed(QN_CAPS_C);
+    if (caps != NULL) {
+      std::string node = caps->Attr(QN_NODE);
+      std::string ver = caps->Attr(QN_VER);
+      std::string exts = caps->Attr(QN_EXT);
+
+      s.set_know_capabilities(true);
+
+      if (node == GOOGLE_CLIENT_NODE) {
+        s.set_is_google_client(true);
+        s.set_version(ver);
+        if (ListContainsToken(exts, "voice-v1")) {
+          s.set_phone_capability(true);
+        }
+      }
+    }
+
+    const XmlElement* delay = stanza->FirstNamed(kQnDelayX);
+    if (delay != NULL) {
+      // Ideally we would parse this according to the Psuedo ISO-8601 rules
+      // that are laid out in JEP-0082:
+      // http://www.jabber.org/jeps/jep-0082.html
+      std::string stamp = delay->Attr(kQnStamp);
+      s.set_sent_time(stamp);
+    }
+
+    SignalStatusUpdate(s);
+  }
+
+  return STATE_START;
+}
+
+
+}
+
+
diff --git a/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/presencepushtask.h b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/presencepushtask.h
new file mode 100644
index 00000000..45bc9020
--- /dev/null
+++ b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/presencepushtask.h
@@ -0,0 +1,44 @@
+/*
+ * Jingle call example
+ * Copyright 2004--2005, Google Inc.
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _PRESENCEPUSHTASK_H_
+#define _PRESENCEPUSHTASK_H_
+
+#include "talk/xmpp/xmppengine.h"
+#include "talk/xmpp/xmpptask.h"
+#include "talk/base/sigslot.h"
+#include "talk/examples/call/status.h"
+
+namespace buzz {
+
+class PresencePushTask : public XmppTask {
+
+public:
+  PresencePushTask(Task * parent) : XmppTask(parent, XmppEngine::HL_TYPE) {}
+  virtual int ProcessStart();
+  sigslot::signal1<const Status &>SignalStatusUpdate;
+
+protected:
+  virtual bool HandleStanza(const XmlElement * stanza);
+};
+
+  
+}
+
+#endif
diff --git a/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/status.h b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/status.h
new file mode 100644
index 00000000..a1e76f62
--- /dev/null
+++ b/kopete/protocols/jabber/jingle/libjingle/talk/examples/call/status.h
@@ -0,0 +1,213 @@
+/*
+ * Jingle call example
+ * Copyright 2004--2005, Google Inc.
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#ifndef _STATUS_H_
+#define _STATUS_H_
+
+#include "talk/xmpp/jid.h"
+#include "talk/xmpp/constants.h"
+
+#define GOOGLE_CLIENT_NODE "http://www.google.com/xmpp/client/caps"
+
+namespace buzz {
+
+class Status {
+public:
+  Status() :
+    pri_(0),
+    show_(SHOW_NONE),
+    available_(false),
+    invisible_(false),
+    e_code_(0),
+    phone_capability_(false),
+    know_capabilities_(false),
+    is_google_client_(false),
+    feedback_probation_(false) {};
+
+  ~Status() {}
+
+  // These are arranged in "priority order", i.e., if we see
+  // two statuses at the same priority but with different Shows,
+  // we will show the one with the highest show in the following
+  // order.
+  enum Show {
+    SHOW_NONE     = 0,
+    SHOW_INVISIBLE = 1,
+    SHOW_OFFLINE  = 2,
+    SHOW_XA       = 3,
+    SHOW_AWAY     = 4,
+    SHOW_DND      = 5,
+    SHOW_ONLINE   = 6,
+    SHOW_CHAT     = 7,
+  };
+
+  const Jid & jid() const { return jid_; }
+  int priority() const { return pri_; }
+  Show show() const { return show_; }
+  const std::string & status() const { return status_; }
+  bool available() const { return available_ ; }
+  bool invisible() const { return invisible_; }
+  int error_code() const { return e_code_; }
+  const std::string & error_string() const { return e_str_; }
+  bool know_capabilities() const { return know_capabilities_; }
+  bool phone_capability() const { return phone_capability_; }
+  bool is_google_client() const { return is_google_client_; }
+  const std::string & version() const { return version_; }
+  bool feedback_probation() const { return feedback_probation_; }
+  const std::string& sent_time() const { return sent_time_; }
+
+  void set_jid(const Jid & jid) { jid_ = jid; }
+  void set_priority(int pri) { pri_ = pri; }
+  void set_show(Show show) { show_ = show; }
+  void set_status(const std::string & status) { status_ = status; }
+  void set_available(bool a) { available_ = a; }
+  void set_invisible(bool i) { invisible_ = i; }
+  void set_error(int e_code, const std::string e_str)
+      { e_code_ = e_code; e_str_ = e_str; }
+  void set_know_capabilities(bool f) { know_capabilities_ = f; }
+  void set_phone_capability(bool f) { phone_capability_ = f; }
+  void set_is_google_client(bool f) { is_google_client_ = f; }
+  void set_version(const std::string & v) { version_ = v; }
+  void set_feedback_probation(bool f) { feedback_probation_ = f; }
+  void set_sent_time(const std::string& time) { sent_time_ = time; }
+
+  void UpdateWith(const Status & new_value) {
+    if (!new_value.know_capabilities()) {
+       bool k = know_capabilities();
+       bool i = is_google_client();
+       bool p = phone_capability();
+       std::string v = version();
+
+       *this = new_value;
+
+       set_know_capabilities(k);
+       set_is_google_client(i);
+       set_phone_capability(p);
+       set_version(v);
+    }
+    else {
+      *this = new_value;
+    }
+  }
+
+  bool HasQuietStatus() const {
+    if (status_.empty())
+      return false;
+    return !(QuietStatus().empty());
+  }
+
+  // Knowledge of other clients' silly automatic status strings -
+  // Don't show these.
+  std::string QuietStatus() const {
+    if (jid_.resource().find("Psi") != std::string::npos) {
+      if (status_ == "Online" ||
+          status_.find("Auto Status") != std::string::npos)
+        return STR_EMPTY;
+    }
+    if (jid_.resource().find("Gaim") != std::string::npos) {
+      if (status_ == "Sorry, I ran out for a bit!")
+        return STR_EMPTY;
+    }
+    return TrimStatus(status_);
+  }
+
+  std::string ExplicitStatus() const {
+    std::string result = QuietStatus();
+    if (result.empty()) {
+      result = ShowStatus();
+    }
+    return result;
+  }
+
+  std::string ShowStatus() const {
+    std::string result;
+    if (!available()) {
+      result = "Offline";
+    }
+    else {
+      switch (show()) {
+        case SHOW_AWAY:
+        case SHOW_XA:
+          result = "Idle";
+          break;
+        case SHOW_DND:
+          result = "Busy";
+          break;
+        case SHOW_CHAT:
+          result = "Chatty";
+          break;
+        default:
+          result = "Available";
+          break;
+      }
+    }
+    return result;
+  }
+
+  static std::string TrimStatus(const std::string & st) {
+    std::string s(st);
+    int j = 0;
+    bool collapsing = true;
+    for (unsigned int i = 0; i < s.length(); i+= 1) {
+      if (s[i] <= ' ' && s[i] >= 0) {
+        if (collapsing) {
+          continue;
+        }
+        else {
+          s[j] = ' ';
+          j += 1;
+          collapsing = true;
+        }
+      }
+      else {
+        s[j] = s[i];
+        j += 1;
+        collapsing = false;
+      }
+    }
+    if (collapsing && j > 0) {
+      j -= 1;
+    }
+    s.erase(j, s.length());
+    return s;
+  }
+
+private:
+  Jid jid_;
+  int pri_;
+  Show show_;
+  std::string status_;
+  bool available_;
+  bool invisible_;
+  int e_code_;
+  std::string e_str_;
+  bool feedback_probation_;
+
+  // capabilities (valid only if know_capabilities_
+  bool know_capabilities_;
+  bool phone_capability_;
+  bool is_google_client_;
+  std::string version_;
+
+  std::string sent_time_; // from the jabber:x:delay element
+};
+
+}
+
+
+#endif