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 #include <glxlog.h>

    22 #include <glxpanic.h>

    23 

    24 //for DRM

    25 #include <caf/content.h>

    26 #include <caf/attributeset.h>

    27 #include <DRMHelper.h>

    28 

    29 #include "glximagereader.h"

    30 

    31 

    32 // ---------------------------------------------------------

    33 // CGlxImageReader::NewL

    34 // ---------------------------------------------------------

    35 //  

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

    37     {

    38     TRACER("CGlxImageReader::NewL");  

    39     

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

    41     CleanupStack::Pop(self);

    42     return self;

    43     }

    44 

    45 // ---------------------------------------------------------

    46 // CGlxImageReader::NewLC

    47 // ---------------------------------------------------------

    48 //  

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

    50     {

    51     TRACER("CGlxImageReader::NewLC"); 

    52     

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

    54     CleanupStack::PushL(self);

    55     self->ConstructL();

    56     return self;

    57     }

    58 

    59 // ---------------------------------------------------------

    60 // CGlxImageReader::CGlxImageReader

    61 // ---------------------------------------------------------

    62 // 

    63 CGlxImageReader::CGlxImageReader(MImageReadyCallBack& aNotify)

    64 :CActive(0),iNotify(aNotify)

    65     {

    66     //no implementation

    67     }

    68 

    69 // ---------------------------------------------------------

    70 // CGlxImageReader::~CGlxImageReader

    71 // ---------------------------------------------------------

    72 //

    73 CGlxImageReader::~CGlxImageReader()

    74     {

    75     TRACER("CGlxImageReader::~");

    76     if(iImageDecoder)

    77         {

    78         Cancel();

    79         delete iImageDecoder;

    80         }  

    81 

    82     if(iFrame)

    83         {

    84         delete iFrame;

    85         }

    86 

    87     if(iImgViewerMgr)

    88         {

    89         iImgViewerMgr->Close();

    90         }

    91     }

    92 

    93 // ---------------------------------------------------------

    94 // CGlxImageReader::ConstructL

    95 // ---------------------------------------------------------

    96 //

    97 void CGlxImageReader::ConstructL()

    98     {

    99     TRACER("CGlxImageReader::ConstructL");

   100 

   101     CActiveScheduler::Add(this);

   102 

   103     iImgViewerMgr = CGlxImageViewerManager::InstanceL();

   104     if (!iImgViewerMgr)

   105         {

   106         return;

   107         }

   108 

   109     TInt errInImage = KErrGeneral;

   110     if (iImgViewerMgr->IsPrivate())

   111         {

   112         if ( &(iImgViewerMgr->ImageFileHandle()) != NULL )

   113             {

   114             TRAP(errInImage,iImageDecoder = CImageDecoder::FileNewL(iImgViewerMgr->ImageFileHandle(), ContentAccess::EPeek));

   115             }

   116         }

   117     else

   118         {

   119         if ( iImgViewerMgr->ImageUri() != NULL )

   120             {

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

   122             }

   123         }

   124     if (errInImage != KErrNone)

   125         {

   126         User::Leave(errInImage);

   127         }

   128 

   129     if ( iImageDecoder )

   130         {

   131         iFrame = new (ELeave) CFbsBitmap();

   132         iFrame->Create(iImageDecoder->FrameInfo(0).iOverallSizeInPixels,

   133                 iImageDecoder->FrameInfo(0).iFrameDisplayMode);

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

   135         SetActive();

   136         }

   137     }

   138 

   139 

   140 // ---------------------------------------------------------

   141 // CGlxImageReader::DoCancel

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

   143 //

   144 void CGlxImageReader::DoCancel()

   145     {

   146     TRACER("CGlxImageReader::DoCancel");

   147     iImageDecoder->Cancel();

   148     }

   149 

   150 // ---------------------------------------------------------

   151 // CGlxImageReader::RunL

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

   153 //

   154 void CGlxImageReader::RunL()

   155     {

   156     TRACER("CGlxImageReader::RunL");

   157     

   158     TSize size = TSize();

   159     TInt reqStatus = iStatus.Int(); 

   160     if (reqStatus == KErrNone && iFrame)

   161         {

   162         size = iFrame->SizeInPixels();

   163         }

   164     GLX_DEBUG2("CGlxImageReader::RunL() reqStatus=%d", reqStatus);   

   165     iNotify.ImageSizeReady(reqStatus, size);

   166     }

   167 // ---------------------------------------------------------

   168 // CGlxImageReader::GetDRMRightsL

   169 // ---------------------------------------------------------

   170 //

   171 TInt CGlxImageReader::GetDRMRightsL(TInt aAttribute)

   172     {

   173     TRACER("CGlxImageReader::GetDRMRightsL");

   174     

   175     TInt value = KErrNone;

   176     TInt error = KErrNone;

   177     CContent* content = NULL;

   178     if(iImgViewerMgr->IsPrivate())

   179         {

   180         if ( &(iImgViewerMgr->ImageFileHandle()) != NULL )

   181             {

   182             content = CContent::NewLC(iImgViewerMgr->ImageFileHandle());

   183             }

   184         }

   185     else

   186         {

   187         if ( iImgViewerMgr->ImageUri() != NULL )

   188             {

   189             content = CContent::NewLC(iImgViewerMgr->ImageUri()->Des());

   190             }

   191         }

   192     __ASSERT_ALWAYS(content, Panic(EGlxPanicNullPointer));

   193     error = content->GetAttribute(aAttribute, value);

   194     CleanupStack::PopAndDestroy( content );

   195     GLX_DEBUG2("CGlxImageReader::GetDRMRightsL value=%d", value);

   196     if(error != KErrNone)

   197 	    {

   198 	    switch	( aAttribute )

   199 			{

   200 			case ContentAccess::EIsProtected : 

   201 				value = ETrue;

   202 				break;

   203 			case ContentAccess::ECanView : 

   204 				value = EFalse;

   205 				break;

   206 		    default:

   207 		    	value = EFalse;

   208 			}

   209 	    }

   210     return value;

   211     }