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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
// Copyright 2013 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 GOOGLE_APIS_GCM_GCM_CLIENT_H_
#define GOOGLE_APIS_GCM_GCM_CLIENT_H_
#include <map>
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "google_apis/gcm/base/gcm_export.h"
namespace base {
class TaskRunner;
}
namespace gcm {
// Interface that encapsulates the network communications with the Google Cloud
// Messaging server. This interface is not supposed to be thread-safe.
class GCM_EXPORT GCMClient {
public:
enum Result {
// Successful operation.
SUCCESS,
// Invalid parameter.
INVALID_PARAMETER,
// Previous asynchronous operation is still pending to finish. Certain
// operation, like register, is only allowed one at a time.
ASYNC_OPERATION_PENDING,
// Network socket error.
NETWORK_ERROR,
// Problem at the server.
SERVER_ERROR,
// Exceeded the specified TTL during message sending.
TTL_EXCEEDED,
// Other errors.
UNKNOWN_ERROR
};
// Message data consisting of key-value pairs.
typedef std::map<std::string, std::string> MessageData;
// Message to be delivered to the other party.
struct GCM_EXPORT OutgoingMessage {
OutgoingMessage();
~OutgoingMessage();
// Message ID.
std::string id;
// In seconds.
int time_to_live;
MessageData data;
};
// Message being received from the other party.
struct GCM_EXPORT IncomingMessage {
IncomingMessage();
~IncomingMessage();
MessageData data;
};
// The check-in info for the user. Returned by the server.
struct GCM_EXPORT CheckinInfo {
CheckinInfo() : android_id(0), secret(0) {}
bool IsValid() const { return android_id != 0 && secret != 0; }
void Reset() {
android_id = 0;
secret = 0;
}
uint64 android_id;
uint64 secret;
};
// A delegate interface that allows the GCMClient instance to interact with
// its caller, i.e. notifying asynchronous event.
class Delegate {
public:
// Called when the user has been checked in successfully or an error occurs.
// |checkin_info|: valid if the CheckIn(..) completed successfully.
// |result|: the type of the error if an error occured, success otherwise.
virtual void OnCheckInFinished(const CheckinInfo& checkin_info,
Result result) = 0;
// Called when the registration completed successfully or an error occurs.
// |app_id|: application ID.
// |registration_id|: non-empty if the registration completed successfully.
// |result|: the type of the error if an error occured, success otherwise.
virtual void OnRegisterFinished(const std::string& app_id,
const std::string& registration_id,
Result result) = 0;
// Called when the message is scheduled to send successfully or an error
// occurs.
// |app_id|: application ID.
// |message_id|: ID of the message being sent.
// |result|: the type of the error if an error occured, success otherwise.
virtual void OnSendFinished(const std::string& app_id,
const std::string& message_id,
Result result) = 0;
// Called when a message has been received.
// |app_id|: application ID.
// |message|: message received.
virtual void OnMessageReceived(const std::string& app_id,
const IncomingMessage& message) = 0;
// Called when some messages have been deleted from the server.
// |app_id|: application ID.
virtual void OnMessagesDeleted(const std::string& app_id) = 0;
// Called when a message failed to send to the server.
// |app_id|: application ID.
// |message_id|: ID of the message being sent.
// |result|: the type of the error if an error occured, success otherwise.
virtual void OnMessageSendError(const std::string& app_id,
const std::string& message_id,
Result result) = 0;
// Returns the checkin info associated with this user. The delegate class
// is expected to persist the checkin info that is provided by
// OnCheckInFinished.
virtual CheckinInfo GetCheckinInfo() const = 0;
// Called when the loading from the persistent store is done. The loading
// is triggered asynchronously when GCMClient is created.
virtual void OnLoadingCompleted() = 0;
// Returns a task runner for file operations that may block. This is used
// in writing to or reading from the persistent store.
virtual base::TaskRunner* GetFileTaskRunner() = 0;
};
// Returns the single instance. Multiple profiles share the same client
// that makes use of the same MCS connection.
static GCMClient* Get();
// Passes a mocked instance for testing purpose.
typedef GCMClient* (*TestingFactoryFunction)();
static void SetTestingFactory(TestingFactoryFunction factory);
// Sets the delegate to interact with related to a specific user.
// |username|: the username (email address) used to check in with the server.
// |delegate|: the delegate whose methods will be called asynchronously in
// response to events and messages.
virtual void SetUserDelegate(const std::string& username,
Delegate* delegate) = 0;
// Checks in the user to use GCM. If the device has not been checked in, it
// will be done first.
// |username|: the username (email address) used to check in with the server.
virtual void CheckIn(const std::string& username) = 0;
// Registers the application for GCM. Delegate::OnRegisterFinished will be
// called asynchronously upon completion.
// |username|: the username (email address) passed in CheckIn(..).
// |app_id|: application ID.
// |cert|: SHA-1 of public key of the application, in base16 format.
// |sender_ids|: list of IDs of the servers that are allowed to send the
// messages to the application. These IDs are assigned by the
// Google API Console.
virtual void Register(const std::string& username,
const std::string& app_id,
const std::string& cert,
const std::vector<std::string>& sender_ids) = 0;
// Unregisters the application from GCM when it is uninstalled.
// Delegate::OnUnregisterFinished will be called asynchronously upon
// completion.
// |username|: the username (email address) passed in CheckIn(..).
// |app_id|: application ID.
virtual void Unregister(const std::string& username,
const std::string& app_id) = 0;
// Sends a message to a given receiver. Delegate::OnSendFinished will be
// called asynchronously upon completion.
// |username|: the username (email address) passed in CheckIn(..).
// |app_id|: application ID.
// |receiver_id|: registration ID of the receiver party.
// |message|: message to be sent.
virtual void Send(const std::string& username,
const std::string& app_id,
const std::string& receiver_id,
const OutgoingMessage& message) = 0;
// Returns true if the loading from the persistent store is still in progress.
virtual bool IsLoading() const = 0;
protected:
virtual ~GCMClient() {}
};
} // namespace gcm
#endif // GOOGLE_APIS_GCM_GCM_CLIENT_H_
|
