/*

 * 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 <SWInstDefs.h>

#include <PolicyEngineClient.h>

#include <PolicyEngineXACML.h>

#include <eikenv.h>

#include <hbapplication.h>

#include <apgwgnam.h>

#include <nsmldmconst.h>

#include <DevManInternalCRKeys.h>

#include <apgtask.h>

#include <apgwgnam.h>

#include "ampskeys.h"

#include "amprivateCRKeys.h"

#include "ApplicationManagementConst.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 "AMPreInstallApp.h"

#include "amview.h"

#include "appmgmtnotifier.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/");

//Package all the above together into a policy

CPolicyServer::TPolicy KApplicationManagementSecurityPolicy;

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

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

    iComp = aComponent;

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

RDEBUG_2( "ApplicationManagementServer DownloadComplete - start %d", errInstall);

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

                    {

                    iStorage->DeactivateL(*aComponent);

                    }

                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.

    iOMASCOMOEnabled = IsOMASCOMOEnabledL();

    m_Window->lower();

    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

            {

            RDEBUG( "CApplicationManagementServer::ASync Reporting Step 1" );

            // Get deployement component entries

            TInt internalid = aComponent->InternalId();

            RDEBUG( "CApplicationManagementServer::ASync Reporting Step 2" );

            TBuf8<256> targetURI;

            TDeploymentComponentState state = aComponent->State();

            RDEBUG( "CApplicationManagementServer::ASync Reporting Step 3" );

            if (state == EDCSDownload)

                {

                RDEBUG( "CApplicationManagementServer::ASync EDCSDownload Start" );

                targetURI.Append(KDownloadState);

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

                RDEBUG( "CApplicationManagementServer::ASync EDCSDownload End" );

                }

            else if (state == EDCSDelivered)

                {

                RDEBUG( "CApplicationManagementServer::ASync EDCSDelivered Start" );

                targetURI.Append(KDeliveredState);

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

                RDEBUG( "CApplicationManagementServer::ASync EDCSDelivered End" );

                }

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

                {

                RDEBUG( "CApplicationManagementServer::ASync EDCSActive Start" );

                targetURI.Append(KDeployedState);

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

                RDEBUG( "CApplicationManagementServer::ASync EDCSActive End" );

                }

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

            TInt iapidval = 2;

            TRAPD( err1, SmlHelper::GetDefaultIAPFromDMProfileL( iapid ) );

            if (err1 == KErrNone)

                {

                RDEBUG_2("Application Mgmt Server service::DownloadCompleteL iapid to : %d", iapid );

                }

            TInt index;

            iAMServerDB->SaveToDatabaseL(index, internalid, status,

                    targetURI, iapidval);

            RDEBUG( "CApplicationManagementServer::ASync SaveToDatabaseL completed" );

            EnableDMNetworkMonL(iapid, aServerId);

            }

        }

    int value = 0 ;

    int err = RProperty::Set(TUid::Uid(KOmaDMAppUid), KDownloadActive, value);

    RDEBUG_2("RProperty set (%d)", err  );

    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.Start();    

            }

        }

    aComponent->SetDriveSelectionStatus(false);

    RDEBUG( "ApplicationManagementServer DownloadComplete - end" );

    }

void CApplicationManagementServer::InstallationCancelled()

	{

		iInstaller.CancelOperation();

	}

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

// CApplicationManagementServer::IsOMASCOMOEnabledL()

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

TBool CApplicationManagementServer::IsOMASCOMOEnabledL()

    {

    RDEBUG( "CApplicationManagementServer::IsOMASCOMOEnabledL Start" );

    TInt adapterValue;

    CRepository *repository = CRepository::NewLC(

            KCRUidPrivateApplicationManagementKeys);

    repository->Get(KAMAdapterValue, adapterValue);

    CleanupStack::PopAndDestroy();

    RDEBUG( "CApplicationManagementServer::IsOMASCOMOEnabledL End" );

    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;

	  if (aErrorInstall == KStatusUserCancelled)

		status = KStatusUserCancelled;

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

    TInt err_val = repository->Set(KDevManEnableDMNetworkMon, retryenabled);

    RDEBUG_2( "CApplicationManagementServer::EnableDMNetworkMonL Retry enabled err: %d", err_val );

    RDEBUG_2( "CApplicationManagementServer::EnableDMNetworkMonL Retry enabled value: %d", retryenabled );

    err_val = repository->Set(KDevManIapIdKey, iapid);

    RDEBUG_2( "CApplicationManagementServer::EnableDMNetworkMonL devmaniapid: %d", err_val );

    RDEBUG_2( "CApplicationManagementServer::EnableDMNetworkMonL iap id: %d", iapid );

    err_val = repository->Set(KDevManServerIdKey, *aServerId);

    RDEBUG_2( "CApplicationManagementServer::EnableDMNetworkMonL serveridkey: %d", err_val );

    TBuf<256> buf1;

    buf1.Copy(*aServerId);

    RDEBUG_2( "Server ID -  '%S'", &buf1);

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

    }

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

// CApplicationManagementServer::CApplicationManagementServer

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

inline CApplicationManagementServer::CApplicationManagementServer() :

    CPolicyServer(0, KApplicationManagementSecurityPolicy, ESharableSessions)

    {

    }

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

// CApplicationManagementServer::AddSession()

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

void CApplicationManagementServer::AddSession()

    {

    // A new session is being created

    RDEBUG( "ApplicationManagementServer: CApplicationManagementServer::AddSession" );

    ++iSessionCount;

    // Cancel the shutdown timer if it was running

    iShutdown.Cancel();

    }

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

// CApplicationManagementServer::DropSession()

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

void CApplicationManagementServer::DropSession()

    {

    // A session is being destroyed

    RDEBUG( "ApplicationManagementServer: CApplicationManagementServer::DropSession" );

    // Start the shutdown timer if it is the last session

    if (--iSessionCount == 0)

        {

        if (iDownloadMngr->DownloadCount() > 0)

            {

            RDEBUG( "ApplicationManagementServer: CApplicationManagementServer::DropSession download in progress" );

            }

        else

            {

            iShutdown.Start();

            }

        }

    }

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

// CApplicationManagementServer::AddDownloadL( CDeploymentComponent *aComponent )

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

void CApplicationManagementServer::AddDownloadL(

        CDeploymentComponent *aComponent)

    {

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

    RDEBUG( "CApplicationManagementServer::AddDownloadL Start" );

    iDownloadMngr->AddDownloadL(aComponent);

    RDEBUG( "CApplicationManagementServer::AddDownloadL End" );

    }

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

// CApplicationManagementServer

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

CServer2* CApplicationManagementServer::NewL(HbMainWindow *mainWindow)

    {

    //specifies all connect attempts should pass

    KApplicationManagementSecurityPolicy.iOnConnect

            = CPolicyServer::EAlwaysPass;

    KApplicationManagementSecurityPolicy.iRangeCount

            = KApplicationManagementRangeCount; //number of ranges                                   

    KApplicationManagementSecurityPolicy.iRanges

            = KApplicationManagementRanges;

    KApplicationManagementSecurityPolicy.iElementsIndex

            = KApplicationManagementSecurityElementsIndex;

    KApplicationManagementSecurityPolicy.iElements

            = KApplicationManagementSecurityElements;

    RDEBUG( "ApplicationManagementServer: CApplicationManagementServer::NewLC" );

    CApplicationManagementServer* self =

            new (ELeave) CApplicationManagementServer;

    CleanupStack::PushL(self);

    self->ConstructL(mainWindow);

    CleanupStack::Pop();

    return self;

    }

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

// CApplicationManagementServer::~CApplicationManagementServer

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

CApplicationManagementServer::~CApplicationManagementServer()

    {

    RDEBUG_3("CApplicationManagementServer::~CApplicationManagementServer 0x%X - 0x%X", reinterpret_cast<TUint>(this ),

            reinterpret_cast<TUint>(this)+sizeof( CApplicationManagementServer ) );

    FeatureManager::UnInitializeLib();

    iInstaller.Close();

    delete iStorage;

    delete iUtility;

    delete iAMServerDB;

    RProperty::Delete(KUidPSApplicationManagementKeys, KAMServerUIEnabled);

    RProperty::Delete(KUidPSApplicationManagementKeys, KAMOperationNonSilent);

    RProperty::Delete(KUidPSApplicationManagementKeys, KSyncNotifier);

    RProperty::Delete(KUidPSApplicationManagementKeys, KDMUINotClosed);

    iInstallFile.Close();

    iInstallRFs.Close();

    delete iDownloadMngr;

    }

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

// CApplicationManagementServer::HandleAllClientsClosed

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

void CApplicationManagementServer::HandleAllClientsClosed()

    {

    // Do Nothing

    RDEBUG( "CApplicationManagementServer::HandleAllClientsClosed" );

    }

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

// CApplicationManagementServer::ConstructL

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

void CApplicationManagementServer::ConstructL(HbMainWindow* aWindow)

    {

    // 2nd phase construction - ensure the timer and server objects are running

    RDEBUG( "CApplicationManagementServer::ConstructL - Start" );

    iOMASCOMOEnabled = ETrue;

    mUserCancelled = 0;