1 /* |
|
2 * Copyright (c) 2008 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: JavaCap |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include "comms.h" |
|
20 #include "rtcmessages.h" |
|
21 #include "coremessages.h" |
|
22 |
|
23 #include "logger.h" |
|
24 |
|
25 #include "javacap.h" |
|
26 #include "javacap.hrh" |
|
27 |
|
28 #include "javainifileutils.h" |
|
29 |
|
30 #include <centralrepository.h> |
|
31 #include <SWInstallerInternalCRKeys.h> |
|
32 |
|
33 #include "javastoragenames.h" // Storage constants. |
|
34 #include "securitystoragedatadefs.h" |
|
35 |
|
36 #include <javacap.rsg> |
|
37 |
|
38 _LIT(KJavaCapYes, "Yes"); |
|
39 _LIT(KJavaCapNo, "No"); |
|
40 _LIT(KUserSecurityMode, "User"); |
|
41 _LIT(KNormalSecurityMode, "Default"); |
|
42 _LIT(KS60SecurityPolicyName, "S60"); |
|
43 _LIT(KMSASecurityPolicyName, "MSA"); |
|
44 _LIT(KATTSecurityPolicyName, "AT&T"); |
|
45 _LIT(KS60SecurityPolicy, "s60"); |
|
46 _LIT(KMSASecurityPolicy, "msa"); |
|
47 _LIT(KATTSecurityPolicy, "att"); |
|
48 // Java Security Policy Central Repository UID |
|
49 static const TUid KCRUidJavaSecurity = { 0x2001B289 }; |
|
50 // IDs for security folder and file keys |
|
51 static const TUint32 KPolicy = 0x03; |
|
52 static const TUint32 KSecurityWarnings = 0x04; |
|
53 const int KS60SecurityPolicyId = 1; |
|
54 const int KMSASecurityPolicyId = 2; |
|
55 const int KATTSecurityPolicyId = 3; |
|
56 |
|
57 using namespace java::storage; |
|
58 using namespace std; |
|
59 using namespace java::util; |
|
60 using namespace java::comms; |
|
61 using namespace java::captain; |
|
62 |
|
63 void CJavaCaptainContainer::ConstructL(const TRect& aRect) |
|
64 { |
|
65 JELOG2(EJavaCaptain); |
|
66 mCaptainRunning = true; |
|
67 mPrewarmEnabled = false; |
|
68 #if defined(RD_JAVA_PREWARM) && !defined (__WINS__) |
|
69 mPrewarmEnabled = true; |
|
70 #endif // RD_JAVA_PREWARM |
|
71 mPrewarmUiEnabled = false; |
|
72 mDebugEnabled = false; |
|
73 mRedirectEnabled = false; |
|
74 iStorage.reset(JavaStorage::createInstance()); |
|
75 try |
|
76 { |
|
77 iStorage->open(); |
|
78 } |
|
79 catch (JavaStorageException& aJse) |
|
80 { |
|
81 User::Leave(aJse.mStatus); |
|
82 } |
|
83 mUserSecurityModeEnabled = (GetSecurityWarningsMode() == SECURITY_WARNINGS_USER_DEFINED_MODE); |
|
84 mSecurityPolicyId = GetSecurityPolicy(); |
|
85 mHeader = _L("Java states:"); |
|
86 updateStates(); |
|
87 CreateWindowL(); |
|
88 SetRect(aRect); |
|
89 ActivateL(); |
|
90 mRedirector.reset(new LogRedirector()); |
|
91 } |
|
92 |
|
93 CJavaCaptainContainer::~CJavaCaptainContainer() |
|
94 { |
|
95 JELOG2(EJavaCaptain); |
|
96 } |
|
97 |
|
98 void CJavaCaptainContainer::Draw(const TRect& /*aRect*/) const |
|
99 { |
|
100 JELOG2(EJavaCaptain); |
|
101 CWindowGc& gc = SystemGc(); |
|
102 gc.Clear(); |
|
103 |
|
104 const CFont* usedFont = CEikonEnv::Static()->NormalFont(); |
|
105 gc.UseFont(usedFont); |
|
106 |
|
107 gc.DrawText(mHeader,TPoint(10,20)); |
|
108 int pos = 50; |
|
109 gc.DrawText(mCaptainState,TPoint(20,pos)); |
|
110 int gap = 25; |
|
111 pos += gap; |
|
112 gc.DrawText(mPrewarmState,TPoint(20,pos)); |
|
113 pos += gap; |
|
114 gc.DrawText(mPrewarmUiState,TPoint(20,pos)); |
|
115 pos += gap; |
|
116 gc.DrawText(mDebugState,TPoint(20,pos)); |
|
117 pos += gap; |
|
118 gc.DrawText(mSecurityMode,TPoint(20,pos)); |
|
119 pos += gap; |
|
120 gc.DrawText(mSecurityPolicy,TPoint(20,pos)); |
|
121 pos += gap; |
|
122 gc.DrawText(mRedirectState,TPoint(20,pos)); |
|
123 |
|
124 gc.DiscardFont(); |
|
125 } |
|
126 |
|
127 void CJavaCaptainContainer::updateStates() |
|
128 { |
|
129 |
|
130 int propertyVal = java::util::JavaIniFileUtils::getProperty(java::util::UI_PREWARM); |
|
131 if (propertyVal != -1) |
|
132 { |
|
133 mPrewarmUiEnabled = propertyVal; |
|
134 } |
|
135 |
|
136 mCaptainState = _L("Captain running: "); |
|
137 if (mCaptainRunning) |
|
138 { |
|
139 mCaptainState.Append(KJavaCapYes); |
|
140 } |
|
141 else |
|
142 { |
|
143 mCaptainState.Append(KJavaCapNo); |
|
144 } |
|
145 |
|
146 mPrewarmState = _L("Prewarm enabled: "); |
|
147 if (mPrewarmEnabled) |
|
148 { |
|
149 mPrewarmState.Append(KJavaCapYes); |
|
150 } |
|
151 else |
|
152 { |
|
153 mPrewarmState.Append(KJavaCapNo); |
|
154 } |
|
155 |
|
156 mPrewarmUiState = _L("Prewarm UI enabled: "); |
|
157 if (mPrewarmUiEnabled) |
|
158 { |
|
159 mPrewarmUiState.Append(KJavaCapYes); |
|
160 } |
|
161 else |
|
162 { |
|
163 mPrewarmUiState.Append(KJavaCapNo); |
|
164 } |
|
165 |
|
166 mDebugState = _L("Java Debug enabled: "); |
|
167 if (mDebugEnabled) |
|
168 { |
|
169 mDebugState.Append(KJavaCapYes); |
|
170 } |
|
171 else |
|
172 { |
|
173 mDebugState.Append(KJavaCapNo); |
|
174 } |
|
175 |
|
176 mSecurityMode = _L("Security warnings: "); |
|
177 if (mUserSecurityModeEnabled) |
|
178 { |
|
179 mSecurityMode.Append(KUserSecurityMode); |
|
180 } |
|
181 else |
|
182 { |
|
183 mSecurityMode.Append(KNormalSecurityMode); |
|
184 } |
|
185 |
|
186 mSecurityPolicy = _L("Security policy: "); |
|
187 switch (mSecurityPolicyId) |
|
188 { |
|
189 case KS60SecurityPolicyId: |
|
190 mSecurityPolicy.Append(KS60SecurityPolicyName); |
|
191 break; |
|
192 case KMSASecurityPolicyId: |
|
193 mSecurityPolicy.Append(KMSASecurityPolicyName); |
|
194 break; |
|
195 case KATTSecurityPolicyId: |
|
196 mSecurityPolicy.Append(KATTSecurityPolicyName); |
|
197 break; |
|
198 default: |
|
199 mSecurityPolicy.Append(KS60SecurityPolicyName); |
|
200 } |
|
201 |
|
202 mRedirectState = _L("Redirect logs: "); |
|
203 if (mRedirectEnabled) |
|
204 { |
|
205 mRedirectState.Append(KJavaCapYes); |
|
206 } |
|
207 else |
|
208 { |
|
209 mRedirectState.Append(KJavaCapNo); |
|
210 } |
|
211 |
|
212 DrawDeferred(); |
|
213 } |
|
214 |
|
215 void CJavaCaptainContainer::setCaptainState(bool running) |
|
216 { |
|
217 mCaptainRunning = running; |
|
218 updateStates(); |
|
219 } |
|
220 |
|
221 |
|
222 |
|
223 #include "commsmessage.h" |
|
224 #include "commsclientendpoint.h" |
|
225 |
|
226 void CJavaCaptainContainer::handleStateChangeCmd(int cmd) |
|
227 { |
|
228 switch (cmd) |
|
229 { |
|
230 |
|
231 case ETogglePrewarmEnable: |
|
232 { |
|
233 mPrewarmEnabled = !mPrewarmEnabled; |
|
234 CommsMessage message; |
|
235 message.setModuleId(PLUGIN_ID_JAVACAPTAIN_CORE_C); |
|
236 if (mPrewarmEnabled) |
|
237 { |
|
238 message.setMessageId(CORE_MSG_ID_START_PREWARM); |
|
239 } |
|
240 else |
|
241 { |
|
242 message.setMessageId(CORE_MSG_ID_STOP_PREWARM); |
|
243 } |
|
244 CommsClientEndpoint comms; |
|
245 comms.connect(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
246 comms.send(message); |
|
247 comms.disconnect(); |
|
248 break; |
|
249 } |
|
250 case ETogglePrewarmUiEnable: |
|
251 mPrewarmUiEnabled = !mPrewarmUiEnabled; |
|
252 java::util::JavaIniFileUtils::setProperty(java::util::UI_PREWARM, mPrewarmUiEnabled); |
|
253 break; |
|
254 |
|
255 case EDebugMode: |
|
256 { |
|
257 mDebugEnabled = !mDebugEnabled; |
|
258 |
|
259 CommsMessage message; |
|
260 std::wstring vmArgs = L""; |
|
261 if (mDebugEnabled) |
|
262 { |
|
263 vmArgs = L"-Xrunjdwp:server=y,address=localhost:8000"; |
|
264 } |
|
265 setSetExtraArguments(message, vmArgs, L""); |
|
266 |
|
267 CommsClientEndpoint comms; |
|
268 comms.connect(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
269 comms.send(message); |
|
270 comms.disconnect(); |
|
271 } |
|
272 break; |
|
273 |
|
274 case ESecurityMode: |
|
275 { |
|
276 mUserSecurityModeEnabled = !mUserSecurityModeEnabled; |
|
277 |
|
278 if (mUserSecurityModeEnabled) |
|
279 { |
|
280 SetSecurityWarningsMode(SECURITY_WARNINGS_USER_DEFINED_MODE); |
|
281 } |
|
282 else |
|
283 { |
|
284 SetSecurityWarningsMode(SECURITY_WARNINGS_DEFAULT_MODE); |
|
285 } |
|
286 } |
|
287 break; |
|
288 case ES60SecurityPolicy: |
|
289 mSecurityPolicyId = KS60SecurityPolicyId; |
|
290 SetSecurityPolicy(mSecurityPolicyId); |
|
291 break; |
|
292 case EMSASecurityPolicy: |
|
293 mSecurityPolicyId = KMSASecurityPolicyId; |
|
294 SetSecurityPolicy(mSecurityPolicyId); |
|
295 break; |
|
296 case EATTSecurityPolicy: |
|
297 mSecurityPolicyId = KATTSecurityPolicyId; |
|
298 SetSecurityPolicy(mSecurityPolicyId); |
|
299 break; |
|
300 |
|
301 case ERedirectMode: |
|
302 mRedirectEnabled = !mRedirectEnabled; |
|
303 if (mRedirectEnabled) |
|
304 { |
|
305 mRedirector->start(); |
|
306 } |
|
307 else |
|
308 { |
|
309 mRedirector->stop(); |
|
310 } |
|
311 break; |
|
312 |
|
313 default: |
|
314 break; |
|
315 } |
|
316 updateStates(); |
|
317 } |
|
318 |
|
319 std::wstring CJavaCaptainContainer::GetSecurityWarningsMode() |
|
320 { |
|
321 try |
|
322 { |
|
323 JavaStorageApplicationEntry_t query; |
|
324 JavaStorageApplicationList_t queryResult; |
|
325 JavaStorageEntry attr; |
|
326 attr.setEntry(ID, L""); |
|
327 query.insert(attr); |
|
328 attr.setEntry(SECURITY_WARNINGS, L""); |
|
329 query.insert(attr); |
|
330 iStorage->search(MIDP_PACKAGE_TABLE, query, queryResult); |
|
331 JavaStorageApplicationList_t::const_iterator iterator; |
|
332 JavaStorageApplicationList_t domainQueryResult; |
|
333 for (iterator = queryResult.begin(); iterator != queryResult.end(); iterator++) |
|
334 { |
|
335 std::wstring securityWarnings = L""; |
|
336 JavaStorageApplicationEntry_t entry = (*iterator); |
|
337 findColumn(entry, SECURITY_WARNINGS, securityWarnings); |
|
338 if (securityWarnings == SECURITY_WARNINGS_USER_DEFINED_MODE) |
|
339 { |
|
340 // make them all USER |
|
341 SetSecurityWarningsMode(SECURITY_WARNINGS_USER_DEFINED_MODE); |
|
342 return SECURITY_WARNINGS_USER_DEFINED_MODE; |
|
343 } |
|
344 } |
|
345 } |
|
346 catch (JavaStorageException& aJse) |
|
347 { |
|
348 } |
|
349 // one mroe check: central repository |
|
350 std::wstring securityWarningsMode = SECURITY_WARNINGS_DEFAULT_MODE; |
|
351 TRAP_IGNORE( |
|
352 CRepository* repository = CRepository::NewLC(KCRUidJavaSecurity); |
|
353 TInt warningsMode; |
|
354 User::LeaveIfError(repository->Get(KSecurityWarnings, warningsMode)); |
|
355 switch (warningsMode) |
|
356 { |
|
357 case 1: |
|
358 securityWarningsMode = SECURITY_WARNINGS_USER_DEFINED_MODE; |
|
359 break; |
|
360 case 2: |
|
361 securityWarningsMode = SECURITY_WARNINGS_DEFAULT_MODE; |
|
362 break; |
|
363 } |
|
364 CleanupStack::PopAndDestroy(repository);); |
|
365 return securityWarningsMode; |
|
366 } |
|
367 |
|
368 void CJavaCaptainContainer::SetSecurityWarningsMode(const std::wstring& aSecurityWarningsMode) |
|
369 { |
|
370 try |
|
371 { |
|
372 JavaStorageApplicationEntry_t query; |
|
373 JavaStorageApplicationList_t queryResult; |
|
374 JavaStorageEntry attr; |
|
375 attr.setEntry(ID, L""); |
|
376 query.insert(attr); |
|
377 iStorage->search(MIDP_PACKAGE_TABLE, query, queryResult); |
|
378 JavaStorageApplicationList_t::const_iterator iterator; |
|
379 JavaStorageApplicationList_t domainQueryResult; |
|
380 for (iterator = queryResult.begin(); iterator != queryResult.end(); iterator++) |
|
381 { |
|
382 std::wstring uid = L""; |
|
383 JavaStorageApplicationEntry_t entry = (*iterator); |
|
384 findColumn(entry, ID, uid); |
|
385 JavaStorageApplicationEntry_t oldEntry; |
|
386 JavaStorageEntry oldAttr; |
|
387 oldAttr.setEntry(ID, uid); |
|
388 oldEntry.insert(oldAttr); |
|
389 attr.setEntry(SECURITY_WARNINGS, aSecurityWarningsMode); |
|
390 entry.clear(); |
|
391 entry.insert(attr); |
|
392 iStorage->update(MIDP_PACKAGE_TABLE, entry, oldEntry); |
|
393 } |
|
394 } |
|
395 catch (JavaStorageException& aJse) |
|
396 { |
|
397 } |
|
398 // set the cenRep key as well |
|
399 TRAP_IGNORE( |
|
400 CRepository* repository = CRepository::NewLC(KCRUidJavaSecurity); |
|
401 if (aSecurityWarningsMode == SECURITY_WARNINGS_USER_DEFINED_MODE) |
|
402 { |
|
403 repository->Set(KSecurityWarnings, 1); |
|
404 } |
|
405 else |
|
406 { |
|
407 repository->Set(KSecurityWarnings, 2); |
|
408 } |
|
409 CleanupStack::PopAndDestroy(repository); |
|
410 ); |
|
411 } |
|
412 |
|
413 void CJavaCaptainContainer::findColumn(const JavaStorageApplicationEntry_t& aEntry, |
|
414 const wstring& aColName, wstring& aColValue) |
|
415 { |
|
416 JavaStorageEntry findPattern; |
|
417 findPattern.setEntry(aColName, L""); |
|
418 JavaStorageApplicationEntry_t::const_iterator findIterator = |
|
419 aEntry.find(findPattern); |
|
420 if (findIterator != aEntry.end()) |
|
421 { |
|
422 aColValue = findIterator->entryValue(); |
|
423 } |
|
424 } |
|
425 |
|
426 |
|
427 int CJavaCaptainContainer::GetSecurityPolicy() |
|
428 { |
|
429 int securityPolicyId =KS60SecurityPolicyId; |
|
430 TRAP_IGNORE( |
|
431 CRepository* repository = CRepository::NewLC(KCRUidJavaSecurity); |
|
432 HBufC* buf = HBufC::NewLC(NCentralRepositoryConstants::KMaxUnicodeStringLength); |
|
433 TPtr policy(buf->Des()); |
|
434 User::LeaveIfError(repository->Get(KPolicy, policy)); |
|
435 if (policy.Compare(KS60SecurityPolicy) == 0) |
|
436 { |
|
437 securityPolicyId = KS60SecurityPolicyId; |
|
438 } |
|
439 else if (policy.Compare(KMSASecurityPolicy) == 0) |
|
440 { |
|
441 securityPolicyId = KMSASecurityPolicyId; |
|
442 } |
|
443 else if (policy.Compare(KATTSecurityPolicy) == 0) |
|
444 { |
|
445 securityPolicyId = KATTSecurityPolicyId; |
|
446 } |
|
447 CleanupStack::PopAndDestroy(buf); |
|
448 CleanupStack::PopAndDestroy(repository);); |
|
449 return securityPolicyId; |
|
450 } |
|
451 |
|
452 void CJavaCaptainContainer::SetSecurityPolicy(int aSecurityPolicyId) |
|
453 { |
|
454 TRAP_IGNORE( |
|
455 CRepository* repository = CRepository::NewLC(KCRUidJavaSecurity); |
|
456 switch (aSecurityPolicyId) |
|
457 { |
|
458 case KS60SecurityPolicyId: |
|
459 User::LeaveIfError(repository->Set(KPolicy, KS60SecurityPolicy)); |
|
460 break; |
|
461 case KMSASecurityPolicyId: |
|
462 User::LeaveIfError(repository->Set(KPolicy, KMSASecurityPolicy)); |
|
463 break; |
|
464 case KATTSecurityPolicyId: |
|
465 User::LeaveIfError(repository->Set(KPolicy, KATTSecurityPolicy)); |
|
466 break; |
|
467 } |
|
468 CleanupStack::PopAndDestroy(repository);); |
|
469 } |
|
470 |
|
471 // |
|
472 // CJavaCaptainAppUi |
|
473 // |
|
474 CJavaCaptainAppUi::~CJavaCaptainAppUi() |
|
475 { |
|
476 JELOG2(EJavaCaptain); |
|
477 RemoveFromStack(iAppView); |
|
478 delete iAppView; |
|
479 delete mPeriodic; |
|
480 } |
|
481 |
|
482 void CJavaCaptainAppUi::ConstructL() |
|
483 { |
|
484 JELOG2(EJavaCaptain); |
|
485 BaseConstructL(); |
|
486 iAppView=new(ELeave) CJavaCaptainContainer; |
|
487 iAppView->SetMopParent(this); |
|
488 iAppView->ConstructL(ClientRect()); |
|
489 |
|
490 iCoeEnv->RootWin().EnableFocusChangeEvents(); |
|
491 mPeriodic=CPeriodic::NewL(CActive::EPriorityStandard); |
|
492 |
|
493 AddToStackL(iAppView); |
|
494 |
|
495 } |
|
496 |
|
497 _LIT(KExecutableName, "javacaptain.exe"); |
|
498 |
|
499 void senMsgToSplash(int id) |
|
500 { |
|
501 CommsMessage message; |
|
502 message.setModuleId(1); |
|
503 message.setMessageId(id); |
|
504 CommsClientEndpoint comms; |
|
505 comms.connect(10900); |
|
506 comms.send(message); |
|
507 comms.disconnect(); |
|
508 } |
|
509 |
|
510 TInt CJavaCaptainAppUi::tick(TAny* appUi) |
|
511 { |
|
512 CJavaCaptainAppUi* app = static_cast<CJavaCaptainAppUi*>(appUi); |
|
513 // ELOG1(EJavaCaptain,"mActive: %d", app->mActive); |
|
514 if (app->mActive) |
|
515 { |
|
516 senMsgToSplash(1); |
|
517 } |
|
518 else |
|
519 { |
|
520 senMsgToSplash(2); |
|
521 } |
|
522 app->mActive = !app->mActive; |
|
523 return 0; |
|
524 } |
|
525 |
|
526 void CJavaCaptainAppUi::HandleCommandL(TInt aCommand) |
|
527 { |
|
528 JELOG2(EJavaCaptain); |
|
529 |
|
530 switch (aCommand) |
|
531 { |
|
532 case EAknSoftkeyExit: |
|
533 case EEikCmdExit: |
|
534 Exit(); |
|
535 break; |
|
536 case ECaptainStart: |
|
537 { |
|
538 RProcess proc; |
|
539 int st = proc.Create(KExecutableName, KExecutableName); |
|
540 if (st == KErrNone) |
|
541 { |
|
542 proc.Resume(); |
|
543 iAppView->setCaptainState(true); |
|
544 } |
|
545 proc.Close(); |
|
546 } |
|
547 break; |
|
548 |
|
549 case ECaptainStop: |
|
550 { |
|
551 CommsMessage message; |
|
552 message.setModuleId(PLUGIN_ID_JAVACAPTAIN_CORE_C); |
|
553 message.setMessageId(CORE_MSG_ID_STOP_JAVACAPTAIN); |
|
554 CommsClientEndpoint comms; |
|
555 comms.connect(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
556 comms.send(message); |
|
557 comms.disconnect(); |
|
558 iAppView->setCaptainState(false); |
|
559 } |
|
560 break; |
|
561 |
|
562 case EThreadDump: |
|
563 { |
|
564 CommsMessage message; |
|
565 message.setModuleId(PLUGIN_ID_JAVACAPTAIN_CORE_C); |
|
566 message.setMessageId(CORE_MSG_ID_DO_THREAD_DUMP); |
|
567 CommsClientEndpoint comms; |
|
568 comms.connect(IPC_ADDRESS_JAVA_CAPTAIN_C); |
|
569 comms.send(message); |
|
570 comms.disconnect(); |
|
571 } |
|
572 break; |
|
573 |
|
574 case ETogglePrewarmEnable: |
|
575 case ETogglePrewarmUiEnable: |
|
576 case EDebugMode: |
|
577 case ESecurityMode: |
|
578 case ES60SecurityPolicy: |
|
579 case EMSASecurityPolicy: |
|
580 case EATTSecurityPolicy: |
|
581 case ERedirectMode: |
|
582 iAppView->handleStateChangeCmd(aCommand); |
|
583 break; |
|
584 |
|
585 default: |
|
586 Exit(); |
|
587 break; |
|
588 } |
|
589 } |
|
590 |
|
591 CEikAppUi* CJavaCaptainEikDocument::CreateAppUiL() |
|
592 { |
|
593 JELOG2(EJavaCaptain); |
|
594 return(new(ELeave) CJavaCaptainAppUi); |
|
595 } |
|
596 |
|
597 void CJavaCaptainEikDocument::ConstructL() |
|
598 { |
|
599 JELOG2(EJavaCaptain); |
|
600 } |
|
601 |
|
602 TUid CJavaCaptainApplication::AppDllUid() const |
|
603 { |
|
604 JELOG2(EJavaCaptain); |
|
605 return KUidJavaCaptain; |
|
606 } |
|
607 |
|
608 CApaDocument* CJavaCaptainApplication::CreateDocumentL() |
|
609 { |
|
610 JELOG2(EJavaCaptain); |
|
611 CJavaCaptainEikDocument* document=new(ELeave) CJavaCaptainEikDocument(*this); |
|
612 CleanupStack::PushL(document); |
|
613 document->ConstructL(); |
|
614 CleanupStack::Pop(); |
|
615 return(document); |
|
616 } |
|
617 |
|
618 #include <eikstart.h> |
|
619 |
|
620 LOCAL_C CApaApplication* NewApplication() |
|
621 { |
|
622 JELOG2(EJavaCaptain); |
|
623 return new CJavaCaptainApplication; |
|
624 } |
|
625 |
|
626 |
|
627 GLDEF_C TInt E32Main() |
|
628 { |
|
629 JELOG2(EJavaCaptain); |
|
630 return EikStart::RunApplication(NewApplication); |
|
631 } |
|
632 |
|
633 |
|
634 #include <fcntl.h> |
|
635 #include <sys/types.h> |
|
636 #include <unistd.h> |
|
637 |
|
638 LogRedirector::LogRedirector() : mFd(-1) |
|
639 { |
|
640 iJavaDiagnostic.reset(JavaDiagnostic::createInstance()); |
|
641 } |
|
642 |
|
643 LogRedirector::~LogRedirector() |
|
644 { |
|
645 } |
|
646 |
|
647 void LogRedirector::start() |
|
648 { |
|
649 iJavaDiagnostic->setDiagnosticListener(*this); |
|
650 mFd = open("c:\\data\\javaredirect.log", O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR); |
|
651 } |
|
652 |
|
653 void LogRedirector::stop() |
|
654 { |
|
655 iJavaDiagnostic->removeDiagnosticListener(); |
|
656 close(mFd); |
|
657 mFd = -1; |
|
658 } |
|
659 |
|
660 void LogRedirector::systemOut(const TDesC8& aData) |
|
661 { |
|
662 write(aData); |
|
663 } |
|
664 |
|
665 void LogRedirector::systemErr(const TDesC8& aData) |
|
666 { |
|
667 write(aData); |
|
668 } |
|
669 |
|
670 void LogRedirector::log(const TDesC8& aData) |
|
671 { |
|
672 write(aData); |
|
673 } |
|
674 |
|
675 void LogRedirector::write(const TDesC8& aData) |
|
676 { |
|
677 if (mFd > 0) |
|
678 { |
|
679 ::write(mFd, (const char*)aData.Ptr(), aData.Size()); |
|
680 } |
|
681 }; |
|
682 |
|
683 |
|
684 |
|
685 // End of File |
|