/*

* Copyright (c) 2002-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:  Keymappings etc. customized for Series 60.

*

*/

// INCLUDE FILES

#include <eikenv.h>

#include <eikappui.h>

#include <coecntrl.h>

#include <coeccntx.h>

#include <coecobs.h>

#include <bassnd.h>

#include <coesndpy.h>

#include <hal.h>

#include <lcdui.rsg>

#include <barsread.h>

#include <aknappui.h>

#include <aknsoundsystem.h>

#include <avkon.hrh> // for Alert Sounds

#include <hwrmlight.h> // backlight

#include <hwrmvibra.h> // vibra

// for layout data in BestImageSize function

#include <aknlayoutscalable_avkon.cdl.h> // for layout data

// API used Color function - mapping Java color type to Avkon-skinned color

#include <AknsUtils.h>

// CMIDKeyDecoder API in funcions related to keys

#include "CMIDKeyDecoder.h"

#include "CMIDUtils.h"

#include "CMIDUIManager.h"

#ifdef RD_SCALABLE_UI_V2

#include <AknUtils.h>

#endif // RD_SCALABLE_UI_V2

#include <e32property.h>

#include <AvkonInternalCRKeys.h>

#include <centralrepository.h>

#include <AknFepInternalCRKeys.h>

#ifdef RD_INTELLIGENT_TEXT_INPUT

#include <PtiEngine.h>

#endif //RD_INTELLIGENT_TEXT_INPUT

// macros definitions for outputing logs

#include <j2me/jdebug.h>

// LOCAL CONSTANTS AND MACROS

/**

 *Info messages for Wins Flashbacklight and Vibrate

 *For development purpose only, not localized

 */

#if defined(__WINS__)

_LIT(KMsgFlashBacklight,"Flash count:");

_LIT(KMsgVibrate,"Vibrating for ");

#endif

// line feed, carriage return, line separator, paragraph separator

_LIT(KSeparators, "\x000a\x000d\x2028\x2029");

// keyboard types

_LIT(KKeyboardNone,            "None");

_LIT(KKeyboardPhoneKeypad,     "PhoneKeypad");

_LIT(KKeyboardFullKeyboard,    "FullKeyboard");

_LIT(KKeyboardLimited4x10,     "LimitedKeyboard4x10");

_LIT(KKeyboardLimited3x11,     "LimitedKeyboard3x11");

_LIT(KKeyboardHalfKeyboard,    "HalfKeyboard");

_LIT(KKeyboardCustom,          "Custom");

_LIT(KKeyboardUnknown,         "Unknown");

// constants for color bits shifting (for creation of 0x00RRGGBB color value)

const TInt KRedBitsShift = 16;

const TInt KGreenBitsShift = 8;

const TInt KBlueBitsShift = 0;

// constant for result size used by PTI Engine for mapping keys, this value is

// based e.g. on PtiXt9CandidateList implementation

#ifdef RD_INTELLIGENT_TEXT_INPUT

const TInt KPTIEngineResultSize = 32;

#endif // RD_INTELLIGENT_TEXT_INPUT

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

//

//

// class MMIDUtils

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

//

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

//

MMIDUtils* CMIDUtils::NewL(MMIDEnv& aEnv, CMIDUIManager* aUIManager)

{

    CMIDUtils* utils = new(ELeave) CMIDUtils(aEnv, aUIManager);

    CleanupStack::PushL(utils);

    utils->ConstructL();

    CleanupStack::Pop(utils);

    return utils;

}

/**

 * CAknKeySoundSystem is use to play sounds,

 * emulator implementation, which does not support

 * this feature.

 */

#if defined(__WINSCW__)

TBool CMIDUtils::PlaySound(TInt /*aSoundType*/)

{

    return EFalse;

}

#else // __WINSCW__

/**

 * CAknKeySoundSystem is use to play sounds

 */

TBool CMIDUtils::PlaySound(TInt aSoundType)

