/*

* Copyright (c) 2002-2007 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:  EikSrv keysound server.

*

*/

#include <e32svr.h>

#include <coemain.h>

#include <barsread.h>

#include <eiksrvui.rsg>

#include <s32mem.h>

#include "eikkeysoundserver.h"

#include <aknanimdllstd.h>

#include "AknEikAudioToneObserver.h"

#include <avkon.hrh>

#include <centralrepository.h>

#include <ProfileEngineSDKCRKeys.h>     // KProEngActiveKeypadVolume

#include <ataudioeventapi.h>

#include <e32uid.h>

// Declare thread entry point

GLDEF_C TInt KeySoundServerThreadStartFunction(TAny* aPtr);

_LIT(KKeySoundServerThreadName,"KeySoundServerThread");

_LIT(KKeySoundServerSemaphoreName,"KeySoundServerSemaphore");

_LIT(KKeySoundServerDll,"AtSoundServerClient.dll");

const TInt KKeySoundServerStackSize     = 1024*4; // 4K

const TInt KAknSoundInfoMapGranularity  = 16;

const TInt KKeyClickPreference          = 0x00140001;

const TInt KKeySoundServerBufExpandSize = 1024*1; // 1K

const TInt KKeysoundServerDllUid        = 0x10281C86;

typedef CATAudioEventAPI* (*PFUNC)(MATEventCompleteObserver& aCient);

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

// CAknAnimKeySoundControl implementation.

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

CAknAnimKeySoundControl::CAknAnimKeySoundControl()

    {

    }

void CAknAnimKeySoundControl::ConstructL(RWindowGroup* aParent)

    {

    CreateWindowL(aParent);

    SetExtent(TPoint(0,0),TSize(0,0));

    Window().SetShadowDisabled(ETrue);

    Window().Activate();

    }

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

// RAknAnimKeySound implementation.

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

RAknAnimKeySound::RAknAnimKeySound(RAnimDll& aAnimDll)

:RAnim(aAnimDll)

    {

    }

void RAknAnimKeySound::ConstructL(RWindowGroup* aParent)

    {

    iKeySoundControl = new(ELeave)CAknAnimKeySoundControl();

    iKeySoundControl->ConstructL(aParent);

    RAnim::Construct(*(iKeySoundControl->DrawableWindow()), EAnimKeySound, TPtrC8());

    }

void RAknAnimKeySound::Close()

    {

    delete iKeySoundControl;

    iKeySoundControl = NULL;

    }

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

// CEikKeySoundServer implementation.

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

TInt CEikKeySoundServer::LaunchServer(TThreadId& aThreadId)

    {

    // First, check that ther server isn't already running.

    TFindServer findServer(__KEYSOUND_SERVER_NAME);

    TFullName name;

    if (findServer.Next(name) == KErrNone)

        {

        return KErrAlreadyExists;

        }

    // Create a semaphore.

    RSemaphore globStartSignal;

    TInt err = globStartSignal.CreateGlobal(KKeySoundServerSemaphoreName, EOwnerProcess);

    if (err != KErrNone)

        {

        err=globStartSignal.OpenGlobal(KKeySoundServerSemaphoreName, EOwnerProcess);

        if (err != KErrNone)

            {

            return err;

            }

        }

    RThread keySoundServerThread;

    err = keySoundServerThread.Create(

        KKeySoundServerThreadName,

        KeySoundServerThreadStartFunction,

        KKeySoundServerStackSize,

        NULL, // uses caller thread's heap

        NULL,

        EOwnerThread);

    aThreadId = keySoundServerThread.Id();

    keySoundServerThread.Resume();

    keySoundServerThread.Close();

    globStartSignal.Wait();

    return err;

    }

// Construct the server object

LOCAL_C void DoKeySoundServerThreadStartFunctionL()

    {

    CEikKeySoundServer::NewLC();

    RSemaphore globStartSignal;

    CleanupClosePushL(globStartSignal);

    User::LeaveIfError(globStartSignal.OpenGlobal(KKeySoundServerSemaphoreName));

    globStartSignal.Signal();

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

    CActiveScheduler::Start();

    CleanupStack::PopAndDestroy(); // keySoundServer

    }

// Entry point into the new thread

