<HTML>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<HEAD>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<meta name="description" content="What's new in NetBeans 3.6 ?">
<link rel="stylesheet" type="text/css" href="../../../netbeans.css">
<style type="text/css">
<!--
.ST1 {color: #99006b}
.ST0 {color: #780000}
-->
</style>
<title>Adding J2ME&#8482; Platform Support to the NetBeans&#8482; IDE</title>
</HEAD>
<body>
<h1>Adding J2ME&#8482; Platform Support to the NetBeans&#8482; IDE</h1>


<p>Updating the NetBeans&#8482; IDE with the Mobility Modules for NetBeans 
  integrates support for developing and testing 
   applications for mobile devices that use the Java&#8482; 2,
  Micro Edition  (J2ME&#8482;) platform. </p>

<p><a href="#included">Included Modules</a><br>
  <a href="#proguard">Installing the Mobility Modules<br>
  Installing the ProGuard Obfuscator  <br>
</a><a href="#palm">Configuring the Palm OS Emulator</a></p>
<h2>Included Modules<a name="included"></a></h2>
<p>The included modules are: </p>
<ul>
  <li>  <code>kjava.nbm</code> - J2ME Wireless Module. Supports MIDP/CLDC development,
  providing various templates, emulator  integration, compilation, execution and debugging.</li>

  <li><code>kjava-emulator</code> - J2ME Wireless Toolkit 1.0.4_01 Module. Provides
    emulation for the MIDP-1.0/CLDC 1.0 platform and various monitoring features.
    The J2ME Wireless Toolkit modules are provided for the Solaris, Linux, and
    Windows platforms, and are named<code> kjava-emulator_sol.nbm</code>, <code>kjava-emulator_linux.nbm</code>,
    and <code>kjava-emulator_win.nbm</code>.</li>
  <li><code>wtk21.nbm</code> - J2ME Wireless Toolkit 2.1 Module. Provides emulation
    for the MIDP 2.0/CLDC 1.1 platform, including
    security standards and support for applications that use the Wireless API
    (WAPI) and Multimedia API (MMAPI).The J2ME Wireless Toolkit modules are provided
    for the Solaris, Linux, and Windows platforms, and are named<code> wtk21_solaris.nbm</code>, <code>wtk21_linux.nbm</code>,
  and <code>wtk21_windows.nbm</code>.</li>

  <li><code>kjava-obfuscator-retroguard.nbm</code> -  RetroGuard Integration
    Module. Provides integration support for the RetroGuard obfuscator. The RetroGuard
    obfuscator
    is included in the module.</li>
  <li><code>kjava-obfuscator-proguard.nbm</code> - 
    ProGuard Integration Module. Provides integration support for the ProGuard
    obfuscator. After you add this module, you must also download and
    add the ProGuard obfuscator
  as described below.</li>
  <li><code>kjava-examples.nbm</code> - 
    Examples Module. Provides sample MIDP applications that demonstrate the features
  and APIs supported by </li>
</ul>
<h2>Installing the Mobility Modules<a name="installing"></a></h2>

<p>To install the Mobility  modules:</p>
<ol>
  <li>Select Tools > Update Center. <br>
    This opens the Update Center wizard. </li>
  <li>On the first page of the wizard, select the Install Manually Downloaded
    Modules (.nbm files) radio button. Follow the wizard instructions to download
    and install the following modules from the Update Center: </li>
  <ul>
  <li>Required:
    <ul>

      <li> J2ME Wireless module</li>
      <li>J2ME Wireless Toolkit 2.1 module for your platform.</li>
      </ul>
  </li>
  <li>Optional:
    <ul>
      <li>J2ME Wireless Toolkit 1.0.4_01 module for your platform.</li>

      <li>RetroGuard
          Integration module </li>
      <li>ProGuard Integration module </li>
      <li>Examples module</li>
    </ul>
  </li>
  </ul>
    <p>

      If any of the modules are not visible in the Update Center, they
     are already
installed.</p>

  <p>Note that the RetroGuard and ProGuard Integration modules are optional.
    If you choose to install them, the menu choice, "Obfuscators" is available
    from the Tools menu after the modules are installed. </p>
  <p>Also note that the RetroGuard obfuscator is included with the Mobility
    modules. To use the ProGuard obfuscator, you must download the obfuscator
    and install it, as described below. </p>



</ol>
<h3>Installing the ProGuard Obfuscator<a name="proguard"></a></h3>
<p>To install the ProGuard obfuscator:</p>

<ol>
<li>Download the ProGuard obfuscator (<code>proguard2.0.1.tar.gz</code> or <code>proguard2.0.1.zip</code>)
    from <code>http://proguard.sourceforge.net/.</code></li>
<li>Untar or unzip the file into a directory on your system. </li>
<li>Add the ProGuard obfuscator
    using the Obfuscator Registry:
    <ol>
      <li>Choose Tools > Obfuscators.
                   The Obfuscator Registry dialog opens. </li>
      <li>In the right pane of the dialog, select the node for the obfuscator
                         you want to install.
                           The Property sheet for the obfuscator is displayed in
      the left pane of the dialog. </li>

      <li> Click on the ellipsis (...) button for the Obfuscator Executable
            property. A File Chooser window opens. </li>
      <li>Use the File Chooser window to navigate to the JAR file for the
                    obfuscator (for example, <code>proguard.jar</code>) and click OK.
                         The path to the JAR file is shown in the property sheet.</li>
    </ol>
  </li>
  <li>You can now integrate obfuscation into your compilation process, as
    described in the  Mobility modules' online help. </li>
</ol>

<h3>Configuring the PalmOS Emulator<a name="palm"></a></h3>
<p>If you want to run the Palm OS Emulator that is included with the J2ME Wireless
  Toolkit 1.0.4, you must install the emulator before installing the NetBeans
IDE. You can download the emulator from <tt>http://www.palmos.com/dev/tech/tools/emulator/</tt>.</p>
  <p>You must first configure the emulator as follows:</p>
  <ol>
    <li>Redirect NetLib calls to the host&#8217;s TCP/IP.<br>
      For certain functions like debugging and Internet connectivity to work,
        you must set NetLib API calls to be redirected from the Palm OS Emulator
        to use
    your computer&#8217;s TCP/IP.</p>

    <ol><li>Run the Palm OS Emulator and right-click the emulator.<br>
    A menu appears.</li>
      <li>Select Settings &gt; Properties&#8230;</li>
        <br>
        The Properties dialog appears.<br>
        <li>Check the Redirect NetLib calls to host TCP/IP box, and click OK.<br>

        The Properties dialog disappears.</li>
        <li>Right-click the emulator and select Save.<br>
      Your changes are saved.</li>
      </ol>
    <li>Disable debugging.<br>
    The Palm OS Emulator allows various items to be debugged while the application
    executes. However, for the Palm OS Emulator to work with the Sun Java Studio
    Mobility IDE, debugging must be disabled altogether.</li>

    <ol><li>Run the Palm OS Emulator, and right-click the emulator.<br>
    A menu appears.</li>
    <li>Select Settings &AElig; Debugging&#8230;<br>
    The Debug Options dialog appears.</li>
    <li>Uncheck all the boxes and click OK.<br>

    The Debug Options dialog disappears.</li>
    <li>Right-click the emulator and select Save.<br>
    Your changes are saved.</li>
        </ol>
    <li>Set the Palm OS Emulator location in the  IDE.<br>
    The first time you run an application using the Palm OS Emulator through
      the IDE, a dialog appears, asking you for the Palm OS
    Emulator location. After you set the location, the dialog will not appear
      again when you run MIDP applications using the emulator.
</li>

  </ol>
  <h2>Legal Notices</h2>
  <p><font size="-1">Copyright &copy; 2004 Sun Microsystems, Inc., 4150 Network
      Circle, Santa Clara, California 95054, U.S.A. All rights reserved.</font></p>
  <p><font size="-1">Sun Microsystems, Inc. has intellectual property rights
      relating to technology embodied in the product that is described in this
      document. In particular, and without limitation, these intellectual property
      rights may include one or more of the U.S. patents listed at <a href="http://www.sun.com/patents">http://www.sun.com/patents</a> and
      one or more additional patents or pending patent applications in the U.S.
      and in other countries.</font></p>
  <p><font size="-1">This document and the product to which it pertains are distributed
      under licenses restricting their use, copying, distribution, and decompilation.
      No part of the product or of this document may be reproduced in any form
      by any means without prior written authorization of Sun and its licensors,
      if any.</font></p>

  <p><font size="-1">Third-party software, including font technology, is copyrighted
      and licensed from Sun suppliers.</font></p>
  <p><font size="-1">Sun, Sun Microsystems, the Sun logo, Forte, Java, NetBeans,
      iPlanet, docs.sun.com, the Sun ONE logo, and Solaris are trademarks or
      registered trademarks of Sun Microsystems, Inc. in the U.S. and other countries.</font></p>
  <p><font size="-1">Federal Acquisitions: Commercial Software - Government Users
      Subject to Standard License Terms and Conditions.</font></p>
  <p><font size="-1">DOCUMENTATION IS PROVIDED &quot;AS IS&quot; AND ALL EXPRESS
      OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY IMPLIED
      WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT,
      ARE DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD TO
      BE LEGALLY INVALID.</font></p>
  <p><font size="-1">Copyright &copy; 2004 Sun Microsystems, Inc., 4150 Network
      Circle, Santa Clara, California 95054, Etats-Unis. Tous droits r&eacute;serv&eacute;s.</font></p>

  <p><font size="-1">Sun Microsystems, Inc. a les droits de propri&eacute;t&eacute; intellectuels
      relatants&agrave; la technologie incorpor&eacute;e dans le produit qui
      est d&eacute;crit dans ce document. En particulier, et sans la limitation,
      ces droits de propri&eacute;t&eacute; intellectuels peuvent inclure un
      ou plus des brevets am&eacute;ricains &eacute;num&eacute;r&eacute;s&agrave; <a href="http://www.sun.com/patents"> http://www.sun.com/patents</a> et
      un ou les brevets plus suppl&eacute;mentaires ou les applications de brevet
      en attente dans les Etats - Unis et dans les autres pays.</font></p>

  <p><font size="-1">Ce produit est un document protege par un copyright et distribue
      avec des licenses qui est en restreignent l'utilisation, la copie, la distribution
      et la d&eacute;compilation. Aucune partie de ce produit ou document ne
      peut &ecirc;tre reproduite sous aucune forme, parquelque moyen que ce soit,
      sans l'autorisation pr&eacute;alable et &eacute;crite de Sun et de ses
      bailleurs de licence, s'il y en a.</font></p>
  <p><font size="-1">Le logiciel d&eacute;tenu par des tiers, et qui comprend
      la technologie relative aux polices de caract&egrave;res, est prot&eacute;g&eacute; par
      un copyright et licenci&eacute; par des fournisseurs de Sun.</font></p>

  <p><font size="-1">Sun, Sun Microsystems, le logo Sun, Forte, Java, NetBeans,
      iPlanet, docs.sun.com, the Sun ONE logo, et Solaris sont des marques de
      fabrique ou des marques d&eacute;pos&eacute;es de Sun Microsystems, Inc.
      aux Etats-Unis et dans d'autres pays.</font></p>
  <p><font size="-1">LA DOCUMENTATION EST FOURNIE &quot;EN L'&Eacute;TAT&quot; ET
      TOUTES AUTRES CONDITIONS, DECLARATIONS ET GARANTIES EXPRESSES OU TACITES
      SONT FORMELLEMENT EXCLUES, DANS LA MESURE AUTORISEE PAR LA LOI APPLICABLE,
      Y COMPRIS NOTAMMENT TOUTE GARANTIE IMPLICITE RELATIVE A LA QUALITE MARCHANDE,
      A L'APTITUDE A UNE UTILISATION PARTICULIERE OU A L'ABSENCE DE CONTREFA&Ccedil;ON.</font></p>
  <p>&nbsp;</p>
</body>
</html>
