/*

 * Copyright (c) 2000 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: Implementation of applicationmanagement components

 *

 */

#define __INCLUDE_CAPABILITY_NAMES__

#include <e32svr.h>

#include <badesca.h>

#include <e32cmn.h>

#include <bautils.h> 

#include <featmgr.h>

#include <imcvcodc.h>

#include <uikon.hrh>

#include <e32property.h>

#include "ApplicationManagementConst.h"

#include "ampskeys.h"

#include <SWInstDefs.h>

#include "amprivateCRKeys.h"

#include <PolicyEngineClient.h>

#include <PolicyEngineXACML.h>

#include <pathinfo.h>

#include <driveinfo.h>

#include "ApplicationManagementCommon.h"

#include "ApplicationManagementClientServer.h"

#include "ApplicationManagementServer.h"

#include "AMDeploymentComponent.h"

#include "amsmlhelper.h"

#include "ApplicationManagementUtility.h"

#include "ApplicationManagementUtilityFactory.h"

#include "debug.h"

#include "coemain.h"

#include <aknnotewrappers.h>

#include "SyncService.h"

#include "AMPreInstallApp.h"

#include <DevManInternalCRKeys.h>

using namespace NApplicationManagement;

#ifdef __AM_CONNECT_INSTALLER_ONSTARTUP_	

#pragma message("AM Connecting installer at startup")

#else

#pragma message("AM Connecting installer when needed")

#endif

// Needed only for jad+jar installation  

_LIT( KInstallDir, "c:\\temp\\" );

_LIT8(KMIDletJarURL, "MIDlet-Jar-URL");

//OMA SCOMO Specific

_LIT8(KDownloadState, "./SCOMO/Download/");

_LIT8(KDeliveredState, "./SCOMO/Inventory/Delivered/");

_LIT8(KDeployedState, "./SCOMO/Inventory/Deployed/");

// ------------------------------------------------------------------------------------------------

// CShutDown::CShutdown()

// ------------------------------------------------------------------------------------------------

inline CShutdown::CShutdown() :

    CTimer(-1)

    {

    CActiveScheduler::Add(this);

    }

// ------------------------------------------------------------------------------------------------

// CShutDown::ConstructL()

// ------------------------------------------------------------------------------------------------

inline void CShutdown::ConstructL()

    {

    CTimer::ConstructL();

    }

// ------------------------------------------------------------------------------------------------

// CShutDown::Start()

// ------------------------------------------------------------------------------------------------

inline void CShutdown::Start()

    {

    RDEBUG( "ApplicationManagementServer: starting shutdown timeout" );

    After(KApplicationManagementShutdownDelay);

    }

// ------------------------------------------------------------------------------------------------

// CShutDown::RunL()

// ------------------------------------------------------------------------------------------------

void CShutdown::RunL()

    {

    RDEBUG( "ApplicationManagementServer timeout ... closing" );

    CActiveScheduler::Stop();

    }

// ------------------------------------------------------------------------------------------------

// CShutDown::Start()

// ------------------------------------------------------------------------------------------------

inline void CShutdown::Stop()

    {

    RDEBUG( "ApplicationManagementServer: Stop" );

    CActiveScheduler::Stop();

    }

// ------------------------------------------------------------------------------------------------

// CApplicationManagementServer::CreateServiceL()

// ------------------------------------------------------------------------------------------------

CApaAppServiceBase* CApplicationManagementServer::CreateServiceL(

        TUid aServiceType) const

    {

    RDEBUG( "ApplicationManagementServer CreateServiceL" );

    if (aServiceType.iUid == KAMServiceUid)

        {

        return ((CApaAppServiceBase*) (new (ELeave) CApplicationManagementSession));

        }

    else

        {

        return CAknAppServer::CreateServiceL(aServiceType);

        }

    }

// ------------------------------------------------------------------------------------------------

// CApplicationManagementServer::SendServerToBackground()

// ------------------------------------------------------------------------------------------------

void CApplicationManagementServer::SendServerToBackground()

    {

    RDEBUG( "ApplicationManagementServer SendServerToBackground - Start " );

    TApaTaskList taskList(CEikonEnv::Static()->WsSession() );

    TApaTask task = taskList.FindApp(TUid::Uid(KAppMgmtServerUid));

     TInt id = CEikonEnv::Static()->RootWin().Identifier();

    RDEBUG_2( "CApplicationManagementServer:::SendServerToBackground %d", id );

    task.SetWgId(id);

    if (task.Exists())

        {

	RDEBUG( "ApplicationManagementServer SendServerToBackground - Start 1" );

        task.SendToBackground();

        }

    RDEBUG( "ApplicationManagementServer SendServerToBackground - End " );

    TInt amServerEnabled = 0;

    RProperty::Set(KUidPSApplicationManagementKeys, KAMServerUIEnabled,

            amServerEnabled);

    RDEBUG( "ApplicationManagementServer SendServerToBackground - End 2 " );

    }

// ------------------------------------------------------------------------------------------------

// CApplicationManagementServer::BringServertoForeground()