GLDEF_C TInt KeySoundServerThreadStartFunction(TAny* /*aPtr*/)

    {

    __UHEAP_MARK;

    RThread thread;

    TInt err = User::RenameThread(KKeySoundServerThreadName);

    if (err == KErrNone)

        {

        thread.SetPriority(EPriorityAbsoluteForeground);

        thread.Close();

        // Set up scheduler and cleanup stack for this thread

        CActiveScheduler* scheduler = new CActiveScheduler;

        if (!scheduler)

            {

            return KErrNoMemory;

            }

        CActiveScheduler::Install(scheduler);

        CTrapCleanup* trapCleanup = CTrapCleanup::New();

        if (!trapCleanup)

            {

            return KErrNoMemory;

            }

        // Set initial trap harness, and construct server object

        TRAP(err,DoKeySoundServerThreadStartFunctionL());

        delete CActiveScheduler::Current();

        delete trapCleanup;

        }

    __UHEAP_MARKEND;

    return err;

    }

CEikKeySoundServer* CEikKeySoundServer::NewLC()

    {

    CEikKeySoundServer* self = new(ELeave)CEikKeySoundServer();

    CleanupStack::PushL(self);

    self->ConstructL();

    self->StartL(__KEYSOUND_SERVER_NAME);

    return self;

    }

CEikKeySoundServer::CEikKeySoundServer()

:CServer2(EActivePriorityDefault),

iDisabledScanCode( -1 )

    {

    // construct all system SID objects

    }

void CEikKeySoundServer::ConstructL()

    {

    iInit = EFalse;

    iSidList = new(ELeave)CArrayFixFlat<TAknSoundID>(KAknSoundInfoMapGranularity);

    iSoundList = new(ELeave)CArrayPtrFlat<CEikSoundInfo>(KAknSoundInfoMapGranularity);

    // Default to loudest volume

    iKeypadVolume = CEikSoundInfo::EKeypadVolumeLoud;

    TRAPD(err, iProfilesRepository = CRepository::NewL(KCRUidProfileEngine));

    if (err == KErrNone)

        {

        iProfilesNotifyHandler = CCenRepNotifyHandler::NewL(*this,

                                                            *iProfilesRepository,

                                                            CCenRepNotifyHandler::EIntKey,

                                                            KProEngActiveKeypadVolume);

        iWarningToneEnableHandler = CCenRepNotifyHandler::NewL( *this,

                                                                *iProfilesRepository,

                                                                CCenRepNotifyHandler::EIntKey,

                                                                KProEngActiveWarningTones);

        iProfilesNotifyHandler->StartListeningL();

        iWarningToneEnableHandler->StartListeningL();

        iProfilesRepository->Get(KProEngActiveKeypadVolume, (TInt&)iKeypadVolume);

        iProfilesRepository->Get(KProEngActiveWarningTones, iWarningToneEnabled);

        }

    iATSoundServerAPI = NULL;

    RLibrary lib;

    TUidType uidType( KDynamicLibraryUid, KSharedLibraryUid, TUid::Uid( KKeysoundServerDllUid ) );

    if(lib.Load(KKeySoundServerDll, uidType) == KErrNone)

        {

        PFUNC func = (PFUNC)lib.Lookup(1); /* NewL */

        TRAPD(error, iATSoundServerAPI = (CATAudioEventAPI*) func(*this));

        if( error )

            {

            iATSoundServerAPI = NULL;

            }

        }

#ifdef _DEBUG

    RDebug::Print(_L("cenrep CEikKeySoundServer::ConstructL %d"), (TInt)iKeypadVolume);

#endif

    }

CEikKeySoundServer::~CEikKeySoundServer()

    {

    if (iProfilesNotifyHandler)

        {

        iProfilesNotifyHandler->StopListening();

        delete iProfilesNotifyHandler;

        }

    if (iWarningToneEnableHandler)

        {

        iWarningToneEnableHandler->StopListening();

        delete iWarningToneEnableHandler;

        }

    delete iProfilesRepository;

    delete iDefaultSoundMap;

    delete iSoundList;

    delete iSidList;

    delete iATSoundServerAPI;

    }

CSession2* CEikKeySoundServer::NewSessionL(const TVersion& aVersion,

    const RMessage2& /*aMessage*/) const

    {

    TVersion ver(KKeySoundServMajorVN, KKeySoundServMinorVN, KKeySoundServBuildVN);

    if (!User::QueryVersionSupported(ver, aVersion))

        {

        User::Leave(KErrNotSupported);

        }

    return CEikKeySoundSession::NewL(CONST_CAST(CEikKeySoundServer*,this));

    }

