/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation, version 2.1 of the License.

* 

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with this program.  If not, 

* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

*

* Description:                                                         

*

*/

#include <e32std.h>

#include <w32std.h>

#include <apparc.h>

#include <apgcli.h>

#include <apacln.h>

#include <apgtask.h>

#include <barsread2.h>

#include <apacmdln.h>

#include <coemain.h>

#include <QBuffer>

#include "xqservicemetadata/xqservicemetadata_p.h"

#include <xqservicemetadata/xqaiwinterfacedescriptor.h>

class XQServiceManagerPrivate 

    {

    public:

        enum matchMode

        {

            MatchInterfaceName,

            MatchServiceAndInterfaceName

        };

        int StartServer(const QString& aService,  bool embedded, int& applicationUid, quint64& processId,

                       XQRequestUtil *util);

        int  LatestError() const {return iLatestError;};

        bool IsRunning(const XQAiwInterfaceDescriptor& implementation) const;

    private:

        void StartServerL(const TUid& uid, bool embedded, TUint64& processId, XQRequestUtil *util);

        TUint64 getAppPid(const TUid& aAppUid);   

        int doMapErrors(TInt aError);

        TVersion iVersion;

        TApaAppInfo  iAppInfo;

        int iLatestError;

    };

XQServiceManager::XQServiceManager()

{

    XQSERVICE_DEBUG_PRINT("XQServiceManager::XQServiceManager");

    d = new XQServiceManagerPrivate();

}

XQServiceManager::~XQServiceManager()

{

    XQSERVICE_DEBUG_PRINT("XQServiceManager::~XQServiceManager");

    delete d;

}

/*!

    Starts service

    \param service The full name of service (servicename + interfacename)

    \param embedded Start in embedded mode

    \param applicationUid Returned applicatiion

    \return List of implementations

*/

int XQServiceManager::startServer(const QString& service, bool embedded, int& applicationUid, quint64& threadId)

{

    XQSERVICE_DEBUG_PRINT("XQServiceManager::startServer(1)");

    return startServer(service,embedded,applicationUid,threadId,NULL);

}

int XQServiceManager::startServer(const QString& service, bool embedded, int& applicationUid, quint64& threadId,

                                 const void *userData)

{

    XQSERVICE_DEBUG_PRINT("XQServiceManager::startServer(2)");

    // The "XQServiceRequest::send(QVariant& retData)" function passed the utility as user data

    // the IPC layer. Could be NULL if no descriptor was given upon creating the request.

    // The util data is known to be writeable (though passed as const userData)

    XQRequestUtil *util = static_cast<XQRequestUtil*>((void *)userData);

    if (util == 0)

    {

        // Something is badly wrong as this should be always avaible

        return XQService::EMgrInternalError;

    }

    return d->StartServer(service,embedded,applicationUid,threadId, util);

}

/*!

    Finds implementations for the given interface

    \param interfaceName Interfacename to match

    \return List of implementations

*/

QList<XQAiwInterfaceDescriptor>  XQServiceManager::findInterfaces ( const QString &interfaceName ) const

    {

    QList<XQAiwInterfaceDescriptor> interfaces;

    TUid appUid;

    interfaces.clear();

    TInt error=d->Discover(interfaceName, appUid, interfaces, XQServiceManagerPrivate::MatchInterfaceName);

    return interfaces;

    }

/*!

    Finds implementations for the given interface implemented by given service

    \param serviceName Service name

    \param interfaceName Interfacename to match

    \return List of implementations

*/

QList<XQAiwInterfaceDescriptor>  XQServiceManager::findInterfaces ( const QString &serviceName, const QString &interfaceName ) const

{

    QList<XQAiwInterfaceDescriptor> interfaces;

    TUid appUid;

    interfaces.clear(); 

    // Catenate to get full name

    TInt error=d->Discover(serviceName + "." + interfaceName, appUid, interfaces,

                           XQServiceManagerPrivate::MatchServiceAndInterfaceName);

    return interfaces;

}

/*!

    Returns the latest error occured

*/

int XQServiceManager::latestError() const

{

    return d->LatestError();

}

/*!

    Returns the latest error occured

*/

bool XQServiceManager::isRunning(const XQAiwInterfaceDescriptor& implementation) const

{

    XQSERVICE_DEBUG_PRINT("XQServiceManager::isRunning");

    return d->IsRunning(implementation);

}

// aService is here the full name (service + interface)

int XQServiceManagerPrivate::StartServer(const QString& aService,  bool embedded, int& applicationUid, quint64& processId,

                                        XQRequestUtil *util)

