/** * Process an Execute event to start a new MIDlet. If the MIDlet is already in the ProxyList it * will <strong>not</strong> start it again. If the MIDlet/Isolate has decided to exit but has not * yet sent the remove event the execute will be unreliable. * * @param genericEvent event to process */ public void process(Event genericEvent) { // Verify that the requested MIDlet is not already running // (is not in the MIDletProxyList) if (MIDletProxyList.getMIDletProxyList().isMidletInList(id, midlet)) { if (Logging.REPORT_LEVEL <= Logging.WARNING) { Logging.report( Logging.WARNING, LogChannels.LC_CORE, "MIDlet already running; execute ignored"); } return; } try { // The execute MIDlet method may block NativeEvent event = (NativeEvent) genericEvent; ExecuteMIDletEventListener runnable = new ExecuteMIDletEventListener( event.intParam1, event.intParam2, event.stringParam1, event.stringParam2, event.stringParam3, event.stringParam4, event.stringParam5); (new Thread(runnable)).start(); } catch (Throwable t) { Logging.trace(t, "Error creating a new Execute thread"); } }
/** * Clear the fields of the saved connection and release any system resources. Any open input and * output streams are closed as well as the connection itself. */ public void close() { try { if (m_data_output_stream != null) { m_data_output_stream.close(); m_data_output_stream = null; } if (m_data_input_stream != null) { m_data_input_stream.close(); m_data_input_stream = null; } if (m_stream != null) { m_stream.close(); m_stream = null; } } catch (IOException ioe) { /* * No special processing for errors, since the * the cached connection is no longer in use, and * the server may already have shutdown its end * of the connection. */ if (Logging.REPORT_LEVEL <= Logging.WARNING) { Logging.report(Logging.WARNING, LogChannels.LC_PROTOCOL, "IOException while close"); } } }
/** Get the settings the Manager saved for the user. */ private void restoreSettings() { ByteArrayInputStream bas; DataInputStream dis; byte[] data; RecordStore settings = null; try { settings = RecordStore.openRecordStore(GraphicalInstaller.SETTINGS_STORE, false); data = settings.getRecord(1); if (data != null) { bas = new ByteArrayInputStream(data); dis = new DataInputStream(bas); defaultInstallListUrl = dis.readUTF(); } } catch (RecordStoreException e) { if (Logging.REPORT_LEVEL <= Logging.WARNING) { Logging.report( Logging.WARNING, LogChannels.LC_AMS, "restoreSettings threw a RecordStoreException"); } } catch (IOException e) { if (Logging.REPORT_LEVEL <= Logging.WARNING) { Logging.report(Logging.WARNING, LogChannels.LC_AMS, "restoreSettings threw an IOException"); } } finally { if (settings != null) { try { settings.closeRecordStore(); } catch (RecordStoreException e) { if (Logging.REPORT_LEVEL <= Logging.WARNING) { Logging.report( Logging.WARNING, LogChannels.LC_AMS, "closeRecordStore threw a RecordStoreException"); } } } } }
/** * Updates CommandState status and displays proper exception message to user * * @param errorCode generic error code * @param details text with error details */ protected void reportError(int errorCode, String details) { String errorMsg = getErrorMessage(errorCode); if (details != null) { errorMsg += "\n\n" + details; } displayException(errorMsg); // Error message is always obtained for logging if (Logging.REPORT_LEVEL <= Logging.ERROR) { Logging.report(Logging.ERROR, LogChannels.LC_CORE, errorMsg); } }
/** Set the next capital mode for this input method */ protected void nextCapsMode() { if (Logging.REPORT_LEVEL <= Logging.INFORMATION) { Logging.report(Logging.INFORMATION, LogChannels.LC_HIGHUI, "[A.nextCapsMode]"); } capsModePointer++; if (capsModePointer == CAPS_MODES.length) { capsModePointer = 0; } if (CAPS_MODES[capsModePointer] == CAPS_OFF) { keyMap = lowerKeyMap; } else { keyMap = upperKeyMap; } mediator.subInputModeChanged(); }
/** * Run the refresh thread. * * @see java.lang.Runnable#run() */ public void run() { Request clonedRequest = (Request) request.clone(); // setRequestHeaders(clonedRequest); request = null; try { updateAndSendRequest(clonedRequest); } catch (Exception ex) { if (Logging.REPORT_LEVEL <= Logging.WARNING) { Logging.report( Logging.WARNING, LogChannels.LC_JSR180, "RefreshTask.run(): can't send a message: " + ex); } } }
/** * Splits a classpath into elements using the <code>path.separator</code> system property. * * @param elements the <code>Vector</code> to which to add the classpath elements * @param classpath the classpath to split */ private static void splitClassPath(final Vector elements, final String classpath) { String separator = System.getProperty("path.separator"); if (separator == null) { // defaults to ';' separator = ";"; Logging.report( Logging.ERROR, LogChannels.LC_AMS, "No \"path.separator\" defined! Using \"" + separator + "\"!"); } int index = classpath.indexOf(separator); int offset = 0; while (index != -1) { addClassPathElement(elements, classpath, offset, index); offset = index + separator.length(); index = classpath.indexOf(separator, offset); } addClassPathElement(elements, classpath, offset, classpath.length()); }
/** * Starts a MIDlet in a new Isolate. Check that the MIDlet is is not realy running and is not * already being started. If so, return immediately. * * @param midletSuiteStorage midletSuiteStorage for obtaining a classpath * @param externalAppId ID of MIDlet to invoke, given by an external application manager * @param id ID of an installed suite * @param midlet class name of MIDlet to invoke * @param displayName name to display to the user * @param arg0 if not null, this parameter will be available to the MIDlet as application property * arg-0 * @param arg1 if not null, this parameter will be available to the MIDlet as application property * arg-1 * @param arg2 if not null, this parameter will be available to the MIDlet as application property * arg-2 * @param memoryReserved the minimum amount of memory guaranteed to be available to the isolate at * any time; < 0 if not used * @param memoryTotal the total amount of memory that the isolate can reserve; < 0 if not used * @param priority priority to set for the new isolate; <= 0 if not used * @param profileName name of the profile to set for the new isolate; null if not used * @param debugMode debug option for the new isolate, one of: MIDP_NO_DEBUG, MIDP_DEBUG_SUSPEND, * MIDP_DEBUG_NO_SUSPEND * @return Isolate that the MIDlet suite was started in; <code>null</code> if the MIDlet is * already running */ private static Isolate startMidletCommon( MIDletSuiteStorage midletSuiteStorage, int externalAppId, int id, String midlet, String displayName, String arg0, String arg1, String arg2, int memoryReserved, int memoryTotal, int priority, String profileName, int debugMode) { Isolate isolate; String[] args = { Integer.toString(id), midlet, displayName, arg0, arg1, arg2, Integer.toString(externalAppId), String.valueOf(debugMode) }; String[] classpath = midletSuiteStorage.getMidletSuiteClassPath(id); if (classpath[0] == null) { if (id == MIDletSuite.INTERNAL_SUITE_ID) { /* * Avoid a null pointer exception, rommized midlets don't need * a classpath. */ classpath[0] = ""; } else { throw new IllegalArgumentException("Suite " + id + " not found"); } } Vector cpExtElements = new Vector(); String isolateClassPath = System.getProperty("classpathext"); if (isolateClassPath != null) { splitClassPath(cpExtElements, isolateClassPath); } /* * Include paths to dynamic components belonging to this suite * and to the "internal" suite (actually, to AMS) into class * path for the new Isolate. */ DynamicComponentStorage componentStorage = DynamicComponentStorage.getComponentStorage(); ComponentInfo[] ci = componentStorage.getListOfSuiteComponents(id); ComponentInfo[] ciAms = componentStorage.getListOfSuiteComponents(MIDletSuite.INTERNAL_SUITE_ID); int numOfComponents = 0; // calculate the number of the components to be added to the class path if (ci != null) { numOfComponents += ci.length; } if (ciAms != null) { numOfComponents += ciAms.length; } if (numOfComponents > 0) { Vector ciVector = new Vector(numOfComponents); // add the suite's own components if (ci != null) { for (int i = 0; i < ci.length; i++) { ciVector.addElement(ci[i]); } } // add the shared (belonging to AMS) components if (ciAms != null) { for (int i = 0; i < ciAms.length; i++) { ciVector.addElement(ciAms[i]); } } /* * IMPL_NOTE: currently is assumed that each component may have * not more than 1 entry in class path. * Later it will be possible to have 2: 1 for MONET. * + 1 is for System.getProperty("classpathext"). */ int n = 0; try { for (int i = 0; i < ciVector.size(); i++) { final ComponentInfo nextComponent = ((ComponentInfo) ciVector.elementAt(i)); final String[] componentPath = componentStorage.getComponentClassPath(nextComponent.getComponentId()); if (componentPath != null) { for (int j = 0; j < componentPath.length; j++) { cpExtElements.addElement(componentPath[j]); ++n; } } } } catch (Exception e) { /* * if something is wrong with a dynamic component, just * don't use the components, this error is not fatal */ cpExtElements.setSize(cpExtElements.size() - n); if (Logging.REPORT_LEVEL <= Logging.ERROR) { e.printStackTrace(); Logging.report( Logging.ERROR, LogChannels.LC_AMS, "Cannot use a dynamic component when starting '" + midlet + "' from the suite with id = " + id); } } } try { StartMIDletMonitor app = StartMIDletMonitor.okToStart(id, midlet); if (app == null) { // Isolate is already running; don't start it again return null; } final String[] classpathext = new String[cpExtElements.size()]; cpExtElements.copyInto(classpathext); isolate = new Isolate( "com.sun.midp.main.AppIsolateMIDletSuiteLoader", args, classpath, classpathext); app.setIsolate(isolate); } catch (Throwable t) { t.printStackTrace(); throw new RuntimeException("Can't create Isolate****"); } try { int reserved, limit; if (memoryReserved >= 0) { reserved = memoryReserved; } else { reserved = Constants.SUITE_MEMORY_RESERVED * 1024; } if (memoryTotal > 0) { limit = memoryTotal; } else { limit = Constants.SUITE_MEMORY_LIMIT; if (limit < 0) { limit = isolate.totalMemory(); } else { limit = limit * 1024; } int heapSize = getMidletHeapSize(id, midlet); if ((heapSize > 0) && (heapSize < limit)) { limit = heapSize; } } isolate.setMemoryQuota(reserved, limit); if (priority >= Isolate.MIN_PRIORITY) { isolate.setPriority(priority); } if (profileName != null) { IsolateUtil.setProfile(isolate, profileName); } isolate.setDebug(debugMode); isolate.setAPIAccess(true); isolate.start(); // Ability to launch midlet implies right to use Service API // for negotiations with isolate being run Link[] isolateLinks = SystemServiceLinkPortal.establishLinksFor(isolate, getTrustedToken()); LinkPortal.setLinks(isolate, isolateLinks); } catch (Throwable t) { int errorCode; String msg; if (Logging.REPORT_LEVEL <= Logging.WARNING) { t.printStackTrace(); } if (t instanceof IsolateStartupException) { /* * An error occured in the * initialization or configuration of the new isolate * before any application code is invoked, or if this * Isolate was already started or is terminated. */ errorCode = Constants.MIDLET_ISOLATE_CONSTRUCTOR_FAILED; msg = "Can't start Application."; } else if (t instanceof IsolateResourceError) { /* The system has exceeded the maximum Isolate count. */ errorCode = Constants.MIDLET_ISOLATE_RESOURCE_LIMIT; msg = "No more concurrent applications allowed."; } else if (t instanceof IllegalArgumentException) { /* Requested profile doesn't exist. */ errorCode = Constants.MIDLET_ISOLATE_CONSTRUCTOR_FAILED; msg = "Invalid profile name: " + profileName; } else if (t instanceof OutOfMemoryError) { /* The reserved memory cannot be allocated */ errorCode = Constants.MIDLET_OUT_OF_MEM_ERROR; msg = "Not enough memory to run the application."; } else { errorCode = Constants.MIDLET_ISOLATE_CONSTRUCTOR_FAILED; msg = t.toString(); } midletControllerEventProducer.sendMIDletStartErrorEvent( id, midlet, externalAppId, errorCode, msg); throw new RuntimeException(msg); } return isolate; }
/** * Get the list of suites for the user to install. The suites that are listed are the links on a * web page that end with .jad. */ public void run() { StreamConnection conn = null; InputStreamReader in = null; String errorMessage; long startTime; startTime = System.currentTimeMillis(); try { parent.displayProgressForm( Resource.getString(ResourceConstants.AMS_DISC_APP_GET_INSTALL_LIST), "", url, 0, Resource.getString(ResourceConstants.AMS_GRA_INTLR_CONN_GAUGE_LABEL)); conn = (StreamConnection) Connector.open(url, Connector.READ); in = new InputStreamReader(conn.openInputStream()); try { parent.updateProgressForm( "", 0, Resource.getString(ResourceConstants.AMS_DISC_APP_GAUGE_LABEL_DOWNLOAD)); parent.installList = SuiteDownloadInfo.getDownloadInfoFromPage(in); if (parent.installList.size() > 0) { parent.installListBox = new List( Resource.getString(ResourceConstants.AMS_DISC_APP_SELECT_INSTALL), Choice.IMPLICIT); // Add each suite for (int i = 0; i < parent.installList.size(); i++) { SuiteDownloadInfo suite = (SuiteDownloadInfo) installList.elementAt(i); parent.installListBox.append(suite.label, (Image) null); } parent.installListBox.addCommand(parent.backCmd); parent.installListBox.addCommand(parent.installCmd); parent.installListBox.setCommandListener(parent); /* * We need to prevent "flashing" on fast development * platforms. */ while (System.currentTimeMillis() - parent.lastDisplayChange < GraphicalInstaller.ALERT_TIMEOUT) ; parent.display.setCurrent(parent.installListBox); return; } errorMessage = Resource.getString(ResourceConstants.AMS_DISC_APP_CHECK_URL_MSG); } catch (IllegalArgumentException ex) { errorMessage = Resource.getString(ResourceConstants.AMS_DISC_APP_URL_FORMAT_MSG); } catch (Exception ex) { errorMessage = ex.getMessage(); } } catch (Exception ex) { errorMessage = Resource.getString(ResourceConstants.AMS_DISC_APP_CONN_FAILED_MSG); } finally { if (parent.progressForm != null) { // end the background thread of progress gauge. Gauge progressGauge = (Gauge) parent.progressForm.get(parent.progressGaugeIndex); progressGauge.setValue(Gauge.CONTINUOUS_IDLE); } try { conn.close(); in.close(); } catch (Exception e) { if (Logging.REPORT_LEVEL <= Logging.WARNING) { Logging.report(Logging.WARNING, LogChannels.LC_AMS, "close threw an Exception"); } } } Alert a = new Alert( Resource.getString(ResourceConstants.ERROR), errorMessage, null, AlertType.ERROR); a.setTimeout(Alert.FOREVER); parent.display.setCurrent(a, parent.urlTextBox); }
/** * Sets appropriate CSeq and Via headers in the given request preparing it for sending. * * @param clonedRequest the request to modify */ public synchronized void setRequestHeaders(Request clonedRequest) { // RFC 3261, section 10.2.4, Refreshing Bindings: // "A UA SHOULD use the same Call-ID for all registrations during a // single boot cycle". // // Call-Id header was added in SipClientConnectionImpl.send() // when the initial request was sent. This is the reason why // Call-Id header is not added here. // Update the CSeq header. RFC 3261, p. 58: // A UA MUST increment the CSeq value by one for each // REGISTER request with the same Call-ID. CSeqHeader cseq = clonedRequest.getCSeqHeader(); if (cseq != null) { cseq.setSequenceNumber(cseq.getSequenceNumber() + 1); } else { // log an error if (Logging.REPORT_LEVEL <= Logging.ERROR) { Logging.report( Logging.ERROR, LogChannels.LC_JSR180, "RefreshTask.run(): The request doesn't " + "contain CSeq header!"); } } // ViaHeader clonedRequest.removeHeader(ViaHeader.NAME); Vector viaHeaders = new Vector(); try { ViaHeader viaHeader = StackConnector.headerFactory.createViaHeader( sipConnectionNotifier.getLocalAddress(), sipConnectionNotifier.getLocalPort(), ((SipConnectionNotifierImpl) sipConnectionNotifier) .getSipProvider() .getListeningPoint() .getTransport(), null); viaHeaders.addElement(viaHeader); } catch (ParseException ex) { if (Logging.REPORT_LEVEL <= Logging.WARNING) { Logging.report( Logging.WARNING, LogChannels.LC_JSR180, "RefreshTask.run(): can't create Via header: " + ex); } } catch (IOException ioe) { if (Logging.REPORT_LEVEL <= Logging.WARNING) { Logging.report( Logging.WARNING, LogChannels.LC_JSR180, "RefreshTask.run(): can't create Via header: " + ioe); } } try { clonedRequest.setVia(viaHeaders); } catch (SipException ex) { if (Logging.REPORT_LEVEL <= Logging.WARNING) { Logging.report( Logging.WARNING, LogChannels.LC_JSR180, "RefreshTask.run(): can't set Via header: " + ex); } } }