|
1 /* |
|
2 * Copyright (c) 2009 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: This class provides container for message. |
|
15 * |
|
16 */ |
|
17 |
|
18 #include <string> |
|
19 #include <algorithm> |
|
20 #include <fstream> |
|
21 #include <list> |
|
22 |
|
23 #include "javacoreui.h" |
|
24 #include "javacoreuiparams.h" |
|
25 #include "runtimestarterutils.h" |
|
26 |
|
27 #include "dynamiclibloader.h" |
|
28 #include "javacommonutils.h" |
|
29 #include "javaoslayer.h" |
|
30 #include "logger.h" |
|
31 |
|
32 #ifdef __SYMBIAN32__ |
|
33 #include "javasymbianoslayer.h" |
|
34 #else // __SYMBIAN32__ |
|
35 #include <signal.h> |
|
36 |
|
37 #endif // __SYMBIAN32__ |
|
38 |
|
39 #include "runtimeexception.h" |
|
40 |
|
41 #include "javastarter.h" |
|
42 #include "javastarterimpl.h" |
|
43 |
|
44 |
|
45 using namespace java::runtime; |
|
46 using namespace java::util; |
|
47 using namespace java::ui; |
|
48 using namespace java; |
|
49 |
|
50 const wchar_t* const NATIVE_RUNTIME_MAIN_CLASS = L"com.nokia.mj.impl.rt.midp.Main"; |
|
51 const wchar_t* const MAIN_RUNTIME_MAIN_CLASS = L"com.nokia.mj.impl.rt.main.Main"; |
|
52 |
|
53 const wchar_t* const ARG_CONF = L"-conf="; |
|
54 const wchar_t* const CONF_CDC = L"cdc"; |
|
55 const wchar_t* const CONF_FOUNDATION = L"foun"; |
|
56 const wchar_t* const CONF_CLDC = L"cldc"; |
|
57 |
|
58 const wchar_t* const ARG_PROFILE = L"-profile="; |
|
59 const wchar_t* const PROFILE_MAIN = L"main"; |
|
60 const wchar_t* const PROFILE_STANDALONE_MIDLET = L"standalonemidlet"; |
|
61 const wchar_t* const ARG_STANDALONE = L"-standalone"; |
|
62 |
|
63 const wchar_t* const ARG_ORIENTATION = L"-Dcom.nokia.startup.arg.orientation="; |
|
64 const wchar_t* const ORIENTATION_PORTRAIT = L"portrait"; |
|
65 const wchar_t* const ORIENTATION_LANDSCAPE = L"landscape"; |
|
66 |
|
67 const wchar_t* const ARG_START_SCREEN = L"-Dcom.nokia.startup.arg.startscreen="; |
|
68 const wchar_t* const START_SCREEN_DEFAULT = L"default"; |
|
69 const wchar_t* const START_SCREEN_NO = L"no"; |
|
70 |
|
71 const wchar_t* const ARG_JAR = L"-jar"; |
|
72 const wchar_t* const ARG_JAD = L"-jad"; |
|
73 const wchar_t* const ARG_CP = L"-cp"; |
|
74 const wchar_t* const ARG_CLASSPATH = L"-classpath"; |
|
75 const wchar_t* const ARG_MAIN = L"-main"; |
|
76 const wchar_t* const ARG_UID = L"-uid"; |
|
77 const wchar_t* const ARG_ROOT_PATH = L"-rootpath"; |
|
78 const wchar_t* const ARG_HANDLE = L"-handle"; |
|
79 const wchar_t* const ARG_END = L"-interalArgEnd"; |
|
80 const wchar_t* const ARG_EMPTY = L""; |
|
81 |
|
82 |
|
83 |
|
84 OS_EXPORT int java::start(int argc, const char** argv) |
|
85 { |
|
86 JELOG2(EJavaRuntime); |
|
87 LOG(EJavaRuntime, EInfo, "java::start(1)"); |
|
88 int result = -1; |
|
89 try |
|
90 { |
|
91 int i = 0; |
|
92 if (argc > 0 && argv[0][0] != '-') |
|
93 { |
|
94 // Check if the first argument is the name of the exe. If so, skip it. |
|
95 std::string firstArg(argv[0]); |
|
96 std::transform(firstArg.begin(), firstArg.end(), |
|
97 firstArg.begin(), tolower); |
|
98 size_t pos = firstArg.rfind(".exe"); |
|
99 bool endsWithExe = (pos != std::string::npos) && |
|
100 (pos == (firstArg.length() - 4)); |
|
101 if (endsWithExe) |
|
102 { |
|
103 // It did end with .exe so ignoring the first argument. |
|
104 i = 1; |
|
105 } |
|
106 |
|
107 } |
|
108 |
|
109 std::list<std::wstring> args; |
|
110 for (; i < argc; ++i) |
|
111 { |
|
112 args.push_back(JavaCommonUtils::utf8ToWstring(argv[i])); |
|
113 } |
|
114 |
|
115 std::auto_ptr<JavaStarterImpl> javaStarter(new JavaStarterImpl(args)); |
|
116 result = javaStarter->start(); |
|
117 } |
|
118 catch (RuntimeException& e) |
|
119 { |
|
120 ELOG1(EJavaRuntime, "java::start RuntimeException catched: %s ", |
|
121 e.toString().c_str()); |
|
122 } |
|
123 |
|
124 catch (ExceptionBase& e) |
|
125 { |
|
126 ELOG1(EJavaRuntime, "java::start ExceptionBase catched: %s ", |
|
127 e.toString().c_str()); |
|
128 } |
|
129 |
|
130 catch (std::exception& e) |
|
131 { |
|
132 ELOG1(EJavaRuntime, "java::start Exception %s catched", e.what()); |
|
133 } |
|
134 |
|
135 LOG1(EJavaRuntime, EInfo, "java::start with status %d", result); |
|
136 return result; |
|
137 } |
|
138 |
|
139 OS_EXPORT int java::start(const char* fileName) |
|
140 { |
|
141 JELOG2(EJavaRuntime); |
|
142 LOG(EJavaRuntime, EInfo, "java::start(2)"); |
|
143 int result = -1; |
|
144 try |
|
145 { |
|
146 std::list<std::wstring> args; |
|
147 JavaStarterImpl::getArgsFromFile(fileName, args); |
|
148 std::auto_ptr<JavaStarterImpl> javaStarter(new JavaStarterImpl(args)); |
|
149 result = javaStarter->start(); |
|
150 } |
|
151 catch (RuntimeException& e) |
|
152 { |
|
153 ELOG1(EJavaRuntime, "java::start(2) RuntimeException catched: %s ", |
|
154 e.toString().c_str()); |
|
155 } |
|
156 |
|
157 catch (ExceptionBase& e) |
|
158 { |
|
159 ELOG1(EJavaRuntime, "java::start(2) ExceptionBase catched: %s ", |
|
160 e.toString().c_str()); |
|
161 } |
|
162 |
|
163 catch (std::exception& e) |
|
164 { |
|
165 ELOG1(EJavaRuntime, "java::start(2) Exception %s catched", e.what()); |
|
166 } |
|
167 |
|
168 LOG1(EJavaRuntime, EInfo, "java::start(2) exited with status %d", result); |
|
169 |
|
170 return result; |
|
171 } |
|
172 |
|
173 JavaStarterImpl::JavaStarterImpl(const std::list<std::wstring>& args): |
|
174 mJvmStarter(0), |
|
175 mRuntimeStarterUtils(0), |
|
176 mOriginalArgs(args), |
|
177 mShudownOk(false), |
|
178 mIsMainApp(true), |
|
179 mConfiguration(JvmStarter::UNDEFINED) |
|
180 |
|
181 { |
|
182 JELOG2(EJavaRuntime); |
|
183 mRuntimeStarterUtils = new RuntimeStarterUtils(); |
|
184 } |
|
185 |
|
186 JavaStarterImpl::~JavaStarterImpl() |
|
187 { |
|
188 JELOG2(EJavaRuntime); |
|
189 delete mJvmStarter; |
|
190 mJvmStarter = 0; |
|
191 |
|
192 delete mRuntimeStarterUtils; |
|
193 mRuntimeStarterUtils = 0; |
|
194 } |
|
195 |
|
196 int JavaStarterImpl::start() |
|
197 { |
|
198 JELOG2(EJavaRuntime); |
|
199 |
|
200 // Start the thread supervisor for noticing crashes. |
|
201 mRuntimeStarterUtils = new RuntimeStarterUtils(); // codescanner::nonleavenew |
|
202 mRuntimeStarterUtils->startThreadSupervisor(); |
|
203 |
|
204 // Parse args that starts with '-'. |
|
205 parseFlags(); |
|
206 |
|
207 // Create JVM starter for selected runtime. |
|
208 createJvmStarter(); |
|
209 |
|
210 // Solves the UID of the application and sets the root path. |
|
211 setUidAndRootPath(); |
|
212 |
|
213 // Create the start screen and start it if needed. |
|
214 std::auto_ptr<java::util::DynamicLibLoader> coreUiLoader; |
|
215 CoreUi& coreUi = CoreUi::getUiInstance(coreUiLoader); |
|
216 if (mUiParams.getScreenMode() != NO_START_SCREEN) |
|
217 { |
|
218 LOG(EJavaRuntime, EInfo, "StartUI"); |
|
219 coreUi.start(mAppUid, &mUiParams); |
|
220 LOG(EJavaRuntime, EInfo, "StartUI ok"); |
|
221 } |
|
222 |
|
223 // Sets the -jar, -jad, -cp (or -classpath) args if were provided. |
|
224 // Also a main class is set if needed. |
|
225 handleJadJarCpArgs(); |
|
226 |
|
227 // Adds a handle to this object in order to enable the callbacks |
|
228 // from runtime. |
|
229 addHandle(); |
|
230 |
|
231 // Add the application arguments if provided. |
|
232 addApplicationArgs(); |
|
233 |
|
234 #ifndef RD_JAVA_UI_QT |
|
235 // In Java 2.x we are using legacy UI. |
|
236 mJvmStarter->appendSystemProperty(L"-Dcom.nokia.legacy.support=symbian"); |
|
237 #endif //RD_JAVA_HYBRID |
|
238 |
|
239 int result = mJvmStarter->startJvm(); |
|
240 CoreUi::releaseUi(coreUiLoader); |
|
241 if (mMonitor.get()) |
|
242 { |
|
243 mShudownOk = true; |
|
244 LOG(EJavaRuntime, EInfo, "Notifying."); |
|
245 mMonitor->notify(); |
|
246 } |
|
247 |
|
248 LOG1(EJavaRuntime, EInfo, "Native exited with status %d", result); |
|
249 |
|
250 return result; |
|
251 |
|
252 } |
|
253 |
|
254 void JavaStarterImpl::parseFlags() |
|
255 { |
|
256 JELOG2(EJavaRuntime); |
|
257 for (mOriginalArgsIter = mOriginalArgs.begin(); |
|
258 (mOriginalArgsIter != mOriginalArgs.end() && mOriginalArgsIter->at(0) == '-'); |
|
259 ++mOriginalArgsIter) |
|
260 { |
|
261 LOG1(EJavaRuntime, EInfo, "Handling flags %S", mOriginalArgsIter->c_str()); |
|
262 if (*mOriginalArgsIter == ARG_JAR) |
|
263 { |
|
264 storeNextArgument(mJarFile); |
|
265 LOG1(EJavaRuntime, EInfo, "Jar file is %S", mJarFile.c_str()); |
|
266 } |
|
267 else if (*mOriginalArgsIter == ARG_JAD) |
|
268 { |
|
269 storeNextArgument(mJadFile); |
|
270 LOG1(EJavaRuntime, EInfo, "Jad file is %S", mJadFile.c_str()); |
|
271 } |
|
272 else if (*mOriginalArgsIter == ARG_CP || *mOriginalArgsIter == ARG_CLASSPATH) |
|
273 { |
|
274 storeNextArgument(mClassPath); |
|
275 LOG1(EJavaRuntime, EInfo, "Classpath is %S", mClassPath.c_str()); |
|
276 } |
|
277 else if (mOriginalArgsIter->find(ARG_CONF) == 0) |
|
278 { |
|
279 setConfigration(getArgValue(*mOriginalArgsIter)); |
|
280 } |
|
281 else if (mOriginalArgsIter->find(ARG_PROFILE) == 0) |
|
282 { |
|
283 setProfile(getArgValue(*mOriginalArgsIter)); |
|
284 } |
|
285 else if (mOriginalArgsIter->find(ARG_ORIENTATION) == 0) |
|
286 { |
|
287 setOrientation(getArgValue(*mOriginalArgsIter)); |
|
288 } |
|
289 else if (mOriginalArgsIter->find(ARG_START_SCREEN) == 0) |
|
290 { |
|
291 setStartScreen(getArgValue(*mOriginalArgsIter)); |
|
292 } |
|
293 else |
|
294 { |
|
295 mFlagArgs.push_back(*mOriginalArgsIter); |
|
296 } |
|
297 } |
|
298 } |
|
299 |
|
300 void JavaStarterImpl::setConfigration(const std::wstring& conf) |
|
301 { |
|
302 JELOG2(EJavaRuntime); |
|
303 |
|
304 if (conf == CONF_CLDC) |
|
305 { |
|
306 LOG(EJavaRuntime, EInfo, "Setting conf to CLDC"); |
|
307 mConfiguration = JvmStarter::CLDC; |
|
308 } |
|
309 else if (conf == CONF_CDC) |
|
310 { |
|
311 LOG(EJavaRuntime, EInfo, "Setting conf to CDC"); |
|
312 mConfiguration = JvmStarter::CDC; |
|
313 } |
|
314 else if (conf == CONF_FOUNDATION) |
|
315 { |
|
316 LOG(EJavaRuntime, EInfo, "Setting conf to FOUNDATION"); |
|
317 mConfiguration = JvmStarter::FOUNDATION; |
|
318 } |
|
319 else |
|
320 { |
|
321 ELOG1(EJavaRuntime, "Unknown conf %S", conf.c_str()); |
|
322 } |
|
323 } |
|
324 |
|
325 void JavaStarterImpl::setProfile(const std::wstring& profile) |
|
326 { |
|
327 JELOG2(EJavaRuntime); |
|
328 |
|
329 if (profile == PROFILE_STANDALONE_MIDLET) |
|
330 { |
|
331 LOG(EJavaRuntime, EInfo, "Setting profile to be standalone MIDlet"); |
|
332 mIsMainApp = false; |
|
333 } |
|
334 else if (profile == PROFILE_MAIN) |
|
335 { |
|
336 LOG(EJavaRuntime, EInfo, "Setting profile to be main"); |
|
337 mIsMainApp = true; |
|
338 } |
|
339 else |
|
340 { |
|
341 ELOG1(EJavaRuntime, "Unknown profile %S", profile.c_str()); |
|
342 } |
|
343 } |
|
344 |
|
345 void JavaStarterImpl::setOrientation(const std::wstring& orientation) |
|
346 { |
|
347 JELOG2(EJavaRuntime); |
|
348 |
|
349 if (orientation == ORIENTATION_PORTRAIT) |
|
350 { |
|
351 LOG(EJavaRuntime, EInfo, "Setting orientation to portrait"); |
|
352 mUiParams.setOrientation(PORTRAIT); |
|
353 } |
|
354 else if (orientation == ORIENTATION_LANDSCAPE) |
|
355 { |
|
356 LOG(EJavaRuntime, EInfo, "Setting orientation to landscape"); |
|
357 mUiParams.setOrientation(LANDSCAPE); |
|
358 } |
|
359 else |
|
360 { |
|
361 ELOG1(EJavaRuntime, "Unknown orientation %S", orientation.c_str()); |
|
362 } |
|
363 } |
|
364 |
|
365 void JavaStarterImpl::setStartScreen(const std::wstring& startscreen) |
|
366 { |
|
367 JELOG2(EJavaRuntime); |
|
368 |
|
369 if (startscreen == START_SCREEN_DEFAULT) |
|
370 { |
|
371 LOG(EJavaRuntime, EInfo, "Setting default start screen"); |
|
372 mUiParams.setScreenMode(DEFAULT_START_SCREEN); |
|
373 } |
|
374 else if (startscreen == START_SCREEN_NO) |
|
375 { |
|
376 LOG(EJavaRuntime, EInfo, "Setting default start screen"); |
|
377 mUiParams.setScreenMode(NO_START_SCREEN); |
|
378 } |
|
379 else |
|
380 { |
|
381 mUiParams.setScreenMode(USER_DEFINED_SCREEN); |
|
382 mUiParams.setImagePath(startscreen); |
|
383 LOG1(EJavaRuntime, EInfo, "Setting start screen from file %S", startscreen.c_str()); |
|
384 } |
|
385 } |
|
386 |
|
387 void JavaStarterImpl::createJvmStarter() |
|
388 { |
|
389 JELOG2(EJavaRuntime); |
|
390 if (mIsMainApp) |
|
391 { |
|
392 // We are starting main app. |
|
393 if (mConfiguration == JvmStarter::UNDEFINED) |
|
394 { |
|
395 // If the user has not explicitely set the conf, CDC is default. |
|
396 mConfiguration = JvmStarter::CDC; |
|
397 } |
|
398 mJvmStarter = JvmStarter::getJvmStarterInstance(mConfiguration, |
|
399 PROFILE_MAIN); |
|
400 mJvmStarter->appendSystemProperty(L"-Dcom.nokia.rt.port=main"); |
|
401 mJvmStarter->setMainClass(MAIN_RUNTIME_MAIN_CLASS); |
|
402 } |
|
403 else |
|
404 { |
|
405 // We are starting standalone MIDlet. |
|
406 if (mConfiguration == JvmStarter::UNDEFINED) |
|
407 { |
|
408 // If the user has not explicitely set the conf, CLDC is default. |
|
409 mConfiguration = JvmStarter::CLDC; |
|
410 } |
|
411 mJvmStarter = JvmStarter::getJvmStarterInstance(mConfiguration, |
|
412 PROFILE_STANDALONE_MIDLET); |
|
413 mJvmStarter->appendSystemProperty(L"-Dcom.nokia.rt.port=midp"); |
|
414 mJvmStarter->setMainClass(NATIVE_RUNTIME_MAIN_CLASS); |
|
415 mJvmStarter->appendApplicationArgument(ARG_STANDALONE); |
|
416 mJvmStarter->appendApplicationArgument(ARG_EMPTY); |
|
417 } |
|
418 } |
|
419 |
|
420 void JavaStarterImpl::handleJadJarCpArgs() |
|
421 { |
|
422 JELOG2(EJavaRuntime); |
|
423 if (mJarFile.length() > 0) |
|
424 { |
|
425 // The -jar argument was provided. Appending it to classpath and |
|
426 // passing that as an argument to the runtime. |
|
427 mJvmStarter->appendClassPath(mJarFile); |
|
428 mJvmStarter->appendApplicationArgument(ARG_JAR); |
|
429 mJvmStarter->appendApplicationArgument(mJarFile); |
|
430 } |
|
431 else |
|
432 { |
|
433 // The -jar argument was not provided. We assume that the next argument |
|
434 // is the main class of the application in case of main app. |
|
435 // passing that as an argument to the runtime. |
|
436 if (mIsMainApp && mOriginalArgsIter != mOriginalArgs.end()) |
|
437 { |
|
438 mJvmStarter->appendApplicationArgument(ARG_MAIN); |
|
439 mJvmStarter->appendApplicationArgument(*mOriginalArgsIter); |
|
440 ++mOriginalArgsIter; |
|
441 } |
|
442 } |
|
443 |
|
444 if (mJadFile.length() > 0) |
|
445 { |
|
446 mJvmStarter->appendApplicationArgument(ARG_JAD); |
|
447 mJvmStarter->appendApplicationArgument(mJadFile); |
|
448 } |
|
449 |
|
450 if (mClassPath.length() > 0) |
|
451 { |
|
452 mJvmStarter->appendClassPath(mClassPath); |
|
453 } |
|
454 } |
|
455 |
|
456 |
|
457 void JavaStarterImpl::setUidAndRootPath() |
|
458 { |
|
459 JELOG2(EJavaRuntime); |
|
460 #ifdef __SYMBIAN32__ |
|
461 TUidToUid(RProcess().Type()[2], mAppUid); |
|
462 LOG1(EJavaRuntime, EInfo, "PROCESS UID %S", mAppUid.toString().c_str()); |
|
463 |
|
464 // TUid tuid = uidType[1]; |
|
465 TUid tuid(TUid::Uid(0x10005902)); |
|
466 // TUidToUid(tuid, mAppUid); |
|
467 // LOG1(EJavaRuntime, EInfo, "TEMP UID %S", mAppUid.toString().c_str()); |
|
468 #else // __SYMBIAN32__ |
|
469 // mAppUid = Uid(L"java_standalone"); |
|
470 |
|
471 #endif // __SYMBIAN32__ |
|
472 |
|
473 mJvmStarter->appendApplicationArgument(ARG_UID); |
|
474 mJvmStarter->appendApplicationArgument(mAppUid.toString()); |
|
475 |
|
476 std::wstring rooPath; |
|
477 #ifdef __SYMBIAN32__ |
|
478 Uid uid; |
|
479 TUidToUid(RProcess().SecureId(), uid); |
|
480 rooPath += L"c:\\private\\"; |
|
481 rooPath += uid.toString().substr(1,8); |
|
482 rooPath += L"\\"; |
|
483 #else // __SYMBIAN32__ |
|
484 rooPath += L"./"; |
|
485 #endif // __SYMBIAN32__ |
|
486 mJvmStarter->appendApplicationArgument(ARG_ROOT_PATH); |
|
487 mJvmStarter->appendApplicationArgument(rooPath); |
|
488 } |
|
489 |
|
490 void JavaStarterImpl::addHandle() |
|
491 { |
|
492 JELOG2(EJavaRuntime); |
|
493 // Provide access to this object by Java peer via delivering a pointer |
|
494 // to this object. |
|
495 mJvmStarter->appendApplicationArgument(ARG_HANDLE); |
|
496 MidpStarterInternalSupport* internalSupport = this; |
|
497 int handle = reinterpret_cast<int>(internalSupport); |
|
498 mJvmStarter->appendApplicationArgument(JavaCommonUtils::intToWstring(handle)); |
|
499 } |
|
500 |
|
501 void JavaStarterImpl::addApplicationArgs() |
|
502 { |
|
503 JELOG2(EJavaRuntime); |
|
504 // Adding end mark of the runtime arguments. |
|
505 mJvmStarter->appendApplicationArgument(ARG_END); |
|
506 |
|
507 // What is left in the argument list is considered to be application arguments. |
|
508 |
|
509 for (; mOriginalArgsIter != mOriginalArgs.end(); ++mOriginalArgsIter) |
|
510 { |
|
511 LOG1(EJavaRuntime, EInfo, "Adding APP args %S", mOriginalArgsIter->c_str()); |
|
512 mJvmStarter->appendApplicationArgument(*mOriginalArgsIter); |
|
513 } |
|
514 } |
|
515 |
|
516 void JavaStarterImpl::storeNextArgument(std::wstring& arg) |
|
517 { |
|
518 ++mOriginalArgsIter; |
|
519 if (mOriginalArgsIter != mOriginalArgs.end()) |
|
520 { |
|
521 arg = *mOriginalArgsIter; |
|
522 } |
|
523 } |
|
524 |
|
525 std::wstring JavaStarterImpl::getArgValue(const std::wstring& arg) |
|
526 { |
|
527 JELOG2(EJavaRuntime); |
|
528 return arg.substr(arg.find(L"=") + 1); |
|
529 } |
|
530 |
|
531 |
|
532 void JavaStarterImpl::getArgsFromFile(const char* file, std::list<std::wstring>& args) |
|
533 { |
|
534 std::ifstream argsFile; |
|
535 try |
|
536 { |
|
537 argsFile.open(file, std::ifstream::in); |
|
538 |
|
539 std::string line; |
|
540 |
|
541 while (std::getline(argsFile, line)) |
|
542 { |
|
543 size_t endln = line.find_last_not_of("\r\n"); |
|
544 if (endln != std::string::npos) |
|
545 { |
|
546 line.erase(endln+1); |
|
547 } |
|
548 args.push_back(JavaCommonUtils::utf8ToWstring(line.c_str())); |
|
549 } |
|
550 } |
|
551 catch (std::exception& e) |
|
552 { |
|
553 LOG2(EJavaRuntime, EInfo, "Not able to read from file %s. Error %s", |
|
554 file, e.what()); |
|
555 } |
|
556 argsFile.close(); |
|
557 } |
|
558 |
|
559 void* JavaStarterImpl::ensureExit(void* ptr) |
|
560 { |
|
561 JELOG2(EUtils); |
|
562 #ifdef __SYMBIAN32__ |
|
563 RThread().SetPriority(EPriorityMore); |
|
564 #endif // __SYMBIAN32__ |
|
565 JavaStarterImpl* starter = reinterpret_cast<JavaStarterImpl*>(ptr); |
|
566 LOG(EJavaRuntime, EInfo, "Starting to wait for the shutdown."); |
|
567 starter->mMonitor->wait(1200); // 1,2 seconds |
|
568 LOG(EJavaRuntime, EInfo, "woke up from monitor."); |
|
569 if (!starter->mShudownOk) |
|
570 { |
|
571 LOG(EJavaRuntime, EInfo, "Killing process."); |
|
572 #ifdef __SYMBIAN32__ |
|
573 RProcess().Kill(0); |
|
574 #else |
|
575 kill(getpid(), SIGTERM); |
|
576 #endif // __SYMBIAN32__ |
|
577 } |
|
578 LOG(EJavaRuntime, EInfo, "Not killing process."); |
|
579 return 0; |
|
580 } |
|
581 |
|
582 void JavaStarterImpl::closeRuntimeInd() |
|
583 { |
|
584 JELOG2(EJavaRuntime); |
|
585 LOG(EJavaRuntime, EInfo, "Starter got close indication from JVM"); |
|
586 pthread_t tid; |
|
587 mMonitor.reset(Monitor::createMonitor()); |
|
588 pthread_create(&tid, 0, ensureExit, this); |
|
589 } |
|
590 |
|
591 void JavaStarterImpl::setUids(const java::util::Uid& /*uid*/, |
|
592 const java::util::Uid& /*suiteUid*/) |
|
593 { |
|
594 JELOG2(EJavaRuntime); |
|
595 // Not applicable in this case. |
|
596 } |