/*
* Copyright (c) 2006-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:  Stores element data and writes it to stream
*
*/


#include <connect/sbdefs.h>

#include "cbsbackupobserver.h"


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

// ---------------------------------------------------------------------------
// CBSBackupObserver::NewL
// ---------------------------------------------------------------------------
//
CBSBackupObserver* CBSBackupObserver::NewL()
    {
    CBSBackupObserver* self = NewLC();
    CleanupStack::Pop();
    return self;
    }

// ---------------------------------------------------------------------------
// CBSBackupObserver::NewLC
// ---------------------------------------------------------------------------
//
CBSBackupObserver* CBSBackupObserver::NewLC()
    {
    CBSBackupObserver* self = new (ELeave) CBSBackupObserver();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ---------------------------------------------------------------------------
// CBSBackupObserver::ConstructL
// ---------------------------------------------------------------------------
//
void CBSBackupObserver::ConstructL()
    {
    CActiveScheduler::Add( this );
    iProperty.Attach( KUidSystemCategory, conn::KUidBackupRestoreKey );
    iLatestState = BackupStateL();
    Subscribe();
    }

// ---------------------------------------------------------------------------
// CBSBackupObserver::CBSBackupObserver
// ---------------------------------------------------------------------------
//
CBSBackupObserver::CBSBackupObserver() :
    CActive( EPriorityStandard )
    {
    }

// ---------------------------------------------------------------------------
// CBSBackupObserver::~CBSBackupObserver
// ---------------------------------------------------------------------------
//
CBSBackupObserver::~CBSBackupObserver()
    {
    Cancel();
    iObservers.Close();
    }

// ---------------------------------------------------------------------------
// CBSBackupObserver::RunL
// ---------------------------------------------------------------------------
//
void CBSBackupObserver::RunL()
    {
    MBSBackupObserver::TBackupState newState = BackupStateL();
    if( newState != iLatestState )
        {
        // state changed
        iLatestState = newState;
        NotifyObserversL( iLatestState );
        }
    Subscribe();
    }

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

// ---------------------------------------------------------------------------
// CBSBackupObserver::RunError
// ---------------------------------------------------------------------------
//
TInt CBSBackupObserver::RunError( TInt /*aError*/ )
    {
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CBSBackupObserver::RegisterObserver
// ---------------------------------------------------------------------------
//
TInt CBSBackupObserver::RegisterObserver( MBSBackupObserver* aObserver )
    {
    TInt err = iObservers.InsertInAddressOrder( aObserver );
    if( err == KErrAlreadyExists )
        {
        // ignore duplicate registration
        err = KErrNone;
        }

    // if backup is already active -> notify
    if( iLatestState == MBSBackupObserver::EBackupActive )
        {
        TRAP_IGNORE( aObserver->HandleBackupStateL( iLatestState ) );
        }

    return err;
    }

// ---------------------------------------------------------------------------
// CBSBackupObserver::UnregisterObserver
// ---------------------------------------------------------------------------
//
void CBSBackupObserver::UnregisterObserver( MBSBackupObserver* aObserver )
    {
    TInt index = iObservers.FindInAddressOrder( aObserver );
    if( index != KErrNotFound )
        {
        iObservers.Remove( index );
        }
    }

// ---------------------------------------------------------------------------
// CBSBackupObserver::Subscribe
// ---------------------------------------------------------------------------
//
void CBSBackupObserver::Subscribe()
    {
    if( IsActive() )
        {
        // already active
        return;
        }
    iStatus = KRequestPending;
    iProperty.Subscribe( iStatus );
    SetActive();    
    }

// ---------------------------------------------------------------------------
// CBSBackupObserver::NotifyObservers
// ---------------------------------------------------------------------------
//
void CBSBackupObserver::NotifyObserversL( MBSBackupObserver::TBackupState aState )
    {
    TInt count = iObservers.Count();
    for( TInt i = 0; i < count; i++ )
        {
        TRAP_IGNORE( iObservers[i]->HandleBackupStateL( aState ) );
        }
    }

// ---------------------------------------------------------------------------
// CBSBackupObserver::BackupState
// ---------------------------------------------------------------------------
//
MBSBackupObserver::TBackupState CBSBackupObserver::BackupStateL()
    {
    TInt value = 0;
    User::LeaveIfError( iProperty.Get( value ) );
    if( value == 0 || 
        value == ( conn::EBURNormal | conn::ENoBackup ) )
        {
        // backup or restore is not active at the moment
        return MBSBackupObserver::EBackupNotActive;
        }
    return MBSBackupObserver::EBackupActive;
    }

// End of file