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


#include "stubdataholder.h"


CProfileName::~CProfileName()
    {
    delete iName;
    }


TInt CProfileName::Id() const
    {
    return iId;
    }


const TDesC& CProfileName::Name() const
    {
    if( iName )
        {
        return *iName;
        }
    return KNullDesC;
    }

const TDesC& CProfileName::NaviName() const
    {
    if( iNaviName )
        {
        return *iNaviName;
        }
    return KNullDesC;
    }

const TDesC& CProfileName::TitleName() const
    {
    if( iTitleName )
        {
        return *iTitleName;
        }
    return KNullDesC;
    }


void CProfileName::SetL( const TDesC& aName, TInt aId )
    {
    delete iName;
    iName = NULL;
    iName = aName.AllocL();
    iId = aId;
    }


const TDesC& CProfileName::ShortName() const
	{
    if( iName )
        {
        return *iName;
        }
    return KNullDesC;
	}


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

// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
CStubDataHolder::CStubDataHolder()
    {
    }


// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
void CStubDataHolder::ConstructL()
    {
    iProfile = new( ELeave ) CProfileName;

    User::LeaveIfError( Dll::SetTls( this ) );
    }


// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
EXPORT_C CStubDataHolder* CStubDataHolder::InstanceL()
    {
    CStubDataHolder* ptr = static_cast<CStubDataHolder*>( Dll::Tls() );

    if( ptr )
        {
        return ptr;
        }

    CStubDataHolder* self = new( ELeave ) CStubDataHolder;
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }


EXPORT_C CStubDataHolder* CStubDataHolder::Instance()
    {
    CStubDataHolder* ptr = static_cast<CStubDataHolder*>( Dll::Tls() );

    if( !ptr )
        {
        User::Panic( _L("StubDataHolder"), 1 );
        }

    return ptr;
    }


EXPORT_C void CStubDataHolder::Release()
    {
    CStubDataHolder* ptr = static_cast<CStubDataHolder*>( Dll::Tls() );

    if( ptr )
        {
        delete ptr;
        }
    }


// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//

// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
CStubDataHolder::~CStubDataHolder()
    {
    iSSSettingValues.Reset();
    iSSSettingsObservers.Reset();
    iProfileChangeObservers.Reset();
    delete iProfile;
    Dll::SetTls( NULL );
    }


// ---------------------------------------------------------------------------
// ?implementation_description
// ---------------------------------------------------------------------------
//
EXPORT_C void CStubDataHolder::AddProfileChangeObserverL( MProfileChangeObserver& aObserver, CBase* aOwner )
    {
    TProfileObserver obs;
    obs.iOwner = aOwner;
    obs.iObserver = &aObserver;
    User::LeaveIfError( iProfileChangeObservers.Append( obs ) );
    }


EXPORT_C void CStubDataHolder::RemoveProfileChangeObserver( CBase* aOwner )
    {
    const TInt count = iProfileChangeObservers.Count();
    
    for( TInt i( 0 ); i < count; i++ )
        {
        if( iProfileChangeObservers[i].iOwner == aOwner )        
            {
            iProfileChangeObservers.Remove( i );
            break;
            }
        }
    }


EXPORT_C RArray<TProfileObserver>& CStubDataHolder::ProfileChangeObservers()
    {
    return iProfileChangeObservers;
    }


EXPORT_C void CStubDataHolder::SetCurrentProfileL( const TDesC& aName, TInt aId )
    {
    iProfile->SetL( aName, aId );
    }


EXPORT_C MProfileName* CStubDataHolder::CurrentProfile()
    {
    return iProfile;
    }


EXPORT_C void CStubDataHolder::SetNWMessageObserver( MNWMessageObserver& aObserver, TNWInfo& aInfo )
    {
    iNWObserver = &aObserver;
    iNWInfo = &aInfo;
    }


EXPORT_C MNWMessageObserver* CStubDataHolder::NWMessageObserver()
    {
    return iNWObserver;
    }


EXPORT_C TNWInfo* CStubDataHolder::NWInfo()
    {
    return iNWInfo;
    }

// ---------------------------------------------------------------------------
// From class ?base_class.
// ?implementation_description
// ---------------------------------------------------------------------------
//
void CStubDataHolder::AddSSSettingsObserverL( MSSSettingsObserver& aObserver )
    {
    User::LeaveIfError( iSSSettingsObservers.Append( &aObserver ) );    
    };


TInt CStubDataHolder::GetSSSettingsValueL( TSSSettingsSetting aSetting )
    {
    const TInt count = iSSSettingValues.Count();
    
    for( TInt i( 0 ); i < count; i++ )    
        {
        if( iSSSettingValues[i].iSetting == aSetting )
            {
            return iSSSettingValues[i].iValue;
            }
        }
        
    User::Leave( KErrNotFound );
    return KErrNotFound;
    }
    

void CStubDataHolder::RemoveSSSettingsObserver( MSSSettingsObserver& aObserver )
    {
    const TInt count = iSSSettingsObservers.Count();
    
    for( TInt i( 0 ); i < count; i++ )
        {
        if( iSSSettingsObservers[i] == &aObserver )
            {
            iSSSettingsObservers.Remove( i );
            break;
            }
        }
    }
    

EXPORT_C RArray<MSSSettingsObserver*>& CStubDataHolder::SSSettingsObservers()
    {
    return iSSSettingsObservers;    
    }


EXPORT_C void CStubDataHolder::SetSSSettingsValueL( TSSSettingsSetting aSetting, TInt aValue )
    {
    TSSSettingsValue ss;
    ss.iSetting = aSetting;
    ss.iValue = aValue;
    User::LeaveIfError( iSSSettingValues.Append( ss ) );
    }


EXPORT_C void CStubDataHolder::RemoveSSSetting( TSSSettingsSetting aSetting )
    {
    const TInt count = iSSSettingValues.Count();
    
    for( TInt i( count - 1 ); i >= 0; i-- )    
        {
        if( iSSSettingValues[i].iSetting == aSetting )
            {
            iSSSettingValues.Remove( i );
            }
        }
    }