/*

* 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 <apaidpartner.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 <QString>

#include <QCoreApplication>

#include <QHash>

#include "xqservicelog.h"

#include <xqserviceglobal.h>

#include "xqrequestutil.h"

#include "xqservicemanager.h"

#include "xqserviceipcconst.h"

#include "xqservicemetadata/xqservicemetadata_p.h"

#include <xqservicemetadata/xqaiwinterfacedescriptor.h>

#include "xqconversions.h"

#define TIMER_DELAY 3000

class CProcessInfo : public CActive

    {

    public:

        static void AddProcessL(const TUid& appUid, RProcess& appProcess);

        static void EnsureProcessCanStartL(const TUid& appUid);

    protected:

        CProcessInfo(const TUid& appUid);

        ~CProcessInfo();

        void ConstructL(RProcess& appProcess);

        void DoCancel();

        void RunL();

    protected:

        class ProcessInfoMap

        {

        public:

            ~ProcessInfoMap()

            {

                foreach (CProcessInfo* info, map.values())

                    delete info;

            }

            QHash<TInt32, CProcessInfo*> map;

        };

        static ProcessInfoMap iProcessInfoMap;

        const TUid iAppUid;

    };

CProcessInfo::ProcessInfoMap CProcessInfo::iProcessInfoMap;

CProcessInfo::CProcessInfo(const TUid& appUid):

        CActive(CActive::EPriorityStandard), 

        iAppUid(appUid)

{

    XQSERVICE_DEBUG_PRINT("CProcessInfo::CProcessInfo");

    CActiveScheduler::Add(this);

}

CProcessInfo::~CProcessInfo()

{

    XQSERVICE_DEBUG_PRINT("CProcessInfo::~CProcessInfo");

    // Cancel asynch request, normally it should be done in DoCancel() 

    // but we dont wont to cancel request when we cancel active object

    User::CancelMiscNotifier(iStatus);

    Cancel();

}

void CProcessInfo::AddProcessL(const TUid& appUid, RProcess& appProcess)

{

    XQSERVICE_DEBUG_PRINT("CProcessInfo::AddProcessL");

    CProcessInfo* self = new(ELeave) CProcessInfo(appUid);

    CleanupStack::PushL(self);

    self->ConstructL(appProcess);

    CleanupStack::Pop(self);

}

void CProcessInfo::EnsureProcessCanStartL(const TUid& appUid)

{

    XQSERVICE_DEBUG_PRINT("CProcessInfo::EnsureProcessCanStartL");

    CProcessInfo* previousProcess = iProcessInfoMap.map[appUid.iUid];

    if (previousProcess) {

        previousProcess->Cancel();

        // Timer is for ensure that wait will end. 

        // Maybe there is possibility that destroing process notification could be lost.

        RTimer securityTimer;

        securityTimer.CreateLocal();

        CleanupClosePushL(securityTimer);

        TRequestStatus timerStatus;

        securityTimer.After(timerStatus, TIMER_DELAY);

        User::WaitForRequest(previousProcess->iStatus, timerStatus);

        CleanupStack::PopAndDestroy();

        delete previousProcess;

        iProcessInfoMap.map.remove(appUid.iUid);

    }

}

void CProcessInfo::RunL()

{

    XQSERVICE_DEBUG_PRINT("CProcessInfo::RunL");

    iProcessInfoMap.map.remove(iAppUid.iUid);

    delete this;

}

void CProcessInfo::ConstructL(RProcess& appProcess)

{

    XQSERVICE_DEBUG_PRINT("CProcessInfo::ConstructL");

    SetActive();

    EnsureProcessCanStartL(iAppUid);

    iProcessInfoMap.map.insert(iAppUid.iUid, this);

    appProcess.NotifyDestruction(iStatus);

}

void CProcessInfo::DoCancel()

{

    XQSERVICE_DEBUG_PRINT("CProcessInfo::DoCancel");

    // Cancel asynch request, normally it should be done in DoCancel() 

    // but we dont wont to cancel request when we cancel active object.

    // Cancel asynch request is in ~CProcessInfo().

}

/*!

    \class XQServiceManagerPrivate

    \brief Private implementation of the XQServiceManager.

*/

