terminalsecurity/SCP/DmEventNotifier/src/DmEventScheduler.cpp
changeset 0 b497e44ab2fc
child 2 5594fba90824
--- /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