FCL/sf/app/jrt: comparison javaruntimes/midp/runtime/javasrc/com/nokia/mj/impl/rt/midp/MidletLifeCycle.java

equal deleted inserted replaced

-:0fd27995241b
+:9ac0a0a7da70
 /*
-* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2009 - 2010 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 package com.nokia.mj.impl.rt.midp;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.IOException;
+import java.util.Hashtable;
 import java.util.Timer;
 import java.util.TimerTask;
 import com.nokia.mj.impl.rt.utils.ExtensionUtil;
 import com.nokia.mj.impl.utils.LineReader;
 import com.nokia.mj.impl.utils.TaskQueue;
 import com.nokia.mj.impl.utils.Uid;
 import com.nokia.mj.impl.utils.StartUpTrace;
 /**
 * A core of the MIDP life cycle. This class controls the life time of the
 * MIDlet.
 * <p>
 * the url contains MIDlet argument 'PromptAppStartup'
 */
 private        boolean               mAutoinvocationFromUrl = false;
 /**
+* PropertyKeys that are not listed in the values of Jad / Manifest
+* attribute Nokia-MIDlet-Launch-Params
+*/
+private        Hashtable             mAcceptedUserProperties;
+/**
 * Flag for identifying whether the MIDlet is a standalone MIDlet.
 */
 private        boolean               mStandAlone = false;
 /*** ----------------------------- PRIVATE ---------------------------- */
 JvmInternal.setSystemProperty("com.nokia.mid.cmdline.instance",
 Integer.toString(mRelaunchCount + 1));
 if (Log.mOn)
 Log.logI("MIDlet launch count is : " + Integer.toString(mRelaunchCount + 1));
-// Update possible MIDlet arguments
+if (applicationArgs != null)
-setMidletArguments(applicationArgs);
+{
+JvmInternal.setSystemProperty("com.nokia.mid.cmdline", applicationArgs);
+}
 if (mState == PRE_INIT_DONE)
 {
 // We were waiting in prewarmed state the launch request
 // and now got it.
 mTaskQueue.addTask(new LifeCycleTask(LifeCycleTask.START_REQUEST,
 LifeCycleTask.PRE_WARM_START));
 }
 else
 {
+// Update possible MIDlet arguments
+setMidletArguments();
 // Bring the MIDlet to foreground
 CoreUi.foregroundRequest();
 }
 }
 if ((encodedMidletArgs != null) && (encodedMidletArgs.length() > 0))
 {
 // Decode arguments
 String midletArgs = decodeArgs(encodedMidletArgs);
-// Parse them
+// Resetting the system property after decoding.
-setMidletArguments(midletArgs);
+JvmInternal.setSystemProperty("com.nokia.mid.cmdline", midletArgs);
 }
 // If the runtime is set to pre warmed state, then the
 // value of the prewarm flag contans the process id which
 // is needed by Captain for identification.
 * Decode string in a private format that was safe to pass to Java side
 * as a Java system property.
 * Native side function java::util::runtime::MidpRuntimeStarter::encodeArgs()
 * was used to encode the string
 *
