/*

* Copyright (c) 2004-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:  Notifier server app session implementation.

*

*/

#include <e32notif.h>

#include <eiksrvs.h>

#include "AknNotiferAppServerApplication.h" 

#include "AknNotifierAppServer.h" 

#include "AknNotifierAppServerSession.h"

#include "AknNotifierControllerUtilities.h"

const TInt KINPUTSLOT = 1; 

const TInt KREPLYSLOT = 2; 

const TInt KEikonServerSecureId = 0x10003A4A;

LOCAL_C void SetEikonServerFree(TAny* aPtr)

    {

    *(TBool*)aPtr = 0; // points to boolean

    }

EXPORT_C CAknNotifierServerAppService::CAknNotifierServerAppService(

    const CAknNotifierAppServer& aAppServer) 

:iOwner(const_cast<CAknNotifierAppServer&>(aAppServer))

    {

    }

EXPORT_C CAknNotifierServerAppService::~CAknNotifierServerAppService()

    {       

    delete iInputBuf;

    delete iReplyBuf;       

    }

EXPORT_C void CAknNotifierServerAppService::HandleMessageL(const RMessage2& aMessage)

    {    

    CAknNotifierAppServerAppUi* appUi = (CAknNotifierAppServerAppUi*)CEikonEnv::Static()->AppUi();

    if (appUi && aMessage.SecureId().iId == KEikonServerSecureId)

        {

        appUi->EikSrvBlocked() = ETrue;

        CleanupStack::PushL(TCleanupItem(SetEikonServerFree, &(appUi->EikSrvBlocked()) ));     

        }

    if (aMessage.Function() == KDoNotifierControllerCommand)

        {

        if (appUi && appUi->NotifierControllerUtility())

            {

            appUi->NotifierControllerUtility()->DoNotifierContollerCommandL(

                (CAknNotifierControllerUtility::TNotifierControllerCommand)aMessage.Int0());

            CleanupStack::PopAndDestroy(); // Free eikon server 

            }

        aMessage.Complete(KErrNone);    

        return;

        }

    switch ( aMessage.Function() )

        {

        case EStartNotifier:

             {

             ResolveBuffersL(aMessage);

             TPtr8 ptr = iReplyBuf->Des();

             iOwner.StartNotifierL(TUid::Uid(aMessage.Int0()),*iInputBuf, ptr);

             WriteReplyL(aMessage);

             break;   

             }

        case EUpdateNotifier:

             {

             ResolveBuffersL(aMessage);

             TPtr8 ptr2 = iReplyBuf->Des();

             iOwner.UpdateNotifierL(TUid::Uid(aMessage.Int0()),*iInputBuf, ptr2);

             WriteReplyL(aMessage);

             break;

             }

        case ECancelNotifier:

             {

             iOwner.CancelNotifier(TUid::Uid(aMessage.Int0()));                 

             aMessage.Complete(KErrNone);

             break;

             }

        case EStartNotifierAndGetResponse:

             {

             if (appUi && appUi->EikSrvBlocked())

                 {

                 CleanupStack::PopAndDestroy(); // Free eikon server 

                 }

             ResolveBuffersL(aMessage);

             iOwner.StartNotifierAndGetResponseL(

                 TUid::Uid(aMessage.Int0()), 

                 *iInputBuf, 

                 aMessage, 

                 KREPLYSLOT); 

             break;

             }

        case EUpdateNotifierAndGetResponse:

             {

             if (appUi && appUi->EikSrvBlocked())

                 {

                 CleanupStack::PopAndDestroy(); // Free eikon server 

                 }

             ResolveBuffersL(aMessage);

             iOwner.UpdateNotifierAndGetResponseL(

                TUid::Uid(aMessage.Int0()), 

                *iInputBuf, 

                aMessage, 

                KREPLYSLOT); 

             break;

             }

        default:

            {

            CAknAppServiceBase::ServiceL(aMessage);           

            }

        }        

    if (appUi && appUi->EikSrvBlocked())

        {

        CleanupStack::PopAndDestroy(); // Free eikon server 

        }    

    }

EXPORT_C TBool CAknNotifierServerAppService::AllowClientL(const RMessage2& aMessage)

    { 

    // By default, we don't serve other process than notifier server.

    return (aMessage.SecureId().iId == KEikonServerSecureId);

    }

EXPORT_C void CAknNotifierServerAppService::ServiceL(const RMessage2& aMessage)

    {

    if (!AllowClientL(aMessage)) 

        {  

        aMessage.Complete(KErrAccessDenied);

        }

    else 

        {

        HandleMessageL(aMessage);   

        }   

    }

void CAknNotifierServerAppService::ResolveBuffersL(const RMessage2& aMessage)

    {

    delete iInputBuf;

    iInputBuf = 0;

    delete iReplyBuf;

    iReplyBuf = 0;

    iInputBuf = HBufC8::NewL(aMessage.GetDesLengthL(KINPUTSLOT));

    TPtr8 ptr = iInputBuf->Des();

    aMessage.Read(KINPUTSLOT,ptr);

    if (aMessage.Function() == EStartNotifier || aMessage.Function() == EUpdateNotifier)

        {

        iReplyBuf = HBufC8::NewL(aMessage.GetDesMaxLengthL(KREPLYSLOT));   

        }

    }

void CAknNotifierServerAppService::WriteReplyL(const RMessage2& aMessage)

    {

    aMessage.WriteL(KREPLYSLOT, *iReplyBuf);

    aMessage.Complete(KErrNone);

    }

// End of file