1 /* |
|
2 * Copyright (c) 2002-2010 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: LandmarksUi Sender class implementation |
|
15 * |
|
16 */ |
|
17 |
|
18 // INCLUDE FILES |
|
19 |
|
20 #include <e32std.h> |
|
21 #include <StringLoader.h> |
|
22 #include <f32file.h> |
|
23 |
|
24 #include <AknWaitDialog.h> |
|
25 #include <coemain.h> |
|
26 #include <eikmenup.h> |
|
27 #include <AknQueryDialog.h> |
|
28 #include <sendui.h> |
|
29 #include <SenduiMtmUids.h> |
|
30 #include <CMessageData.h> |
|
31 #include <EPos_CPosLandmarkDatabase.h> |
|
32 #include <EPos_CPosLandmark.h> |
|
33 #include <EPos_CPosLmCategoryManager.h> |
|
34 #include <lmkui.rsg> |
|
35 #include "LmkConsts.h" |
|
36 #include "CLmkEncoder.h" |
|
37 #include "landmarks.hrh" |
|
38 #include "CLmkUiUtils.h" |
|
39 #include "LmkFileUtils.h" |
|
40 #include "Debug.h" |
|
41 #include "CLmkSender.h" |
|
42 #include "CLmkFields.h" |
|
43 #include "LmkConsts.h" |
|
44 #include "CLmkDbUtils.h" |
|
45 #include <CSendingServiceInfo.h> |
|
46 #include <lmkerrors.h> |
|
47 |
|
48 // CONSTANTS |
|
49 //for the sendui query |
|
50 const static TInt KBluetooth = 0x10009ed5; |
|
51 const static TInt KInfrared = 0x100053A4; |
|
52 const static TInt KEmail = 0x10001028; |
|
53 const static TInt KMessaging = 0x102072D6; |
|
54 |
|
55 const TInt KNumOfReplaceChars(25); |
|
56 |
|
57 /// Unnamed namespace for local definitions |
|
58 namespace |
|
59 { |
|
60 const TInt KLmkMtmFilterGranularity(8); |
|
61 #if defined(_DEBUG) |
|
62 _LIT( KPanicMsg, "CLmkSender" ); |
|
63 |
|
64 void Panic(TPanicCode aReason) |
|
65 { |
|
66 User::Panic(KPanicMsg, aReason); |
|
67 } |
|
68 #endif |
|
69 } // namespace |
|
70 |
|
71 // ============================ MEMBER FUNCTIONS =============================== |
|
72 |
|
73 // ----------------------------------------------------------------------------- |
|
74 // CLmkSender::CLmkSender |
|
75 // C++ default constructor can NOT contain any code, that |
|
76 // might leave. |
|
77 // ----------------------------------------------------------------------------- |
|
78 // |
|
79 CLmkSender::CLmkSender(CPosLandmarkDatabase& aDb) : |
|
80 iLastOperationResult(KErrNone), iDb(aDb) |
|
81 { |
|
82 } |
|
83 |
|
84 // ---------------------------------------------------- |
|
85 // CLmkSender::ConstructL |
|
86 // ---------------------------------------------------- |
|
87 // |
|
88 void CLmkSender::ConstructL(CPosLandmarkDatabase& aDb) |
|
89 { |
|
90 iSendUi = CSendUi::NewL(); |
|
91 iEncoder = CLmkEncoder::NewL(aDb, *this, ETrue); |
|
92 } |
|
93 |
|
94 // ----------------------------------------------------------------------------- |
|
95 // CLmkSender::NewL |
|
96 // Two-phased constructor. |
|
97 // ----------------------------------------------------------------------------- |
|
98 // |
|
99 EXPORT_C CLmkSender* CLmkSender::NewL(CPosLandmarkDatabase& aDb) |
|
100 { |
|
101 CLmkSender* self = new (ELeave) CLmkSender(aDb); |
|
102 CleanupStack::PushL(self); |
|
103 self->ConstructL(aDb); |
|
104 CleanupStack::Pop(); |
|
105 return self; |
|
106 } |
|
107 |
|
108 // ---------------------------------------------------- |
|
109 // CLmkSender::~CLmkSender |
|
110 // ---------------------------------------------------- |
|
111 // |
|
112 CLmkSender::~CLmkSender() |
|
113 { |
|
114 if (iWaitNote) |
|
115 { |
|
116 TRAPD( err, iWaitNote->ProcessFinishedL() ); |
|
117 if (err != KErrNone) |
|
118 { |
|
119 delete iWaitNote; |
|
120 iWaitNote = NULL; |
|
121 } |
|
122 } |
|
123 delete iEncoder; |
|
124 delete iSendUi; |
|
125 } |
|
126 |
|
127 // --------------------------------------------------------- |
|
128 // CLmkSender::DisplaySendMenuL |
|
129 // --------------------------------------------------------- |
|
130 // |
|
131 EXPORT_C void CLmkSender::DisplaySendMenuL(CEikMenuPane& aMenuPane, |
|
132 TInt aVisibleCount, TInt aMenuTextResource) const |
|
133 { |
|
134 TInt pos(0); |
|
135 aMenuPane.ItemAndPos(ELmkCmdSendDummy, pos); |
|
136 // Set dummy command dimmed anyway. It was only needed because |
|
137 // SendUI needs to know the right position: |
|
138 aMenuPane.SetItemDimmed(ELmkCmdSendDummy, ETrue); |
|
139 |
|
140 // Now if there are items visible then let SendUi check whether |
|
141 // option can be shown: |
|
142 if (aVisibleCount > 0) |
|
143 { |
|
144 TSendingCapabilities capabilities(0, 0, |
|
145 TSendingCapabilities::EAllServices); |
|
146 iSendUi->AddSendMenuItemL(aMenuPane, pos, ELmkCmdSend, capabilities); |
|
147 |
|
148 // Set menu item text to desired value since previous operation |
|
149 // overrides it with SendUI default value. |
|
150 if (aMenuTextResource != KZeroResourceId) |
|
151 { |
|
152 aMenuPane.SetItemTextL(ELmkCmdSend, aMenuTextResource); |
|
153 } |
|
154 } |
|
155 } |
|
156 |
|
157 // --------------------------------------------------------- |
|
158 // CLmkSender::DisplaySendCascadeMenuL |
|
159 // --------------------------------------------------------- |
|
160 // |
|
161 EXPORT_C void CLmkSender::DisplaySendCascadeMenuL(CEikMenuPane& /*aMenuPane*/) const |
|
162 { |
|
163 // Construct the MTM filter |
|
164 CArrayFixFlat<TUid>* mtmFilter = new (ELeave) CArrayFixFlat<TUid> ( |
|
165 KLmkMtmFilterGranularity); |
|
166 CleanupStack::PushL(mtmFilter); |
|
167 mtmFilter->AppendL(KSenduiMtmSmsUid); // hide SMS |
|
168 mtmFilter->AppendL(KSenduiMtmFaxUid); // hide fax |
|
169 CleanupStack::PopAndDestroy(); // mtmFilter |
|
170 } |
|
171 |
|
172 // ---------------------------------------------------- |
|
173 // CLmkSender::CreateAndSendL |
|
174 // ---------------------------------------------------- |
|
175 // |
|
176 void CLmkSender::CreateAndSendL(TInt aCommandId, |
|
177 const RArray<TPosLmItemId>& aMarkedIds, TPosLmItemId aSelectedId) |
|
178 { |
|
179 DEBUG( CLmkSender::CreateAndSendL entered ); |
|
180 HBufC* filePath; |
|
181 PrepareSendFilePathL(filePath); |
|
182 TPtr ptr = filePath->Des(); |
|
183 TInt markedCount = aMarkedIds.Count(); |
|
184 if (markedCount == 0 || markedCount == 1) |
|
185 { |
|
186 // One item only marked or unmarked |
|
187 RArray<TPosLmItemId> lmIdArray(1); |
|
188 CleanupClosePushL(lmIdArray); |
|
189 User::LeaveIfError(lmIdArray.Append(aSelectedId)); |
|
190 CPosLandmark* landmark = iDb.ReadLandmarkLC(aSelectedId); |
|
191 HBufC* webUrl = HBufC::NewL(KMaxBufferLen); |
|
192 CleanupStack::PushL(webUrl); |
|
193 TPtrC urlDes = webUrl->Des(); |
|
194 landmark->GetPositionField(ELmkPositionFieldWebAddress, urlDes); |
|
195 if (urlDes.Length() > KMaxUrlFieldLenWithDefaultProtocol) |
|
196 { |
|
197 TInt pos = urlDes.Find(KProtocol); |
|
198 if (pos == KErrNotFound) |
|
199 { |
|
200 webUrl = webUrl->ReAllocL(KHttp().Length() + urlDes.Length()); |
|
201 TPtr url = webUrl->Des(); |
|
202 webUrl->Des().Copy(urlDes); |
|
203 webUrl->Des().Insert(0, KHttp); |
|
204 landmark->SetPositionFieldL(ELmkPositionFieldWebAddress, |
|
205 webUrl->Des()); |
|
206 } |
|
207 } |
|
208 CleanupStack::PopAndDestroy();//webUrl |
|
209 TPtrC landmarkName; |
|
210 TInt retVal(0); |
|
211 retVal = landmark->GetLandmarkName(landmarkName); |
|
212 if (retVal == KErrNone) |
|
213 { |
|
214 iEncoder->StartEncodingL(landmarkName, lmIdArray); |
|
215 ptr.Append(landmarkName); |
|
216 } |
|
217 else |
|
218 { |
|
219 iEncoder->StartEncodingL(KLmkEncodedDataFileName, lmIdArray); |
|
220 ptr.Append(KLmkEncodedDataFileName); |
|
221 } |
|
222 SendL(ptr, aCommandId); |
|
223 CleanupStack::PopAndDestroy(2); //landmark, lmIdArray |
|
224 } |
|
225 else |
|
226 { |
|
227 HBufC* pckgName; |
|
228 TPtrC currentPckgName;//not really used, only for passing to the func. |
|
229 if (QueryNewPackageNameLC(currentPckgName, pckgName)) |
|
230 { |
|
231 TPtr name = pckgName->Des(); |
|
232 iEncoder->StartEncodingL(name, aMarkedIds); |
|
233 ptr.Append(name); |
|
234 SendL(ptr, aCommandId); |
|
235 } |
|
236 CleanupStack::PopAndDestroy(); |
|
237 } |
|
238 CleanupStack::PopAndDestroy(filePath); //filePath |
|
239 } |
|
240 // ---------------------------------------------------- |
|
241 // CLmkSender::HandleOperationL |
|
242 // ---------------------------------------------------- |
|
243 // |
|
244 void CLmkSender::HandleOperationL(TOperationTypes /*aType*/, |
|
245 TReal32 /*aProgress*/, TInt aStatus) |
|
246 { |
|
247 if (aStatus != KPosLmOperationNotComplete) |
|
248 { |
|
249 __ASSERT_DEBUG( iWaitNote, Panic( KLmkPanicNullMember ) ); |
|
250 iWaitNote->ProcessFinishedL(); |
|
251 iWaitNote = NULL; |
|
252 iLastOperationResult = aStatus; |
|
253 } |
|
254 } |
|
255 |
|
256 // ---------------------------------------------------- |
|
257 // CLmkSender::SendLandmarksL |
|
258 // ---------------------------------------------------- |
|
259 // |
|
260 void CLmkSender::SendLandmarksL(TInt aCommandId, const TDesC& aPackageName, |
|
261 const RPointerArray<CLmkLandmark>& aLandmarks) |
|
262 { |
|
263 DEBUG( CLmkSender::SendMultipleLandmarkL entered ); |
|
264 TInt lmkCount = aLandmarks.Count(); |
|
265 __ASSERT_DEBUG(lmkCount > 0, Panic( KLmkPanicNullMember ) ); |
|
266 if (lmkCount == 1) |
|
267 { |
|
268 SendSingleLandmarkL(aCommandId, aLandmarks); |
|
269 } |
|
270 else |
|
271 { |
|
272 SendLandmarksPackageL(aCommandId, aPackageName, aLandmarks); |
|
273 } |
|
274 } |
|
275 |
|
276 // ---------------------------------------------------- |
|
277 // CLmkSender::SendSingleLandmarkL |
|
278 // ---------------------------------------------------- |
|
279 // |
|
280 void CLmkSender::SendSingleLandmarkL(const CPosLandmark& alandmark) |
|
281 { |
|
282 CLmkLandmark* lmkLandmark; |
|
283 LmkLandmarkFromPosLandmarkL(lmkLandmark, alandmark); |
|
284 SendSingleLandmarkL(ELmkCmdSend, *lmkLandmark); |
|
285 CleanupStack::PopAndDestroy();//landMarkLmk |
|
286 } |
|
287 |
|
288 // ---------------------------------------------------- |
|
289 // CLmkSender::SendSingleLandmarkL() |
|
290 // ---------------------------------------------------- |
|
291 // |
|
292 void CLmkSender::SendSingleLandmarkL(TInt aCommandId, |
|
293 const CLmkLandmark& alandmark) |
|
294 { |
|
295 TPtrC ptr; |
|
296 RPointerArray<CLmkLandmark> landmark; |
|
297 landmark.Append(&alandmark); |
|
298 SendLandmarksL(aCommandId, ptr, landmark); |
|
299 landmark.Close(); |
|
300 } |
|
301 |
|
302 // ---------------------------------------------------- |
|
303 // CLmkSender::SendSingleLandmarkL() |
|
304 // ---------------------------------------------------- |
|
305 // |
|
306 void CLmkSender::SendSingleLandmarkL(TInt aCommandId, const RPointerArray< |
|
307 CLmkLandmark>& aLandmarks) |
|
308 { |
|
309 HBufC* filePath; |
|
310 PrepareSendFilePathL(filePath); |
|
311 TPtr ptr = filePath->Des(); |
|
312 CLmkLandmark* lmk = aLandmarks[0]; |
|
313 CPosLandmark* landmark = lmk->PosLandmark(); |
|
314 CLmkDbUtils::AddDefaultProtocolL(landmark); |
|
315 TPtrC landmarkName; |
|
316 TInt retVal(KErrNone); |
|
317 retVal = landmark->GetLandmarkName(landmarkName); |
|
318 |
|
319 if (retVal == KErrNone && LmkFileUtils::IsValidPathL(landmarkName)) |
|
320 { |
|
321 TRAP(retVal,iEncoder->StartEncodingL(landmarkName,aLandmarks)); |
|
322 if (retVal == KErrNone) |
|
323 { |
|
324 ptr.Append(landmarkName); |
|
325 } |
|
326 } |
|
327 else |
|
328 { |
|
329 retVal = KErrBadName; |
|
330 } |
|
331 |
|
332 if (retVal != KErrNone) |
|
333 { |
|
334 TPtr lmName = ReplaceSpecialCharactersL(landmarkName); |
|
335 TRAP(retVal,iEncoder->StartEncodingL(lmName,aLandmarks)); |
|
336 if (retVal == KErrNone) |
|
337 { |
|
338 ptr.Append(lmName); |
|
339 } |
|
340 else |
|
341 { |
|
342 iEncoder->StartEncodingL(KLmkEncodedDataFileName, aLandmarks); |
|
343 ptr.Append(KLmkEncodedDataFileName); |
|
344 } |
|
345 } |
|
346 SendL(ptr, aCommandId); |
|
347 CleanupStack::PopAndDestroy(filePath); //filePath |
|
348 } |
|
349 |
|
350 // ---------------------------------------------------- |
|
351 // CLmkSender::SendLandmarksPackageL |
|
352 // ---------------------------------------------------- |
|
353 // |
|
354 void CLmkSender::SendLandmarksPackageL(TInt aCommandId, |
|
355 const TDesC& aPackageName, |
|
356 const RPointerArray<CLmkLandmark>& aLandmarks) |
|
357 { |
|
358 HBufC* pckgName; |
|
359 HBufC* filePath; |
|
360 PrepareSendFilePathL(filePath); |
|
361 TPtr ptr = filePath->Des(); |
|
362 if (QueryNewPackageNameLC(aPackageName, pckgName)) |
|
363 { |
|
364 TPtr desName = pckgName->Des(); |
|
365 iEncoder->StartEncodingL(desName, aLandmarks); |
|
366 ptr.Append(desName); |
|
367 SendL(ptr, aCommandId); |
|
368 } |
|
369 CleanupStack::PopAndDestroy(2); |
|
370 } |
|
371 |
|
372 // ---------------------------------------------------- |
|
373 // CLmkSender::SendL() |
|
374 // ---------------------------------------------------- |
|
375 // |
|
376 void CLmkSender::SendL(TDes& aFilePath, TInt aCommandId) |
|
377 { |
|
378 aFilePath.Append(KLmkEncodedDataFileExtension); |
|
379 iWaitNote = new (ELeave) CAknWaitDialog(NULL, ETrue); |
|
380 if (iWaitNote->ExecuteLD(R_LMK_ENCODING_WAIT_NOTE)) |
|
381 { |
|
382 if (iLastOperationResult == KErrNone) |
|
383 { |
|
384 RFs fs; |
|
385 User::LeaveIfError(fs.Connect()); |
|
386 CleanupClosePushL(fs); |
|
387 User::LeaveIfError(fs.ShareProtected()); |
|
388 RFile fileHandle; |
|
389 User::LeaveIfError(fileHandle.Open(fs, aFilePath, EFileShareAny)); |
|
390 CleanupClosePushL(fileHandle); |
|
391 TRAPD( err, SendFileL( aCommandId, fileHandle, ETrue)); |
|
392 if (err != KErrNone) |
|
393 { |
|
394 CleanupStack::PopAndDestroy(); // fileHandle |
|
395 LmkFileUtils::DeleteFileL(aFilePath); |
|
396 CleanupStack::PopAndDestroy(); // fs |
|
397 User::LeaveIfError(err); |
|
398 } |
|
399 CleanupStack::PopAndDestroy(); // fileHandle |
|
400 LmkFileUtils::DeleteFileL(aFilePath); |
|
401 CleanupStack::PopAndDestroy(); // fs |
|
402 } |
|
403 else |
|
404 { // error situation |
|
405 CCoeEnv::Static()->HandleError(iLastOperationResult); |
|
406 } |
|
407 } |
|
408 else |
|
409 { |
|
410 //making iWaitNote null, since framework destroys waitnote |
|
411 //dialog on pressing cancel. |
|
412 iWaitNote = NULL; |
|
413 iEncoder->CancelEncodeOperationL(); |
|
414 } |
|
415 } |
|
416 |
|
417 // ---------------------------------------------------- |
|
418 // CLmkSender::SendFileL |
|
419 // ---------------------------------------------------- |
|
420 // |
|
421 void CLmkSender::SendFileL(TInt /*aCommandId*/, const TDesC& aFile, |
|
422 TBool aDeleteSentFile) |
|
423 { |
|
424 DEBUG( CLmkSender::SendFileL entered ); |
|
425 |
|
426 // one attachment only: |
|
427 CMessageData * messageData = CMessageData::NewL(); |
|
428 CleanupStack::PushL( messageData ); |
|
429 messageData->AppendAttachmentL( aFile ); |
|
430 DEBUG( CLmkSender::SendFileL: calling SendUI ); |
|
431 LoadFilteredSendListQueryL(messageData); |
|
432 DEBUG( CLmkSender::SendFileL: SendUI returned ); |
|
433 |
|
434 // Delete the file since it is no more needed |
|
435 if( aDeleteSentFile ) |
|
436 { |
|
437 LmkFileUtils::DeleteFileL( aFile ); |
|
438 } |
|
439 CleanupStack::PopAndDestroy( messageData ); |
|
440 } |
|
441 |
|
442 // ---------------------------------------------------- |
|
443 // CLmkSender::SendFileL -- FileHandle version |
|
444 // ---------------------------------------------------- |
|
445 // |
|
446 void CLmkSender::SendFileL(TInt /*aCommandId*/, RFile& aFile, TBool /*aDeleteSentFile*/) |
|
447 { |
|
448 DEBUG( CLmkSender::SendFileL entered ); |
|
449 |
|
450 // one attachment only: |
|
451 CMessageData * messageData = CMessageData::NewL(); |
|
452 CleanupStack::PushL(messageData); |
|
453 messageData->AppendAttachmentHandleL(aFile); |
|
454 DEBUG( CLmkSender::SendFileL: calling SendUI ); |
|
455 LoadFilteredSendListQueryL(messageData); |
|
456 CleanupStack::PopAndDestroy(); //messageData |
|
457 DEBUG( CLmkSender::SendFileL: SendUI returned ); |
|
458 } |
|
459 |
|
460 // ---------------------------------------------------- |
|
461 // CLmkSender::QueryPackageName |
|
462 // ---------------------------------------------------- |
|
463 // |
|
464 TBool CLmkSender::QueryNewPackageNameLC(const TDesC& aCurrentPckgName, |
|
465 HBufC*& aNewPackageName) |
|
466 { |
|
467 TBool retVal = EFalse; |
|
468 HBufC* pkgName = StringLoader::LoadL(R_LMK_DEFAULT_PACKAGE_NAME, |
|
469 CEikonEnv::Static()); |
|
470 |
|
471 if (aCurrentPckgName.Length() > pkgName->Des().Length()) |
|
472 { |
|
473 delete pkgName; |
|
474 pkgName = NULL; |
|
475 pkgName = HBufC::NewL(aCurrentPckgName.Length()); |
|
476 pkgName->Des().Copy(aCurrentPckgName); |
|
477 } |
|
478 |
|
479 TPtr desName = pkgName->Des(); |
|
480 |
|
481 CAknTextQueryDialog* dlg = new (ELeave) CAknTextQueryDialog(desName, |
|
482 CAknQueryDialog::ENoTone); |
|
483 if (dlg->ExecuteLD(R_LMK_PACKAGE_NAME_QUERY)) |
|
484 { |
|
485 retVal = ETrue; |
|
486 if (!LmkFileUtils::IsValidPathL(desName)) |
|
487 { |
|
488 delete pkgName; |
|
489 pkgName = NULL; |
|
490 |
|
491 TInt len = KLmkEncodedDataFileName().Length(); |
|
492 aNewPackageName = HBufC::NewLC(len); |
|
493 aNewPackageName->Des().Copy(KLmkEncodedDataFileName); |
|
494 return retVal; |
|
495 } |
|
496 } |
|
497 aNewPackageName = HBufC::NewLC(pkgName->Des().Length()); |
|
498 aNewPackageName->Des().Copy(pkgName->Des()); |
|
499 |
|
500 delete pkgName; |
|
501 pkgName = NULL; |
|
502 |
|
503 return retVal; |
|
504 } |
|
505 |
|
506 // ---------------------------------------------------- |
|
507 // CLmkSender::LmkLandmarkFromPosLandmarkL() |
|
508 // ---------------------------------------------------- |
|
509 // |
|
510 void CLmkSender::LmkLandmarkFromPosLandmarkL(CLmkLandmark*& aLmkLandmark, |
|
511 const CPosLandmark& aPosLandmark) |
|
512 { |
|
513 RArray<TPosLmItemId> categoryIdArray; |
|
514 RPointerArray<CPosLandmarkCategory> categories; |
|
515 aPosLandmark.GetCategoriesL(categoryIdArray); |
|
516 |
|
517 CPosLmCategoryManager* categoryMgr = CPosLmCategoryManager::NewL(iDb); |
|
518 CleanupStack::PushL(categoryMgr); |
|
519 TInt catCount = categoryIdArray.Count(); |
|
520 for (TInt i = 0; i < catCount; i++) |
|
521 { |
|
522 TPosLmItemId catId = categoryIdArray[i]; |
|
523 CPosLandmarkCategory* category = categoryMgr->ReadCategoryLC(catId); |
|
524 categories.Append(category); |
|
525 CleanupStack::Pop(); |
|
526 } |
|
527 categoryIdArray.Close(); |
|
528 CleanupStack::PopAndDestroy();//categoryMgr |
|
529 aLmkLandmark = CLmkLandmark::NewL(&aPosLandmark, categories); |
|
530 CleanupStack::PushL(aLmkLandmark); |
|
531 categories.ResetAndDestroy(); |
|
532 } |
|
533 |
|
534 // ---------------------------------------------------- |
|
535 // CLmkSender::PrepareSendFilePathL() |
|
536 // ---------------------------------------------------- |
|
537 // |
|
538 void CLmkSender::PrepareSendFilePathL(HBufC*& aFilePath) |
|
539 { |
|
540 // Full path name (private path c:\\private\\UID3 + pacakge File name + File bname Extension) |
|
541 aFilePath = HBufC::NewLC(2 * KLmkPackageNameMaxLen |
|
542 + KLmkEncodedDataFileExtension().Length()); |
|
543 TPtr ptr = aFilePath->Des(); |
|
544 |
|
545 // Create the private path(c:\\private\\UID3) for Landmarks UI application |
|
546 TFileName fileName; |
|
547 RFs fs; |
|
548 User::LeaveIfError(fs.Connect()); |
|
549 CleanupClosePushL(fs); |
|
550 fs.SessionPath(fileName); |
|
551 fs.MkDirAll(fileName); |
|
552 aFilePath->Des().Append(fileName); |
|
553 CleanupStack::PopAndDestroy(); // fs |
|
554 } |
|
555 |
|
556 // ---------------------------------------------------- |
|
557 // CLmkSender::PrepareMultipleLandmarkForSendL() |
|
558 // ---------------------------------------------------- |
|
559 // |
|
560 void CLmkSender::PrepareMultipleLandmarkForSendL( |
|
561 RPointerArray<CLmkLandmark>& aLmkLandmark, |
|
562 const RArray<TPosLmItemId>& aMarkedIds) |
|
563 { |
|
564 /* |
|
565 This function prepares an array of CLmkLandmark from given |
|
566 landmark ids. |
|
567 */ |
|
568 for (TInt i = 0; i < aMarkedIds.Count(); i++) |
|
569 { |
|
570 CPosLandmark* landmark = iDb.ReadLandmarkLC(aMarkedIds[i]); |
|
571 CLmkLandmark* lmk; |
|
572 LmkLandmarkFromPosLandmarkL(lmk, *landmark); |
|
573 CleanupStack::Pop(lmk); |
|
574 User::LeaveIfError(aLmkLandmark.Append(lmk)); |
|
575 CleanupStack::PopAndDestroy();//landmark |
|
576 } |
|
577 } |
|
578 |
|
579 // ---------------------------------------------------- |
|
580 // CLmkSender::LoadFilteredSendListQueryL() |
|
581 // ---------------------------------------------------- |
|
582 // |
|
583 void CLmkSender::LoadFilteredSendListQueryL(const CMessageData* aMessageData) |
|
584 { |
|
585 /** |
|
586 * Currently we need to show only four services in the sendui query |
|
587 * 1.via messaging |
|
588 * 2.via bluetooth |
|
589 * 3.via infrared |
|
590 * 4.via email |
|
591 */ |
|
592 RPointerArray<CSendingServiceInfo> serviceList; |
|
593 CleanupClosePushL(serviceList); |
|
594 //load all the available services |
|
595 iSendUi->AvailableServicesL(serviceList); |
|
596 TInt count = serviceList.Count(); |
|
597 CArrayFixFlat<TUid>* serviceFilter = new (ELeave) CArrayFixFlat<TUid> ( |
|
598 count); |
|
599 CleanupStack::PushL(serviceFilter); |
|
600 for (TInt i = 0; i < count; i++) |
|
601 { |
|
602 CSendingServiceInfo* info = serviceList[i]; |
|
603 TPtrC ptr = info->ServiceName(); |
|
604 CleanupStack::PushL(info); |
|
605 TUid id = info->ServiceId(); |
|
606 //check if this service is not one of the required list |
|
607 if (id.iUid != KBluetooth && id.iUid != KInfrared && id.iUid |
|
608 != KEmail && id.iUid != KMessaging) |
|
609 { |
|
610 //unwanted serivce list for filtering. |
|
611 serviceFilter->AppendL(info->ServiceId()); |
|
612 } |
|
613 CleanupStack::PopAndDestroy();//info |
|
614 } |
|
615 TSendingCapabilities capabilities(0, 0, |
|
616 TSendingCapabilities::ESupportsAttachments); |
|
617 iSendUi->ShowQueryAndSendL(aMessageData, capabilities, serviceFilter); |
|
618 CleanupStack::PopAndDestroy(2);//serviceList,serviceFilter |
|
619 } |
|
620 |
|
621 // ---------------------------------------------------- |
|
622 // CLmkSender::ReplaceSpecialCharactersL |
|
623 // ---------------------------------------------------- |
|
624 // |
|
625 TPtr CLmkSender::ReplaceSpecialCharactersL(TPtrC aText) |
|
626 { |
|
627 TBuf<KNumOfReplaceChars> replaceChars; |
|
628 replaceChars.Zero(); |
|
629 |
|
630 // special chars from Unicode/Character reference |
|
631 replaceChars.Append(0x0022); // """ |
|
632 replaceChars.Append(0x002A); // "*" |
|
633 replaceChars.Append(0x002F); // "/" |
|
634 |
|
635 replaceChars.Append(0x003A); // ":" |
|
636 replaceChars.Append(0x003C); // "<" |
|
637 replaceChars.Append(0x003E); // ">" |
|
638 replaceChars.Append(0x003F); // "?" |
|
639 replaceChars.Append(0x005C); // "\" |
|
640 replaceChars.Append(0x007C); // "|" |
|
641 |
|
642 TInt nameLength = KLmkEncodedDataFileName.iTypeLength; |
|
643 if (nameLength < aText.Length()) |
|
644 { |
|
645 nameLength = aText.Length(); |
|
646 } |
|
647 HBufC* buffer = HBufC::NewLC(nameLength); |
|
648 TPtr des1 = buffer->Des(); |
|
649 des1.Copy(aText); |
|
650 AknTextUtils::ReplaceCharacters(des1, replaceChars, TChar(' ')); |
|
651 |
|
652 TInt spaceCount = 0; |
|
653 for (TInt i = 0; i < des1.Length(); i++) |
|
654 { |
|
655 if (des1[i] == TChar(' ')) |
|
656 spaceCount++; |
|
657 } |
|
658 |
|
659 if (spaceCount == des1.Length()) |
|
660 { |
|
661 des1.Copy(KLmkEncodedDataFileName); |
|
662 } |
|
663 |
|
664 CleanupStack::Pop(buffer); |
|
665 return des1; |
|
666 } |
|
667 |
|
668 // End of File |
|
669 |
|