/*
* Copyright (c) 2008 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:
 *
*/


// INCLUDE FILES
#include "cstspinattributes.h"

namespace java
{
namespace satsa
{

// CONSTANTS

//0000 0000 1000 0000 -->9. bit from left but first byte ignored
const TUint8 KSTSDisableAllowed = 0x80;

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

// -----------------------------------------------------------------------------
// CSTSPinAttributes::CSTSPinAttributes
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CSTSPinAttributes::CSTSPinAttributes()
{
    iPinType = ENotInitialized;
    iMaxLength = KErrNotFound;
}

// -----------------------------------------------------------------------------
// CSTSPinAttributes::CSTSPinAttributes
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CSTSPinAttributes::CSTSPinAttributes(TInt aPinType, TInt aMinLength,
                                     TInt aStoredLength, TInt aMaxLength, TInt aPinReference)
{

    iPinType = (TPinType) aPinType;

    //if maxLenght is zero or less it is not found correctly
    if (aMaxLength <= 0)
    {
        iMaxLength = KErrNotFound;
    }
    else
    {
        iMaxLength = aMaxLength;
    }

    iMinLength = aMinLength;
    iStoredLength = aStoredLength;

    iPinReference = aPinReference;

}

// -----------------------------------------------------------------------------
// CSTSPinAttributes::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CSTSPinAttributes::ConstructL()
{
    // creating with empty values
    iPinFlags = KNullDesC8().AllocL();
    iPadChar = KNullDesC8().AllocL();
}

// -----------------------------------------------------------------------------
// CSTSPinAttributes::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CSTSPinAttributes::ConstructL(TInt aPadChar, TInt aFlags)
{
    // creating with empty values
    iPinFlags = HBufC8::NewL(2);//pinflags contains maximum of two bytes of data
    iPinFlags->Des().Append(aFlags);
    iPadChar = HBufC8::NewL(1);
    iPadChar->Des().Append(aPadChar);
}

// -----------------------------------------------------------------------------
// CSTSPinAttributes::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CSTSPinAttributes* CSTSPinAttributes::NewLC(TInt aPinType, TInt aMinLength,
        TInt aStoredLength, TInt aMaxLength, TInt aPinReference, TInt aPadChar,
        TInt aFlags)
{
    CSTSPinAttributes
    * self =
        new(ELeave) CSTSPinAttributes(aPinType, aMinLength, aStoredLength, aMaxLength, aPinReference);
    CleanupStack::PushL(self);
    self->ConstructL(aPadChar, aFlags);
    return self;
}

// -----------------------------------------------------------------------------
// CSTSPinAttributes::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CSTSPinAttributes* CSTSPinAttributes::NewL()
{
    CSTSPinAttributes* self = new(ELeave) CSTSPinAttributes();

    return self;
}

// Destructor
CSTSPinAttributes::~CSTSPinAttributes()
{
    delete iPinFlags;
    delete iPadChar;
}

// -----------------------------------------------------------------------------
// CSTSPinAttributes::PinType
// Getter for PIN type
// -----------------------------------------------------------------------------
CSTSPinAttributes::TPinType CSTSPinAttributes::PinType() const
{
    return iPinType;
}

// -----------------------------------------------------------------------------
// CSTSPinAttributes::MinLength
// Getter for PIN minimum length
// -----------------------------------------------------------------------------
TInt CSTSPinAttributes::MinLength() const
{
    return iMinLength;
}

// -----------------------------------------------------------------------------
// CSTSPinAttributes::StoredLength
// Getter for PIN stored lenght
// -----------------------------------------------------------------------------

TInt CSTSPinAttributes::StoredLength() const
{
    return iStoredLength;
}

// -----------------------------------------------------------------------------
// CSTSPinAttributes::MaxLength
// Getter for PIN maximum length
// -----------------------------------------------------------------------------

TInt CSTSPinAttributes::MaxLength() const
{
    return iMaxLength;
}

// -----------------------------------------------------------------------------
// CSTSPinAttributes::PinReference
// Getter for PIN reference
// -----------------------------------------------------------------------------

TUint8 CSTSPinAttributes::PinReference() const
{
    return iPinReference;
}

// -----------------------------------------------------------------------------
// CSTSPinAttributes::PadChar
// Getter for padding character
// -----------------------------------------------------------------------------

const TDesC8& CSTSPinAttributes::PadChar() const
{
    return *iPadChar;
}

// -----------------------------------------------------------------------------
// CSTSPinAttributes::CopyL
// Takes information from parameter and sets it, takes copy
// -----------------------------------------------------------------------------
void CSTSPinAttributes::CopyL(const CSTSPinAttributes& aPinAttributes)
{
    HBufC8* tmpPinFlags = aPinAttributes.iPinFlags->AllocL();
    delete iPinFlags;
    iPinFlags = tmpPinFlags;

    iPinType = aPinAttributes.PinType();
    iMinLength = aPinAttributes.MinLength();
    iStoredLength = aPinAttributes.StoredLength();
    iMaxLength = aPinAttributes.MaxLength();
    iPinReference = aPinAttributes.PinReference();

    HBufC8* tmpPadChar = aPinAttributes.PadChar().AllocL();
    delete iPadChar;
    iPadChar = tmpPadChar;
}

// -----------------------------------------------------------------------------
// CSTSPinAttributes::IsPinFlagSet
// Uses mask to find out is flag set or not. Mask is already set in header file
// where TFlagType is defined. Supports only case sensitive and needs-padding
// flags.
// -----------------------------------------------------------------------------
TBool CSTSPinAttributes::IsPinFlagSet(TFlagType aFlagType) const
{

    TBool returnValue = EFalse;
    TInt8 correctByte = 0x00;

    //case sensitive, needs-padding, change-disabled and unblock-disabled
    //information will be found from first byte
    TInt index = 0;

    //disable allowed information will be found from second byte
    if (aFlagType == EDisableAllowed)
    {
        //special case because value is in second byte of iPinFlags
        //and thats why when presenting flagtype in one byte form
        //DisableAllowed has same value than ECaseSensitive flag.
        //Thats why own constant for disable allowed.
        aFlagType = (TFlagType) KSTSDisableAllowed;
    }

    if (iPinFlags->Length() > index)
    {
        correctByte = iPinFlags->Ptr()[index];
        //check is wanted bit set or not
        returnValue = ((aFlagType & correctByte) == aFlagType);
    }
    //if correctByte is missing, we return EFalse
    return returnValue;
}

} // namespace satsa
} // namespace java
//  End of File