/*
* Copyright (c) 2009 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:
*
*/
/*
 * T_caapphandlerplugin.cpp
 *
 *  Created on: 2009-09-16
 *      Author:
 */

//  CLASS HEADER

#include <w32std.h>
#include <apgtask.h>
#include <apgcli.h>
#include <mmf/common/mmfcontrollerpluginresolver.h>
#include <usif/scr/scr.h>
#include <usif/sif/sifcommon.h>
#include <usif/scr/screntries.h>
#include <qservicemanager.h>
#include <QProcess>
#include <qservicemanager.h>

#include <cadefs.h>

#include "T_caapphandlerplugin.h"
#include "waitactive.h"
#include "catasklist.h"
#include "caapphandler.h"
#include "caapphandlerplugin.h"
#include "caentry.h"
#include "caclient_defines.h"
#include "t_cainstaller.h"

template <typename RClass>
struct RClassDeleter
{
    static inline void cleanup(RClass *ptr)
    {
        ptr->Close();
    }
};


typedef RClassDeleter< RBuf > RBufDeleter;
typedef QScopedPointer< RBuf, RBufDeleter > 
    RBufPointer;


QTM_USE_NAMESPACE

static const char caTypeApp[] = "application";
static const char caTypePackage[] = "package";
static const char caTypeWidget[] = "widget";
static const char caAttrView[] = "view";
static const char caCmdClose[] = "close";
static const char caAttrWindowGroupId[] = "window_group_id";
static const char caAttrComponentId[] = "component_id";
static const char caUidAttribute[] = "application:uid";

T_CaHandler::T_CaHandler():
    iAppHandler(NULL)
{
}

