/*

* Copyright (c) 2008 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:

*

*/

#include "tsscreenshotplugin.h"

#include "tstaskmonitorglobals.h"

#include <graphics/wsscreendevice.h>

#include <s32mem.h>

const TInt KMsgSize(5);

const TInt KInvalidGroupId(~0);

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

// 

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

//

CTsScreenshotPlugin* CTsScreenshotPlugin::NewL()

{

    //no second step construction is required here

    //window server will initialize plugin later

    return new(ELeave)CTsScreenshotPlugin();

}

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

// 

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

//

void CTsScreenshotPlugin::ConstructL(MWsGraphicDrawerEnvironment& env, 

                                     const TGraphicDrawerId& id, 

                                     MWsClient& owner, 

                                     const TDesC8& /*data*/ )

{

    BaseConstructL(env, id, owner);

    env.RegisterEventHandler(this, 

                             this, 

                             TWservCrEvent::EWindowGroupChanged |

                             TWservCrEvent::EDeviceOrientationChanged);

    mWindowGroupId = KInvalidGroupId;

}

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

// 

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

//

CTsScreenshotPlugin::~CTsScreenshotPlugin()

{

    Env().UnregisterEventHandler(this);

    mCache.ResetAndDestroy();

}

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

// 

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

//

void CTsScreenshotPlugin::DoDraw(MWsGc&, const TRect&, const TDesC8&) const

{

    //plugin is not a real drawer

    //no implementation required

}

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

// 

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

//

void CTsScreenshotPlugin::HandleMessage(const TDesC8& msg)

{

    TRAP_IGNORE(HandleMessageL(msg));

}

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

// 

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

//

void CTsScreenshotPlugin::HandleMessageL(const TDesC8& msg)

{

    TInt parsedMsg[KMsgSize];

    RDesReadStream msgStream(msg);

    for (TInt iter(0); iter < KMsgSize; ++iter) {

        parsedMsg[iter] = msgStream.ReadInt32L(); 

    }

    if (RegisterScreenshotMessage == parsedMsg[0]) { //Screenshot registeration ACK 

        for(TInt iter(0); iter < mCache.Count(); ++iter) {

            if (mCache[iter]->Handle() == parsedMsg[ScreenshotHandle + 1]) {

                //bitmap is not needed no more

                delete mCache[iter];

                mCache.Remove(iter);

                break;

            }

        }

    }

}

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

// 

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

//

void CTsScreenshotPlugin::DoHandleEvent(const TWservCrEvent& event)

{

    switch (event.Type()) {

    case TWservCrEvent::EWindowGroupChanged:

        if (KInvalidGroupId != mWindowGroupId) {

            TakeScreenshot(mWindowGroupId);

        }

        mWindowGroupId = event.WindowGroupIdentifier();

        break;

    case TWservCrEvent::EDeviceOrientationChanged:

        TakeScreenshot(mWindowGroupId);

        break;

    }

}

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

// 

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

//

void CTsScreenshotPlugin::TakeScreenshot(TInt id)

{

    TRAP_IGNORE(TakeScreenshotL(id);)

}

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

// 

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

//

void CTsScreenshotPlugin::TakeScreenshotL(TInt id)

{

    if(0 >= Env().ScreenCount()) {

        User::Leave(KErrCorrupt);

    }

    const TInt screenId(0); //use local variable in case of changing screen selection policy

    const MWsScreenConfig* const screenConfig = 

        Env().Screen(screenId)->ObjectInterface<MWsScreenConfig>();

    const MWsScreenDevice* const screenDevice = 

        static_cast<MWsScreenDevice*>(Env().Screen(screenId)->ResolveObjectInterface(MWsScreenDevice::EWsObjectInterfaceId));

    User::LeaveIfNull(screenConfig);

    User::LeaveIfNull(screenDevice);

    //prepare destination bitmap

    CFbsBitmap *bitmap = new (ELeave) CFbsBitmap();

    CleanupStack::PushL(bitmap);

    User::LeaveIfError(bitmap->Create(screenConfig->SizeInPixels(), 

                                screenConfig->DisplayMode()));

    screenDevice->CopyScreenToBitmapL(bitmap, 

                                      screenConfig->SizeInPixels());

    //prepare and send message

    TInt msg[KMsgSize] = {RegisterScreenshotMessage};

    msg[WindowsGroup + 1] = id;

    msg[ScreenshotHandle + 1] = bitmap->Handle();

    msg[Priority + 1] = Low;

    msg[AdditionalParameters + 1] = 0; //unused

    const TPckgC<TInt[sizeof(msg) / sizeof(TInt)]> buf(msg);

    User::LeaveIfError(SendMessage(buf));

    mCache.AppendL(bitmap);

    CleanupStack::Pop(bitmap);

}