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



#include <ncdnodecontentinfo.h>
#include <ncdnode.h>
#include <catalogsuids.h>

#include "iaupdatenodefactory.h"
#include "iaupdatenodeimpl.h"
#include "iaupdatefwnodeimpl.h"
#include "iaupdatespecialnode.h"
#include "iaupdateservicepacknode.h"
#include "iaupdateruids.h"
#include "iaupdatectrlnodeconsts.h"
#include "iaupdateprotocolconsts.h"
#include "iaupdatedebug.h"


// ---------------------------------------------------------------------------
// IAUpdateNodeFactory::CreateNodeLC
// 
// ---------------------------------------------------------------------------
//
CIAUpdateNode* IAUpdateNodeFactory::CreateNodeLC( 
    MNcdNode* aNode,
    CIAUpdateController& aController )
    {
    CIAUpdateNode* updateNode( 
        IAUpdateNodeFactory::CreateNodeL( aNode, aController ) );
    CleanupStack::PushL( updateNode );
    return updateNode;
    }
    

// ---------------------------------------------------------------------------
// IAUpdateNodeFactory::CreateNodeL
// 
// ---------------------------------------------------------------------------
//
CIAUpdateNode* IAUpdateNodeFactory::CreateNodeL( 
    MNcdNode* aNode, 
    CIAUpdateController& aController )
    {
    if ( !aNode )
        {
        User::Leave( KErrArgument );
        }

    CIAUpdateNode* updateNode( NULL );

    TUid nodeUid( TUid::Null() ); 
    TBool isServicePack( EFalse );

    // Put the node into the cleanup stack.
    // So, it will be released if update node creation fails.
    CleanupReleasePushL( *aNode );

    // Get information from content info.
    MNcdNodeContentInfo* contentInfo( 
        aNode->QueryInterfaceLC< MNcdNodeContentInfo >() );
    if ( contentInfo )
        {
        // Notice, check if the node is actually a firmware node.
        // Do not accept them. Content info is used to check this.
        // Because content info exists, also checking can be done here without
        // leaving because content info did not exist.
        if ( IsFwUpdateL( *aNode ) )
            {
            User::Leave( KErrArgument );
            }

        nodeUid = contentInfo->Uid(); 
        isServicePack = IsServicePack( contentInfo->MimeType() );

        // Release content info.
        // So, we can later check if it still exists and then get 
        // new one if it exists.
        CleanupStack::PopAndDestroy( contentInfo );
        contentInfo = NULL;
        }

    if ( IsSelfUpdate( nodeUid ) )
        {
        // Node contents require special install handling. 
        // So, create special node.
        updateNode = CIAUpdateSpecialNode::NewL( aNode, aController );
        }
    else if ( isServicePack )
        {
        // The node is actually service pack.
        // Notice, that the service pack should not contain any content
        // itself. Instead, content is provided via dependencies.
        // So, self update nodes should never be service packs themselves.
        // So, they can be handled separately above in if-clause.
        updateNode = CIAUpdateServicePackNode::NewL( aNode, aController );
        }
    else
        {
        // Normal node.
        updateNode = CIAUpdateNode::NewL( aNode, aController );       
        }

    // The update node took the ownership. So, it is safe to pop.        
    CleanupStack::Pop( aNode );
        
    return updateNode;
    }


// ---------------------------------------------------------------------------
// IAUpdateNodeFactory::IsSelfUpdate
// 
// ---------------------------------------------------------------------------
//
TBool IAUpdateNodeFactory::IsSelfUpdate( const TUid& aUid )
    {
    // The UI, that uses this iaupdate engine dll, is thought as a special content.
    // Iaupdate uses NCD Engine to install itself. So, it requires also special installer.
    // These special cases should be installed by using updater.

    if ( IsIad( aUid ) || IsNcd( aUid ) )    
        {
        // Special installing is required.
        return ETrue;
        }

    return EFalse;
    }


// ---------------------------------------------------------------------------
// IAUpdateNodeFactory::IsIad
// 
// ---------------------------------------------------------------------------
//
TBool IAUpdateNodeFactory::IsIad( const TUid& aUid )
    {
    RProcess process;
    TUid uiUid( process.SecureId() );
    
    if ( aUid == uiUid )
        {
        // UID matched the IAD UID.
        return ETrue;
        }

    return EFalse;
    }


