/*

* Copyright (c) 2005-2009 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:  CCapInfo implementation

*

*/

// INCLUDE FILES

#include <utf.h>

#include <driveinfo.h>

#include <pathinfo.h>    // for PathInfo::SoundsPath

#include <seconsdkcrkeys.h>

#include "sconsyncservice.h"

#include "capinfo.h"

#include "caplist.h"

#include "capparser.h"

#include "caputils.h"

#include "stringlist.h"

#include "sconversioninfo.h"

#include "debug.h"

_LIT8( KLineFeed, "\r\n" );

const TInt KDefaultArrayGranularity = 5;

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

// -----------------------------------------------------------------------------

// CCapInfo::NewL()

// Two-phase constructor

// -----------------------------------------------------------------------------

//

CCapInfo* CCapInfo::NewL()

    {

    TRACE_FUNC_ENTRY;

    CCapInfo* self = new (ELeave) CCapInfo();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(self);

    TRACE_FUNC_EXIT;

    return self;

    }

// -----------------------------------------------------------------------------

// CCapInfo::~CCapInfo()

// Destructor

// -----------------------------------------------------------------------------

//

CCapInfo::~CCapInfo()

    {

    TRACE_FUNC_ENTRY;

    iFsSession.Close();

    delete iHeapBuf;

    delete iCapList;

    delete iSconInfo;

    TRACE_FUNC_EXIT;

    }

// -----------------------------------------------------------------------------

// CCapInfo::CapabilityDocumentL(CBufFlat* aBuf)

// Creates capability xml document end places it in aBuf

// -----------------------------------------------------------------------------

//

void CCapInfo::CapabilityDocumentL(CBufFlat* aBuf)

    {

    TRACE_FUNC_ENTRY;

    TInt err( KErrNone );

    // set buffer where capability document is written

    SetCapabilityBuf( aBuf );

    WriteL( KXmlVersion );

    WriteL( KComment1 );

    WriteL( KDocType );

    WriteL( KRootBegin );

    //

    // general

    //

    TRAP( err, GeneralInfoL() );

    if ( err != KErrNone )

        {

        LOGGER_WRITE_1( "GeneralInfoL failed : %d", err );

        User::Leave( err ); 

        }

    //

    // services

    //

    // Search service files first from C-drive, and then from Z

    // Do not add same files twice.

    RArray<TFileName> excludeList( KDefaultArrayGranularity );

    CleanupClosePushL( excludeList );

    RArray<TFileName> filesAdded( KDefaultArrayGranularity );

    CleanupClosePushL( filesAdded );

    //read service files from C Import folder

    TRAP( err, ServiceInfoL( KCapabilityDirCImport, excludeList, filesAdded ) );     

    LOGGER_WRITE_1( "ServiceInfoL(KCapabilityDirCImport) returned : %d", err );

    for ( TInt i=0; i<filesAdded.Count(); i++ )

        {

        excludeList.Append( filesAdded[i] );

        }

    filesAdded.Reset();

    // read service files from C Capability folder

    TRAP( err, ServiceInfoL( KCapabilityDirC, excludeList, filesAdded ) ); 

    LOGGER_WRITE_1( "ServiceInfoL(KCapabilityDirC) returned : %d", err );

    for ( TInt i=0; i<filesAdded.Count(); i++ )

        {

        excludeList.Append( filesAdded[i] );

        }

    filesAdded.Reset();

    // read service files from Z Capability folder

    TRAP( err, ServiceInfoL( KCapabilityDirZ, excludeList, filesAdded ) );

    LOGGER_WRITE_1( "ServiceInfoL(KCapabilityDirZ) returned : %d", err );

    CleanupStack::PopAndDestroy( &filesAdded );

    CleanupStack::PopAndDestroy( &excludeList );

    // this service does not come from file

    TRAP( err, FolderServiceL() );

    LOGGER_WRITE_1( "FolderServiceL() returned : %d", err );

    TRAP( err, SyncSolutionsServiceL() );

    LOGGER_WRITE_1( "SyncSolutionsServiceL() returned: %d", err );

    WriteL( KRootEnd );

    TRACE_FUNC_EXIT;

    }

// -----------------------------------------------------------------------------

// CCapInfo::ConstructL()

// Initializes member data

// -----------------------------------------------------------------------------

//

