/*

* 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:  Background manager.

*

*/

// INCLUDE FILES

#include "xnbackgroundmanager.h"

#include "hspswrapper.h"

#include "xnviewmanager.h"

#include "xnviewdata.h"

#include "xnplugindefs.h"

#include "hspssapi.h"

#include "xnappuiadapter.h"

#include "xnwallpaperview.h"

#include "xnrootdata.h"

#include "xnuiengine.h"

#include "xnoomsyshandler.h"

#include "xneffectmanager.h"

// SYSTEM INCLUDE FILES

#include <gfxtranseffect/gfxtranseffect.h>

#include <akntransitionutils.h>

#include <aknlistquerydialog.h> 

#include <xnuiengine.rsg>

#include <xnwallpaperview.rsg>

#include <AknSkinsInternalCRKeys.h>

#include <activeidle2domaincrkeys.h>

#include <AknsWallpaperUtils.h>

#include <imageconversion.h>

#include <bitmaptransforms.h>

#include <StringLoader.h>

#include <aknnotewrappers.h>

#include <bautils.h>

#include <utf.h>

#include <AknsUtils.h>

#include <AknsDrawUtils.h>

#include <AknsControlContext.h>

#include <AknsLayeredBackgroundControlContext.h>

#include <driveinfo.h>

#include <layoutmetadata.cdl.h>

using namespace hspswrapper;

// Constants

_LIT8( KSingle, "single" );

const TUid KDummyUid = { 0x0000000 };

const TInt KSkinGfxInnerRectShrink( 5 );

// ============================= LOCAL FUNCTIONS ===============================

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

// ShowInfoNoteL

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

//

void ShowInfoNoteL( TInt aResourceId )

    {

    HBufC* msg( StringLoader::LoadLC( aResourceId ) ); 

    CAknInformationNote* note = new ( ELeave ) CAknInformationNote;    

    note->ExecuteLD( *msg );

    CleanupStack::PopAndDestroy( msg );                 

    }

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

// HandleErrorL

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

//

void HandleErrorL( TInt aErr )

    {

    TInt resourceId( NULL );

    if ( aErr == KErrTooBig )

        {

        resourceId = R_QTN_HS_TOO_BIG_IMAGE_NOTE;

        }

    else if( aErr == KErrNoMemory )

        {

        resourceId = R_QTN_HS_WALLPAPER_OUT_OF_RAM;

        }

    else if ( aErr == KErrCancel || aErr == KErrCouldNotConnect || 

        aErr == KErrCANoRights )

        {

        // Ignore these

        }

    else if ( aErr != KErrNone )

        {

        resourceId = R_QTN_HS_CORRUPTED_IMAGE_NOTE;

        }

    if( resourceId )

        {

        ShowInfoNoteL( resourceId );

        }

    }

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

// CreateBitmapFromColorL

// Creates a bitmap object with the given size and fill color

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

//

static CFbsBitmap* CreateBitmapFromColorL( TSize aSize, TRgb aColor )

    {

    CFbsBitmap* newBitmap = new ( ELeave ) CFbsBitmap;

    newBitmap->Create( aSize, EColor16M );

    CleanupStack::PushL( newBitmap );

    CFbsBitmapDevice* bitmapDev = CFbsBitmapDevice::NewL( newBitmap );

    CleanupStack::PushL( bitmapDev );

    CFbsBitGc* bc = NULL;

    User::LeaveIfError( bitmapDev->CreateContext( bc ) );

    CleanupStack::PushL( bc );

    bc->SetBrushColor( aColor );

    bc->Clear(); // area is filled with the brush color

    CleanupStack::PopAndDestroy( bc );

    CleanupStack::PopAndDestroy( bitmapDev );

    CleanupStack::Pop( newBitmap );

    return newBitmap;

    }

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

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

// C++ default constructor.

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

//

CXnBackgroundManager::CXnBackgroundManager( CXnViewManager& aViewManager, CHspsWrapper& aWrapper )

    : iViewManager( aViewManager ), 

      iHspsWrapper( aWrapper ),

      iStoreWallpaper( ETrue ),

      iImageChanged( EFalse )

    {

    }

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

// Symbian 2nd phase constructor.

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

//

