/*
* Copyright (c) 2004 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Token and TokenType implementation for TrustSettingsStore
*
*/



// INCLUDE FILES
#include    "WimDummyToken.h"
#include    "WimTrace.h"


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

// -----------------------------------------------------------------------------
// CWimDummyToken::CWimDummyToken
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CWimDummyToken::CWimDummyToken( MCTTokenType& aTokenType )
    : iTokenType( aTokenType )
    {
    _WIMTRACE(_L("WIM | WIMUtil | CWimDummyToken::CWimDummyToken | Begin"));
    }

// -----------------------------------------------------------------------------
// CWimDummyToken::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CWimDummyToken::ConstructL()
    {
    _WIMTRACE(_L("WIM | WIMUtil | CWimDummyToken::ConstructL | Begin"));
    iCount = -1; // -1 instead of 0 because of different construction method
    }

// -----------------------------------------------------------------------------
// CWimDummyToken::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CWimDummyToken* CWimDummyToken::NewL( MCTTokenType& aTokenType )
    {
    _WIMTRACE(_L("WIM | WIMUtil | CWimDummyToken::NewL | Begin"));
    CWimDummyToken* self = new( ELeave ) CWimDummyToken( aTokenType );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();
    return self;
    }

// Destructor
CWimDummyToken::~CWimDummyToken()
    {
    _WIMTRACE(_L("WIM | WIMUtil | CWimDummyToken::~CWimDummyToken | Begin"));
    delete iSerialNumber;
    }

// -----------------------------------------------------------------------------
// CWimDummyToken::Label()
// Get the label from current token
// -----------------------------------------------------------------------------
//
const TDesC& CWimDummyToken::Label()
    {
    _WIMTRACE ( _L( "CWimDummyToken::Label()" ) );
    return KNullDesC;
    }

// -----------------------------------------------------------------------------
// CWimDummyToken::Information()
// Returns the specified information string about the token
// -----------------------------------------------------------------------------
//
const TDesC& CWimDummyToken::Information( 
    TTokenInformation aRequiredInformation )
    {
    _WIMTRACE ( _L( "CWimDummyToken::Information()" ) );

    switch ( aRequiredInformation ) 
        {
        case ESerialNo: // Returns the Serialnumber from current token
            {
            return *iSerialNumber;
            }
        default:    // Returns empty string 
            {
            break;
            }
        }

    return KNullDesC;
    }

// -----------------------------------------------------------------------------
// MCTTokenType& CWimDummyToken::TokenType()
// Returns the associated token type.
// -----------------------------------------------------------------------------
//
MCTTokenType& CWimDummyToken::TokenType()
    {
    _WIMTRACE ( _L( "CWimDummyToken::TokenType()" ) );
    return iTokenType;
    }

// -----------------------------------------------------------------------------
// TCTTokenHandle CWimDummyToken::Handle()
// Returns the token's handle. TCTTokenHandle defines a handle to a subclass 
// of the MCTToken class
// WimSecModule()->TokenNumber retrieves the token actually exists. 
// Values 0..7 are for hardware tokens. Value 255 is for SoftId-token.
// -----------------------------------------------------------------------------
//
TCTTokenHandle CWimDummyToken::Handle()
    {
    _WIMTRACE ( _L( "CWimDummyToken::Handle()" ) );
    return TCTTokenHandle( TokenType().Type(), 0 );
    }

// -----------------------------------------------------------------------------
// CWimDummyToken::DoGetInterface()
// Returns a valid interface and KErrNone, or interface = NULL and 
// KErrNotSupported if it isn't supported by this token
// -----------------------------------------------------------------------------
// 
void CWimDummyToken::DoGetInterface(
    TUid /*aRequiredInterface*/,
    MCTTokenInterface*& /*aReturnedInterface*/,
    TRequestStatus& /*aStatus*/ )
    {
    _WIMTRACE ( _L( "CWimDummyToken::DoGetInterface()" ) );
    }

// -----------------------------------------------------------------------------
// CWimDummyToken::DoCancelGetInterface()
// Nothing to do
// -----------------------------------------------------------------------------
//
TBool CWimDummyToken::DoCancelGetInterface()
    {
    _WIMTRACE ( _L( "CWimDummyToken::DoCancelGetInterface()" ) );
    return EFalse;
    }

// -----------------------------------------------------------------------------
// CWimDummyToken::ReferenceCount()
// Returns a reference to reference counter.
// -----------------------------------------------------------------------------
//
TInt& CWimDummyToken::ReferenceCount()
    {
    _WIMTRACE ( _L( "CWimDummyToken::ReferenceCount()" ) );
    return iCount;
    }

// -----------------------------------------------------------------------------
// CWimDummyToken::NotifyOnRemoval( TRequestStatus& aStatus )
// Notifies the client when the token has been removed.
// -----------------------------------------------------------------------------
//
void CWimDummyToken::NotifyOnRemoval( TRequestStatus& /*aStatus*/ )
    {
    _WIMTRACE ( _L( "CWimDummyToken::NotifyOnRemoval()" ) );
    }

