1 /*

     2 * Copyright (c) 2008 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:  contains id and uid

    15 *

    16 */

    17 

    18 

    19 #include "pluginmap.h"

    20 

    21 namespace hspswrapper{

    22 

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

    24 // ---------------------------------------------------------------------------

    25 //

    26 CPluginMap::CPluginMap()

    27     {

    28     }

    29 

    30 

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

    32 // ---------------------------------------------------------------------------

    33 //

    34 void CPluginMap::ConstructL()

    35     {

    36     }

    37 

    38 

    39 // ---------------------------------------------------------------------------

    40 // ---------------------------------------------------------------------------

    41 //

    42 EXPORT_C CPluginMap* CPluginMap::NewL()

    43     {

    44     CPluginMap* self = CPluginMap::NewLC();

    45     CleanupStack::Pop( self );

    46     return self;

    47     }

    48 

    49 

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

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

    52 //

    53 EXPORT_C CPluginMap* CPluginMap::NewLC()

    54     {

    55     CPluginMap* self = new( ELeave ) CPluginMap;

    56     CleanupStack::PushL( self );

    57     self->ConstructL();

    58     return self;

    59     }

    60 

    61 

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

    63 // ---------------------------------------------------------------------------

    64 //

    65 EXPORT_C CPluginMap::~CPluginMap()

    66     {

    67     delete iPluginId;

    68     delete iPluginUid;

    69     delete iActivationState;

    70     }

    71 

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

    73 // ---------------------------------------------------------------------------

    74 //

    75 EXPORT_C CPluginMap& CPluginMap::SetPluginIdL(const TDesC8& aPluginId)

    76     {

    77     delete iPluginId;

    78     iPluginId = NULL;

    79     iPluginId = aPluginId.AllocL();

    80     return *this;

    81     }

    82     

    83 // ---------------------------------------------------------------------------

    84 // ---------------------------------------------------------------------------

    85 //

    86 EXPORT_C const TDesC8& CPluginMap::PluginId()const

    87     {

    88     if(iPluginId)

    89        {

    90        return *iPluginId;

    91        }

    92     else

    93        {

    94        return KNullDesC8;

    95        }

    96     }

    97     

    98 // ---------------------------------------------------------------------------

    99 // ---------------------------------------------------------------------------

   100 //

   101 EXPORT_C CPluginMap& CPluginMap::SetPluginUidL(const TDesC8& aPluginUid)

   102     {

   103     delete iPluginUid;

   104     iPluginUid = NULL;

   105     iPluginUid = aPluginUid.AllocL();

   106     return *this;

   107     }

   108     

   109 // ---------------------------------------------------------------------------

   110 // ---------------------------------------------------------------------------

   111 //

   112 EXPORT_C const TDesC8& CPluginMap::PluginUid()const

   113     {

   114     if(iPluginUid)

   115        {

   116        return *iPluginUid;

   117        }

   118     else

   119        {

   120        return KNullDesC8;

   121        }

   122     }

   123 

   124 // ---------------------------------------------------------------------------

   125 // ---------------------------------------------------------------------------

   126 //

   127 EXPORT_C CPluginMap& CPluginMap::SetActivationStateL(const TDesC8& aState)

   128     {

   129     delete iActivationState;

   130     iActivationState = NULL;

   131     iActivationState = aState.AllocL();

   132     return *this;    

   133     }

   134 

   135 // ---------------------------------------------------------------------------

   136 // ---------------------------------------------------------------------------

   137 //

   138 EXPORT_C TBool CPluginMap::ActivationState()const

   139     {

   140     if( iActivationState )

   141         {               

   142         return ( *iActivationState == _L8("1") ) ? ETrue : EFalse; 

   143         }

   144     

   145     return EFalse;

   146     }

   147 

   148 // ---------------------------------------------------------------------------

   149 // ---------------------------------------------------------------------------

   150 //

   151 EXPORT_C CPluginMap& CPluginMap::SetLockingStatusL( const TDesC8& aLockingStatus )

   152     {

   153     delete iLockingStatus;

   154     iLockingStatus = NULL;

   155     iLockingStatus = aLockingStatus.AllocL();

   156     return *this;

   157     }

   158 

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

   160 // ---------------------------------------------------------------------------

   161 //

   162 EXPORT_C const TDesC8& CPluginMap::LockingStatus() const

   163     {

   164     if ( iLockingStatus )

   165         {

   166         return *iLockingStatus;

   167         }

   168     else

   169         {

   170         return KNullDesC8;

   171         }

   172     }

   173 

   174 }