/*
* 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:   VideoOperatorServicePrivate class implementation.
*
*/

// Version : 

// INCLUDE FILES
#include "videocollectiontrace.h"
#include "videooperatorservice_p.h"
#include "videocollectionviewutils.h"
#include "videocollectioncenrepdefs.h"

#include <qdesktopservices.h>
#include <qurl.h>
#include <e32base.h>
#include <coemain.h>
#include <apgcli.h>
#include <apaid.h>
#include <apgtask.h>
#include <xqappmgr.h>

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
VideoOperatorServicePrivate::VideoOperatorServicePrivate() :
    mProcess(0),
    mAppMgr(0)
{
    
}

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
VideoOperatorServicePrivate::~VideoOperatorServicePrivate()
{   
    if(mProcess)
    {
        disconnect(mProcess, SIGNAL(finished(int, QProcess::ExitStatus)),
                this, SLOT(processFinished(int, QProcess::ExitStatus)));
        
        disconnect(mProcess, SIGNAL(error(QProcess::ProcessError)), 
                this, SLOT(processError(QProcess::ProcessError)));        
        mProcess->close();
    }
    delete mProcess;
    mProcess = 0;
    delete mAppMgr;
    mAppMgr = 0;
}

// ---------------------------------------------------------------------------
// load
// ---------------------------------------------------------------------------
//
bool VideoOperatorServicePrivate::load(int titleKey, int iconKey, int serviceUriKey, int appUidKey)
{
    FUNC_LOG;
    VideoCollectionViewUtils& utils = VideoCollectionViewUtils::instance();
    
    mTitle = utils.getCenRepStringValue(titleKey);
    mIconResource = utils.getCenRepStringValue(iconKey);
    mServiceUri = utils.getCenRepStringValue(serviceUriKey);
    mApplicationUid = utils.getCenRepIntValue(appUidKey);
    
    // Icon is required, either service uri or application uid is required.
    if(mIconResource.isEmpty() || (mServiceUri.isEmpty() && mApplicationUid <= 0))
    {
        return false;
    }
    
    return true;
}

// ---------------------------------------------------------------------------
// title
// ---------------------------------------------------------------------------
//
const QString VideoOperatorServicePrivate::title() const
{
    return mTitle;
}

// ---------------------------------------------------------------------------
// iconResource
// ---------------------------------------------------------------------------
//
const QString VideoOperatorServicePrivate::iconResource() const
{
    return mIconResource;
}

// ---------------------------------------------------------------------------
// launchService
// ---------------------------------------------------------------------------
//
void VideoOperatorServicePrivate::launchService()
{
    FUNC_LOG;
    
    if(!mServiceUri.isEmpty())
    {
        INFOQSTR_1("VideoOperatorServicePrivate::launchService() starting url: %S", mServiceUri);
        launchUrl(mServiceUri);
    }
    else
    {
        INFO_1("VideoOperatorServicePrivate::launchService() starting application 0x%x", mApplicationUid);
        TRAPD(err, startApplicationL(TUid::Uid(mApplicationUid)));
        if(err)
        {
            INFO_1("VideoOperatorServicePrivate::launchService() failed to start, error: %d", err);
        }
    }
}

// ---------------------------------------------------------------------------
// getApplicationFilenameL
// ---------------------------------------------------------------------------
//
QString VideoOperatorServicePrivate::getApplicationFilenameL(const TUid uid)
{
    FUNC_LOG;

    // 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);
    RApaLsSession appArcSession;
    User::LeaveIfError(appArcSession.Connect());
    CleanupClosePushL<RApaLsSession>(appArcSession);

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

    QString fullName((QChar*)appInfo->iFullName.Ptr(), appInfo->iFullName.Length()); 
    
    CleanupStack::PopAndDestroy(&appArcSession);
    CleanupStack::PopAndDestroy(appInfo);
    
    return fullName;
}

// ---------------------------------------------------------------------------
// bringApplicationToForeground
// ---------------------------------------------------------------------------
//
bool VideoOperatorServicePrivate::bringApplicationToForeground(const TUid uid)
{
    FUNC_LOG;
    
    CCoeEnv* coe = CCoeEnv::Static();
    bool ret = false;
    if(coe)
    {
        TApaTaskList taskList(coe->WsSession());
        TApaTask task(taskList.FindApp(uid));
        
        if(task.Exists())
        {
            INFO("VideoOperatorServicePrivate::processFinished() task found.");
            task.BringToForeground();
            ret = true;
        }
    }
    return ret;
}

// ---------------------------------------------------------------------------
// startApplicationL
// ---------------------------------------------------------------------------
//
void VideoOperatorServicePrivate::startApplicationL(const TUid uid)
{
    FUNC_LOG;
    
    // Process handle already exists, try to bring app to foreground.
    if(mProcess)
    {
        if(bringApplicationToForeground(uid))
        {
            // App brought to foreground, all done.
            return;
        }
        // Application is not running, cleanup previous process.
        disconnect(mProcess, SIGNAL(finished(int, QProcess::ExitStatus)),
                this, SLOT(processFinished(int, QProcess::ExitStatus)));
        
        disconnect(mProcess, SIGNAL(error(QProcess::ProcessError)), 
                this, SLOT(processError(QProcess::ProcessError)));

        delete mProcess;
        mProcess = 0;
    }
    
    // Create new process and start it.
    mProcess = new QProcess();

    if(!connect(mProcess, SIGNAL(finished(int, QProcess::ExitStatus)),
            this, SLOT(processFinished(int, QProcess::ExitStatus)), Qt::UniqueConnection) ||
       !connect(mProcess, SIGNAL(error(QProcess::ProcessError)), 
            this, SLOT(processError(QProcess::ProcessError)), Qt::UniqueConnection))
    {
        INFO("VideoOperatorServicePrivate::startApplicationL() failed to connect signals");
        User::Leave(KErrGeneral);
    }

    QString appName = getApplicationFilenameL(uid);
    if(!appName.isEmpty())
    {
        mProcess->start(appName);
    }
}

// ---------------------------------------------------------------------------
// launchUrl
// ---------------------------------------------------------------------------
//
void VideoOperatorServicePrivate::launchUrl(QString url)
{
    if(!mAppMgr)
    {
        mAppMgr = new XQApplicationManager();
    }
    
    XQAiwRequest *request = mAppMgr->create(QUrl(url));
    if(!request)
    {
        INFO("VideoOperatorServicePrivate::launchUrl() handler was not found!");
        return;
    }

    // Set function parameters
    QList<QVariant> args;
    args << url;
    request->setArguments(args);
    request->setEmbedded(true);
    // Send the request
    bool res = request->send();
    if(!res)
    {
        // Request failed.
        int error = request->lastError();
        INFO_1("VideoOperatorServicePrivate::launchUrl() send failed with error: %d", error);
    }

    delete request;
}

// ---------------------------------------------------------------------------
// processFinished
// ---------------------------------------------------------------------------
//
void VideoOperatorServicePrivate::processFinished(int exitCode, QProcess::ExitStatus exitStatus)
{
    Q_UNUSED(exitCode);
    Q_UNUSED(exitStatus);
    INFO_2("VideoOperatorServicePrivate::processFinished() code: %d, status: %d", exitCode, exitStatus);
}

// ---------------------------------------------------------------------------
// processError
// ---------------------------------------------------------------------------
//
void VideoOperatorServicePrivate::processError(QProcess::ProcessError error)
{
    Q_UNUSED(error);
    INFO_1("VideoOperatorServicePrivate::processError() error: %d", error);
}

// End of file.