/*

* Copyright (c) 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:

*

*/

#include "irqsystemeventhandler.h"

#include "irqsystemeventhandler_p.h"

#include "irdiskspaceobserver.h"

#include "iralarmobserver.h"

#include "irpropertyobserver.h"

#include "irqlogger.h"

IRQSystemEventHandlerPrivate::IRQSystemEventHandlerPrivate(IRQSystemEventHandler *aSystemEventHandler) : q_ptr(aSystemEventHandler),

                              mPropertyObserver(NULL),mErrorCode(0)

}

IRQSystemEventHandlerPrivate::~IRQSystemEventHandlerPrivate()

{

    cancel();

    delete mDiskSpaceObserver;

    delete mAlarmObserver;   

    delete mPropertyObserver;

}

bool IRQSystemEventHandlerPrivate::init()

    TRAPD(err, initializeL());      

    if( KErrNone == err )

    {

        return true;

    }

    else

    {

        mAlarmObserver = NULL;

        mDiskSpaceObserver = NULL;

        mPropertyObserver = NULL;        

    }

    return false;

}

qint64 IRQSystemEventHandlerPrivate::diskCriticalLevel() const

{

    if(NULL != mDiskSpaceObserver)

    {

        return (qint64)(mDiskSpaceObserver->CriticalLevel());

    }

    else

    {

        return -1;

    }

}

void IRQSystemEventHandlerPrivate::initializeL()

{

    mAlarmObserver = CIRAlarmObserver::NewLC(this);    

    mDiskSpaceObserver = CIRDiskSpaceObserver::NewLC(this);

    mPropertyObserver = CIRPropertyObserver::NewL(this);   

    CleanupStack::Pop(mDiskSpaceObserver);

    CleanupStack::Pop(mAlarmObserver);    

}

void IRQSystemEventHandlerPrivate::cancel()

{

    if( mAlarmObserver )

    {

        mAlarmObserver->Cancel();

    }

    if( mDiskSpaceObserver )

    {

        mDiskSpaceObserver->Cancel();

    }

}

void IRQSystemEventHandlerPrivate::start()

{

    if( mAlarmObserver )

    {

        mAlarmObserver->Start();        

    }

    if( mDiskSpaceObserver )

    {

        mDiskSpaceObserver->Start((TInt64)mDefaultLevel);            

    }       

}

bool IRQSystemEventHandlerPrivate::isBelowCriticalLevel(const qint64 aCriticalLevel)

{

    if( 0 == aCriticalLevel )

    {

        return mDiskSpaceObserver->IsBelowCriticalLevel((TInt64)mDefaultLevel );

    }

    return mDiskSpaceObserver->IsBelowCriticalLevel((TInt64)aCriticalLevel );

}

bool IRQSystemEventHandlerPrivate::isCallActive() const

{

    return mPropertyObserver->IsCallActive();

}

int IRQSystemEventHandlerPrivate::getErrorCode() const

{

    return mErrorCode;

}

void IRQSystemEventHandlerPrivate::alarmStarted()

{

    if( !mAlarmOn )

    {

        emit q_ptr->alarmStarted();

        mAlarmOn = true;

    }

}

void IRQSystemEventHandlerPrivate::alarmStopped()

{

    if( mAlarmOn )

    {

        emit q_ptr->alarmStopped();

        mAlarmOn = false;

    }

}

void IRQSystemEventHandlerPrivate::notifyLowDiskSpace(qint64 aCriticalLevel)

{

    emit q_ptr->diskSpaceLowNotification(aCriticalLevel);

}

void IRQSystemEventHandlerPrivate::callIsActivated()

{

    LOG_METHOD;

    emit q_ptr->callActivated();    

}

void IRQSystemEventHandlerPrivate::callIsDeactivated()

{

    LOG_METHOD;

    emit q_ptr->callDeactivated();    

}

void IRQSystemEventHandlerPrivate::errorCallback(int aError)

{

    mErrorCode = aError;

}

void IRQSystemEventHandlerPrivate::headsetIsConnected()

{

    LOG_METHOD;    

    emit q_ptr->headsetConnected();

}

void IRQSystemEventHandlerPrivate::headsetIsDisconnected()

{

    LOG_METHOD;

    emit q_ptr->headsetDisconnected();

}