|
1 /* |
|
2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: RLS and Presence XDM, This class represents validity part of |
|
15 * a Presence Condition |
|
16 * |
|
17 */ |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 // Includes |
|
23 #include <XdmDocumentNode.h> |
|
24 #include <XdmNodeAttribute.h> |
|
25 #include <xcapappusagedef.h> |
|
26 #include <utf.h> |
|
27 |
|
28 #include "prescondvalidity.h" |
|
29 #include "cpresencexdm.h" |
|
30 #include "rlspresxdmlogger.h" |
|
31 #include "rlspresxdmconstsint.h" |
|
32 |
|
33 |
|
34 // --------------------------------------------------------------------------- |
|
35 // TPresCondValidity::TPresCondValidity() |
|
36 // --------------------------------------------------------------------------- |
|
37 // |
|
38 EXPORT_C TPresCondValidity::TPresCondValidity(): iPresXDM(NULL) |
|
39 { |
|
40 OPENG_DP(D_OPENG_LIT( "TPresCondValidity::TPresCondValidity()" )); |
|
41 } |
|
42 |
|
43 // --------------------------------------------------------------------------- |
|
44 // TPresCondValidity::Init() |
|
45 // --------------------------------------------------------------------------- |
|
46 // |
|
47 EXPORT_C void TPresCondValidity::Init(CPresenceXDM* const aPresXDM) |
|
48 { |
|
49 OPENG_DP(D_OPENG_LIT( "TPresCondValidity::Init(%d)" ), aPresXDM); |
|
50 iPresXDM = aPresXDM; |
|
51 } |
|
52 |
|
53 |
|
54 // --------------------------------------------------------------------------- |
|
55 // TPresCondValidity::GetValidity() |
|
56 // --------------------------------------------------------------------------- |
|
57 // |
|
58 EXPORT_C TInt TPresCondValidity::GetValidityL(const TDesC& aRuleID, |
|
59 RArray<TTimePeriod>& aValidTimes) |
|
60 { |
|
61 OPENG_DP(D_OPENG_LIT( "TPresCondValidity::GetValidity()" ) ); |
|
62 OPENG_DP(D_OPENG_LIT( " aRuleID = %S"),&aRuleID); |
|
63 |
|
64 CXdmDocumentNode* validityNode = GetValidityNodeL(aRuleID, EFalse); |
|
65 if(validityNode==NULL) |
|
66 return KErrNotFound; |
|
67 |
|
68 TInt nodeCount = validityNode->NodeCount(); |
|
69 OPENG_DP(D_OPENG_LIT( " validityNode->NodeCount() = %d"),nodeCount); |
|
70 if(!nodeCount) |
|
71 return KErrNotFound; |
|
72 |
|
73 RPointerArray<CXdmDocumentNode> fromNodes; |
|
74 RPointerArray<CXdmDocumentNode> untilNodes; |
|
75 |
|
76 HBufC* fromPtr(NULL); |
|
77 HBufC* untilPtr(NULL); |
|
78 |
|
79 TTime fromTime(0); |
|
80 TTime untilTime(0); |
|
81 |
|
82 |
|
83 TTimePeriod myTimePeriod; |
|
84 |
|
85 // Get all the <from> nodes |
|
86 validityNode->Find(KXdmFrom, fromNodes); |
|
87 validityNode->Find(KXdmUntil, untilNodes); |
|
88 |
|
89 if((fromNodes.Count()) != (untilNodes.Count())) |
|
90 { |
|
91 fromNodes.Close(); |
|
92 untilNodes.Close(); |
|
93 return KErrGeneral; |
|
94 } |
|
95 |
|
96 |
|
97 nodeCount = fromNodes.Count(); |
|
98 OPENG_DP(D_OPENG_LIT( " nodesCount = %d" ),nodeCount); |
|
99 |
|
100 for(TInt i=0; i<nodeCount; i++) |
|
101 { |
|
102 aValidTimes.Append(myTimePeriod); |
|
103 |
|
104 // processing from |
|
105 (fromNodes[i])->SetLeafNode(ETrue); |
|
106 fromPtr = CnvUtfConverter::ConvertToUnicodeFromUtf8L((fromNodes[i])->LeafNodeContent()); |
|
107 CleanupStack::PushL(fromPtr); |
|
108 OPENG_DP(D_OPENG_LIT( " from string at i(%d): %S" ),i,&(*fromPtr)); |
|
109 ParseFromXMLTimeString(fromPtr->Des(), fromTime); |
|
110 CleanupStack::PopAndDestroy(fromPtr); |
|
111 ConvertToLocal(fromTime); |
|
112 ((aValidTimes[i]).from).Set(fromTime.DateTime().Year(),fromTime.DateTime().Month(), |
|
113 fromTime.DateTime().Day(),fromTime.DateTime().Hour(),fromTime.DateTime().Minute(), |
|
114 fromTime.DateTime().Second(), fromTime.DateTime().MicroSecond()); |
|
115 OPENG_DP(D_OPENG_LIT( " from at i = %d" ),i); |
|
116 LogDateTime((aValidTimes[i]).from); |
|
117 |
|
118 |
|
119 // processing until |
|
120 (untilNodes[i])->SetLeafNode(ETrue); |
|
121 untilPtr = CnvUtfConverter::ConvertToUnicodeFromUtf8L((untilNodes[i])->LeafNodeContent()); |
|
122 CleanupStack::PushL(untilPtr); |
|
123 OPENG_DP(D_OPENG_LIT( " until string at i(%d): %S" ),i,&(*untilPtr)); |
|
124 ParseFromXMLTimeString(untilPtr->Des(), untilTime); |
|
125 CleanupStack::PopAndDestroy(untilPtr); |
|
126 ConvertToLocal(untilTime); |
|
127 (aValidTimes[i]).until.Set(untilTime.DateTime().Year(),untilTime.DateTime().Month(), |
|
128 untilTime.DateTime().Day(),untilTime.DateTime().Hour(),untilTime.DateTime().Minute(), |
|
129 untilTime.DateTime().Second(),untilTime.DateTime().MicroSecond()); |
|
130 OPENG_DP(D_OPENG_LIT( " until at i = %d" ),i); |
|
131 LogDateTime((aValidTimes[i]).until); |
|
132 |
|
133 } |
|
134 |
|
135 fromNodes.Close(); |
|
136 untilNodes.Close(); |
|
137 return KErrNone; |
|
138 } |
|
139 |
|
140 // --------------------------------------------------------------------------- |
|
141 // TPresCondValidity::DeleteAllValidity() |
|
142 // --------------------------------------------------------------------------- |
|
143 // |
|
144 EXPORT_C TInt TPresCondValidity::DeleteAllValidityL(const TDesC& aRuleID) |
|
145 { |
|
146 OPENG_DP(D_OPENG_LIT( "TPresCondValidity::DeleteAllValidity()" ) ); |
|
147 OPENG_DP(D_OPENG_LIT( " aRuleID = %S"),&aRuleID); |
|
148 |
|
149 __ASSERT_ALWAYS(iPresXDM, User::Leave(KErrNotReady)); |
|
150 |
|
151 CXdmDocumentNode* validityNode = GetValidityNodeL(aRuleID, EFalse); |
|
152 if(validityNode==NULL) |
|
153 return KErrNotFound; |
|
154 |
|
155 iPresXDM->RemoveFromModelL(validityNode); |
|
156 |
|
157 OPENG_DP(D_OPENG_LIT( " removed")); |
|
158 return KErrNone; |
|
159 } |
|
160 |
|
161 // --------------------------------------------------------------------------- |
|
162 // TPresCondValidity::AddValidityL() |
|
163 // --------------------------------------------------------------------------- |
|
164 // |
|
165 EXPORT_C TInt TPresCondValidity::AddValidityL(const TDesC& aRuleID, |
|
166 const TTimePeriod aValidTime) |
|
167 { |
|
168 OPENG_DP(D_OPENG_LIT( "TPresCondValidity::AddValidityL()" ) ); |
|
169 OPENG_DP(D_OPENG_LIT( " aRuleID = %S"),&aRuleID); |
|
170 OPENG_DP(D_OPENG_LIT( " from:")); |
|
171 LogDateTime(aValidTime.from); |
|
172 OPENG_DP(D_OPENG_LIT( " until:")); |
|
173 LogDateTime(aValidTime.until); |
|
174 |
|
175 CXdmDocumentNode* validityNode = GetValidityNodeL(aRuleID, ETrue); |
|
176 if(validityNode==NULL) |
|
177 return KErrNotFound; |
|
178 |
|
179 TBuf<KPresDateTimeBufLength> fromString; |
|
180 TBuf<KPresDateTimeBufLength> untilString; |
|
181 |
|
182 |
|
183 TTime fromTTime(aValidTime.from); |
|
184 TTime untilTTime(aValidTime.until); |
|
185 |
|
186 // convert to universal times |
|
187 ConvertToUniversal(fromTTime); |
|
188 ConvertToUniversal(untilTTime); |
|
189 |
|
190 // get the xml strings |
|
191 FormatToXMLTimeStringL(fromString, fromTTime); |
|
192 FormatToXMLTimeStringL(untilString, untilTTime); |
|
193 |
|
194 OPENG_DP(D_OPENG_LIT( " from: %S"), &fromString); |
|
195 OPENG_DP(D_OPENG_LIT( " until: %S"), &untilString); |
|
196 |
|
197 // make the nodes |
|
198 CXdmDocumentNode* fromNode = validityNode->CreateChileNodeL(KXdmFrom); |
|
199 CXdmDocumentNode* untilNode = validityNode->CreateChileNodeL(KXdmUntil); |
|
200 |
|
201 // make the leaf and put contents |
|
202 fromNode->SetLeafNode(ETrue); |
|
203 fromNode->SetLeafNodeContentL(fromString); |
|
204 |
|
205 untilNode->SetLeafNode(ETrue); |
|
206 untilNode->SetLeafNodeContentL(untilString); |
|
207 |
|
208 return KErrNone; |
|
209 } |
|
210 |
|
211 // --------------------------------------------------------------------------- |
|
212 // TPresCondValidity::IsTimeValidL() |
|
213 // --------------------------------------------------------------------------- |
|
214 // |
|
215 EXPORT_C TBool TPresCondValidity::IsTimeValidL(const TDesC& aRuleID, |
|
216 const TTimePeriod aTime) |
|
217 { |
|
218 OPENG_DP(D_OPENG_LIT( "TPresCondValidity::IsTimeValid()" ) ); |
|
219 OPENG_DP(D_OPENG_LIT( " aRuleID = %S"),&aRuleID); |
|
220 OPENG_DP(D_OPENG_LIT( " from:")); |
|
221 LogDateTime(aTime.from); |
|
222 OPENG_DP(D_OPENG_LIT( " until:")); |
|
223 LogDateTime(aTime.until); |
|
224 |
|
225 |
|
226 CXdmDocumentNode* validityNode = GetValidityNodeL(aRuleID, EFalse); |
|
227 if (validityNode==NULL) |
|
228 return ETrue; // because all times are valid if no validity node |
|
229 |
|
230 TBool result(EFalse); |
|
231 |
|
232 RArray<TTimePeriod> validTimes; |
|
233 GetValidityL(aRuleID, validTimes); |
|
234 |
|
235 TTime givenfromTime(aTime.from); |
|
236 TTime givenuntilTime(aTime.until); |
|
237 |
|
238 TInt validTimeCounts = validTimes.Count(); |
|
239 for(TInt i=0; i<validTimeCounts; i++) |
|
240 { |
|
241 TTime fromTime((validTimes[i]).from); |
|
242 TTime untilTime((validTimes[i]).until); |
|
243 |
|
244 if( (givenfromTime>=fromTime) && (givenuntilTime<=untilTime) ) |
|
245 { |
|
246 result = ETrue; |
|
247 break; |
|
248 } |
|
249 } |
|
250 |
|
251 validTimes.Close(); |
|
252 OPENG_DP(D_OPENG_LIT( " result = %d"),result); |
|
253 return result; |
|
254 } |
|
255 |
|
256 // --------------------------------------------------------------------------- |
|
257 // TPresCondValidity::GetValidityNode() |
|
258 // --------------------------------------------------------------------------- |
|
259 // |
|
260 CXdmDocumentNode* TPresCondValidity::GetValidityNodeL(const TDesC& aRuleID, |
|
261 TBool aCreate) |
|
262 { |
|
263 OPENG_DP(D_OPENG_LIT( " TPresCondValidity::GetValidityNodeL()" ) ); |
|
264 OPENG_DP(D_OPENG_LIT( " GetValidityNodeL aRuleID = %S, aCreate = %d"), |
|
265 &aRuleID, aCreate); |
|
266 |
|
267 __ASSERT_ALWAYS(iPresXDM, User::Leave(KErrNotReady)); |
|
268 |
|
269 CXdmDocumentNode* conditionNode = iPresXDM->GetRuleChildNodeL(aRuleID, |
|
270 KXdmConditions, aCreate); |
|
271 if (conditionNode==NULL) |
|
272 return conditionNode; |
|
273 |
|
274 RPointerArray<CXdmDocumentNode> nodes; |
|
275 CXdmDocumentNode* validityNode(NULL); |
|
276 |
|
277 // Finding sphere node |
|
278 conditionNode->Find(KXdmValidity, nodes); |
|
279 OPENG_DP(D_OPENG_LIT( " GetValidityNodeL nodeCount = %d"),nodes.Count()); |
|
280 if(nodes.Count()) // if identity node exist |
|
281 { |
|
282 validityNode = nodes[0]; // only one sphere node can exist |
|
283 } |
|
284 else if (aCreate) // if asked to create |
|
285 { |
|
286 validityNode = conditionNode->CreateChileNodeL(KXdmValidity); |
|
287 } |
|
288 |
|
289 nodes.Close(); |
|
290 return validityNode; |
|
291 } |
|
292 |
|
293 |
|
294 // --------------------------------------------------------------------------- |
|
295 // TPresCondValidity::ParseFromXMLTimeString() |
|
296 // --------------------------------------------------------------------------- |
|
297 // |
|
298 TInt TPresCondValidity::ParseFromXMLTimeString(const TDesC& aXMLTimeString, |
|
299 TTime& aUTCDateTime) |
|
300 { |
|
301 OPENG_DP(D_OPENG_LIT( " TPresCondValidity::ParseFromXMLTimeString()" ) ); |
|
302 OPENG_DP(D_OPENG_LIT( " ParseFromXMLTimeString aXMLTimeString = %S"), |
|
303 &aXMLTimeString); |
|
304 |
|
305 TInt err(KErrNone); |
|
306 |
|
307 // Initializing the locale |
|
308 TLocale myLocale, systemLocale; |
|
309 myLocale.Refresh(); |
|
310 systemLocale.Refresh(); |
|
311 myLocale.SetDateFormat(EDateJapanese); |
|
312 myLocale.SetDateSeparator('-',1); |
|
313 myLocale.SetDateSeparator('-',2); |
|
314 myLocale.SetDateSeparator('T',3); |
|
315 |
|
316 myLocale.SetTimeFormat(ETime24); |
|
317 myLocale.SetTimeSeparator(':',1); |
|
318 myLocale.SetTimeSeparator(':',2); |
|
319 myLocale.SetTimeSeparator(' ',3); |
|
320 myLocale.Set(); |
|
321 |
|
322 TTime myTime; |
|
323 TTime myUTCtime; |
|
324 TChar uTCtimeSign(aXMLTimeString[23]); // 23 is ascii T |
|
325 |
|
326 |
|
327 // parsing main time |
|
328 TBuf<KPresDateTimeBufLength> dateTimeBuffer(aXMLTimeString); |
|
329 dateTimeBuffer.Delete(KPresDTWithoutUTCLength-1,6); |
|
330 dateTimeBuffer.Replace(KPresDTSeperatorPos,1,KPresSpaceString); |
|
331 myTime.Parse(dateTimeBuffer); |
|
332 |
|
333 // parsing utc time |
|
334 TBuf<KPresDateTimeBufLength> uTCbuffer(aXMLTimeString); |
|
335 uTCbuffer.Delete(0,KPresDTWithoutUTCLength); |
|
336 myUTCtime.Parse(uTCbuffer); |
|
337 TDateTime uTCDateTime = myUTCtime.DateTime(); |
|
338 |
|
339 // adding or substracting utc from main time |
|
340 if(uTCtimeSign=='+') // if diff is positive |
|
341 { |
|
342 aUTCDateTime = myTime - TTimeIntervalHours(uTCDateTime.Hour()); |
|
343 aUTCDateTime = aUTCDateTime - TTimeIntervalMinutes(uTCDateTime.Minute()); |
|
344 } |
|
345 else if(uTCtimeSign=='-') |
|
346 { |
|
347 aUTCDateTime = myTime + TTimeIntervalHours(uTCDateTime.Hour()); |
|
348 aUTCDateTime = aUTCDateTime + TTimeIntervalMinutes(uTCDateTime.Minute()); |
|
349 } |
|
350 else |
|
351 err = KErrArgument; |
|
352 |
|
353 // putting the system locale back |
|
354 systemLocale.Set(); |
|
355 return err; |
|
356 } |
|
357 |
|
358 // --------------------------------------------------------------------------- |
|
359 // TPresCondValidity::FormatToXMLTimeStringL() |
|
360 // --------------------------------------------------------------------------- |
|
361 // |
|
362 TInt TPresCondValidity::FormatToXMLTimeStringL(TDes& aXMLTimeString, |
|
363 const TTime aUTCDateTime) |
|
364 { |
|
365 OPENG_DP(D_OPENG_LIT( " TPresCondValidity::FormatToXMLTimeString()" ) ); |
|
366 OPENG_DP(D_OPENG_LIT( " FormatToXMLTimeString aUTCDateTime:")); |
|
367 LogDateTime(aUTCDateTime.DateTime()); |
|
368 |
|
369 // Initializing the locale |
|
370 TLocale myLocale, systemLocale; |
|
371 myLocale.Refresh(); |
|
372 systemLocale.Refresh(); |
|
373 myLocale.SetDateFormat(EDateJapanese); |
|
374 myLocale.SetDateSeparator('-',1); |
|
375 myLocale.SetDateSeparator('-',2); |
|
376 myLocale.SetDateSeparator('T',3); |
|
377 |
|
378 myLocale.SetTimeFormat(ETime24); |
|
379 myLocale.SetTimeSeparator(':',1); |
|
380 myLocale.SetTimeSeparator(':',2); |
|
381 myLocale.SetTimeSeparator(' ',3); |
|
382 myLocale.Set(); |
|
383 |
|
384 // getting UTC difference |
|
385 TTimeIntervalSeconds uTCseconds = systemLocale.UniversalTimeOffset(); |
|
386 |
|
387 // processing main time and date component |
|
388 TTime mainTTime = aUTCDateTime + uTCseconds; |
|
389 mainTTime.FormatL(aXMLTimeString, KPresDateTimeFormatString); |
|
390 |
|
391 // Processing for time difference |
|
392 TChar uTCtimeSign('+'); |
|
393 TDateTime myUTCtime(0,EJanuary,0,0,0,0,0); |
|
394 TTime uTCTTime(myUTCtime); |
|
395 if(uTCseconds.Int()<0) |
|
396 { |
|
397 uTCtimeSign = '-'; |
|
398 uTCseconds = (uTCseconds.Int())*(-1); |
|
399 } |
|
400 uTCTTime = uTCTTime + uTCseconds; |
|
401 TBuf<KPresDateTimeBufLength> dateTimeUTCBuffer; |
|
402 uTCTTime.FormatL(dateTimeUTCBuffer, KPresUTCFormatString); |
|
403 |
|
404 |
|
405 // Appending the time difference to main string |
|
406 aXMLTimeString.Append(dateTimeUTCBuffer); |
|
407 |
|
408 // put time difference sign to main string |
|
409 aXMLTimeString[23] = uTCtimeSign; |
|
410 |
|
411 // putting the system locale back |
|
412 systemLocale.Set(); |
|
413 return KErrNone; |
|
414 } |
|
415 |
|
416 // --------------------------------------------------------------------------- |
|
417 // TPresCondValidity::ConvertToUniversal() |
|
418 // --------------------------------------------------------------------------- |
|
419 // |
|
420 void TPresCondValidity::ConvertToUniversal(TTime& aDateTime) |
|
421 { |
|
422 OPENG_DP(D_OPENG_LIT( " TPresCondValidity::ConvertToUniversal()" ) ); |
|
423 OPENG_DP(D_OPENG_LIT( " ConvertToUniversal aDateTime:")); |
|
424 LogDateTime(aDateTime.DateTime()); |
|
425 |
|
426 TLocale myLocale; |
|
427 myLocale.Refresh(); |
|
428 |
|
429 // getting UTC difference |
|
430 TTimeIntervalSeconds uTCseconds = myLocale.UniversalTimeOffset(); |
|
431 aDateTime = aDateTime - uTCseconds; |
|
432 } |
|
433 |
|
434 // --------------------------------------------------------------------------- |
|
435 // TPresCondValidity::ConvertToLocal() |
|
436 // --------------------------------------------------------------------------- |
|
437 // |
|
438 void TPresCondValidity::ConvertToLocal(TTime& aDateTime) |
|
439 { |
|
440 OPENG_DP(D_OPENG_LIT( " TPresCondValidity::ConvertToLocal()" ) ); |
|
441 OPENG_DP(D_OPENG_LIT( " ConvertToLocal aDateTime:")); |
|
442 LogDateTime(aDateTime.DateTime()); |
|
443 |
|
444 TLocale myLocale; |
|
445 myLocale.Refresh(); |
|
446 |
|
447 // getting UTC difference |
|
448 TTimeIntervalSeconds uTCseconds = myLocale.UniversalTimeOffset(); |
|
449 aDateTime = aDateTime + uTCseconds; |
|
450 } |
|
451 |
|
452 // --------------------------------------------------------------------------- |
|
453 // TPresCondValidity::LogDateTime() |
|
454 // --------------------------------------------------------------------------- |
|
455 // |
|
456 void TPresCondValidity::LogDateTime(TDateTime aDateTime) |
|
457 { |
|
458 OPENG_DP(D_OPENG_LIT( " %d, %d, %d, %d, %d, %d, %d"), |
|
459 aDateTime.Year(), aDateTime.Month()+1, aDateTime.Day()+1, |
|
460 aDateTime.Hour(), aDateTime.Minute(), aDateTime.Second(), |
|
461 aDateTime.MicroSecond() ); |
|
462 } |
|
463 |
|
464 // end of file |
|
465 |