{

    TInt toneType = -1;

    switch (aSoundType)

    {

    case MMIDAlert::EAlarm:

        toneType = (TInt) EAvkonSIDInformationTone;

        break;

    case MMIDAlert::EConfirmation:

        toneType = (TInt) EAvkonSIDConfirmationTone;

        break;

    case MMIDAlert::EError:

        toneType = (TInt) EAvkonSIDErrorTone;

        break;

    case MMIDAlert::EWarning:

        toneType = (TInt) EAvkonSIDWarningTone;

        break;

    case MMIDAlert::EInfo:

        toneType = (TInt) EAvkonSIDInformationTone;

        break;

    case MMIDAlert::ENone: // No Alerttype set

    default:

        toneType = (TInt) EAvkonSIDNoSound;

        break;

    }

    CAknKeySoundSystem* soundSystem = iAvkonAppUi->KeySounds();

    if (toneType  != -1)

    {

        soundSystem->PlaySound(toneType);

    }

    return ETrue;

}

#endif // __WINSCW__

/**

 * Determines if a key code should be sent to Canvas.keyPressed(int keyCode)

 */

TBool CMIDUtils::IsJavaKey(TInt aScanCode)

{

    ASSERT(iKeyDecoder);

    return iKeyDecoder->IsJavaKey(aScanCode);

}

/**

 * Maps EPOC scan code to negative key code required by MIDP spec.

 * For keys that have no corresponding Unicode character,

 * the implementation must use negative values.

 */

TInt CMIDUtils::MapNonUnicodeKey(TUint aScanCode)

{

    ASSERT(iKeyDecoder);

    return iKeyDecoder->MapNonUnicodeKey(aScanCode);

}

/**

 * Gets a key code that corresponds to the specified game action on the device.

 *

 * Returns zero if aGameAction is not a valid game action.

 *

 * @see CMIDKeyDecoder::GetKeyCode()

 */

TInt CMIDUtils::GetKeyCode(TInt aGameAction)

{

    ASSERT(iKeyDecoder);

    return iKeyDecoder->GetKeyCode(aGameAction);

}

/**

 * Gets an informative key string for a key. The string returned will resemble the text

 * physically printed on the key. This string is suitable for displaying to the user.

 * For example, on a device with function keys F1 through F4, calling this method on

 * the keyCode for the F1 key will return the string "F1". A typical use for this string

 * will be to compose help text such as "Press F1 to proceed."

 *

 * This method will return a non-empty string for every valid key code.

 * @see CMIDKeyDecoder::GetKeyName()

 */

void CMIDUtils::GetKeyName(TDes& aText,TInt aKeyCode)

{

    ASSERT(iKeyDecoder);

    return iKeyDecoder->GetKeyName(aText, aKeyCode);

}

/**

* Gets the game action associated with the given key code of the device.

*

* Return zero if no game action is associated with this key code.

*

* @see CMIDKeyDecoder::GameAction()

*/

TInt CMIDUtils::GetGameAction(TInt aKeyCode)

{

    ASSERT(iKeyDecoder);

    return iKeyDecoder->GameAction(aKeyCode);

}

void CMIDUtils::MapJavaToETextChars(HBufC* aText,TBool aSupportLineBreaks)

{

    TPtr text = aText->Des();

    TInt pos = text.Length();

    for (; pos>0;)

    {

        TText& ch=(text)[--pos];

        switch (ch)

        {

        case '\n':

            //From 3.0m onwards: If line breaks are not supported, returns ESpace instead of ETabCharacter

            ch = (TText)(aSupportLineBreaks ? CEditableText::EParagraphDelimiter : CEditableText::ESpace);

            break;

        case '\f':

            //From 3.0m onwards: If line breaks are not supported, returns ESpace instead of ETabCharacter

            ch = (TText)(aSupportLineBreaks ? CEditableText::EPageBreak : CEditableText::ESpace);

            break;

        case '\t':

            ch = CEditableText::ETabCharacter;

            break;

        }

    }

}