void CEikKeySoundServer::InitL(const RMessage2& aMessage)

    {

    TPckg<TInt> pckgBuf(iInit);

    aMessage.WriteL(0, pckgBuf);

    iInit = ETrue;

    }

void CEikKeySoundServer::Complete(TInt aError, TAudioThemeEvent aEvent)

	{

	if( aError != KErrNone && aError != ESilencedError 

	    && aError != EEventCurrentlyPlaying )

		{

		PlaySid(aEvent, ETrue);

		}

	}

void CEikKeySoundServer::PlaySid(TInt aSid, TBool aPlaySelf)

    {

    if (aSid == EAvkonSIDWarningTone && iWarningToneEnabled == 0)

        {

        // Don't play warning tone, when the warning tone is disabled in setting.

        return;

        }

    TInt error(KErrNone);

// special cases when the sound is always played in the key sound server

    if (aSid <= 1000 || aSid == EAvkonSIDStandardKeyClick ||

        aSid == EAvkonSIDReadialCompleteTone || aSid == EAvkonSIDPowerOffTone ||

        aSid == EAvkonSIDPowerOnTone || aSid == EAvkonSIDVoiceRecordingTone ||

        aSid == EAvkonSIDVoiceRecordingStartTone ||

        aSid == EAvkonSIDVoiceRecordingStopTone || aSid == EAvkonSIDNetBusy ||

        aSid == EAvkonSIDNetCallWaiting || aSid == EAvkonSIDNetReorder ||

        aSid == EAvkonSIDNetCongestion || aSid == EAvkonSIDNetSpecialInformation ||

        aSid == EAvkonSIDNetRadioNotAvailable || aSid == EAvkonSIDIHFActive ||

        aSid == EAvkonSIDRadioPathAcknowledge || aSid == EAvkonSIDDial ||

        aSid == EAvkonSIDRingGoing || aSid == EAvkonSIDLocationRequest ||

        aSid == EAvkonSIDInformationTone || aSid == EAvkonSIDConfirmationTone ) 

        {

        aPlaySelf = ETrue;

        }

    if(!aPlaySelf && iATSoundServerAPI)

        {

        TAudioThemeEvent event = static_cast<TAudioThemeEvent>(aSid);

        TRAP(error, iATSoundServerAPI->SendAudioEventL(event, EFalse));

        }

    if (aPlaySelf || error)

        {

        TKeyArrayFix sidKey(_FOFF(TAknSoundID, iSid), ECmpTUint);

        TAknSoundID soundId;

        soundId.iSid = aSid;

        TInt index;

        if (iSidList->FindIsq(soundId, sidKey, index) == 0)

            {

            CEikSoundInfo* info = ((*iSidList)[index]).iSoundInfo;

            if (info && info->Volume() != CEikSoundInfo::EKeypadVolumeOff )

                {

                TRAP_IGNORE(info->PlayL());

#if defined(EIKKSS_DEBUGSOUNDID)

                RDebug::Print(_L("Playing SoundID:%d"), aSid & 0xffff);

#endif

                LOGTEXT2(_L(" PlaySid(): Index:%d, pointer:%d"), index, (TInt)info);

                }

            }

        }

    }

void CEikKeySoundServer::StopSid(TInt aSid)

    {

    TKeyArrayFix sidKey(_FOFF(TAknSoundID, iSid), ECmpTUint);

    TAknSoundID soundId;

    soundId.iSid = aSid;

    TInt index;

    if (iSidList->FindIsq(soundId, sidKey, index) == 0)

        {

        CEikSoundInfo* info = ((*iSidList)[index]).iSoundInfo;

        if (info)

            {

            info->Stop();

#if defined(EIKKSS_DEBUGSOUNDID)

            RDebug::Print(_L("Force Stopping SoundID:%d"), aSid & 0xffff);

#endif

            }

        }

    }

void CEikKeySoundServer::SetVolumeForPreferenceType(TInt aPreference,

    CEikSoundInfo::TVolumeSetting aVolume)

    {

    TInt count = iSoundList->Count();

    for (TInt ii = 0; ii < count; ii++)

        {

        CEikSoundInfo* info = (*iSoundList)[ii];

        if (info)

            {

            if (info->Preference() == aPreference)

                {

                info->SetVolume(aVolume);

                }

            }

        }

    }

