1 /*

     2 * Copyright (c) 2005 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:    DM MMS Settings Adapter

    15  *

    16 */

    17 

    18 

    19 

    20 #include <iapprefs.h>

    21 #include <msvids.h>

    22 #include <msvuids.h>

    23 #include <utf.h>

    24 #include <implementationproxy.h> // For TImplementationProxy definition

    25 #include <commdb.h>

    26 #include <cdbcols.h>             // CommsDB columname defs

    27 #include <mmsclient.h>

    28 #include <ApUtils.h>

    29 #include <MmsConformance.h>

    30 #include <protectdb.h>

    31 

    32 #include "nsmldmimpluids.h"

    33 #include "nsmldmmmsadapter.h"

    34 #include "nsmldebug.h"

    35 #include "nsmlconstants.h"

    36 #include "nsmldmconst.h"

    37 #include "nsmldmiapmatcher.h"

    38 #include "nsmldmtreedbclient.h"

    39 

    40 #ifndef __WINS__

    41 // This lowers the unnecessary compiler warning (armv5) to remark.

    42 // "Warning:  #174-D: expression has no effect..." is caused by 

    43 // DBG_ARGS8 macro in no-debug builds.

    44 #pragma diag_remark 174

    45 #endif

    46 

    47 

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

    49 // CNSmlDmMMSAdapter* CNSmlDmMMSAdapter::NewL( )

    50 // -----------------------------------------------------------------------------

    51 CNSmlDmMMSAdapter* CNSmlDmMMSAdapter::NewL(MSmlDmCallback* aDmCallback )

    52     {

    53     _DBG_FILE("CNSmlDmMMSAdapter::NewL(): begin");

    54     CNSmlDmMMSAdapter* self = new (ELeave) CNSmlDmMMSAdapter(aDmCallback);

    55     CleanupStack::PushL(self);

    56     self->ConstructL();

    57     CleanupStack::Pop();

    58     _DBG_FILE("CNSmlDmMMSAdapter::NewL(): end");

    59     return self;

    60     }

    61     

    62 // -----------------------------------------------------------------------------

    63 // CNSmlDmMMSAdapter::CNSmlDmMMSAdapter()

    64 // -----------------------------------------------------------------------------

    65 CNSmlDmMMSAdapter::CNSmlDmMMSAdapter(MSmlDmCallback* aDmCallback) 

    66     : CSmlDmAdapter(aDmCallback)

    67     {

    68     _DBG_FILE("CNSmlDmMMSAdapter::CNSmlDmMMSAdapter(): begin");

    69     _DBG_FILE("CNSmlDmMMSAdapter::CNSmlDmMMSAdapter(): end");

    70     }

    71 

    72 // -----------------------------------------------------------------------------

    73 // CNSmlDmMMSAdapter::ConstructL()

    74 // -----------------------------------------------------------------------------

    75 void CNSmlDmMMSAdapter::ConstructL()

    76     {

    77     _DBG_FILE("CNSmlDmMMSAdapter::ConstructL(): begin");

    78     iStatusRef = KNSmlMMSUndefinedStatusRef;

    79     iImgSizeStatusRef = KNSmlMMSUndefinedStatusRef;

    80     iDatabase = CCommsDatabase::NewL(EDatabaseTypeIAP);

    81     _DBG_FILE("CNSmlDmMMSAdapter::ConstructL(): end");

    82     }

    83 

    84 

    85 // -----------------------------------------------------------------------------

    86 // CNSmlDmMMSAdapter::~CNSmlDmMMSAdapter()

    87 // -----------------------------------------------------------------------------

    88 CNSmlDmMMSAdapter::~CNSmlDmMMSAdapter()

    89     {

    90     _DBG_FILE("CNSmlDmMMSAdapter::~CNSmlDmMMSAdapter(): begin");

    91     delete iMmsClient;

    92     delete iClientMtmRegistry;

    93     delete iMsvSession;

    94     delete iMMSSAddr;

    95     delete iMmsSettings;

    96 	if(iDatabase)

    97     delete iDatabase;

    98     _DBG_FILE("CNSmlDmMMSAdapter::~CNSmlDmMMSAdapter(): end");

    99     }

   100 

   101 // -----------------------------------------------------------------------------

   102 //  CNSmlDmMMSAdapter::DDFVersionL()

   103 //  Returns the DDF version of the adapter

   104 // -----------------------------------------------------------------------------

   105 void CNSmlDmMMSAdapter::DDFVersionL(CBufBase& aDDFVersion)

   106     {

   107     _DBG_FILE("CNSmlDmMMSAdapter::DDFVersionL(TDes& aDDFVersion): begin");

   108     aDDFVersion.InsertL(0,KNSmlDMMMSDDFVersion);

   109     _DBG_FILE("CNSmlDmMMSAdapter::DDFVersionL(TDes& aDDFVersion): end");

   110     }

   111 

   112 

   113 // -----------------------------------------------------------------------------

   114 //  CNSmlDmMMSAdapter::DDFStructureL()

   115 //  Builds the DDF structure of adapter

   116 // -----------------------------------------------------------------------------

   117 void CNSmlDmMMSAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )

   118     {

   119     _DBG_FILE("CNSmlDmMMSAdapter::DDFStructureL(): begin");

   120 

   121     TSmlDmAccessTypes accessTypesGetAdd;

   122     accessTypesGetAdd.SetGet();

   123     accessTypesGetAdd.SetAdd();

   124     

   125     TSmlDmAccessTypes accessTypesGet;

   126     accessTypesGet.SetGet();

   127 

   128     TSmlDmAccessTypes accessTypesNoDelete;

   129     accessTypesNoDelete.SetGet();

   130     accessTypesNoDelete.SetAdd();

   131     accessTypesNoDelete.SetReplace();

   132 

   133     // MMS

   134     MSmlDmDDFObject& MMS = aDDF.AddChildObjectL(KNSmlDMMMSNodeName);

   135     FillNodeInfoL(MMS,accessTypesGet,MSmlDmDDFObject::EOne,

   136                   MSmlDmDDFObject::EPermanent,MSmlDmDDFObject::ENode,

   137                   KNSmlDMMMSNodeNameDescription);

   138 

   139     //run time node 

   140     MSmlDmDDFObject& rtAcc = MMS.AddChildObjectGroupL();

   141     FillNodeInfoL(rtAcc,accessTypesGet,MSmlDmDDFObject::EOne,

   142                   MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::ENode,

   143                   KNSmlDMMMSDynamicNodeDescription);

   144 

   145     //level of mms protocol operations

   146     MSmlDmDDFObject& mmRecep = rtAcc.AddChildObjectL(KNSmlDMMMSMMRecep);

   147     FillNodeInfoL(mmRecep,accessTypesNoDelete,MSmlDmDDFObject::EZeroOrOne,

   148                   MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

   149                   KNSmlDMMMSMMRecepDescription);

   150 

   151     //Creation mode

   152     MSmlDmDDFObject& creMode = rtAcc.AddChildObjectL(KNSmlDMMMSCreMode);

   153     FillNodeInfoL(creMode,accessTypesNoDelete,MSmlDmDDFObject::EZeroOrOne,

   154                   MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

   155                   KNSmlDMMMSCreModeDescription);

   156 

   157     //anonymous messages allowed

   158     MSmlDmDDFObject& amsg = rtAcc.AddChildObjectL(KNSmlDMMMSAMsg);

   159     FillNodeInfoL(amsg,accessTypesNoDelete,MSmlDmDDFObject::EZeroOrOne,

   160                   MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EBool,

   161                   KNSmlDMMMSAMsgDescription);

   162 

   163     //adverts messages allowed

   164     MSmlDmDDFObject& rcvAds = rtAcc.AddChildObjectL(KNSmlDMMMSRcvAds);

   165     FillNodeInfoL(rcvAds,accessTypesNoDelete,MSmlDmDDFObject::EZeroOrOne,

   166                   MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EBool,

   167                   KNSmlDMMMSRcvAdsDescription);

   168 

   169     //image size in sending

   170     MSmlDmDDFObject& imgSize = rtAcc.AddChildObjectL(KNSmlDMMMSImgSize);

   171     FillNodeInfoL(imgSize,accessTypesNoDelete,MSmlDmDDFObject::EZeroOrOne,

   172                   MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

   173                   KNSmlDMMMSImgSizeDescription);

   174 

   175     //deny delivery report sending

   176     MSmlDmDDFObject& dRepSnd = rtAcc.AddChildObjectL(KNSmlDMMMSDRepSnd);

   177     FillNodeInfoL(dRepSnd,accessTypesNoDelete,MSmlDmDDFObject::EZeroOrOne,

   178                   MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EBool,

   179                   KNSmlDMMMSDRepSndDescription);

   180 

   181     //delivery report requested by default

   182     MSmlDmDDFObject& rcvRep = rtAcc.AddChildObjectL(KNSmlDMMMSRcvRep);

   183     FillNodeInfoL(rcvRep,accessTypesNoDelete,MSmlDmDDFObject::EZeroOrOne,

   184                   MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EBool,

   185                   KNSmlDMMMSRcvRepDescription);

   186 

   187     //message validity time

   188     MSmlDmDDFObject& msgVal = rtAcc.AddChildObjectL(KNSmlDMMMSMsgVal);

   189     FillNodeInfoL(msgVal,accessTypesNoDelete,MSmlDmDDFObject::EZeroOrOne,

   190                   MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

   191                   KNSmlDMMMSMsgValDescription);

   192 

   193     // MMS/<X>/Con

   194     MSmlDmDDFObject& con = rtAcc.AddChildObjectL(KNSmlDMMMSCon);

   195     FillNodeInfoL(con,accessTypesGet,MSmlDmDDFObject::EOne,

   196                   MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::ENode,

   197                   KNSmlDMMMSConNodeDescription);

   198 

   199 

   200     // MMS/<X>/Con/<X>

   201     MSmlDmDDFObject& rtCon = con.AddChildObjectL(KNSmlDMMMSConDynamicName16);

   202     FillNodeInfoL(rtCon,accessTypesGet,MSmlDmDDFObject::EOne,

   203                   MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::ENode,

   204                   KNSmlDMMMSConRtNodeDescription);

   205 

   206 

   207     // MMS/<X>/Con/<X>/MMSSAddr

   208     MSmlDmDDFObject& mmsAddr = rtCon.AddChildObjectL(KNSmlDMMMSMMSSAddr);

   209     FillNodeInfoL(mmsAddr,accessTypesNoDelete,MSmlDmDDFObject::EOne,

   210                   MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

   211                   KNSmlDMMMSMMSSAddrDescription);

   212 

   213     // MMS/<X>/Con/<X>/MToNapID

   214     MSmlDmDDFObject& mToNapID = rtCon.AddChildObjectL(KNSmlDMMMSMToNapID);

   215     FillNodeInfoL(mToNapID,accessTypesGet,MSmlDmDDFObject::EZeroOrOne,

   216                   MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::ENode,

   217                   KNSmlDMMMSConRtNodeDescription);

   218 

   219     // MMS/<X>/Con/<X>/MToNapID/<X>

   220     MSmlDmDDFObject& rtNapIds = mToNapID.AddChildObjectL(KNullDesC8);

   221     FillNodeInfoL(rtNapIds,accessTypesGet,MSmlDmDDFObject::EZeroOrOne,

   222                   MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::ENode,

   223                   KNSmlDMMMSConRtNodeDescription);

   224 

   225     // MMS/<X>/Con/<X>/MToNapID/<X>/MToNapIdL

   226     MSmlDmDDFObject& mToNapIDL = rtNapIds.AddChildObjectL(KNSmlDMMMSMToNapIDL);

   227     FillNodeInfoL(mToNapIDL,accessTypesNoDelete,MSmlDmDDFObject::EOneOrMore,

   228                   MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

   229                   KNSmlDMMMSMToNapIDLDescription);

   230 

   231     RNSmlDMCallbackSession session;

   232     User::LeaveIfError( session.Connect() );

   233     CleanupClosePushL(session);

   234     

   235     session.UpdateAclL(KNSmlDMMMSLevel3Parents,KNSmlDmMMSAclGet);

   236     session.UpdateAclL(KNSmlDMMMSAclName,KNSmlDmMMSAclDefault);

   237     session.UpdateAclL(KNSmlDMMMSAclMMRecep,KNSmlDmMMSAclDefault);

   238     session.UpdateAclL(KNSmlDMMMSAclCreMode,KNSmlDmMMSAclDefault);

   239     session.UpdateAclL(KNSmlDMMMSAclAMsg,KNSmlDmMMSAclDefault);

   240     session.UpdateAclL(KNSmlDMMMSAclRcvAds,KNSmlDmMMSAclDefault);

   241     session.UpdateAclL(KNSmlDMMMSAclImgSize,KNSmlDmMMSAclDefault);

   242     session.UpdateAclL(KNSmlDMMMSAclDRepSnd,KNSmlDmMMSAclDefault);

   243     session.UpdateAclL(KNSmlDMMMSAclRcvRep,KNSmlDmMMSAclDefault);

   244     session.UpdateAclL(KNSmlDMMMSAclMsgVal,KNSmlDmMMSAclDefault);

   245     session.UpdateAclL(KNSmlDMMMSAclMMSSAddr,KNSmlDmMMSAclDefault);

   246     session.UpdateAclL(KNSmlDMMMSAclPrimaryMToNapIDL,KNSmlDmMMSAclDefault);

   247     CleanupStack::PopAndDestroy(); //session

   248     

   249     _DBG_FILE("CNSmlDmMMSAdapter::DDFStructureL(): end");

   250     }

   251 

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

   253 //  CNSmlDmMMSAdapter::UpdateLeafObjectL()

   254 // Updates value of leaf object

   255 // -----------------------------------------------------------------------------

   256 void CNSmlDmMMSAdapter::UpdateLeafObjectL( const TDesC8& aURI, 

   257                                            const TDesC8& aLUID, 

   258                                            const TDesC8& aObject, 

   259                                            const TDesC8& /*aType*/, 

   260                                            const TInt aStatusRef )

   261     {

   262     _DBG_FILE("CNSmlDmMMSAdapter::UpdateLeafObjectL(): begin");

   263     CSmlDmAdapter::TError status = ValidateUriL( aURI );

   264     if ( status == EOk )

   265         {

   266         _DBG_FILE("CNSmlDmMMSAdapter::UpdateLeafObjectL(): OK update");

   267         status = UpdateDataL(aURI, aLUID, aObject, aStatusRef);

   268         }

   269     // ImgSize and MMSAddr are always stored last, from the 

   270     // CompleteOutstandingCmdsL() function

   271     if( ( aStatusRef != iStatusRef ) && (aStatusRef != iImgSizeStatusRef ))

   272         {

   273         StoreSettingsL();

   274         Callback().SetStatusL(aStatusRef, status);

   275         }

   276     _DBG_FILE("CNSmlDmMMSAdapter::UpdateLeafObjectL(): end");

   277     }

   278 // -----------------------------------------------------------------------------

   279 // CNSmlDmMMSAdapter::DeleteObjectL( const TDesC8& aURI, const TDesC8& aLUID )

   280 // This should delete values or accounts, but in case of MMS adapter the delete 

   281 // is not allowed

   282 // and the adapters returns allways the EError.

   283 // -----------------------------------------------------------------------------

   284 void CNSmlDmMMSAdapter::DeleteObjectL( const TDesC8& /*aURI*/, 

   285                                        const TDesC8& /*aLUID*/, 

   286                                        const TInt aStatusRef )

   287     {

   288     _DBG_FILE("CNSmlDmMMSAdapter::DeleteLeafObjectL( ): begin");

   289 

   290     Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EError);

   291     _DBG_FILE("CNSmlDmMMSAdapter::DeleteLeafObjectL( ): end");

   292     }

   293 // -----------------------------------------------------------------------------

   294 //  CNSmlDmMMSAdapter::FetchLeafObjectL( const TDesC8& aURI, 

   295 //  const TDesC8& aLUID,

   296 //  const TDesC8& aType, 

   297 //  const TInt aResultsRef, 

   298 //  const TInt aStatusRef )

   299 //  Fetches the values of leaf objects.

   300 // -----------------------------------------------------------------------------

   301 void CNSmlDmMMSAdapter::FetchLeafObjectL( const TDesC8& aURI, 

   302                                           const TDesC8& /*aLUID*/, 

   303                                           const TDesC8& aType, 

   304                                           const TInt aResultsRef, 

   305                                           const TInt aStatusRef )

   306     {

   307     _DBG_FILE("CNSmlDmMMSAdapter::FetchLeafObjectL(): begin");

   308     CBufBase* result = CBufFlat::NewL(64);

   309     CleanupStack::PushL(result);

   310     CSmlDmAdapter::TError status = FetchObjectL(aURI, *result);

   311     if(status == CSmlDmAdapter::EOk)

   312         {

   313         Callback().SetResultsL(aResultsRef,*result,aType);

   314         }

   315     Callback().SetStatusL(aStatusRef, status);

   316 

   317     CleanupStack::PopAndDestroy(); //result

   318     _DBG_FILE("CNSmlDmMMSAdapter::FetchLeafObjectL(): end");

   319     }

   320 

   321 // -----------------------------------------------------------------------------

   322 //  CNSmlDmMMSAdapter::ChildURIListL( const TDesC8& aURI, 

   323 //                                       const TDesC8& /*aLUID*/, 

   324 //                                       const CArrayFix<TSmlDmMappingInfo>& 

   325 //                                       /*aPreviousURISegmentList*/, 

   326 //                                       const TInt aResultsRef, 

   327 //                                       const TInt aStatusRef )

   328 //  Retuns the list of children of the node

   329 // -----------------------------------------------------------------------------

   330 void CNSmlDmMMSAdapter::ChildURIListL( const TDesC8& aURI, 

   331                                        const TDesC8& /*aLUID*/, 

   332                                        const CArrayFix<TSmlDmMappingInfo>& 

   333                                        /*aPreviousURISegmentList*/, 

   334                                        const TInt aResultsRef, 

   335                                        const TInt aStatusRef )

   336     {

   337     _DBG_FILE("CNSmlDmMMSAdapter::ChildURIListL(): begin");

   338     TRAPD(err, CreateMMSClientL());

   339     if(err!=KErrNone)

   340         {

   341         Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EError);

   342         _DBG_FILE("CNSmlDmMMSAdapter::ChildURIListL(): EError end");

   343         return;

   344         }

   345 

   346     CBufBase* currentList = CBufFlat::NewL(1);

   347     CleanupStack::PushL(currentList);

   348 

   349     TMsvId id = iMmsSettings->Service();

   350     if(id==KMsvNullIndexEntryId)

   351         {

   352         if(aURI.Compare(KNSmlDMMMSNodeName)==0)

   353             {

   354             Callback().SetResultsL(aResultsRef,*currentList,KNullDesC8);

   355             Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EOk);

   356             _DBG_FILE("CNSmlDmMMSAdapter::ChildURIListL(): end");

   357             }

   358         else

   359             {

   360             Callback().SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);

   361             _DBG_FILE("CNSmlDmMMSAdapter::ChildURIListL(): ENotFound end");

   362             }

   363         CleanupStack::PopAndDestroy(); //currentList

   364         return;

   365         }

   366 

   367     CSmlDmAdapter::TError status = CSmlDmAdapter::EOk;

   368     TPtrC8 lastSeg = LastURISeg(aURI);

   369     TInt num = NumOfURISegs(aURI);

   370 

   371     if(aURI.Compare(KNSmlDMMMSNodeName)==0)

   372         {

   373         currentList->InsertL(0,KNSmlDMMMSAccount8);

   374         }

   375     else if(num==2&&aURI.Find(KNSmlDMMMSAccount8)>=0)

   376         {

   377         currentList->InsertL(0,KNSmlDMMMSListOfLeafsLo);

   378         }

   379     else if(num==3&&lastSeg.Compare(KNSmlDMMMSCon)==0)

   380         {

   381         currentList->InsertL(0,KNSmlDMMMSConDynamicName8);

   382         }

   383     else if(num==4&&lastSeg.Compare(KNSmlDMMMSConDynamicName16)==0)

   384         {

   385         currentList->InsertL(0,KNSmlDMMMSListOfLeafsMid);

   386         }

   387     else if(num==5&&lastSeg.Compare(KNSmlDMMMSMToNapID)==0)

   388         {

   389         currentList->InsertL(0,KNSmlDMMMSValuePrimary);

   390         }

   391     else if(num==6&&(lastSeg.Compare(KNSmlDMMMSDynamicPrimary)==0))

   392         {

   393         currentList->InsertL(0,KNSmlDMMMSListOfLeafsHi);

   394         }

   395     else

   396         {

   397         status=CSmlDmAdapter::ENotFound;

   398         }

   399     Callback().SetStatusL(aStatusRef, status);

   400     if(status==CSmlDmAdapter::EOk)

   401         {

   402         Callback().SetResultsL(aResultsRef,*currentList,KNullDesC8);

   403         }

   404     CleanupStack::PopAndDestroy(); //currentList

   405 

   406     _DBG_FILE("CNSmlDmMMSAdapter::ChildURIListL(): end");

   407     }

   408 // -----------------------------------------------------------------------------

   409 // CNSmlDmMMSAdapter::AddNodeObjectL( const TDesC8& aURI, 

   410 // const TDesC8& aParentLUID )

   411 // This should add a new account, but in case of MMS settings only one 

   412 // account exist,

   413 // and so the add is not possible. Returns allways CSmlDmAdapter::EError.

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

   415 void CNSmlDmMMSAdapter::AddNodeObjectL( const TDesC8& /*aURI*/, 

   416                                         const TDesC8& /*aParentLUID*/, 

   417                                         const TInt aStatusRef )

   418     {

   419     _DBG_FILE("CNSmlDmMMSAdapter::AddNodeObjectL(): begin");

   420     //If add is needed in future then add call to AddObjectL function here

   421     Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EError);

   422     _DBG_FILE("CNSmlDmMMSAdapter::AddNodeObjectL(): end");

   423     }

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

   425 // CNSmlDmMMSAdapter::UpdateLeafObjectL( const TDesC8& aURI, 

   426 // const TDesC8& aLUID, RWriteStream*& aStream, const TDesC8& aType,

   427 //  const TInt aStatusRef )

   428 // This should update a stream object, but in case of MMS settings streaming is 

   429 // not supported.

   430 // -----------------------------------------------------------------------------

   431 void CNSmlDmMMSAdapter::UpdateLeafObjectL( const TDesC8& /*aURI*/, 

   432                                            const TDesC8& /*aLUID*/, 

   433                                            RWriteStream*& /*aStream*/, 

   434                                            const TDesC8& /*aType*/, 

   435                                            const TInt aStatusRef )

   436     {

   437     _DBG_FILE("CNSmlDmMMSAdapter::UpdateLeafObjectL(stream): begin");

   438     Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EError);

   439     _DBG_FILE("CNSmlDmMMSAdapter::UpdateLeafObjectL(stream): end");

   440     }

   441 // -----------------------------------------------------------------------------

   442 // void CNSmlDmMMSAdapter::FetchLeafObjectSizeL( const TDesC8& aURI, 

   443 // const TDesC8& aLUID, const TDesC8& aType, const TInt aResultsRef, 

   444 // const TInt aStatusRef )

   445 // Fetches data object and returns its size.

   446 // -----------------------------------------------------------------------------

   447 void CNSmlDmMMSAdapter::FetchLeafObjectSizeL( const TDesC8& aURI, 

   448                                               const TDesC8& /*aLUID*/, 

   449                                               const TDesC8& aType, 

   450                                               const TInt aResultsRef, 

   451                                               const TInt aStatusRef )

   452     {

   453     _DBG_FILE("CNSmlDmMMSAdapter::FetchLeafObjectSizeL(): begin");

   454 

   455     CBufBase* result = CBufFlat::NewL(64);

   456     CleanupStack::PushL(result);

   457     CSmlDmAdapter::TError status = FetchObjectL(aURI, *result);

   458     if( status == CSmlDmAdapter::EOk )

   459         {

   460         TInt objSizeInBytes = result->Size();

   461         TBuf8<KNSmlDmMmsObjectSizeWidth> stringObjSizeInBytes;

   462         stringObjSizeInBytes.Num( objSizeInBytes );

   463         result->Reset();

   464         result->InsertL( 0, stringObjSizeInBytes );

   465         Callback().SetResultsL(aResultsRef, *result, aType);

   466         }

   467     Callback().SetStatusL(aStatusRef, status);

   468     CleanupStack::PopAndDestroy(); //result

   469     _DBG_FILE("CNSmlDmMMSAdapter::FetchLeafObjectSizeL(): end");

   470     }

   471 //==============================================================================

   472 // CNSmlDmMMSAdapter::ExecuteCommandL()

   473 //==============================================================================

   474 void CNSmlDmMMSAdapter::ExecuteCommandL( const TDesC8& /*aURI*/, 

   475                                          const TDesC8& /*aLUID*/, 

   476                                          const TDesC8& /*aArgument*/, 

   477                                          const TDesC8& /*aType*/, 

   478                                          const TInt aStatusRef )

   479     {

   480     //Not supported 

   481     Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EError);

   482     }

   483 

   484 //==============================================================================

   485 // CNSmlDmMMSAdapter::ExecuteCommandL()

   486 //==============================================================================

   487 void CNSmlDmMMSAdapter::ExecuteCommandL( const TDesC8& /*aURI*/, 

   488                                          const TDesC8& /*aLUID*/, 

   489                                          RWriteStream*& /*aStream*/, 

   490                                          const TDesC8& /*aType*/, 

   491                                          const TInt aStatusRef )

   492     {

   493     //Not supported

   494     Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EError);

   495     }

   496 

   497 //==============================================================================

   498 // CNSmlDmMMSAdapter::CopyCommandL()

   499 //==============================================================================

   500 void CNSmlDmMMSAdapter::CopyCommandL( const TDesC8& /*aTargetURI*/, 

   501                                       const TDesC8& /*aTargetLUID*/, 

   502                                       const TDesC8& /*aSourceURI*/, 

   503                                       const TDesC8& /*aSourceLUID*/, 

   504                                       const TDesC8& /*aType*/, 

   505                                       TInt aStatusRef )

   506     {

   507     //Not supported

   508     Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EError);

   509 

   510     }

   511 

   512 //==============================================================================

   513 // CNSmlDmMMSAdapter::StartAtomicL()

   514 //==============================================================================

   515 void CNSmlDmMMSAdapter::StartAtomicL()

   516     {

   517     //Not supported

   518     }

   519 

   520 //==============================================================================

   521 // CNSmlDmMMSAdapter::CommitAtomicL()

   522 //==============================================================================

   523 void CNSmlDmMMSAdapter::CommitAtomicL()

   524     {

   525     //Not supported

   526     }

   527 

   528 //==============================================================================

   529 // CNSmlDmMMSAdapter::RollbackAtomicL()

   530 //==============================================================================

   531 void CNSmlDmMMSAdapter::RollbackAtomicL()

   532     {

   533     //Not supported

   534     }

   535 

   536 //==============================================================================

   537 // CNSmlDmMMSAdapter::StreamingSupport()

   538 //==============================================================================

   539 TBool CNSmlDmMMSAdapter::StreamingSupport( TInt& /*aItemSize*/ )

   540     {

   541     return EFalse;

   542     }

   543 

   544 //==============================================================================

   545 // CNSmlDmMMSAdapter::StreamCommittedL()

   546 //==============================================================================

   547 void CNSmlDmMMSAdapter::StreamCommittedL()

   548     {

   549     //Not supported

   550     }

   551 // -----------------------------------------------------------------------------

   552 // CNSmlDmMMSAdapter::CompleteOutstandingCmdsL()

   553 // Indication of message ending. The buffered commands must be executed before 

   554 // return of this function.

   555 // -----------------------------------------------------------------------------

   556 void CNSmlDmMMSAdapter::CompleteOutstandingCmdsL()

   557     {

   558     _DBG_FILE("CNSmlDmMMSAdapter::CompleteOutstandingCmdsL(): begin");

   559     if(iStatusRef!=KNSmlMMSUndefinedStatusRef)

   560         {

   561         Callback().SetStatusL(iStatusRef,UpdateMMSAddrL());

   562         delete iMMSSAddr;

   563         iMMSSAddr = 0;

   564         iStatusRef = KNSmlMMSUndefinedStatusRef;

   565         }

   566     StoreSettingsL();

   567     _DBG_FILE("CNSmlDmMMSAdapter::CompleteOutstandingCmdsL(): end");

   568     }

   569 

   570 // -----------------------------------------------------------------------------

   571 // CNSmlDmMMSAdapter::HandleSessionEventL()

   572 // Inherited from MMsvSessionObserver, and this is needs to implemented for 

   573 // opening the CMsvSession

   574 // -----------------------------------------------------------------------------

   575 void CNSmlDmMMSAdapter::HandleSessionEventL( TMsvSessionEvent /*aEvent*/, 

   576                                              TAny* /*aArg1*/, 

   577                                              TAny* /*aArg2*/, 

   578                                              TAny* /*aArg3*/ )

   579     {

   580     }

   581 

   582 

   583 // -----------------------------------------------------------------------------

   584 // CSmlDmAdapter::TError CNSmlDmMMSAdapter::UpdateDataL()

   585 // The function is used for updating the MMS settings. The function is used in 

   586 // AddLeafObjectL() and UpdateLeafObjectL()

   587 // -----------------------------------------------------------------------------

   588 CSmlDmAdapter::TError CNSmlDmMMSAdapter::UpdateDataL(const TDesC8& aURI, 

   589                                                      const TDesC8& /*aParentLUID*/,

   590                                                      const TDesC8& aObject, 

   591                                                      TInt aStatusRef)

   592     {

   593     _DBG_FILE("CNSmlDmMMSAdapter::UpdateDataL(): begin");

   594     HBufC8* data = NULL;

   595     TRAPD(err, CreateMMSClientL());

   596     if(err!=KErrNone)

   597         {

   598         _DBG_FILE("CNSmlDmMMSAdapter::UpdateDataL(): EError end");

   599         return CSmlDmAdapter::EError;

   600         }

   601 

   602     TMsvId id = iMmsSettings->Service();

   603 

   604     if( id == KMsvNullIndexEntryId || aURI.Find( KNSmlDMMMSAccount8 )

   605         ==KErrNotFound )

   606         {

   607         _DBG_FILE("CNSmlDmMMSAdapter::UpdateDataL(): ENotFound end");

   608         return CSmlDmAdapter::ENotFound;

   609         }

   610 

   611     TPtrC8 uriSeg = LastURISeg(aURI);

   612     CSmlDmAdapter::TError status = CSmlDmAdapter::EOk;

   613 

   614     if(uriSeg.Compare(KNSmlDMMMSName)==0)

   615         {

   616         // Not supported.

   617         _DBG_FILE("CNSmlDmMMSAdapter::UpdateDataL(): ENotFound end");

   618         status = CSmlDmAdapter::ENotFound;

   619         }

   620     else if(uriSeg.Compare(KNSmlDMMMSMMRecep)==0)

   621         {

   622         data = aObject.AllocLC();

   623         TPtr8 dataPtr = data->Des();

   624         dataPtr.Capitalize();

   625         if(dataPtr.Find(KNSmlDMMMSValueAlwaysOn)==0)

   626             {

   627             iMmsSettings->SetReceivingModeHome(EMmsReceivingAutomatic);

   628             iMmsSettings->SetReceivingModeForeign(EMmsReceivingAutomatic);

   629             }

   630         else if(dataPtr.Compare(KNSmlDMMMSValueOff)==0)

   631             {

   632             iMmsSettings->SetReceivingModeHome(EMmsReceivingReject);

   633             iMmsSettings->SetReceivingModeForeign(EMmsReceivingReject);

   634             }

   635         else if(dataPtr.Find(KNSmlDMMMSValueAutomaticAtHome)==0)

   636             {

   637             iMmsSettings->SetReceivingModeHome(EMmsReceivingAutomatic);

   638             iMmsSettings->SetReceivingModeForeign(EMmsReceivingReject);

   639             }

   640         else if (dataPtr.Find(KNSmlDMMMSValueAlwaysManual2)==0 ||

   641                  dataPtr.Find(KNSmlDMMMSValueAlwaysManual)==0 )

   642             {

   643             iMmsSettings->SetReceivingModeHome(EMmsReceivingManual);

   644             iMmsSettings->SetReceivingModeForeign(EMmsReceivingManual);

   645             }

   646         else

   647             {

   648             status = CSmlDmAdapter::EInvalidObject;

   649             }

   650         CleanupStack::PopAndDestroy(); //data

   651         }

   652     else if(uriSeg.Compare(KNSmlDMMMSCreMode)==0)

   653         {

   654         data = aObject.AllocLC();

   655         TPtr8 dataPtr = data->Des();

   656         dataPtr.Capitalize();

   657         if(dataPtr.Find(KNSmlDMMMSValueFree)==0)

   658             {

   659             iMmsSettings->SetCreationMode(EMmsCreationModeFree);

   660             }

   661         else if(dataPtr.Find(KNSmlDMMMSValueRestricted)==0)

   662             {

   663                iMmsSettings->SetImageWidth(KImageRichWidth);

   664                iMmsSettings->SetImageHeight(KImageRichHeight);

   665                iMmsSettings->SetCreationMode(EMmsCreationModeRestricted);

   666             }

   667         else if(dataPtr.Find(KNSmlDMMMSValueWarning)==0)

   668             {

   669             iMmsSettings->SetCreationMode(EMmsCreationModeWarning);

   670             }

   671         else

   672             {

   673             status = CSmlDmAdapter::EInvalidObject;

   674             }

   675         CleanupStack::PopAndDestroy(); //data

   676         }

   677     else if( uriSeg.Compare(KNSmlDMMMSAMsg) == 0 )

   678         {

   679         data = aObject.AllocLC();

   680         TPtr8 dataPtr = data->Des();

   681         dataPtr.Capitalize();

   682         TBool object=EFalse;

   683         if(dataPtr.Find(KNSmlDMMMSValueTrue)>=0)

   684             {

   685             object = ETrue;

   686             }

   687         iMmsSettings->SetAcceptAnonymousMessages(object);

   688         CleanupStack::PopAndDestroy(); //data

   689         }

   690     else if( uriSeg.Compare(KNSmlDMMMSRcvAds) == 0 )

   691         {

   692         data = aObject.AllocLC();

   693         TPtr8 dataPtr = data->Des();

   694         dataPtr.Capitalize();

   695         TBool object=EFalse;

   696         if(dataPtr.Find(KNSmlDMMMSValueTrue)>=0)

   697             {

   698             object = ETrue;

   699             }

   700         iMmsSettings->SetAcceptAdvertisementMessages(object);

   701         CleanupStack::PopAndDestroy(); //data

   702         }

   703     else if(uriSeg.Compare(KNSmlDMMMSImgSize)==0)

   704         {

   705         data = aObject.AllocLC();

   706         TPtr8 dataPtr = data->Des();

   707         dataPtr.Capitalize();

   708         if(dataPtr.Compare(KNSmlDMMMSValueLarge)==0)

   709             {

   710              switch(iMmsSettings->CreationMode())

   711             {

   712                 case EMmsCreationModeRestricted:

   713                 status = CSmlDmAdapter::EInvalidObject;

   714                 break;

   715                 default : 

   716                 iMmsSettings->SetImageWidth(KImageMegapixelWidth);

   717                 iMmsSettings->SetImageHeight(KImageMegapixelHeight);

   718                 break;

   719             }

   720             iImgSizeStatusRef = KNSmlMMSUndefinedStatusRef;

   721             }

   722         else if(dataPtr.Compare(KNSmlDMMMSValueSmall)==0)

   723             {

   724             iMmsSettings->SetImageWidth(KImageRichWidth);

   725             iMmsSettings->SetImageHeight(KImageRichHeight);

   726             iImgSizeStatusRef = KNSmlMMSUndefinedStatusRef;

   727             }

   728         else

   729             {

   730             status = CSmlDmAdapter::EInvalidObject;

   731             }

   732         CleanupStack::PopAndDestroy(); //data

   733         }

   734     else if(uriSeg.Compare(KNSmlDMMMSDRepSnd)==0)

   735         {

   736         data = aObject.AllocLC();

   737         TPtr8 dataPtr = data->Des();

   738         dataPtr.Capitalize();

   739         if(dataPtr.Compare(KNSmlDMMMSValueFalse)==0)

   740             {

   741             iMmsSettings->SetDeliveryReportSendingAllowed(KMmsYes);

   742             }

   743         else

   744             {

   745             iMmsSettings->SetDeliveryReportSendingAllowed(KMmsNo);

   746             }

   747         CleanupStack::PopAndDestroy(); //data

   748         }

   749     else if(uriSeg.Compare(KNSmlDMMMSRcvRep)==0)

   750         {

   751         data = aObject.AllocLC();

   752         TPtr8 dataPtr = data->Des();

   753         dataPtr.Capitalize();

   754         if(dataPtr.Compare(KNSmlDMMMSValueTrue)==0)

   755             {

   756             iMmsSettings->SetDeliveryReportWanted(KMmsYes);

   757             }

   758         else

   759             {

   760             iMmsSettings->SetDeliveryReportWanted(KMmsNo);

   761             }

   762         CleanupStack::PopAndDestroy(); //data

   763         }

   764     else if(uriSeg.Compare(KNSmlDMMMSMsgVal)==0)

   765         {

   766         data = aObject.AllocLC();

   767         TPtr8 dataPtr = data->Des();

   768         dataPtr.LowerCase();

   769         if(dataPtr.Compare(KNSmlDMMMSValueHour)==0 ||

   770            dataPtr.Compare(KNSmlDMMMSValueHourShort)==0)

   771             {

   772             iMmsSettings->SetExpiryInterval(KNSmlDMMMSExpiryHour);

   773             }

   774         else if(dataPtr.Find(KNSmlDMMMSValueSixHoursShort)==0 ||

   775                 dataPtr.Find(KNSmlDMMMSValueSixHoursShortNum)==0)

   776             {

   777             iMmsSettings->SetExpiryInterval(KNSmlDMMMSExpirySixHours);

   778             }

   779         else if(dataPtr.Find(KNSmlDMMMSValueDayShort)==0)

   780             {

   781             iMmsSettings->SetExpiryInterval(KNSmlDMMMSExpiryDay);

   782             }

   783         else if(dataPtr.Find(KNSmlDMMMSValueThreeDaysShort)==0 ||

   784                 dataPtr.Find(KNSmlDMMMSValueThreeDaysShortNum)==0)

   785             {

   786             iMmsSettings->SetExpiryInterval(KNSmlDMMMSExpiryThreeDays);

   787             }

   788         else if(dataPtr.Find(KNSmlDMMMSValueWeekShort)>=0)

   789             {

   790             iMmsSettings->SetExpiryInterval(KNSmlDMMMSExpiryWeek);

   791             }

   792         else if(dataPtr.Find(KNSmlDMMMSValueMaximumTimeShort)==0)

   793             {

   794             iMmsSettings->SetExpiryInterval(KNSmlDMMMSExpiryMaximum);

   795             }

   796         else

   797             {

   798             status = CSmlDmAdapter::EInvalidObject;

   799             }

   800         CleanupStack::PopAndDestroy(); //data

   801         }

   802     else if(uriSeg.Compare(KNSmlDMMMSMToNapIDL)==0)

   803         {

   804         TPtrC8 seg=LastURISeg(RemoveLastURISeg(aURI));

   805         if( seg.Compare(KNSmlDMMMSDynamicPrimary)==0 )

   806             {

   807             CNSmlDMIAPMatcher* iapmatch = CNSmlDMIAPMatcher::NewL( &Callback() );

   808             CleanupStack::PushL(iapmatch);

   809             

   810             TInt iap = iapmatch->IAPIdFromURIL( aObject );

   811 

   812             CleanupStack::PopAndDestroy(); // iapmatch

   813             

   814             if ( iap != KErrNotFound )

   815                 {

   816                 CCommsDatabase* commDb = CCommsDatabase::NewL();

   817                 CleanupStack::PushL(commDb);

   818                 CApUtils* aputils = CApUtils::NewLC(*commDb);

   819                 TRAP(err, iap = aputils->WapIdFromIapIdL( iap ) );

   820                 DBG_ARGS(_S("IAP = %d"), iap);

   821 

   822                 CleanupStack::PopAndDestroy(2); //commdb,aputils

   823 

   824                 if( err == KErrNone)

   825                     {

   826                     ReplaceAPL( iap, KNSmlDMMMSFirstAccessPointId );

   827                     }

   828                 else

   829                     {

   830                     _DBG_FILE("CNSmlDmMMSAdapter::UpdateDataL(): \

   831                     err!=KErrNone");

   832                     iap = KNSmlDMMMSIapNotDefined;

   833                     status = CSmlDmAdapter::EInvalidObject;

   834                     }

   835                 }

   836             else

   837                 {

   838                 _DBG_FILE("CNSmlDmMMSAdapter::UpdateDataL(): status = \

   839                 CSmlDmAdapter::EInvalidObject");

   840                 status = CSmlDmAdapter::EInvalidObject;

   841                 }

   842             }

   843         else

   844             {

   845             if( status == CSmlDmAdapter::EOk )

   846                 {

   847                 status = CSmlDmAdapter::ENotFound;

   848                 }

   849             }

   850         }

   851     else if(uriSeg.Compare(KNSmlDMMMSMMSSAddr)==0)

   852         {

   853         if(iMMSSAddr)

   854             {

   855             delete iMMSSAddr;

   856             iMMSSAddr = 0;

   857             }

   858         if(iStatusRef != KNSmlMMSUndefinedStatusRef)

   859             {

   860             Callback().SetStatusL(iStatusRef,CSmlDmAdapter::EError);

   861             }

   862         iMMSSAddr = aObject.AllocL();

   863         iStatusRef = aStatusRef;

   864         }

   865 

   866     _DBG_FILE("CNSmlDmMMSAdapter::UpdateDataL(): end");

   867     return status;

   868     }

   869 

   870 // -----------------------------------------------------------------------------

   871 // void CNSmlDmMMSAdapter::ReplaceAP( TInt aIapId, TInt aPos )

   872 // replace AP, if no AP exitst in aPos then just add it.

   873 // -----------------------------------------------------------------------------

   874 void CNSmlDmMMSAdapter::ReplaceAPL( TInt aIapId, TInt aPos )

   875     {

   876     if( iMmsSettings->AccessPoint( aPos ) != KErrNotFound )

   877         {

   878         iMmsSettings->DeleteAccessPointL( aPos );

   879         }

   880     iMmsSettings->AddAccessPointL( aIapId, aPos );

   881     }

   882 

   883 // -----------------------------------------------------------------------------

   884 // CNSmlDmMMSAdapter::UpdateMMSAddrL()

   885 // Executes the buffered MMSSAddr update command. 

   886 // This command is called from CompleteOutstandingCmdsL() 

   887 // -----------------------------------------------------------------------------

   888 CSmlDmAdapter::TError CNSmlDmMMSAdapter::UpdateMMSAddrL()

   889     {

   890     _DBG_FILE("CNSmlDmMMSAdapter::UpdateMMSAddrL(): begin");

   891     CSmlDmAdapter::TError status = CSmlDmAdapter::EOk;

   892 

   893     TBool ok = EFalse;

   894     TUint32 wapid = iMmsSettings->AccessPoint(KNSmlDMMMSFirstAccessPointId);

   895     

   896     //Check if locked , if locked unlock else execute normal sequence.

   897         

   898         TBool reclock = EFalse;

   899         TBool lockerror =KErrNone;

   900         reclock = IsWAPAccessPointRecordLockedL(wapid);

   901         if(reclock)

   902         {

   903         	_DBG_FILE("CNSmlDmMMSAdapter::UpdateMMSAddrL():making record unlock");

   904         	//unlock the record

   905         	lockerror = DoProtectWAPAccessRecordL(wapid,EFalse);

   906         	_DBG_FILE("CNSmlDmMMSAdapter::UpdateMMSAddrL():record unlocked with error as ");

   907         	DBG_ARGS(_S("err = %d"), lockerror);

   908         }

   909         

   910     

   911     CCommsDbTableView* tableView=0;

   912     tableView = iDatabase->OpenViewMatchingUintLC(TPtrC(WAP_ACCESS_POINT),

   913                                                TPtrC(COMMDB_ID), wapid );        

   914     if(tableView->GotoFirstRecord()==KErrNone)

   915         {

   916         _DBG_FILE("CNSmlDmMMSAdapter::UpdateMMSAddrL(): GotoFirstRecord");

   917         

   918         

   919         //If it was unlocked, lock it again

   920         

   921         if(lockerror == KErrNone)

   922         {

   923         	TInt err = tableView->UpdateRecord();

   924         	if(err == KErrNone)

   925         	{

   926         		HBufC* object = HBufC::NewLC(iMMSSAddr->Length());

   927         TPtr obPtr = object->Des();

   928         CnvUtfConverter::ConvertToUnicodeFromUtf8( obPtr, *iMMSSAddr);

   929 

   930         TRAPD(err,tableView->WriteLongTextL(TPtrC(WAP_START_PAGE),obPtr));

   931         DBG_ARGS(_S("err = %d"), err);

   932         if(err==KErrNone)

   933             {

   934             _DBG_FILE("CNSmlDmMMSAdapter::UpdateMMSAddrL(): Write OK");

   935             tableView->PutRecordChanges();

   936             ok = ETrue;

   937             }

   938         CleanupStack::PopAndDestroy(); //object

   939         

   940         	}

   941         	

   942         }

   943         

   944         }

   945     CleanupStack::PopAndDestroy(1); //tableview  //, commDb--iDatabase

   946 if(reclock)

   947         	{

   948         		TInt err = DoProtectWAPAccessRecordL(wapid,ETrue);

   949         	_DBG_FILE("CNSmlDmMMSAdapter::UpdateMMSAddrL():record again locked with error as ");

   950         	 DBG_ARGS(_S("err = %d"), err);

   951         	 reclock = EFalse;

   952         	}

   953     if(!ok)

   954         {

   955         status = CSmlDmAdapter::EError;

   956         }

   957 

   958     _DBG_FILE("CNSmlDmMMSAdapter::UpdateMMSAddrL(): end");

   959     return status;

   960     }

   961 

   962 // -----------------------------------------------------------------------------

   963 // CNSmlDmMMSAdapter::DesToInt()

   964 // Converts a 16 bit descriptor to TInt

   965 // -----------------------------------------------------------------------------

   966 TInt CNSmlDmMMSAdapter::DesToInt(const TDesC& aLuid)

   967     {

   968     TLex16 lex(aLuid);

   969     TInt value = 0;

   970     lex.Val(value);

   971     return value;

   972     }

   973 

   974 

   975 // -----------------------------------------------------------------------------

   976 // TPtrC8 CNSmlDmMMSAdapter::RemoveLastURISeg(const TDesC8& aURI)

   977 // returns parent uri, i.e. removes last uri segment

   978 // -----------------------------------------------------------------------------

   979 TPtrC8 CNSmlDmMMSAdapter::RemoveLastURISeg(const TDesC8& aURI)

   980     {

   981     TInt i;

   982     for(i=aURI.Length()-1;i>=0;i--)

   983         {

   984         if(aURI[i]==KNSmlDMMMSSeparatorDef)

   985             {

   986             break;

   987             }

   988         }

   989     return aURI.Left(i);

   990     }

   991 

   992 

   993 

   994 // -----------------------------------------------------------------------------

   995 // TInt CNSmlDmMMSAdapter::NumOfURISegs(const TDesC8& aURI)

   996 // Returns the num of uri segs

   997 // -----------------------------------------------------------------------------

   998 TInt CNSmlDmMMSAdapter::NumOfURISegs(const TDesC8& aURI)

   999     {

  1000     TInt numOfURISegs = 1;

  1001     for(TInt i=0;i<aURI.Length();i++)

  1002         {

  1003         if(aURI[i]==KNSmlDMMMSSeparatorDef)

  1004             {

  1005             numOfURISegs++;

  1006             }

  1007         }

  1008     return numOfURISegs;

  1009     }

  1010 

  1011 

  1012 // -----------------------------------------------------------------------------

  1013 // TPtrC8 CNSmlDmMMSAdapter::LastURISeg(const TDesC8& aURI)

  1014 // Returns only the last uri segemnt

  1015 // -----------------------------------------------------------------------------

  1016 TPtrC8 CNSmlDmMMSAdapter::LastURISeg(const TDesC8& aURI)

  1017     {

  1018     _DBG_FILE("CNSmlDmMMSAdapter::LastURISeg() : begin");

  1019     TInt i;

  1020     for(i=aURI.Length()-1;i>=0;i--)

  1021         {

  1022         if(aURI[i]==KNSmlDMMMSSeparatorDef)

  1023             {

  1024             break;

  1025             }

  1026         }

  1027     _DBG_FILE("CNSmlDmMMSAdapter::LastURISeg() : end");

  1028     if(i==0)

  1029         {

  1030         return aURI;

  1031         }

  1032     else

  1033         {

  1034         return aURI.Mid(i+1);

  1035         }

  1036     }

  1037 

  1038 

  1039 // -----------------------------------------------------------------------------

  1040 // CNSmlDmMMSAdapter::CreateMMSClientL()

  1041 // Creates MMS client mtm

  1042 // -----------------------------------------------------------------------------

  1043 void CNSmlDmMMSAdapter::CreateMMSClientL()

  1044     {

  1045     if(iMmsClient ==0)

  1046         {

  1047         iMsvSession = CMsvSession::OpenSyncL( *this );

  1048         iClientMtmRegistry = CClientMtmRegistry::NewL(* iMsvSession );

  1049         iMmsClient = (CMmsClientMtm *) iClientMtmRegistry->

  1050             NewMtmL( KUidMsgTypeMultimedia );

  1051         iMmsClient->RestoreSettingsL();

  1052         iMmsSettings = CMmsSettings::NewL();

  1053         iMmsSettings->CopyL( iMmsClient->MmsSettings() );

  1054         }

  1055     }

  1056 

  1057 // -----------------------------------------------------------------------------

  1058 // CNSmlDmMMSAdapter::FillNodeInfoL()

  1059 // Fills the node info in ddf structure

  1060 // -----------------------------------------------------------------------------

  1061 void CNSmlDmMMSAdapter::FillNodeInfoL( MSmlDmDDFObject& aNode,

  1062                                        TSmlDmAccessTypes aAccTypes,

  1063                                        MSmlDmDDFObject::TOccurence aOccurrence, 

  1064                                        MSmlDmDDFObject::TScope aScope, 

  1065                                        MSmlDmDDFObject::TDFFormat aFormat,

  1066                                        const TDesC8& aDescription)

  1067     {

  1068     aNode.SetAccessTypesL(aAccTypes);

  1069     aNode.SetOccurenceL(aOccurrence);

  1070     aNode.SetScopeL(aScope);

  1071     aNode.SetDFFormatL(aFormat);

  1072     if(aFormat!=MSmlDmDDFObject::ENode)

  1073         {

  1074         aNode.AddDFTypeMimeTypeL(KNSmlDMMMSTextPlain);

  1075         }

  1076     aNode.SetDescriptionL(aDescription);

  1077 

  1078     }

  1079 

  1080 // -----------------------------------------------------------------------------

  1081 // CSmlDmAdapter::TError FetchObjectL(const TDesC8& aURI, const TDesC8& aObject)

  1082 // Fetches data object and returns it in parameter. 

  1083 // Return values according to CSmlDmAdapter::TError.

  1084 // -----------------------------------------------------------------------------

  1085 CSmlDmAdapter::TError CNSmlDmMMSAdapter::FetchObjectL(const TDesC8& aURI, 

  1086                                                       CBufBase& aObject)

  1087     {

  1088     _DBG_FILE("CNSmlDmMMSAdapter::FetchObjectL(): begin");

  1089     TRAPD(err, CreateMMSClientL());

  1090     if(err!=KErrNone)

  1091         {

  1092         _DBG_FILE("CNSmlDmMMSAdapter::FetchObjectL(): EError end");

  1093         return CSmlDmAdapter::EError;

  1094         }

  1095 

  1096     TMsvId id = iMmsSettings->Service();

  1097 

  1098     if(id == KMsvNullIndexEntryId||aURI.Find(KNSmlDMMMSAccount8)==KErrNotFound)

  1099         {

  1100         _DBG_FILE("CNSmlDmMMSAdapter::FetchObjectL(): ENotFound end");

  1101         return CSmlDmAdapter::ENotFound;

  1102         }

  1103 

  1104     TPtrC8 uriSeg = LastURISeg(aURI);

  1105     CSmlDmAdapter::TError status = CSmlDmAdapter::EOk;

  1106 

  1107     if(uriSeg.Compare(KNSmlDMMMSName)==0)

  1108         {

  1109         status = CSmlDmAdapter::ENotFound;

  1110         }

  1111     else if(uriSeg.Compare(KNSmlDMMMSMMRecep)==0)

  1112         {

  1113         TMmsReceivingMode rcvHome = iMmsSettings->ReceivingModeHome();

  1114         TMmsReceivingMode rcvForeign = iMmsSettings->ReceivingModeForeign();

  1115         if ( rcvHome == EMmsReceivingAutomatic )

  1116             {

  1117             if ( rcvForeign == EMmsReceivingAutomatic )

  1118                 {

  1119                 aObject.InsertL( 0, KNSmlDMMMSValueAlwaysOn );

  1120                 }

  1121             else

  1122                 {

  1123                 aObject.InsertL( 0, KNSmlDMMMSValueAutomaticAtHome );

  1124                 }

  1125             }

  1126         else if ( rcvHome == EMmsReceivingReject )

  1127             {

  1128             aObject.InsertL( 0, KNSmlDMMMSValueOff );

  1129             }

  1130         else if ( rcvHome == EMmsReceivingManual )

  1131             {

  1132             aObject.InsertL( 0, KNSmlDMMMSValueAlwaysManual );

  1133             }

  1134         else

  1135             {