appmanageruiimpl.java

来自「This is a resource based on j2me embedde」· Java 代码 · 共 1,791 行 · 第 1/5 页

        mciVector = new Vector();

        this.manager = manager;
        this.appManager = appManager;
        this.display = display;
        this.displayError = displayError;

        midletSwitcher = new MIDletSwitcher(this, manager, display);

        midletSuiteStorage = MIDletSuiteStorage.getMIDletSuiteStorage();

        midletSelectors = new Vector();
        exitingMidletSuiteId = 0;
        exitingMidletClassName = null;

        setTitle(Resource.getString(ResourceConstants.AMS_MGR_TITLE));
        
        if (foldersOn) {
            addCommand(backCmd);
        } else {
            addCommand(exitCmd);
        }

        setCommandListener(this);
        
    }

    /**
     * Creates the Application Selector Screen.
     * Called if this is the first time AppSelector is being shown.
     *
     * @param manager - The application manager that invoked it
     * @param appManager - The app manager
     * @param display - The display instance associated with the manager
     * @param displayError - The UI used to display error messages
     * @param foldersOn - if folders are used
     */
    AppManagerUIImpl(ApplicationManager manager, AppManagerPeer appManager,
                 Display display, DisplayError displayError, boolean foldersOn) {
        super(null);

        init(manager, appManager, display, displayError, foldersOn);

        if (foldersOn) {
            display.setCurrent(new SplashScreen(display, folderList));
        } else {
            display.setCurrent(new SplashScreen(display, this));
        }
    }


    /**
     * Creates the Application Selector Screen.
     * @param manager - The application manager that invoked it
     * @param appManager - The app manager
     * @param display - The display instance associated with the manager
     * @param displayError - The UI used to display error messages
     * @param foldersOn - if folders are used
     * @param askUserIfLaunchMidlet - If true, it is expected that dialog be shown asking
     *             user if last installed midlet should be launched.
     */
    AppManagerUIImpl(ApplicationManager manager, AppManagerPeer appManager,
                 Display display, DisplayError displayError, boolean foldersOn,
                 boolean askUserIfLaunchMidlet) {
        super(null);
        init(manager, appManager, display, displayError, foldersOn);
        if (askUserIfLaunchMidlet) {
            askUserIfLaunchMidlet();
        }  else {
            display.setCurrent(this);
        }
   }

    /**
     * Requests that the ui element, associated with the specified midlet
     * suite, be visible and active.
     *
     * @param msi corresponding suite info
     */
    public void setCurrentItem(RunningMIDletSuiteInfo msi) {
        for (int i = 0; i < mciVector.size(); i++) {
            MidletCustomItem mci = (MidletCustomItem)mciVector.elementAt(i);
            if (mci.msi == msi) {
                selectItem(mci);
                break;
            }
        }

    }

    /**
     * Selects specified item. If necessary changes folder to items folder. 
     */
    private void selectItem(MidletCustomItem mi) {
        if (foldersOn) {
            if (currentFolderId != mi.msi.folderId) {
                setFolder(mi.msi.folderId);
            }
        }
        display.setCurrentItem(mi);
    }

    /**
     * Changes current folder and refreshes items on the
     * form accordingly.
     *
     * @param fid new current folder id
     */
    private void setFolder(int fid) {
        if (foldersOn) {
            currentFolderId = fid;
            deleteAll();
            for (int i = 0; i < mciVector.size(); i++) {
                MidletCustomItem mci = (MidletCustomItem)mciVector.elementAt(i);
                if (currentFolderId == mci.msi.folderId) {
                    append(mci);
                }
            }
        } else {
            if (Logging.REPORT_LEVEL <= Logging.ERROR) {
                Logging.report(Logging.ERROR, LogChannels.LC_AMS,
                               "Folders are not supported");
            }
        }
    }
    
    /**
     * Called when midlet switcher is needed.
     *
     * @param onlyFromLaunchedList true if midlet should
     *        be selected from the list of already launched midlets,
     *        if false then possibility to launch midlet is needed.
     */
    public void showMidletSwitcher(boolean onlyFromLaunchedList) {
        if (onlyFromLaunchedList && midletSwitcher.hasItems()) {
            display.setCurrent(midletSwitcher);
        } else {
            display.setCurrent(this);
        }
    }

    /**
     * Called when midlet selector is needed. Should show a list of
     * midlets present in the given suite and allow to select one.
     *
     * @param msiToRun a suite from which a midlet must be selected
     */
    public void showMidletSelector(RunningMIDletSuiteInfo msiToRun) {
        if (msiToRun != null) {
            try {
                MIDletSelector selector = getMidletSelector(msiToRun.suiteId);
                if (selector != null) {
                    selector.show();
                    return;
                }
                
                midletSelectors.addElement(new MIDletSelector(msiToRun, display, this, manager));
            } catch (Exception e) {
                if (Logging.REPORT_LEVEL <= Logging.ERROR) {
                    Logging.report(Logging.ERROR, LogChannels.LC_AMS,
                                   "showMidletSelector(): " + e.getMessage());
                }

                displayError.showErrorAlert(msiToRun.displayName,
                                            e, null, null);
            }
        } else {
            display.setCurrent(this);
        }
    }
    
    /**
     * Called to determine MidletSuiteInfo of the last selected Item.
     *
     * @return last selected MidletSuiteInfo
     */
    public RunningMIDletSuiteInfo getSelectedMIDletSuiteInfo() {
        return lastSelectedMsi;
    }

    /**
     * Respond to a command issued on any Screen.
     *
     * @param c command activated by the user
     * @param s the Displayable the command was on.
     */
    public void commandAction(Command c, Displayable s) {
        if (c == exitCmd) {
            if ((s == this) || s == folderList) {
                manager.shutDown();
            }
            return;
        }

        // for the rest of the commands
        // we will have to request AppSelector to be displayed
        if (c == removeOkCmd) {

            // suite to remove was set in confirmRemove()
            try {
                appManager.removeSuite(removeMsi);
            } catch (Throwable t) {
                if (Logging.REPORT_LEVEL <= Logging.WARNING) {
                    Logging.report(Logging.WARNING, LogChannels.LC_AMS,
                                   "Throwable in removeSuitee");
                }
            }
            return;

        } else if (c == cancelCmd) {

            // null out removeMsi in remove confirmation screen
            removeMsi = null;

        } else if (c == runYesCmd) {

            // user decided run the midlet suite after installation
            RunningMIDletSuiteInfo msiToRun = appManager.getLastInstalledMidletItem();
            if (msiToRun != null) {
                display.setCurrentItem(findItem(msiToRun));
                if (msiToRun.hasSingleMidlet()) {
                    appManager.launchMidlet(msiToRun);
                    display.setCurrent(this);
                } else {
                    appManager.showMidletSelector(msiToRun);
                }
                return;
            }

        } else if (c == runNoCmd) {

            /*
             * user decided not to run the newly installed midlet suite
             *
             * if a MIDlet was just installed
             * we should make the corresponding item active
             */
            RunningMIDletSuiteInfo isi = appManager.getLastInstalledMidletItem();
            if (isi != null) {
                setCurrentItem(isi);
                return;
            }

        } else if (c == selectFolderCmd) {
            if (foldersOn) {
                Folder f = folderList.getSelectedFolder();
                setFolder(f.getId());
            }
        } else if (c == selectItemFolderCmd) {
            if (foldersOn && (null != mciToChangeFolder)) {
                Folder f = folderList.getSelectedFolder();
                int folderId = f.getId();

                if (mciToChangeFolder.msi.folderId != folderId) {
                    try {
                        midletSuiteStorage.moveSuiteToFolder(
                                mciToChangeFolder.msi.suiteId, folderId);
                        mciToChangeFolder.msi.folderId = folderId;
                        if (currentFolderId != folderId) {
                            /*
                             * IMPL_NOTE: optimization possible - we can remove only
                             *  one item and avoid full refresh
                             */
                            setFolder(currentFolderId);
                        }
                    } catch (Throwable t) {
                        displayError.showErrorAlert(
                                mciToChangeFolder.msi.displayName,
                                    t, null, null);
                    }
                    mciToChangeFolder = null;
                }
            }
            display.setCurrent(this);
        } else if (c == backCmd) {
            if ((display.getCurrent() == this) && foldersOn) {
                folderList.removeCommand(selectItemFolderCmd);
                folderList.addCommand(exitCmd);
                folderList.addCommand(selectFolderCmd);
                folderList.setSelectCommand(selectFolderCmd);
                folderList.setSelectedFolder(currentFolderId);
                display.setCurrent(folderList);
                return;
            }
        } else {
            return;
        }

        // for back we just need to display AppSelector
        display.setCurrent(this);
    }
    
    /**
     * Launches a midlet suite.
     * @param msi Structure identifying the suite to launch
     */
    private void enterSuite(RunningMIDletSuiteInfo msi) {
        if (msi.hasSingleMidlet()) {
            appManager.launchMidlet(msi);
            display.setCurrent(this);
        } else {
            appManager.showMidletSelector(msi);
        }        
    }
    
    /**
     * Respond to a command issued on an Item in AppSelector
     *
     * @param c command activated by the user
     * @param item the Item the command was on.
     */
    public void commandAction(Command c, Item item) {
        RunningMIDletSuiteInfo msi = ((MidletCustomItem)item).msi;
        if (msi == null) {
            return;
        }

        if (c == launchInstallCmd) {

            manager.installSuite();

        } else if (c == launchCaManagerCmd) {

            manager.launchCaManager();

        } else if (c == launchCompManagerCmd) {

            manager.launchComponentManager();

        } else if (c == launchODTAgentCmd) {

            manager.launchODTAgent();

        } if (c == openCmd) {

            enterSuite(msi);
           
        } else if (c == infoCmd) {

            try {
                AppInfo appInfo = new AppInfo(msi.suiteId);
                appInfo.addCommand(backCmd);
                appInfo.setCommandListener(this);
                display.setCurrent(appInfo);
            } catch (Throwable t) {
                displayError.showErrorAlert(msi.displayName, t, null, null);
            }

        } else if (c == viewCompCmd) {

            // Installation of new components is a MIDlet's prerogative.
            // Therefore, we specify the read-only mode (3rd arg).
            ComponentManagerLauncher.componentView(msi.suiteId, display, false);

        } else if (c == removeCmd) {

            showConfirmRemoveDialog(msi);