/*
* Copyright (c) 2006 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:   SlideshowPlugin utility classes and functions
*
*/



// INCLUDE FILES
#include <centralrepository.h>
#include <f32fsys.h>
#include <eikenv.h>
#include <pathinfo.h>
#include <DRMHelper.h>
#include <caf/caftypes.h>

#include "SlideshowPluginUtils.h"

_LIT(KSSPDriveLetterMC, "E");

// ============================ MEMBER FUNCTIONS ===============================

// Repository watcher

// ---------------------------------------------------------------------------
// CRepositoryWatcher::NewL
// ---------------------------------------------------------------------------
//
CRepositoryWatcher* CRepositoryWatcher::NewL(
    const TUid aUid,
    const TUint32 aKey,
    CCenRepNotifyHandler::TCenRepKeyType aKeyType,
    TCallBack aCallBack,
    CRepository* aRepository)
    {
    CRepositoryWatcher* self = new(ELeave) 
          CRepositoryWatcher(aUid, aKey, aCallBack, aRepository);

    CleanupStack::PushL(self);
    self->ConstructL(aKeyType);
    CleanupStack::Pop(self);

    return self;
    }

// ---------------------------------------------------------------------------
// CRepositoryWatcher::NewL
// ---------------------------------------------------------------------------
//
CRepositoryWatcher* CRepositoryWatcher::NewL(
    const TUid aUid,
    TCallBack aCallBack,
    CRepository* aRepository)
    {
    CRepositoryWatcher* self = new(ELeave) CRepositoryWatcher(
        aUid, NCentralRepositoryConstants::KInvalidNotificationId, aCallBack, aRepository);

    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);

    return self;
    }

// ---------------------------------------------------------------------------
// CRepositoryWatcher::~CRepositoryWatcher
// ---------------------------------------------------------------------------
//
CRepositoryWatcher::~CRepositoryWatcher()
    {
    if ( iNotifyHandler )
        {
        iNotifyHandler->StopListening();
        delete iNotifyHandler;      
        }
    }

// ---------------------------------------------------------------------------
// CRepositoryWatcher::CRepositoryWatcher
// ---------------------------------------------------------------------------
//
CRepositoryWatcher::CRepositoryWatcher(
    const TUid aUid,
    const TUint32 aKey,
    TCallBack aCallBack,
    CRepository* aRepository)
    :
    iUid(aUid), iKey(aKey), iCallBack(aCallBack), iRepository(aRepository)
    {
    }

// ---------------------------------------------------------------------------
// CRepositoryWatcher::ConstructL
// ---------------------------------------------------------------------------
//
void CRepositoryWatcher::ConstructL(CCenRepNotifyHandler::TCenRepKeyType aKeyType)
    {
    iNotifyHandler = CCenRepNotifyHandler::NewL(*this, *iRepository, aKeyType, iKey);
    iNotifyHandler->StartListeningL();
    }

// ---------------------------------------------------------------------------
// CRepositoryWatcher::ConstructL
// ---------------------------------------------------------------------------
//
void CRepositoryWatcher::ConstructL()
    {
    iNotifyHandler = CCenRepNotifyHandler::NewL(*this, *iRepository);
    iNotifyHandler->StartListeningL();
    }

// ---------------------------------------------------------------------------
// CRepositoryWatcher::ChangedKey
// ---------------------------------------------------------------------------
//
TUint32 CRepositoryWatcher::ChangedKey()
    {
    return iChangedKey;
    }

// ---------------------------------------------------------------------------
// CRepositoryWatcher::HandleNotifyInt
// ---------------------------------------------------------------------------
//
void CRepositoryWatcher::HandleNotifyInt( 
                                    TUint32 aKey, TInt /*aNewValue*/ )
    {
    iChangedKey = aKey;
    iCallBack.CallBack();
    iChangedKey = NCentralRepositoryConstants::KInvalidNotificationId;
    }

// ---------------------------------------------------------------------------
// CRepositoryWatcher::HandleNotifyString
// ---------------------------------------------------------------------------
//
void CRepositoryWatcher::HandleNotifyString( TUint32 aKey, 
                                                     const TDesC16& /*aNewValue*/ )
    {  
    iChangedKey = aKey;
    iCallBack.CallBack();
    iChangedKey = NCentralRepositoryConstants::KInvalidNotificationId;
    }

// ---------------------------------------------------------------------------
// CRepositoryWatcher::HandleNotifyGeneric
// ---------------------------------------------------------------------------
//
void CRepositoryWatcher::HandleNotifyGeneric(TUint32 aKey)
    {
    iChangedKey = aKey;
    iCallBack.CallBack();
    iChangedKey = NCentralRepositoryConstants::KInvalidNotificationId;
    }

