1 /*

     2 * Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   glximagereader.cpp

    15 *

    16 */

    17 

    18 

    19 #include <apgcli.h>

    20 #include <glxtracer.h>

    21 //for DRM

    22 #include <caf/content.h>

    23 #include <caf/attributeset.h>

    24 #include <DRMHelper.h>

    25 

    26 #include "glximagereader.h"

    27 

    28 

    29 // ---------------------------------------------------------

    30 // CGlxImageReader::NewL

    31 // ---------------------------------------------------------

    32 //  

    33 CGlxImageReader* CGlxImageReader::NewL(MImageReadyCallBack& aNotify)

    34     {

    35     TRACER("CGlxImageReader::NewL");  

    36     

    37     CGlxImageReader* self = CGlxImageReader::NewLC( aNotify);

    38     CleanupStack::Pop(self);

    39     return self;

    40     }

    41 

    42 // ---------------------------------------------------------

    43 // CGlxImageReader::NewLC

    44 // ---------------------------------------------------------

    45 //  

    46 CGlxImageReader* CGlxImageReader::NewLC(MImageReadyCallBack& aNotify)

    47     {

    48     TRACER("CGlxImageReader::NewLC"); 

    49     

    50     CGlxImageReader* self = new(ELeave) CGlxImageReader(aNotify);

    51     CleanupStack::PushL(self);

    52     self->ConstructL();

    53     return self;

    54     }

    55 

    56 // ---------------------------------------------------------

    57 // CGlxImageReader::CGlxImageReader

    58 // ---------------------------------------------------------

    59 // 

    60 CGlxImageReader::CGlxImageReader(MImageReadyCallBack& aNotify)

    61 :CActive(0),iNotify(aNotify)

    62                                 {

    63                                 }

    64 

    65 // ---------------------------------------------------------

    66 // CGlxImageReader::~CGlxImageReader

    67 // ---------------------------------------------------------

    68 //

    69 CGlxImageReader::~CGlxImageReader()

    70     {

    71     TRACER("CGlxImageReader::~");

    72     

    73     Cancel();

    74     delete iFrame;

    75     delete iImageDecoder;

    76     if(iImgViewerMgr)

    77         {

    78         iImgViewerMgr->DeleteInstance();

    79         }

    80     }

    81 

    82 // ---------------------------------------------------------

    83 // CGlxImageReader::ConstructL

    84 // ---------------------------------------------------------

    85 //

    86 void CGlxImageReader::ConstructL()

    87     {

    88     TRACER("CGlxImageReader::ConstructL");

    89     

    90     CActiveScheduler::Add(this);

    91     iIsLaunchedFromFMngr = EFalse;

    92     TDataType imageType;

    93 

    94     iImgViewerMgr = CGlxImageViewerManager::InstanceL();

    95     if (iImgViewerMgr && iImgViewerMgr->IsPrivate())

    96         {

    97         iIsLaunchedFromFMngr = ETrue;    

    98         }

    99     

   100     GetFileTypeL(imageType);

   101     if (iIsLaunchedFromFMngr)

   102         {

   103         // TODO type cast handle to RFile

   104         iImageDecoder = CImageDecoder::FileNewL(iImgViewerMgr->ImageFileHandle(), ContentAccess::EPeek);

   105         }

   106     else

   107         { 

   108         iImageDecoder = CImageDecoder::FileNewL(CCoeEnv::Static()->FsSession(), iImgViewerMgr->ImageUri()->Des());

   109         }

   110 

   111     iFrame = new(ELeave)CFbsBitmap();

   112     iFrame->Create(iImageDecoder->FrameInfo(0).iOverallSizeInPixels,iImageDecoder->FrameInfo(0).iFrameDisplayMode);

   113     iImageDecoder->Convert(&iStatus,*iFrame,0);

   114     SetActive();

   115     }

   116 

   117 // ---------------------------------------------------------

   118 // CGlxImageReader::GetFileTypeL

   119 // ---------------------------------------------------------

   120 //

   121 void CGlxImageReader::GetFileTypeL(TDataType aMimeType)

   122     {

   123     TRACER("CGlxImageReader::GetFileTypeL");

   124     

   125     RApaLsSession session;

   126     User::LeaveIfError(session.Connect());

   127     CleanupClosePushL(session);

   128 

   129     TUid uid;

   130     if(iIsLaunchedFromFMngr)

   131         {

   132         // TODO type cast handle to RFile

   133         User::LeaveIfError(session.AppForDocument(iImgViewerMgr->ImageFileHandle(), uid, aMimeType));

   134         }

   135     else

   136         {

   137         User::LeaveIfError(session.AppForDocument(iImgViewerMgr->ImageUri()->Des(),uid,aMimeType));

   138         }

   139     CleanupStack::PopAndDestroy(); // session

   140     }

   141 

   142 // ---------------------------------------------------------

   143 // CGlxImageReader::DoCancel

   144 // ---------------------------------------------------------

   145 //

   146 void CGlxImageReader::DoCancel()

   147     {

   148     TRACER("CGlxImageReader::DoCancel");

   149     iImageDecoder->Cancel();

   150     }

   151 

   152 // ---------------------------------------------------------

   153 // CGlxImageReader::RunL

   154 // ---------------------------------------------------------

   155 //

   156 void CGlxImageReader::RunL()

   157     {

   158     TRACER("CGlxImageReader::RunL");

   159     

   160     const TSize sz = iFrame->SizeInPixels();

   161     iNotify.ImageReadyL(iStatus.Int(),sz);

   162     }

   163 // ---------------------------------------------------------

   164 // CGlxImageReader::HasDRMRightsL

   165 // ---------------------------------------------------------

   166 //

   167 TBool CGlxImageReader::HasDRMRightsL()

   168     {

   169     TRACER("Entering CGlxImageReader::HasDRMRightsL");

   170  

   171     RAttributeSet attributeSet;

   172     CleanupClosePushL(attributeSet);

   173     attributeSet.AddL(ECanView);

   174     attributeSet.AddL(EIsProtected);

   175     CContent* content;

   176     if(iIsLaunchedFromFMngr)

   177         {

   178         content = CContent::NewL(iImgViewerMgr->ImageFileHandle());    

   179         }

   180     else

   181         {

   182         content = CContent::NewL(iImgViewerMgr->ImageUri()->Des());

   183         }

   184 

   185     // Retrieve the attributes from the agent

   186     User::LeaveIfError(content->GetAttributeSet(attributeSet));

   187     TInt rights = ERightsNone;

   188     TBool drmProtected = EFalse;

   189     attributeSet.GetValue(EIsProtected,drmProtected);

   190     if(!drmProtected)

   191         {

   192         CleanupStack::PopAndDestroy();

   193         delete content;

   194         content = NULL;

   195         return EFalse;

   196         }

   197     attributeSet.GetValue(ECanView,rights);

   198     CleanupStack::PopAndDestroy();

   199 

   200     if(content)

   201         {

   202         delete content;

   203         content = NULL;

   204         }

   205 

   206     if(rights)

   207         {

   208         return ETrue;

   209         }

   210     return EFalse;

   211     }