// ------------------------------------------------------------------------------------------------

void CApplicationManagementServer::BringServertoForeground()

    {

    RDEBUG( "CApplicationManagementServer:::BringServertoForeground " );

    TApaTaskList taskList(CEikonEnv::Static()->WsSession() );

    TApaTask task = taskList.FindApp(TUid::Uid(KAppMgmtServerUid));

    TInt id = CEikonEnv::Static()->RootWin().Identifier();

    RDEBUG_2( "CApplicationManagementServer:::BringServertoForeground %d", id );

    task.SetWgId(id);

    if (task.Exists())

        {

	RDEBUG( "ApplicationManagementServer SendServerToBackground - BringServertoForeground " );

        task.BringToForeground();

        }

    }

// ------------------------------------------------------------------------------------------------

// CApplicationManagementServer::BringServertoForeground()

// ------------------------------------------------------------------------------------------------

void CApplicationManagementServer::BringDMUItoForeground()

    {

    RDEBUG( "ApplicationManagementServer DownloadComplete - DM UI Broughtto foreground Start " );

    TApaTaskList taskList(CEikonEnv::Static()->WsSession() );

    TApaTask task = taskList.FindApp(KPSUidNSmlDMSyncApp);

    const TInt id = task.WgId();

    task.SetWgId(id);

    RDEBUG_2( "CApplicationManagementServer:::BringDMUItoForeground %d", id );

    if (task.Exists())

        {

        RDEBUG( "ApplicationManagementServer DownloadComplete - DM UI Broughtto foreground " );

        task.BringToForeground();

        }

    }

// ------------------------------------------------------------------------------------------------

// CApplicationManagementServer::ComponentDownloadComplete()

// ------------------------------------------------------------------------------------------------

void CApplicationManagementServer::ComponentDownloadComplete(

        CDeploymentComponent *aComponent, TInt iapid, HBufC8 *aServerId)

    {

    TInt err = KErrNone;

    TRAP( err, DownloadCompleteL( aComponent, iapid, aServerId ));

    }

// ------------------------------------------------------------------------------------------------

// CApplicationManagementServer::DownloadCompleteL()

// ------------------------------------------------------------------------------------------------

void CApplicationManagementServer::DownloadCompleteL(

        CDeploymentComponent *aComponent, TInt iapid, HBufC8 *aServerId)

    {

    RDEBUG( "ApplicationManagementServer DownloadComplete - start" );

    __ASSERT_DEBUG( aComponent, User::Invariant() );

    iStorage->UpdateL( *aComponent);

    TInt errdownload = KErrNone;

    TInt errInstall = KErrNone;

    TInt status = KStatusSuccess;

    if ( !aComponent->DownloadFailed() )

        {

        CDeploymentComponent *old = DoDataUpdateCheckL( *aComponent);

        TDownloadTarget trgt = aComponent->DownloadTarget();

        switch (trgt)

            {

            case EDeliver:

                {

                break;

                }

            case EInstall:

            case EInstallAndActivate:

                {

                TRAP(errInstall,DoTheInstallL( *aComponent));

                if (trgt == EInstall && errInstall == KErrNone)

                    {

                    iStorage->DeactivateL( *aComponent);

                    }

                /* to avoid duplicates in deployed tree if user delivered upgrade package

                 * by using "Install/InstallActivate" operation. if upgrade package is delivered 

                 * by Update/UpdateandActivate" , this been handled in next switch case

                 */

                break;

                }

            case EUpdate:

            case EUpdateAndActivate:

                {

                if (old)

                    {

                    FullUpdateL( *aComponent, *old);

                    if (trgt == EUpdate)

                        {

                        iStorage->DeactivateL( *aComponent);

                        }

                    }

                break;

                }

            default:

                {

                break;

                }

            }

        }

    else

        {

        errdownload = aComponent->DownloadStatus();

        }

    RDEBUG( "ApplicationManagementServer DownloadComplete - Start Send to background" );

    //Download Completed/ Failed or installation success/ failure Send server to Background.

    SendServerToBackground();

    // Bring DM UI to foreground provided operation is in non silent mode.

    TInt operNonSilent = KErrNotFound;

    RProperty::Get(KUidPSApplicationManagementKeys, KAMOperationNonSilent,

            operNonSilent);

    if (operNonSilent==1 || operNonSilent==KErrNotFound)

        {

        RDEBUG( "ApplicationManagementServer DownloadComplete - DM UI Bring " );

        BringDMUItoForeground();

        }

    iOMASCOMOEnabled = IsOMASCOMOEnabledL();

    if (iOMASCOMOEnabled)

        {

				status = GetErrorStatus(errdownload,errInstall); 

        TInt ASyncSupported = -1;

        CRepository *repository = CRepository::NewLC( KUidPSApplicationManagementKeys );

        repository->Get(KAsyncEnabled, ASyncSupported);

        CleanupStack::PopAndDestroy();

        // For Sync Reporting

        if (!ASyncSupported)

            {

            // Update Central Repository with proper error code for Sync

            CRepository *repository= CRepository::NewLC ( KUidPSApplicationManagementKeys ) ;

            repository->Set(KAMSyncStatus, status);

            CleanupStack::PopAndDestroy();

            RProperty counter;

            TInt r=counter.Attach(KUidPSApplicationManagementKeys,

                    KSyncNotifier, EOwnerThread);

            User::LeaveIfError(r);

            TInt err = counter.Set(KErrCancel);

            User::LeaveIfError(err);

            counter.Close();

            }

        else// Do AsyncReporting

            {

            // Get deployement component entries

            TInt internalid = aComponent->InternalId();

            TBuf8<256> targetURI;

            TDeploymentComponentState state = aComponent->State();

            if (state == EDCSDownload)

                {

                targetURI.Append(KDownloadState);

                targetURI.Append(aComponent->UserId());

                }

            else

                if (state == EDCSDelivered)

                    {

                    targetURI.Append(KDeliveredState);

                    targetURI.Append(aComponent->UserId());

                    }

                else

                    if (state == EDCSActive|| state == EDCSInactive)

                        {

                        targetURI.Append(KDeployedState);

                        targetURI.Append(aComponent->UserId());

                        }

            //Save Entry to database with status and target URI of deployment component

            TInt index;

            iAMServerDB->SaveToDatabaseL(index, internalid, status,

                    targetURI, iapid);

            EnableDMNetworkMonL(iapid, aServerId);

            }

        }

    if (iDownloadMngr->DownloadCount() == 0)

        {

        RDEBUG_2( "CApplicationManagementServer::ConstructL - ERROR leaving cannot connect installer: %d", iSessionCount );

        // Is session count is not modified whenever there is error then at the end of download complete decrement

        //  the session count.

        if(status != KStatusSuccess && iSessionCount != 0 )

            {

            iSessionCount--; 

            }

        if (iSessionCount == 0)

            {  

		       iShutdown.Stop();

            }

        }

    RDEBUG( "ApplicationManagementServer DownloadComplete - end" );

    }