// ---------------------------------------------------------------------------
// IAUpdateNodeFactory::IsNcd
// 
// ---------------------------------------------------------------------------
//
TBool IAUpdateNodeFactory::IsNcd( const TUid& aUid )
    {
    if ( aUid.iUid == KCatalogsServerUid
         || aUid.iUid == KNcdProviderUid
         || aUid.iUid == KCatalogsEngineUid
         || aUid.iUid == KCatalogsEngineInterfaceUid
         || aUid.iUid == KCatalogsEngineImplementationUid )
        {
        // UID matched to one NCD UID.
        return ETrue;
        }

    return EFalse;
    }


// ---------------------------------------------------------------------------
// IAUpdateNodeFactory::IsUpdater
// 
// ---------------------------------------------------------------------------
//
TBool IAUpdateNodeFactory::IsUpdater( const TUid& aUid )
    {
    if ( aUid.iUid == KIAUpdaterUid )
        {
        // UID matched the self updater UID.
        return ETrue;
        }

    return EFalse;
    }


// ---------------------------------------------------------------------------
// IAUpdateNodeFactory::CreateFwNodeLC
// 
// ---------------------------------------------------------------------------
//
CIAUpdateFwNode* IAUpdateNodeFactory::CreateFwNodeLC( 
    MNcdNode* aNode,
    CIAUpdateController& aController )
    {
    CIAUpdateFwNode* updateNode( 
        IAUpdateNodeFactory::CreateFwNodeL( aNode, aController ) );
    CleanupStack::PushL( updateNode );
    return updateNode;
    }
    

// ---------------------------------------------------------------------------
// IAUpdateNodeFactory::CreateFwNodeL
// 
// ---------------------------------------------------------------------------
//    
CIAUpdateFwNode* IAUpdateNodeFactory::CreateFwNodeL( 
    MNcdNode* aNode, 
    CIAUpdateController& aController )
    {
    IAUPDATE_TRACE("[IAUPDATE] IAUpdateNodeFactory::CreateFwNodeL() begin");
    
    if ( !aNode )
        {
        IAUPDATE_TRACE("[IAUPDATE] ERROR: NULL node");
        User::Leave( KErrArgument );
        }

    CIAUpdateFwNode* updateNode( NULL );

    // Put the node into the cleanup stack.
    // So, it will be released if update node creation fails.
    CleanupReleasePushL( *aNode );

    MNcdNodeContentInfo* contentInfo(
        aNode->QueryInterfaceLC< MNcdNodeContentInfo >() );
    if ( contentInfo )
        {
        IAUPDATE_TRACE("[IAUPDATE] Node has content info");
        
        const TDesC& mime( contentInfo->MimeType() );
        IAUPDATE_TRACE_1("[IAUPDATE] Mime: %S", &mime);        
        
        if ( mime == IAUpdateProtocolConsts::KMimeFotaDp2 )
            {
            IAUPDATE_TRACE("[IAUPDATE] Fota Dp2");
            updateNode = 
                CIAUpdateFwNode::NewL( 
                    aNode, aController, MIAUpdateFwNode::EFotaDp2 );
            }
        else if ( mime == IAUpdateProtocolConsts::KMimeFotiNsu )
            {
            IAUPDATE_TRACE("[IAUPDATE] Foti Nsu");
            updateNode = 
                CIAUpdateFwNode::NewL( 
                    aNode, aController, MIAUpdateFwNode::EFotiNsu );
            }
        else
            {
            // Unknown firmware mime type
            IAUPDATE_TRACE("[IAUPDATE] ERROR: Unknown MIME for fw");
            User::Leave( KErrArgument );
            }

        // Firmware item should always have content info available.
        CleanupStack::PopAndDestroy( contentInfo );
        }
    else
        {
        IAUPDATE_TRACE("[IAUPDATE] ERROR: Firmware item did not have content info");
        User::Leave( KErrNotFound );
        }
                     
    // The update node took the ownership. So, it is safe to pop.        
    CleanupStack::Pop( aNode );

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateNodeFactory::CreateFwNodeL() end");
        
    return updateNode;
    }


