stockmidlet.java

SUN官方的资料

            alertPriceBox = new TextBox("Alert me when stock reaches:", 
                                        "", 9, TextField.NUMERIC);
            alertPriceBox.setTicker(stockTicker);
            alertPriceBox.addCommand(DONE_COMMAND);
            alertPriceBox.addCommand(BACK_COMMAND);
            alertPriceBox.setCommandListener(new StockCommandListener());
            
            updatesForm = new Form("Updates");
            updatesChoices = new ChoiceGroup("Update Interval:", 
                                             Choice.EXCLUSIVE);
            updatesChoices.append("Continuous", null); // will be 30 seconds
            updatesChoices.append("15 minutes", null); // default for JavaONE
            updatesChoices.append("30 minutes", null);
            updatesChoices.append("1 hour", null);
            updatesChoices.append("3 hours", null);
            switch (refresh_interval) {
                case 30000:    updatesChoices.setSelectedIndex(0, true);
                    break;
                case 1800000:  updatesChoices.setSelectedIndex(2, true);
                    break;
                case 3600000:  updatesChoices.setSelectedIndex(3, true);
                    break;
                case 10800000: updatesChoices.setSelectedIndex(4, true);
                    break;
                case 900000:
                default:       updatesChoices.setSelectedIndex(1, true);
                    break;
            }
            updatesForm.setTicker(stockTicker);
            updatesForm.append(updatesChoices);
            updatesForm.addCommand(BACK_COMMAND);
            updatesForm.addCommand(DONE_COMMAND);
            updatesForm.setCommandListener(new StockCommandListener());
            
            stockSymbolBox = new TextBox("Enter a Stock Symbol:",
                                         "", 5, TextField.ANY);
            stockSymbolBox.setTicker(stockTicker);
            stockSymbolBox.addCommand(DONE_COMMAND);
            stockSymbolBox.addCommand(BACK_COMMAND);
            stockSymbolBox.setCommandListener(new StockCommandListener());
            
            mainMenu();
            
            // Set up and start the timer to refresh the stock quotes
            stockRefreshTask = new StockRefreshTask();
            stockRefresh = new Timer();
            stockRefresh.schedule(stockRefreshTask, 0, refresh_interval);
            
            // FOR JavaONE -- ADD IN A COUPLE DEFAULT STOCKS
            /*
              addNewStock("MOT");
              addNewStock("SUNW");
              addNewStock("NOK");
              addNewStock("IBM");
              addNewStock("AOL");
              addNewStock("MSFT");
              addNewStock("GM");
              addNewStock("FORD");
              addNewStock("ORCL");
              addNewStock("SEEK");
              addNewStock("AT&T");
              addNewStock("LU");
              addNewStock("HON");
              addNewStock("CORL");
              addNewStock("NOR");
            */
        } // synchronized
    }

    /**
     * <p>This method is invoked by the application management software when
     * the <code>MIDlet</code> no longer needs to be active.  It is a stop
     * signal for the <code>MIDlet</code> upon which the <code>MIDlet</code>
     * should release any resources which can be re-acquired through the
     * <code>startApp<code> method which will be called upon re-activation of
     * the <code>MIDlet</code>. The <code>MIDlet</code> enters
     * the <code>Paused</code>
     * state upon completion of this method.</p>
     *
     * @see javax.microedition.midlet.MIDlet
     */
    public void pauseApp() {
        synchronized (this) {
            // free memory used by these objects
            display        = null;
            choose         = null;
            view           = null;
            menu           = null;
            alertList      = null;
            settingsList   = null;
            whatif         = null;
            updatesForm    = null;
            stockSymbolBox = null;
            alertPriceBox  = null;
            origPurchPriceField = null;
            numSharesField      = null;
            stockTicker         = null;
            stockRefresh.cancel();
            stockRefresh        = null;
            stockRefreshTask    = null;
            try {
                stocks.close();
                stocks = null;
                alerts.close();
                alerts = null;
            } catch (Exception e) {}
        } // synchronized
    }

    /**
     * <p>When the application management software has determined that the
     * <code>MIDlet</code> is no longer needed, or perhaps needs to make room
     * for a higher priority application in memory, is signals
     * the <code>MIDlet</code>
     * that it is a candidate to be destroyed by invoking the
     * <code>destroyApp(boolean)</code> method. In this case, we need to destroy
     * the <code>RecordEnumeration</code>s so that we don't waste their memory
     * and close the open <code>RecordStore</code>s.  If the 
     * <code>RecordStore</code>s
     * are empty, then we do not need them to be stored as 
     * they will be recreated
     * on the next invokation of the <code>MIDlet</code> so 
     * we should delete them.
     * At the end of our clean up, we must call <code>notifyDestroyed</code>
     * which will inform the application management software that we are done
     * cleaning up and have finished our execution and can 
     * now be safely terminated and
     * enters the <code>Destroyed</code> state.</p>
     *
     * @param unconditional If true when this method is called, 
     * the <code>MIDlet</code> must
     * cleanup and release all resources. If false the <code>MIDlet</code>
     * may throw <code>MIDletStateChangeException</code> to indicate it
     * does not want to be destroyed at this time.
     * @throws <code>MIDletStateChangeException</code>
     *         is thrown if the <code>MIDlet</code> wishes to continue to
     *         execute (Not enter the <code>Destroyed</code> state). This
     *         exception is ignored if <code>unconditional</code> is equal
     *         to true.
     * @see javax.microedition.midlet.MIDlet
     */
    public void destroyApp(boolean unconditional) 
        throws MIDletStateChangeException {

        // If there is no criteria that will keep us from terminating
        if (unconditional) {
            synchronized (this) {
                if (display == null) {
                    // If display == null, we are not initialized and
                    // we have nothing to destroy
                    return;
                }
                stockRefresh.cancel();
                try {
                    stocks.close();
                    alerts.close();
                    RecordStore settings = 
                        RecordStore.openRecordStore("Settings", true);
                    try {
                        settings.setRecord(1, 
                                           String.valueOf(refresh_interval)
                                           .getBytes(), 
                                           0, String.valueOf(refresh_interval)
                                           .length());
                        
                        // First time writing to the settings file
                    } catch (RecordStoreException rse) {
                        settings.addRecord(String.valueOf(refresh_interval)
                                           .getBytes(),
                                           0, String.valueOf(refresh_interval)
                                           .length());
                    }
                    settings.closeRecordStore();
                } catch (Exception e) {
                    // Ignore exception there is no place to report it
                }
                notifyDestroyed();
                
                // Something might make us not want to exit so check it 
                // here before terminating
            } // synchronized
        } else {
        }
    }

    /**
     * <p>Calculate the profits in a What If? scenario by the formula:</p>
     * <p><type>  Profit = (CurrentPrice - OriginalPurchasePrice)
     * * NumberOfShares</type></p>
     * <p>First we retrieve the current price of the stock. Then parse the
     * original purchase price that the user enters to format it to an
     * integer.  Next, retrieve the number of shares from the form that
     * the user filled in and then calculate the profits and display a nice
     * message (with the result) to the user onscreen.</p>
     */
    private void calc() {
        try {
            String s       = stocks.search(stockSymbol);
            int currPrice  = Stock.getPrice(s);
            int opp        = Stock.makeInt(origPurchPriceField.getString());
            int numShares  = 
		Integer.valueOf(numSharesField.getString()).intValue();
            int profit     = ((currPrice - opp) * numShares);

            Form answerForm = new Form(Stock.getName(s) + 
				       " " + Stock.getStringPrice(s));
            StringBuffer sb = 
		new StringBuffer().append("Net profit (loss) is ")
		    .append((profit >= 0) ? "$" : "($")
		    .append((profit >= 0) ? Stock.convert(profit) :
			    "-" + Stock.convert(profit))
		    .append((profit >= 0) ? "" : ")")
		    .append(" when selling ")
		    .append(String.valueOf(numShares))
		    .append(" shares at $")
		    .append(Stock.convert(currPrice))
		    .append(" per share.");
            answerForm.append(sb.toString());
            answerForm.addCommand(BACK_COMMAND);
            answerForm.addCommand(MAIN_MENU_COMMAND);
            answerForm.setCommandListener(new StockCommandListener());
            display.setCurrent(answerForm);
            currentMenu = "AnswerForm";
        }
        catch (Exception e) {
            error("Calculation Failed", 2000);
        }
    }

    /**
     * <p>Set an alert for the selected stock at the specified price</p>
     *
     * @param Sprice String representation of the price of the stock that
     *               the user would like an alert for
     */
    private void setAlert(String Sprice) {
        try {
            alerts.add((new StringBuffer()
                            .append(Stock.getName(stocks.search(stockSymbol)))
                            .append(';')
                            .append(Stock.makeInt(Sprice))).toString());
        } catch (Exception e) {
            error("Failed to add alert", 2000);
        }
    }

    /**
     * <p>Generate a string (which concatenates all of the stock names and
     * prices) which will be used for the <code>Ticker</code>.</p>
     *
     * @return The ticker string which concatenates all of the stock symbols
     *         and prices
     */
    private String makeTickerString() {

        // the ticker tape string
        StringBuffer tickerTape = new StringBuffer();

        try {
            RecordEnumeration re = stocks.enumerateRecords();
            while (re.hasNextElement()) {
                String theStock = new String(re.nextRecord());
                tickerTape.append(Stock.getName(theStock))
                          .append(" @ ")
                          .append(Stock.getStringPrice(theStock))
                          .append("   ");
            }
        } catch (Exception e) {
            return "Error Accessing Database";
        }
        return tickerTape.toString();
    }

    /**
     * <p>Display a message onscreen for a specified period of time</p>
     *
     * @param message The message to be displayed
     * @param time The delay before the message disappears
     */
    private void error(String message, int time) {
        if (!(display.getCurrent() instanceof Alert)) {
            Alert a = new Alert("Error", message, null, AlertType.ERROR);
            a.setTimeout(time);
            display.setCurrent(a, display.getCurrent());
        }
    }

    /**
     * <p>Check the alerts to see if any are registered for tkrSymbol at the
     * tkrSymbol's current price</p>
     *
     * @param tkrSymbol The name of the stock to check for alerts on
     */
    private void checkAlerts(String tkrSymbol) {
        try {
            int current_price = Stock.getPrice(stocks.search(tkrSymbol));
            RecordEnumeration re = alerts.enumerateRecords(tkrSymbol,
						       current_price);
            while (re.hasNextElement()) {
                String alert_string = new String(re.nextRecord());
                int my_price = 
		    Integer.valueOf(alert_string
				    .substring(alert_string.indexOf(';')+1,
					       alert_string.length()))
		    .intValue();
                Alert a = new Alert(tkrSymbol, "", null, AlertType.ALARM);
                StringBuffer sb = new StringBuffer()
                                  .append(tkrSymbol)
                                  .append(" has reached your price point of $")
                                  .append(Stock.convert(my_price))
                                  .append(" and currently is trading at $")
                                  .append(Stock.getStringPrice(stocks
						    .search(tkrSymbol)));
                a.setString(sb.toString());
                a.setTimeout(Alert.FOREVER);
                display.setCurrent(a);
                alerts.delete(alert_string);
            }
        } catch (RecordStoreNotOpenException rsno) {
        } catch (RecordStoreException rs) {
        }
    }

    /**
     * <p>Display the main menu of the program</p>
     */
    private void mainMenu() {
        display.setCurrent(menu);
        currentMenu = "Main";
    }

    /**
     * <p>Show the list of stocks to pick from and set the menu type to indicate
     * to the Listener what to do with the list choice</p>
     *
     * @param reload   Indicates whether the list should be reloaded
     * which should
     * only happen if it is possible that the stocks have changed
     * since it was last shown
     * @param menuType Which menu is this list representing
     * @param type     Type of Choice to display
     * @param prices   Indicates whether or not to show prices on the list
     */