// ------------------------------------------------------------------------------------------------

// CApplicationManagementServer::IsOMASCOMOEnabledL()

// ------------------------------------------------------------------------------------------------

TBool CApplicationManagementServer::IsOMASCOMOEnabledL()

    {

    TInt adapterValue;

    CRepository *repository = CRepository::NewLC ( KCRUidPrivateApplicationManagementKeys ) ;

    repository->Get(KAMAdapterValue, adapterValue);

    CleanupStack::PopAndDestroy();

    if(adapterValue ==0 || adapterValue == 1)

     return EFalse;

    else

     return ETrue;

    }

// ------------------------------------------------------------------------------------------------

// CApplicationManagementServer::GetErrorStatus()

// ------------------------------------------------------------------------------------------------

TInt CApplicationManagementServer::GetErrorStatus(TInt aErrorDownload, TInt aErrorInstall)

{

	       TInt status = KStatusSuccess;

	       if (aErrorDownload!=KErrNone)

                {

                if (aErrorDownload == KStatusUserCancelled || aErrorDownload

                        == KStatusDowloadFailedOOM || aErrorDownload

                         == KStatusUnSupportedEnvironment || aErrorDownload 

                        ==KStatusAlternateDownldAuthFail || aErrorDownload == KStatusAltDowldUnavailable)

                    {

                    status = aErrorDownload;

                    }

                else

                    status = KStatusDownloadFailed;

                }

            else

                if (aErrorInstall!=KErrNone)

                    {

                    if (aErrorInstall == SwiUI::KSWInstErrSecurityFailure)

                        status = KStatusPkgValidationFailed;

                    if (aErrorInstall == SwiUI::KSWInstErrInsufficientMemory)

                        status = KStatusInstallFailedOOM;

                    else

                        status = KStatusInstallFailed;

                    }

           return status;

}

// ------------------------------------------------------------------------------------------------

// CApplicationManagementServer::EnableDMNetworkMonL()

// ------------------------------------------------------------------------------------------------

void CApplicationManagementServer::EnableDMNetworkMonL(TInt iapid, HBufC8 *aServerId)

{

						TInt retryenabled = 1;

						_LIT( KNetMon,"\\dmnetworkmon.exe" );

            // Enable DM Network Monitoring for retry of Generic alert in case of N/W loss

            CRepository *repository= CRepository::NewLC ( KCRUidDeviceManagementInternalKeys );

            repository->Set(KDevManEnableDMNetworkMon, retryenabled);

            repository->Set(KDevManServerIdKey, *aServerId);

            repository->Set(KDevManIapIdKey, iapid);

            CleanupStack::PopAndDestroy();

						// create NetMon EXE

            RProcess rp;

            TInt err = rp.Create(KNetMon,KNullDesC);

            User::LeaveIfError(err);

            TRequestStatus stat;

            rp.Rendezvous(stat);

            if (stat!=KRequestPending)

              rp.Kill(0);     // abort startup

            else

              rp.Resume();    // logon OK - start the server

            TInt r=(rp.ExitType()==EExitPanic) ? KErrGeneral : stat.Int();

                        rp.Close();

}