void CMIDUtils::MapETextToJavaChars(HBufC* aText)

{

    if (!aText)

        return;

    TPtr text = aText->Des();

    TInt pos = text.Length();

    for (; pos>0;)

    {

        TText& ch=(text)[--pos];

        switch (ch)

        {

        case CEditableText::EParagraphDelimiter:

            ch = '\n';

            break;

        case CEditableText::EPageBreak:

            ch = '\f';

            break;

        case CEditableText::ETabCharacter:

            ch = '\t';

            break;

        }

    }

}

/**

 * Looks for first character which indicates text direction such as Arabic character meaning right-to-left.

 * (similar code can be found in lcdgr)

 */

TBool CMIDUtils::IsStronglyRightToLeft(HBufC* aText)

{

    TPtr text = aText->Des();

    TInt pos;

    TInt len = text.Length();

    for (pos = 0; pos < len; pos++)

    {

        TChar ch((text)[pos]);

        TChar::TCharInfo info;

        ch.GetInfo(info);

        switch (info.iBdCategory)

        {

        case TChar::ERightToLeft:

        case TChar::ERightToLeftArabic:

        case TChar::ERightToLeftEmbedding:

        case TChar::ERightToLeftOverride:

        case TChar::EArabicNumber:

            return true;

        case TChar::ELeftToRight:

            return false;

        default:

            ;

        }

    }

    return false;

}

/**

 * Reverses order of contents of array.

 */

void CMIDUtils::Reverse(HBufC* aText)

{

    TPtr text = aText->Des();

    TInt s = 0;

    TInt e = text.Length() - 1;

    while (s < e)

    {

        TText t = text[s];

        text[s] = text[e];

        text[e] = t;

        ++s;

        --e;

    }

}

/** Some key events should be ignored, for example when opening or closing a device. */

TBool CMIDUtils::IgnoreKeyEvent(TUint aKeyEvent)

{

    return (aKeyEvent == EKeyGripOpen)   ||

           (aKeyEvent == EKeyGripClose)  ||

           (aKeyEvent == EKeyTwistOpen)  ||

           (aKeyEvent == EKeyTwistClose) ||

           (aKeyEvent == EKeyFlipOpen)   ||

           (aKeyEvent == EKeyFlipClose)  ||

           (aKeyEvent == EKeyQwertyOn)   ||

           (aKeyEvent == EKeyQwertyOff);

}

/** Creates an identical copy of the given bitmap. This utility function is used instead

of MMIDBitmapImage::CreateColorBitmapL() because this latter looses transparency information

when the display mode is EColor16MA (it blits on a white bitmap...).

*/

CFbsBitmap* CMIDUtils::CopyBitmapL(CFbsBitmap* aSource)

{

    CFbsBitmap* target = NULL;

    if (aSource)

    {

        target = new(ELeave) CFbsBitmap();

        target->Create(aSource->SizeInPixels(), aSource->DisplayMode());

        //if there is no memory for new bitmap, target has null adress pointer

        //and calling Mem::Copy causes a panic.

        //So if target->DataAdress() returns null pointer,

        //function leave with KErrNoMemory -> java.lang.OutOfMemoryError is thrown

        if (!target->DataAddress())

        {

            User::Leave(KErrNoMemory);

        }

        TInt nBytes = aSource->SizeInPixels().iHeight *

                      aSource->ScanLineLength(aSource->SizeInPixels().iWidth, aSource->DisplayMode());

        target->LockHeap();

        Mem::Copy(target->DataAddress(), aSource->DataAddress(), nBytes);

        target->UnlockHeap();

    }

    return target;

}

TBool CMIDUtils::IsLineSeparator(const TText aChar)

{

    return (KSeparators().Locate(aChar) != KErrNotFound);

}

TBool CMIDUtils::HasPointerEvents()

{

    return (HasPen() || HasMouse());

}

