/*
* Copyright (c) 2004-2008 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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 "config.h"
#include <e32std.h> 
#include "SyncDecodeThread.h"
#include "MaskedBitmap.h"
#include <ImageConversion.h>

namespace TBidirectionalState {
    class TRunInfo;
};

#include <EIKENV.H> 

#define KMaxHeapSize 0x1000000

class BmElem 
{
    public:
        TPtrC8 iData;
        TThreadId iParentThreadId;
        TRequestStatus* iRequestStatus;
        TInt iBitmapHandle;
        TInt iMaskHandle;
};

class CSynDecoder : public CActive
    {
    public:  // Constructors and destructor
        static CSynDecoder* NewL();
        virtual ~CSynDecoder();

    public:
        TInt Open(BmElem* aElem);

    private: // From base class CActive
        void DoCancel();
        void RunL();
        TInt RunError( TInt aError );
        void SignalParent( TInt aError );
        
    private: // Private constructors
        CSynDecoder();
        void ConstructL() {}

    private: // Data
        BmElem* iElem; // not owned
        CImageDecoder* iDecoder; // owned
        CMaskedBitmap* iBitmap; // owned
    };

// FORWARD DECLARATIONS

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

// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
//
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
CSynDecoder::CSynDecoder() : CActive(CActive::EPriorityHigh)
    {
    CActiveScheduler::Add( this );
    }

CSynDecoder* CSynDecoder::NewL()
    {
    CSynDecoder* self = new (ELeave) CSynDecoder();
    CleanupStack::PushL( self );
    self->ConstructL( );
    CleanupStack::Pop(); // self
    return self;
    }

CSynDecoder::~CSynDecoder()
    {
    Cancel();
    delete iDecoder;
    delete iBitmap;
    }

// -----------------------------------------------------------------------------
// OpenL
// -----------------------------------------------------------------------------
TInt CSynDecoder::Open(BmElem* aElem)
{
    iElem = aElem;
    // reset decoder
    TRAPD( err, 
        iDecoder = CImageDecoder::DataNewL(CEikonEnv::Static()->FsSession(), iElem->iData);
        iBitmap = CMaskedBitmap::NewL();
        );
    if( err != KErrNone )
        return err;

    TFrameInfo frameInfo = iDecoder->FrameInfo( 0 );

    if( frameInfo.iFlags & TFrameInfo::ETransparencyPossible ) {
        TDisplayMode maskmode = (frameInfo.iFlags & TFrameInfo::EAlphaChannel) ? EGray256 : EGray2;

        err = iBitmap->Create( frameInfo.iOverallSizeInPixels, EColor64K, maskmode );
    }
    else
        err = iBitmap->Create( frameInfo.iOverallSizeInPixels, EColor64K );
    //
    if( err != KErrNone )
        return err;
   // start decoding
    CFbsBitmap& dstBitmap = iBitmap->BitmapModifyable();
    CFbsBitmap& dstMask = iBitmap->MaskModifyable();

    if( ( frameInfo.iFlags & TFrameInfo::ETransparencyPossible ) && dstMask.Handle() )
        iDecoder->Convert( &iStatus, dstBitmap, dstMask, 0 );
    else {
        dstMask.Reset();
        iDecoder->Convert( &iStatus, dstBitmap, 0 );
    }
    SetActive();
    return KErrNone;
}

// -----------------------------------------------------------------------------
// CSynDecoder::DoCancel
// -----------------------------------------------------------------------------
void CSynDecoder::DoCancel()
{
    iDecoder->Cancel();
    SignalParent( KErrCancel );
}

// -----------------------------------------------------------------------------
// CSynDecoder::RunL
// -----------------------------------------------------------------------------
void CSynDecoder::RunL()
{
    SignalParent( iStatus.Int() );

    if( iStatus.Int() == KErrNone ) {
        iElem->iBitmapHandle = iBitmap->Bitmap().Handle();
        iElem->iMaskHandle = iBitmap->Mask().Handle();

        RThread self;
        self.Suspend(); 
        self.Close();
        // destroy
        CActiveScheduler::Stop();
    }
}

// -----------------------------------------------------------------------------
// CSynDecoder::RunError
// -----------------------------------------------------------------------------
TInt CSynDecoder::RunError(TInt aError)
{
    SignalParent( aError );
    return KErrNone;
}

// -----------------------------------------------------------------------------
// CSynDecoder::RunError
// -----------------------------------------------------------------------------
void CSynDecoder::SignalParent(TInt aError)
{
    RThread parent;
    parent.Open(iElem->iParentThreadId);
    parent.RequestComplete(iElem->iRequestStatus, aError );
    parent.Close();            

    if (aError != KErrNone)
        CActiveScheduler::Stop();
}

CSynDecodeThread* CSynDecodeThread::NewL()
{
    CSynDecodeThread* self = new (ELeave) CSynDecodeThread();
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
}

CSynDecodeThread::CSynDecodeThread()
{
}

CSynDecodeThread::~CSynDecodeThread()
{   	
	if(iUp) {
		iDecoderThread.Resume();
		iDecoderThread.Kill(KErrNone);  
		iDecoderThread.Close();  
	}
	delete iElem;
}


void CSynDecodeThread::ConstructL()
{
}

TInt CSynDecodeThread::Decode(const TDesC8& aData, TRequestStatus* aRequestStatus)
{
	iElem = new (ELeave) BmElem;
	iElem->iData.Set( aData );
	iElem->iParentThreadId = RThread().Id();
	iElem->iRequestStatus = aRequestStatus;

    TBuf<20> randName;
	TTime t;
	t.HomeTime();
	randName.Num( I64INT(t.Int64()) );
    
	TInt err = iDecoderThread.Create(randName, CSynDecodeThread::ScaleInThread, KDefaultStackSize, KMinHeapSize, KMaxHeapSize, iElem);
    if (err==KErrNone) {
		iUp = ETrue;
        iDecoderThread.SetPriority(EPriorityMore);
        *aRequestStatus = KRequestPending;
        iDecoderThread.Resume(); 
    }
    return err;
}

void CSynDecodeThread::Handle(TInt& aBitmapHandle, TInt& aMaskHandle)
{
    aBitmapHandle = iElem->iBitmapHandle;
    aMaskHandle = iElem->iMaskHandle;    
}

TInt CSynDecodeThread::ScaleInThread(TAny *aPtr)
{
    CTrapCleanup* cleanup = CTrapCleanup::New();
    CActiveScheduler* as = new CActiveScheduler;
    CActiveScheduler::Install(as);  

    CSynDecoder* decoder = NULL;         

    RFbsSession fbs;
    fbs.Connect();

    BmElem* elem = (BmElem*)aPtr;
    TRAPD(err, decoder = CSynDecoder::NewL());

    if (err == KErrNone && (err = decoder->Open(elem))== KErrNone )
        CActiveScheduler::Start();              
    else {    
        RThread parent;
        parent.Open(elem->iParentThreadId);
        parent.RequestComplete(elem->iRequestStatus, err);
        parent.Close();            
    }

    delete as;
    delete decoder; 
    delete cleanup; 
    fbs.Disconnect();       
    return err;
}