void CXnBackgroundManager::ConstructL()

    {    

    // Connect to skin server.

    User::LeaveIfError( iSkinSrv.Connect( this ) );

    // Start listening for drive events.

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

    CreateWindowL();

    iRect = TRect();

    iBgContext = CAknsLayeredBackgroundControlContext::NewL(

            KAknsIIDQsnBgScreenIdle, iRect, ETrue, 1 );

    TRect bgRect;

    AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, bgRect );

    SetRect( bgRect );

    Window().SetOrdinalPosition( -1 );

    MakeVisible( ETrue );

    ActivateL();

    iIntUpdate = 0;

    // Start listening file server notifications.

    iDiskNotifier = CDiskNotifyHandler::NewL( *this, iFsSession );

    User::LeaveIfError( iDiskNotifier->NotifyDisk() );

    // Reads from cenrep wheteher page specific wallpaper is enabled or not

    CheckFeatureTypeL();   

    GfxTransEffect::Register( this, KGfxContextBgAppear );

    }

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

// Two-phased constructor.

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

//

CXnBackgroundManager* CXnBackgroundManager::NewL( CXnViewManager& aViewManager, 

    CHspsWrapper& aWrapper )

    {

    CXnBackgroundManager* self = new (ELeave) CXnBackgroundManager( aViewManager, 

        aWrapper );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor.

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

//

CXnBackgroundManager::~CXnBackgroundManager()

    {

    if ( GfxTransEffect::IsRegistered( this) )

        {

        GfxTransEffect::Deregister( this );

        }

    iSkinSrv.RemoveAllWallpapers();

    iSkinSrv.Close();

    delete iDiskNotifier;

    iFsSession.Close();

    delete iBgContext;

    delete iBgImage;

    delete iBgImagePath;    

    delete iSpBitmap;

    delete iSpMask;   

    }

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

// CXnBackgroundManager::Draw

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

//    

void CXnBackgroundManager::Draw(const TRect& aRect) const

    {

    CFbsBitmap* wallpaper( NULL );

    if( iImageChanged )

        {

        iImageChanged = EFalse;

        wallpaper = iWallpaper;

        iWallpaper = NULL;

        }

    else if( iType == EPageSpecific )

        {

        CXnViewData& viewData( iViewManager.ActiveViewData() );

        wallpaper = viewData.WallpaperImage();

        }

    else if( iType == ECommon )

        {

        wallpaper = iBgImage;

        }

    // Draw bg image

    if( wallpaper )

        {   

        TSize bitmapSize = wallpaper->SizeInPixels();

        // If image is smaller that screen size it needs to be centralized

        if( iRect.Height() > bitmapSize.iHeight && 

            iRect.Width() > bitmapSize.iWidth )

            {

            TInt width = bitmapSize.iWidth / 2;

            TInt height = bitmapSize.iHeight / 2;

            TPoint point = iRect.Center();

            point.SetXY( point.iX - width, point.iY - height );

            SystemGc().SetBrushColor( KRgbBlack );

            SystemGc().Clear( aRect );

            SystemGc().DrawBitmap( TRect( point, bitmapSize), wallpaper );

            }

        else

            {

            SystemGc().DrawBitmap( iRect, wallpaper );

            }

        DrawStatusPaneMask();

        }

    // Skin bg is used by default

    else

        {  

        MAknsSkinInstance* skin( AknsUtils::SkinInstance() );     

        AknsDrawUtils::Background( skin, iBgContext, this, SystemGc(), aRect );

        }

    // Draw edit mode background highlight

    if( iViewManager.UiEngine().IsEditMode() )

        {

        DrawEditModeBackgroundSkin();

        }

    }

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

// CXnBackgroundManager::SizeChanged

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

// 

void CXnBackgroundManager::SizeChanged()

    {

    iRect = Rect();

    if ( iType == EPageSpecific )

        {

        TRAP_IGNORE( UpdateWallpapersL() );

        }

    else if ( iType == ECommon ) 

        {

        if( iBgImagePath )

            {

            delete iBgImage;

            iBgImage = NULL;

            TRAP_IGNORE( iBgImage = iSkinSrv.WallpaperImageL( *iBgImagePath ) );

            }

        }

    iBgContext->SetRect( iRect );

    TRAPD( err, UpdateStatuspaneMaskL() );

    if( err )

        {

        delete iSpBitmap;

        iSpBitmap = NULL;

        delete iSpMask;

        iSpMask = NULL;

        }

    }

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

// CXnBackgroundManager::MakeVisible

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

// 

void CXnBackgroundManager::MakeVisible( TBool aVisible )

    {    

    CCoeControl::MakeVisible( aVisible );      

    if ( aVisible )

        {

        DrawNow();

        }

    }

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

// Handle disk drive notifications.

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

//

void CXnBackgroundManager::HandleNotifyDisk( TInt /*aError*/, 

    const TDiskEvent& aEvent )              

    {

    if( aEvent.iType == MDiskNotifyHandlerCallback::EDiskStatusChanged )

        {

        if( aEvent.iInfo.iType == EMediaHardDisk )

            {

            TRAP_IGNORE( RemovableDiskInsertedL() ); 

            }

        else if( aEvent.iInfo.iType == EMediaNotPresent )

            {

            TRAP_IGNORE( RemovableDiskRemovedL() ); 

            }

        }

    }

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

// CXnBackgroundManager::ConstructWallpaper

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

//

TInt CXnBackgroundManager::ConstructWallpaper( const TDesC& aFileName, 

    CXnViewData& aViewData )

    {

    TRAP_IGNORE( aViewData.SetWallpaperImagePathL( aFileName ) );

    aViewData.SetWallpaperImage( NULL );

    TRAPD( err, iSkinSrv.AddWallpaperL( aFileName, iRect.Size() ) );

    if( err == KErrNone )

        {

        UpdateViewData( aFileName, aViewData );

        }  

    return err;

    }

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

// CXnBackgroundManager::SetWallpaperL

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

//

void CXnBackgroundManager::SetWallpaperL()

    {

    TInt selectedIndex( 0 );

    CAknListQueryDialog* query =

        new ( ELeave ) CAknListQueryDialog( &selectedIndex );   

    query->PrepareLC( R_LISTQUERY_CHANGE_WALLPAPER );

    if ( !query->RunLD() )

        {

        // Query canceled

        return;

        }

    CXnAppUiAdapter& appui( iViewManager.AppUiAdapter() );

    if ( selectedIndex == 0 )

        {

        // Set wallpaper to default skin

        SetWallpaper( KNullDesC );

        appui.EffectManager()->BgAppearEffect( this, ETrue );        

        }

    else if ( selectedIndex == 1 )

        {

        if ( CXnOomSysHandler::HeapAvailable( CXnOomSysHandler::EMem6MB ) )

            {                                      

            appui.ActivateLocalViewL( KWallpaperViewUid, KDummyUid, KSingle );

            appui.EffectManager()->BeginFullscreenEffectL( KGfxContextOpenWallpaperView );            

            }

        else

            {

            // Potentially not enough memory

            HandleErrorL( KErrNoMemory );        

            }

        }        

    }

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

// CXnBackgroundManager::SetWallpaper

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

//

TBool CXnBackgroundManager::SetWallpaper( const TDesC& aFileName )

    {

    TInt err( KErrNone );

    if ( iType == EPageSpecific )

        {

        TRAP( err, SetPageSpecificWallpaperL( aFileName ) );

        }

    else if ( iType == ECommon )

        {

        TRAP( err, SetCommonWallpaperL( aFileName ) );

        }

    if( err )

        {

        TRAP_IGNORE( HandleErrorL( err ) );

        return EFalse;

        }

    return ETrue;

    }

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

// CXnBackgroundManager::DeleteWallpaper

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

//

void CXnBackgroundManager::DeleteWallpaper( CXnViewData& aViewData )

    {

    if( iType == EPageSpecific )

        {

        const TDesC& path = aViewData.WallpaperImagePath();

        if( path != KNullDesC )

            {

            RemoveWallpaperFromCache( path, &aViewData );

            TRAP_IGNORE( aViewData.SetWallpaperImagePathL( KNullDesC ) );

            aViewData.SetWallpaperImage( NULL );

            }

        }

    else if( iType == ECommon )

        {

        if( iBgImagePath )

            {

            iSkinSrv.RemoveWallpaper( *iBgImagePath );          

            delete iBgImagePath;

            iBgImagePath = NULL;

            }

        delete iBgImage;

        iBgImage = NULL;

        }

    }

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

// CXnBackgroundManager::ChangeWallpaper

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

//

void CXnBackgroundManager::ChangeWallpaper( const CXnViewData& aOldView, 

    const CXnViewData& aNewView, TBool aDrawNow )

    {

    if( iType == EPageSpecific )

        {

        const TDesC& oldwp( aOldView.WallpaperImagePath() );

        const TDesC& newwp( aNewView.WallpaperImagePath() ); 

        if ( oldwp.Compare( newwp ) ) 

            {

            iStoreWallpaper = ETrue;                    

            iImageChanged = ETrue;                    

            iWallpaper = aNewView.WallpaperImage();

            if ( aDrawNow )

                {

                DrawNow();

                }

            }

        }

    }

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

// CXnBackgroundManager::WallpaperType

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

//

CXnBackgroundManager::WppType CXnBackgroundManager::WallpaperType()

    {

    return iType;

    }

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