void CCapInfo::ConstructL()

    {

    TRACE_FUNC_ENTRY;

    User::LeaveIfError( iFsSession.Connect() );

    iHeapBuf = HBufC8::NewL( KMaxSize*2 );

    iCapList = CCapList::NewL();

    iIdStack.Reset();

    iSconInfo = CSconVersionInfo::NewL();

    TInt err(KErrNone);

    TRAP(err, iSconInfo->FetchInfoL( iFsSession ));

    LOGGER_WRITE_1("sconInfo->FetchInfoL() Leaved: %d", err);

    TRACE_FUNC_EXIT;

    }

// -----------------------------------------------------------------------------

// CCapInfo::CCapInfo()

// Constuctor

// -----------------------------------------------------------------------------

//

CCapInfo::CCapInfo()

    {

    }

// -----------------------------------------------------------------------------

// CCapInfo::CapList()

// Returns caplist

// -----------------------------------------------------------------------------

//

CCapList* CCapInfo::CapList()

    {

    TRACE_FUNC;

    __ASSERT_DEBUG(iCapList, CapUtil::Panic(KErrGeneral));

    return iCapList;

    }

// -----------------------------------------------------------------------------

// CCapInfo::SetCapabilityBuf( CBufFlat* aBuf )

// Set capability buffer

// -----------------------------------------------------------------------------

//

void CCapInfo::SetCapabilityBuf( CBufFlat* aBuf )

    {

    TRACE_FUNC;

    iCapabilityBuf=aBuf;

    }

// -----------------------------------------------------------------------------

// CCapInfo::GeneralInfoL()

// Write general device capability information.

// -----------------------------------------------------------------------------

//

