uicontroller.java

来自「SUN公司发布的SmartTicket 2.0蓝图」· Java 代码 · 共 1,260 行 · 第 1/4 页

        setCurrent(progressObserverUI);
    } 

    public void setCurrentItem(Item i) {
        display.setCurrentItem(i);
    } 

    public void setCurrent(Displayable d) {
        display.setCurrent(d);
    } 

    public void setCurrent(Alert a, Displayable d) {
        display.setCurrent(a, d);
    } 

    public Display getDisplay() {
        return display;
    } 

    public String getString(int uiMessageCode) {
        return resourceBundle.getString(uiMessageCode);
    } 

    public byte[] getBytes(int uiResourceId) {
        return resourceBundle.getBytes(uiResourceId);
    } 

    public Image getImage(byte index) {
        if (icons[index] == null) {
            byte[] data = resourceBundle.getBytes(iconResourceIndices[index]);

            icons[index] = Image.createImage(data, 0, data.length);
        } 

        return icons[index];
    } 

    public void showErrorAlert(Exception e) {
        showErrorAlert(new ApplicationException(e), mainMenuUI);
    } 

    public void showErrorAlert(ApplicationException ae, Displayable d) {
        showErrorAlert(ae.getMessage(), d);
    } 

    public void showErrorAlert(String message) {
        showErrorAlert(message, display.getCurrent());
    } 

    private void showErrorAlert(String message, Displayable d) {
        Alert alert = new Alert(getString(UIMessageCodes.ERROR));

        alert.setType(AlertType.ERROR);
        alert.setTimeout(Alert.FOREVER);
        alert.setString(message);
        display.setCurrent(alert, d);
    } 

    public void showInfoAlert(String message, Displayable d) {
        showInfoAlert(null, message, d);
    } 

    public void showInfoAlert(String title, String message, Displayable d) {
        Alert alert = new Alert((title == null) 
                                ? getString(UIMessageCodes.SMART_TICKET) 
                                : title);

        alert.setType(AlertType.INFO);
        alert.setTimeout(Alert.FOREVER);
        alert.setString(message);
        display.setCurrent(alert, d);
    } 

    /**
     * Sign on, and eventually execute the given runnable after doing
     * so.
     */
    private void signOn(EventHandler authorizedEventHandler) {
        boolean isLoggedIn = false;

        try {
            model.setOffline(false);

            isLoggedIn = model.isLoggedIn();
        } catch (ApplicationException ae) {
            // Ignore. Therefore, isLoggedIn == false.
        } 

        if (isLoggedIn) {
            display.setCurrent(progressObserverUI);
            new Thread(authorizedEventHandler).start();
        } else {
            String userName = accountInfo.getUserName();
            String password = accountInfo.getPassword();

            System.out.println("userName == " + userName);
            System.out.println("password == " + password);

            if (preferences.isSilentlyLoggingIn() && userName != null 
                    && password != null) {
                signOn(authorizedEventHandler, userName, password);
            } else {
                signOnUI.init(authorizedEventHandler);
                showInfoAlert(getString(UIMessageCodes.SIGN_IN_FIRST), 
                              getString(UIMessageCodes.SIGN_IN_FIRST_LONG), 
                              signOnUI);
            } 
        } 
    } 

    /**
     * Callback after user signs on, and finally executes the given
     * runnable.
     */
    public void signOn(final EventHandler authorizedEventHandler, 
                       final String userName, final String password) {
        Thread thread = new Thread() {
            public void run() {
                try {
                    displayProgress(getString(UIMessageCodes.SIGNING_IN), 
                                    false);
                    model.login(userName, password);
                    authorizedEventHandler.start();
                } catch (ApplicationException ae) {
                    showErrorAlert(ae, signOnUI);
                } catch (Exception e) {
                    showErrorAlert(e);
                } 
            } 

        };

        thread.start();
    } 

    public void mainMenuRequested() {
        setCurrent(mainMenuUI);
    } 

    public void exitRequested() {
        new Thread() {
            public void run() {
                display.setCurrent(null);
                midlet.exit();
            } 

        }.start();
    } 

    private void setCommands(Displayable displayable) {
        if (displayable != mainMenuUI) {
            displayable.addCommand(mainMenuCommand);
        } 

        displayable.addCommand(exitCommand);
    } 

    public void handleEvent(final int eventId) {
        new EventHandler(eventId, null).start();
    } 

    public void handleEvent(final int eventId, final Object[] eventObjects) {
        new EventHandler(eventId, eventObjects).start();
    } 

    class EventHandler extends Thread {
        private int eventId;
        private Displayable fallbackUI;
        private Object[] eventObjects;

        EventHandler(int eventId, Object[] eventObjects) {
            this.eventId = eventId;
            this.eventObjects = eventObjects;
        }

        public void run() {
            synchronized (UIController.this) {
                run(eventId, eventObjects);
            } 
        } 

        private void run(int eventId, Object[] eventObjects) {
            try {
                switch (eventId) {

                case EventIds.EVENT_ID_ACCOUNT_INFO_SAVE_REQUESTED: {
                    signOn(new EventHandler(EventIds.EVENT_ID_AUTHORIZED_ACCOUNT_INFO_SAVE_REQUESTED, 
                                            eventObjects));

                    break;
                } 

                case EventIds.EVENT_ID_AUTHORIZED_ACCOUNT_INFO_SAVE_REQUESTED: {
                    fallbackUI = accountInfoUI;

                    displayProgress(getString(UIMessageCodes.SAVING_ACCOUNT_INFO), 
                                    false);

                    newAccountInfo = (AccountInfo) eventObjects[0];
                    newPreferences = (Preferences) eventObjects[1];

                    model.updateAccount(newAccountInfo);
                    model.setPreferences(newPreferences);

                    accountInfo = newAccountInfo;
                    preferences = newPreferences;

                    setCurrent(settingsUI);

                    break;
                } 

                case EventIds.EVENT_ID_BILLING_INFO_SAVE_REQUESTED: {
                    fallbackUI = billingInfoUI;

                    displayProgress(getString(UIMessageCodes.SAVING_BILLING_INFO), 
                                    false);

                    newAccountInfo = (AccountInfo) eventObjects[0];

                    model.setAccountInfo(newAccountInfo);

                    accountInfo = newAccountInfo;

                    setCurrent(settingsUI);

                    break;
                } 

                case EventIds.EVENT_ID_PREFERENCES_REQUESTED: {
                    defaultsUI.init(preferences);
                    setCurrent(defaultsUI);

                    break;
                } 

                case EventIds.EVENT_ID_PREFERENCES_SAVE_REQUESTED: {
                    fallbackUI = defaultsUI;

                    displayProgress(getString(UIMessageCodes.SAVING_DEFAULTS), 
                                    false);

                    newPreferences = (Preferences) eventObjects[0];

                    model.setPreferences(newPreferences);

                    preferences = newPreferences;

                    setCurrent(settingsUI);

                    break;
                } 

                case EventIds.EVENT_ID_ACCOUNT_INFO_REQUESTED: {
                    // Use the model's copy rather than our copy,
                    // to avoid accidental modifications.
                    AccountInfo savedAccountInfo = model.getAccountInfo();
                    Preferences savedPreferences = model.getPreferences();

                    accountInfoUI.init(savedAccountInfo, savedPreferences);
                    setCurrent(accountInfoUI);

                    break;
                } 

                case EventIds.EVENT_ID_BILLING_INFO_CANCELLED:

                case EventIds.EVENT_ID_ACCOUNT_INFO_CANCELLED:

                case EventIds.EVENT_ID_PREFERENCES_CANCELLED:

                case EventIds.EVENT_ID_SETTINGS_REQUESTED: {
                    setCurrent(settingsUI);

                    break;
                } 

                case EventIds.EVENT_ID_BILLING_INFO_REQUESTED: {
                    fallbackUI = settingsUI;

                    displayProgress(getString(UIMessageCodes.LOADING_BILLING_INFO), 
                                    false);

                    // Use the model's copy rather than our copy,
                    // to avoid accidental modifications.
                    AccountInfo savedAccountInfo = model.getAccountInfo();

                    billingInfoUI.init(savedAccountInfo);
                    setCurrent(billingInfoUI);

                    break;
                } 

                case EventIds.EVENT_ID_ACCOUNT_SETUP_SAVE_REQUESTED: {
                    fallbackUI = accountSetupUI;

                    displayProgress(getString(UIMessageCodes.CREATING_ACCOUNT_INFO), 
                                    false);

                    newAccountInfo = (AccountInfo) eventObjects[0];
                    newPreferences = (Preferences) eventObjects[1];

                    model.createAccount(newAccountInfo);
                    model.setPreferences(newPreferences);

                    accountInfo = newAccountInfo;
                    preferences = newPreferences;

                    System.out.println(accountInfo.getCreditCardExpirationDate());
                    setCurrent(mainMenuUI);

                    break;
                } 

                case EventIds.EVENT_ID_THEATER_SCHEDULES_REQUESTED: {