/*

* 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 "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"

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; 

    };

XQServiceManager::XQServiceManager()

{

    XQSERVICE_DEBUG_PRINT("XQServiceManager::XQServiceManager");

    d = new XQServiceManagerPrivate();

}

XQServiceManager::~XQServiceManager()

{

    XQSERVICE_DEBUG_PRINT("XQServiceManager::~XQServiceManager");

    delete d;

}

/*!

    Starts service

*/

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

}

/*!

*/

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;

    }

/*!

*/

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.

*/

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;

}

/*!

*/

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;

}

/*!

*/

int XQServiceManager::latestError() const

{

    return d->LatestError();

}

/*!

*/

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;

            }

        }

        TRequestStatus requestStatusForRendezvous;

        // start application with command line parameters

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

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

        if (embed)

        {