/*
 * 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:    CGlxImageViewerManager implementation
 *
 */


#include "glximageviewermanager.h"
#include <glxsingletonstore.h>
#include <glxtracer.h>

#include <f32file.h>

EXPORT_C CGlxImageViewerManager* CGlxImageViewerManager::InstanceL()
    {
    TRACER("CGlxImageViewerManager::InstanceL()");
    return CGlxSingletonStore::InstanceL(&NewL);
    }

EXPORT_C void CGlxImageViewerManager::Close()
    {
    TRACER("CGlxImageViewerManager::DeleteInstance()");
    CGlxSingletonStore::Close(this);
    }

EXPORT_C HBufC* CGlxImageViewerManager::ImageUri()
    {
    TRACER("CGlxImageViewerManager::ImageUri()");    
    return iImageUri;
    }

EXPORT_C RFile64& CGlxImageViewerManager::ImageFileHandle()
    {
    TRACER("CGlxImageViewerManager::ImageFileHandle()");    
    return *iFile;
    }

EXPORT_C TBool CGlxImageViewerManager::IsPrivate()
    {
    TRACER("CGlxImageViewerManager::IsPrivate()");    
    return iIsPrivate;
    }

CGlxImageViewerManager::CGlxImageViewerManager()
    : iImageUri(NULL), iFile(NULL), iIsPrivate(EFalse)
    {
    TRACER("CGlxImageViewerManager::CGlxImageViewerManager()");
    // No implementation required
    }

CGlxImageViewerManager::~CGlxImageViewerManager()
    {
    TRACER("CGlxImageViewerManager::~CGlxImageViewerManager()");
    Reset();
    }

CGlxImageViewerManager* CGlxImageViewerManager::NewLC()
    {
    TRACER("CGlxImageViewerManager::NewLC()");
    CGlxImageViewerManager* self = new (ELeave) CGlxImageViewerManager();
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

CGlxImageViewerManager* CGlxImageViewerManager::NewL()
    {
    TRACER("CGlxImageViewerManager::NewL()");
    CGlxImageViewerManager* self = CGlxImageViewerManager::NewLC();
    CleanupStack::Pop(self);
    return self;
    }

void CGlxImageViewerManager::ConstructL()
    {
    TRACER("CGlxImageViewerManager::ConstructL()");
    }

// ---------------------------------------------------------------------------
// SetImageUri
// ---------------------------------------------------------------------------
//
EXPORT_C void CGlxImageViewerManager::SetImageUriL(const TDesC& aFileName)
    {
    TRACER("void CGlxImageViewerManager::SetImageUriL()");    
    if ( iImageUri )
        {
        delete iImageUri;
        iImageUri = NULL;
        }
    if (aFileName.Length() == 0)
        {
        User::Leave(KErrNotSupported);    
        }
   	
    iImageUri = aFileName.AllocL();    
    }

// ---------------------------------------------------------------------------
// Reset
// ---------------------------------------------------------------------------
//
EXPORT_C void CGlxImageViewerManager::Reset()
    {
    TRACER("void CGlxImageViewerManager::Reset()");
    if( iFile )
        {
        iFile->Close();
        }
    delete iFile;
    iFile = NULL;

    if ( iImageUri )
        {
        delete iImageUri;
        iImageUri = NULL;
        }
    iIsPrivate = EFalse;
    }

// ---------------------------------------------------------------------------
// SetImageFileHandleL
// ---------------------------------------------------------------------------
//
EXPORT_C void CGlxImageViewerManager::SetImageFileHandleL(const RFile& aFileHandle)
    {
    TRACER("void CGlxImageViewerManager::SetImageFileHandleL()");
    _LIT( KPrivateFolder, "\\Private\\" );    // Platsec private folder  
    TFileName filePath;
    User::LeaveIfError( aFileHandle.FullName( filePath ) );
    SetImageUriL( filePath );
    TParsePtrC parse( filePath );
    if( parse.PathPresent() &&
        parse.Path().Length() > KPrivateFolder().Length() &&
        parse.Path().Left( KPrivateFolder().Length() ).CompareF( KPrivateFolder ) == 0 )
        {
        // File is in private folder; duplicate file handle
        iFile = new (ELeave) RFile64;
        User::LeaveIfError( iFile->Duplicate( aFileHandle ) );
        iIsPrivate = ETrue;
        }
    }