{

    XQSERVICE_DEBUG_PRINT("XQServiceManagerPrivate::startServer(2)");

    XQSERVICE_DEBUG_PRINT("aService: %s", qPrintable(aService));

    TUid appUid;

    appUid.iUid=0;

    TInt error = KErrNone;

    QList<XQAiwInterfaceDescriptor> interfaces;

    TPtrC serverName( reinterpret_cast<const TUint16*>(aService.utf16()) );

    if (util->mDescriptor.isValid()) 

    {

        appUid.iUid = util->mDescriptor.property(XQAiwInterfaceDescriptor::ImplementationId).toInt();

        XQSERVICE_DEBUG_PRINT("ApplicationUid from descriptor: %x", appUid.iUid);

    }

    // Need to discover service first if descriptor did not contained valid UID

    // Otherwise, go directly starting the service server

    if (appUid.iUid == 0)

    {

    }

    if (error)

        {

        return doMapErrors(error);

        }

    TRAP(error, StartServerL(appUid,embedded,processId, util));

    applicationUid = appUid.iUid ;

    XQSERVICE_DEBUG_PRINT("ApplicationUid: %x, processId: %d", applicationUid, processId);

    XQSERVICE_DEBUG_PRINT("error: %d", error);

    return doMapErrors(error);

}

void XQServiceManagerPrivate::StartServerL(const TUid& uid, bool embedded, TUint64& processId,

                                           XQRequestUtil *util)

{

    XQSERVICE_DEBUG_PRINT("XQServiceManagerPrivate::StartServerL");

    Q_UNUSED(embedded);  // Not used any more. XQRequestUtil applied instead

    bool toBackground = false;

    // Apply the utility's option for embedding  instead

    bool embed = util->mInfo.isEmbedded();

    toBackground = util->mInfo.isBackground();

    XQSERVICE_DEBUG_PRINT("\tembedded got from utility=%d", embed);

    XQSERVICE_DEBUG_PRINT("\tbackground got from utility=%d", toBackground);

    // retrieve application information

    TApaAppCapabilityBuf caps;

    if (!toBackground)

    {

        // If service wants to be launched to background.. respect it

        toBackground = caps().iLaunchInBackground;

        XQSERVICE_DEBUG_PRINT("\tbackground from apparch=%d", toBackground);

    }

    // Consistency check

    if (embed && toBackground)

    {

        User::Leave(KErrArgument);

    }

    /*

    // Using the "iAppInfo.iCaption" is wrong as the channel name (full servicename) shall be used:

    // e.g. tester's "com.nokia.servicesd.serviceapp.Dialer" or

    //       "com.nokia.servicesd.serviceapp.Dialer.PROCESS-ID" in case of embedded launch

    // Anyway, this is not needed as the "XQServiceIpcClient::connectToServer()" takes care of the checking logic

    // earlier (the "startServer" logic will be applied only when needed)

    TFindServer find( iAppInfo.iCaption );

    TFullName fullName;

    TInt err = find.Next( fullName );

    XQSERVICE_DEBUG_PRINT("err: %d", err);

    */

    TInt err = KErrNotFound;  // Assume not found

    if ( err != KErrNone )

        {

        CApaCommandLine* cmdLine = CApaCommandLine::NewLC();

        cmdLine->SetExecutableNameL( iAppInfo.iFullName );

        TApaCommand  aLaunchCommand = toBackground ? EApaCommandBackground : EApaCommandRun;

        cmdLine->SetCommandL(aLaunchCommand);

        // just use the Secure ID as server differentiator

        //cmdLine->SetServerRequiredL( uid.iUid );

        RProcess client;

        cmdLine->SetServerRequiredL(client.Id().Id());

        if (embed) {

            CCoeEnv* env= CCoeEnv::Static();

            if (env)  // Could be NULL 

            {

                RWindowGroup& wg = env->RootWin();

                wg.AllowProcessToCreateChildWindowGroups(iAppInfo.iUid);

                TInt parentId = wg.Identifier();

                if (parentId)

                {

                    // pass our window group ID to the embedded child process

                    cmdLine->SetParentWindowGroupID(parentId);

                    XQSERVICE_DEBUG_PRINT("\tParent ID %x set for %x (%x)", (int)parentId, iAppInfo.iUid, uid.iUid);

                }

            }

            else

            {

                // Can not be embedded (non GUI client)

                embed = false;

            }

        }

        TRequestStatus requestStatusForRendezvous;

        // start application with command line parameters

        QString startupArgs = QString::fromLatin1(XQServiceUtils::StartupArgService);

        if (embed)

        {

            startupArgs += (" " + QString::fromLatin1(XQServiceUtils::StartupArgEmbedded));

        }

        //

        // Add interface name and operation (message) name to the command line as startup args.

        // Usable in practise only for the embedded launch

        // Can be used  by service application to prepare the UI to the coming call.

        //

        QStringList l = util->mOperation.split("("); 

        QString oper = l.value(0); //  // Pick only the function name and ignore parameters

        startupArgs += (" " + QString::fromLatin1(XQServiceUtils::StartupArgInterfaceName) + util->mDescriptor.interfaceName() );

        startupArgs += (" " + QString::fromLatin1(XQServiceUtils::StartupArgOperationName) + oper);

        XQSERVICE_DEBUG_PRINT("\tStartupArgs:%s", qPrintable(startupArgs));

        TPtrC cmdLineArgs( reinterpret_cast<const TUint16*>(startupArgs.utf16()) );

        RProcess newApp;

        XQSERVICE_DEBUG_PRINT("XQServiceManagerPrivate::Creating process");

        User::LeaveIfError(newApp.Create(iAppInfo.iFullName, cmdLineArgs));

        CleanupClosePushL(newApp);

        XQSERVICE_DEBUG_PRINT("XQServiceManagerPrivate::Created process");

        cmdLine->SetProcessEnvironmentL(newApp);

        TProcessId newAppId = newApp.Id();

        processId = newAppId.Id();

        XQSERVICE_DEBUG_PRINT("XQServiceManagerPrivate::Rendezvous for %x", processId);

        newApp.Rendezvous(requestStatusForRendezvous);  // Asynchronous

        newApp.Resume();

        User::WaitForRequest( requestStatusForRendezvous ); // Make the  rendezvouz

        XQSERVICE_DEBUG_PRINT("XQServiceManagerPrivate::Rendezvous done %d", requestStatusForRendezvous.Int());

        User::LeaveIfError( requestStatusForRendezvous.Int()); 

        CleanupStack::PopAndDestroy(2,cmdLine); // newApp, cmdLine

        XQSERVICE_DEBUG_PRINT("XQServiceManagerPrivate::Done"); 

        }

}

