1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
// Copyright (c) 2010 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef REMOTING_JINGLE_GLUE_JINGLE_CLIENT_H_
#define REMOTING_JINGLE_GLUE_JINGLE_CLIENT_H_
#include <string>
#include "base/lock.h"
#include "base/ref_counted.h"
#include "third_party/libjingle/source/talk/xmpp/xmppclient.h"
class MessageLoop;
class Task;
namespace talk_base {
class NetworkManager;
} // namespace talk_base
namespace buzz {
class PreXmppAuth;
} // namespace buzz
namespace cricket {
class BasicPortAllocator;
class SessionManager;
class TunnelSessionClient;
class SessionManagerTask;
class Session;
} // namespace cricket
namespace remoting {
class IqRequest;
class JingleThread;
class JingleClient : public base::RefCountedThreadSafe<JingleClient>,
public sigslot::has_slots<> {
public:
enum State {
START, // Initial state.
CONNECTING,
CONNECTED,
CLOSED,
};
class Callback {
public:
virtual ~Callback() {}
// Called when state of the connection is changed.
virtual void OnStateChange(JingleClient* client, State state) = 0;
};
// Creates a JingleClient object that executes on |thread|. This does not
// take ownership of |thread| and expects that the thread is started before
// the constructor is called, and only stopped after the JingleClient object
// has been destructed.
explicit JingleClient(JingleThread* thread);
virtual ~JingleClient();
// Starts the XMPP connection initialization. Must be called only once.
// |callback| specifies callback object for the client and must not be NULL.
void Init(const std::string& username, const std::string& auth_token,
const std::string& auth_token_service, Callback* callback);
// Closes XMPP connection and stops the thread. Must be called before the
// object is destroyed. If specified, |closed_task| is executed after the
// connection is successfully closed.
void Close();
void Close(Task* closed_task);
// Returns JID with resource ID. Empty string is returned if full JID is not
// known yet, i.e. authentication hasn't finished.
std::string GetFullJid();
// Creates new IqRequest for this client. Ownership for of the created object
// is transfered to the caller.
virtual IqRequest* CreateIqRequest();
// Current connection state of the client.
State state() { return state_; }
// Returns XmppClient object for the xmpp connection or NULL if not connected.
buzz::XmppClient* xmpp_client() { return client_; }
// Message loop used by this object to execute tasks.
MessageLoop* message_loop();
// The session manager used by this client. Must be called from the
// jingle thread only. Returns NULL if the client is not active.
cricket::SessionManager* session_manager();
private:
friend class HeartbeatSenderTest;
friend class JingleClientTest;
void OnConnectionStateChanged(buzz::XmppEngine::State state);
void DoInitialize(const std::string& username,
const std::string& auth_token,
const std::string& auth_token_service);
// Used by Close().
void DoClose();
void SetFullJid(const std::string& full_jid);
// Updates current state of the connection. Must be called only in
// the jingle thread.
void UpdateState(State new_state);
buzz::PreXmppAuth* CreatePreXmppAuth(
const buzz::XmppClientSettings& settings);
// JingleThread used for the connection. Set in the constructor.
JingleThread* thread_;
// Callback for this object. Callback must not be called if closed_ == true.
Callback* callback_;
// The XmppClient and its state and jid.
buzz::XmppClient* client_;
State state_;
Lock full_jid_lock_;
std::string full_jid_;
// Current state of the object.
Lock state_lock_; // Must be locked when accessing initialized_ or closed_.
bool initialized_;
bool closed_;
scoped_ptr<Task> closed_task_;
scoped_ptr<talk_base::NetworkManager> network_manager_;
scoped_ptr<cricket::BasicPortAllocator> port_allocator_;
scoped_ptr<cricket::SessionManager> session_manager_;
DISALLOW_COPY_AND_ASSIGN(JingleClient);
};
} // namespace remoting
#endif // REMOTING_JINGLE_GLUE_JINGLE_CLIENT_H_
|