void CCapInfo::GeneralInfoL()

    {

    TRACE_FUNC_ENTRY;

    TInt err( KErrNone );

    TBuf<KBufSize> buf;

    TBuf<KBufSize> longName;

    TBuf<KBufSize> coutryCode;

    TBuf<KBufSize> networkID;

    WriteTagL(EGeneral, TXmlParser::EElementBegin);

    if ( !iSconInfo->IsReady() )

        {

        LOGGER_WRITE("iSconInfo wasn't ready, call iSconInfo->FetchInfoL");

        iSconInfo->FetchInfoL( iFsSession );

        }

    if ( iSconInfo->iManufacturer )

        {

        WriteValueL( EManufacturer, *iSconInfo->iManufacturer );

        }

    if ( iSconInfo->iProduct )

        {

        WriteValueL( EModel, *iSconInfo->iProduct );

        }

    // serial number

    if ( iSconInfo->iSerialNumber )

        {

        WriteValueL( ESN, *iSconInfo->iSerialNumber );

        }

    // software version 

    if ( iSconInfo->iSWVersion )

        {

        WriteAttributeL( ESW, *iSconInfo->iSWVersion, iSconInfo->iDate );

        }

    // language

    WriteValueL( ELanguage, iSconInfo->iLanguage );

    // this must succeed - do not trap

    MemoryInfoL();

    // Operator

    TRAP( err, CapUtil::GetOperatorNameL( longName, coutryCode, networkID ) );

    LOGGER_WRITE_1( "CapUtil::GGetOperatorNameL returned : %d", err );

    if( err == KErrNone )

        {

        LOGGER_WRITE_3( "CSConFsHandler::GetOperatorNameL longName =  %S coutryCode = %S networkID = %S", &longName, &coutryCode, &networkID );       

        _LIT( KNetworkInfo, "NetworkInfo" );

        _LIT( KCurrentNetwork, "CurrentNetwork=" );

        _LIT( KCountryCode, "CountryCode=" );

        _LIT( KNetworkID, "NetworkID=" );

        WriteTagL( EExt, TXmlParser::EElementBegin );

        WriteValueL( EXNam, KNetworkInfo );

        // write CurrentNetwork

        buf.Copy( KCurrentNetwork );

        buf.Append( longName );

        WriteValueL( EXVal, buf );

        // write CountryCode

        buf.Copy( KCountryCode );

        buf.Append( coutryCode );

        WriteValueL( EXVal, buf );

        // write NetworkID

        buf.Copy( KNetworkID );

        buf.Append( networkID );

        WriteValueL( EXVal, buf );

        WriteTagL( EExt, TXmlParser::EElementEnd );     

        }

    if ( iSconInfo->iModel )

        {

        // print modelname (phone model sales name. For example "N01".)

        WriteTagL( EExt, TXmlParser::EElementBegin );

        _LIT(KModelName, "ModelName");

        WriteValueL( EXNam, KModelName );

        WriteValueL( EXVal, *iSconInfo->iModel );

        WriteTagL( EExt, TXmlParser::EElementEnd ); 

        }

    if ( iSconInfo->iProductCode )

        {

        // print productcode

        WriteTagL( EExt, TXmlParser::EElementBegin );

        _LIT( KProductCode, "ProductCode" );

        WriteValueL( EXNam, KProductCode );

        WriteValueL( EXVal, *iSconInfo->iProductCode );

        WriteTagL( EExt, TXmlParser::EElementEnd );

        }

    // print advanced info

    WriteTagL( EExt, TXmlParser::EElementBegin );

    _LIT(KAdvancedDeviceInfo, "AdvancedDeviceInfo");

    WriteValueL( EXNam, KAdvancedDeviceInfo );

    TBuf<KSysVersionInfoTextLength> temp;

    if ( iSconInfo->iRevision )

        {

        // product revision. For example "01"

        _LIT( KRevision, "Revision=" );

        temp.Copy( KRevision );

        temp.Append( *iSconInfo->iRevision );

        LOGGER_WRITE_1( "CCapInfo::GeneralInfoL() : %S ", &temp );

        WriteValueL( EXVal, temp );

        }

    if ( iSconInfo->iSysVersionInfo )

        {

        _LIT( KFWVersion, "FWVersion=" );

        temp.Copy( KFWVersion );

        temp.Append( *iSconInfo->iSysVersionInfo );

        LOGGER_WRITE_1( "CCapInfo::GeneralInfoL() : %S ", &temp );

        WriteValueL( EXVal, temp );

        }

    SysVersionInfo::TSymbianOSVersion osVersion;

    err = iSconInfo->GetSymbianVersion( osVersion );

    LOGGER_WRITE_1("TSymbianOSVersion info error: %d", err)

    if ( !err )

        {

        // Now osVersion contains the Symbian OS version information

        _LIT( KSymbianOSVersion, "SymbianOSVersion=%d.%d" );

        temp.Format( KSymbianOSVersion,

                osVersion.iMajorVersion,

                osVersion.iMinorVersion  );

        LOGGER_WRITE_1( "CCapInfo::GeneralInfoL() : %S ", &temp );

        WriteValueL( EXVal, temp );

        }

    VersionInfo::TPlatformVersion platformVersion;

    err = iSconInfo->GetS60Version( platformVersion );

    if ( !err )

       {

       _LIT( KS60Version, "S60PlatformVersion=%d.%d" );

       temp.Format( KS60Version,

               platformVersion.iMajorVersion,

               platformVersion.iMinorVersion  );

       LOGGER_WRITE_1( "CCapInfo::GeneralInfoL() : %S ", &temp );

       WriteValueL( EXVal, temp );

       }

    if ( iSconInfo->iLangVersion )

        {

        _LIT( KLangVersion, "LangVersion=" );

        temp.Copy( KLangVersion );

        temp.Append( *iSconInfo->iLangVersion );

        LOGGER_WRITE_1( "CCapInfo::GeneralInfoL() : %S ", &temp );

        WriteValueL( EXVal, temp );

        }

    if ( iSconInfo->iLangSWVersion )

        {

        _LIT( KLangSWVersion, "LangSWVersion=" );

        temp.Copy( KLangSWVersion );

        temp.Append( *iSconInfo->iLangSWVersion );

        LOGGER_WRITE_1( "CCapInfo::GeneralInfoL() : %S ", &temp );

        WriteValueL( EXVal, temp );

        }

    if ( iSconInfo->iOPVersion )

        {

        // CustomerVersion

        _LIT( KOPVersion, "OPVersion=" );

        temp.Copy( KOPVersion );

        temp.Append( *iSconInfo->iOPVersion );

        LOGGER_WRITE_1( "CCapInfo::GeneralInfoL() : %S ", &temp );

        WriteValueL( EXVal, temp );

        }

    // screen size

    LOGGER_WRITE_2("Size, width: %d, height: %d",

            iSconInfo->iScreenSize.iWidth,

            iSconInfo->iScreenSize.iHeight );

    _LIT( KWidth, "ScreenWidth=%d" );

    _LIT( KHeight, "ScreenHeight=%d" );

    temp.Format( KWidth, iSconInfo->iScreenSize.iWidth );

    WriteValueL( EXVal, temp );

    temp.Format( KHeight, iSconInfo->iScreenSize.iHeight );

    WriteValueL( EXVal, temp );

    WriteTagL( EExt, TXmlParser::EElementEnd ); 

    // end of advanced info

    WriteTagL(EGeneral, TXmlParser::EElementEnd);

    TRACE_FUNC_EXIT;

    }

