--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/terminalsecurity/SCP/DmEventNotifier/src/DmEventScheduler.cpp Thu Dec 17 09:07:52 2009 +0200
@@ -0,0 +1,511 @@
+/*
+ * 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: This class implements the condition based schedule.
+ *
+ */
+//System includes
+#include <eikenv.h>
+#include <e32property.h>
+#include <centralrepository.h>
+
+//User includes
+#include "DmEventScheduler.h"
+#include "DmEventNotifierCommon.h"
+#include "DmEventNotifierInternal.h"
+#include "SwApplicationService.h" //Software service
+#include "JavaApplicationService.h" //Java service
+#include "MMCService.h" //MMC service
+#include "DmEventNotifierDebug.h"
+
+#include "SCPEventHandler.h" // dll for event handling (viz: uninstallation)
+
+// ====================== MEMBER FUNCTIONS ===================================
+
+// ---------------------------------------------------------------------------
+// CDmEventScheduler::CDmEventScheduler()
+// ---------------------------------------------------------------------------
+CDmEventScheduler::CDmEventScheduler()
+ {
+ }
+
+// ---------------------------------------------------------------------------
+// CDmEventScheduler::~CDmEventScheduler()
+// ---------------------------------------------------------------------------
+CDmEventScheduler::~CDmEventScheduler()
+ {
+ FLOG(_L("CDmEventScheduler::~CDmEventScheduler >>"));
+
+ iScheduler.Close();
+
+ iServices.DeleteAll();
+ iServices.Reset();
+
+ FLOG(_L("CDmEventScheduler::~CDmEventScheduler <<"));
+ }
+
+
+// ---------------------------------------------------------------------------
+// CDmEventScheduler::NewL()
+// ---------------------------------------------------------------------------
+CDmEventScheduler* CDmEventScheduler::NewL()
+ {
+ FLOG(_L("CDmEventScheduler::NewL >>"));
+
+ CDmEventScheduler* self = new (ELeave) CDmEventScheduler();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop();
+
+ FLOG(_L("CDmEventScheduler::NewL <<"));
+ return self;
+ }
+
+CDmEventScheduler* CDmEventScheduler::NewLC()
+ {
+ FLOG(_L("CDmEventScheduler::NewLC >>"));
+
+ CDmEventScheduler* self = CDmEventScheduler::NewL();
+ CleanupStack::PushL(self);
+
+ FLOG(_L("CDmEventScheduler::NewLC <<"));
+ return self;
+ }
+
+// ---------------------------------------------------------------------------
+// CDmEventScheduler::ConstructL()
+// ---------------------------------------------------------------------------
+void CDmEventScheduler::ConstructL()
+ {
+ FLOG(_L("CDmEventScheduler::ConstructL >>"));
+
+ __LEAVE_IF_ERROR(iScheduler.Connect());
+
+ TFileName handler(KDmEventNotifierExe);
+
+ User::LeaveIfError(iScheduler.Register(handler, CActive::EPriorityStandard));
+
+ iServices[ESoftwareService] = CSwApplicationService::NewL();
+
+ iServices[EJavaService] = CJavaApplicationService::NewL();
+
+ iServices[EMmcService] = CMmcService::NewL();
+
+ FLOG(_L("CDmEventScheduler::ConstructL <<"));
+ }
+
+// ---------------------------------------------------------------------------
+// CDmEventScheduler::CreateConditionScheduleL()
+// ---------------------------------------------------------------------------
+void CDmEventScheduler::CreateConditionScheduleL(CDmEventServiceBase* aService)
+ {
+ FLOG(_L("CDmEventScheduler::CreateConditionSchedule >>"));
+
+ //Create new schedule
+ TInt err(KErrNone);
+ TBool schenabled (EFalse);
+ TSchedulerItemRef conditionScheduleHandle;
+ TTsTime defaultTime;
+ TTime time;
+ time.HomeTime();
+ time = time.operator+(TTimeIntervalYears(10)); //Schedule will automatically expire after 10 years!
+ defaultTime.SetLocalTime( time );
+ TInt newConditionTaskId = -1;
+
+ if (aService == NULL)
+ {
+
+ TRAP(err, DeleteScheduleL());
+ FLOG(_L("Deleted existing schedule, err = %d"),err);
+
+
+ //Performing for Software Installer
+ FLOG(_L("Registering for Software Installer..."));
+ if (iServices[ESoftwareService]->IsKeyValid())
+ {
+ CSchConditionArray* aConditions;
+
+ aConditions = CreateConditionLC(iServices[ESoftwareService]);
+
+ err = CreateConditionScheduleWithTaskL(iConditionScheduleHandle,
+ iScheduler, defaultTime, newConditionTaskId, aConditions, iServices[ESoftwareService] );
+
+ schenabled = (KErrNone == err);
+ CleanupStack::PopAndDestroy(); //aConditions
+ }
+ else
+ {
+ FLOG(_L("Can't read PS key, hence not registering!"));
+ }
+ //Performing for Java Installer
+ FLOG(_L("Registering for Java Installer..."));
+ if (iServices[EJavaService]->IsKeyValid())
+ {
+ CSchConditionArray* aConditions;
+
+ aConditions = CreateConditionLC(iServices[EJavaService]);
+
+ err = CreateConditionScheduleWithTaskL(iConditionScheduleHandle,
+ iScheduler, defaultTime, newConditionTaskId, aConditions, iServices[EJavaService] );
+
+ schenabled = (KErrNone == err);
+ CleanupStack::PopAndDestroy(); //aConditions
+ }
+ else
+ {
+ FLOG(_L("Can't read PS key, hence not registering!"));
+ }
+
+ //Performing for Mmc observer
+ FLOG(_L("Registering for Mmc observer..."));
+ if (iServices[EMmcService]->IsKeyValid())
+ {
+ CSchConditionArray* aConditions;
+
+ aConditions = CreateConditionLC(iServices[EMmcService]);
+
+ err = CreateConditionScheduleWithTaskL(iConditionScheduleHandle,
+ iScheduler, defaultTime, newConditionTaskId, aConditions, iServices[EMmcService] );
+
+ schenabled = (KErrNone == err);
+ CleanupStack::PopAndDestroy(); //aConditions
+
+ if (err == KErrNone)
+ {
+ //Set cenrep value for mmc accordingly
+
+ CMmcService *ptr = (CMmcService *) iServices[EMmcService];
+ ptr->UpdateMmcStatus();
+ }
+ }
+ else
+ {
+ FLOG(_L("Can't read PS key, hence not registering!"));
+ }
+ }
+ else
+ {
+ FLOG(_L("Scheduling for only the expired service"));
+ CSchConditionArray* aConditions;
+
+ aConditions = CreateConditionLC(aService);
+
+ err = CreateConditionScheduleWithTaskL(iConditionScheduleHandle,
+ iScheduler, defaultTime, newConditionTaskId, aConditions, aService );
+
+ CleanupStack::PopAndDestroy(); //aConditions
+
+ schenabled = (KErrNone == err);
+ }
+
+ SetScheduleEnabledL(schenabled);
+
+ FLOG(_L("CDmEventScheduler::CreateConditionSchedule, error = %d <<"), err);
+ }
+
+// ---------------------------------------------------------------------------
+// CDmEventScheduler::WaitAndCreateConditionScheduleL()
+// ---------------------------------------------------------------------------
+void CDmEventScheduler::WaitAndCreateConditionScheduleL(TName aTaskName)
+ {
+ FLOG(_L("CDmEventScheduler::WaitAndCreateConditionScheduleL >>"));
+
+ SetScheduleEnabledL(EHandlerNotRegistered);
+
+ CDmEventServiceBase* service = FindExpiredService(aTaskName);
+ // CleanupStack::PushL(service); // Not necessary, as service pointer is changed in the code
+
+ if ( service )
+ {
+ service->WaitForRequestCompleteL();
+ }
+
+ //Read the status from aService
+ THandlerServiceId srvid;
+ THandlerOperation opn;
+
+ service->GetServiceIdAndOperation(srvid,opn);
+
+ TBool mmcservice (EFalse);
+ if (service == iServices[EMmcService])
+ {
+ mmcservice = ETrue;
+ }
+
+ if (iServices[EMmcService])
+ {
+ delete iServices[EMmcService]; iServices[EMmcService] = NULL;
+ iServices[EMmcService] = CMmcService::NewL();
+ }
+
+ if (mmcservice)
+ {
+ service = iServices[EMmcService];
+ }
+ CreateConditionScheduleL(service);
+
+ if ( opn != ENoOpn )
+ {
+ TRAPD(err, NotifyRegisteredServersL(srvid, opn));
+ FLOG(_L("Notification error = %d"), err);
+ }
+ else
+ {
+ FLOG(_L("Operation got cancelled. Skipping notification"));
+ }
+
+ // CleanupStack::Pop(service); //don't destroy as object is not owned
+
+ FLOG(_L("CDmEventScheduler::WaitAndCreateConditionScheduleL <<"));
+ }
+
+// ---------------------------------------------------------------------------
+// CDmEventScheduler::CreateConditionScheduleWithTaskL()
+// ---------------------------------------------------------------------------
+TInt CDmEventScheduler::CreateConditionScheduleWithTaskL(
+ TSchedulerItemRef& aSchedulerItem,
+ RScheduler& aScheduler,
+ const TTsTime& aDefaultRunTime,
+ TInt& aNewTaskId,
+ CArrayFixFlat<TTaskSchedulerCondition>* &aConditions,
+ CDmEventServiceBase* aService)
+ {
+ FLOG(_L("CDmEventScheduler::CreateConditionScheduleWithTaskL >>"));
+
+ TInt ret(KErrNone);
+
+ aSchedulerItem.iName = KAppDmEventNotifierUid.Name();
+
+
+ ret = aScheduler.CreatePersistentSchedule(aSchedulerItem,
+ *aConditions, aDefaultRunTime);
+
+ if (KErrNone == ret)
+ {
+ TTaskInfo taskInfo;
+ taskInfo.iTaskId = 0;
+ taskInfo.iName = aService->TaskName();
+ taskInfo.iPriority = 2;
+ taskInfo.iRepeat = 0;
+ HBufC* data = aService->TaskName().AllocLC();
+
+ ret = aScheduler.ScheduleTask(taskInfo, *data, aSchedulerItem.iHandle);
+ aNewTaskId = taskInfo.iTaskId;
+
+ CleanupStack::PopAndDestroy(); // data
+ }
+ else
+ {
+ //Creating persistent schedule failed, do something...
+ FLOG(_L("Creation of persistent scheduled failed, error = %d"), ret);
+ }
+
+ FLOG(_L("CDmEventScheduler::CreateConditionScheduleWithTaskL, ret = %d <<"), ret);
+ return ret;
+ }
+
+// ---------------------------------------------------------------------------
+// CDmEventScheduler::DeleteScheduleL
+// ---------------------------------------------------------------------------
+void CDmEventScheduler::DeleteScheduleL()
+ {
+ FLOG(_L("CDmEventScheduler::DeleteScheduleL >>"));
+
+ RScheduler sc;
+ CArrayFixFlat<TSchedulerItemRef>* aSchRefArray = new CArrayFixFlat <TSchedulerItemRef>(KScheduleReferenceMax);
+ TScheduleFilter aFilter(EAllSchedules);
+ User::LeaveIfError( sc.Connect() );
+ CleanupClosePushL( sc );
+ CleanupStack::PushL(aSchRefArray);
+
+ User::LeaveIfError( sc.GetScheduleRefsL( *aSchRefArray,aFilter) );
+ FLOG(_L("Schedule items: "));
+ for ( TInt i=0; i<aSchRefArray->Count(); ++i )
+ {
+ TSchedulerItemRef it = (*aSchRefArray)[i];
+ if ( it.iName == KAppDmEventNotifierUid.Name() )
+ {
+ TScheduleState2 sc_state;
+ CSchConditionArray* sc_entries = new CSchConditionArray (KConditionArraySizeMax);
+ TTsTime sc_time;
+ CArrayFixFlat<TTaskInfo>* sc_tasks = new CArrayFixFlat <TTaskInfo>(KTaskArraySizeMax);
+
+ CleanupStack::PushL( sc_entries );
+ CleanupStack::PushL( sc_tasks );
+ FLOG (_L("%d. schedule handle: %d name:'%S'"),i,it.iHandle, &(it.iName) );
+
+ TInt err = sc.GetScheduleL ( it.iHandle , sc_state, *sc_entries, sc_time, *sc_tasks);
+
+ if (KErrNone == err)
+ {
+ for ( TInt j=0; j<sc_tasks->Count();++j)
+ {
+ TTaskInfo sc_task = (*sc_tasks)[j];
+ FLOG(_L(" schedule task %d '%S'"),sc_task.iTaskId,&(sc_task.iName) );
+
+ err = sc.DeleteTask(sc_task.iTaskId);
+ FLOG(_L("Deleted task state, error = %d"), err);
+ }
+ }
+ else
+ {
+ FLOG(_L("Getting schedule error = %d"), err);
+ }
+
+ err = sc.DeleteSchedule(it.iHandle );
+ FLOG(_L("Deleted schedule %d, error = %d"),i+1, err);
+
+ CleanupStack::PopAndDestroy( sc_tasks );
+ CleanupStack::PopAndDestroy( sc_entries );
+ }
+ }
+ CleanupStack::PopAndDestroy( aSchRefArray );
+ CleanupStack::PopAndDestroy(&sc);
+ FLOG(_L("CDmEventScheduler::DeleteScheduleL <<"));
+ }
+
+// ---------------------------------------------------------------------------
+// CDmEventScheduler::CreateConditionLC
+// ---------------------------------------------------------------------------
+CSchConditionArray* CDmEventScheduler::CreateConditionLC(CDmEventServiceBase* aService)
+ {
+ FLOG(_L("CDmEventScheduler::CreateConditionLC >>"));
+
+ CSchConditionArray* conditions = new (ELeave) CSchConditionArray(KConditionArraySize);
+ CleanupStack::PushL(conditions); //To be poped/destroyed by the caller
+
+ TTaskSchedulerCondition Condition;
+ TPSKeyCondition pskeycondition = aService->GetPSKeyCondition();
+ Condition.iCategory = pskeycondition.iPskey.iConditionCategory;
+ Condition.iKey = pskeycondition.iPskey.iConditionKey;
+ Condition.iState = pskeycondition.iSchState;
+ Condition.iType = pskeycondition.iSchType;
+
+ conditions->AppendL(Condition);
+
+ FLOG(_L("CDmEventScheduler::CreateConditionLC <<"));
+ return conditions;
+ }
+
+// ---------------------------------------------------------------------------
+// CDmEventScheduler::FindExpiredService
+// ---------------------------------------------------------------------------
+CDmEventServiceBase* CDmEventScheduler::FindExpiredService(TName& aTaskName)
+ {
+ FLOG(_L("CDmEventScheduler::FindExpiredService >>"));
+ CDmEventServiceBase* ret (NULL);
+ if (iServices[ESoftwareService]->TaskName().Compare(aTaskName) == KErrNone)
+ {
+ FLOG(_L("SW Operation detected..."))
+ ret = iServices[ESoftwareService];
+ }
+ else if (iServices[EJavaService]->TaskName().Compare(aTaskName) == KErrNone)
+ {
+ FLOG(_L("Java Inst Operation detected..."))
+ ret = iServices[EJavaService];
+ }
+ else if (iServices[EMmcService]->TaskName().Compare(aTaskName) == KErrNone)
+ {
+ FLOG(_L("MMC Operation detected..."))
+ ret = iServices[EMmcService];
+ }
+ else
+ {
+ //Should not land here...
+ FLOG(_L("Unknown trigger"));
+ }
+
+ FLOG(_L("CDmEventScheduler::FindExpiredService, ret = %X <<"), ret);
+ return ret;
+ }
+
+// ---------------------------------------------------------------------------
+// CDmEventScheduler::NotifyRegisteredServicesL
+// ---------------------------------------------------------------------------
+void CDmEventScheduler::NotifyRegisteredServersL(THandlerServiceId aServiceId, THandlerOperation aOpn)
+ {
+ FLOG(_L("CDmEventScheduler::NotifyRegisteredServersL, serviceid = %d, operation = %d >>"), aServiceId, aOpn);
+ //Read whome to notify...
+ CRepository* cenrep (NULL);
+ cenrep = CRepository::NewLC( KAppDmEventNotifierUid );
+ TInt notifyscp (KErrNotFound);
+ TInt error = cenrep->Get(KDmEventNotifierEnabled, notifyscp);
+
+ TInt notifyam (KErrNotFound);
+ error = cenrep->Get(KSCPNotifyEvent,notifyam);
+
+ CleanupStack::PopAndDestroy(cenrep);
+
+ if (notifyscp)
+ {
+ FLOG(_L("CDmEventScheduler::NotifyRegisteredServersL: Invocation of SCPEventHandler"));
+ TRAPD ( err, {
+ CSCPEventHandler* handler = CSCPEventHandler::NewL();
+ handler->NotifyChangesL(aServiceId, aOpn);
+ delete handler;
+ handler = NULL;
+ });
+ FLOG(_L("CDmEventScheduler::NotifyRegisteredServersL: SCPEventHandler completed with err: %d"), err);
+ }
+ if (notifyam)
+ {
+ //Notify AM server on the happened operation
+ }
+
+ FLOG(_L("CDmEventScheduler::NotifyRegisteredServersL notifyscp = %d, notifyam = %d<<"),notifyscp,notifyam);
+ }
+
+// ---------------------------------------------------------------------------
+// CDmEventScheduler::IsScneduleEnabledL
+// ---------------------------------------------------------------------------
+TBool CDmEventScheduler::IsScheduleEnabledL()
+ {
+ FLOG(_L("CDmEventScheduler::IsScheduleEnabledL >>"));
+ CRepository* cenrep (NULL);
+ TInt error (KErrNone);
+ TInt value (KErrNotFound);
+
+ TRAP(error, cenrep = CRepository::NewL( KAppDmEventNotifierUid ));
+
+ FLOG(_L("Cenrep file read status = %d"), error);
+ User::LeaveIfError(error);
+ CleanupStack::PushL(cenrep);
+
+ error = cenrep->Get(KDmEventNotifierEnabled, value);
+
+ CleanupStack::PopAndDestroy(cenrep);
+
+ FLOG(_L("CDmEventScheduler::IsScheduleEnabledL, value = %d, error = %d <<"),value, error);
+ return (value == EHandlerRegistered);
+ }
+
+// ---------------------------------------------------------------------------
+// CDmEventScheduler::SetScheduleEnabledL
+// ---------------------------------------------------------------------------
+void CDmEventScheduler::SetScheduleEnabledL(TBool aValue)
+ {
+ FLOG(_L("CDmEventScheduler::SetScheduleEnabledL, aValue = %d >>"), aValue);
+
+ CRepository* cenrep (NULL);
+ TInt error (KErrNone);
+
+ cenrep = CRepository::NewL( KAppDmEventNotifierUid );
+ CleanupStack::PushL(cenrep);
+
+ error = cenrep->Set(KDmEventNotifierEnabled, aValue);
+
+ CleanupStack::PopAndDestroy(cenrep);
+
+ FLOG(_L("CDmEventScheduler::SetScheduleEnabledL, error = %d <<"),error);
+ }
+//End of file