|
1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 #include <babackup.h> |
|
17 #include <bafl/backup_std.h> |
|
18 #include <e32std.h> |
|
19 #include <e32base.h> |
|
20 #include <baksrv.h> |
|
21 #include "Baksrvs.h" |
|
22 #include <e32math.h> |
|
23 #include <e32svr.h> |
|
24 #include <baflpan.h> |
|
25 |
|
26 #define UNUSED_VAR(a) a = a |
|
27 |
|
28 const TUid KServerUid3={0x10004900}; |
|
29 const TInt KBADefaultPriority = CActive::EPriorityUserInput; |
|
30 _LIT(KBackupSrvName,"baksrvs"); |
|
31 |
|
32 // |
|
33 // class RBaBackupSession |
|
34 // |
|
35 |
|
36 const TInt KNumConnectRetries =10; |
|
37 |
|
38 |
|
39 class RBaBackupSession : public RSessionBase |
|
40 { |
|
41 public: |
|
42 TInt Connect(); |
|
43 void RegisterForNotifications(TRequestStatus& aStatus) const; |
|
44 void DeregisterForNotifications() const; |
|
45 void GetEvent(TDes& aFileName,MBackupObserver::TFileLockFlags& aFileFlag) const; |
|
46 void CloseAllFiles(MBackupObserver::TFileLockFlags aFlags,TRequestStatus& aStatus) const; |
|
47 void RestartApps() const; |
|
48 TInt CloseFile(const TDesC& aFileName,MBackupObserver::TFileLockFlags aFlags) const; |
|
49 void RestartFile(const TDesC& aFileName) const; |
|
50 TInt NotifyChangeFileLock(const TDesC& aFileName) const; |
|
51 void NotifyChangeFileLockCancel(const TDesC& aFileName) const; |
|
52 void CloseServer() const; |
|
53 void NotifyBackupOperation(const TBackupOperationAttributes& aBackupOperationAttributes); |
|
54 TBool IsBackupOperationRunning() const; |
|
55 void BackupOperationEventReady(TRequestStatus& aStatus, TPckgBuf<TBackupOperationAttributes>& aBackupOperationAttributes) const; |
|
56 void CancelOutstandingEventForBackupOperation() const; |
|
57 void GetBackupOperationEvent(TBackupOperationAttributes& aBackupOperationAttributes) const; |
|
58 void SetBackupOperationObserverIsPresent(TBool aObserverIsPresent) const; |
|
59 private: |
|
60 TInt StartServer(); |
|
61 }; |
|
62 |
|
63 TInt RBaBackupSession::Connect() |
|
64 { |
|
65 TInt err=KErrNone; |
|
66 TInt retry=KNumConnectRetries; |
|
67 FOREVER |
|
68 { |
|
69 err=CreateSession(__BACKUP_SERVER_NAME_V2,TVersion(KBakServMajorVN,KBakServMinorVN,KBakServBuildVN),KBakServMessageSlots); |
|
70 if ((--retry>0) && ((err==KErrNotFound) || (err==KErrServerTerminated))) |
|
71 { |
|
72 err = StartServer(); |
|
73 if ((err!=KErrNone) && (err!=KErrAlreadyExists)) |
|
74 { |
|
75 break; |
|
76 } |
|
77 } |
|
78 else |
|
79 { |
|
80 break; |
|
81 } |
|
82 } |
|
83 return err; |
|
84 } |
|
85 |
|
86 TInt RBaBackupSession::StartServer() |
|
87 { |
|
88 const TUidType serverUid(KNullUid,KNullUid,KServerUid3); |
|
89 TInt error=KErrNone; |
|
90 RProcess server; |
|
91 error = server.Create(KBackupSrvName,KNullDesC,serverUid); |
|
92 if(error!=KErrNone) |
|
93 return error; |
|
94 TRequestStatus stat; |
|
95 server.Rendezvous(stat); |
|
96 if (stat!=KRequestPending) |
|
97 server.Kill(0); // abort startup |
|
98 else |
|
99 server.Resume(); // logon OK - start the server |
|
100 User::WaitForRequest(stat); // wait for start or death |
|
101 // we can't use the 'exit reason' if the server panicked as this |
|
102 // is the panic 'reason' and may be '0' which cannot be distinguished |
|
103 // from KErrNone |
|
104 error=(server.ExitType()==EExitPanic) ? KErrGeneral : stat.Int(); |
|
105 server.Close(); |
|
106 return error; |
|
107 } |
|
108 |
|
109 |
|
110 void RBaBackupSession::RegisterForNotifications(TRequestStatus& aStatus) const |
|
111 { |
|
112 SendReceive(EBakOpCodeEventReady,aStatus); |
|
113 } |
|
114 |
|
115 void RBaBackupSession::DeregisterForNotifications() const |
|
116 { |
|
117 SendReceive(EBakOpCodeStopNotifications); |
|
118 } |
|
119 |
|
120 void RBaBackupSession::GetEvent(TDes& aFileName,MBackupObserver::TFileLockFlags& aFileFlag) const |
|
121 { |
|
122 TBuf<KMaxFileName+1> buf; |
|
123 if (SendReceive(EBakOpCodeGetEvent,TIpcArgs(&buf))!=KErrServerTerminated) |
|
124 { |
|
125 TBuf<1> num=buf.Left(1); |
|
126 buf.Delete(0,1); |
|
127 aFileName=buf; |
|
128 aFileFlag=(MBackupObserver::TFileLockFlags)(num[0]-'0'); |
|
129 } |
|
130 } |
|
131 |
|
132 void RBaBackupSession::CloseAllFiles(MBackupObserver::TFileLockFlags aFlags,TRequestStatus& aStatus) const |
|
133 { |
|
134 SendReceive(EBakOpCodeCloseAllFiles,TIpcArgs(aFlags),aStatus); |
|
135 } |
|
136 |
|
137 void RBaBackupSession::RestartApps() const |
|
138 { |
|
139 SendReceive(EBakOpCodeRestartAll); |
|
140 } |
|
141 |
|
142 TInt RBaBackupSession::CloseFile(const TDesC& aFileName,MBackupObserver::TFileLockFlags aFlags) const |
|
143 { |
|
144 const TInt err=SendReceive(EBakOpCodeCloseFile,TIpcArgs(aFileName.Length(),&aFileName,aFlags)); |
|
145 return err; |
|
146 } |
|
147 |
|
148 void RBaBackupSession::RestartFile(const TDesC& aFileName) const |
|
149 { |
|
150 SendReceive(EBakOpCodeRestartFile,TIpcArgs(aFileName.Length(),&aFileName)); |
|
151 } |
|
152 |
|
153 TInt RBaBackupSession::NotifyChangeFileLock(const TDesC& aFileName) const |
|
154 { |
|
155 return SendReceive(EBakOpCodeNotifyLockChange,TIpcArgs(aFileName.Length(),&aFileName)); |
|
156 } |
|
157 |
|
158 void RBaBackupSession::NotifyChangeFileLockCancel(const TDesC& aFileName) const |
|
159 { |
|
160 SendReceive(EBakOpCodeNotifyLockChangeCancel,TIpcArgs(aFileName.Length(),&aFileName)); |
|
161 } |
|
162 |
|
163 void RBaBackupSession::CloseServer() const |
|
164 { |
|
165 Send(EBakOpCodeCloseServer); |
|
166 } |
|
167 |
|
168 void RBaBackupSession::NotifyBackupOperation(const TBackupOperationAttributes& aBackupOperationAttributes) |
|
169 { |
|
170 TPckgC<TBackupOperationAttributes> backupOpAttPkg(aBackupOperationAttributes); |
|
171 SendReceive(EBakOpCodeNotifyBackupOperation, TIpcArgs(&backupOpAttPkg)); |
|
172 } |
|
173 |
|
174 void RBaBackupSession::CancelOutstandingEventForBackupOperation() const |
|
175 { |
|
176 SendReceive(EBakOpCodeCancelOutstandingBackupOperationEvent); |
|
177 } |
|
178 |
|
179 TBool RBaBackupSession::IsBackupOperationRunning() const |
|
180 { |
|
181 TBool isRunning=EFalse; |
|
182 TPckg<TBool> pkg(isRunning); |
|
183 SendReceive(EBakOpCodeGetBackupOperationState, TIpcArgs(&pkg)); |
|
184 return pkg(); |
|
185 } |
|
186 |
|
187 void RBaBackupSession::BackupOperationEventReady(TRequestStatus& aStatus, TPckgBuf<TBackupOperationAttributes>& aBackupOperationAttributes) const |
|
188 { |
|
189 SendReceive(EBakOpCodeBackupOperationEventReady,TIpcArgs(&aBackupOperationAttributes),aStatus); |
|
190 } |
|
191 |
|
192 void RBaBackupSession::GetBackupOperationEvent(TBackupOperationAttributes& aBackupOperationAttributes) const |
|
193 { |
|
194 TPckg<TBackupOperationAttributes> backupOpAttPkg(aBackupOperationAttributes); |
|
195 SendReceive(EBakOpCodeGetBackupOperationEvent, TIpcArgs(&backupOpAttPkg)); |
|
196 } |
|
197 |
|
198 void RBaBackupSession::SetBackupOperationObserverIsPresent(TBool aObserverIsPresent) const |
|
199 { |
|
200 Send(EBakOpCodeSetBackupOperationObserverIsPresent, TIpcArgs(aObserverIsPresent)); |
|
201 } |
|
202 |
|
203 // |
|
204 // class CBaLockChangeNotifier |
|
205 // |
|
206 |
|
207 NONSHARABLE_CLASS(CBaLockChangeNotifier) : public CActive |
|
208 { |
|
209 public: |
|
210 static CBaLockChangeNotifier* NewL(RBaBackupSession& aBackupSession); |
|
211 ~CBaLockChangeNotifier(); |
|
212 void AddL(const TDesC& aFileName, MBackupObserver& aObserver); |
|
213 void Remove(const TDesC& aFileName); |
|
214 protected: |
|
215 void StartNotifications(); |
|
216 void StopNotifications(); |
|
217 private: // from CActive |
|
218 void DoCancel(); |
|
219 void RunL(); |
|
220 private: |
|
221 CBaLockChangeNotifier(RBaBackupSession& aBackupSession); |
|
222 void DoRunL(); |
|
223 TInt Find(const TDesC& aFileName) const; |
|
224 private: |
|
225 class TFileItem |
|
226 { |
|
227 public: |
|
228 TFileItem(HBufC* aFile,MBackupObserver& aObserver); |
|
229 public: |
|
230 HBufC* iFile; |
|
231 MBackupObserver& iObserver; |
|
232 }; |
|
233 private: |
|
234 RBaBackupSession& iBackupSession; |
|
235 RArray<TFileItem> iFileItems; |
|
236 }; |
|
237 |
|
238 CBaLockChangeNotifier::TFileItem::TFileItem(HBufC* aFile,MBackupObserver& aObserver) |
|
239 : iFile(aFile), |
|
240 iObserver(aObserver) |
|
241 {} |
|
242 |
|
243 CBaLockChangeNotifier* CBaLockChangeNotifier::NewL(RBaBackupSession& aBackupSession) |
|
244 { // static |
|
245 CBaLockChangeNotifier* self=new(ELeave) CBaLockChangeNotifier(aBackupSession); |
|
246 CActiveScheduler::Add(self); |
|
247 return self; |
|
248 } |
|
249 |
|
250 CBaLockChangeNotifier::~CBaLockChangeNotifier() |
|
251 { |
|
252 Cancel(); |
|
253 |
|
254 const TInt count=iFileItems.Count(); |
|
255 for (TInt ii=0;ii<count;ii++) |
|
256 { |
|
257 delete iFileItems[ii].iFile; |
|
258 } |
|
259 iFileItems.Close(); |
|
260 } |
|
261 |
|
262 void CBaLockChangeNotifier::StartNotifications() |
|
263 { |
|
264 if(!IsActive()) |
|
265 { |
|
266 iBackupSession.RegisterForNotifications(iStatus); |
|
267 SetActive(); |
|
268 } |
|
269 } |
|
270 |
|
271 void CBaLockChangeNotifier:: StopNotifications() |
|
272 { |
|
273 const TInt count=iFileItems.Count(); |
|
274 |
|
275 if(count==0) |
|
276 { |
|
277 Cancel(); |
|
278 } |
|
279 } |
|
280 |
|
281 void CBaLockChangeNotifier::AddL(const TDesC& aFileName, MBackupObserver& aObserver) |
|
282 { |
|
283 StartNotifications(); |
|
284 |
|
285 HBufC* file=aFileName.AllocLC(); |
|
286 TFileItem fileItem(file,aObserver); |
|
287 User::LeaveIfError(iFileItems.Append(fileItem)); |
|
288 CleanupStack::Pop(); // file |
|
289 const TInt err=iBackupSession.NotifyChangeFileLock(aFileName); |
|
290 if (err!=KErrNone) |
|
291 { |
|
292 delete file; |
|
293 iFileItems.Remove(iFileItems.Count()-1); |
|
294 iFileItems.Compress(); |
|
295 User::Leave(err); |
|
296 } |
|
297 } |
|
298 |
|
299 void CBaLockChangeNotifier::Remove(const TDesC& aFileName) |
|
300 { |
|
301 const TInt index=Find(aFileName); |
|
302 if (index!=KErrNotFound) |
|
303 { |
|
304 const TFileItem& fileItem=iFileItems[index]; |
|
305 iBackupSession.NotifyChangeFileLockCancel(*fileItem.iFile); |
|
306 delete fileItem.iFile; |
|
307 iFileItems.Remove(index); |
|
308 iFileItems.Compress(); |
|
309 } |
|
310 |
|
311 StopNotifications(); |
|
312 } |
|
313 |
|
314 |
|
315 void CBaLockChangeNotifier::DoCancel() |
|
316 { |
|
317 const TInt count=iFileItems.Count(); |
|
318 |
|
319 // release the locks on all outstandng files in this session |
|
320 for (TInt ii=0;ii<count;ii++) |
|
321 { |
|
322 const TFileItem& fileItem=iFileItems[ii]; |
|
323 iBackupSession.NotifyChangeFileLockCancel(*fileItem.iFile); |
|
324 } |
|
325 iBackupSession.DeregisterForNotifications(); |
|
326 } |
|
327 |
|
328 void CBaLockChangeNotifier::RunL() |
|
329 { |
|
330 TRAPD(err,DoRunL()); |
|
331 if (err!=KErrServerTerminated) |
|
332 { |
|
333 StartNotifications(); |
|
334 } |
|
335 User::LeaveIfError(err); |
|
336 } |
|
337 |
|
338 CBaLockChangeNotifier::CBaLockChangeNotifier(RBaBackupSession& aBackupSession) |
|
339 : CActive(KBADefaultPriority), iBackupSession(aBackupSession) |
|
340 {} |
|
341 |
|
342 |
|
343 void CBaLockChangeNotifier::DoRunL() |
|
344 { |
|
345 const TInt status=iStatus.Int(); |
|
346 |
|
347 if (status<0) |
|
348 { |
|
349 User::Leave(status); |
|
350 } |
|
351 TFileName fileName; |
|
352 MBackupObserver::TFileLockFlags fileFlag; |
|
353 iBackupSession.GetEvent(fileName,fileFlag); |
|
354 TInt err=KErrNone; |
|
355 const TInt count=iFileItems.Count(); |
|
356 for (TInt ii=0;ii<count;ii++) |
|
357 { |
|
358 const TFileItem& fileItem=iFileItems[ii]; |
|
359 if (fileItem.iFile->MatchF(fileName)==0) |
|
360 { |
|
361 TRAPD(r,fileItem.iObserver.ChangeFileLockL(*fileItem.iFile,fileFlag)); |
|
362 if (r!=KErrNone && err==KErrNone) |
|
363 { |
|
364 err=r; |
|
365 } |
|
366 } |
|
367 } |
|
368 User::LeaveIfError(err); |
|
369 } |
|
370 |
|
371 TInt CBaLockChangeNotifier::Find(const TDesC& aFileName) const |
|
372 { |
|
373 TInt index=KErrNotFound; |
|
374 const TInt count=iFileItems.Count(); |
|
375 for (TInt ii=0;ii<count;ii++) |
|
376 { |
|
377 const TFileItem& fileItem=iFileItems[ii]; |
|
378 if (*fileItem.iFile==aFileName) |
|
379 { |
|
380 index=ii; |
|
381 break; |
|
382 } |
|
383 } |
|
384 return index; |
|
385 } |
|
386 |
|
387 // |
|
388 // class CBaBackupOperationNotifier |
|
389 // |
|
390 |
|
391 NONSHARABLE_CLASS(CBaBackupOperationNotifier) : public CActive |
|
392 { |
|
393 public: |
|
394 static CBaBackupOperationNotifier* NewL(RBaBackupSession& aBackupSession); |
|
395 ~CBaBackupOperationNotifier(); |
|
396 void AddBackupOperationObserverL(MBackupOperationObserver& aBackupSession); |
|
397 void RemoveBackupOperationObserver(MBackupOperationObserver& aBackupSession); |
|
398 private: // from CActive |
|
399 void DoCancel(); |
|
400 void RunL(); |
|
401 private: |
|
402 CBaBackupOperationNotifier(RBaBackupSession& aBackupSession); |
|
403 void Queue(); |
|
404 void DoRunL(); |
|
405 private: |
|
406 RPointerArray<MBackupOperationObserver> iObservers; |
|
407 RBaBackupSession& iBackupSession; |
|
408 TPckgBuf<TBackupOperationAttributes> iBackupOperationAttributes; |
|
409 }; |
|
410 |
|
411 |
|
412 CBaBackupOperationNotifier* CBaBackupOperationNotifier::NewL(RBaBackupSession& aBackupSession) |
|
413 { // static |
|
414 CBaBackupOperationNotifier* self=new(ELeave) CBaBackupOperationNotifier(aBackupSession); |
|
415 CActiveScheduler::Add(self); |
|
416 return self; |
|
417 } |
|
418 |
|
419 CBaBackupOperationNotifier::~CBaBackupOperationNotifier() |
|
420 { |
|
421 Cancel(); |
|
422 iObservers.Reset(); |
|
423 iObservers.Close(); |
|
424 } |
|
425 |
|
426 void CBaBackupOperationNotifier::AddBackupOperationObserverL(MBackupOperationObserver& aBackupOperationObserver) |
|
427 { |
|
428 const TInt index = iObservers.Find(&aBackupOperationObserver); |
|
429 if (index == KErrNotFound) |
|
430 { |
|
431 User::LeaveIfError(iObservers.Append(&aBackupOperationObserver)); |
|
432 if (iBackupSession.IsBackupOperationRunning()) |
|
433 { |
|
434 TBackupOperationAttributes backupOperationAttributes; |
|
435 iBackupSession.GetBackupOperationEvent(backupOperationAttributes); |
|
436 aBackupOperationObserver.HandleBackupOperationEventL(backupOperationAttributes); |
|
437 } |
|
438 } |
|
439 Queue(); |
|
440 } |
|
441 |
|
442 void CBaBackupOperationNotifier::RemoveBackupOperationObserver(MBackupOperationObserver& aBackupOperationObserver) |
|
443 { |
|
444 const TInt index = iObservers.Find(&aBackupOperationObserver); |
|
445 if (index != KErrNotFound) |
|
446 { |
|
447 iObservers.Remove(index); |
|
448 if (iObservers.Count() == 0) |
|
449 { |
|
450 iBackupSession.CancelOutstandingEventForBackupOperation(); |
|
451 iBackupSession.SetBackupOperationObserverIsPresent(EFalse); |
|
452 } |
|
453 } |
|
454 } |
|
455 |
|
456 void CBaBackupOperationNotifier::DoCancel() |
|
457 { |
|
458 TBackupOperationAttributes backupOperationAttributes; |
|
459 iBackupSession.GetBackupOperationEvent(backupOperationAttributes); |
|
460 const TInt count = iObservers.Count(); |
|
461 for (TInt index=0; index<count; ++index) |
|
462 { |
|
463 // TRAP and ignore the errCode |
|
464 TRAPD(errCode, iObservers[index]->HandleBackupOperationEventL(backupOperationAttributes)); |
|
465 UNUSED_VAR(errCode); |
|
466 } |
|
467 iBackupSession.CancelOutstandingEventForBackupOperation(); |
|
468 } |
|
469 |
|
470 void CBaBackupOperationNotifier::RunL() |
|
471 { |
|
472 const TInt status=iStatus.Int(); |
|
473 if (status!=KErrCancel && iObservers.Count()>0) |
|
474 { |
|
475 TRAPD(err,DoRunL()); |
|
476 if (err!=KErrServerTerminated) |
|
477 { |
|
478 Queue(); |
|
479 } |
|
480 User::LeaveIfError(err); |
|
481 } |
|
482 } |
|
483 |
|
484 CBaBackupOperationNotifier::CBaBackupOperationNotifier(RBaBackupSession& aBackupSession) |
|
485 : CActive(EPriorityStandard), iBackupSession(aBackupSession) |
|
486 {} |
|
487 |
|
488 void CBaBackupOperationNotifier::Queue() |
|
489 { |
|
490 if (!IsActive()) |
|
491 { |
|
492 iStatus=KRequestPending; |
|
493 SetActive(); |
|
494 iBackupSession.SetBackupOperationObserverIsPresent(ETrue); |
|
495 iBackupSession.BackupOperationEventReady(iStatus, iBackupOperationAttributes); |
|
496 } |
|
497 } |
|
498 |
|
499 void CBaBackupOperationNotifier::DoRunL() |
|
500 { |
|
501 const TInt status=iStatus.Int(); |
|
502 if (status<0) |
|
503 { |
|
504 User::Leave(status); |
|
505 } |
|
506 const TInt count = iObservers.Count(); |
|
507 for (TInt index=0; index<count; ++index) |
|
508 { |
|
509 iObservers[index]->HandleBackupOperationEventL(iBackupOperationAttributes()); |
|
510 } |
|
511 } |
|
512 |
|
513 // |
|
514 // class CBaBackupSessionWrapper |
|
515 // |
|
516 |
|
517 /** |
|
518 * Returns a newly created CBaBackupSessionWrapper, passing ownership immediately |
|
519 */ |
|
520 EXPORT_C CBaBackupSessionWrapper* CBaBackupSessionWrapper::NewL() |
|
521 { // static |
|
522 CBaBackupSessionWrapper* self=new(ELeave) CBaBackupSessionWrapper(); |
|
523 CleanupStack::PushL(self); |
|
524 self->ConstructL(); |
|
525 CleanupStack::Pop(); // self |
|
526 return self; |
|
527 } |
|
528 |
|
529 /** |
|
530 * D'tor. Any files or apps that have been closed will be restarted |
|
531 */ |
|
532 EXPORT_C CBaBackupSessionWrapper::~CBaBackupSessionWrapper() |
|
533 { |
|
534 delete iLockChangeNotifier; |
|
535 delete iBackupOperationNotifier; |
|
536 if (iBackupSession) |
|
537 { |
|
538 iBackupSession->Close(); |
|
539 delete iBackupSession; |
|
540 } |
|
541 } |
|
542 |
|
543 /** |
|
544 Register the specified file to the server. The given observer will be called back when |
|
545 the lock state of the file should be modified |
|
546 |
|
547 @param aFileName the name of the file to be observed. |
|
548 @param aObserver the observer which will be called back when the lock state of the file should be modified. |
|
549 |
|
550 @leave KErrServerBusy if the server is busy with the other client or under CloseAll operation. KErrNoMemory |
|
551 if not enough memory to register this file. |
|
552 */ |
|
553 EXPORT_C void CBaBackupSessionWrapper::RegisterFileL(const TDesC& aFileName,MBackupObserver& aObserver) |
|
554 { |
|
555 if (!iLockChangeNotifier) |
|
556 { |
|
557 iLockChangeNotifier=CBaLockChangeNotifier::NewL(*iBackupSession); |
|
558 } |
|
559 |
|
560 __ASSERT_ALWAYS(iLockChangeNotifier, Panic(EBafPanicNullPointer)); |
|
561 iLockChangeNotifier->AddL(aFileName,aObserver); |
|
562 } |
|
563 |
|
564 /** |
|
565 * Stop sending this client requests to alter the lock state of aFileName |
|
566 */ |
|
567 EXPORT_C void CBaBackupSessionWrapper::DeregisterFile(const TDesC& aFileName) |
|
568 { |
|
569 if(iLockChangeNotifier) |
|
570 iLockChangeNotifier->Remove(aFileName); |
|
571 } |
|
572 |
|
573 /** |
|
574 Closes all non-system apps and signal all registered files to have their locks altered according to aFlags. |
|
575 Returns immediately before having finished all processing. aStatus will be completed when everything is |
|
576 closed or closing has completed. Possible error codes are |
|
577 KErrNoMemory - Not enough memory to signal all apps/files to close |
|
578 KErrServerBusy - Another client has some files closed - No-one else should attempt any backup operation |
|
579 KErrLocked - Not all apps were successfully closed |
|
580 In all cases, an undefined number of apps/files may have been closed and backup may still be possible although |
|
581 install/restore operations should not be attempted. |
|
582 |
|
583 @param aFlags the file lock state to request the other clients with. |
|
584 @param aStatus the request status to be completed when all files have been closed. |
|
585 @publishedPartner |
|
586 @released |
|
587 @capability WriteDeviceData |
|
588 */ |
|
589 EXPORT_C void CBaBackupSessionWrapper::CloseAll(MBackupObserver::TFileLockFlags aFlags,TRequestStatus& aStatus) |
|
590 { |
|
591 iBackupSession->CloseAllFiles(aFlags,aStatus); |
|
592 } |
|
593 |
|
594 /** |
|
595 * Opposite of CloseAll. Can safely be called nothing has been closed by this client |
|
596 * |
|
597 * @publishedPartner |
|
598 * @released |
|
599 * @capability WriteDeviceData |
|
600 */ |
|
601 EXPORT_C void CBaBackupSessionWrapper::RestartAll() |
|
602 { |
|
603 iBackupSession->RestartApps(); |
|
604 } |
|
605 |
|
606 /** |
|
607 Close or reduce use of aFileName depending on the state of aFlags. |
|
608 |
|
609 @param aFileName the name of the file to be closed / changed the file lock state. |
|
610 @param aFlag the file lock state to change to. |
|
611 @leave KErrNoMemory if not enough memory to signal the files to close. KErrServerIsBusy if another client |
|
612 has some files being closed. |
|
613 @publishedPartner |
|
614 @released |
|
615 @capability WriteDeviceData |
|
616 */ |
|
617 EXPORT_C void CBaBackupSessionWrapper::CloseFileL(const TDesC& aFileName,MBackupObserver::TFileLockFlags aFlags) |
|
618 { |
|
619 User::LeaveIfError(iBackupSession->CloseFile(aFileName,aFlags)); |
|
620 } |
|
621 |
|
622 /** |
|
623 * Opposite of CloseFileL. Can be safely called if CloseFileL hasn't been called before |
|
624 * |
|
625 * @publishedPartner |
|
626 * @released |
|
627 * @capability WriteDeviceData |
|
628 */ |
|
629 EXPORT_C void CBaBackupSessionWrapper::RestartFile(const TDesC& aFileName) |
|
630 { |
|
631 iBackupSession->RestartFile(aFileName); |
|
632 } |
|
633 |
|
634 CBaBackupSessionWrapper::CBaBackupSessionWrapper() |
|
635 {} |
|
636 |
|
637 void CBaBackupSessionWrapper::ConstructL() |
|
638 { |
|
639 iBackupSession=new(ELeave) RBaBackupSession(); |
|
640 User::LeaveIfError(iBackupSession->Connect()); |
|
641 } |
|
642 |
|
643 |
|
644 /** |
|
645 * Registers the observer aBackupOperationObserver for getting notifications whether a backup or |
|
646 * restore operation starts or ends. |
|
647 * |
|
648 * @since App-Framework_6.2 |
|
649 */ |
|
650 EXPORT_C void CBaBackupSessionWrapper::RegisterBackupOperationObserverL(MBackupOperationObserver& aBackupOperationObserver) |
|
651 { |
|
652 if (!iBackupOperationNotifier) |
|
653 { |
|
654 iBackupOperationNotifier=CBaBackupOperationNotifier::NewL(*iBackupSession); |
|
655 } |
|
656 iBackupOperationNotifier->AddBackupOperationObserverL(aBackupOperationObserver); |
|
657 } |
|
658 |
|
659 /** |
|
660 * De-registers the observer aBackupOperationObserver for getting notifications whether a backup or |
|
661 * restore operation starts or ends. |
|
662 * |
|
663 * @since App-Framework_6.2 |
|
664 */ |
|
665 EXPORT_C void CBaBackupSessionWrapper::DeRegisterBackupOperationObserver(MBackupOperationObserver& aBackupOperationObserver) |
|
666 { |
|
667 if (iBackupOperationNotifier) |
|
668 { |
|
669 iBackupOperationNotifier->RemoveBackupOperationObserver(aBackupOperationObserver); |
|
670 } |
|
671 } |
|
672 |
|
673 /** |
|
674 * Returns ETrue when either a backup or restore operation is running, otherwise it retunrs EFalse. |
|
675 * |
|
676 * @since App-Framework_6.2 |
|
677 */ |
|
678 EXPORT_C TBool CBaBackupSessionWrapper::IsBackupOperationRunning() const |
|
679 { |
|
680 return iBackupSession->IsBackupOperationRunning(); |
|
681 } |
|
682 |
|
683 /** |
|
684 * Notifies the server that a backup operation is going to happen. |
|
685 * |
|
686 * @since App-Framework_6.2 |
|
687 * @publishedPartner |
|
688 * @released |
|
689 * @capability WriteDeviceData |
|
690 */ |
|
691 EXPORT_C void CBaBackupSessionWrapper::NotifyBackupOperationL(const TBackupOperationAttributes& aBackupOperationAttributes) |
|
692 { |
|
693 iBackupSession->NotifyBackupOperation(aBackupOperationAttributes); |
|
694 } |
|
695 |
|
696 |
|
697 EXPORT_C void MBackupOperationObserver::Reserved1() |
|
698 { |
|
699 } |