void CEikKeySoundServer::SetDisabledScanCode( TInt aScanCode )

	{

	iDisabledScanCode = aScanCode;

	}

TInt CEikKeySoundServer::DisabledScanCode()

	{

	return iDisabledScanCode;

	}

void CEikKeySoundServer::HandleNotifyInt(TUint32 aId, TInt aNewValue)

    {

    if (aId == KProEngActiveKeypadVolume)

        {

        iKeypadVolume = (CEikSoundInfo::TVolumeSetting)aNewValue;

        SetVolumeForPreferenceType( KKeyClickPreference, iKeypadVolume );

        }

    else if (aId == KProEngActiveWarningTones)

        {

        iWarningToneEnabled = aNewValue;

        }

    }

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

// CEikKeySoundSession implementation.

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

CEikKeySoundSession* CEikKeySoundSession::NewL(CEikKeySoundServer* aServer)

    {

    CEikKeySoundSession* self = new(ELeave)CEikKeySoundSession(aServer);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

CEikKeySoundSession::CEikKeySoundSession(CEikKeySoundServer* aServer)

:CSession2(), iServer(aServer)

    {

    }

CEikKeySoundSession::~CEikKeySoundSession()

    {

    RemoveSids(iClientUid);

    if (iHasLockedContext)

        {

        iServer->SetContextLocked(EFalse);

        }

    if (iOwnsDefaultSounds)

        {

        RemoveSids(0);

        iServer->iInit = EFalse;

        }

    if (iSoundStack)

        {

        if (iSoundStack->Count() > 0)

            {

            // Bottom entry is owned by server, so remove before deleting other sound maps

            iSoundStack->Delete(0);

            iSoundStack->ResetAndDestroy();

            }

        // Make sure server isn't using this soundstack

        if (iServer->iCurrentSoundStack == iSoundStack)

            {

            iServer->iCurrentSoundStack = NULL;

            }

        delete iSoundStack;

        }

    }

void CEikKeySoundSession::ConstructL()

    {

    iSoundStack = CEikKeySoundStack::NewL();

    if (iServer->iDefaultSoundMap)

        {

        iSoundStack->AppendL(iServer->iDefaultSoundMap);

        }

    }

void CEikKeySoundSession::ServiceL(const RMessage2& aMessage)

    {

    if (aMessage.Function() == EKeySoundServerPlayKey)

        {

        TInt scancode = aMessage.Int0() & 0xff;

        TBool repeat = aMessage.Int1();

        aMessage.Complete(KErrNone);

        TInt sid;

        if (iServer->iCurrentSoundStack)

            {

            if (iServer->iCurrentSoundStack->Find(scancode, repeat, sid))

                {

                if ( scancode != iServer->DisabledScanCode() )

                	{

                    iServer->PlaySid(sid, EFalse);

                	}

                else

                	{

                	iServer->SetDisabledScanCode( -1 );

                	}

                }

            }

        }

    else

        {

        TRAPD(err, DispatchMessageL(aMessage));

        aMessage.Complete(err);

        }

    }

void CEikKeySoundSession::DispatchMessageL(const RMessage2& aMessage)

    {

    switch (aMessage.Function())

        {

        case EKeySoundServerInit:

            iClientUid = aMessage.Int1();

            iServer->InitL(aMessage);

            break;

        case EKeySoundServerPlaySID:

            iServer->PlaySid(aMessage.Int0(), EFalse);

            break;

        case EKeySoundServerAddSIDS:

            AddSoundIdBufferL(aMessage);

            break;

        case EKeySoundServerPushContext:

            PushContextL(aMessage);

            break;

        case EKeySoundServerPopContext:

            PopContext();

            break;

        case EKeySoundServerTopContext:

            {

            TInt id = 0;

            if (iServer->iCurrentSoundStack && iServer->iCurrentSoundStack->Count())

                {

                CEikKeySoundMap* map = iServer->iCurrentSoundStack->At(

                    iServer->iCurrentSoundStack->Count() - 1);

                id = map->ContextResourceId();

                }

            TPckg<TInt> pckg(id);

            aMessage.WriteL(0, pckg);

            break;

            }

        case EKeySoundServerBringToForeground: