/*
* Copyright (c) 2008-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:   glximagereader.cpp
*
*/


#include <apgcli.h>
#include <glxtracer.h>
//for DRM
#include <caf/content.h>
#include <caf/attributeset.h>
#include <DRMHelper.h>

#include "glximagereader.h"


// ---------------------------------------------------------
// CGlxImageReader::NewL
// ---------------------------------------------------------
//  
CGlxImageReader* CGlxImageReader::NewL(MImageReadyCallBack& aNotify)
    {
    TRACER("CGlxImageReader::NewL");  
    
    CGlxImageReader* self = CGlxImageReader::NewLC( aNotify);
    CleanupStack::Pop(self);
    return self;
    }

// ---------------------------------------------------------
// CGlxImageReader::NewLC
// ---------------------------------------------------------
//  
CGlxImageReader* CGlxImageReader::NewLC(MImageReadyCallBack& aNotify)
    {
    TRACER("CGlxImageReader::NewLC"); 
    
    CGlxImageReader* self = new(ELeave) CGlxImageReader(aNotify);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

// ---------------------------------------------------------
// CGlxImageReader::CGlxImageReader
// ---------------------------------------------------------
// 
CGlxImageReader::CGlxImageReader(MImageReadyCallBack& aNotify)
:CActive(0),iNotify(aNotify)
                                {
                                }

// ---------------------------------------------------------
// CGlxImageReader::~CGlxImageReader
// ---------------------------------------------------------
//
CGlxImageReader::~CGlxImageReader()
    {
    TRACER("CGlxImageReader::~");
    
    Cancel();
    delete iFrame;
    delete iImageDecoder;
    if(iImgViewerMgr)
        {
        iImgViewerMgr->DeleteInstance();
        }
    }

// ---------------------------------------------------------
// CGlxImageReader::ConstructL
// ---------------------------------------------------------
//
void CGlxImageReader::ConstructL()
    {
    TRACER("CGlxImageReader::ConstructL");
    
    CActiveScheduler::Add(this);
    iIsLaunchedFromFMngr = EFalse;
    TDataType imageType;

    iImgViewerMgr = CGlxImageViewerManager::InstanceL();
    if (iImgViewerMgr && iImgViewerMgr->IsPrivate())
        {
        iIsLaunchedFromFMngr = ETrue;    
        }
    
    GetFileTypeL(imageType);
    if (iIsLaunchedFromFMngr)
        {
        // TODO type cast handle to RFile
        iImageDecoder = CImageDecoder::FileNewL(iImgViewerMgr->ImageFileHandle(), ContentAccess::EPeek);
        }
    else
        { 
        iImageDecoder = CImageDecoder::FileNewL(CCoeEnv::Static()->FsSession(), iImgViewerMgr->ImageUri()->Des());
        }

    iFrame = new(ELeave)CFbsBitmap();
    iFrame->Create(iImageDecoder->FrameInfo(0).iOverallSizeInPixels,iImageDecoder->FrameInfo(0).iFrameDisplayMode);
    iImageDecoder->Convert(&iStatus,*iFrame,0);
    SetActive();
    }

// ---------------------------------------------------------
// CGlxImageReader::GetFileTypeL
// ---------------------------------------------------------
//
void CGlxImageReader::GetFileTypeL(TDataType aMimeType)
    {
    TRACER("CGlxImageReader::GetFileTypeL");
    
    RApaLsSession session;
    User::LeaveIfError(session.Connect());
    CleanupClosePushL(session);

    TUid uid;
    if(iIsLaunchedFromFMngr)
        {
        // TODO type cast handle to RFile
        User::LeaveIfError(session.AppForDocument(iImgViewerMgr->ImageFileHandle(), uid, aMimeType));
        }
    else
        {
        User::LeaveIfError(session.AppForDocument(iImgViewerMgr->ImageUri()->Des(),uid,aMimeType));
        }
    CleanupStack::PopAndDestroy(); // session
    }

// ---------------------------------------------------------
// CGlxImageReader::DoCancel
// ---------------------------------------------------------
//
void CGlxImageReader::DoCancel()
    {
    TRACER("CGlxImageReader::DoCancel");
    iImageDecoder->Cancel();
    }

// ---------------------------------------------------------
// CGlxImageReader::RunL
// ---------------------------------------------------------
//
void CGlxImageReader::RunL()
    {
    TRACER("CGlxImageReader::RunL");
    
    const TSize sz = iFrame->SizeInPixels();
    iNotify.ImageReadyL(iStatus.Int(),sz);
    }
// ---------------------------------------------------------
// CGlxImageReader::HasDRMRightsL
// ---------------------------------------------------------
//
TBool CGlxImageReader::HasDRMRightsL()
    {
    TRACER("Entering CGlxImageReader::HasDRMRightsL");
 
    RAttributeSet attributeSet;
    CleanupClosePushL(attributeSet);
    attributeSet.AddL(ECanView);
    attributeSet.AddL(EIsProtected);
    CContent* content;
    if(iIsLaunchedFromFMngr)
        {
        content = CContent::NewL(iImgViewerMgr->ImageFileHandle());    
        }
    else
        {
        content = CContent::NewL(iImgViewerMgr->ImageUri()->Des());
        }

    // Retrieve the attributes from the agent
    User::LeaveIfError(content->GetAttributeSet(attributeSet));
    TInt rights = ERightsNone;
    TBool drmProtected = EFalse;
    attributeSet.GetValue(EIsProtected,drmProtected);
    if(!drmProtected)
        {
        CleanupStack::PopAndDestroy();
        delete content;
        content = NULL;
        return EFalse;
        }
    attributeSet.GetValue(ECanView,rights);
    CleanupStack::PopAndDestroy();

    if(content)
        {
        delete content;
        content = NULL;
        }

    if(rights)
        {
        return ETrue;
        }
    return EFalse;
    }