// ---------------------------------------------------------------------------
// IAUpdateNodeFactory::IsFwUpdateL
// 
// ---------------------------------------------------------------------------
//
TBool IAUpdateNodeFactory::IsFwUpdateL( MNcdNode& aNode )
    {
    IAUPDATE_TRACE("[IAUPDATE] IAUpdateNodeFactory::IsFwUpdateL() begin");
    
    TBool isFwUpdate( EFalse );

    MNcdNodeContentInfo* contentInfo(
        aNode.QueryInterfaceLC< MNcdNodeContentInfo >() );
    if ( contentInfo )
        {
        IAUPDATE_TRACE("[IAUPDATE] Node has content info");

        const TDesC& mime( contentInfo->MimeType() );
        IAUPDATE_TRACE_1("[IAUPDATE] Mime: %S", &mime);

        isFwUpdate = IsFwUpdate( mime );

        // Firmware item should always have content info available.
        CleanupStack::PopAndDestroy( contentInfo );
        }
    else
        {
        IAUPDATE_TRACE("[IAUPDATE] ERROR: Firmware item did not have content info");
        User::Leave( KErrNotFound );
        }

    IAUPDATE_TRACE_1("[IAUPDATE] IAUpdateNodeFactory::IsFwUpdateL() end: %d",
                     isFwUpdate);

    return isFwUpdate;
    }


// ---------------------------------------------------------------------------
// IAUpdateNodeFactory::IsFwUpdate
// 
// ---------------------------------------------------------------------------
//
TBool IAUpdateNodeFactory::IsFwUpdate( const TDesC& aMime )
    {
    IAUPDATE_TRACE("[IAUPDATE] IAUpdateNodeFactory::IsFwUpdate() begin");
    
    TBool isFwUpdate( EFalse );
    
    if ( aMime == IAUpdateProtocolConsts::KMimeFotaDp2
         || aMime == IAUpdateProtocolConsts::KMimeFotiNsu )
        {
        isFwUpdate = ETrue;
        }

    IAUPDATE_TRACE_1("[IAUPDATE] IAUpdateNodeFactory::IsFwUpdate() end: %d",
                     isFwUpdate);
    
    return isFwUpdate;
    }


// ---------------------------------------------------------------------------
// IAUpdateNodeFactory::IsServicePack
// 
// ---------------------------------------------------------------------------
//     
TBool IAUpdateNodeFactory::IsServicePack( const TDesC& aMime )
    {
    IAUPDATE_TRACE_1("[IAUPDATE] IAUpdateNodeFactory::IsServicePack: %d",
                     ( aMime.Match( IAUpdateProtocolConsts::KMimeServicePackPattern() )
                       != KErrNotFound ));

    // Notice, that here we compare the beginning of the MIME.
    // So, the end of the MIME may contain some postfix, for example,
    // IAUpdateCtrlNodeConsts::KMimeServicePackDependencyPostfix. But,
    // we always interpret the item as service pack if the MIME so 
    // suggests. So, even if this service pack is a service pack inside
    // another service pack. This is still service pack.
    return ( aMime.Match( IAUpdateProtocolConsts::KMimeServicePackPattern() )
             != KErrNotFound );
    }


// ---------------------------------------------------------------------------
// IAUpdateNodeFactory::IsHidden
// 
// ---------------------------------------------------------------------------
//     
TBool IAUpdateNodeFactory::IsHidden( const TDesC& aMime )
    {
    IAUPDATE_TRACE_1("[IAUPDATE] IAUpdateNodeFactory::IsHidden(): %d",
                     ( aMime.Match( IAUpdateCtrlNodeConsts::KMimeHiddenPostfixPattern() )
                       != KErrNotFound ));

    // Notice, that here we compare the end of the MIME.
    // The end of the MIME may contain some postfix, for example,
    // IAUpdateCtrlNodeConsts::KMimeHiddenPostfix.
    // So, if correct postfix is found, then this is a hidden node.
    return ( aMime.Match( IAUpdateCtrlNodeConsts::KMimeHiddenPostfixPattern() )
             != KErrNotFound );
    }