/*
* Copyright (c) 2006 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:  project specification
*
*/



// USER
#include "muswpadapter.h"
#include "muswpitem.h"
#include "mussettings.h"
#include "muslogger.h"

// SYSTEM
#include <muswpadapterresource.rsg>
#include <CWPCharacteristic.h>
#include <CWPParameter.h>
#include <utf.h>
#include <WPAdapterUtil.h>




// CONSTANTS

_LIT( KMusAppID, "w9017" );
_LIT8( KSipAppID8, "w9010" );

_LIT( KMusWpAdapterName, "muswpadapterresource" );

_LIT( KMUsWpCharacteristicNameCapability, "CAPABILITY" );
_LIT( KMUsWpCharacteristicNameActivation, "ACTIVATION" );

_LIT( KMusWpParamNameEdgeDtm, "EDGEDTM" );
_LIT( KMusWpParamNameInternetSignaling, "INTERNETSIGNALING" );
_LIT( KMusWpParamNameQuery, "QUERY" );
_LIT( KMusWpParamNameCondition, "CONDITION" );

const TUint32 KMusWpNotSet = 0;



// -----------------------------------------------------------------------------
// Symbian two-phased constructor.
// -----------------------------------------------------------------------------
//
CMusWpAdapter* CMusWpAdapter::NewL()
    {
    MUS_LOG( "mus: [MUSWP]  ->  CMusWpAdapter::NewL" )
    CMusWpAdapter* self = new( ELeave ) CMusWpAdapter;
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    MUS_LOG( "mus: [MUSWP]  <- CMusWpAdapter::NewL" )
    return self;
    }


// -----------------------------------------------------------------------------
// Destructor.
// -----------------------------------------------------------------------------
//
CMusWpAdapter::~CMusWpAdapter()
    {
    MUS_LOG( "mus: [MUSWP]  -> CMusWpAdapter::~CMusWpAdapter" )
    delete iAppID;
    delete iWpItem;
    delete iNewWpItem;
    delete iSummaryTitle;
    MUS_LOG( "mus: [MUSWP]  <- CMusWpAdapter::~CMusWpAdapter" )
    }
    

// -----------------------------------------------------------------------------
// From base class CWAdapter. Definition of the pure virtual function.
// -----------------------------------------------------------------------------
//
TInt CMusWpAdapter::ItemCount() const
    {
    MUS_LOG( "mus: [MUSWP]  -> CMusWpAdapter::ItemCount()" )
    MUS_LOG( "mus: [MUSWP]  <- CMusWpAdapter::ItemCount()" )
    
    if ( iWpItem )
        {
        return 1;
        }

    return 0;
    }


// -----------------------------------------------------------------------------
// From base class CWAdapter. Definition of the pure virtual function.
// -----------------------------------------------------------------------------
//
const TDesC16& CMusWpAdapter::SummaryTitle( TInt /*aIndex*/ ) const
    {
    MUS_LOG( "mus: [MUSWP]  -> CMusWpAdapter::SummaryTitle()" )
    MUS_LOG( "mus: [MUSWP]  <- CMusWpAdapter::SummaryTitle()" )
    
    return *iSummaryTitle;
    }


// -----------------------------------------------------------------------------
// From base class CWAdapter. Definition of the pure virtual function.
// -----------------------------------------------------------------------------
//
const TDesC16& CMusWpAdapter::SummaryText( TInt /*aIndex*/ ) const
    {
    MUS_LOG( "mus: [MUSWP]  -> CMusWpAdapter::SummaryText( ... )" )
    if( iWpItem )
        {
        return iWpItem->Name();   
        }

    MUS_LOG( "mus: [MUSWP]  <- CMusWpAdapter::SummaryText( ... )" )
    return *iSummaryTitle;
    }


// -----------------------------------------------------------------------------
// From base class CWAdapter. Definition of the pure virtual function.
// -----------------------------------------------------------------------------
//
void CMusWpAdapter::SaveL( TInt /*aItem*/ )
    {
    MUS_LOG( "mus: [MUSWP]  -> CMusWpAdapter::SaveL" )
    
    if ( iWpItem )
        {
        iWpItem->SaveL();
        }
        
    MUS_LOG( "mus: [MUSWP]  <- CMusWpAdapter::SaveL" )
    }


