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
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
|
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include "qnearfieldtarget.h"
#include "qnearfieldtarget_p.h"
#include "qndefmessage.h"
#include <QtCore/QString>
#include <QtCore/QUrl>
#include <QtCore/QDebug>
#include <QCoreApplication>
QT_BEGIN_NAMESPACE
QT_IMPL_METATYPE_EXTERN_TAGGED(QNearFieldTarget::RequestId, QNearFieldTarget__RequestId)
/*!
\class QNearFieldTarget
\brief The QNearFieldTarget class provides an interface for communicating with a target
device.
\ingroup connectivity-nfc
\inmodule QtNfc
\since 5.2
QNearFieldTarget provides a generic interface for communicating with an NFC target device.
Both NFC Forum devices and NFC Forum Tag targets are supported by this class. All target
specific classes subclass this class.
The type() function can be used to get the type of the target device. The uid() function
returns the unique identifier of the target. The AccessMethods flags returns from the
accessMethods() function can be tested to determine which access methods are supported by the
target.
If the target supports NdefAccess, hasNdefMessage() can be called to test if the target has a
stored NDEF message, readNdefMessages() and writeNdefMessages() functions can be used to get
and set the NDEF message.
If the target supports TagTypeSpecificAccess, sendCommand() can be used to send a single
proprietary command to the target and retrieve the response.
*/
/*!
\enum QNearFieldTarget::Type
This enum describes the type of tag the target is detected as.
\value ProprietaryTag An unidentified proprietary target tag.
\value NfcTagType1 An NFC tag type 1 target.
\value NfcTagType2 An NFC tag type 2 target.
\value NfcTagType3 An NFC tag type 3 target.
\value NfcTagType4 An NFC tag type 4 target. This value is used if the NfcTagType4
cannot be further refined by NfcTagType4A or NfcTagType4B below.
\value NfcTagType4A An NFC tag type 4 target based on ISO/IEC 14443-3A.
\value NfcTagType4B An NFC tag type 4 target based on ISO/IEC 14443-3B.
\value MifareTag A Mifare target.
*/
/*!
\enum QNearFieldTarget::AccessMethod
This enum describes the access methods a near field target supports.
\value UnknownAccess The target supports an unknown access type.
\value NdefAccess The target supports reading and writing NDEF messages using
readNdefMessages() and writeNdefMessages().
\value TagTypeSpecificAccess The target supports sending tag type specific commands using
sendCommand().
\value AnyAccess The target supports any of the known access types.
*/
/*!
\enum QNearFieldTarget::Error
This enum describes the error codes that a near field target reports.
\value NoError No error has occurred.
\value UnknownError An unidentified error occurred.
\value UnsupportedError The requested operation is unsupported by this near field
target.
\value TargetOutOfRangeError The target is no longer within range.
\value NoResponseError The target did not respond.
\value ChecksumMismatchError The checksum has detected a corrupted response.
\value InvalidParametersError Invalid parameters were passed to a tag type specific function.
\value ConnectionError Failed to connect to the target.
\value NdefReadError Failed to read NDEF messages from the target.
\value NdefWriteError Failed to write NDEF messages to the target.
\value CommandError Failed to send a command to the target.
\value TimeoutError The request could not be completed within the time
specified in waitForRequestCompleted().
*/
/*!
\fn void QNearFieldTarget::disconnected()
This signal is emitted when the near field target moves out of proximity.
*/
/*!
\fn void QNearFieldTarget::ndefMessageRead(const QNdefMessage &message)
This signal is emitted when a complete NDEF \a message has been read from the target.
\sa readNdefMessages()
*/
/*!
\fn void QNearFieldTarget::requestCompleted(const QNearFieldTarget::RequestId &id)
This signal is emitted when a request \a id completes.
\sa sendCommand()
*/
/*!
\fn void QNearFieldTarget::error(QNearFieldTarget::Error error, const QNearFieldTarget::RequestId &id)
This signal is emitted when an error occurs while processing request \a id. The \a error
parameter describes the error.
*/
/*!
\class QNearFieldTarget::RequestId
\inmodule QtNfc
\inheaderfile QNearFieldTarget
\brief A request id handle.
*/
/*!
Constructs a new invalid request id handle.
*/
QNearFieldTarget::RequestId::RequestId()
{
}
/*!
Constructs a new request id handle that is a copy of \a other.
*/
QNearFieldTarget::RequestId::RequestId(const RequestId &other)
: d(other.d)
{
}
/*!
\internal
*/
QNearFieldTarget::RequestId::RequestId(RequestIdPrivate *p)
: d(p)
{
}
/*!
Destroys the request id handle.
*/
QNearFieldTarget::RequestId::~RequestId()
{
}
/*!
Returns \c true if this is a valid request id; otherwise returns \c false.
*/
bool QNearFieldTarget::RequestId::isValid() const
{
return d;
}
/*!
Returns the current reference count of the request id.
*/
int QNearFieldTarget::RequestId::refCount() const
{
if (d)
return d->ref.loadRelaxed();
return 0;
}
/*!
\internal
*/
bool QNearFieldTarget::RequestId::operator<(const RequestId &other) const
{
return std::less<const RequestIdPrivate*>()(d.constData(), other.d.constData());
}
/*!
\internal
*/
bool QNearFieldTarget::RequestId::operator==(const RequestId &other) const
{
return d == other.d;
}
/*!
\internal
*/
bool QNearFieldTarget::RequestId::operator!=(const RequestId &other) const
{
return d != other.d;
}
/*!
Assigns a copy of \a other to this request id and returns a reference to this request id.
*/
QNearFieldTarget::RequestId &QNearFieldTarget::RequestId::operator=(const RequestId &other)
{
d = other.d;
return *this;
}
/*!
Constructs a new near field target with \a parent.
*/
QNearFieldTarget::QNearFieldTarget(QObject *parent)
: QNearFieldTarget(new QNearFieldTargetPrivate(this), parent)
{
}
/*!
Destroys the near field target.
*/
QNearFieldTarget::~QNearFieldTarget()
{
Q_D(QNearFieldTarget);
d->disconnect();
}
/*!
Returns the UID of the near field target.
\note On iOS, this function returns an empty QByteArray for
a near field target discovered using NdefAccess method.
\sa QNearFieldTarget::AccessMethod
*/
QByteArray QNearFieldTarget::uid() const
{
Q_D(const QNearFieldTarget);
return d->uid();
}
/*!
Returns the type of tag type of this near field target.
*/
QNearFieldTarget::Type QNearFieldTarget::type() const
{
Q_D(const QNearFieldTarget);
return d->type();
}
/*!
Returns the access methods supported by this near field target.
*/
QNearFieldTarget::AccessMethods QNearFieldTarget::accessMethods() const
{
Q_D(const QNearFieldTarget);
return d->accessMethods();
}
/*!
\since 5.9
Closes the connection to the target to enable communication with the target
from a different instance. The connection will also be closed, when the
QNearFieldTarget is destroyed. A connection to the target device is
(re)created to process a command or read/write a NDEF messages.
Returns \c true only if an existing connection was successfully closed;
otherwise returns \c false.
*/
bool QNearFieldTarget::disconnect()
{
Q_D(QNearFieldTarget);
return d->disconnect();
}
/*!
Returns \c true if at least one NDEF message is stored on the near field
target; otherwise returns \c false.
*/
bool QNearFieldTarget::hasNdefMessage()
{
Q_D(QNearFieldTarget);
return d->hasNdefMessage();
}
/*!
Starts reading NDEF messages stored on the near field target. Returns a request id which can
be used to track the completion status of the request. An invalid request id will be returned
if the target does not support reading NDEF messages.
An ndefMessageRead() signal will be emitted for each NDEF message. The requestCompleted()
signal will be emitted was all NDEF messages have been read. The error() signal is emitted if
an error occurs.
\note An attempt to read an NDEF message from a tag, that is in INITIALIZED
state as defined by NFC Forum, will fail with the \l NdefReadError, as the
tag is formatted to support NDEF but does not contain a message yet.
*/
QNearFieldTarget::RequestId QNearFieldTarget::readNdefMessages()
{
Q_D(QNearFieldTarget);
return d->readNdefMessages();
}
/*!
Writes the NDEF messages in \a messages to the target. Returns a request id which can be used
to track the completion status of the request. An invalid request id will be returned if the
target does not support reading NDEF messages.
The requestCompleted() signal will be emitted when the write operation completes
successfully; otherwise the error() signal is emitted.
*/
QNearFieldTarget::RequestId QNearFieldTarget::writeNdefMessages(const QList<QNdefMessage> &messages)
{
Q_D(QNearFieldTarget);
return d->writeNdefMessages(messages);
}
/*!
\since 5.9
Returns the maximum number of bytes that can be sent with sendCommand. 0 will
be returned if the target does not support sending tag type specific commands.
\sa sendCommand()
*/
int QNearFieldTarget::maxCommandLength() const
{
Q_D(const QNearFieldTarget);
return d->maxCommandLength();
}
/*!
Sends \a command to the near field target. Returns a request id which can be used to track the
completion status of the request. An invalid request id will be returned if the target does not
support sending tag type specific commands.
The requestCompleted() signal will be emitted on successful completion of the request;
otherwise the error() signal will be emitted.
Once the request completes successfully the response can be retrieved from the
requestResponse() function. The response of this request will be a QByteArray.
\sa requestCompleted(), waitForRequestCompleted()
*/
QNearFieldTarget::RequestId QNearFieldTarget::sendCommand(const QByteArray &command)
{
Q_D(QNearFieldTarget);
return d->sendCommand(command);
}
/*!
Waits up to \a msecs milliseconds for the request \a id to complete.
Returns \c true if the request completes successfully and the
requestCompeted() signal is emitted; otherwise returns \c false.
*/
bool QNearFieldTarget::waitForRequestCompleted(const RequestId &id, int msecs)
{
Q_D(QNearFieldTarget);
return d->waitForRequestCompleted(id, msecs);
}
/*!
Returns the decoded response for request \a id. If the request is unknown or has not yet been
completed an invalid QVariant is returned.
*/
QVariant QNearFieldTarget::requestResponse(const RequestId &id) const
{
Q_D(const QNearFieldTarget);
return d->requestResponse(id);
}
/*!
\internal
*/
QNearFieldTarget::QNearFieldTarget(QNearFieldTargetPrivate *backend, QObject *parent)
: QObject(parent), d_ptr(backend)
{
Q_D(QNearFieldTarget);
d->q_ptr = this;
d->setParent(this);
qRegisterMetaType<QNearFieldTarget::RequestId>();
qRegisterMetaType<QNearFieldTarget::Error>();
qRegisterMetaType<QNdefMessage>();
connect(d, &QNearFieldTargetPrivate::disconnected,
this, &QNearFieldTarget::disconnected);
connect(d, &QNearFieldTargetPrivate::ndefMessageRead,
this, &QNearFieldTarget::ndefMessageRead);
connect(d, &QNearFieldTargetPrivate::requestCompleted,
this, &QNearFieldTarget::requestCompleted);
connect(d, &QNearFieldTargetPrivate::error,
this, &QNearFieldTarget::error);
}
QT_END_NAMESPACE
#include "moc_qnearfieldtarget.cpp"
|