class XQServiceManagerPrivate 

    {

    public:

        XQServiceManagerPrivate();

        ~XQServiceManagerPrivate();

        enum matchMode

        {

            MatchInterfaceName,

            MatchServiceAndInterfaceName

        };

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

                       XQRequestUtil *util);

        TInt Discover(const QString& aService,TUid& aAppUid, QList<XQAiwInterfaceDescriptor>& interfaces, int matchMode,

                      bool findFirst=false);

        int  LatestError() const {return iLatestError;};

        bool IsRunning(const XQAiwInterfaceDescriptor& implementation) const;

    private:

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

        TInt Discover(const TDesC& aService,TUid& aAppUid, QList<XQAiwInterfaceDescriptor>& interfaces, int matchMode,

                      bool findFirst=false);

        TInt Discover1(const TDesC& aService,TUid& aAppUid, QList<XQAiwInterfaceDescriptor>& interfaces, int matchMode,

                       bool findFirst=false);

        TInt Discover2(const TDesC& aService,TUid& aAppUid, QList<XQAiwInterfaceDescriptor>& interfaces, int matchMode,

                       bool findFirst=false);

        CApaAppServiceInfoArray* AvailableServiceImplementations1L();

        CApaAppServiceInfoArray* AvailableServiceImplementations2L();

        TUint64 getAppPid(const TUid& aAppUid);   

        int doMapErrors(TInt aError);

        TVersion iVersion;

        TApaAppInfo  iAppInfo;

        int iLatestError;

        RApaLsSession iApaSession;

        XQAiwInterfaceDescriptor iImplDescriptor; 

    };

/*!

    \class XQServiceManager

    \brief Discovery and service startup. 

*/

/*!

    Constructor.

*/

XQServiceManager::XQServiceManager()

{

    XQSERVICE_DEBUG_PRINT("XQServiceManager::XQServiceManager");

    d = new XQServiceManagerPrivate();

}

/*!

    Destructor.

*/

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.

    \param threadId Returned process id of the application.

    \return Error code if error occured, 0 otherwise.

*/

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);

}

/*!

    Starts service

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

    \param embedded Start in embedded mode.

    \param applicationUid Returned applicatiion.

    \param threadId Returned process id of the application.

    \param userData Additional user data.

    \return Error code if error occured, 0 otherwise.

*/

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

    {

    XQSERVICE_DEBUG_PRINT("XQServiceManager::findInterfaces 1");

    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

{

    XQSERVICE_DEBUG_PRINT("XQServiceManager::findInterfaces 2");

    QList<XQAiwInterfaceDescriptor> interfaces;

    TUid appUid;

    interfaces.clear(); 

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

                           XQServiceManagerPrivate::MatchServiceAndInterfaceName);

    return interfaces;

}

/*!

    Finds the first implementation for the given interface name.

    \param interfaceName Interfacename to match.

    \return List of implementations.

*/

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

{

    XQSERVICE_DEBUG_PRINT("XQServiceManager::findFirstInterface 1");

    QList<XQAiwInterfaceDescriptor> interfaces;

    TUid appUid;

    interfaces.clear();

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

    return interfaces;

}

/*!

    Finds the first implementation for the given service + interface names.

    \param serviceName Service name.

    \param interfaceName Interfacename to match.

    \return List of implementations.

*/

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

{

    XQSERVICE_DEBUG_PRINT("XQServiceManager::findFirstInterface 2");

    QList<XQAiwInterfaceDescriptor> interfaces;

    TUid appUid;

    interfaces.clear(); 

    // Catenate to get full name

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

                           XQServiceManagerPrivate::MatchServiceAndInterfaceName, true);

    return interfaces;

}

/*!

    Gets the latest error occured.

    \return Latest error code as integer value.

*/

int XQServiceManager::latestError() const

{

    return d->LatestError();

}

/*!

    Checks if the given \a implmentation is running.

    \param implementation Implementation to be checked.

    \return true if given \a implementation is running, false otherwise.

*/

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

{

    XQSERVICE_DEBUG_PRINT("XQServiceManager::isRunning");

    return d->IsRunning(implementation);

}

// ====== Private part ==============

XQServiceManagerPrivate::XQServiceManagerPrivate()

{

    XQSERVICE_DEBUG_PRINT("XQServiceManagerPrivate::XQServiceManagerPrivate");

    iLatestError = 0;

    iApaSession.Connect();    

}

XQServiceManagerPrivate::~XQServiceManagerPrivate()

{

    XQSERVICE_DEBUG_PRINT("XQServiceManagerPrivate::~XQServiceManagerPrivate");

    iApaSession.Close();

};

// 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()) 

    {

        iImplDescriptor=util->mDescriptor;  // Descriptor given by caller

        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)

    {

        // Find the first implementation

        error = Discover(serverName,appUid,interfaces, XQServiceManagerPrivate::MatchServiceAndInterfaceName, true);

        if (interfaces.count())

        {

            iImplDescriptor=interfaces[0];  // Descriptor search upon start

        }

    }

    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

    User::LeaveIfError( iApaSession.GetAppInfo( iAppInfo, uid ) );

    TApaAppCapabilityBuf caps;

    User::LeaveIfError(iApaSession.GetAppCapability(caps, uid));

    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;

            }

        }

        else {

            CProcessInfo::EnsureProcessCanStartL(uid);

        }

        TRequestStatus requestStatusForRendezvous;

        // start application with command line parameters

        //User::LeaveIfError( iApaSession.StartApp( *cmdLine, threadId, &requestStatusForRendezvous) );

        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) + iImplDescriptor.interfaceName() );

        startupArgs += (" " + QString::fromLatin1(XQServiceUtils::StartupArgServiceName) + iImplDescriptor.serviceName() );

        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);