-* @param args original wstring
+* @param encodedArgs encoded arguments
-* @return encoded wstring
+* @return decoded argument string
 */
 private String decodeArgs(String encodedArgs)
 {
 StringBuffer res = new StringBuffer();
-int idx = encodedArgs.indexOf('%');
+int  idx = 0;
-int cur = 0;
+int  len = encodedArgs.length();
+char t;
-while (idx != -1)
-{
+// Decoding is done in blocks of 4 or 2 characters.
-// Add all characters up to but not including the '%' char
+// Possible extra chars are ignored
-// to final result string
-if ((idx - cur) > 0)
+while (idx < len)
 {
-res.append(encodedArgs.substring(cur, idx));
+t = encodedArgs.charAt(idx);
-}
+if (t < 'a')
+{
-// Decode all special sequences 'X%' in same way.
+if (idx + 4 >= len)
-// "X%" -> "X", so skip "%"
+break;
-// Note that "%%" is decoded to "%"
+// decode one 16-bit char
-cur = idx + 1;
+char a = (char)(t - 'A');
-idx = encodedArgs.indexOf('%', cur + 1);
+char b = (char)(encodedArgs.charAt(idx+1) - 'A');
-}
+char c = (char)(encodedArgs.charAt(idx+2) - 'A');
+char d = (char)(encodedArgs.charAt(idx+3) - 'A');
-// Add characters after last special character if any
+char r = (char)(((a<<12)+(b<<8)+(c<<4)+d));
-res.append(encodedArgs.substring(cur, encodedArgs.length()));
+res.append(r);
+idx = idx + 4;
+}
+else
+{
+if (idx + 2 >= len)
+break;
+// decode one 8-bit char
+char a = (char)(t - 'a');
+char b = (char)(encodedArgs.charAt(idx+1) - 'a');
+char r = (char)((a<<4)+b);
+res.append(r);
+idx = idx + 2;
+}
+}
 return res.toString();
 }
 /**
 // Set the MidletInfo class to contain correct data. The data is read
 // from storage.
 setMidletInfo();
+// If system property com.nokia.mid.cmdline has value, it contains
+// the arguments for the current MIDlet.
+setMidletArguments();
 if (mPrewarmStart)
 {
 // Get the recorded heap size from previous run.
 int targetHeapSize = MemoryLogger.getOldHeapSizeToExpand();
 }
 /**
 * Parse the MIDlet arguments given as parameter and set them
 * to system properties so that MIDlet can access them.
-*
+*/
-* @param applicationArgs the MIDlet arguments, can be empty
+private void setMidletArguments()
-*/
+{
-private void setMidletArguments(String applicationArgs)
+String applicationArgs = System.getProperty("com.nokia.mid.cmdline");
-{
-if (applicationArgs == null)
+if (applicationArgs != null && applicationArgs.length() > 0)
-{
-applicationArgs = "";
-}
-JvmInternal.setSystemProperty("com.nokia.mid.cmdline", applicationArgs);
-if (applicationArgs.length() > 0)
 {
 if (Log.mOn)
 Log.logI("MIDlet arguments are : " + applicationArgs);
 // parse args and set individual system properties
 StringBuffer argBuf = new StringBuffer();
 String arg;
 String propertyKey;
 String propertyValue;
 mAutoinvocationFromUrl = false;
+if (mAcceptedUserProperties == null)
+{
+// Doing intialization only once.
+String launchParams =
+ApplicationInfoImpl.getMidletInfo().getAttribute("Nokia-MIDlet-Launch-Params");
+mAcceptedUserProperties = split(launchParams, ",");
+}
 do
 {
 argBuf.setLength(0);
 idx = applicationArgs.indexOf(";", cur);
 // Arguments string started with ';'
 cur = idx + 1;
 continue;
 }
-argBuf.append("com.nokia.mid.cmdline.param.");
 if (idx != -1)
 {
 argBuf.append(applicationArgs.substring(cur, idx));
 }
 else
 // The property has also a value.
 propertyKey = arg.substring(0, indEq);
 propertyValue = arg.substring(indEq + 1);
 }
-if (propertyKey.equals("com.nokia.mid.cmdline.param.PromptAppStartup"))
+if (propertyKey.equals("PromptAppStartup"))
 {
 mAutoinvocationFromUrl = true;
 if (Log.mOn)
 Log.logI("MIDlet had argument PromptAppStartup");
 }
-JvmInternal.setSystemProperty(propertyKey, propertyValue);
+if (mAcceptedUserProperties.get(propertyKey) != null)
+{
+JvmInternal.setUserProperty(propertyKey, propertyValue);
+}
 cur = idx + 1;
 }
 while ((idx != -1) && (cur < applicationArgs.length()));
 }
+}
+/**
+* Split a string into Hashtable. This util method splits the given
+* string separated by given separator into Hashtable so that tokens
+* are keys and values are just empty Strings. Before adding the tokens
+* into hashtable those are trimmed.
+*
+* @str String to split.
+* @separator A separator that separates the tokens.
+*/
+static Hashtable split(String str, String separator)
+{
+Hashtable ht = new Hashtable();
+if (separator != null)
+{
+int separatorLen = separator.length();
+if (str != null && separatorLen > 0)
+{
+int index = str.indexOf(separator);
+while (index != -1)
+{
+String token = str.substring(0,index).trim();
+ht.put(token, "");
+str = str.substring(index + separatorLen);
+index = str.indexOf(separator);
+}
+}
+}
+if (str != null)
+{
+str = str.trim();
+if (str.length() > 0)
+{
+// add token after last separator
+ht.put(str, "");
+}
+}
+return ht;
 }
 /**
 * Class for extending the TimerTask. This is for the shut down timer.
 */

branch	RCL_3
changeset 25	9ac0a0a7da70
parent 24	0fd27995241b
child 34	71c436fe3ce0