/*

* 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:   This file implements the Slideshow Screensaver plugin.

*

*/

#include <eikenv.h>

#include <bautils.h>

#include <data_caging_path_literals.hrh>

#include <centralrepository.h>

#include <DRMHelper.h>

// #include <aknnotewrappers.h> AppendSlideL

// #include <aknnavi.h>

// #include <aknnavide.h>

// #include <mmfcontrollerpluginresolver.h>

#include <DRMHelperServerInternalCRKeys.h>

#include <mmf/common/mmfcontrollerpluginresolver.h> // For CleanupResetAndDestroyPushL

#include <pslninternalcrkeys.h>

#include <pslnslidesetdialoginterface.h>

// #include <NPNExtensions.h>

#include <coecntrl.h>

#include <ecom/ecom.h>

#include <ContentListingFactory.h>

#include <MCLFItem.h>

#include <slideshowplugin.rsg>

#include "SlideshowPlugin.h"

#include "SlideshowSlide.h"

#include "SlideshowPluginUtils.h"

// Constants

const TInt KSecsToMicros = 1000000;

// Slideshow duration times (secs)

const TInt KMinSlideshowTime = 1;

const TInt KMaxSlideshowTime = 60;

const TInt KDefaultSlideshowTime = 5;

// Backlight times (secs)

const TInt KMinLightsTime = 0;

const TInt KMaxLightsTime = 30;

const TInt KDefaultLightsTime = 0;

// Slide times 

// const TInt KMinSlideTime = 1;

// const TInt KMaxSlideTime = 30;

const TInt KDefaultSlideTime = 5;

// Refresh interval (Draw() call frequency) in secs.

// For better resolution kept smaller than slide time

const TInt KRefreshInterval = 1;

// Slideshow type

const TInt KSlideshowTypeContinuous = 0;

const TInt KSlideshowTypeRandom = 1;

// const TInt KScreensaverAnimPluginInterfaceUid = 0x102750CB;

_LIT(KResourceFileName, "Z:SlideshowPlugin.rsc");

CSlideshowSettings::CSlideshowSettings()

    {

    iSlideshowTime = KDefaultSlideshowTime;

    iLightsTime = KDefaultLightsTime;

    iSlideTime = KDefaultSlideTime;

    iSlideshowType = KSlideshowTypeContinuous;

    }

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

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

// CSlideshowPlugin::NewL

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

//

