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
|
#ifndef WATCHDATAREADER_H
#define WATCHDATAREADER_H
#include "watchconnection.h"
#include <QByteArray>
#include <QtEndian>
#include <QString>
#include <QUuid>
#include <QMap>
class WatchDataReader {
public:
WatchDataReader(const QByteArray &data):
m_data(data)
{
}
template <typename T>
T read() {
if (checkBad(sizeof(T))) return 0;
const uchar *u = p();
m_offset += sizeof(T);
return qFromBigEndian<T>(u);
}
inline bool checkBad(int n = 0)
{
if (m_offset + n > m_data.size()) {
m_bad = true;
}
return m_bad;
}
inline const uchar * p()
{
return reinterpret_cast<const uchar *>(&m_data.constData()[m_offset]);
}
inline void skip(int n)
{
m_offset += n;
checkBad();
}
template <typename T>
inline T readLE()
{
if (checkBad(sizeof(T))) return 0;
const uchar *u = p();
m_offset += sizeof(T);
return qFromLittleEndian<T>(u);
}
QString readFixedString(int n)
{
if (checkBad(n)) return QString();
const char *u = &m_data.constData()[m_offset];
m_offset += n;
return QString::fromUtf8(u, strnlen(u, n));
}
QByteArray peek(int n) {
return m_data.left(m_offset + n).right(n);
}
QUuid readUuid()
{
if (checkBad(16)) return QString();
m_offset += 16;
return QUuid::fromRfc4122(m_data.mid(m_offset - 16, 16));
}
QByteArray readBytes(int n)
{
if (checkBad(n)) return QByteArray();
const char *u = &m_data.constData()[m_offset];
m_offset += n;
return QByteArray(u, n);
}
QMap<int, QVariant> readDict()
{
QMap<int, QVariant> d;
if (checkBad(1)) return d;
const int n = readLE<quint8>();
for (int i = 0; i < n; i++) {
if (checkBad(4 + 1 + 2)) return d;
const int key = readLE<qint32>(); // For some reason, this is little endian.
const int type = readLE<quint8>();
const int width = readLE<quint16>();
switch (type) {
case WatchConnection::DictItemTypeBytes:
d.insert(key, QVariant::fromValue(readBytes(width)));
break;
case WatchConnection::DictItemTypeString:
d.insert(key, QVariant::fromValue(readFixedString(width)));
break;
case WatchConnection::DictItemTypeUInt:
switch (width) {
case sizeof(quint8):
d.insert(key, QVariant::fromValue(readLE<quint8>()));
break;
case sizeof(quint16):
d.insert(key, QVariant::fromValue(readLE<quint16>()));
break;
case sizeof(quint32):
d.insert(key, QVariant::fromValue(readLE<quint32>()));
break;
default:
m_bad = true;
return d;
}
break;
case WatchConnection::DictItemTypeInt:
switch (width) {
case sizeof(qint8):
d.insert(key, QVariant::fromValue(readLE<qint8>()));
break;
case sizeof(qint16):
d.insert(key, QVariant::fromValue(readLE<qint16>()));
break;
case sizeof(qint32):
d.insert(key, QVariant::fromValue(readLE<qint32>()));
break;
default:
m_bad = true;
return d;
}
break;
default:
m_bad = true;
return d;
}
}
return d;
}
bool bad() const;
private:
QByteArray m_data;
int m_offset = 0;
bool m_bad = false;
};
#endif // WATCHDATAREADER_H
|
