stdpeergroup.java

jxme的一些相关程序,主要是手机上程序开发以及手机和计算机通信的一些程序资料,程序编译需要Ant支持

/*
 * Copyright (c) 2001 Sun Microsystems, Inc.  All rights
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:
 *       "This product includes software developed by the
 *       Sun Microsystems, Inc. for Project JXTA."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Sun", "Sun Microsystems, Inc.", "JXTA" and "Project JXTA" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact Project JXTA at http://www.jxta.org.
 *
 * 5. Products derived from this software may not be called "JXTA",
 *    nor may "JXTA" appear in their name, without prior written
 *    permission of Sun.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL SUN MICROSYSTEMS OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of Project JXTA.  For more
 * information on Project JXTA, please see
 * <http://www.jxta.org/>.
 *
 * This license is based on the BSD license adopted by the Apache Foundation.
 *
 * $Id: StdPeerGroup.java,v 1.2 2002/03/04 21:42:59 echtcherbina Exp $
 */



package net.jxta.impl.peergroup;

import java.util.Hashtable;
import java.util.Vector;
import java.util.Enumeration;
import java.io.IOException;
import java.io.StringWriter;

import net.jxta.credential.*;
import net.jxta.discovery.DiscoveryService;
import net.jxta.document.Advertisement;
import net.jxta.document.AdvertisementFactory;
import net.jxta.document.Element;
import net.jxta.document.MimeMediaType;
import net.jxta.document.StructuredDocumentFactory;
import net.jxta.document.StructuredTextDocument;
import net.jxta.document.TextElement;
import net.jxta.exception.PeerGroupException;
import net.jxta.id.ID;
import net.jxta.peergroup.PeerGroup;
import net.jxta.peergroup.PeerGroupFactory;
import net.jxta.platform.Module;
import net.jxta.platform.ModuleClassID;
import net.jxta.platform.ModuleSpecID;
import net.jxta.protocol.ModuleImplAdvertisement;
import net.jxta.protocol.PeerAdvertisement;
import net.jxta.service.*;

import org.apache.log4j.Category; import org.apache.log4j.Priority;

/**
 * A subclass of GenericPeerGroup that make a group out of independent
 * plugin services listed in its impl advertisement.
 */
public class StdPeerGroup extends GenericPeerGroup {

    private static final Category LOG =
        Category.getInstance(StdPeerGroup.class.getName());

    static {
	try {
	    PeerGroupFactory.setStdPeerGroupClass(Class.forName("net.jxta.impl.peergroup.StdPeerGroup"));
	} catch(Exception e) {
	    e.printStackTrace();
	}
    }

    private boolean initialized = false;

    private Hashtable applications = new Hashtable();
    private Hashtable protocols = new Hashtable();

        // A few things common to all ImplAdv for built-in things.
    public static final StructuredTextDocument stdCompatStatement = mkCS();
    public static final String stdUri = "http://www.jxta.org/download/jxta.jar";
    public static final String stdProvider = "sun.com";

    private static StructuredTextDocument mkCS() {
        try {
            StructuredTextDocument doc = (StructuredTextDocument)
                StructuredDocumentFactory.newStructuredDocument(
                    new MimeMediaType("text", "xml"),
                    "Comp");
            Element e = doc.createElement("Efmt", "JDK1.4");
            doc.appendChild(e);
            e = doc.createElement("Bind", "V1.0 Ref Impl");
            doc.appendChild(e);
            return doc;
        } catch (Exception trbl) {
            if (LOG.isEnabledFor(Priority.ERROR)) LOG.error("Cannot create essential StructuredTextDocument.", trbl);
            throw new RuntimeException(
                "Cannot create essential StructuredTextDocument.");
        }
    }

    private ModuleImplAdvertisement allPurposeImplAdv = null;

    // An internal convenience method essentialy for bootstraping.
    // Make a standard ModuleImplAdv for any service that comes builtin this
    // reference implementation.
    // In most cases there are no params, so we do not take that argument.
    // The invoker may add params afterwards.
    protected ModuleImplAdvertisement mkImplAdvBuiltin(
        ModuleSpecID specID,
        String code,
        String descr ) {

        ModuleImplAdvertisement implAdv = (ModuleImplAdvertisement)
            AdvertisementFactory.newAdvertisement(
                ModuleImplAdvertisement.getAdvertisementType());

        implAdv.setModuleSpecID(specID);
        implAdv.setCompat(stdCompatStatement);
        implAdv.setCode(code);
        implAdv.setUri(stdUri);
        implAdv.setProvider(stdProvider);
        implAdv.setDescription(descr);
        return implAdv;
    }