CSlideshowPlugin* CSlideshowPlugin::NewL()

    {

    CSlideshowPlugin* self = new (ELeave) CSlideshowPlugin;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CSlideshowPlugin::~CSlideshowPlugin

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

//   

CSlideshowPlugin::~CSlideshowPlugin()

    {    

    if (iResourceOffset != 0)

        {

        iEikEnv->DeleteResourceFile(iResourceOffset);

        }

    // Close and delete CR handlers

    NotifyCenrepChangeCancel();

    UnInitializeCenRep();

    // Close and delete P&S handlers

    if (iSettingsChangedSubscriber)

        {

        iSettingsChangedSubscriber->StopSubscribe();

        }

    iSettingsChangedProperty.Close();

    delete iSettingsChangedSubscriber;

    delete iScreensaverName;

    delete iSettings;

    delete iDrmHelper;

    delete iModel;

    // First model, then engine, otherwise bad things happen

    delete iCLFModel;

    delete iCLFEngine;

    // Logging done

    SSPLOGGER_DELETE;

    }

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

// CSlideshowPlugin::ConstructL

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

//    

void CSlideshowPlugin::ConstructL()

    {

    // Start logging

    SSPLOGGER_CREATE;

    iModel = CSlideshowModel::NewL();

    iSettings = new (ELeave) CSlideshowSettings();

    // Get nearest language resource file and add it to the

    // eikon environment for the duration of the plugin life

    TFileName fileName;

    TParse lParse;

    // Add the resource dir

    lParse.Set(KResourceFileName, &KDC_RESOURCE_FILES_DIR, NULL);

    // Get the filename with full path

    fileName = lParse.FullName();

    iEikEnv = CEikonEnv::Static();

    BaflUtils::NearestLanguageFile(iEikEnv->FsSession(), fileName);

    iResourceOffset = iEikEnv->AddResourceFileL(fileName);

    // Load localised name of screensaver to be returned 

    // to Themes app in Name() query

    iScreensaverName = iEikEnv->AllocReadResourceL(R_SLIDESHOW_SCREENSAVER_NAME);

    InitializeCenRepL();

    // Read settings

    ReadSettings();

    // Make sure random slides are loaded

    iCLFModelUpToDate = EFalse;    

    iTimerUpdated = EFalse;

    }

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

// CSlideshowPlugin::CSlideshowPlugin

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

CSlideshowPlugin::CSlideshowPlugin()

    {

    }

// --- MScreensaverPlugin ---

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

// CSlideshowPlugin::InitializeL

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

TInt CSlideshowPlugin::InitializeL(MScreensaverPluginHost *aHost)

    {

    SSPLOGGER_ENTERFN("InitializeL()");

    iWaitActive = EFalse;

    iDrawCount = 0;

    if (!aHost)

        {

        return KErrArgument;

        }

    iHost = aHost;   

    // iHost->UseRefreshTimer( EFalse );

    NotifyCenrepChangeL();

    // No indicators while plugin running

    iHost->OverrideStandardIndicators();    

    // Get display info

    UpdateDisplayInfo();

    // Attach and start watching settings changed key

    User::LeaveIfError(iSettingsChangedProperty.Attach(

        KPSUidScreenSaver, KScreenSaverPluginSettingsChanged));

    iSettingsChangedSubscriber = new (ELeave) CPSSubscriber(

        TCallBack(HandleSettingsChanged, this), iSettingsChangedProperty);

    iSettingsChangedSubscriber->SubscribeL();

    iDrmHelper = CDRMHelper::NewL(*iEikEnv);

    // Load slides on start rather than here

    // LoadSlidesL();

    // Make sure random slides are loaded

    iCLFModelUpToDate = EFalse;

    SSPLOGGER_LEAVEFN("InitializeL()");

    return KErrNone;

    }

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

// CSlideshowPlugin::Draw

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

TInt CSlideshowPlugin::Draw(CWindowGc& aGc)

    {

    SSPLOGGER_ENTERFN("Draw()");

    // Clear the screen on the very first draw call after starting

    if (iDrawCount < 0)

        {

        iDrawCount = 0;

        aGc.SetBrushColor(KRgbBlack);

        aGc.Clear();

        }

    // If still waiting for CLF, bail out

    if (iWaitActive)

        {

        SSPLOGGER_WRITE("Draw(): Waiting for CLF, bail out");

        SSPLOGGER_LEAVEFN("Draw()");

        return KErrNone;

        }

    // Make sure we have something to display

    	{

        SSPLOGGER_WRITE("Draw(): Nothing to display, suspending");

        SSPLOGGER_LEAVEFN("Draw()");

//        iHost->Suspend( -1 ); // This place will be crashed when transform to default type

        }

    CSlideshowSlide* pSlide = iModel->NextSlide(EFalse);

   // get the status of the slide

    TInt status = iModel->SlideStatus(pSlide); // TInt   decoded(1), decoding(2), not decoding(3),no slide (0)

    											// 4 could not decode the slide

    if(KStatusDecodingInProgress == status) 

    	{

    	// decoding in progress... return

    	// when ever decoding is going on.. call draw method every 1 second to check the status of the decoding

    	// and draw the image as soon as it is available ( otherwise Draw is called every 5 secods, very bad user responce)

    	if(iTimerUpdated)

    		{

    		iHost->SetRefreshTimerValue(KSecsToMicros);

    		iTimerUpdated = EFalse;

    		}

    	return KErrNone;

      	}

    else if (KStatusSlideDecoded == status)

    	{

    	// File was decoded properly and available

    	SSPLOGGER_WRITEF(_L("SSP: Draw(): Got slide (%x), drawing"), pSlide);

    	// Consume slide's DRM rights

    	SlideshowUtil::DRMConsume(iDrmHelper, pSlide);

    	// Make sure the window is empty in case the bitmap doesn't

    	// fill the whole screen. Draw background black

    	aGc.SetBrushColor(KRgbBlack);

    	// aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

    	aGc.Clear();

    	// Draw image centered

    	DrawCentered(aGc, pSlide);

    	if(iHost && !iTimerUpdated)

        	{

        	iHost->SetRefreshTimerValue(iSettings->iSlideTime * KSecsToMicros);

        	iTimerUpdated = ETrue;

        	}

    	// Flush draw buffer so that the new image is displayed immediately

    	FlushDrawBuffer();

    	SSPLOGGER_WRITE("Draw(): Prepare next slide");

    	SSPLOGGER_LEAVEFN("Draw()");

    	}

    // Prefetch image for the next slide

    iModel->PrepareNextSlide(

            (iSettings->iSlideshowType == KSlideshowTypeRandom), iDi.iRect.Size());

    SSPLOGGER_LEAVEFN("Draw()");

    return KErrNone;

  }

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

// CSlideshowPlugin::Name

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

const TDesC16& CSlideshowPlugin::Name() const

    {

    if (iScreensaverName)

        {

        return *iScreensaverName;

        }

    else

        {

        return KNullDesC;

        }

    }

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

// CSlideshowPlugin::Capabilities

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

TInt CSlideshowPlugin::Capabilities()

    {

    return (EScpCapsConfigure | EScpCapsSelectionNotification);

    }

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

// CSlideshowPlugin::PluginFunction

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

TInt CSlideshowPlugin::PluginFunction(

    TScPluginCaps aFunction,

    TAny* aParam)

    {

    TInt ret = KErrNone;

    switch (aFunction)

        {

        case EScpCapsSelectionNotification:

        case EScpCapsPreviewNotification:

        // Peek into the slideset

        TRAP(ret, LoadSlidesL());

	    if (ret!=KErrNone || iModel->NumberOfSlides() == 0)

            {

            SSPLOGGER_WRITE("No slides selected - launching settings");

            TRAP(ret, ConfigureL(aParam));

            // Check if at least one file is selected    

            TRAP(ret, LoadSlidesL());

            if ( ret == KErrNone && iModel->NumberOfSlides() == 0)

                {

                // Don't Pop an error note, just return error

                return KErrCancel;          

                }   

            }

            break;      

        case EScpCapsConfigure:

            // Configure command

            TRAP(ret, ConfigureL(aParam));

            break;

        default:

            break;

        }

    return ret;

    }  

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

// CSlideshowPlugin::HandleScreensaverEventL

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

TInt CSlideshowPlugin::HandleScreensaverEventL(

    TScreensaverEvent aEvent,

    TAny* /*aData*/ )

    {

    switch (aEvent)

        {

        case EScreensaverEventStopping:

            StopPlugin();

            break;

        case EScreensaverEventStarting:

            StartPlugin();

            break;

        case EScreensaverEventDisplayChanged:

            UpdateDisplayInfo();

            break;

        case EScreensaverEventTimeout:

            StopPlugin();

            iHost->Suspend(-1);

            break;

        default:

            break;

        }

    return KErrNone;

    }  

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

// From MCLFOperationObserver. Called by CLF when e.g. a content listing

// operation is finished.

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

void CSlideshowPlugin::HandleOperationEventL(TCLFOperationEvent aOperationEvent,

                                             TInt aError)

    {

    if (aOperationEvent == ECLFRefreshComplete)

        {

        iCLFError = aError;

        EndWaitForCLF();

        }

    if (aOperationEvent == ECLFModelOutdated)

        {

        // Need to update random list on next start

        iCLFModelUpToDate = EFalse;

        }

    }

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

// CSlideshowPlugin::ReadSettings

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

TInt CSlideshowPlugin::ReadSettings()

    {

    TInt err = KErrNone;

    err = iSlideshowRepository->Get(

        KThemesScreenSaverSlideSetDuration,

        iSettings->iSlideshowTime);

    if ((iSettings->iSlideshowTime < KMinSlideshowTime) ||

        (iSettings->iSlideshowTime > KMaxSlideshowTime))

        {

        // Out of range, set to default

        iSettings->iSlideshowTime = KDefaultSlideshowTime;

        }

    err = iSlideshowRepository->Get(

        KThemesScreenSaverSlideSetBacklight,

        iSettings->iLightsTime);

    if ((iSettings->iLightsTime < KMinLightsTime) ||

        (iSettings->iLightsTime > KMaxLightsTime))

        {

        // Out of range, set to default

        iSettings->iLightsTime = KDefaultLightsTime;

        }

    err = iSlideshowRepository->Get(

        KThemesScreenSaverSlideSetType,

        iSettings->iSlideshowType);

    // No setting for slide timing

    iSettings->iSlideTime = KDefaultSlideTime;

    return err;             

    }

#if 0

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

// CSlideshowPlugin::UpdateFileName

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

//      

TBool CSlideshowPlugin::UpdateFileName()

    {

    if ( !BaflUtils::FileExists( iEikEnv->FsSession(), 

                                iSettings->iFileName  ) )

        {

        // File is deleted now, Show empty string

        iSettings->iFileName.Copy( KEmptyString );        

        return ETrue;

        }

    TBool canbeautomated(EFalse);   

    TInt res = 0;

    iDrmHelper->SetAutomatedType( 

                   CDRMHelper::EAutomatedTypeScreenSaver );

    res = iDrmHelper->CanSetAutomated( iSettings->iFileName, 

                                       canbeautomated );

    if ( res || !canbeautomated)

        {

        iSettings->iFileName.Copy( KEmptyString );

        return ETrue;

        }

    return EFalse;

    }

#endif      

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

// CSlideshowPlugin::HandleRepositoryCallBack

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

//                

TInt CSlideshowPlugin::HandleRepositoryCallBack(TAny* aPtr)    

    {