|
1 /**************************************************************************** |
|
2 ** |
|
3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). |
|
4 ** All rights reserved. |
|
5 ** Contact: Nokia Corporation (qt-info@nokia.com) |
|
6 ** |
|
7 ** This file is part of the Qt Mobility Components. |
|
8 ** |
|
9 ** $QT_BEGIN_LICENSE:LGPL$ |
|
10 ** No Commercial Usage |
|
11 ** This file contains pre-release code and may not be distributed. |
|
12 ** You may use this file in accordance with the terms and conditions |
|
13 ** contained in the Technology Preview License Agreement accompanying |
|
14 ** this package. |
|
15 ** |
|
16 ** GNU Lesser General Public License Usage |
|
17 ** Alternatively, this file may be used under the terms of the GNU Lesser |
|
18 ** General Public License version 2.1 as published by the Free Software |
|
19 ** Foundation and appearing in the file LICENSE.LGPL included in the |
|
20 ** packaging of this file. Please review the following information to |
|
21 ** ensure the GNU Lesser General Public License version 2.1 requirements |
|
22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
|
23 ** |
|
24 ** In addition, as a special exception, Nokia gives you certain additional |
|
25 ** rights. These rights are described in the Nokia Qt LGPL Exception |
|
26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. |
|
27 ** |
|
28 ** If you have questions regarding the use of this file, please contact |
|
29 ** Nokia at qt-info@nokia.com. |
|
30 ** |
|
31 ** |
|
32 ** |
|
33 ** |
|
34 ** |
|
35 ** |
|
36 ** |
|
37 ** |
|
38 ** $QT_END_LICENSE$ |
|
39 ** |
|
40 ****************************************************************************/ |
|
41 #include "qmessagecontentcontainer.h" |
|
42 #include <QStringList> |
|
43 #include <QTextCodec> |
|
44 #include "qmessagecontentcontainer_symbian_p.h" |
|
45 #include <qmtmengine_symbian_p.h> |
|
46 #include <messagingutil_p.h> |
|
47 |
|
48 QTM_BEGIN_NAMESPACE |
|
49 |
|
50 QMessageContentContainer QMessageContentContainerPrivate::from(long int messageId, |
|
51 unsigned int attachmentId, |
|
52 QByteArray &name, |
|
53 QByteArray &mimeType, |
|
54 QByteArray &mimeSubType, |
|
55 int size) |
|
56 { |
|
57 QMessageContentContainer result; |
|
58 result.d_ptr->_containingMessageId = messageId; |
|
59 result.d_ptr->_attachmentId = attachmentId; |
|
60 result.d_ptr->_name = name; |
|
61 result.d_ptr->_type = mimeType; |
|
62 result.d_ptr->_subType = mimeSubType; |
|
63 result.d_ptr->_size = size; |
|
64 result.d_ptr->_available = true; |
|
65 return result; |
|
66 } |
|
67 |
|
68 QMessageContentContainerPrivate& QMessageContentContainerPrivate::operator=(const QMessageContentContainerPrivate &other) |
|
69 { |
|
70 q_ptr = other.q_ptr; |
|
71 _message = other._message; |
|
72 _available = other._available; |
|
73 _size = other._size; |
|
74 _attachments = other._attachments; |
|
75 _type = other._type; |
|
76 _subType = other._subType; |
|
77 _charset = other._charset; |
|
78 _name = other._name; |
|
79 _content = other._content; |
|
80 _textContent = other._textContent; |
|
81 _filename = other._filename; |
|
82 _messageId = other._messageId; |
|
83 _id = other._id; |
|
84 _header = other._header; |
|
85 _containingMessageId = other._containingMessageId; |
|
86 _attachmentId = other._attachmentId; |
|
87 |
|
88 return *this; |
|
89 } |
|
90 |
|
91 bool QMessageContentContainerPrivate::isMessage() const |
|
92 { |
|
93 return (_message != 0); |
|
94 } |
|
95 |
|
96 void QMessageContentContainerPrivate::setDerivedMessage(QMessage *derived) |
|
97 { |
|
98 _message = derived; |
|
99 } |
|
100 |
|
101 void QMessageContentContainerPrivate::clearContents() |
|
102 { |
|
103 _type = QByteArray("text"); |
|
104 _subType = QByteArray("plain"); |
|
105 _charset = QByteArray(); |
|
106 _name = QByteArray(); |
|
107 _content = QByteArray(); |
|
108 _textContent = QString(); |
|
109 _filename = QByteArray(); |
|
110 _available = false; |
|
111 _size = 0; |
|
112 _header.clear(); |
|
113 _attachments.clear(); |
|
114 _containingMessageId = 0; |
|
115 _attachmentId = 0; |
|
116 } |
|
117 |
|
118 void QMessageContentContainerPrivate::setContentType(const QByteArray &type, const QByteArray &subType, const QByteArray &charset) |
|
119 { |
|
120 clearContents(); |
|
121 |
|
122 _type = type; |
|
123 _subType = subType; |
|
124 _charset = charset; |
|
125 } |
|
126 |
|
127 void QMessageContentContainerPrivate::setContent(const QString &content, const QByteArray &type, const QByteArray &subType, const QByteArray &charset) |
|
128 { |
|
129 setContentType(type, subType, charset); |
|
130 |
|
131 _textContent = content; |
|
132 _size = content.size(); |
|
133 _available = true; |
|
134 } |
|
135 |
|
136 void QMessageContentContainerPrivate::setContent(const QByteArray &content, const QByteArray &type, const QByteArray &subType, const QByteArray &charset) |
|
137 { |
|
138 setContentType(type, subType, charset); |
|
139 |
|
140 _content = content; |
|
141 _available = true; |
|
142 } |
|
143 |
|
144 void QMessageContentContainerPrivate::setHeaderField(const QByteArray &name, const QByteArray &value) |
|
145 { |
|
146 _header.remove(name); |
|
147 _header.insert(name, value); |
|
148 } |
|
149 |
|
150 QMessageContentContainer* QMessageContentContainerPrivate::attachment(const QMessageContentContainerId &id) |
|
151 { |
|
152 if (isMessage()) { |
|
153 if (id == bodyContentId()) { |
|
154 return _message; |
|
155 } else { |
|
156 foreach (const QMessageContentContainer &container, _attachments) { |
|
157 if (container.d_ptr->_id == id) { |
|
158 return const_cast<QMessageContentContainer*>(&container); |
|
159 } |
|
160 } |
|
161 } |
|
162 } |
|
163 |
|
164 return 0; |
|
165 } |
|
166 |
|
167 const QMessageContentContainer* QMessageContentContainerPrivate::attachment(const QMessageContentContainerId &id) const |
|
168 { |
|
169 if (isMessage()) { |
|
170 if (id == bodyContentId()) { |
|
171 return _message; |
|
172 } else { |
|
173 foreach (const QMessageContentContainer &container, _attachments) { |
|
174 if (container.d_ptr->_id == id) { |
|
175 return &container; |
|
176 } |
|
177 } |
|
178 } |
|
179 } |
|
180 |
|
181 return 0; |
|
182 } |
|
183 |
|
184 bool QMessageContentContainerPrivate::createAttachment(const QString& attachmentPath) |
|
185 { |
|
186 //set the attachment data |
|
187 |
|
188 if (!QFile::exists(attachmentPath)) { |
|
189 return false; |
|
190 } |
|
191 |
|
192 QFile attachmentFile(attachmentPath); |
|
193 if (!attachmentFile.open(QIODevice::ReadOnly)) { |
|
194 return false; |
|
195 } |
|
196 |
|
197 _content = attachmentFile.readAll(); |
|
198 _available = true; |
|
199 |
|
200 _size = attachmentFile.size(); |
|
201 |
|
202 attachmentFile.close(); |
|
203 QFileInfo fi(attachmentPath); |
|
204 _name = fi.fileName().toLatin1(); |
|
205 |
|
206 //set the mime-type |
|
207 QByteArray mimeType; |
|
208 QString type; |
|
209 TBuf8<255> fileBuffer; |
|
210 RApaLsSession session; |
|
211 QString fileString = fi.fileName(); |
|
212 TPtrC16 filePtr(reinterpret_cast<const TUint16*>(fileString.utf16())); |
|
213 TBuf8<20> fileType; |
|
214 TPtrC8 ptr8((TUint8 *)(_content.constData()), _content.length()); |
|
215 if(session.Connect() == KErrNone){ |
|
216 TDataRecognitionResult fileDataType; |
|
217 session.RecognizeData(filePtr, ptr8, fileDataType); |
|
218 fileType.Copy(fileDataType.iDataType.Des8()); |
|
219 mimeType = QByteArray((const char*)fileType.Ptr(), fileType.Length()); |
|
220 session.Close(); |
|
221 } |
|
222 |
|
223 QString extension(fi.suffix()); |
|
224 int index = mimeType.indexOf("/"); |
|
225 if (index != -1) { |
|
226 _type = mimeType.left(index).trimmed(); |
|
227 _subType = mimeType.mid(index + 1).trimmed(); |
|
228 } |
|
229 |
|
230 // set the whole filepath to _filename |
|
231 _filename = fi.filePath().toLatin1(); |
|
232 |
|
233 return true; |
|
234 } |
|
235 |
|
236 QMessageContentContainerId QMessageContentContainerPrivate::appendContent(QMessageContentContainer& container) |
|
237 { |
|
238 container.d_ptr->_id = QMessageContentContainerId(SymbianHelpers::addIdPrefix(QString::number(_attachments.count()+1),SymbianHelpers::EngineTypeMTM)); |
|
239 _attachments.append(container); |
|
240 return container.d_ptr->_id; |
|
241 } |
|
242 |
|
243 QMessageContentContainerId QMessageContentContainerPrivate::prependContent(QMessageContentContainer& container) |
|
244 { |
|
245 _attachments.prepend(container); |
|
246 for (int i = 0; i < _attachments.count(); ++i) { |
|
247 _attachments[i].d_ptr->_id = QMessageContentContainerId(SymbianHelpers::addIdPrefix(QString::number(i+1),SymbianHelpers::EngineTypeMTM)); |
|
248 } |
|
249 return _attachments[0].d_ptr->_id; |
|
250 } |
|
251 |
|
252 |
|
253 |
|
254 QMessageContentContainerId QMessageContentContainerPrivate::bodyContentId() |
|
255 { |
|
256 return QMessageContentContainerId(SymbianHelpers::addIdPrefix(QString::number(0),SymbianHelpers::EngineTypeMTM)); |
|
257 } |
|
258 |
|
259 QByteArray QMessageContentContainerPrivate::attachmentFilename(const QMessageContentContainer& container) |
|
260 { |
|
261 return container.d_ptr->_filename; |
|
262 } |
|
263 |
|
264 QMessageContentContainerPrivate* QMessageContentContainerPrivate::implementation(const QMessageContentContainer &container) |
|
265 { |
|
266 return container.d_ptr; |
|
267 } |
|
268 |
|
269 QMessageContentContainer::QMessageContentContainer() |
|
270 : d_ptr(new QMessageContentContainerPrivate(this)) |
|
271 { |
|
272 } |
|
273 |
|
274 QMessageContentContainer::QMessageContentContainer(const QMessageContentContainer &other) |
|
275 : d_ptr(new QMessageContentContainerPrivate(this)) |
|
276 { |
|
277 this->operator=(other); |
|
278 } |
|
279 |
|
280 QMessageContentContainer& QMessageContentContainer::operator=(const QMessageContentContainer& other) |
|
281 { |
|
282 if (&other != this) { |
|
283 *d_ptr = *other.d_ptr; |
|
284 } |
|
285 |
|
286 return *this; |
|
287 } |
|
288 |
|
289 QMessageContentContainer::~QMessageContentContainer() |
|
290 { |
|
291 delete d_ptr; |
|
292 } |
|
293 |
|
294 QByteArray QMessageContentContainer::contentType() const |
|
295 { |
|
296 return d_ptr->_type; |
|
297 } |
|
298 |
|
299 QByteArray QMessageContentContainer::contentSubType() const |
|
300 { |
|
301 return d_ptr->_subType; |
|
302 } |
|
303 |
|
304 QByteArray QMessageContentContainer::contentCharset() const |
|
305 { |
|
306 return d_ptr->_charset; |
|
307 } |
|
308 |
|
309 QByteArray QMessageContentContainer::suggestedFileName() const |
|
310 { |
|
311 return d_ptr->_name; |
|
312 } |
|
313 |
|
314 bool QMessageContentContainer::isContentAvailable() const |
|
315 { |
|
316 return d_ptr->_available; |
|
317 } |
|
318 |
|
319 int QMessageContentContainer::size() const |
|
320 { |
|
321 return d_ptr->_size; |
|
322 } |
|
323 |
|
324 QString QMessageContentContainer::textContent() const |
|
325 { |
|
326 if (d_ptr->_textContent.isEmpty() && d_ptr->_attachmentId != 0) { |
|
327 CMTMEngine* mtmEngine = CMTMEngine::instance(); |
|
328 const_cast<QString&>(d_ptr->_textContent) = mtmEngine->attachmentTextContent(d_ptr->_containingMessageId, d_ptr->_attachmentId, d_ptr->_charset); |
|
329 } |
|
330 if (!d_ptr->_textContent.isEmpty()) { |
|
331 return d_ptr->_textContent; |
|
332 } |
|
333 |
|
334 QTextCodec *codec = QTextCodec::codecForName(d_ptr->_charset.data()); |
|
335 if (codec) { |
|
336 return codec->toUnicode(d_ptr->_content); |
|
337 } else { |
|
338 return QString::fromLatin1(d_ptr->_content); |
|
339 } |
|
340 } |
|
341 |
|
342 QByteArray QMessageContentContainer::content() const |
|
343 { |
|
344 if (d_ptr->_content.isEmpty() && d_ptr->_attachmentId != 0) { |
|
345 CMTMEngine* mtmEngine = CMTMEngine::instance(); |
|
346 const_cast<QByteArray&>(d_ptr->_content) = mtmEngine->attachmentContent(d_ptr->_containingMessageId, d_ptr->_attachmentId); |
|
347 } |
|
348 |
|
349 return d_ptr->_content; |
|
350 } |
|
351 |
|
352 void QMessageContentContainer::writeTextContent(QTextStream& out) const |
|
353 { |
|
354 out << textContent(); |
|
355 } |
|
356 |
|
357 void QMessageContentContainer::writeContent(QDataStream& out) const |
|
358 { |
|
359 QByteArray data(content()); |
|
360 out.writeRawData(data.constData(), data.length()); |
|
361 } |
|
362 |
|
363 QMessageContentContainerIdList QMessageContentContainer::contentIds() const |
|
364 { |
|
365 QMessageContentContainerIdList ids; |
|
366 |
|
367 if (d_ptr->isMessage()) { |
|
368 foreach (const QMessageContentContainer &container, d_ptr->_attachments) { |
|
369 ids.append(container.d_ptr->_id); |
|
370 } |
|
371 } |
|
372 |
|
373 return ids; |
|
374 } |
|
375 |
|
376 QMessageContentContainer QMessageContentContainer::find(const QMessageContentContainerId &id) const |
|
377 { |
|
378 if (d_ptr->isMessage()) { |
|
379 if (const QMessageContentContainer *container = d_ptr->attachment(id)) { |
|
380 return *container; |
|
381 } |
|
382 } |
|
383 |
|
384 return QMessageContentContainer(); |
|
385 } |
|
386 |
|
387 bool QMessageContentContainer::contains(const QMessageContentContainerId &id) const |
|
388 { |
|
389 if (d_ptr->isMessage()) { |
|
390 return (d_ptr->attachment(id) != 0); |
|
391 } |
|
392 |
|
393 return false; |
|
394 } |
|
395 |
|
396 QString QMessageContentContainer::headerFieldValue(const QByteArray &name) const |
|
397 { |
|
398 QMultiMap<QByteArray, QString>::const_iterator it = d_ptr->_header.find(name); |
|
399 if (it != d_ptr->_header.end()) { |
|
400 return it.value(); |
|
401 } |
|
402 |
|
403 return QString(); |
|
404 } |
|
405 |
|
406 QStringList QMessageContentContainer::headerFieldValues(const QByteArray &name) const |
|
407 { |
|
408 QStringList values; |
|
409 |
|
410 QMultiMap<QByteArray, QString>::const_iterator it = d_ptr->_header.find(name); |
|
411 while ((it != d_ptr->_header.end()) && (it.key() == name)) { |
|
412 values.append(it.value()); |
|
413 ++it; |
|
414 } |
|
415 |
|
416 return values; |
|
417 } |
|
418 |
|
419 QList<QByteArray> QMessageContentContainer::headerFields() const |
|
420 { |
|
421 return d_ptr->_header.keys(); |
|
422 } |
|
423 |
|
424 void QMessageContentContainer::setDerivedMessage(QMessage *derived) |
|
425 { |
|
426 d_ptr->setDerivedMessage(derived); |
|
427 } |
|
428 |
|
429 QTM_END_NAMESPACE |