/*
* Copyright (c) 2007-2008 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:  Compatibility mode utility functions
*
*/


#include <e32base.h>
#include <data_caging_path_literals.hrh>
#include <barsread.h>
#include <bautils.h>
#include <aknappui.h>
#include <coemop.h>
#include <AknScreenMode.h>
#include <AknSgcc.h>
#include <AknCapServerDefs.h>
#include <AknNotifierWrapperDefs.h>
#include <centralrepository.h>
#include <AvkonInternalCRKeys.h>
#include <pslninternalcrkeys.h>

#include <akncompamode.rsg>

#include "akncompautils.h"
#include "akncompakb.h"
#include "akncompabutton.h"
#include "akncompaclearer.h"
#include "akncompaflags.h"

// Class to detect a console application via MopGetObject
class MConsoleApp
    {
public:
    DECLARE_TYPE_ID(0x2001b26a)
    };

// --------------------------------------------------------------------------
// Determine if app requires compa-mode and set to compa screen
// mode if so
// --------------------------------------------------------------------------
TInt AknCompaUtils::SetCompaAppScreenModeL(TBool& aScrModeChanged,
    TBool& aIsConsoleApp, CAknCompaClearer*& aClearer, TInt aAppUiFlags,
    CAknAppUiBase& aAppUi, const CCoeEnv& aCoeEnv, CRepository& aRepository)
    {
    // Change application screen mode before a call to BaseConstructL().
    // This prevents HandleResourceChangeL() to be called before application
    // views have been constructed.

    aScrModeChanged = EFalse;
    aIsConsoleApp = IsConsoleApp(aAppUi);
    aClearer = NULL;
    TInt screenMode = KErrNotFound;

    TInt configFlags = 0;
    aRepository.Get(KAknCompaModeSettings, configFlags);

    // Before CAknAppUi::BaseConstructL(), current screen mode is the
    // same as the application that starts the current application.
    TCompaAppCheckResult result =
        IsCompaModeAppL(aIsConsoleApp, configFlags, aAppUiFlags,
        aCoeEnv);
    if (result == ECompaCheckResultYes)
        {
        screenMode = FindCompaScreenMode();
        if (screenMode != KErrNotFound)
            {
            // Clear whole screen with a skin backround before
            // screen mode changes
            CAknCompaClearer* clearer = CAknCompaClearer::NewLC();

            SetAppScreenModeL(aAppUi, screenMode);
            aScrModeChanged = ETrue;
            CleanupStack::Pop(); // clearer
            aClearer = clearer; // transfer ownership
            }
        }
    else if (InGlobalUiSrv(aAppUiFlags))
        {
        // Current process is a server that may display global
        // notes/notifications. Return compa screen mode but don't
        // set it as current mode.
        screenMode = FindCompaScreenMode();
        }
    return screenMode;
    }

// --------------------------------------------------------------------------
// Find compatibility screen mode
// --------------------------------------------------------------------------
TInt AknCompaUtils::FindCompaScreenMode()
    {
    // Look for screen mode style name QVGACOMPA
    const TInt KNameHash = 0xA786E9F3;
    CAknLayoutConfig::TScreenModeArray scrModeArray =
        CAknSgcClient::LayoutConfig().ScreenModes();
    TInt nModes = scrModeArray.Count();
    TInt mode = KErrNotFound;
    for(TInt i = 0; i < nModes && mode == KErrNotFound; i++)
        {
        if (scrModeArray.At(i).ScreenStyleHash() == KNameHash)
            {
            mode = i;
            }
        }
    return mode;
    }

// --------------------------------------------------------------------------
// Check if process is a server that displays global
// notes/notifications (Eikon server, Avkon notify and cap servers)
// --------------------------------------------------------------------------
TBool AknCompaUtils::IsGlobalUiSrv(TSecureId aSecureId)
    {
    return IsAknCapSrv(aSecureId) ||
        aSecureId.iId == KCommonNotifierAppSrvUid.iUid ||
        IsEikSrv(aSecureId);
    }

// --------------------------------------------------------------------------
// Check if process is eikon server
// --------------------------------------------------------------------------
TBool AknCompaUtils::IsEikSrv(TSecureId aSecureId)
    {
    const TUid KEikSrvUid = {0x10003a4a};
    return aSecureId.iId == KEikSrvUid.iUid;
    }

// --------------------------------------------------------------------------
// Check if process is AknCap server
// --------------------------------------------------------------------------
TBool AknCompaUtils::IsAknCapSrv(TSecureId aSecureId)
    {
    return aSecureId.iId == KAknCapServerUid.iUid;
    }