// -----------------------------------------------------------------------------
// CWimDummyToken::CancelNotify()
// Cancels the NotifyOnRemoval request.
// -----------------------------------------------------------------------------
//
void CWimDummyToken::CancelNotify()
    {
    _WIMTRACE ( _L( "CWimDummyToken::CancelNotify()" ) );
    }

// -----------------------------------------------------------------------------
// CWimDummyToken::SetSerialNumber()
// Sets serial number for token
// -----------------------------------------------------------------------------
//
void CWimDummyToken::SetSerialNumber( TDesC& aSerialNumber )
    {
    _WIMTRACE ( _L( "CWimDummyToken::SetSerialNumber()" ) );
    if ( iSerialNumber )
        {
        delete iSerialNumber;
        iSerialNumber = NULL;
        }

    TRAPD( err, iSerialNumber = HBufC::NewL( aSerialNumber.Length() ) );
    if ( err != KErrNone )
        {
        return;
    	  }
    TPtr serialNbr = iSerialNumber->Des();
    serialNbr.Copy( aSerialNumber );
    }


// ============== TokenType ====================================================

// -----------------------------------------------------------------------------
// CWimDummyTokenType::CWimDummyTokenType()
// Default constructor
// -----------------------------------------------------------------------------
//
CWimDummyTokenType::CWimDummyTokenType()
    {
    _WIMTRACE ( _L( "CWimDummyToken::CWimDummyTokenType()" ) );
    }

// -----------------------------------------------------------------------------
// CWimDummyTokenType::ConstructL()
// Second phase constructor
// -----------------------------------------------------------------------------
//
void CWimDummyTokenType::ConstructL()
    {
    _WIMTRACE ( _L( "CWimDummyTokenType::ConstructL()" ) );
    }

// -----------------------------------------------------------------------------
// CWimDummyTokenType::NewL()
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CWimDummyTokenType* CWimDummyTokenType::NewL() 
    {
    _WIMTRACE ( _L( "CWimDummyToken::NewL()" ) );
    CWimDummyTokenType* that = new( ELeave ) CWimDummyTokenType();
    CleanupStack::PushL( that );
    that->ConstructL();
    CleanupStack::Pop();
    return that;
    }

// -----------------------------------------------------------------------------
// CWimDummyTokenType::~CWimDummyTokenType()
// Destructor.
// -----------------------------------------------------------------------------
//
CWimDummyTokenType::~CWimDummyTokenType()
    {
    _WIMTRACE ( _L( "CWimDummyTokenType::~CWimDummyTokenType()" ) );

    }

// -----------------------------------------------------------------------------
// CWimDummyTokenType::List()
// List all the tokens of this type.
// -----------------------------------------------------------------------------
//
void CWimDummyTokenType::List(
    RCPointerArray<HBufC>& /*aTokens*/,
    TRequestStatus& /*aStatus*/ )
    {
    _WIMTRACE ( _L( "CWimDummyToken::List()" ) );
    }

// -----------------------------------------------------------------------------
// CWimDummyTokenType::CancelList()
// Cancel a list operation.
// -----------------------------------------------------------------------------
//
void CWimDummyTokenType::CancelList()
    {
    _WIMTRACE ( _L( "CWimDummyTokenType::CancelList" ) );
    }

// -----------------------------------------------------------------------------
// CTokenTypeImplementation::OpenToken() 
// Opens new token, which name is specified in aTokenInfo
// This is not true asynchronous function.
// -----------------------------------------------------------------------------
//
void CWimDummyTokenType::OpenToken(
    const TDesC& /*aTokenInfo*/,
    MCTToken*& /*aToken*/,
    TRequestStatus& /*aStatus*/ )
    { 
    _WIMTRACE ( _L( "CWimDummyTokenType::OpenToken with name" ) );
    }

// -----------------------------------------------------------------------------
// CWimDummyTokenType::OpenToken()
// Open new token, The handle of the required token is used to get needed 
// information. Before opening new token we need to compare token numbers.
// This is not true asynchronous function.
// -----------------------------------------------------------------------------
//
void CWimDummyTokenType::OpenToken(
    TCTTokenHandle /*aHandle*/,
    MCTToken*& /*aToken*/,
    TRequestStatus& /*aStatus*/ )
    {
    _WIMTRACE ( _L( "CWimDummyTokenType::OpenToken with handle" ) );
    }
// -----------------------------------------------------------------------------
// CWimDummyTokenType::CancelOpenToken()
// Cancel an OpenToken operation.
// -----------------------------------------------------------------------------
//
void CWimDummyTokenType::CancelOpenToken()
    {
    _WIMTRACE ( _L( "CWimDummyTokenType::CancelOpenToken" ) );
    }


//  End of File