// -----------------------------------------------------------------------------
// From base class CWAdapter. Definition of the pure virtual function.
// -----------------------------------------------------------------------------
//
TBool CMusWpAdapter::CanSetAsDefault( TInt /*aIndex*/ ) const
    {
    return EFalse;
    }


// -----------------------------------------------------------------------------
// From base class CWAdapter. Definition of the pure virtual function.
// -----------------------------------------------------------------------------
//
void CMusWpAdapter::SetAsDefaultL( TInt /*aIndex*/ )
    {
    User::Leave( KErrNotSupported );
    }


// -----------------------------------------------------------------------------
// From base class CWAdapter. Definition of the pure virtual function.
// -----------------------------------------------------------------------------
//
TInt CMusWpAdapter::DetailsL( TInt /*aItem*/, MWPPairVisitor& /*aVisitor */ )
    {
    return KErrNotSupported;
    }


// -----------------------------------------------------------------------------
// From base class CWPAdapter. Overrides the empty implementation of that class.
// -----------------------------------------------------------------------------
//
void CMusWpAdapter::SettingsSavedL( const TDesC8& aAppIdOfSavingItem,
                                     const TDesC8& aAppRef,
                                     const TDesC8& aStorageIdValue )
    {
    MUS_LOG( "mus: [MUSWP]  -> CMusWpAdapter::SettingsSavedL" )    

    // If settings are saved by SIPAdapter...
    if ( aAppIdOfSavingItem == KSipAppID8 )
        {
        // ...and are ment for us...
        if ( iWpItem )
            {
            HBufC8* tmpValue = HBufC8::NewLC( 4*iWpItem->ToAppRef().Length() );
            TPtr8 ptrTmpValue( tmpValue->Des() );
            CnvUtfConverter::ConvertFromUnicodeToUtf8( ptrTmpValue, 
                                                       iWpItem->ToAppRef() );
            
            if ( aAppRef == *tmpValue )
                {
                MUS_LOG( "   CMusWpAdapter, Prepared to save setting" )
                // ...prepare to save profile Id
                TLex8 lex( aStorageIdValue );
                User::LeaveIfError( lex.Val( iProfileId, EDecimal ) );
                iProfileIdReceived = ETrue;
                }
            
            CleanupStack::PopAndDestroy( tmpValue );
            }
        }    
    
    MUS_LOG( "mus: [MUSWP]  <- CMusWpAdapter::SettingsSavedL" )
    };


// -----------------------------------------------------------------------------
// From base class CWPAdapter. Overrides the empty implementation of that class.
// -----------------------------------------------------------------------------
//
void CMusWpAdapter::SavingFinalizedL()
    {
    MUS_LOG( "mus: [MUSWP]  -> CMusWpAdapter::SavingFinalizedL" )

    if ( iProfileIdReceived )
        {
        MultimediaSharingSettings::SetSipProfileSettingL( 
                                        static_cast<TInt>(iProfileId) );
        }
        
    MUS_LOG( "mus: [MUSWP]  <- CMusWpAdapter::SavingFinalizedL" )
    }


// -----------------------------------------------------------------------------
// From base class CWPAdapter, which derives this from MWPVisitor.
// Definition of the pure virtual function.
// -----------------------------------------------------------------------------
//
void CMusWpAdapter::VisitL( CWPCharacteristic& aCharacteristic )
    {
    MUS_LOG( "mus: [MUSWP]  -> CMusWpAdapter::VisitL (Characteristic)" )
    switch ( aCharacteristic.Type() )
        {
        case KWPApplication:
            {
            iNewWpItem = CMusWpItem::NewL();
           
            aCharacteristic.AcceptL( *this );
            
            // If Mus settings, store information
            if( iAppID && *iAppID == KMusAppID )
                {
                MUS_LOG( "   CMusWpAdapter, Mus Settings found" )
                delete iWpItem;
                iWpItem = iNewWpItem;
                }
            else
                {
                delete iNewWpItem;
                }
                
            iNewWpItem = NULL;
            break;
            }
        case KWPNamedCharacteristic:
            {
            if ( iNewWpItem )
                {
                // We are inside APPLICATION-characteristic
                if ( aCharacteristic.Name() == 
                        KMUsWpCharacteristicNameCapability() ||
                     aCharacteristic.Name() == 
                        KMUsWpCharacteristicNameActivation() )
                    {
                    aCharacteristic.AcceptL( *this );
                    }
                }
            break;
            }
        default:
            {
            break;
            }
        }
    MUS_LOG( "mus: [MUSWP]  <- CMusWpAdapter::VisitL (Characteristic)" )
    }