TUint64 XQServiceManagerPrivate::getAppPid(const TUid& aAppUid)

{

    XQSERVICE_DEBUG_PRINT("XQServiceManagerPrivate::getAppPid");

    TUint64 pid = 0;

    // Get the current task

    RWsSession ws;

    if (ws.Connect()==KErrNone) {

        XQSERVICE_DEBUG_PRINT("Connected to window server");

        TApaTaskList tasklist( ws );

        TApaTask task = tasklist.FindApp( aAppUid );        

        if (task.Exists()) {

            XQSERVICE_DEBUG_PRINT("Application found");

            pid=task.ThreadId().Id();

        }

    }

    return pid;

}

{

    // retrieve list of available services implementations from apparc

    CApaAppServiceInfoArray* apaInfo = 

    CleanupStack::Pop( apaInfo );

    return apaInfo;

}

TInt XQServiceManagerPrivate::Discover(const QString& aService,TUid& aAppUid, QList<XQAiwInterfaceDescriptor>& interfaces,

    {

    TPtrC serverName( reinterpret_cast<const TUint16*>(aService.utf16()) );

    XQSERVICE_DEBUG_PRINT("XQServiceManagerPrivate::Discover (1)");

    return error;

    }

TInt XQServiceManagerPrivate::Discover( const TDesC& aService,

                                      TUid& aAppUid, QList<XQAiwInterfaceDescriptor>& interfaces,

    {

    XQSERVICE_DEBUG_PRINT("XQServiceManagerPrivate::Discover (2)");

    CApaAppServiceInfoArray* apaInfo = NULL;

    TInt error = KErrNone;

    XQSERVICE_DEBUG_PRINT("Discover status=%d", error);

    if (error)

        {

        return error;  // This is fatal as nothing found

        }

    TArray<TApaAppServiceInfo> implArray( apaInfo->Array() );

    XQSERVICE_DEBUG_PRINT("implArray.Count(): %d", implArray.Count());

    if ( !implArray.Count() )

        {

        delete apaInfo;

        return KErrNotFound;   // No services found

        }

    TBool found( EFalse );

    QString serviceName = QString::fromUtf16(aService.Ptr(),aService.Length());

    XQSERVICE_DEBUG_PRINT("serviceName: %s", qPrintable(serviceName));

    for ( TInt ii = 0; ii < implArray.Count(); ii++ )  

        {

        //

        // Reset error for each check round

        //

        error = KErrNone;

        TUid uid = implArray[ii].Uid();

        XQSERVICE_DEBUG_PRINT("implArray[%d].UID=%x", ii, uid);

        RResourceReader res;

        // read opaque data

        TRAP(error,res.OpenL( implArray[ii].OpaqueData() ) )

        if ( error )

            {

            XQSERVICE_DEBUG_PRINT("OpaqueData error: %d", error);

            delete apaInfo;

            apaInfo = NULL;