// ---------------------------------------------------------------------------
// CRepositoryWatcher::HandleNotifyError
// ---------------------------------------------------------------------------
//
void CRepositoryWatcher::HandleNotifyError(TUint32 /*aKey*/, TInt /*aError*/, CCenRepNotifyHandler* /*aHandler*/)
    {
    }     


// P & S subscriber    

// ---------------------------------------------------------------------------
// CPSSubscriber::CPSSubscriber
// ---------------------------------------------------------------------------
//
CPSSubscriber::CPSSubscriber(TCallBack aCallBack, RProperty& aProperty)
    : CActive(EPriorityNormal), iCallBack(aCallBack), iProperty(aProperty)
    {
    CActiveScheduler::Add(this);
    }

// ---------------------------------------------------------------------------
// CPSSubscriber::~CPSSubscriber
// ---------------------------------------------------------------------------
//
CPSSubscriber::~CPSSubscriber()
    {
    Cancel();
    }

// ---------------------------------------------------------------------------
// CPSSubscriber::SubscribeL
// ---------------------------------------------------------------------------
//
void CPSSubscriber::SubscribeL()
    {
    if (!IsActive())
        {
        iProperty.Subscribe(iStatus);
        SetActive();
        }
    }

// ---------------------------------------------------------------------------
// CPSSubscriber::StopSubscribe
// ---------------------------------------------------------------------------
//
void CPSSubscriber::StopSubscribe()
    {
    Cancel();
    }

// ---------------------------------------------------------------------------
// CPSSubscriber::RunL
// ---------------------------------------------------------------------------
//
void CPSSubscriber::RunL()
    {
    if (iStatus.Int() == KErrNone)
        {
        iCallBack.CallBack();
        SubscribeL();
        }
    }

// ---------------------------------------------------------------------------
// CPSSubscriber::DoCancel
// ---------------------------------------------------------------------------
//
void CPSSubscriber::DoCancel()
    {
    iProperty.Cancel();
    }



// ========== UTILITIES CLASS ===============================

// Checks if memory card is present
TBool SlideshowUtil::IsMCPresent()
    {
    RFs& fs = CCoeEnv::Static()->FsSession();

    TInt error = KErrNone;
    TDriveInfo driveInfo;
    TInt res = 0;
    TInt err = fs.CharToDrive(PathInfo::MemoryCardRootPath()[0], res);
    error = fs.Drive(driveInfo, res );

    // Not present, locked or unknown is bad
    if ((error != KErrNone) ||
        (driveInfo.iMediaAtt & KMediaAttLocked) ||
        (driveInfo.iType == EMediaNotPresent) ||
        (driveInfo.iType == EMediaUnknown))
        {
        return EFalse;
        }

    // Read-only is fine
    return ETrue;
    }


// Checks if the given file is on memory card
TBool SlideshowUtil::IsOnMC(TFileName aFile)
    {
    // Grab drive letter from path and compare to memory card drive letter
    TBuf<1> driveLetterBuf;
    driveLetterBuf.CopyUC(aFile.Left(1));

    if (driveLetterBuf.Compare(KSSPDriveLetterMC) == 0)
        {
        return ETrue;
        }
    
    return EFalse;
    }


// Checks that the file has enough DRM rights to be displayed
TBool SlideshowUtil::DRMCheck(CDRMHelper *aDRMHelper, TDesC& /* aFileName */)
    {
    if (!aDRMHelper)
        {
        return EFalse;
        }

    return ETrue;
    }

    
// Checks that the slide has enough DRM rights to be displayed
TBool SlideshowUtil::DRMCheck(CDRMHelper *aDRMHelper, CSlideshowSlide* aSlide)
    {
    if (!aDRMHelper || !aSlide)
        {
        return EFalse;
        }

    return (DRMCheck(aDRMHelper, *(aSlide->FileName())));
    }

    
// Consumes the slide's DRM rights
void SlideshowUtil::DRMConsume(CDRMHelper* aDRMHelper, CSlideshowSlide* aSlide)
    {
    if (!aDRMHelper || !aSlide)
        {
        return;
        }
    
    aDRMHelper->ConsumeFile2(*(aSlide->FileName()),
                             ContentAccess::EView,
                             CDRMHelper::EStart);
    aDRMHelper->ConsumeFile2(*(aSlide->FileName()),
                             ContentAccess::EView,
                             CDRMHelper::EFinish);
    }


// End of File