// -----------------------------------------------------------------------------
// From base class CWPAdapter, which derives this from MWPVisitor.
// Definition of the pure virtual function.
// -----------------------------------------------------------------------------
//
void CMusWpAdapter::VisitL( CWPParameter& aParameter )
    {
    MUS_LOG( "mus: [MUSWP]  -> CMusWpAdapter::VisitL (Parameter)" )
    
    switch ( aParameter.ID() )
        {
        case EWPNamedParameter: // Name is used instead of ID
            {
            if ( aParameter.Name() == KMusWpParamNameEdgeDtm() )
                {
                iNewWpItem->SetEdgeDtmSupport( ETrue );
                }
            else if ( aParameter.Name() == KMusWpParamNameInternetSignaling() )
                {
                iNewWpItem->SetForceInternetSignaling( ETrue );
                }
            else if ( aParameter.Name() == KMusWpParamNameQuery() )
                {
                iNewWpItem->SetCapabilityQuery( aParameter.Value() );
                }
            else if ( aParameter.Name() == KMusWpParamNameCondition() )
                {
                iNewWpItem->SetActivationCondition( aParameter.Value() );
                }
            else
                {
                // To keep PC-Lint happy
                }
            break;
            }
        case EWPParameterAppID: // APPLICATION/APPID
            {
	        delete iAppID; 
	        iAppID = NULL;
	        iAppID = aParameter.Value().AllocL();
            break;
            }
        case EWPParameterProviderID: // APPLICATION/PROVIDER-ID
            {
            iNewWpItem->SetProviderIdL( aParameter.Value() );
            break;
            }
        case EWPParameterName: // APPLICATION/NAME
            {
            iNewWpItem->SetNameL( aParameter.Value() );
            break;
            }
        case EWPParameterToAppRef: // APPLICATION/TO-APPREF
            {
            iNewWpItem->SetToAppRefL( aParameter.Value() );
            break;
            }
		default:
            {
			break;
            }
        }
    
    MUS_LOG( "mus: [MUSWP]  <- CMusWpAdapter::VisitL (Parameter)" )
    }


// -----------------------------------------------------------------------------
// From base class CWPAdapter, which derives this from MWPVisitor.
// Definition of the pure virtual function.
// -----------------------------------------------------------------------------
//
void CMusWpAdapter::VisitLinkL(CWPCharacteristic& /*aLink*/ )
    {
    // NOP
    }


// -----------------------------------------------------------------------------
// C++ default constructor
// -----------------------------------------------------------------------------
//
CMusWpAdapter::CMusWpAdapter() 
    :CWPAdapter(),
    iProfileIdReceived( EFalse ),
    iProfileId( KMusWpNotSet )
    {
    }


// -----------------------------------------------------------------------------
// Symbian 2nd phase constructor
// -----------------------------------------------------------------------------
//
void CMusWpAdapter::ConstructL()
    {
    MUS_LOG( "mus: [MUSWP]  -> CMusWpAdapter::ConstructL" )
    
    TFileName fileName;
    Dll::FileName(fileName);
    
    iSummaryTitle = WPAdapterUtil::ReadHBufCL( fileName, 
                                               KMusWpAdapterName, 
                                               R_MUS_WP_SUMMARYTITLE );

    MUS_LOG( "mus: [MUSWP]  <- CMusWpAdapter::ConstructL" )
    }