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 Tree module

    15  *

    16  */

    17 

    18 #include <utf.h>

    19 #include <smldmadapter.h>

    20 #include "nsmldmiapmatcher.h"

    21 

    22 

    23 // -----------------------------------------------------------------------------

    24 // CNSmlDMIAPMatcher* CNSmlDMIAPMatcher::NewL( MSmlDmCallback* aDmCallback )

    25 // -----------------------------------------------------------------------------

    26 CNSmlDMIAPMatcher* CNSmlDMIAPMatcher::NewL(MSmlDmCallback* aDmCallback)

    27     {

    28     CNSmlDMIAPMatcher* self = CNSmlDMIAPMatcher::NewLC(aDmCallback);

    29     CleanupStack::Pop();

    30     return self;

    31     }

    32 

    33 // -----------------------------------------------------------------------------

    34 // CNSmlDMIAPMatcher* CNSmlDMIAPMatcher::NewLC( MSmlDmCallback* aDmCallback )

    35 // -----------------------------------------------------------------------------

    36 CNSmlDMIAPMatcher* CNSmlDMIAPMatcher::NewLC(MSmlDmCallback* aDmCallback)

    37     {

    38     CNSmlDMIAPMatcher* self = new( ELeave ) CNSmlDMIAPMatcher;

    39     CleanupStack::PushL(self);

    40     self->ConstructL(aDmCallback);

    41     return self;

    42     }

    43 

    44 // -----------------------------------------------------------------------------

    45 // void CNSmlDMIAPMatcher::ConstructL( MSmlDmCallback* aDmCallback )

    46 // -----------------------------------------------------------------------------

    47 void CNSmlDMIAPMatcher::ConstructL(MSmlDmCallback* aDmCallback)

    48     {

    49     iCallback = aDmCallback;

    50     }

    51 

    52 // -----------------------------------------------------------------------------

    53 // CNSmlDMIAPMatcher::~CNSmlDMIAPMatcher()

    54 // -----------------------------------------------------------------------------

    55 CNSmlDMIAPMatcher::~CNSmlDMIAPMatcher()

    56     {

    57     }

    58 

    59 // -----------------------------------------------------------------------------

    60 // TInt CNSmlDMIAPMatcher::IAPIdFromURIL( const TDesC8& aURI )

    61 // -----------------------------------------------------------------------------

    62 TInt CNSmlDMIAPMatcher::IAPIdFromURIL(const TDesC8& aURI)

    63     {

    64     TInt iapId(KErrNotFound);

    65 

    66     MSmlDmAdapter::TError status;

    67     CBufBase* allIAPs = CBufFlat::NewL(16);

    68     CleanupStack::PushL(allIAPs);

    69     iCallback->FetchLinkL(KNSmlDMIAPUri, *allIAPs, status);

    70     TPtrC8 uri = RemoveDotSlash(aURI);

    71 

    72     if (status == MSmlDmAdapter::EOk && uri.Find(KNSmlDMIAPUri) == 0

    73             && allIAPs->Ptr(0).Find(LastURISeg(uri))>=0)

    74         {

    75         HBufC8* luid = iCallback->GetLuidAllocL(uri);

    76 

    77         if (luid->Length() )

    78             {

    79             iapId = DesToInt(*luid);

    80             }

    81         delete luid;

    82         }

    83 

    84     CleanupStack::PopAndDestroy(allIAPs);

    85 

    86     return iapId;

    87     }

    88 

    89 // -----------------------------------------------------------------------------

    90 // HBufC8* CNSmlDMIAPMatcher::URIFromIAPIdL( TInt aIAPId )

    91 // -----------------------------------------------------------------------------

    92 HBufC8* CNSmlDMIAPMatcher::URIFromIAPIdL(TInt aIAPId)

    93     {

    94     CBufBase *allIAPs = CBufFlat::NewL(16);

    95     CleanupStack::PushL(allIAPs);

    96     MSmlDmAdapter::TError status;

    97 

    98     iCallback->FetchLinkL(KNSmlDMIAPUri, *allIAPs, status);

    99 

   100     if (status == MSmlDmAdapter::EOk)

   101         {

   102         TInt index(0);

   103         TInt segStart(0);

   104 

   105         while (index != KErrNotFound)

   106             {

   107             TPtrC8 allIAPsptr = allIAPs->Ptr(segStart).Mid(0);

   108             index = allIAPsptr.Locate('/');

   109             HBufC8* uriSeg = 0;

   110 

   111             if (index == KErrNotFound)

   112                 {

   113                 TPtrC8 uriSeg8Ptr = allIAPs->Ptr(segStart);

   114                 uriSeg = uriSeg8Ptr.AllocLC();

   115                 }

   116             else

   117                 {

   118                 TPtrC8 uriSeg8Ptr = allIAPs->Ptr(segStart).Mid( 0, index);

   119                 uriSeg = uriSeg8Ptr.AllocLC();

   120                 }

   121 

   122             HBufC8* uri = HBufC8::NewLC(KNSmlDMIAPUri().Length() + 1 + uriSeg->Length() );

   123 

   124             TPtr8 uriPtr = uri->Des();

   125             uriPtr.Format(KNSmlDMIAPUri);

   126             uriPtr.Append(KNSmlDMSeparator8);

   127             uriPtr.Append( *uriSeg);

   128             HBufC8* luid = iCallback->GetLuidAllocL(uriPtr);

   129             CleanupStack::PushL(luid);

   130 

   131             if (luid->Length() > 0)

   132                 {

   133                 TInt iapId = DesToInt(luid->Des());

   134                 if (iapId == aIAPId)

   135                     {

   136                     CleanupStack::PopAndDestroy(); //luid

   137                     CleanupStack::Pop(); //uri

   138                     CleanupStack::PopAndDestroy(2); //uriSeg, allIAPs

   139                     return uri;

   140                     }

   141                 }

   142             CleanupStack::PopAndDestroy(3); // luid, uri, uriSeg

   143 

   144             segStart += index + 1;

   145             }

   146         }

   147 

   148     CleanupStack::PopAndDestroy(); // allIAPs

   149 

   150     return 0;

   151     }

   152 

   153 // -----------------------------------------------------------------------------

   154 // TInt CNSmlDMIAPMatcher::DesToInt(const TDesC& aLuid)

   155 // -----------------------------------------------------------------------------

   156 TInt CNSmlDMIAPMatcher::DesToInt(const TDesC8& aLuid)

   157     {

   158     TLex8 lex(aLuid);

   159     TInt value = 0;

   160     lex.Val(value);

   161     return value;

   162     }

   163 

   164 // -----------------------------------------------------------------------------

   165 // TPtrC8 CNSmlDMIAPMatcher::RemoveDotSlash(const TDesC8& aURI) const

   166 // -----------------------------------------------------------------------------

   167 TPtrC8 CNSmlDMIAPMatcher::RemoveDotSlash(const TDesC8& aURI) const

   168     {

   169     if (aURI.Find(KNSmlDMIAPUriDotSlash)==0)

   170         {

   171         return aURI.Right(aURI.Length()-KNSmlDMIAPUriDotSlash().Length() );

   172         }

   173     else

   174         {

   175         return aURI;

   176         }

   177     }

   178 

   179 // -----------------------------------------------------------------------------

   180 // CNSmlDMIAPMatcher::TPtrC8 LastURISeg(const TDesC8& aURI)

   181 // Returns only the last uri segemnt

   182 // -----------------------------------------------------------------------------

   183 TPtrC8 CNSmlDMIAPMatcher::LastURISeg(const TDesC8& aURI) const

   184     {

   185     TInt i;

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

   187         {

   188         if (aURI[i]==KNSmlDMSlash)

   189             {

   190             break;

   191             }

   192         }

   193     if (i==0)

   194         {

   195         return aURI;

   196         }

   197     else

   198         {

   199         return aURI.Mid(i+1);

   200         }

   201     }

   202