peergroupfactory.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: PeerGroupFactory.java,v 1.2 2002/03/04 20:19:20 echtcherbina Exp $
 */

package net.jxta.peergroup;

import java.lang.Class;

import java.io.FileInputStream;
import java.util.Hashtable;
import java.util.Properties;

import net.jxta.document.Advertisement;
import net.jxta.document.AdvertisementFactory;
import net.jxta.document.StructuredDocument;
import net.jxta.document.MimeMediaType;
import net.jxta.protocol.ModuleImplAdvertisement;
import net.jxta.protocol.PeerAdvertisement;
import net.jxta.id.ID;
import net.jxta.id.IDFactory;
import net.jxta.peergroup.PeerGroup;
import net.jxta.exception.PeerGroupException;
import net.jxta.exception.JxtaError;

import java.util.Hashtable;

// Here we refer to the implementation, which is normal since we are explicitly
// chosing to use a particular peergroup implementation for the default net
// peer group

import net.jxta.impl.peergroup.StdPeerGroupParamAdv;

/**
 * Factory Classes to create a new Peer Platform and New PeerGroups. This
 * class is used by Jxta applications to create new groups
 *
 * <p> JXTA comes with two subclasses of peer groups:
 *
 * <ul type-disc>
 *
 * <li> <strong>Platform</strong>: this is used to represent the <em>World</em>
 * group. Every peer, when booting, becomes part of this group. This group
 * provides the minimum core services needed to find and instanciate other
 * groups on a peer. <strong>Platform</strong> has the privilege of assigning
 * a new ID to the peer, if it does not already have one. The <em>World</em>
 * group's ID is invariant.</li>
 *
 * <li> <strong>StdPeergroup</strong>: this is currently used to implement
 * all other kinds of peer groups.
 * The first such group that it is instanciated after booting is known as
 * <em>The Net Peer Group</em>. When <strong>Platform</strong> starts it may
 * optionaly search for <em>The Net Peer Group</em> on the local network and,
 * if found, instanciate it. Otherwise a default configuration of
 * <em>The Net Peer Group</em> is instanciated.
 *
 * A non-default configuration of <em>The Net Peer Group</em> may be set-up
 * by the administrator in charge of the network domain inside which the peer
 * is booting. <em>The Net Peer Group</em> is discovered via the DiscoveryService
 * protocol. Many such groups may be configured by an administrator.<br>
 *
 * <strong>StdPeergroup</strong> may also be used to implement User-defined
 * peer groups: Users can create new peer groups which use their own set of
 * customized services.
 *</li>
 *</ul>
 *
 * <p>The Platform group is created via the <b>newPlatform</b> method. The Net
 * Peer Group and user Peer Groups are created via the <b>newPeerGroup</b>
 * method.
 *
 *  @see net.jxta.peergroup.PeerGroup
 *
 *  @version $Revision: 1.2 $
 *  @since JXTA 1.0 */

public class PeerGroupFactory {

  private static Class stdPeerGroupClass;
  private static Class platformClass;

  /**
   * Static Method to initialize the std peer group class
   *
   *  @param Class name to be initialized in the factory
   *  @version $Revision: 1.2 $
   *
   *  @since JXTA 1.0
   */

    public static void setStdPeerGroupClass(Class c) {
      stdPeerGroupClass = c;
    }

  /**
   * Static Method to initialize the Platform peergroup class
   *
   *  @param Class name of the class implementing platform
   *  @version $Revision: 1.2 $
   *
   *  @since JXTA 1.0
   */

  public static void setPlatformClass(Class c) {
    platformClass = c;
  }

  /**
   * Static Method to create a new peer group instance.
   *
   * After beeing created the init method needs to be called, and
   * the startApp() method may be called, at the invoker's discretion.
   *
   *  @return PeerGroup instance of a new PeerGroup
   *  @version $Revision: 1.2 $
   *
   *  @since JXTA 1.0
   */


  public static PeerGroup newPeerGroup() {
    try {
      return (PeerGroup) stdPeerGroupClass.newInstance();
    } catch (Exception e) {
      throw new JxtaError("No valid Standard PeerGroup class");
    }
  }



  /**
   * Static Method to create a new peer Plaform
   *
   * The init() method is called automatically. The startApp() method
   * is left for the invoker to call if appropriate.
   *
   * Invoking this method amounts to creating an instance of JXTA.
   *
   * Since JXTA stores its persistent state in the local filesystem
   * relative to the initial current directory, it is unadvisable to
   * start more than one instance with the same current directory.
   *
   *  @return PeerGroup instance of a new Platform
   *
   *  @version $Revision: 1.2 $
   *  @since JXTA 1.0
   */

  public static PeerGroup newPlatform() {

    PeerGroup plat = null;
    try {
      plat = (PeerGroup) platformClass.newInstance();
    } catch (Exception e) {
      throw new JxtaError("No valid Platform class");
    }

    try {
        plat.init(null, null, null);
    } catch (Exception e) {
      throw new JxtaError("Platform.init failed");
    }
    return plat;
  }

    /**
     * Until the concept of netPeerGroup is better integrated, we need
     * something straightforward so that applications that whish to control
     * the start-up process can easily bring up a netPeerGroup like
     * startNetPeerGroup does.
     *
     * This method does this.
     *
     * @param pg The platform group.
     * @return PeerGroup The default netPeerGroup
     */

    public static PeerGroup newNetPeerGroup(PeerGroup pg)
        throws PeerGroupException
        {
         try {
            // Use the all purpose group impl as a basis.
            ModuleImplAdvertisement netPgImplAdv =
                pg.getAllPurposePeerGroupImplAdvertisement();

            // For now, still use the well know NPG naming, it is not
            // identical to the allPurpose PG because we use the class
            // ShadowPeerGroup which initializes the peer config from its
            // parent.
            netPgImplAdv.setModuleSpecID(PeerGroup.refNetPeerGroupSpecID);
            netPgImplAdv.setCode("net.jxta.impl.peergroup.ShadowPeerGroup");
            netPgImplAdv.setDescription("Default NetPeerGroup reference"
                                       + " implementation.");

            // Use the well known default NPG ID.
            PeerGroupID pgId = PeerGroupID.defaultNetPeerGroupID;

            // We've got a gid and a complete ModuleImplAdv so we can build
            // the group now.
            PeerGroup newPg = pg.newGroup(pgId,
                                          netPgImplAdv,
                                          "NetPeerGroup",
                                          "NetPeerGroup by default");
            return newPg;
        } catch (Exception e) {
            // Simplify exception scheme for caller: any sort of trbl is
            // a PeerGroupException.
            throw new PeerGroupException(e.getMessage());
        }
    }


    /**
     *  Creates a default platform peergroup, from which a new netpeergroug is
     *  created.  This simplifies the method by which applications can
     *  start jxta.
     *
     *  @return The newly created net peer group.
     */
    public static PeerGroup newNetPeerGroup( )
        throws PeerGroupException
    {
       try {
            setPlatformClass(
                    Class.forName("net.jxta.impl.peergroup.Platform"));
            setStdPeerGroupClass(
                    Class.forName("net.jxta.impl.peergroup.StdPeerGroup"));
       } catch ( ClassNotFoundException e ) {
           throw new PeerGroupException("Unable to find class :"+e.getMessage() );
       }
       // create the  default Platform Group.

       PeerGroup platformGroup = newPlatform();
       PeerGroup npg = newNetPeerGroup ( platformGroup );
       return npg;
    }
}