/*
* Copyright (c) 2007-2010 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: This module contains the implementation of RIAUpdateClient
* class member functions.
*
*/
//INCLUDES
#include <eikenv.h>
#include <apgcli.h>
#include <e32math.h>
#include "iaupdateclient.h"
#include "iaupdateclientdefines.h"
#include "iaupdatetools.h"
#include "iaupdatedebug.h"
// -----------------------------------------------------------------------------
// RIAUpdateClient::RIAUpdateClient
//
// -----------------------------------------------------------------------------
//
RIAUpdateClient::RIAUpdateClient()
: iPtr1( NULL, 0 ),
iPtr2( NULL, 0 ),
iPtr3( NULL, 0 )
{
}
// -----------------------------------------------------------------------------
// RIAUpdateClient::Open
//
// -----------------------------------------------------------------------------
//
TInt RIAUpdateClient::Open()
{
IAUPDATE_TRACE("[IAUPDATE] RIAUpdateClient::Open() begin");
TInt error( KErrNone );
if ( !iConnected )
{
TRAP( error, ConnectNewAppL( ServiceUid() ) );
if ( error == KErrNone )
{
iConnected = ETrue;
CEikonEnv* eikEnv = CEikonEnv::Static();
if ( eikEnv )
{
RWindowGroup owngroup;
iOwnWgId = eikEnv->RootWin().Identifier();
TPckg<TInt> wgId( iOwnWgId );
delete iData;
iData = NULL;
TRAP_IGNORE( iData = wgId.AllocL() );
TIpcArgs args;
args.Set( 0, iData );
SendReceive( IAUpdateClientDefines::EIAUpdateServerSendWgId, args );
}
}
}
IAUPDATE_TRACE_1("[IAUPDATE] RIAUpdateClient::Open() end error code: %d", error );
return error;
}
// -----------------------------------------------------------------------------
// RIAUpdateClient::OpenToBackroundAsync
//
// -----------------------------------------------------------------------------
//
TInt RIAUpdateClient::OpenToBackroundAsync( TRequestStatus& aStatus )
{
IAUPDATE_TRACE("[IAUPDATE] RIAUpdateClient::OpenToBackroundAsync() begin");
TInt error( KErrNone );
if ( !iConnected )
{
TRAP( error, StartNewAppToBackgroundL( ServiceUid(), aStatus ) );
}
IAUPDATE_TRACE_1("[IAUPDATE] RIAUpdateClient::OpenToBackroundAsync() end error code: %d", error );
return error;
}
// -----------------------------------------------------------------------------
// RIAUpdateClient::ConnectToApp
//
// -----------------------------------------------------------------------------
//
TInt RIAUpdateClient::ConnectToApp()
{
IAUPDATE_TRACE("[IAUPDATE] RIAUpdateClient::ConnectToApp() begin");
TInt error( KErrNone );
TName serverName;
ServerName(serverName, ServiceUid(), iDifferentiator);
TRAP( error,ConnectExistingByNameL( serverName ) );
if ( error == KErrNone )
{
iConnected = ETrue;
CEikonEnv* eikEnv = CEikonEnv::Static();
if ( eikEnv )
{
RWindowGroup owngroup;
iOwnWgId = eikEnv->RootWin().Identifier();
TPckg<TInt> wgId( iOwnWgId );
delete iData;
iData = NULL;
TRAP_IGNORE( iData = wgId.AllocL() );
TIpcArgs args;
args.Set( 0, iData );
SendReceive( IAUpdateClientDefines::EIAUpdateServerSendWgId, args );
}
}
IAUPDATE_TRACE_1("[IAUPDATE] RIAUpdateClient::ConnectToApp() end error code: %d", error );
return error;
}
// -----------------------------------------------------------------------------
// RIAUpdateClient::Close
//
// -----------------------------------------------------------------------------
//
void RIAUpdateClient::Close()
{
IAUPDATE_TRACE("[IAUPDATE] RIAUpdateClient::Close() begin");
// Let the parent handle closing.
REikAppServiceBase::Close();
iConnected = EFalse;
delete iData;
iData = NULL;
IAUPDATE_TRACE("[IAUPDATE] RIAUpdateClient::Close() end");
}
// -----------------------------------------------------------------------------
// RIAUpdateClient::CheckUpdates
//
// -----------------------------------------------------------------------------
//
TInt RIAUpdateClient::CheckUpdates( const CIAUpdateParameters& aUpdateParameters,
TInt& aAvailableUpdates,
TRequestStatus& aStatus )
{
IAUPDATE_TRACE("[IAUPDATE] RIAUpdateClient::CheckUpdates()");
// Inform the caller about the success of the request initializing.
return SendCheckUpdatesRequest( IAUpdateClientDefines::EIAUpdateServerCheckUpdates,
aUpdateParameters,
aAvailableUpdates,
aStatus );
}
// -----------------------------------------------------------------------------
// RIAUpdateClient::ShowUpdates
//
// -----------------------------------------------------------------------------
//
TInt RIAUpdateClient::ShowUpdates( const CIAUpdateParameters& aUpdateParameters,
TInt& aNumberOfSuccessfullUpdates,
TInt& aNumberOfFailedUpdates,
TInt& aNumberOfCancelledUpdates,
TRequestStatus& aStatus )
{
IAUPDATE_TRACE("[IAUPDATE] RIAUpdateClient::ShowUpdates()");
// Inform the caller about the success of the request initializing.
return SendUpdateRequest( IAUpdateClientDefines::EIAUpdateServerShowUpdates,
aUpdateParameters,
aNumberOfSuccessfullUpdates,
aNumberOfFailedUpdates,
aNumberOfCancelledUpdates,
aStatus );
}
// -----------------------------------------------------------------------------
// RIAUpdateClient::UpdateQuery
//
// -----------------------------------------------------------------------------
//
TInt RIAUpdateClient::UpdateQuery( TBool& aUpdateNow, TRequestStatus& aStatus )
{
IAUPDATE_TRACE("[IAUPDATE] RIAUpdateClient::UpdateQuery() begin");
TPckg<TBool> updateNow( aUpdateNow );
iPtr1.Set( updateNow );
TIpcArgs args;
args.Set( 1, &iPtr1 );
SendReceive( IAUpdateClientDefines::EIAUpdateServerShowUpdateQuery,
args,
aStatus );
IAUPDATE_TRACE("[IAUPDATE] RIAUpdateClient::UpdateQuery() begin");
return KErrNone;
}
// -----------------------------------------------------------------------------
// RIAUpdateClient::BroughtToForeground
//
// -----------------------------------------------------------------------------
//
void RIAUpdateClient::BroughtToForeground()
{
IAUPDATE_TRACE("[IAUPDATE] RIAUpdateClient::BroughtToForeground() begin");
if ( iConnected )
{
SendReceive( IAUpdateClientDefines::EIAUpdateServerToForeground );
}
IAUPDATE_TRACE("[IAUPDATE] RIAUpdateClient::BroughtToForeground() end");
}
// -----------------------------------------------------------------------------
// RIAUpdateClient::CancelAsyncRequest
//
// -----------------------------------------------------------------------------
//
void RIAUpdateClient::CancelAsyncRequest()
{
IAUPDATE_TRACE("[IAUPDATE] RIAUpdateClient::CancelAsyncRequest() begin");
// We suppose that an active object will
// wait for the cancellation to complete.
// So, let the server know that operation is cancelled.
// The server should set the correct status and complete
// the request of the active object. So, the cancellation
// can proceed to the end.
if ( iConnected )
{
SendReceive( IAUpdateClientDefines::EIAUpdateServerCancel );
}
IAUPDATE_TRACE("[IAUPDATE] RIAUpdateClient::CancelAsyncRequest() end");
}
// -----------------------------------------------------------------------------
// RIAUpdateClient::ServiceUid()
//
// -----------------------------------------------------------------------------
//
TUid RIAUpdateClient::ServiceUid() const
{
IAUPDATE_TRACE("[IAUPDATE] RIAUpdateClient::ServiceUid()");
return IAUpdateClientDefines::KIAUpdateServiceUid;
}
// -----------------------------------------------------------------------------
// RIAUpdateClient::SendCheckUpdatesRequest
//
// -----------------------------------------------------------------------------
//
TInt RIAUpdateClient::SendCheckUpdatesRequest( TInt aUpdateFunction,
const CIAUpdateParameters& aUpdateParameters,
TInt& aCount,
TRequestStatus& aStatus )
{
IAUPDATE_TRACE("[IAUPDATE] RIAUpdateClient::SendCheckUpdatesRequest() begin");
aStatus = KRequestPending;
delete iData;
iData = NULL;
TInt error( KErrNone );
TRAP( error,
IAUpdateTools::ExternalizeParametersL( iData,
aUpdateParameters ) );
IAUPDATE_TRACE_1("[IAUPDATE] error code: %d", error );
// Because this function does not leave,
// use error value to check if request can be done.
if ( error == KErrNone )
{
TPckg<TInt> count( aCount );
iPtr1.Set( count );
TIpcArgs args;
args.Set( 0, iData );
args.Set( 1, &iPtr1 );
// Start the asynchronous operation in the server side.
SendReceive( aUpdateFunction, args, aStatus );
}
// Inform the caller about the success of the request initializing.
IAUPDATE_TRACE("[IAUPDATE] RIAUpdateClient::SendCheckUpdatesRequest() begin");
return error;
}
// -----------------------------------------------------------------------------
// RIAUpdateClient::SendUpdateRequest
//
// -----------------------------------------------------------------------------
//
TInt RIAUpdateClient::SendUpdateRequest( TInt aUpdateFunction,
const CIAUpdateParameters& aUpdateParameters,
TInt& aNumberOfSuccessfullUpdates,
TInt& aNumberOfFailedUpdates,
TInt& aNumberOfCancelledUpdates,
TRequestStatus& aStatus )
{
IAUPDATE_TRACE("[IAUPDATE] RIAUpdateClient::SendUpdateRequest() begin");
aStatus = KRequestPending;
delete iData;
iData = NULL;
TInt error( KErrNone );
TRAP( error,
IAUpdateTools::ExternalizeParametersL( iData,
aUpdateParameters ) );
IAUPDATE_TRACE_1("[IAUPDATE] error code: %d", error );
// Because this function does not leave,
// use error value to check if request can be done.
if ( error == KErrNone )
{
TPckg<TInt> successCount( aNumberOfSuccessfullUpdates );
iPtr1.Set( successCount );
TPckg<TInt> failCount( aNumberOfFailedUpdates );
iPtr2.Set( failCount );
TPckg<TInt> cancelCount( aNumberOfCancelledUpdates );
iPtr3.Set( cancelCount );
TIpcArgs args;
args.Set( 0, iData );
args.Set( 1, &iPtr1 );
args.Set( 2, &iPtr2 );
args.Set( 3, &iPtr3 );
// Start the asynchronous operation in the server side.
SendReceive( aUpdateFunction, args, aStatus );
}
// Inform the caller about the success of the request initializing.
IAUPDATE_TRACE("[IAUPDATE] RIAUpdateClient::SendUpdateRequest() end");
return error;
}
// -----------------------------------------------------------------------------
// RIAUpdateClient::StartNewAppToBackgroundL
//
// -----------------------------------------------------------------------------
//
void RIAUpdateClient::StartNewAppToBackgroundL( TUid aAppUid, TRequestStatus& aStatus )
{
IAUPDATE_TRACE("[IAUPDATE] RIAUpdateClient::StartNewAppToBackgroundL() begin");
TName notUsed;
iDifferentiator = GenerateServerDifferentiatorAndName(notUsed, aAppUid);
RApaLsSession apa;
User::LeaveIfError(apa.Connect());
CleanupClosePushL(apa);
TApaAppInfo info;
User::LeaveIfError(apa.GetAppInfo(info, aAppUid));
CApaCommandLine* cmdLine = CApaCommandLine::NewLC();
cmdLine->SetExecutableNameL(info.iFullName);
cmdLine->SetServerRequiredL( iDifferentiator );
cmdLine->SetCommandL(EApaCommandBackground);
TThreadId notUsedId;
User::LeaveIfError(apa.StartApp(*cmdLine, notUsedId, &aStatus));
CleanupStack::PopAndDestroy(2, &apa); // cmdLine and apa
IAUPDATE_TRACE("[IAUPDATE] RIAUpdateClient::StartNewAppToBackgroundL() end");
}
void RIAUpdateClient::ServerName(TName& aServerName, TUid aAppServerUid, TUint aServerDifferentiator)
{
_LIT(KServerNameFormat, "%08x_%08x_AppServer");
aServerName.Format(KServerNameFormat, aServerDifferentiator, aAppServerUid);
}
TUint RIAUpdateClient::GenerateServerDifferentiatorAndName(TName& aServerName, TUid aAppServerUid)
{
TUint r;
FOREVER
{
r = Math::Random();
if (r==0)
continue;
ServerName(aServerName, aAppServerUid, r);
TFindServer find(aServerName);
TFullName fullName;
if (find.Next(fullName) == KErrNone)
continue;
break;
}
return r;
}