/*

* 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: 

*

*/

// SYSTEM INCLUDES

#include <uiklaf/private/lafshut.h>

#include <w32std.h>

#include <coemain.h>

#include <lafmemorywatcher.rsg>

#include <bautils.h>

#include <e32property.h>

#include <UikonInternalPSKeys.h>

#include <data_caging_path_literals.hrh>

#include <coreapplicationuisdomainpskeys.h>

// USER INCLUDES

#include "UiklafInternalCRKeys.h"

#include "OodTraces.h"

#include "Ood.h"

// CONSTANTS

// ---------------------------------------------------------

//

// ---------------------------------------------------------

//

EXPORT_C CLafShutdownManagerBase* LafShutdown::CreateShutdownManager(

                MShutdownEventObserver& aObserver)

    { // static

    TRACES("LafShutdown::CreateShutdownManager");

    CLafShutdownManagerBase* lafShutdownManager(NULL);

    TInt err(KErrNone);

    TRAP(err, lafShutdownManager = CLafShutdownManager::NewL(aObserver));

    return lafShutdownManager;

    }

// ---------------------------------------------------------

//

// ---------------------------------------------------------

//

EXPORT_C MSaveObserver::TSaveType LafShutdown::SaveFromViewSwitch()

    { // static

    TRACES("LafShutdown::SaveFromViewSwitch");

    return MSaveObserver::ESaveNone;

    }

// ---------------------------------------------------------

//

// ---------------------------------------------------------

//

EXPORT_C MSaveObserver::TSaveType LafShutdown::SaveFromAppSwitch()

    { // static

    TRACES("LafShutdown::SaveFromAppSwitch");

    return MSaveObserver::ESaveNone;

    }

// ======================================================================

// class CLafShutdownManager

// ======================================================================

// ---------------------------------------------------------

//

// ---------------------------------------------------------

//

