1 /*

     2  * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of "Eclipse Public License v1.0"

     6  * which accompanies this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description:

    15  *

    16  */

    17 

    18 // System include files

    19 

    20 // User include files

    21 #include "convergedmessageimpl.h"

    22 

    23 // ====================== LOCAL FUNCTIONS ========================

    24 

    25 

    26 // ====================== MEMBER FUNCTIONS =======================

    27 

    28 //----------------------------------------------------------------

    29 // ConvergedMessageImpl::ConvergedMessageImpl

    30 // @see header

    31 //----------------------------------------------------------------

    32 

    33 

    34 ConvergedMessageImpl::ConvergedMessageImpl(

    35         ConvergedMessage::MessageType messageType) :

    36     mSubject(QString()), mBodyText(QString()), mTimeStamp(0), mProperty(0x0),

    37         mMessageSubType(ConvergedMessage::None),

    38             mPriority(ConvergedMessage::Normal), mLocation(

    39                     ConvergedMessage::Delete), mDirection(

    40                     ConvergedMessage::Incoming), mSendingState(

    41                     ConvergedMessage::Unknown)

    42     {

    43     mMessageType = messageType;

    44     mId = new ConvergedMessageId();

    45     mFromAddress = new ConvergedMessageAddress();

    46     }

    47 

    48 //----------------------------------------------------------------

    49 // ConvergedMessageImpl::ConvergedMessageImpl

    50 // @see header

    51 //----------------------------------------------------------------

    52 ConvergedMessageImpl::ConvergedMessageImpl(const ConvergedMessageId &id) :

    53     mSubject(QString()), mBodyText(QString()), mTimeStamp(0), mProperty(0x0),

    54             mMessageType(ConvergedMessage::None), 

    55             mMessageSubType(ConvergedMessage::None),

    56             mPriority(ConvergedMessage::Normal), mLocation(

    57                     ConvergedMessage::Delete), mDirection(

    58                     ConvergedMessage::Incoming), mSendingState(

    59                     ConvergedMessage::Unknown)

    60     {

    61     mId = new ConvergedMessageId(id);

    62     mFromAddress = new ConvergedMessageAddress();

    63 

    64     }

    65 

    66 //----------------------------------------------------------------

    67 // ConvergedMessageImpl::ConvergedMessageImpl

    68 // @see header

    69 //----------------------------------------------------------------

    70 ConvergedMessageImpl::ConvergedMessageImpl(const ConvergedMessage& msg)

    71     {

    72     mId = new ConvergedMessageId(*msg.id());

    73     mSubject = QString(msg.subject());

    74     mBodyText = QString(msg.bodyText());

    75 

    76     int toCount = msg.toAddressList().count();

    77     for (int i = 0; i < toCount; i++)

    78         {

    79         ConvergedMessageAddress* address = new ConvergedMessageAddress(

    80                 msg.toAddressList().at(i)->address(), msg.toAddressList().at(

    81                         i)->alias());

    82         mToAddresses.append(address);

    83         }

    84 

    85     int ccCount = msg.ccAddressList().count();

    86     for (int i = 0; i < ccCount; i++)

    87         {

    88         ConvergedMessageAddress* address = new ConvergedMessageAddress(

    89                 msg.ccAddressList().at(i)->address(), msg.ccAddressList().at(

    90                         i)->alias());

    91         mCcAddresses.append(address);

    92         }

    93 

    94     int bccCount = msg.bccAddressList().count();

    95     for (int i = 0; i < bccCount; i++)

    96         {

    97         ConvergedMessageAddress* address = new ConvergedMessageAddress(

    98                 msg.bccAddressList().at(i)->address(),

    99                 msg.bccAddressList().at(i)->alias());

   100         mBccAddresses.append(address);

   101         }

   102 

   103     mFromAddress = new ConvergedMessageAddress(msg.fromAddress()->address(),

   104             msg.fromAddress()->alias());

   105 

   106     int attachmentsCount = msg.attachments().count();

   107     for (int i = 0; i < attachmentsCount; i++)

   108         {

   109         ConvergedMessageAttachment *attachment =

   110                 new ConvergedMessageAttachment(

   111                         msg.attachments().at(i)->filePath(),

   112                         msg.attachments().at(i)->attachmentType());

   113         mAttachments.append(attachment);

   114         }

   115 

   116     mTimeStamp = msg.timeStamp();

   117     mProperty = msg.properties();

   118     mMessageType = msg.messageType();

   119     mMessageSubType = msg.messageSubType();

   120     mPriority = msg.priority();

   121     mLocation = msg.location();

   122     mDirection = msg.direction();

   123     mSendingState = msg.sendingState();

   124     }

   125 

   126 //----------------------------------------------------------------

   127 // ConvergedMessageImpl::~ConvergedMessageImpl

   128 // @see header

   129 //----------------------------------------------------------------

   130 ConvergedMessageImpl::~ConvergedMessageImpl()

   131     {

   132     delete mId;

   133     delete mFromAddress;

   134     //delete arrays

   135     while (!mToAddresses.isEmpty())

   136         {

   137         delete mToAddresses.takeAt(0);

   138         }

   139 

   140     //clean cc

   141     while (!mCcAddresses.isEmpty())

   142         {

   143         delete mCcAddresses.takeAt(0);

   144         }

   145 

   146     //clean Bcc

   147     while (!mBccAddresses.isEmpty())

   148         {

   149         delete mBccAddresses.takeAt(0);

   150         }

   151 

   152     //clean attachment list

   153     while (!mAttachments.isEmpty())

   154         {

   155         delete mAttachments.takeFirst();

   156         }

   157     }

   158 

   159 //----------------------------------------------------------------

   160 // ConvergedMessageImpl::id

   161 // @see header

   162 //----------------------------------------------------------------

   163 ConvergedMessageId* ConvergedMessageImpl::id() const

   164     {

   165     return mId;

   166     }

   167 

   168 //----------------------------------------------------------------

   169 // ConvergedMessageImpl::setMessageId

   170 // @see header

   171 //----------------------------------------------------------------

   172 void ConvergedMessageImpl::setMessageId(ConvergedMessageId &id)

   173     {

   174 	mId->setId(id.getId());

   175     }

   176 

   177 //----------------------------------------------------------------

   178 // ConvergedMessageImpl::messageType

   179 // @see header

   180 //----------------------------------------------------------------

   181 ConvergedMessage::MessageType ConvergedMessageImpl::messageType() const

   182     {

   183     return ConvergedMessage::MessageType(mMessageType);

   184     }

   185 

   186 //----------------------------------------------------------------

   187 // ConvergedMessageImpl::setMessageType

   188 // @see header

   189 //----------------------------------------------------------------

   190 void ConvergedMessageImpl::setMessageType(ConvergedMessage::MessageType type)

   191     {

   192     mMessageType = type;

   193     }

   194 

   195 //----------------------------------------------------------------

   196 // ConvergedMessageImpl::messageType

   197 // @see header

   198 //----------------------------------------------------------------

   199 ConvergedMessage::MessageSubType ConvergedMessageImpl::messageSubType() const

   200     {

   201     return ConvergedMessage::MessageSubType(mMessageSubType);

   202     }

   203 

   204 //----------------------------------------------------------------

   205 // ConvergedMessageImpl::setMessageSubType

   206 // @see header

   207 //----------------------------------------------------------------

   208 void ConvergedMessageImpl::setMessageSubType(ConvergedMessage::MessageSubType type)

   209     {

   210     mMessageSubType = type;

   211     }

   212 

   213 //----------------------------------------------------------------

   214 // ConvergedMessageImpl::priority

   215 // @see header

   216 //----------------------------------------------------------------

   217 ConvergedMessage::Priority ConvergedMessageImpl::priority() const

   218     {

   219     return ConvergedMessage::Priority(mPriority);

   220     }

   221 

   222 //----------------------------------------------------------------

   223 // ConvergedMessageImpl::setPriority

   224 // @see header

   225 //----------------------------------------------------------------

   226 void ConvergedMessageImpl::setPriority(ConvergedMessage::Priority newPriority)

   227     {

   228     mPriority = newPriority;

   229     }

   230 

   231 //----------------------------------------------------------------

   232 // ConvergedMessageImpl::direction

   233 // @see header

   234 //----------------------------------------------------------------

   235 ConvergedMessage::Direction ConvergedMessageImpl::direction() const

   236     {

   237     return ConvergedMessage::Direction(mDirection);

   238     }

   239 

   240 //----------------------------------------------------------------

   241 // ConvergedMessageImpl::setDirection

   242 // @see header

   243 //----------------------------------------------------------------

   244 void ConvergedMessageImpl::setDirection(ConvergedMessage::Direction direction)

   245     {

   246     mDirection = direction;

   247     }

   248 

   249 //----------------------------------------------------------------

   250 // ConvergedMessageImpl::sendingState

   251 // @see header

   252 //----------------------------------------------------------------

   253 ConvergedMessage::SendingState ConvergedMessageImpl::sendingState() const

   254     {

   255     return ConvergedMessage::SendingState(mSendingState);

   256     }

   257 

   258 //----------------------------------------------------------------

   259 // ConvergedMessageImpl::setSendingState

   260 // @see header

   261 //----------------------------------------------------------------

   262 void ConvergedMessageImpl::setSendingState(

   263         ConvergedMessage::SendingState state)

   264     {

   265     mSendingState = state;

   266     }

   267 

   268 //----------------------------------------------------------------

   269 // ConvergedMessageImpl::isUnread

   270 // @see header

   271 //----------------------------------------------------------------

   272 bool ConvergedMessageImpl::isUnread() const

   273     {

   274     return mProperty & ConvergedMessage::Unread;

   275     }

   276 

   277 //----------------------------------------------------------------

   278 // ConvergedMessageImpl::hasAttachment

   279 // @see header

   280 //----------------------------------------------------------------

   281 bool ConvergedMessageImpl::hasAttachment() const

   282     {

   283     return mProperty & ConvergedMessage::Attachment;

   284     }

   285 

   286 //----------------------------------------------------------------

   287 // ConvergedMessageImpl::location

   288 // @see header

   289 //----------------------------------------------------------------

   290 ConvergedMessage::MessageLocation ConvergedMessageImpl::location() const

   291     {

   292     return ConvergedMessage::MessageLocation(mLocation);

   293     }

   294 

   295 //----------------------------------------------------------------

   296 // ConvergedMessageImpl::setLocation

   297 // @see header

   298 //----------------------------------------------------------------

   299 void ConvergedMessageImpl::setLocation(

   300         ConvergedMessage::MessageLocation location)

   301     {

   302     mLocation = location;

   303     }

   304 

   305 //----------------------------------------------------------------

   306 // ConvergedMessageImpl::setProperty

   307 // @see header

   308 //----------------------------------------------------------------

   309 void ConvergedMessageImpl::setProperty(

   310         ConvergedMessage::MessageProperty property)

   311     {

   312     // set the attribute to member attribute var 

   313     mProperty |= property;

   314     }

   315 

   316 //----------------------------------------------------------------

   317 // ConvergedMessageImpl::properties

   318 // @see header

   319 //----------------------------------------------------------------

   320 quint16 ConvergedMessageImpl::properties() const

   321     {

   322     return mProperty;

   323     }

   324 

   325 //----------------------------------------------------------------

   326 // ConvergedMessageImpl::subject

   327 // @see header

   328 //----------------------------------------------------------------

   329 const QString& ConvergedMessageImpl::subject() const

   330     {

   331     return mSubject;

   332     }

   333 

   334 //----------------------------------------------------------------

   335 // ConvergedMessageImpl::setSubject

   336 // @see header

   337 //----------------------------------------------------------------

   338 void ConvergedMessageImpl::setSubject(const QString &subject)

   339     {

   340     mSubject = subject;

   341     }

   342 

   343 //----------------------------------------------------------------

   344 // ConvergedMessageImpl::timeStamp

   345 // @see header

   346 //----------------------------------------------------------------

   347 qint64 ConvergedMessageImpl::timeStamp() const

   348     {

   349     return mTimeStamp;

   350     }

   351 

   352 //----------------------------------------------------------------

   353 // ConvergedMessageImpl::setTimeStamp

   354 // @see header

   355 //----------------------------------------------------------------

   356 void ConvergedMessageImpl::setTimeStamp(qint64 timeStamp)

   357     {

   358     mTimeStamp = timeStamp;

   359     }

   360 

   361 //----------------------------------------------------------------

   362 // ConvergedMessageImpl::setBodyText

   363 // @see header

   364 //----------------------------------------------------------------

   365 void ConvergedMessageImpl::setBodyText(const QString &bodyText)

   366     {

   367     mBodyText = bodyText;

   368     }

   369 

   370 //----------------------------------------------------------------

   371 // ConvergedMessageImpl::bodyText

   372 // @see header

   373 //----------------------------------------------------------------

   374 const QString& ConvergedMessageImpl::bodyText() const

   375     {

   376     return mBodyText;

   377     }

   378 

   379 //----------------------------------------------------------------

   380 // ConvergedMessageImpl::addToRecipient

   381 // @see header

   382 //----------------------------------------------------------------

   383 void ConvergedMessageImpl::addToRecipient(ConvergedMessageAddress &recipient)

   384     {

   385     ConvergedMessageAddress* address = new ConvergedMessageAddress();

   386     address->setAddress(recipient.address());

   387     address->setAlias(recipient.alias());

   388 

   389     mToAddresses.append(address);

   390     }

   391 //----------------------------------------------------------------

   392 // ConvergedMessageImpl::addToRecipients

   393 // @see header

   394 //----------------------------------------------------------------

   395 void ConvergedMessageImpl::addToRecipients(

   396         ConvergedMessageAddressList &recipients)

   397     {

   398     //recipient address is a To address

   399     mToAddresses.append(recipients);

   400     }

   401 //----------------------------------------------------------------

   402 // ConvergedMessageImpl::addCcRecipient

   403 // @see header

   404 //----------------------------------------------------------------

   405 void ConvergedMessageImpl::addCcRecipient(ConvergedMessageAddress &recipient)

   406     {

   407     ConvergedMessageAddress* address = new ConvergedMessageAddress();

   408     address->setAddress(recipient.address());

   409     address->setAlias(recipient.alias());

   410 

   411     mCcAddresses.append(address);

   412     }

   413 

   414 //----------------------------------------------------------------

   415 // ConvergedMessageImpl::addCcRecipients

   416 // @see header

   417 //----------------------------------------------------------------

   418 void ConvergedMessageImpl::addCcRecipients(

   419         ConvergedMessageAddressList &recipients)

   420     {

   421     //recipient address is a Cc address

   422     mCcAddresses.append(recipients);

   423     }

   424 //----------------------------------------------------------------

   425 // ConvergedMessageImpl::addBccRecipient

   426 // @see header

   427 //----------------------------------------------------------------

   428 void ConvergedMessageImpl::addBccRecipient(ConvergedMessageAddress &recipient)

   429     {

   430     ConvergedMessageAddress* address = new ConvergedMessageAddress();

   431     address->setAddress(recipient.address());

   432     address->setAlias(recipient.alias());

   433     mBccAddresses.append(address);

   434     }

   435 //----------------------------------------------------------------

   436 // ConvergedMessageImpl::addBccRecipients

   437 // @see header

   438 //----------------------------------------------------------------

   439 void ConvergedMessageImpl::addBccRecipients(

   440         ConvergedMessageAddressList &recipients)

   441     {

   442     //recipient address is a Bcc address

   443     mBccAddresses.append(recipients);

   444     }

   445 //----------------------------------------------------------------

   446 // ConvergedMessageImpl::addFromRecipient

   447 // @see header

   448 //----------------------------------------------------------------

   449 void ConvergedMessageImpl::addFromRecipient(

   450         ConvergedMessageAddress &recipient)

   451     {

   452     mFromAddress->setAddress(recipient.address());

   453     mFromAddress->setAlias(recipient.alias());

   454     }

   455 

   456 //----------------------------------------------------------------

   457 // ConvergedMessageImpl::toAddressArray

   458 // @see header

   459 //----------------------------------------------------------------

   460 const ConvergedMessageAddressList ConvergedMessageImpl::toAddressList() const

   461     {

   462     return mToAddresses;

   463     }

   464 

   465 //----------------------------------------------------------------

   466 // ConvergedMessageImpl::ccAddressArray

   467 // @see header

   468 //----------------------------------------------------------------

   469 const ConvergedMessageAddressList ConvergedMessageImpl::ccAddressList() const

   470     {

   471     return mCcAddresses;

   472     }

   473 

   474 //----------------------------------------------------------------

   475 // ConvergedMessageImpl::bccAddressArray

   476 // @see header

   477 //----------------------------------------------------------------

   478 const ConvergedMessageAddressList ConvergedMessageImpl::bccAddressList() const

   479     {

   480     return mBccAddresses;

   481     }

   482 

   483 //----------------------------------------------------------------

   484 // ConvergedMessageImpl::fromAddress

   485 // @see header

   486 //----------------------------------------------------------------

   487 ConvergedMessageAddress*

   488 ConvergedMessageImpl::fromAddress() const

   489     {

   490     return mFromAddress;

   491     }

   492 

   493 //----------------------------------------------------------------

   494 // ConvergedMessageImpl::attachments

   495 // @see header

   496 //----------------------------------------------------------------

   497 ConvergedMessageAttachmentList ConvergedMessageImpl::attachments() const

   498     {

   499     return mAttachments;

   500     }

   501 

   502 //----------------------------------------------------------------

   503 // ConvergedMessageImpl::addAttachments

   504 // @see header

   505 //----------------------------------------------------------------

   506 void ConvergedMessageImpl::addAttachments(

   507         ConvergedMessageAttachmentList attachmentList)

   508     {

   509     mAttachments.append(attachmentList);

   510 

   511     }

   512 

   513 //----------------------------------------------------------------

   514 // ConvergedMessageImpl::serialize

   515 // @see header

   516 //----------------------------------------------------------------

   517 void ConvergedMessageImpl::serialize(QDataStream &stream) const

   518     {

   519     // put into the stream

   520     mId->serialize(stream);

   521     stream << mSubject;

   522     stream << mBodyText;

   523     // to address

   524     stream << mToAddresses.count();

   525     for (int a = 0; a < mToAddresses.count(); ++a)

   526         {

   527         mToAddresses.at(a)->serialize(stream);

   528         }

   529 

   530     // cc address

   531     stream << mCcAddresses.count();

   532     for (int a = 0; a < mCcAddresses.count(); ++a)

   533         {

   534         mCcAddresses.at(a)->serialize(stream);

   535         }

   536 

   537     // bcc address

   538     stream << mBccAddresses.count();

   539     for (int a = 0; a < mBccAddresses.count(); ++a)

   540         {

   541         mBccAddresses.at(a)->serialize(stream);

   542         }

   543     // from address

   544     mFromAddress->serialize(stream);

   545 

   546     // attachment list

   547     stream << mAttachments.count();

   548     for (int a = 0; a < mAttachments.count(); a++)

   549         {

   550         mAttachments.at(a)->serialize(stream);

   551         }

   552 

   553     //timestamp convert to string and write

   554     QString timeStamp = QString::number(mTimeStamp);

   555     stream << timeStamp;

   556     stream << mProperty;

   557     stream << mMessageType;

   558     stream << mMessageSubType;

   559     stream << mPriority;

   560     stream << mLocation;

   561     stream << mDirection;

   562     stream << mSendingState;

   563     }

   564 

   565 //----------------------------------------------------------------

   566 // ConvergedMessageImpl::deserialize

   567 // @see header

   568 //----------------------------------------------------------------

   569 void ConvergedMessageImpl::deserialize(QDataStream &stream)

   570     {

   571     // get from the stream

   572     // put into the stream

   573     mId->deserialize(stream);

   574 

   575     stream >> mSubject;

   576     stream >> mBodyText;

   577 

   578     // to address

   579     int toAddressesCount = 0;

   580     stream >> toAddressesCount;

   581     for (int a = 0; a < toAddressesCount; ++a)

   582         {

   583         ConvergedMessageAddress* address = new ConvergedMessageAddress();

   584         address->deserialize(stream);

   585         mToAddresses.append(address);

   586         }

   587 

   588     // cc address

   589     int ccAddressesCount = 0;

   590     stream >> ccAddressesCount;

   591     for (int a = 0; a < ccAddressesCount; ++a)

   592         {

   593         ConvergedMessageAddress* address = new ConvergedMessageAddress();

   594         address->deserialize(stream);

   595         mCcAddresses.append(address);

   596         }

   597 

   598     // bcc address

   599     int bccAddressesCount = 0;

   600     stream >> bccAddressesCount;

   601     for (int a = 0; a < bccAddressesCount; ++a)

   602         {

   603         ConvergedMessageAddress* address = new ConvergedMessageAddress();

   604         address->deserialize(stream);

   605         mBccAddresses.append(address);

   606         }

   607 

   608     // from address	

   609 

   610     mFromAddress->deserialize(stream);

   611     // attachment list

   612     int attachmentsCount = 0;

   613     stream >> attachmentsCount;

   614     for (int a = 0; a < attachmentsCount; a++)

   615         {

   616         //create on heap and append to the list

   617         ConvergedMessageAttachment *attachment =

   618                 new ConvergedMessageAttachment();

   619         attachment->deserialize(stream);

   620         mAttachments.append(attachment);

   621         }

   622 

   623     //timestamp

   624     QString timeStamp;

   625     stream >> timeStamp;

   626     mTimeStamp = timeStamp.toUInt();

   627 

   628     //others

   629     stream >> mProperty;

   630     stream >> mMessageType;

   631     stream >> mMessageSubType;

   632     stream >> mPriority;

   633     stream >> mLocation;

   634     stream >> mDirection;

   635     stream >> mSendingState;

   636     }

   637 

   638 // eof

   639