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 INCLUDES

    19 #include <e32cmn.h>

    20 #include <mtclreg.h>

    21 #include <mtclbase.h>

    22 #include <msvids.h>

    23 #include <txtetext.h>

    24 #include <txtrich.h>

    25 #include <txtfmlyr.h>

    26 #include <badesca.h>

    27 #include <eikrted.h>

    28 #include <mmsclient.h>

    29 #include <mmssettings.h>

    30 #include <mmsheaders.h>

    31 #include <MsgMediaInfo.h>

    32 #include <MsgMediaResolver.h>

    33 #include <QDateTime>

    34 

    35 #include "convergedmessage.h"

    36 #include "s60qconversions.h"

    37 #include "convergedmessageaddress.h"

    38 #include "unimmsdataplugin_p.h"

    39 #include "debugtraces.h"

    40 

    41 

    42 #define KSenduiMtmMmsUidValue 0x100058E1

    43 const TUid KSenduiMtmMmsUid = {KSenduiMtmMmsUidValue};

    44 

    45 _LIT(KUnixEpoch, "19700000:000000.000000");

    46 

    47 

    48 UniMMSDataPluginPrivate::UniMMSDataPluginPrivate():

    49     mSession(NULL),

    50     mMtmRegistry(NULL),

    51     mUniDataModel(NULL),

    52     mMmsClient(NULL)

    53     {

    54     done = EFalse;

    55     mSession = CMsvSession::OpenSyncL(*this);

    56     }

    57 

    58 void UniMMSDataPluginPrivate::initL()

    59 {

    60     mMtmRegistry = CClientMtmRegistry::NewL(*mSession);

    61     mMmsClient = static_cast<CMmsClientMtm*> (mMtmRegistry->NewMtmL(KSenduiMtmMmsUid));

    62     User::LeaveIfError(mfsSession.Connect());

    63     iMessageId = 0;

    64 }

    65 

    66 UniMMSDataPluginPrivate::~UniMMSDataPluginPrivate()

    67 {

    68    if(mUniDataModel)

    69     {

    70         delete mUniDataModel;

    71     }

    72     mfsSession.Close();

    73     delete mMmsClient;

    74     delete mMtmRegistry;

    75     delete mSession;

    76 }

    77 

    78 int UniMMSDataPluginPrivate::setMessageId(int messageId)

    79 {

    80     TInt error = KErrNone;

    81     TRAP(error, setMessageIdL(messageId));

    82     return error;

    83 }

    84 

    85 void UniMMSDataPluginPrivate::setMessageIdL(int messageId)

    86 {

    87     if (done == EFalse)

    88     {

    89         initL();

    90     }

    91 

    92     if (iMessageId != messageId)

    93     {

    94         if (done)

    95         {

    96             reset();

    97         }

    98         done = ETrue;

    99         iMessageId = messageId;

   100         mMmsClient->SwitchCurrentEntryL(iMessageId);

   101         mMmsClient->LoadMessageL();

   102         mUniDataModel = CUniDataModel::NewL(mfsSession, *mMmsClient);

   103         mUniDataModel->RestoreL(*this, EFalse);

   104     }

   105 }

   106 

   107 void UniMMSDataPluginPrivate::reset()

   108 {

   109     delete mUniDataModel;

   110     mUniDataModel = NULL;

   111 }

   112 

   113 void UniMMSDataPluginPrivate::body(QString& aBodyText)

   114 {

   115 

   116     CRichText& textBody = mMmsClient->Body();

   117     TInt len = textBody.DocumentLength();

   118     HBufC* buf = HBufC::NewL(len);

   119     TPtr bufPtr = buf->Des();

   120     aBodyText = S60QConversions::s60DescToQString(bufPtr);

   121 }

   122 

   123 int UniMMSDataPluginPrivate::messageSize()

   124 {

   125     return mMmsClient->MessageSize();

   126 }

   127 

   128 

   129 QString UniMMSDataPluginPrivate::subject()

   130 {

   131    TPtrC sub =  mMmsClient->SubjectL();

   132    return S60QConversions::s60DescToQString(sub);

   133 }

   134 

   135 

   136 

   137 

   138 void UniMMSDataPluginPrivate::toRecipientList(

   139     ConvergedMessageAddressList& mAddressList)

   140 {

   141     CMsvEntry* cEntry = mSession->GetEntryL(KMsvGlobalInBoxIndexEntryIdValue);

   142     CleanupStack::PushL(cEntry);

   143     TRAPD (error, cEntry->SetEntryL( iMessageId ));

   144     if (error != KErrNone)

   145     {

   146         CleanupStack::PopAndDestroy(); // cEntry

   147         return;

   148     }

   149     CMsvStore* store = cEntry->ReadStoreL();

   150     CleanupStack::PushL(store);

   151     CMmsSettings* settings = CMmsSettings::NewL();

   152     CleanupStack::PushL(settings);

   153     CMmsHeaders* mmsHeaders = CMmsHeaders::NewL(settings->MmsVersion());

   154     CleanupStack::PushL(mmsHeaders);

   155     mmsHeaders->RestoreL(*store);

   156     TPtrC name;

   157     TPtrC address;

   158     TPtrC to;

   159     for (TInt id = 0; id < mmsHeaders->ToRecipients().MdcaCount(); id++)

   160     {

   161         to.Set( (mmsHeaders->ToRecipients())[id]);

   162         extractNameAndAddress(to, name, address);

   163         // populate address

   164         ConvergedMessageAddress

   165         * messageAddress =

   166             new ConvergedMessageAddress(S60QConversions::s60DescToQString(address),

   167                 S60QConversions::s60DescToQString(name));

   168         mAddressList.append(messageAddress);

   169     }

   170 

   171     CleanupStack::PopAndDestroy(3); //  mmsHeaders, settings, store

   172 

   173     CleanupStack::PopAndDestroy(); // cEntry

   174 }

   175 

   176 void UniMMSDataPluginPrivate::ccRecipientList(

   177     ConvergedMessageAddressList& mAddressList)

   178 {

   179     CMsvEntry* cEntry = mSession->GetEntryL(KMsvGlobalInBoxIndexEntryIdValue);

   180     CleanupStack::PushL(cEntry);

   181     TRAPD (error, cEntry->SetEntryL( iMessageId ));

   182     if (error != KErrNone)

   183     {

   184         CleanupStack::PopAndDestroy(); // cEntry

   185         return;

   186     }

   187     CMsvStore* store = cEntry->ReadStoreL();

   188     CleanupStack::PushL(store);

   189     CMmsSettings* settings = CMmsSettings::NewL();

   190     CleanupStack::PushL(settings);

   191     CMmsHeaders* mmsHeaders = CMmsHeaders::NewL(settings->MmsVersion());

   192     CleanupStack::PushL(mmsHeaders);

   193     mmsHeaders->RestoreL(*store);

   194     //CDesCArray& ccList = mmsHeaders->CcRecipients();

   195 

   196     TPtrC cc;

   197     TPtrC name;

   198     TPtrC address;

   199     for (TInt id = 0; id < mmsHeaders->CcRecipients().MdcaCount(); id++)

   200     {

   201         cc.Set( (mmsHeaders->CcRecipients())[id]);

   202         extractNameAndAddress(cc, name, address);

   203         // populate address

   204         ConvergedMessageAddress

   205         * messageAddress =

   206             new ConvergedMessageAddress(S60QConversions::s60DescToQString(address),

   207                 S60QConversions::s60DescToQString(name));

   208         mAddressList.append(messageAddress);

   209     }

   210 

   211     CleanupStack::PopAndDestroy(3); //  mmsHeaders, settings, store

   212 

   213     CleanupStack::PopAndDestroy(); // cEntry

   214 }

   215 

   216 void UniMMSDataPluginPrivate::bccRecipientList(

   217     ConvergedMessageAddressList& mAddressList)

   218 {

   219     CMsvEntry* cEntry = mSession->GetEntryL(KMsvGlobalInBoxIndexEntryIdValue);

   220     CleanupStack::PushL(cEntry);

   221     TRAPD (error, cEntry->SetEntryL( iMessageId ));

   222     if (error != KErrNone)

   223     {

   224         CleanupStack::PopAndDestroy(); // cEntry

   225         return;

   226     }

   227     CMsvStore* store = cEntry->ReadStoreL();

   228     CleanupStack::PushL(store);

   229     CMmsSettings* settings = CMmsSettings::NewL();

   230     CleanupStack::PushL(settings);

   231     CMmsHeaders* mmsHeaders = CMmsHeaders::NewL(settings->MmsVersion());

   232     CleanupStack::PushL(mmsHeaders);

   233     mmsHeaders->RestoreL(*store);

   234     //CDesCArray& bccList = mmsHeaders->BccRecipients();

   235 

   236     TPtrC bcc;

   237     TPtrC name;

   238     TPtrC address;

   239     for (TInt id = 0; id < mmsHeaders->BccRecipients().MdcaCount(); id++)

   240     {

   241         bcc.Set( (mmsHeaders->BccRecipients())[id]);

   242         extractNameAndAddress(bcc, name, address);

   243         // populate address

   244         ConvergedMessageAddress

   245         * messageAddress =

   246             new ConvergedMessageAddress(S60QConversions::s60DescToQString(address),

   247                 S60QConversions::s60DescToQString(name));

   248         mAddressList.append(messageAddress);

   249     }

   250 

   251     CleanupStack::PopAndDestroy(3); //  mmsHeaders, settings, store

   252 

   253     CleanupStack::PopAndDestroy(); // cEntry

   254 }

   255 

   256 void UniMMSDataPluginPrivate::fromAddress(QString& messageAddress)

   257 {

   258 

   259     TPtrC sender = mMmsClient->Sender();

   260     messageAddress = S60QConversions::s60DescToQString(sender);

   261 }

   262 

   263 UniMessageInfoList UniMMSDataPluginPrivate::attachmentList()

   264 {

   265     UniMessageInfoList attlist;

   266     int attcount = mUniDataModel->AttachmentList().Count();

   267 

   268     QString path;

   269     QString mimetype;

   270     int size;

   271     for (int i = 0; i < attcount; i++)

   272     {

   273         CUniObject *obj = mUniDataModel->AttachmentList().GetByIndex(i);

   274 

   275         mimetype = S60QConversions::s60Desc8ToQString(obj->MimeType());

   276         path

   277         = S60QConversions::s60DescToQString(obj->MediaInfo()->FullFilePath());

   278         size = obj->Size(EFalse);

   279 

   280         UniMessageInfo *msgobj = new UniMessageInfo(path, size, mimetype);

   281         attlist << msgobj;

   282     }

   283 

   284     return attlist;

   285 }

   286 

   287 QString UniMMSDataPluginPrivate::messageType()

   288 {

   289     QString str("mms");

   290     return str;

   291 }

   292 

   293 MsgPriority UniMMSDataPluginPrivate::messagePriority()

   294 {

   295     return Normal;

   296 }

   297 

   298 int UniMMSDataPluginPrivate::attachmentCount()

   299 {

   300     return mUniDataModel->AttachmentList().Count();

   301 }

   302 

   303 bool UniMMSDataPluginPrivate::hasAttachment()

   304 {

   305     int count = mUniDataModel->AttachmentList().Count();

   306     if (count > 0)

   307     {

   308         return true;

   309     }

   310     else

   311     {

   312         return false;

   313     }

   314 }

   315 

   316 int UniMMSDataPluginPrivate::objectCount()

   317 {

   318     return mUniDataModel->ObjectList().Count();

   319 }

   320 

   321 UniMessageInfoList UniMMSDataPluginPrivate::objectList()

   322 {

   323     UniMessageInfoList objlist;

   324     int objcount = mUniDataModel->ObjectList().Count();

   325 

   326     QString path;

   327     QString mimetype;

   328     int size;

   329     for (int i = 0; i < objcount; i++)

   330     {

   331         CUniObject *obj = mUniDataModel->ObjectList().GetByIndex(i);

   332 

   333         mimetype = S60QConversions::s60Desc8ToQString(obj->MimeType());

   334         path

   335         = S60QConversions::s60DescToQString(obj->MediaInfo()->FullFilePath());

   336         size = obj->Size(EFalse);

   337 

   338         UniMessageInfo *msgobj = new UniMessageInfo(path, size, mimetype);

   339         objlist << msgobj;

   340     }

   341 

   342     return objlist;

   343 }

   344 

   345 /*

   346  * For now not reqd

   347  */

   348 int UniMMSDataPluginPrivate::slideCount()

   349 {

   350     return mUniDataModel->SmilModel().SlideCount();

   351 }

   352 

   353 UniMessageInfoList UniMMSDataPluginPrivate::slideContent(TInt slidenum)

   354 {

   355     UniMessageInfoList slidecontent;

   356 

   357     int slideobjcount = mUniDataModel->SmilModel().SlideObjectCount(slidenum);

   358 

   359     QString path;

   360     QString mimetype;

   361     int size;

   362     for (int i = 0; i < slideobjcount; i++)

   363     {

   364         CUniObject *obj = mUniDataModel->SmilModel().GetObjectByIndex(slidenum,

   365             i);

   366 

   367         mimetype = S60QConversions::s60Desc8ToQString(obj->MimeType());

   368         path

   369         = S60QConversions::s60DescToQString(obj->MediaInfo()->FullFilePath());

   370         size = obj->Size(EFalse);

   371 

   372         UniMessageInfo *msgobj = new UniMessageInfo(path, size, mimetype);

   373         slidecontent << msgobj;

   374     }

   375 

   376     return slidecontent;

   377 }

   378 

   379 int UniMMSDataPluginPrivate::timeStamp()

   380 {

   381     QDateTime retTimeStamp;

   382     TTime timeStamp = mMmsClient->Entry().Entry().iDate;

   383     TTime unixEpoch(KUnixEpoch);

   384     TTimeIntervalSeconds seconds;

   385     timeStamp.SecondsFrom(unixEpoch, seconds);

   386     return seconds.Int();

   387 }

   388 

   389 void UniMMSDataPluginPrivate::extractNameAndAddress(const TDesC& aMsvAddress,

   390     TPtrC& aName,

   391     TPtrC& aAddress)

   392 {

   393     // For address information separation (start)

   394     const TUint KMsgMmsAddressStartChar('<');

   395 

   396     // For address information separation (end)

   397     const TUint KMsgMmsAddressEndChar('>');

   398 

   399     TInt addressStart = aMsvAddress.LocateReverse(KMsgMmsAddressStartChar);

   400     TInt addressEnd = aMsvAddress.LocateReverse(KMsgMmsAddressEndChar);

   401 

   402     if (addressStart != KErrNotFound && addressEnd != KErrNotFound

   403             && addressEnd > addressStart)

   404     {

   405         // verified address, will be used as selected from contacts manager

   406         aName.Set(aMsvAddress.Ptr(), addressStart);

   407         aAddress.Set(aMsvAddress.Mid(addressStart + 1).Ptr(), (addressEnd

   408                 - addressStart) - 1);

   409         if (!aAddress.Length())

   410         {

   411             aAddress.Set(aName);

   412             aName.Set(KNullDesC); // empty string

   413         }

   414     }

   415     else

   416     {

   417         // unverified string, will be used as entered in the header field

   418         aName.Set(KNullDesC); // empty string

   419         aAddress.Set(aMsvAddress.Ptr(), aMsvAddress.Length()); // a whole string to address

   420     }

   421 

   422     if (aName.CompareF(aAddress) == 0)

   423     {

   424         aName.Set(KNullDesC); // empty string

   425     }

   426 }

   427 

   428 void UniMMSDataPluginPrivate::RestoreReady(TInt /*aParseResult*/, 

   429     TInt /*aError*/)

   430 {

   431 }

   432 

   433 

   434 

   435 void UniMMSDataPluginPrivate::restoreL(CBaseMtm& mtm)

   436 {

   437     initL();	

   438     mUniDataModel = CUniDataModel::NewL(mfsSession, mtm);

   439     mUniDataModel->RestoreL(*this, ETrue);

   440 }

   441 

   442 CMsvSession* UniMMSDataPluginPrivate::session()

   443 {

   444     return mSession;

   445 }

   446 

   447 void UniMMSDataPluginPrivate::HandleSessionEventL(TMsvSessionEvent /*aEvent*/,

   448                                                   TAny* /*aArg1*/,

   449                                                   TAny* /*aArg2*/, TAny* /*aArg3*/)

   450 {

   451 // do nothing

   452 }

   453