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