// -----------------------------------------------------------------------------

// CCapInfo::MemoryInfoL()

// Create memory info for all drives (RAM excluded).

// -----------------------------------------------------------------------------

//

void CCapInfo::MemoryInfoL()

    {

    TRACE_FUNC_ENTRY;

    TMemoryInfo info;

    TInt devDriveCount = 0;

    TInt mmcDriveCount = 0;

    //Write all drivers to folderlisting object

    TDriveList driveList;

    // Get all drives that are visible to the user.

    TInt driveCount;

    User::LeaveIfError( DriveInfo::GetUserVisibleDrives( iFsSession, driveList, driveCount ) );

    for( TInt i = EDriveA; i < KMaxDrives; i++ )

        {

        if( driveList[i] )

            {

            TUint driveStatus;

            TInt err = DriveInfo::GetDriveStatus( iFsSession, i, driveStatus );

            if( err )

                {

                LOGGER_WRITE_1( "CCapInfo::MemoryInfoL() : DriveInfo::GetDriveStatus: %d", i);

                continue;

                }

            if( !(driveStatus & DriveInfo::EDrivePresent )

                || driveStatus & DriveInfo::EDriveCorrupt

                || (driveStatus & DriveInfo::EDriveRemote) )

                {

                LOGGER_WRITE_1( "skip drive %d", i);

                continue;

                }

            TRAP( err, CapUtil::GetMemoryInfoL( iFsSession, i, info ));

            if ( err )

                {

                LOGGER_WRITE_1( "CapUtil::GetMemoryInfoL() : Leaved with: %d", err);

                continue;

                }

            info.iDriveStatus = driveStatus;

            if( driveStatus & DriveInfo::EDriveInternal )

                {

                // if internal (DEV) drive, save drive number

                devDriveCount++;

                info.iMemNr = devDriveCount;

                }

            else if ( driveStatus & DriveInfo::EDriveRemovable )

                {

                // if removable (MMC) drive, save drive number

                mmcDriveCount++;

                info.iMemNr = mmcDriveCount;

                }

            else

                {

                // was not internal or removable, skip.

                LOGGER_WRITE( "CCapInfo::MemoryInfoL() : not internal or removable, skip." );

                continue;

                }

            WriteMemoryInfoL(info);

            }

        }

    TRACE_FUNC_EXIT;

    }

// -----------------------------------------------------------------------------

// CCapInfo::MemoryInfoL(TMemoryInfo& aInfo)

// Create memory info for all drives (RAM excluded).

// -----------------------------------------------------------------------------

//

void CCapInfo::WriteMemoryInfoL(TMemoryInfo& aInfo)

    {

    TRACE_FUNC_ENTRY;

    TBuf<KBufSize> buf;

    WriteTagL(EMemory, TXmlParser::EElementBegin);

    if( aInfo.iDriveStatus & DriveInfo::EDriveInternal )

        {

        buf = KMediaFlash;

        }

    else

        {

        buf = KMediaMMC;  // memory card (MMC)

        }

    if( aInfo.iMemNr > 1 )

        {

        // append memory number DEV2, MMC2..

        buf.AppendNum( aInfo.iMemNr ); 

        }

    WriteValueL(EMemType, buf);

    WriteValueL(ELocation, aInfo.iLocation);

    WriteValueL(EFree, aInfo.iFree);

    WriteValueL(EUsed, aInfo.iUsed);

    WriteValueL(EFileNLen, aInfo.iFileNameSize);

    WriteTagL(EMemory, TXmlParser::EElementEnd);

    TRACE_FUNC_EXIT;

    }

// -----------------------------------------------------------------------------

// CCapInfo::ServiceInfoL(const TDesC& aDir)

// Reads service xml-files from directory and writes them into capability 

// document.

// -----------------------------------------------------------------------------

//

void CCapInfo::ServiceInfoL(const TDesC& aDir, const RArray<TFileName>& aExcludeList,