// --------------------------------------------------------------------------
// Read and create buttons from a resource file
// --------------------------------------------------------------------------
void AknCompaUtils::ReadButtonsL(RPointerArray<CAknCompaButton>& aButtons,
    TInt& aPenButton, CCoeEnv& aCoeEnv)
    {
    RResourceFile resFile;
    AknCompaUtils::OpenResourceFileLC(resFile, aCoeEnv.FsSession());

    // Add localized text resource to CoeEnv
    TInt textResFileOffs = AddTextResourceFileL(aCoeEnv);

    // Read button resources
    HBufC8* buff = resFile.AllocReadLC(R_COMPAMODE_BUTTONS);
    TResourceReader reader;
    reader.SetBuffer(buff);   

    TInt buttonFlags(reader.ReadInt16());
    TInt numButtons(reader.ReadInt16());

    aPenButton = KErrNotFound;
    for(TInt i = 0; i < numButtons; i++)
        {
        // Create button
        CAknCompaButton* button = CAknCompaButton::NewLC(reader);

        if (button->ScanCode() != EStdKeyRightShift)
            {
            // Set flags for button
            button->SetButtonFlags(buttonFlags);
            }
        else
            {
            // Enable long press event for "pen" button
            button->SetButtonFlags(buttonFlags + KAknButtonReportOnLongPress);
            aPenButton = i;
            }

        aButtons.AppendL(button);

        CleanupStack::Pop(); // button
        }  

    aCoeEnv.DeleteResourceFile(textResFileOffs);

    CleanupStack::PopAndDestroy(2); // buff, resFile
    }

// --------------------------------------------------------------------------
// Open compamode resource file
// --------------------------------------------------------------------------
void AknCompaUtils::OpenResourceFileLC(RResourceFile& aResourceFile,
    RFs& aFsSession)
    {
    _LIT(KResourceFileName, "z:akncompamode.rsc");

    TParse parse;
    parse.Set(KResourceFileName, &KDC_RESOURCE_FILES_DIR, NULL);
    TFileName fileName(parse.FullName());
    aResourceFile.OpenL(aFsSession, fileName);

    CleanupClosePushL(aResourceFile);
    aResourceFile.ConfirmSignatureL();
    }

// --------------------------------------------------------------------------
// Add compamode localized text resource file into CoeEnv
// --------------------------------------------------------------------------
TInt AknCompaUtils::AddTextResourceFileL(CCoeEnv& aCoeEnv)
    {
    _LIT(KResourceFileName, "z:akncomparesources.rsc");

    TParse parse;
    parse.Set(KResourceFileName, &KDC_RESOURCE_FILES_DIR, NULL);
    TFileName fileName(parse.FullName());

    BaflUtils::NearestLanguageFile(aCoeEnv.FsSession(), fileName);
    return aCoeEnv.AddResourceFileL(fileName);
    }

// --------------------------------------------------------------------------
// Wait for effects to go into disabled state
// --------------------------------------------------------------------------
void AknCompaUtils::WaitTransEffectsOff(CRepository& aThemesCenRep)
    {
    const TInt KTick = 10000; // 10 ms
    const TInt KMaxWait = 100;

    // There could be a timing issue between CenRep variable change and
    // when tfx server actually disables the effects. Tested following loop
    // with a busy wait and there were no problems. So timing doesn't seem
    // to matter. It would be better of course if tfx server
    // would provide a feedback when effects actually are disabled.
    TInt effects;
    for(TInt i = 0; i < KMaxWait; i++)
        {
        aThemesCenRep.Get(KThemesTransitionEffects, effects);
        if (effects == KAknCompaModeEffectsDisabled)
            {
            return;
            }
        User::After(KTick);
        }
    }

// --------------------------------------------------------------------------
// Panic application
// --------------------------------------------------------------------------
void AknCompaUtils::Panic(TInt aCode)
    {
    _LIT(KCategory, "Compamode");
    User::Panic(KCategory, aCode);
    }

// --------------------------------------------------------------------------
// Scale rectangle to correct size and move it if necessary.
// --------------------------------------------------------------------------
void AknCompaUtils::ScaleRect(TRect& aRect, TInt aMoveX, TInt aMoveY)
    {    
    aRect.iTl.iY = (aRect.iTl.iY * 2);
    aRect.iBr.iY = (aRect.iBr.iY * 2);

    TInt bX = aRect.iBr.iX;
    TInt tmp = bX / 2;
    aRect.iBr.iX = ((bX * 2) - tmp);

    TInt tX = aRect.iTl.iX;
    tmp = tX / 2;
    aRect.iTl.iX = ((tX * 2) - tmp);
    
    if(aMoveX != 0 || aMoveY != 0)
        {
        aRect.Move(aMoveX, aMoveY);
        }
    }

