/*

* Copyright (c) 2005-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:  This class implemets the Default App Client API

*

*/

#include <e32std.h>

#include <apgcli.h>

#include <das_client.h>

#include "das_service.h"

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <apaid.h>

#else

#include <apaid.h>

#include <apaidpartner.h> // new file introduced by xSymbian

#endif

const TUid KDefaultAppServiceUid = { 0x10281B9D };

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

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

// CDefaultAppClient::NewL()

// 

//

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

//

EXPORT_C CDefaultAppClient* CDefaultAppClient::NewL( MAknServerAppExitObserver* aObserver )

    {

    CDefaultAppClient* self = CDefaultAppClient::NewLC( aObserver );

    CleanupStack::Pop( self );

    return self;

    }

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

// CDefaultAppClient::NewLC()

//

//

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

//

EXPORT_C CDefaultAppClient* CDefaultAppClient::NewLC( MAknServerAppExitObserver* aObserver )

    {

    CDefaultAppClient* self = new ( ELeave ) CDefaultAppClient;

    CleanupStack::PushL( self );

    self->ConstructL( aObserver );

    return self;

    }

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

// CDefaultAppClient::CDefaultAppClient()

// Default constructor

//

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

//

CDefaultAppClient::CDefaultAppClient()

    {

    iServerAppUid.iUid = 0;

    }

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

// CDefaultAppClient::ConstructL()

// 

//

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

//

void CDefaultAppClient::ConstructL( MAknServerAppExitObserver* aObserver )

    {

    iObserver=aObserver;

    iService = new (ELeave) RDefaultAppService;

    }

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

// CDefaultAppClient::~CDefaultAppClient

//

//

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

//

EXPORT_C CDefaultAppClient::~CDefaultAppClient()

    {

    if(iMonitor)

        {

        iMonitor->Cancel();

        delete iMonitor;

        };

    if(iService)

        {

        iService->Close();

        delete iService;

        };

    // iObserver is not owned

    }

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

// Function to check if a server is present in the system. If the

// server is present, the subsequent functions should not fail due

// to server unavailability.

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

//

EXPORT_C TBool CDefaultAppClient::ServiceAvailable(TInt& aErrorCode)

    {

    TRAP(aErrorCode,GetServiceParamsL(NULL));

    if(aErrorCode != KErrNone) return EFalse;

    return ETrue;

    }

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

// Function to check the number of Service & MIME pairs the server would display if the 

// ChangeDefaultsL() would be called. The purpose of this function

// is to allow the client application not to display an entry for starting the server, in the 

// Options menu, in case the Server's list of Service & MIME pairs is empty.

// 

// Please note that the function may return a higher number than the actual number

// of pairs, because it does not check for MIMEs with System priority (that would not be 

// displayed).

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

//

EXPORT_C TInt CDefaultAppClient::PairsToDisplayL()

    {

    RApaLsSession ls;

    TInt i,j;

    TInt pairs=0;

    //Get own UID

    TUid clientAppUid = User::Identity(); 

    //connect

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

    //we are connected, so some initialization

    CleanupClosePushL( ls );

    User::LeaveIfError(ls.GetAllApps());

    //get all services & MIMEs supported by our application

    CApaAppServiceInfoArray* servicesAndDataTypes=ls.GetAppServicesLC(clientAppUid);

    for(i=0; i<servicesAndDataTypes->Array().Count(); i++ )

        {

        const TApaAppServiceInfo currentServiceInfo = servicesAndDataTypes->Array()[i];

        for ( j = 0 ; j < currentServiceInfo.DataTypes().Count() ; j++ )

            {

            //check if there are more than one applications supporting this Service & MIME pair

            CApaAppServiceInfoArray* apps=ls.GetServiceImplementationsLC(currentServiceInfo.Uid(),currentServiceInfo.DataTypes()[j].iDataType);

            if(apps->Array().Count()>1)

                {

            	//more that one app handles this Service & MIME

            	pairs++;

                };

            CleanupStack::PopAndDestroy(apps);

            };

        };

    //clean

    CleanupStack::PopAndDestroy(servicesAndDataTypes);

    CleanupStack::PopAndDestroy();  // closes RApaLsSession        

    return pairs;

    }

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

// This function launches the server, as a chained application. The client application will not be

// available to the user until the server does not exit.

// When the server exits, the client application gains control again. The observer (if specified 

// during instantiation (NewL) is notified that the server has exited.

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

//

EXPORT_C void CDefaultAppClient::ChangeDefaultsL( TInt aFlags )

    {

    if(iServerAppUid.iUid == 0)

        GetServiceParamsL( &iServerAppUid );

    iService->ConnectChainedAppL(iServerAppUid);

    if(iObserver)

        iMonitor = CApaServerAppExitMonitor::NewL(*iService, *iObserver, CActive::EPriorityStandard);

    else

        aFlags|=EFlagNoObserver;

    iService->SetDefault(aFlags);

    }

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

// This function finds out the uid of the Default Application Server 

// (the application registered to handle the DefaultApp service)

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

//     

void CDefaultAppClient::GetServiceParamsL( TUid *aServerAppUid)

    {

    CApaAppServiceInfoArray* services = NULL;    

    RApaLsSession ls;

    TInt count = 0; //number of services found so far.

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

    CleanupClosePushL( ls );

    User::LeaveIfError(ls.GetServerApps( KDefaultAppServiceUid ));

    services = ls.GetServiceImplementationsLC( KDefaultAppServiceUid );

    if( services )

        {

        count = services->Array().Count();

        // get the server's Uid

        if( aServerAppUid )

            aServerAppUid->iUid = services->Array()[0].Uid().iUid;

        };

    CleanupStack::PopAndDestroy( 2 );  // destroys services + closes RApaLsSession

    if ( count == 0) User::Leave(KErrNotFound);

    if ( count > 1) User::Leave(KErrNotSupported);

    // if we are here, it means that we have a single server handling the defaults

    }