void T_CaHandler::cleanup()
{
    delete iAppHandler;
    iAppHandler = NULL;
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void T_CaHandler::initTestCase()
{
    QStringList pluginPaths;
    QString xmlName("caapphandlerplugin.xml");

    pluginPaths.append("c:/resource/qt/plugins/commandhandler");
    pluginPaths.append("z:/resource/qt/plugins/commandhandler");

    QServiceManager serviceManager;
    foreach (QString path, pluginPaths) {
        QApplication::addLibraryPath(path);
        QDir dir(path);
        if (dir.exists(xmlName)) {
            serviceManager.addService(dir.absoluteFilePath(xmlName));
        }
    }

    Usif::RSoftwareInstall sif;
    CleanupClosePushL( sif );
    User::LeaveIfError( sif.Connect() );
    
    // Install the component
    _LIT16( KHelloJarPath, "c:\\testing\\data\\t_caapphandler\\installs\\hello.jar" );
    Usif::COpaqueNamedParams* arguments = NULL;
    Usif::COpaqueNamedParams* results = NULL;
    arguments = Usif::COpaqueNamedParams::NewLC();
    results = Usif::COpaqueNamedParams::NewLC();
    arguments->AddIntL( Usif::KSifInParam_InstallSilently, 1 );
    TRequestStatus status;
    sif.Install( KHelloJarPath, *arguments, *results, status, EFalse );
    User::WaitForRequest( status );
    User::LeaveIfError( status.Int() );
    
    CleanupStack::PopAndDestroy( results );
    CleanupStack::PopAndDestroy( arguments );
    
    // Disconnect from the SIF server
    CleanupStack::PopAndDestroy( &sif );
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaHandler::appHandlerConstruction()
{
    iAppHandler = new CaAppHandler();
    QVERIFY(iAppHandler);
}


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaHandler::appHandlerMultipleLoad()
{
    RPointerArray<CaAppHandler> handlerArray;

    bool foundNull(false);
    TRAPD(err,
          CleanupResetAndDestroyPushL(handlerArray);
    for (TInt i(0); i < 10; ++i) {
    handlerArray.AppendL(new CaAppHandler());
        if (handlerArray[i] == 0) {
            foundNull = true;
            break;
        }
    }
    CleanupStack::PopAndDestroy(&handlerArray);
         );
    QCOMPARE(err, KErrNone);
    QVERIFY(!foundNull);
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaHandler::appHandlerMultipleLoadAndDelete()
{
    CaAppHandler *handlerPtr(NULL);
    for (TInt i(0); i < 10; ++i) {
        handlerPtr = new CaAppHandler();
        delete handlerPtr;
        handlerPtr = NULL;
    }
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaHandler::appHandlerOpenFails()
{
    appHandlerConstruction();

    TInt unsuportedCommandResult(KErrNone);
    TInt unexistingEntryOpenResult(KErrNone);
    TInt corruptedEntryOpenResult(KErrNone);
    TInt unsupportedEntryTypeOpenResult(KErrNone);

    CaEntry *entry = new CaEntry();

    // valid entry type name
    entry->setEntryTypeName(caTypeApp);

    unsuportedCommandResult =
        iAppHandler->execute(*entry, "unsupported_command_name");
    // invalid UID
    entry->setAttribute(APPLICATION_UID_ATTRIBUTE_NAME, "11111");

    unexistingEntryOpenResult = iAppHandler->execute(*entry, caCmdOpen);

    // invalid view ID
    entry->setAttribute(caAttrView, "not_a_hex_value");

    corruptedEntryOpenResult = iAppHandler->execute(*entry, caCmdOpen);

    // invalid entry type name
    entry->setEntryTypeName("unsupported_entry_type_name");

    unsupportedEntryTypeOpenResult =
        iAppHandler->execute(*entry, caCmdOpen);

    delete entry;
    entry = NULL;
    QCOMPARE(unsuportedCommandResult, KErrNotSupported);
    QCOMPARE(unexistingEntryOpenResult, KErrNotFound);
    QCOMPARE(corruptedEntryOpenResult, KErrGeneral);
    QCOMPARE(unsupportedEntryTypeOpenResult, KErrNotSupported);
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaHandler::appHandlerRemoveFails()
{
    appHandlerConstruction();
    TInt unpermittedRemovalResult(KErrNone);
    TInt unexistingEntryRemovalResult(KErrNone);

    CaEntry *entry = new CaEntry();
    entry->setEntryTypeName(caTypeApp);

    // invalid flags (should be removable)
    entry->setFlags(0);

    unpermittedRemovalResult =
        iAppHandler->execute(*entry, caCmdRemove);

    // set correct flags
    entry->setFlags(RemovableEntryFlag);

    // invalid UID
    entry->setAttribute(APPLICATION_UID_ATTRIBUTE_NAME, "0");

    unexistingEntryRemovalResult =
        iAppHandler->execute(*entry, caCmdRemove);
    delete entry;
    entry = NULL;

    QCOMPARE(unpermittedRemovalResult, KErrAccessDenied);
    QCOMPARE(unexistingEntryRemovalResult, KErrNotFound);
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaHandler::appHandlerClose()
{
    TInt errorClose1(KErrNone);
    TInt errorClose2(KErrNone);
    TInt errorOpen(KErrNone);
    bool wasRunning(false);
    bool closedRunning(false);

    const TInt KPhonebookUid(0x20022EF9);

    RWsSession wsSession;
    TRAPD(err,
        CleanupClosePushL(wsSession);
        User::LeaveIfError(wsSession.Connect());

        TApaTaskList taskList(wsSession);
        TApaTask taskBefore = taskList.FindApp(TUid::Uid(KPhonebookUid));
        if (taskBefore.Exists()) {
            taskBefore.EndTask();
        }

        appHandlerConstruction();

        CaEntry *entry = new CaEntry();
        entry->setEntryTypeName(caTypeApp);
        entry->setAttribute(APPLICATION_UID_ATTRIBUTE_NAME,
            QString::number(KPhonebookUid, 10));

        errorClose1 = iAppHandler->execute(*entry, caCmdClose);
        QTest::qWait(10000);
        errorOpen = iAppHandler->execute(*entry, caCmdOpen);

        QTest::qWait(10000);
        TApaTask taskAfter = taskList.FindApp(TUid::Uid(KPhonebookUid));
        TInt id = taskAfter.WgId();
        QString numBuf;
        numBuf = QString::number(id);
        entry->setFlags(entry->flags() | RunningEntryFlag);
        entry->setAttribute(caAttrWindowGroupId, numBuf);

        wasRunning = taskAfter.Exists();

        errorClose2 = iAppHandler->execute(*entry, caCmdClose);

        QTest::qWait(10000);
        closedRunning = !taskList.FindApp(TUid::Uid(KPhonebookUid)).Exists();
        delete entry;
        entry = NULL;
        CleanupStack::PopAndDestroy(&wsSession);
         );
    QCOMPARE(err, KErrNone);
    QCOMPARE(errorClose1, KErrGeneral);
    QCOMPARE(errorOpen, KErrNone);
    QCOMPARE(errorClose2, KErrNone);
    QVERIFY(wasRunning);
    QVERIFY(closedRunning);
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaHandler::appHandlerRunApplication()
{

    TInt error(KErrNone);
    bool started(false);
    // we will run calculator app
    const TInt KPhonebookUid(0x20022EF9);

    RWsSession wsSession;

    TRAPD(err,
        CleanupClosePushL(wsSession);
        User::LeaveIfError(wsSession.Connect());

        TApaTaskList taskList(wsSession);
        TApaTask taskBefore = taskList.FindApp(TUid::Uid(KPhonebookUid));
        if (taskBefore.Exists()) {
            taskBefore.EndTask();
        }

        appHandlerConstruction();

        CaEntry *entry = new CaEntry();
        entry->setEntryTypeName(caTypeApp);
        entry->setAttribute(APPLICATION_UID_ATTRIBUTE_NAME,
            QString::number(KPhonebookUid));

        error = iAppHandler->execute(*entry, caCmdOpen);

        QTest::qWait(1000);
        TApaTask taskAfter = taskList.FindApp(TUid::Uid(KPhonebookUid));
        started = taskAfter.Exists();
        taskAfter.EndTask();

        delete entry;
        entry = NULL;
        CleanupStack::PopAndDestroy(&wsSession);
         );
    QCOMPARE(err, KErrNone);
    QCOMPARE(error, KErrNone);
    QVERIFY(started);
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaHandler::appHandlerRemoveApplication()
{
    bool leaveOnRemove(true);
    bool removed(false);

    _LIT(KSapiPackageFileName, 
        "c:\\testing\\data\\t_apphandler\\installs\\sapiapp_S60_3_X_v_1_0_0.sisx");
    _LIT(KSapiAppFileName, "c:\\sys\\bin\\sapiapp.exe");
    const TUid KSapiAppUid(TUid::Uid(0xe6bc1167));

    T_CaInstaller *installer = NULL;
    installer = T_CaInstaller::NewL();
    CleanupStack::PushL(installer);
    TRAPD(err, installer->InstallL(KSapiPackageFileName));
    QCOMPARE(err, KErrNone);
    QTest::qWait(20000);
    
    Usif::TComponentId componentId(0);
    TRAP(err, componentId = installer->GetComponentIdL(KSapiAppFileName));
    QCOMPARE(err, KErrNone);
    
    appHandlerConstruction();
    
    CaEntry *entry = new CaEntry();
    
    entry->setEntryTypeName(caTypeApp);
    entry->setFlags(RemovableEntryFlag);
    entry->setAttribute(APPLICATION_UID_ATTRIBUTE_NAME,
        QString::number(KSapiAppUid.iUid));
    
    entry->setAttribute(caAttrComponentId,
        QString::number(componentId));
    
    TRAP(err, iAppHandler->execute(*entry, caCmdRemove));
    QCOMPARE(err, KErrNone);
    QTest::qWait(20000);
    delete entry;
    entry = NULL;
    
    // check again if installed, should be gone
    TRAP(err, componentId = installer->GetComponentIdL(KSapiAppFileName))
    QCOMPARE(err, KErrNone);
    QCOMPARE(componentId, 0);
    CleanupStack::PopAndDestroy(installer);

}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaHandler::appHandlerRemoveJavaApplication()
{
    const int javaAppUid = 0x101251BB;//
    bool removed(false);
    int error(KErrNone);

    TRAPD(err,
          QVERIFY(javaAppInstalled(javaAppUid));
          
          appHandlerConstruction();

          CaEntry *entry = new CaEntry();
          entry->setEntryTypeName(caTypeApp);
          entry->setFlags(RemovableEntryFlag);
          entry->setAttribute(APPLICATION_UID_ATTRIBUTE_NAME,
                  QString::number(javaAppUid));
          
          Usif::RSoftwareComponentRegistry scr;
          CleanupClosePushL(scr);
          User::LeaveIfError(scr.Connect());
          TUid uid;
          Usif::TComponentId componentId =
              scr.GetComponentIdForAppL( uid.Uid( javaAppUid ) );
            
          if (componentId > 0) {
              entry->setAttribute(caAttrComponentId, QString::number(componentId));
          }

          CleanupStack::PopAndDestroy(&scr);
          
          error = iAppHandler->execute(*entry, caCmdRemove);
          QTest::qWait(20000);
          delete entry;
          entry = NULL;
          )
    QVERIFY(!javaAppInstalled(javaAppUid));
    QCOMPARE(err, KErrNone);
    QCOMPARE(error, KErrNone);
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool T_CaHandler::javaAppInstalled(TInt32 aUid)
    {
    TBool result = EFalse;
    Usif::RSoftwareComponentRegistry scr;
    CleanupClosePushL(scr);
    scr.Connect();
    TUid uid;
    TInt err;
    Usif::TComponentId componentId( 0 );
    TRAP(err, componentId = 
            scr.GetComponentIdForAppL(
            uid.Uid( aUid ) ) )
    if (componentId > 0 && err == KErrNone)
        {
        result = ETrue;
        }
    CleanupStack::PopAndDestroy(&scr);
    return result;
    }


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaHandler::testCCaTaskList()
{
    RWsSession wsSession;
    User::LeaveIfError( wsSession.Connect() );
    CleanupClosePushL<RWsSession>( wsSession );

	CCaTaskList* taskList = CCaTaskList::NewL( wsSession );
	taskList->UpdateListL();
	QVERIFY(taskList->IsRootWindowGroup(-1) == EFalse);
	delete taskList;
    CleanupStack::PopAndDestroy( &wsSession );
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaHandler::appHandlerCreateInstance()
{
    QServiceManager serviceManager;
    CaAppHandlerPlugin plugin;
    QServiceFilter serviceFilter("com.nokia.homescreen.ICommandHandler");
    serviceFilter.setCustomAttribute("entryTypeName", "application");
    QList<QServiceInterfaceDescriptor> serviceInterfaceDescriptorList =
        serviceManager.findInterfaces(serviceFilter);
    int len = serviceInterfaceDescriptorList.size();
    QVERIFY(len>0);
    QServiceInterfaceDescriptor serviceInterfaceDescriptor =
        serviceInterfaceDescriptorList[0];
    QObject *handler = plugin.createInstance(
        serviceInterfaceDescriptor, NULL, NULL);
    QVERIFY(handler);
    delete handler;
}

QTEST_MAIN(T_CaHandler)