/*

 * Copyright (c) 2008 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:  ?Description

 *

 */

#include <QString>

#include <e32base.h>

#include <w32std.h>

#include <apgtask.h>

#include <apgcli.h>

#include <eikenv.h>

#include <eikappui.h>

#include <AknDef.h>

#include <AknTaskList.h>

#include <usif/usifcommon.h>

#include <usif/scr/scr.h>

#include <usif/usiferror.h>

#include <cadefs.h>

#include <caentry.h>

#include "caapphandler.h"

#include "cainnerentry.h"

#include "causifuninstalloperation.h"

#include "catasklist.h"

#include "cautils.h"

#include "caclient_defines.h"

#include "cadef.h"

using namespace Usif;

static const char caTypeApp[] = "application";

static const char caTypePackage[] = "package";

static const char caTypeWidget[] = "widget";

static const char caAttrView[] = "view";

static const char caAttrComponentId[] = "component_id";

/*!

 *  Command handler for application entries.

 *

 *  \lib caclient.lib

 */

/*!

 * Constructor.

 */

CaAppHandler::CaAppHandler(QObject *parent):

    iEikEnv(CEikonEnv::Static()),

    iUsifUninstallOperation(NULL)

{

    Q_UNUSED(parent);

}

/*!

 * Destructor.

 */

CaAppHandler::~CaAppHandler()

{

    delete iUsifUninstallOperation;

}

/*!

 * Execute a given command.

 * \param entry a reference to a CaEntry instance.

 * \param command a given command.

 * \param receiver a QObject class with slot to invoke.

 * \param member a slot to invoke.

 * \retval an error code.

 */

int CaAppHandler::execute(const CaEntry &entry, const QString &command,

        QObject* receiver, const char* member)

{

    if ( receiver && member ) {

        connect( this, SIGNAL(uninstallFailed(int)), receiver, member, Qt::UniqueConnection );

    }

    int result(KErrGeneral);

    if (command == caCmdOpen && entry.entryTypeName() == caTypeApp) {

        QString viewIdValue = entry.attribute(caAttrView);

        bool viewIdIsCorrect(true);

        int viewId(-1);

        if (!viewIdValue.isNull()) {

            viewId = viewIdValue.toInt(&viewIdIsCorrect, 0);

        }

        if (viewIdIsCorrect) {

            QString uidValue =

                entry.attribute(APPLICATION_UID_ATTRIBUTE_NAME);

            int uid = uidValue.toInt();

            TRAP(result, launchApplicationL(TUid::Uid(uid), viewId));

        }

    } else if (command == caCmdRemove) {

        QString componentId(entry.attribute(caAttrComponentId));

        result = handleRemove(entry.flags(),

            entry.entryTypeName(),

            componentId);

    } else {

        result = KErrNotSupported;

    }

    return result;

}

/*!

 * Launch application

 * \param uid UID of the application to launch.

 * \param viewId id of the view the application is to start in.

 */

void CaAppHandler::launchApplicationL(const TUid uid, TInt viewId)

{

    if (viewId > 0 && iEikEnv) {

        TVwsViewId view(uid, TUid::Uid(viewId));

        iEikEnv->EikAppUi()->ActivateViewL( view );

    } else {

        RWsSession wsSession;

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

        CleanupClosePushL<RWsSession>(wsSession);

        CCaTaskList* taskList = CCaTaskList::NewLC(wsSession);

        TApaTask task = taskList->FindRootApp(uid);

        CleanupStack::PopAndDestroy(taskList);

        if (task.Exists()) {

            task.BringToForeground();

        } else {

            // TApaAppInfo size is greater then 1024 bytes

            // so its instances should not be created on the stack.

            TApaAppInfo* appInfo = new(ELeave) TApaAppInfo;

            CleanupStack::PushL(appInfo);

            TApaAppCapabilityBuf capabilityBuf;

            RApaLsSession appArcSession;

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

            CleanupClosePushL<RApaLsSession>(appArcSession);

            User::LeaveIfError(appArcSession.GetAppInfo(*appInfo, uid));

            User::LeaveIfError(appArcSession.GetAppCapability(

               capabilityBuf, uid));

            TApaAppCapability &caps = capabilityBuf();

            CApaCommandLine *cmdLine = CApaCommandLine::NewLC();

            cmdLine->SetExecutableNameL(appInfo->iFullName);

            if (caps.iLaunchInBackground) {

                cmdLine->SetCommandL(EApaCommandBackground);

            } else {

                cmdLine->SetCommandL(EApaCommandRun);

            }

            cmdLine->SetTailEndL(KNullDesC8);

            User::LeaveIfError(appArcSession.StartApp(*cmdLine));

            CleanupStack::PopAndDestroy(cmdLine);

            CleanupStack::PopAndDestroy(&appArcSession);

            CleanupStack::PopAndDestroy(appInfo);

        }

        CleanupStack::PopAndDestroy( &wsSession );

    }

}

/*!

 * Uninstall application.

 * \param flags flags of the application which is to uninstall.

 * \param typeName type name of the entry.

 * \param componentId component id.

 * \retval an error code.

 */

int CaAppHandler::handleRemove(const EntryFlags &flags,

    const QString &typeName,

    const QString &componentId)

{

    int result(KErrNone);

    if (flags.testFlag(RemovableEntryFlag)) {

        if (typeName == caTypeApp

            || typeName == caTypePackage

            || typeName == caTypeWidget) {

            if(componentId.isNull()) {

                result = KErrNotFound;

            } else {

                bool convertStatus(false);

                int id = componentId.toInt(&convertStatus);

                if (convertStatus) {

                    TRAP(result, startUsifUninstallL(id));

                } else {

                    result = KErrGeneral;

                }

            }

        }

        else {

            result = KErrNotSupported;

        }

    } else {

        result = KErrAccessDenied;

    }

    return result;

}

/*!

 * Start uninstall operation via usif.

 * \param componentId component id.

 */

void CaAppHandler::startUsifUninstallL(TInt componentId)

{

    if (iUsifUninstallOperation && iUsifUninstallOperation->IsActive()) {

        uninstallError(Usif::EInstallerBusy);

    } else {

        delete iUsifUninstallOperation;

        iUsifUninstallOperation = NULL;

        iUsifUninstallOperation = CCaUsifUninstallOperation::NewL(componentId);

        iUsifUninstallOperation->AddObserver(this);

    }

}

#ifdef COVERAGE_MEASUREMENT

#pragma CTC SKIP

#endif //COVERAGE_MEASUREMENT 

/*!

 * Show information message about unninstall error.

 * \param error uninstall error.

 * \retval void.

 */

void CaAppHandler::uninstallError(int error)

{

   	emit uninstallFailed(error);

}

#ifdef COVERAGE_MEASUREMENT

#pragma CTC ENDSKIP

#endif //COVERAGE_MEASUREMENT