CLafShutdownManager* CLafShutdownManager::NewL(MShutdownEventObserver& aObserver)

    { // static

    TRACES("LafShutdown::NewL");

    CLafShutdownManager* self = new(ELeave) CLafShutdownManager(aObserver);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// ---------------------------------------------------------

//

// ---------------------------------------------------------

//

CLafShutdownManager::~CLafShutdownManager()

    {

    TRACES("LafShutdown::~CLafShutdownManager");

    delete iOODWarningWatcher;

    delete iOODCriticalWatcher;

    iDiskStatusProperty.Close();

    iMMCStatusProperty.Close();

    if (iDisplayNotesSubscriber)

        {

        iDisplayNotesSubscriber->StopSubscribe();

        }

    iCanDisplayNotesProperty.Close();

    delete iDisplayNotesSubscriber;

    if (iAutolockStatusSubscriber)

        {

        iAutolockStatusSubscriber->StopSubscribe();

        }

    iAutolockStatusProperty.Close();

    delete iAutolockStatusSubscriber;

    if (iMMCWatchSubscriber)

        {

        iMMCWatchSubscriber->StopSubscribe();

        }

    iEnableMMCWatchProperty.Close();

    delete iMMCWatchSubscriber;

    delete iOOMMCWarningWatcher;

    delete iOOMMCCriticalWatcher;

    delete iGlobalQueryActive;

    iWs.Close();

    iFs.Close();

    TRACES("LafShutdown::~CLafShutdownManager: End");

    }

// ---------------------------------------------------------

//

// ---------------------------------------------------------

//

CLafShutdownManager::CLafShutdownManager(MShutdownEventObserver& aObserver)

    : CLafShutdownManagerBase(aObserver)

    {

    TRACES("CLafShutdownManager::CLafShutdownManager");

    }

// ---------------------------------------------------------

//

// ---------------------------------------------------------

//

void CLafShutdownManager::ConstructL()

    {

    TRACES("CLafShutdownManager::ConstructL");

    User::LeaveIfError(iWs.Connect());

    User::LeaveIfError(iFs.Connect());

    RResourceFile resFile;

    TFileName filename(KDriveZ);

    filename.Append(KDC_RESOURCE_FILES_DIR);

    filename.Append(KOOMWatcherResourceFileName);

    BaflUtils::NearestLanguageFile(iFs, filename);

    resFile.OpenL(iFs, filename);

    CleanupClosePushL(resFile);

    TResourceReader theReader;

        HBufC8* thresholds = resFile.AllocReadLC(R_APP_OOD_THRESHOLDS);

        theReader.SetBuffer(thresholds);

        iOODWarningThreshold = theReader.ReadInt32();

        iOODCriticalThreshold = theReader.ReadInt32();

        CleanupStack::PopAndDestroy(thresholds);

        // Global Query

        iGlobalQueryActive = CGlobalQueryActive::NewL(resFile,theReader);

    CleanupStack::PopAndDestroy(); // resFile.Close()

        TVolumeInfo volInfo;

        User::LeaveIfError(iDiskStatusProperty.Attach(KPSUidUikon, KUikFFSFreeLevel));

        User::LeaveIfError(iMMCStatusProperty.Attach (KPSUidUikon, KUikMmcFFSFreeLevel));

        iDiskStatusProperty.Set(GetDiskStatusL(volInfo, EDriveC));

        iMMCStatusProperty.Set(DISK_SPACE_OK);

        User::LeaveIfError(iCanDisplayNotesProperty.Attach (KPSUidUikon, KUikGlobalNotesAllowed));

        iDisplayNotesSubscriber = new (ELeave) CSubscriber(TCallBack(DisplayNotesCallBackL, this),

                                                           iCanDisplayNotesProperty);

        iDisplayNotesSubscriber->SubscribeL();

        User::LeaveIfError(iAutolockStatusProperty.Attach (KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus));

        iAutolockStatusSubscriber = new (ELeave) CSubscriber(TCallBack(AutolockStatusCallBackL, this),

                                                           iAutolockStatusProperty);

        iAutolockStatusProperty.Get(iAutolockStatus);

        iAutolockStatusSubscriber->SubscribeL();

        // Start OOD watchers.

        iOODWarningWatcher = CLafShutdownManager::COutOfDiskWatcher::NewL(*this,

                                                                          iOODWarningThreshold,

                                                                          EDriveC,

                                                                          iFs);

        iOODWarningWatcher->Start();

        iOODCriticalWatcher = CLafShutdownManager::COutOfDiskWatcher::NewL(*this,

                                                                           iOODCriticalThreshold,

                                                                           EDriveC,

                                                                           iFs);

        iOODCriticalWatcher->Start();

        User::LeaveIfError(iEnableMMCWatchProperty.Attach (KPSUidUikon, KUikMMCInserted));

        iMMCWatchSubscriber = new (ELeave) CSubscriber(TCallBack(MMCStatusChanged, this),

                                                       iEnableMMCWatchProperty);

        iMMCWatchSubscriber->SubscribeL();

    TRACES("CLafShutdownManager::ConstructL: End");        

    }

// ---------------------------------------------------------

//

// ---------------------------------------------------------

//

TInt CLafShutdownManager::MMCStatusChanged(TAny* aPtr)

    {

    TRACES("CLafShutdownManager::MMCStatusChanged");

    CLafShutdownManager* self = STATIC_CAST(CLafShutdownManager*,aPtr);

    if (self)

        {

        TInt err(KErrNone);

        TRAP(err, self->HandleMMCCallBackL());

        }

    TRACES("CLafShutdownManager::MMCStatusChanged: End");        

    return KErrNone;

    }

// ---------------------------------------------------------

//

// ---------------------------------------------------------

//

void CLafShutdownManager::HandleMMCCallBackL()

    {

    TRACES("CLafShutdownManager::HandleMMCCallBackL");        

    TInt value = 0;

    iEnableMMCWatchProperty.Get(value);

    if (value)

        {

        if (!iOOMMCWarningWatcher)

            {

            iOOMMCWarningWatcher = COutOfDiskWatcher::NewL(*this,iOODWarningThreshold,EDriveE,iFs);

            }

        if (!iOOMMCCriticalWatcher)

            {

            iOOMMCCriticalWatcher = COutOfDiskWatcher::NewL(*this,

                                                            iOODCriticalThreshold,

                                                            EDriveE,

                                                            iFs);

            }

        iOOMMCWarningWatcher->Start();

        iOOMMCCriticalWatcher->Start();

#ifdef _DEBUG

    RDebug::Print(_L("OOD WATCHER: Started MMC watch"));

#endif

        }

    else

        {

        iMMCStatusProperty.Set( DISK_SPACE_OK );

        if (iOOMMCWarningWatcher)

            {

            iOOMMCWarningWatcher->Cancel();

            }

        if (iOOMMCCriticalWatcher)

            {

            iOOMMCCriticalWatcher->Cancel();

            }

#ifdef _DEBUG

    RDebug::Print(_L("OOD WATCHER: Cancelled MMC watch"));

#endif

        }

    TRACES("CLafShutdownManager::HandleMMCCallBackL: End");        

    }

// ---------------------------------------------------------

//

// ---------------------------------------------------------

//

TInt CLafShutdownManager::DisplayNotesCallBackL(TAny* aPtr)

    {

    TRACES("CLafShutdownManager::DisplayNotesCallBackL");

    CLafShutdownManager* self = STATIC_CAST(CLafShutdownManager*,aPtr);

    if (self)

        self->HandleDisplayNotesCallBackL();

    TRACES("CLafShutdownManager::DisplayNotesCallBackL: End");

    return KErrNone;

    }

// ---------------------------------------------------------

//

// ---------------------------------------------------------

//

void CLafShutdownManager::HandleDisplayNotesCallBackL()

    {

    TRACES("CLafShutdownManager::HandleDisplayNotesCallBackL");

    TInt value(0);

    iCanDisplayNotesProperty.Get(value);

    if (value == 1)

        {

        TRACES("CLafShutdownManager::HandleAutolockStatusCallBack: Can display notes");

        FreeDiskThresholdCrossedL(EDriveC, ETrue);

        iEnableMMCWatchProperty.Get(value);

        if (value)

            {

            TRACES("CLafShutdownManager::HandleAutolockStatusCallBack: Memory card inserted");

            FreeDiskThresholdCrossedL(EDriveE, ETrue);

            }

        }

    TRACES("CLafShutdownManager::HandleDisplayNotesCallBackL: End");

    }

// ---------------------------------------------------------

//

// ---------------------------------------------------------

//

TInt CLafShutdownManager::AutolockStatusCallBackL(TAny* aPtr)

    {

    TRACES("CLafShutdownManager::AutolockStatusCallBackL");

    CLafShutdownManager* self = STATIC_CAST(CLafShutdownManager*,aPtr);

    if (self)

        self->HandleAutolockStatusCallBackL();

    TRACES("CLafShutdownManager::DisplayNotesCallBackL: End");

    return KErrNone;

    }

// ---------------------------------------------------------

//

// ---------------------------------------------------------

//

void CLafShutdownManager::HandleAutolockStatusCallBackL()

    {        

    TRACES("CLafShutdownManager::HandleAutolockStatusCallBackL");

    TInt autolockStatus(0);

    iAutolockStatusProperty.Get(autolockStatus);

    if (autolockStatus == EAutolockOff && 

        iAutolockStatus != EAutolockStatusUninitialized && 

        iAutolockStatus != EAutolockOff )

        {

        TRACES("CLafShutdownManager::HandleAutolockStatusCallBack: Autolock off");

        TInt value(0);

        iCanDisplayNotesProperty.Get(value);

        if (value == 1)

            {

            TRACES("CLafShutdownManager::HandleAutolockStatusCallBack: Can display notes");

            FreeDiskThresholdCrossedL(EDriveC, ETrue, ETrue);

            iEnableMMCWatchProperty.Get(value);

            if (value)

                {

                TRACES("CLafShutdownManager::HandleAutolockStatusCallBack: Memory card inserted");

                FreeDiskThresholdCrossedL(EDriveE, ETrue, ETrue);

                }

            }            

        }

    iAutolockStatus = autolockStatus;

    TRACES("CLafShutdownManager::HandleAutolockStatusCallBackL: End");

    }

// ---------------------------------------------------------

//

// ---------------------------------------------------------

//

void CLafShutdownManager::ReportEventL(MSaveObserver::TSaveType aAction,TBool aPowerOff)

    {

    TRACES("CLafShutdownManager::ReportEventL");

    iObserver.HandleShutdownEventL(aAction,aPowerOff);

    TRACES("CLafShutdownManager::ReportEventL: End");

    }

// ---------------------------------------------------------

//

// ---------------------------------------------------------

//

void CLafShutdownManager::GetShutdownState(TBool& aPowerOff, TBool& aAllSessionsHavePendingRequest)

    {

    TRACES("CLafShutdownManager::GetShutdownState");

    iObserver.GetShutdownState(aPowerOff, aAllSessionsHavePendingRequest);

    TRACES("CLafShutdownManager::GetShutdownState: End");

    }

// ---------------------------------------------------------

//

// ---------------------------------------------------------

//

void CLafShutdownManager::FreeDiskThresholdCrossedL(TDriveNumber aDrive, TBool aIsCallBack, TBool aForcedNote)

    {

    TRACES("CLafShutdownManager::FreeDiskThresholdCrossedL");

    TVolumeInfo volInfo;

    TInt oldDiskStatus;

    TInt oldMmcStatus;

    iDiskStatusProperty.Get(oldDiskStatus);

    iMMCStatusProperty.Get(oldMmcStatus);

    TInt status = GetDiskStatusL(volInfo, aDrive);

    if (aDrive == EDriveC)

        {

        iDiskStatusProperty.Set(status);

        }

    else

        {

        iMMCStatusProperty.Set(status);

        }

#ifdef _DEBUG

    RDebug::Print(_L("OOD WATCHER: Notified on drive %c, Free: 0x%X%X"),aDrive+KAlphaStartPoint,I64HIGH(volInfo.iFree),I64LOW(volInfo.iFree));

#endif

    TInt diskStatus = DISK_SPACE_OK;

    TInt mmcStatus  = DISK_SPACE_OK;

    iDiskStatusProperty.Get(diskStatus);

    iMMCStatusProperty.Get (mmcStatus);

    switch (((aDrive == EDriveC) ? diskStatus : mmcStatus))

        {

    case DISK_SPACE_CRITICAL:

        {

        if (aDrive == EDriveC)

            {

            if (aIsCallBack || oldDiskStatus != DISK_SPACE_CRITICAL)

                {

                ShowGlobalQueryL(CGlobalQueryActive::ECritical, aForcedNote);

                }

            }

        else

            {

            if (aIsCallBack || oldMmcStatus != DISK_SPACE_CRITICAL)

                {

                ShowGlobalQueryL(CGlobalQueryActive::ECriticalMMC, aForcedNote);

                }

            }

#ifdef _DEBUG

    TBuf<KMaxMsgSize> msg;

    msg.AppendFormat( KCriticalMode, aDrive+KAlphaStartPoint );

    RDebug::Print(_L("OOD WATCHER: Entering critical mode on drive %c"),aDrive+KAlphaStartPoint);

    User::InfoPrint(msg);

#endif

        break;

        }

    case DISK_SPACE_WARNING:

        {

        // this is bit awkward but necessary:

        ShowGlobalQueryL( aDrive!=EDriveC ?

            CGlobalQueryActive::EClearNotesMMC :

            CGlobalQueryActive::EClearNotesC, aForcedNote );

        // Display note only if disk is getting more full.

        if (oldDiskStatus != DISK_SPACE_CRITICAL||aDrive != EDriveC)

            {

            if (aDrive == EDriveC)

                {

                if (aIsCallBack || oldDiskStatus != DISK_SPACE_WARNING)

                    {

                    ShowGlobalQueryL(CGlobalQueryActive::EWarning, aForcedNote);

                    }

                }

            else if (oldMmcStatus != DISK_SPACE_CRITICAL)

                {

                if (aIsCallBack || oldMmcStatus != DISK_SPACE_WARNING)

                    {

                    ShowGlobalQueryL(CGlobalQueryActive::EWarningMMC, aForcedNote);

                    }

                }

            }

#ifdef _DEBUG

    TBuf<KMaxMsgSize> msg;

    msg.AppendFormat( KWarningMode, aDrive+KAlphaStartPoint );

    RDebug::Print(_L("OOD WATCHER: Entering warning mode on drive %c"),aDrive+KAlphaStartPoint);

    User::InfoPrint(msg);

#endif

        break;

        }

    case DISK_SPACE_OK:

    default:

        {

#ifdef _DEBUG

        TBuf<KMaxMsgSize> msg;

        msg.AppendFormat( KNormalMode, aDrive+KAlphaStartPoint );

        RDebug::Print(_L("OOD WATCHER: Entering normal   mode on drive %c"),aDrive+KAlphaStartPoint);

        User::InfoPrint(msg);

#endif

        if (aDrive == EDriveC)

            {

            ShowGlobalQueryL(CGlobalQueryActive::EClearNotesC, aForcedNote);

            }

        else

            {

            ShowGlobalQueryL(CGlobalQueryActive::EClearNotesMMC, aForcedNote);

            }

        break;

        }

        } // end of switch

    TRACES("CLafShutdownManager::FreeDiskThresholdCrossedL: End");

    }

// ---------------------------------------------------------

// Use a global query to display the message but make sure that eiksrv is

// there (state must not be initialising (AVKON + UIKON)

// ---------------------------------------------------------

//

void CLafShutdownManager::ShowGlobalQueryL(const CGlobalQueryActive::TMessageType& aMessageType, TBool aForcedNote)

    {

    TRACES("CLafShutdownManager::ShowGlobalQueryL");

    TInt value = 0;

    iCanDisplayNotesProperty.Get(value);

    if (value == 1)

        {

        iGlobalQueryActive->DisplayL(aMessageType, aForcedNote);

        }

    TRACES("CLafShutdownManager::ShowGlobalQueryL: End");

    }

// ---------------------------------------------------------

//

// ---------------------------------------------------------

//

TInt CLafShutdownManager::GetDiskStatusL(TVolumeInfo& aVolInfo, TDriveNumber aDrive)

    {

    TRACES("CLafShutdownManager::GetDiskStatusL");

    // MMC not always present: By returning disk space ok, we won't trigger any alarms.