|
1 // Copyright (c) 2002-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 // Implementation of the Background Sync Engine client interface. |
|
15 // |
|
16 // |
|
17 |
|
18 /** |
|
19 @file |
|
20 @internalComponent |
|
21 */ |
|
22 |
|
23 #include "SyncEngineClient.h" |
|
24 #include "common.h" |
|
25 #include "Phonebook.h" |
|
26 #include "PhonebookManager.h" |
|
27 #include "SyncContactICCEntry.h" |
|
28 #include "SyncEngineServer.h" |
|
29 #include "phbksynclog.h" |
|
30 |
|
31 |
|
32 /** |
|
33 * Size of the Background Sync Engine thread stack size. |
|
34 */ |
|
35 const TInt KSyncEngineStackSize(0x3000); |
|
36 |
|
37 |
|
38 /** |
|
39 * Performs all server initialisation, in particular creation of the |
|
40 * scheduler object, the enigne server and then runs the scheduler |
|
41 * (which starts the engine server). |
|
42 * |
|
43 * @param aPhoneBookManager Reference to the phonebook manager class used |
|
44 * by the front-end server. |
|
45 */ |
|
46 static void RunEngineL(CPhoneBookManager& aPhoneBookManager) |
|
47 { |
|
48 LOGENGINE1(_L8("RunEngineL()")); |
|
49 |
|
50 // |
|
51 // Create a new Sync Engine Server... |
|
52 // |
|
53 CSyncEngineServer* engine = CSyncEngineServer::NewL(aPhoneBookManager); |
|
54 CleanupStack::PushL(engine); |
|
55 |
|
56 // |
|
57 // Initialisation complete, now signal the client thread... |
|
58 // |
|
59 LOGENGINE1(_L8("RunEngineL(): Meeting Rendezvous...")); |
|
60 RThread::Rendezvous(KErrNone); |
|
61 |
|
62 // |
|
63 // Run the server... |
|
64 // |
|
65 LOGENGINE1(_L8("RunEngineL(): Starting server...")); |
|
66 CSyncEngineScheduler::Start(); |
|
67 |
|
68 CleanupStack::PopAndDestroy(engine); |
|
69 } // RunEngineL |
|
70 |
|
71 |
|
72 /** |
|
73 * Thread function for starting the engine. This function basically just |
|
74 * installs an Active Scheduler, a clean up stack and then calls the |
|
75 * RunEngineL() leaving function. |
|
76 * |
|
77 * @param aPtr TAny pointer to the phonebook manager class used |
|
78 * by the front-end server. |
|
79 */ |
|
80 static TInt RunEngineThread(TAny* aPtr) |
|
81 { |
|
82 CPhoneBookManager* phonebookManager = static_cast<CPhoneBookManager*>(aPtr); |
|
83 |
|
84 LOGENGINE1(_L8("RunEngineThread()")); |
|
85 |
|
86 // |
|
87 // Create an Active Scheduler... |
|
88 // |
|
89 CActiveScheduler* scheduler = new CActiveScheduler(); |
|
90 if (scheduler == NULL) |
|
91 { |
|
92 return KErrNoMemory; |
|
93 } |
|
94 CActiveScheduler::Install(scheduler); |
|
95 |
|
96 // |
|
97 // Create a clean up stack... |
|
98 // |
|
99 CTrapCleanup* cleanup = CTrapCleanup::New(); |
|
100 |
|
101 TRAPD(leaveCode, RunEngineL(*phonebookManager)); |
|
102 |
|
103 delete cleanup; |
|
104 delete scheduler; |
|
105 |
|
106 return leaveCode; |
|
107 } // RunEngineThread |
|
108 |
|
109 |
|
110 /** |
|
111 * Start the engine thread. |
|
112 */ |
|
113 TInt RSyncEngineSession::StartPhBkSyncEngine(CPhoneBookManager* aPhoneBookManager) |
|
114 { |
|
115 LOGENGINE1(_L8("RSyncEngineSession::StartPhBkSyncEngine()")); |
|
116 |
|
117 // |
|
118 // Create the Sync Engine Thread (using the same heap as this thread) at |
|
119 // EPriorityAbsoluteBackground priority, ... |
|
120 // |
|
121 TInt ret; |
|
122 |
|
123 ret = iEngineThread.Create(PHBKSYNC_ENGINE_NAME, RunEngineThread, |
|
124 KSyncEngineStackSize, NULL, aPhoneBookManager); |
|
125 if (ret != KErrNone) |
|
126 { |
|
127 return ret; |
|
128 } |
|
129 |
|
130 iEngineThread.SetPriority(EPriorityAbsoluteBackground); |
|
131 |
|
132 // |
|
133 // Logon to the engine thread. This will be used later to ensure the |
|
134 // thread shuts down when closed. |
|
135 // |
|
136 iEngineThread.Logon(iEngineThreadStatus); |
|
137 if (iEngineThreadStatus != KRequestPending) |
|
138 { |
|
139 iEngineThread.Kill(0); |
|
140 iEngineThread.Close(); |
|
141 |
|
142 User::WaitForRequest(iEngineThreadStatus); |
|
143 |
|
144 return iEngineThreadStatus.Int(); |
|
145 } |
|
146 |
|
147 // |
|
148 // Rendezvous with the engine or abort the engine start... |
|
149 // |
|
150 TRequestStatus rendezvousStatus; |
|
151 |
|
152 iEngineThread.Rendezvous(rendezvousStatus); |
|
153 if (rendezvousStatus != KRequestPending) |
|
154 { |
|
155 iEngineThread.Kill(0); |
|
156 iEngineThread.Close(); |
|
157 |
|
158 User::WaitForRequest(rendezvousStatus); |
|
159 User::WaitForRequest(iEngineThreadStatus); |
|
160 |
|
161 return rendezvousStatus.Int(); |
|
162 } |
|
163 |
|
164 // |
|
165 // The thread is ready to go... |
|
166 // |
|
167 iEngineThread.Resume(); |
|
168 User::WaitForRequest(rendezvousStatus); |
|
169 if (rendezvousStatus != KErrNone) |
|
170 { |
|
171 iEngineThread.Kill(0); |
|
172 iEngineThread.Close(); |
|
173 |
|
174 User::WaitForRequest(iEngineThreadStatus); |
|
175 |
|
176 return rendezvousStatus.Int(); |
|
177 } |
|
178 |
|
179 return KErrNone; |
|
180 } // RSyncEngineSession::StartPhBkSyncEngine |
|
181 |
|
182 |
|
183 /** |
|
184 * Standard constructor. |
|
185 */ |
|
186 RSyncEngineSession::RSyncEngineSession() |
|
187 { |
|
188 iEngineThread.SetHandle(0); |
|
189 } // RSyncEngineSession::RSyncEngineSession |
|
190 |
|
191 |
|
192 /** |
|
193 * Connects the client to the Phonebook Synchronizer Server. |
|
194 * |
|
195 * This must be used before any of the other methods listed in |
|
196 * this API section. The first client to call this method will |
|
197 * cause the initiation of the Phonebook Synchronizer Server |
|
198 * within its own executable process. |
|
199 * |
|
200 * @param aPhoneBookManager Pointer to the phonebook manager class used |
|
201 * by the front-end server. |
|
202 * |
|
203 * @return KErrNone if successful, a system-wide error code if not. |
|
204 * |
|
205 * @capability None |
|
206 */ |
|
207 TInt RSyncEngineSession::Connect(CPhoneBookManager* aPhoneBookManager) |
|
208 { |
|
209 LOGENGINE1(_L8("RSyncEngineSession::Connect()")); |
|
210 |
|
211 // |
|
212 // Create a session with the server, but if it doesn't exist then start it and |
|
213 // then create a session. |
|
214 // |
|
215 TInt result = CreateSession(PHBKSYNC_ENGINE_NAME, TVersion()); |
|
216 if (result == KErrNotFound || result == KErrServerTerminated) |
|
217 { |
|
218 result = StartPhBkSyncEngine(aPhoneBookManager); |
|
219 |
|
220 if(result == KErrNone) |
|
221 { |
|
222 result = CreateSession(PHBKSYNC_ENGINE_NAME, TVersion()); |
|
223 } |
|
224 } |
|
225 |
|
226 // |
|
227 // If the creation of the session fails then close it to clean up |
|
228 // any allocated member data or running threads... |
|
229 // |
|
230 if (result != KErrNone) |
|
231 { |
|
232 Close(); |
|
233 } |
|
234 |
|
235 return result; |
|
236 } // RSyncEngineSession::Connect |
|
237 |
|
238 |
|
239 /** |
|
240 * Closes the client's session with the Phonebook Synchronizer Server. |
|
241 * |
|
242 * @capability None |
|
243 */ |
|
244 void RSyncEngineSession::Close() |
|
245 { |
|
246 LOGENGINE1(_L8("RSyncEngineSession::Close()")); |
|
247 |
|
248 RSessionBase::Close(); |
|
249 |
|
250 // |
|
251 // Ensure the engine thread shuts down before we return... |
|
252 // |
|
253 if (iEngineThread.Handle() != 0) |
|
254 { |
|
255 User::WaitForRequest(iEngineThreadStatus); |
|
256 iEngineThread.Close(); |
|
257 } |
|
258 } // RSyncEngineSession::Close |
|
259 |
|
260 |
|
261 /** |
|
262 * Instructs the engine to start a manual synchronisation of the ICC |
|
263 * phonebook specified by the aPhonebookUid parameter. |
|
264 * |
|
265 * @param aReqStatus On completion, KErrNone if successful, a |
|
266 * system-wide error code if not. |
|
267 * @param aPhonebookUid TUid of the ICC phonebook to be synchronised. |
|
268 * |
|
269 * @capability ReadUserData |
|
270 * @capability WriteUserData |
|
271 */ |
|
272 void RSyncEngineSession::DoSynchronisation(TRequestStatus& aReqStatus, |
|
273 TUid aPhonebookUid) |
|
274 { |
|
275 LOGENGINE2(_L8("RSyncEngineSession::DoSynchronisation(): 0x%08x"), |
|
276 aPhonebookUid); |
|
277 |
|
278 SendReceive(ESyncDoSynchronisation, TIpcArgs(aPhonebookUid.iUid), aReqStatus); |
|
279 } // RSyncEngineSession::DoSynchronisation |
|
280 |
|
281 |
|
282 /** |
|
283 * Cancels an existing Syncronisation request. |
|
284 * |
|
285 * @param aPhonebookUid TUid of the ICC phonebook to cancel. |
|
286 * |
|
287 * @capability ReadUserData |
|
288 * @capability WriteUserData |
|
289 */ |
|
290 void RSyncEngineSession::DoSynchronisationCancel(TUid aPhonebookUid) |
|
291 { |
|
292 LOGENGINE2(_L8("RSyncEngineSession::DoSynchronisationCancel(): 0x%08x"), |
|
293 aPhonebookUid); |
|
294 |
|
295 SendReceive(ESyncDoSynchronisationCancel, TIpcArgs(aPhonebookUid.iUid)); |
|
296 } // RSyncEngineSession::DoSynchronisationCancel |
|
297 |
|
298 |
|
299 /** |
|
300 * Write the contact item to an ICC phonebook. The parameters for this |
|
301 * function are left in the original packaged state from the front-end |
|
302 * server's client. |
|
303 * |
|
304 * @param aReqStatus On completion, KErrNone if successful, |
|
305 * a system-wide error code if not. |
|
306 * @param aTemplateIdAndBufferSizePtr Packaged pointer to the template and |
|
307 * buffer size. |
|
308 * @param aSlotNumberPtr Packaged pointer to the slot number. |
|
309 * @param aPhoneBookUidPtr Packaged pointer to the phonebook UID. |
|
310 * @param aICCEntryBufPtr Packaged pointer to the ICC Entry. |
|
311 * |
|
312 * @capability WriteUserData |
|
313 */ |
|
314 void RSyncEngineSession::WriteContact(TRequestStatus& aReqStatus, |
|
315 TPtrC8& aTemplateIdAndBufferSizePtr, |
|
316 TPtr8& aSlotNumberPtr, |
|
317 TPtr8& aPhoneBookUidPtr, |
|
318 TPtr8& aICCEntryBufPtr) |
|
319 { |
|
320 LOGENGINE1(_L8("RSyncEngineSession::WriteContact()")); |
|
321 |
|
322 TIpcArgs args(&aTemplateIdAndBufferSizePtr, &aSlotNumberPtr, |
|
323 &aPhoneBookUidPtr, &aICCEntryBufPtr); |
|
324 |
|
325 SendReceive(ESyncWriteCntToICC, args, aReqStatus); |
|
326 } // RSyncEngineSession::WriteContact |
|
327 |
|
328 |
|
329 /** |
|
330 * Cancels an existing WriteContact request. |
|
331 * |
|
332 * @param aPhonebookUid TUid of the ICC phonebook to cancel. |
|
333 * |
|
334 * @capability WriteUserData |
|
335 */ |
|
336 void RSyncEngineSession::WriteContactCancel(TUid aPhonebookUid) |
|
337 { |
|
338 LOGENGINE2(_L8("RSyncEngineSession::WriteContactCancel(): 0x%08x"), |
|
339 aPhonebookUid); |
|
340 |
|
341 SendReceive(ESyncWriteCntToICCCancel, TIpcArgs(aPhonebookUid.iUid)); |
|
342 } // RSyncEngineSession::WriteContactCancel |
|
343 |
|
344 |
|
345 /** |
|
346 * Deletes a contact item from the ICC. |
|
347 * |
|
348 * @param aReqStatus On completion, KErrNone if successful, a system-wide |
|
349 * error code if not. |
|
350 * @param aPhonebookUid UID of the ICC phonebook to delete from. |
|
351 * @param aId The contact item to delete. |
|
352 * |
|
353 * @capability WriteUserData |
|
354 */ |
|
355 void RSyncEngineSession::DeleteContact(TRequestStatus& aReqStatus, |
|
356 TUid aPhonebookUid, |
|
357 TContactItemId aId) |
|
358 { |
|
359 LOGENGINE3(_L8("RSyncEngineSession::DeleteContact(): 0x%08x"), |
|
360 aPhonebookUid, aId); |
|
361 |
|
362 SendReceive(ESyncDeleteCntFromICC, TIpcArgs(aPhonebookUid.iUid, aId), |
|
363 aReqStatus); |
|
364 } // RSyncEngineSession::DeleteContact |
|
365 |
|
366 |
|
367 /** |
|
368 * Cancels an existing WriteContact request. |
|
369 * |
|
370 * @param aPhonebookUid TUid of the ICC phonebook to cancel. |
|
371 * |
|
372 * @capability WriteUserData |
|
373 */ |
|
374 void RSyncEngineSession::DeleteContactCancel(TUid aPhonebookUid) |
|
375 { |
|
376 LOGENGINE2(_L8("RSyncEngineSession::DeleteContactCancel(): 0x%08x"), |
|
377 aPhonebookUid); |
|
378 |
|
379 SendReceive(ESyncDeleteCntFromICCCancel, TIpcArgs(aPhonebookUid.iUid)); |
|
380 } // RSyncEngineSession::DeleteContactCancel |
|
381 |