dialogmanager.java

myjxta是用jxta开发的一个p2p通讯软件 有聊天 文件共享 视频3大功能 界面采用swing

    public static void removeDialog(Group g, Dialog d) {
        if (dialogs != null &&
                dialogs.containsKey(g) &&
                d != null) {
            List<Dialog> dl = dialogs.get(g);
            int i = dl != null ? dl.indexOf(d) : -1;

            if (i > -1) {
                (dl.get(i)).close();
                dl.remove(i);

                if (dl.size() == 0) {
                    dl.clear();
                    dialogs.remove(g);

                    if (dialogs.size() == 0) {
                        dialogs.clear();

                        dialogs = null;
                    }
                }
            }
        }
    }

    public static void clearDialogs(Group g) {
        if (dialogs != null && dialogs.containsKey(g)) {
            ArrayList<Dialog> cl = new ArrayList<Dialog>(dialogs.get(g));

            for (Iterator<Dialog> d = cl.iterator(); d.hasNext();) {
                Object next = d.next();
                if (next instanceof Dialog) {
                    Dialog dialog = (Dialog) next;
                    removeDialog(g, dialog);
                } else {
                    //todo gonzo: why are there commandListeners in the list? the commander hashmap isnt used for anything....
//                    System.out.println("WARNING - there are commandListeners in the dialog list!");
                }
            }
        }
    }

    public static void removeCommander(Group g, CommandExecutor c) {
        if (commandListeners != null &&
                commandListeners.containsKey(g) &&
                c != null) {
            List<CommandExecutor> cl = commandListeners.get(g);
            int i = cl != null ? cl.indexOf(c) : -1;

            if (i > -1) {
                cl.remove(i);

                if (cl.size() == 0) {
                    cl.clear();
                    commandListeners.remove(g);

                    if (commandListeners.size() == 0) {
                        commandListeners.clear();

                        commandListeners = null;
                    }
                }
            }
        }
    }

    public static void clearCommanders(Group g) {
        if (commandListeners != null &&
                commandListeners.containsKey(g)) {
            List<CommandExecutor> cl = new ArrayList<CommandExecutor>(commandListeners.get(g));

            for (CommandExecutor aCl : cl) {
                removeCommander(g, aCl);
            }
        }
    }


    public static void clear(Group g) {
        clearDialogs(g);
        clearCommanders(g);
    }

    public DialogManager(String name, String type) {
        this.name = name;
        this.type = type;
    }

    /**
     * Get the PipeAdvertisement for the indicated PeerGroup
     *
     * @param pg the PeerGroup for which to create the advertisment
     */
    public abstract PipeAdvertisement getPipeAdv(PeerGroup pg);

    /**
     * Add a new DialogPipeListener
     *
     * @param pg       the PeerGroup in which the DialogPipeListener operates
     * @param listener the DialogPipeListener to add
     */
    public abstract void addPipeListener(PeerGroup pg,
                                         DialogPipeListener listener);

    /**
     * Removes a DialogPipeListener previously registered for
     * the indicated PeerGroup
     *
     * @param pg       the PeerGroup to which the DialogPipeListener belongs
     * @param listener the listener to remove
     */
    public abstract void removePipeListener(PeerGroup pg,
                                            DialogPipeListener listener);

    public abstract void clearPipeListeners(PeerGroup pg);

    public String getDialogName() {
        return this.name;
    }

    public String getDialogType() {
        return this.type;
    }

    public boolean equals(Object o) {
        return DialogManager.class.isAssignableFrom(o.getClass()) &&
                ((DialogManager) o).getDialogName().equals(getDialogName()) &&
                ((DialogManager) o).getDialogType().equals(getDialogType());
    }

    protected String getName() {
        return this.name;
    }

    protected String getType() {
        return this.type;
    }

    public static List<Dialog> getDialogsForGroup(Group group) {
        if (dialogs == null) {
            dialogs = new HashMap<Group, List<Dialog>>();
        }

        return dialogs.get(group);
    }

    private static void addDialogToGroup(Group group, Dialog dialog) {
        List<Dialog> list = getDialogsForGroup(group);
        if (list == null) {
            list = new ArrayList<Dialog>();
            dialogs.put(group, list);
        }
        if (!list.contains(dialog)) {
            list.add(dialog);
        }
    }

    private static Dialog getDialog(Group group, Dialog dialogTemplate) {
        Dialog d;
        List<Dialog> list = getDialogsForGroup(group);

        int i = list != null ? list.indexOf(dialogTemplate) : -1;

        d = i > -1 ? list.get(i) : null;

        if (d == null || !d.isConnected()) {
            d = dialogTemplate;
            d.activate();
            if (d.isConnected()){
                addDialogToGroup(group, d);
            } else {
                //template is not connected
            }
        }



        return d;
    }

    private static OneToOneCommandDialog getCommandDialog(Group g, OneToOneCommandDialog d) {
        CommandExecutor c = null;
        CommandExecutor commanExecutorTemplate = new CommandExecutor(d);

        //nano: oh my.... (i assume: the intention is to reuse a commandListener if there is already one)
        if (commandListeners != null) {
            List<CommandExecutor> cl = commandListeners.get(g);
            int i = cl != null ? cl.indexOf(commanExecutorTemplate) : -1;

            c = i > -1 ? cl.get(i) : null;
        }

        if (c == null) {
            //not there, we are using the template
            c = commanExecutorTemplate;

            if (commandListeners == null) {
                commandListeners = new HashMap<Group, List<CommandExecutor>>();
            }

            List<CommandExecutor> cl = commandListeners.get(g);

            if (cl != null) {
                if (!cl.contains(c)) {
                    cl.add(c);
                }
            } else {
                cl = new ArrayList<CommandExecutor>();

                cl.add(c);

                commandListeners.put(g, cl);
            }
        }

        //if the CommandExecutor==DialogListener is not yet registerd at the CommandDialog --> register it!
        if (!c.getDialog().getListeners().contains(c)) {
            c.getDialog().addListener(c);
        }
        return c.getDialog();
    }

    public static void registerDialogProvider(Class p_class, IDialogProvider p_provider) {
        Object oldProvider = dialogProvider.get(p_class.getName());
        if (oldProvider != null) {
            throw new IllegalArgumentException("there is already a provider" + oldProvider + " for this class");
        }
        dialogProvider.put(p_class.getName(), p_provider);
    }

    public static void removeDialogProvider(Class p_class) {
        Object oldProvider = dialogProvider.get(p_class.getName());
        if (oldProvider == null) {
            throw new IllegalArgumentException("there is no provider installed for class" + p_class);
        }
        dialogProvider.remove(p_class.getName());
    }

    public interface IDialogProvider {
        Dialog createDialog(Group p_g, PipeAdvertisement p_pa, MyJXTA p_myjxta);

        Dialog createDialog(Group p_g, JxtaBiDiPipe p_pipe, MyJXTA p_myjxta);
    }
}