TBool CMIDUtils::HasPointerMotionEvents()

{

    return (HasPen() || HasMouse());

}

TBool CMIDUtils::HasRepeatEvents()

{

    return ETrue;

}

TBool CMIDUtils::HasPen()

{

#ifdef RD_SCALABLE_UI_V2

    return AknLayoutUtils::PenEnabled();

#else

    TInt hasPen = EFalse;

    return hasPen;

#endif // RD_SCALABLE_UI_V2

}

TBool CMIDUtils::HasMouse()

{

    TInt hasMouse = EFalse;

    return hasMouse;

}

TSize CMIDUtils::BestImageSize(TImageType aImageType) const

{

    TAknWindowLineLayout lineLayout;

    switch (aImageType)

    {

    case EListImage:

        lineLayout = AknLayoutScalable_Avkon::list_single_large_graphic_pane_g1(0).LayoutLine();

        break;

    case EChoiceImage:

        lineLayout = AknLayoutScalable_Avkon::list_single_2graphic_pane_g1_cp4().LayoutLine();

        break;

    case EAlertImage:

        lineLayout = AknLayoutScalable_Avkon::popup_midp_note_alarm_window_g1(0).LayoutLine();

        break;

    default:

        return TSize();

    }

    return TSize(lineLayout.iW, lineLayout.iH);

}

/**

 * Requests a flashing effect for the device's backlight

 * Returns false as the emulator does not support this feature.

 */

#if defined(__WINSCW__)

TBool CMIDUtils::FlashBacklightL(const TTimeIntervalMicroSeconds32& /*aDuration*/)

{

    return EFalse;

}

#else // __WINSCW__

/**

 * Requests a flashing effect for the device's backlight

 * Must return true if the backlight can be controlled by the application

 */

TBool CMIDUtils::FlashBacklightL(const TTimeIntervalMicroSeconds32& aDuration)

{

    if (!iLight)

    {

        iLight = CHWRMLight::NewL();

    }

    // SupportedTargets() returns the supported targets as a bitmap.

    if ((iLight->SupportedTargets() &

            CHWRMLight::EPrimaryDisplayAndKeyboard) !=

            CHWRMLight::EPrimaryDisplayAndKeyboard)

    {

        return EFalse;

    }

    TInt duration = aDuration.Int() / 1000;

    if (!duration)

    {

        // 0 would be infinite

        duration = 1;

    }

    iLight->LightBlinkL(CHWRMLight::EPrimaryDisplayAndKeyboard,

                        duration);

    return ETrue;

}

#endif // __WINSCW__

/**

 * There is no API for vibrate. Left to be customised according to each device

 * Printing InfoMsg for the user for the duration given to vibrate

 * Returns false in emulator builds as it does not support this feature.

 */

#if defined(__WINSCW__)

TBool CMIDUtils::Vibrate(const TTimeIntervalMicroSeconds32& /*aDuration*/)

{

    return EFalse;

}

#else // __WINSCW__

/**

 * There is no API for vibrate. Left to be customised according to each device

 * Printing InfoMsg for the user for the duration given to vibrate

 * Must return true if the vibrator can be controlled by the application

 */

TBool CMIDUtils::Vibrate(const TTimeIntervalMicroSeconds32& aDuration)

{

    TInt duration = aDuration.Int() / 1000; // convert micro to milli

    // as this method can't leave, and only returns a boolean, we must

    // return false if anything goes wrong.

    if (!iVibra)

    {

        TRAPD(err1, iVibra = CHWRMVibra::NewL());

        if (err1 != KErrNone)

        {

            return EFalse;

        }

    }

    TInt err2 = KErrNone;

    if (duration)

    {

        TRAP(err2, iVibra->StartVibraL(duration));

    }

    else

    {

        TRAP(err2, iVibra->StopVibraL());

    }

    if (err2 == KErrNone)

    {

        return ETrue;

    }

    else

    {

        return EFalse;

    }