<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<HTML>
<HEAD>
  <meta NAME='content-language' CONTENT='fr'>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
  <meta name="description" content="Support J2ME dans NetBeans 3.6 ?">
  <link rel="stylesheet" type="text/css" href="../../../netbeans.css">
<style type="text/css">
<!--
.ST1 {color: #99006b}
.ST0 {color: #780000}
-->
</style>
<title>Ajout Support Plateforme J2ME&#8482; à l'EDI NetBeans&#8482;</title>
</HEAD>

<body>

<h1>Ajout Support Plateforme J2ME&#8482; à l'EDI NetBeans&#8482;</h1>

<p>La mise à Jour de l'EDI NetBeans&#8482; avec les Modules de Mobilités 
pour NetBeans intègre le support pour le développement et le test
d'applications pour les appareils mobiles qui utilisent 
la plateforme Java&#8482; 2, Micro Edition  (J2ME&#8482;). </p>

<p><a href="#included">Modules Inclus</a><br>
  <a href="#proguard">Installation des Modules de Mobilité<br>
  Installation de l'Obfuscateur ProGuard <br>
</a><a href="#palm">Configuration de l'Emulateur Palm OS</a></p>
<h2>Modules Inclus<a name="included"></a></h2>
<p>Les modules inclus sont : </p>
<ul>
  <li>  <code>kjava.nbm</code> - J2ME Wireless Module. Supporte le développement 
 de MIDP/CLDC, fournissant de nombreux templates, intégration 
 compilation exécution et débogage sous des émulateurs.</li>

  <li><code>kjava-emulator</code> - J2ME Wireless Toolkit 1.0.4_01 Module. 
Fournit l'émulation pour la plateforme MIDP-1.0/CLDC 1.0 et de nombreuses
fonctionnalités de monitoring. Les modules J2ME Wireless Toolkit sont
fournit pour les plateformes Solaris, Linux, et Windows, et sont nommés
<code> kjava-emulator_sol.nbm</code>, 
<code>kjava-emulator_linux.nbm</code>, et 
<code>kjava-emulator_win.nbm</code>.</li>
  <li><code>wtk21.nbm</code> - J2ME Wireless Toolkit 2.1 Module. Fournit une
émulation pour la plateforme MIDP 2.0/CLDC 1.1, comprenant les standards de
sécurité, et le support pour des applications qui utilisent le Wireless API
    (WAPI) et Multimédia API (MMAPI).
    Les modules J2ME Wireless Toolkit sont fournit pour les plateformes 
    Solaris, Linux, et Windows, et sont nommés
    <code> wtk21_solaris.nbm</code>, 
    <code>wtk21_linux.nbm</code>, et 
    <code>wtk21_windows.nbm</code>.</li>

  <li><code>kjava-obfuscator-retroguard.nbm</code> -  RetroGuard Integration
    Module. Fournit le support d'intégration pour l'obfuscateur RetroGuard obfuscator. 
    L'obfuscateur The RetroGuard est inclut dans le module.</li>
  <li><code>kjava-obfuscator-proguard.nbm</code> - 
    Module d'Intégration ProGuard. Fournit le support d'intégration pour 
    l'obfuscateur ProGuard. Après que vous ayez ajouté ce module, vous devez également
    télécharger et ajouter l'obfuscateur ProGuard comme décrit ci-dessous.</li>
  <li><code>kjava-examples.nbm</code> - 
    Modules d'Exemples. Fournit des applications d'exemple MIDP qui démontrent 
    les fonctionnalités et API supportées
  </li>
</ul>
<h2>Installation des Modules de Mobilité<a name="installing"></a></h2>

<p>Pour installer les Modules de Mobilités:</p>
<ol>
  <li>Sélectionnez Outils > Centre de Mise à Jour. <br>
    Cela ouvre l'assistant de Centre de Mise à Jour. </li>
  <li>Sur la première page de l'assistant, sélectionnez le bouton radio 
        Install Manually Downloaded Modules (.nbm files). 
      Suivez les instructions de l'assistant pour télécharger et installer
      les modules suivants depuis le Centre de Mise à Jour: </li>
  <ul>
  <li>Requis:
    <ul>

      <li> module J2ME Wireless </li>
      <li>module J2ME Wireless Toolkit 2.1 pour votre plateforme .</li>
      </ul>
  </li>
  <li>Optionnel:
    <ul>
      <li>module J2ME Wireless Toolkit 1.0.4_01 pour votre plateforme.</li>

      <li>module d'Intégration RetroGuard </li>
      <li>module d'Intégration ProGuard </li>
      <li>module d'Exemples</li>
    </ul>
  </li>
  </ul>
    <p>
      Si certaines de ces modules ne sont pas visible dans le Centre de Mise à 
      Jour, cela signifie qu'ils sont déjà installés.</p>

  <p>Notez que les modules d'intégration de RetroGuard et ProGuard sont optionnels.
    Si vous choisissez de les installer, le choix de menu, "Obfuscators", 
    sera disponible dans le menu Tools après que les modules aient été installés. </p>
  <p>Notez également que l'obfuscateur RetroGuard est inclut avec les modules de 
    mobilités. Pour utilisez l'obfuscateur ProGuard, vous devez 
    tout d'abord le télécharger et l'installer, comme décrit ci-dessous. </p>



</ol>
<h3>Installation de l'Obfuscateur ProGuard <a name="proguard"></a></h3>
<p>Pour installer l'obfuscateur ProGuard:</p>

<ol>
<li>Téléchargez l'obfuscateur ProGuard (<code>proguard2.0.1.tar.gz</code> ou <code>proguard2.0.1.zip</code>)
    depuis <code>http://proguard.sourceforge.net/.</code></li>
<li>Untar ou unzip le fichier dans un répertoire de votre système. </li>
<li>Ajoutez l'obfuscateur ProGuard en utilisant l'Obfuscator Registry:
    <ol>
      <li>Choisissez Tools > Obfuscators.
                   La boîte de dialogue Obfuscator Registry s'ouvre. </li>
      <li>Dans le panneau de droite, sélectionnez le noeud pour l'obfuscateur 
    que vous désirez installer.
                           La feuille de propriété pour l'obfuscateur est
    affichée dans le panneau de gauche. </li>

      <li> Cliquez sur le bouton d'ellipse (...) pour la propriété 
    Obfuscator Executable. Une fenêtre pour Ouvrir le Fichier s'ouvre. </li>
      <li>Utilisez la fenêtre File Chooser pour naviguer jusqu'au fichier JAR 
    de l'obfuscateur (par exemple, <code>proguard.jar</code>) and cliquez sur OK.
    Le chemin jusqu'au fichier JAR est montré dans la feuille de propriété.</li>
    </ol>
  </li>
  <li>Vous pouvez maintenant intégré l'obfuscation dans votre processus 
    de compilation, comme décrit dans l'aide en ligne des modules de Mobilité. </li>
</ol>

<h3>Configuration de l'Emulateur PalmOS<a name="palm"></a></h3>
<p>Si vous désirez exécuter l'Emulateur Palm OS qui est inclut avec le 
J2ME Wireless Toolkit 1.0.4, vous devez installer l'émulateur avant d'installer 
l'EDI NetBeans. Vous pouvez télécharger l'émulateur depuis la page
<tt>http://www.palmos.com/dev/tech/tools/emulator/</tt>.</p>
  <p>Vous devez tout d'abord configurer l'émulateur comme suit:</p>
  <ol>
    <li>Rediriger les appels NetLib sur le TCP/IP du host.<br>
      Pour que certaines fonctions comme le débogage et la connectivité Internet
      fonctionnent, vous devez définir les appels d'API NetLib pour être 
      redirigé depuit l'Emulateur Palm OS pour utiliser le TCP/IP
      de votre ordinateur.</p>

    <ol><li>Exécuter l'Emulateur Palm OS et cliquez-droit sur l'émulateur.<br>
    Un menu apparaît.</li>
      <li>Sélectionnez Settings &gt; Properties&#8230;</li>
        <br>
        La boîte de dialogue des Propriétés apparait.<br>
        <li>Cocher la case Redirect NetLib calls to host TCP/IP, et cliquez sur OK.<br>

        La boîte de dialogue des propriétés disparait.</li>
        <li>Cliquez-droit sur l'émulateur et sélectionnez Save.<br>
      Vos modifications sont enregistrées.</li>
      </ol>
    <li>Désactiver le débogage.<br>
    L'Emulateur Palm OS permet à de nombreux éléments d'être débogué durant l'
    exécution de l'application. Cependant, pour que l'Emulateur 
    Palm OS focntionne avec l'EDI NetBeans, le débogage doit être 
    désactivé.</li>

    <ol><li>Exécutez l'Emulateur Palm OS, et cliquez-droit sur l'émulateur.<br>
    Un menu apparaît.</li>
    <li>Sélectionnez Settings &AElig; Debugging&#8230;<br>
    La boîte de dialogue de Débogage apparaît.</li>
    <li>Décochez toutes les cases et cliquez sur OK.<br>

    La boîte de dialogue de Débogage disparait.</li>
    <li>Cliquez-droit sur l'émulateur et sélectionnez Enregistrer.<br>
    Vos modifications sont enregistrées.</li>
        </ol>
    <li>Définir l'endroit de l'Emulateur Palm OS dans l'EDI.<br>
    La première fois que vous exécutez une application en utilisant 
    l'Emulateur Palm OS via l'EDI, une boite de dialogue apparaît, vous demandant 
    l'endroit où se site l'émulateur Palm OS. Après que vous ayez définit cet endroit,
    la boite de dialogue n'apparaitra plus lorsque vous exécuterez les applications
    MIDP en utilisant l'émulateur.
</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>