// --------------------------------------------------------------------------
// Set application screen mode
// --------------------------------------------------------------------------
void AknCompaUtils::SetAppScreenModeL(CAknAppUiBase& aAppUi, TInt aMode)
    {
    TAknScreenModes scrModes = TAknScreenModes::GetModes();
    TAknScreenModes::SetAppUiScreenModeL(&aAppUi, scrModes[aMode]);
    }

// --------------------------------------------------------------------------
// Read a vector of integers from a resource file
// --------------------------------------------------------------------------
void AknCompaUtils::ReadIntegerResourceL(RArray<TInt>& aArray,
        const RResourceFile& aResourceFile, TInt aResId)
    {
    HBufC8* buff = aResourceFile.AllocReadLC(aResId);

    TResourceReader resReader;
    resReader.SetBuffer(buff);

    aArray.Reset();
    TInt cnt = resReader.ReadInt16();
    while(cnt--)
        {
        aArray.AppendL(resReader.ReadInt32());
        }
    CleanupStack::PopAndDestroy(); // buff
    }

// --------------------------------------------------------------------------
// Check if application requires a compatibility mode
// --------------------------------------------------------------------------
AknCompaUtils::TCompaAppCheckResult AknCompaUtils::IsCompaModeAppL(
    TBool aIsConsoleApp, TInt aConfigFlags, TInt aAppUiFlags,
    const CCoeEnv& aCoeEnv)
    {
    if ((aAppUiFlags & CAknAppUiBase::EAknTouchCompatible) ||
        (aAppUiFlags & CEikAppUi::ENoScreenFurniture && !aIsConsoleApp) ||
        (aConfigFlags & KAknCompaSettingEnaApps) == 0)
        {
        return ECompaCheckResultNo;
        }

    RResourceFile resFile;
    OpenResourceFileLC(resFile, aCoeEnv.FsSession());

    RProcess process;
    TSecureId secureId = process.SecureId();

    TCompaAppCheckResult appCheckResult = ECompaCheckResultUndefinite;

    RArray<TInt> array;
    CleanupClosePushL(array);
    // Application is not put into compa-mode if it is in non compa-mode list
    ReadIntegerResourceL(array, resFile, R_COMPAMODE_NON_COMPA_APPS);
    if (array.Find(secureId.iId) != KErrNotFound)
        {
        appCheckResult = ECompaCheckResultNo;
        }
    if (appCheckResult == ECompaCheckResultUndefinite)
        {
        // Application is put into compa-mode if it is in compa-mode list
        ReadIntegerResourceL(array, resFile, R_COMPAMODE_COMPA_APPS);
        if (array.Find(secureId.iId) != KErrNotFound)
            {
            appCheckResult = ECompaCheckResultYes;
            }
        }

    if (appCheckResult == ECompaCheckResultUndefinite)
        {
        // By default, all applications included in a rom image are
        // not put into compa-mode. Unless overriden by a flag or if
        // the app. is a console application.
        TFileName fileName = process.FileName();
        _LIT(KRomDrive,"z:");
        if (fileName.FindF(KRomDrive) == 0)
            {
            appCheckResult =
                aConfigFlags & KAknCompaSettingEnaRomApps || aIsConsoleApp ?
                ECompaCheckResultYes:ECompaCheckResultNo;
            }
        }

    if (appCheckResult == ECompaCheckResultUndefinite)
        {
        // Application is not executing from rom drive. Go to compa-mode.
        appCheckResult = ECompaCheckResultYes;
        }

    CleanupStack::PopAndDestroy(2); // resFile, array
    return appCheckResult;
    }

// --------------------------------------------------------------------------
// Check if current process is a server that displays global
// notes/notifications (Eikon server, Avkon notify and cap servers)
// --------------------------------------------------------------------------
TBool AknCompaUtils::InGlobalUiSrv(TInt aAppUiFlags)
    {
    // Optimization: don't check secure id if ENoScreenFurniture
    // flag not set.
    TBool inGlobalUiSrv = EFalse;
    if (aAppUiFlags & CEikAppUi::ENoScreenFurniture)
        {
        RProcess process;
        inGlobalUiSrv = IsGlobalUiSrv(process.SecureId());
        }
    return inGlobalUiSrv;
    }

// --------------------------------------------------------------------------
// Check if application is console application
// --------------------------------------------------------------------------
TBool AknCompaUtils::IsConsoleApp(CAknAppUiBase& aAppUi)
    {
    MConsoleApp* consoleApp;
    aAppUi.MopGetObjectNoChaining(consoleApp);
    return consoleApp != NULL;
    }