    /**
     * Evaluates if the given compatibility statement makes the module that
     * bears it is lodable by this group.
     *
     * @return boolean True if the given statement is compatible.
     */
    public boolean compatible(Element compat) {
        // The use of the string form is not terribly smart, but it seems
        // there is no reasonable equals() method in Document or Element.
        StringWriter mine = new StringWriter();
        StringWriter his = new StringWriter();
        try {
            ((StructuredTextDocument) compat).sendToWriter(his);
            stdCompatStatement.sendToWriter(mine);
        } catch (Exception any) {
            return false;
        }
        return his.toString().equals(mine.toString());
    }

    Vector disabledModules = new Vector();

    /**
     * Builds a table of modules indexed by their class ID.
     * The values are the loaded modules, the keys are their classId.
     * This routine interprets the <param> list in the adv, which is
     * proper to this group subclass.
     */
    protected void loadAllModules(Hashtable modules,
                                  ModuleClassID thisClassOnly) {

        Enumeration allKeys = modules.keys();
        while (allKeys.hasMoreElements()) {
            ModuleClassID classID = (ModuleClassID) allKeys.nextElement();
            Object value = modules.get(classID);


            // Class was filtered.
            if (thisClassOnly != null && ! thisClassOnly.equals(classID)) {
                continue;
            }

            // If it is disabled, strip it.
            if (disabledModules.contains(classID)) {
                if (LOG.isEnabledFor(Priority.INFO)) {
                    LOG.info("disabled by configuration: "
                             + classID.toString() + ".");

                }
                modules.remove(classID);
                if (thisClassOnly != null) break; else continue;
            }

            // Already loaded.
            if (value instanceof Module) {
                if (thisClassOnly != null) break; else continue;
            }

            // Try and load it.
            try {
                Module theModule = null;
                if (value instanceof ModuleImplAdvertisement) {
                    // Load module will republish localy but not in the
                    // parent since that adv does not come from there.
                    theModule = loadModule(classID,
                                           (ModuleImplAdvertisement) value);

                } else if (value instanceof ModuleSpecID) {
                    // loadModule will republish both localy and in the parent
                    // Where the module was fetched.
                    theModule = loadModule(classID,
                                           (ModuleSpecID) value,
                                           FromParent);
                } else {
                    if (LOG.isEnabledFor(Priority.WARN)) LOG.warn("skipping: "
                             + classID.toString()
                             + " (Unsupported descriptor).");
                    modules.remove(classID);
                    if (thisClassOnly != null) break; else continue;
                }
                modules.put(classID, theModule);
                if (value instanceof ModuleClassID) {
                    if (LOG.isEnabledFor(Priority.INFO)) LOG.info("loaded: "
                             + theModule.getClass().getName());
                } else {
                    if (LOG.isEnabledFor(Priority.INFO)) LOG.info("loaded: "
                             + ((ModuleImplAdvertisement)
                                value).getDescription());
                }
            } catch(Exception e) {
                if (LOG.isEnabledFor(Priority.DEBUG)) LOG.debug("Could not load module: ", e);
                if (value instanceof ModuleClassID) {
                    if (LOG.isEnabledFor(Priority.WARN)) LOG.warn("skipped: "
                             + classID.toString()
                             + " (" + e.getMessage() + ").");
                } else {
                    if (LOG.isEnabledFor(Priority.WARN)) LOG.warn("skipped: "
                             + ((ModuleImplAdvertisement)
                                value).getDescription()
                             + " (" + e.getMessage() + ").");
                }
                modules.remove(classID);
            }
            if (thisClassOnly != null) break;
        }
    }

    /**
     * The group does not care for start args, and does not come-up
     * with args to pass to its main app. So, until we decide on something
     * more usefull, the args of the group's startApp are passed-on to the
     * group's main app. NB: both the apps init and startApp methods are
     * invoked.
     *
     * @return int Status.
     */

    public int startApp(String[] arg) {
        // Normaly does nothing, but we have to.
        super.startApp(arg);

        loadAllModules(applications,
                      null);

        int res = 0;
        Enumeration appKeys = applications.keys();

        while (appKeys.hasMoreElements()) {
            Object appKey = appKeys.nextElement();
            Module app = (Module) applications.get(appKey);