<!DOCTYPE HTML PUBLIC"-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=UTF-8">

<title>Guia de instala&ccedil;&atilde;o do NetBeans Mobility Pack para CDC 5.5.1</title>
<link rel="stylesheet" type="text/css" href="../../../../netbeans.css">

</head>
<body>
<a name=top></a>
<h1>Guia de instala&ccedil;&atilde;o do NetBeans Mobility Pack para CDC 5.5.1</h1>
<p>O NetBeans Mobility Pack para CDC 5.5.1 fornece um ambiente para construir rapidamente aplicativos do Java Micro Edition (Java ME) que d&atilde;o suporte a dispositivos usando a Connected Device Configuration (CDC) e os perfis Pessoal, Funda&ccedil;&atilde;o e AGUI. </p>
<p><b>Conte&uacute;do</b></p>
<ul>
  <li> <a href="#prerequisites" title="Pr&eacute;-requisitos">Pr&eacute;-requisitos</a></li>
  <li> <a href="#installation" title="Instalando o software">Instalando o software</a></li>
  <li><a href="#emulators">Instalando plataformas de emulador</a></li>
  <li> <a href="#uninstallation" title="Desinstalando o software">Desinstalando o software</a></li>
  <li> <a href="#troubleshoot" title="Solu&ccedil;&atilde;o de problemas">Solu&ccedil;&atilde;o de problemas</a></li>
</ul>
<p>&nbsp;</p>
<p><b>Observa&ccedil;&atilde;o:</b> Para obter informa&ccedil;&otilde;es sobre os requisitos do sistema para o software inclu&iacute;do neste pacote, consulte as <a href="relnotes-mobilitycdc_pt_BR.html">Notas da vers&atilde;o do NetBeans Mobility Pack para CDC 5.5.1</a>.</p>
<h2><a name=prerequisites></a>Pr&eacute;-requisitos</h2>
<p>Este t&oacute;pico especifica os pr&eacute;-requisitos que devem ser cumpridos antes de voc&ecirc; iniciar a instala&ccedil;&atilde;o do NetBeans Mobility Pack para CDC 5.5.1.</p>
<p>Observe que o NetBeans Mobility Pack para CDC n&atilde;o pode ser executado no NetBeans IDE 5.5. Voc&ecirc; <em>deve</em> usar o NetBeans IDE 5.5.1. </p>
<p>Fa&ccedil;a o download do NetBeans Mobility Pack para CDC 5.5.1 na <a href="http://services.netbeans.org/downloads/index.php?p=10">P&aacute;gina de downloads netbeans.org</a>.</p>
<blockquote>
  <h3>Software necess&aacute;rio</h3>
  <p>Informa&ccedil;&otilde;es detalhadas sobre hardware, software e requisitos do sistema operacional encontram-se nas <a href="relnotes-mobilitycdc_pt_BR.html">Notas da vers&atilde;o do NetBeans Mobility Pack para CDC 5.5.1</a>.</p>
  <p>&Eacute; necess&aacute;rio que os softwares abaixo estejam instalados antes da instala&ccedil;&atilde;o do NetBeans Mobility Pack para CDC 5.5.1.</p>
  <ul>
    <li><a href="http://java.sun.com/javase/downloads/index.jsp" target="_blank">Java SE Development Kit (JDK) 5.0 ou 6.0</a></li>
    <li><a href="http://services.netbeans.org/downloads/index.php?rs=21" target="_blank">NetBeans IDE 5.5.1</a></li>
  </ul>
  <p>O Sun Java Toolkit para CDC est&aacute; integrado ao NetBeans Mobility Pack. No entanto, se desejar programar aplicativos para outras plataformas suportadas, &eacute; necess&aacute;rio fazer o download de um ou mais dos seguintes SDKs e instal&aacute;-los:</p>
  <ul>
    <li>Ricoh
      <ul>
        <li>Embedded Software Architecture Emulator (Registro necess&aacute;rio para o <a href="http://www.ricoh.com/esa/index.html">download</a>)</li>
      </ul>
    </li>
    <li>Sony Ericsson
      <ul>
        <li>UIQ 3 SDK (logon necess&aacute;rio para o <a href="http://developer.sonymobile.com/downloads/sdks/">download</a>)</li>
        <li>M600 Extension Package para o UIQ 3 SDK Beta 3 (<a href="http://developer.sonymobile.com/downloads/sdks/">download</a>)</li>
        <li>P990 Extension Package para o UIQ 3 SDK Beta 3 (<a href="http://developer.sonymobile.com/downloads/sdks/">download</a>)</li>
      </ul>
    </li>
    <li>Nokia
      <ul>
        <li>Nokia Series 80 Platform SDK para Symbian OS, para Java, perfil Pessoal (<a href="http://www.forum.nokia.com/info/sw.nokia.com/id/449a2f84-2a8a-44fa-a7f4-93b53cb9c89a/Series_80_Platform_SDK_s_for_Symbian_OS_for_Java.html">download</a>)
        </li>
      </ul>
    </li>
    <li> NSIcom (CrEme para Windows CE)
      <ul>
        <li> CrEme 4.10 Developer Support (<a href="http://nsicom.com/shared/CrEmeDevSup410.exe">download</a>)</li>
        <li>Microsoft Device Emulator 1.0 (<a href="http://www.microsoft.com/en-us/download/details.aspx?id=20259">download</a>)
        </li>
        <li>Virtual Machine Network Driver para Microsoft Device Emulator (<a href="http://www.microsoft.com/en-us/download/details.aspx?id=2863">download</a>)</li>
        <li>ActiveSync (<a href="http://www.microsoft.com/downloads/details.aspx?FamilyID=9e641c34-6f7f-404d-a04b-dc09f8141141&DisplayLang=en">download</a>)</li>
      </ul>
    </li>
    <li> SavaJe
      <ul>
        <li> A plataforma SavaJe Mobile (n&atilde;o mais dispon&iacute;vel)</li>
      </ul>
    </li>
  </ul>
</blockquote>

<p align=center><a href="#top">in&iacute;cio</a></p>
<h2><a name=installation></a>Instala&ccedil;&atilde;o do software</h2>
<p>Seguem-se instru&ccedil;&otilde;es para instalar o Mobility Pack do NetBeans para CDC 5.5.1. Estas instru&ccedil;&otilde;es pressup&otilde;em que voc&ecirc; j&aacute; tenha instalado o <a href="http://java.sun.com/javase/downloads/index.jsp">Java SE Development Kit</a> e o <a href="https://netbeans.org/community/releases/55/1/install_pt_BR.html">NetBeans IDE 5.5.1</a>.
<blockquote>
  <p><b>Para instalar o Mobility Pack NetBeans para CDC 5.5.1:</b></p>

  <ol>
    <li> Fa&ccedil;a o download do arquivo instalador em <a href="http://services.netbeans.org/downloads/index.php?p=10">http://services.netbeans.org/downloads/index.php?p=10</a>.</li>
    <li>Navegue o sistema at&eacute; o local do arquivo instalador e clique duas vezes no &iacute;cone do instalador para iniciar o instalador. </li>
    <li> Na p&aacute;gina de boas-vindas do assistente para instala&ccedil;&atilde;o, clique em Pr&oacute;ximo. </li>
    <li> Aceite o contrato de licen&ccedil;a e clique em Pr&oacute;ximo. </li>
    <li> Na p&aacute;gina do diret&oacute;rio de instala&ccedil;&atilde;o do assistente para instala&ccedil;&atilde;o, especifique o local de instala&ccedil;&atilde;o do NetBeans IDE 5.5.1. </li>
    <li> O assistente para instala&ccedil;&atilde;o procura as instala&ccedil;&otilde;es compat&iacute;veis do JDK. Se o JDK n&atilde;o estiver no local padr&atilde;o, ser&aacute; necess&aacute;rio especificar o local do Java JDK 1.5.0 ou superior. Voc&ecirc; tamb&eacute;m pode digitar o caminho de outro JDK instalado ou usar o bot&atilde;o Explorar para ir at&eacute; outra instala&ccedil;&atilde;o e selecion&aacute;-la. </li>
    <li>Quando a instala&ccedil;&atilde;o estiver conclu&iacute;da, clique em Finalizar para sair do assistente.</li>
  </ol>
<p>O diret&oacute;rio de projetos padr&atilde;o &eacute; <tt>C:\Documentos e configura&ccedil;&otilde;es\<i>nome de usu&aacute;rio</i></tt>. Se voc&ecirc; desinstalar o Mobility Pack do NetBeans para CDC, este diret&oacute;rio n&atilde;o ser&aacute; exclu&iacute;do e ser&aacute; identificado na pr&oacute;xima vez que voc&ecirc; instalar o Mobility Pack para CDC.</p>
<div class=greybox>
    <p><b>Observa&ccedil;&atilde;o: </b>Se encontrar problemas durante a instala&ccedil;&atilde;o do software, consulte <a href="https://netbeans.org/kb/archive/index.html">Solu&ccedil;&atilde;o de problemas</a> para obter descri&ccedil;&otilde;es completas e solu&ccedil;&otilde;es sugeridas para problemas n&atilde;o resolvidos que poderiam afetar a instala&ccedil;&atilde;o.</p>
  </div>
    <p>&nbsp;</p>
    <p><b>Instalando o Mobility Pack do NetBeans para CDC 5.5.1 em plataformas n&atilde;o-Windows</b></p>

  <p>Atualmente o Mobility Pack para CDC n&atilde;o est&aacute; dispon&iacute;vel para plataformas n&atilde;o-Windows devido &agrave; inexist&ecirc;ncia de suporte de emuladores de terceiros para outras plataformas. No entanto, oferecemos um zip bin&aacute;rio n&atilde;o suportado do pacote para quem desejar instalar o pacote em outros sistemas operacionais. Observe que n&atilde;o h&aacute; documenta&ccedil;&atilde;o ou suporte para o zip bin&aacute;rio. Para obter informa&ccedil;&otilde;es sobre o download e a instala&ccedil;&atilde;o do zip bin&aacute;rio, consulte este t&oacute;pico na <a href="http://wiki.netbeans.org/wiki/view/MobilityFromZipToNB">P&aacute;gina de perguntas freq&uuml;entes</a>. A <a href="https://netbeans.org/projects/mobility/lists/users/archive">Lista de usu&aacute;rios do Mobility</a> tamb&eacute;m est&aacute; dispon&iacute;vel para a solu&ccedil;&atilde;o de outras d&uacute;vidas relacionadas a este t&oacute;pico.</p>

</blockquote>
<p align=center><a href="#top">in&iacute;cio</a></p>
<h2><a name="emulators"></a>Instalando plataformas de emulador</h2>
<p>Para desenvolver aplicativos CDC, &eacute; necess&aacute;rio ter uma plataforma CDC registrada no IDE. As instru&ccedil;&otilde;es a seguir descrevem o processo para instalar cada plataforma de emulador que atualmente tem suporte do IDE.</p>
<blockquote>
  <h3>Sun Java Toolkit para CDC<a name="cdctk"></a></h3>
  <p>O Sun Java Toolkit para CDC est&aacute; integrado ao NetBeans Mobility Pack, por isso n&atilde;o &eacute; necess&aacute;rio fazer o download deste emulador e instal&aacute;-lo. </p>
  <p>No entanto, se desejar ter uma instala&ccedil;&atilde;o separada do kit de ferramentas, siga estas instru&ccedil;&otilde;es: </p>
  <ol>
    <li>Fa&ccedil;a o download do Sun Java Toolkit para CDC<font color="#FF0000"> </font>1.0 na Sun Developer Network (<a href="http://java.sun.com/products/cdctoolkit/overview.html">download</a>).</li>
    <li>Instale o emulador de plataforma de acordo com as instru&ccedil;&otilde;es fornecidas.
    </li>
    <li>No Menu principal, escolha Ferramentas &gt; Gerenciador de plataformas Java. </li>
    <li>Clique em Adicionar plataforma. A caixa de di&aacute;logo Adicionar plataforma Java &eacute; aberta. </li>
    <li>Selecione Emulador da plataforma CDC Java Micro Edition e clique em Pr&oacute;ximo. </li>
    <li>Selecione a pasta que cont&eacute;m a plataforma SDK. O diret&oacute;rio padr&atilde;o &eacute; <code>C:\CDCTK10\.</code> Clique em Pr&oacute;ximo.<code> </code></li>
    <li>Se desejar, use a caixa de di&aacute;logo Nome da plataforma para adicionar ou remover bibliotecas de recursos adicionais. </li>
    <li>Clique em Finalizar. O IDE registra a plataforma CDC.</li>
  </ol>
  <p align=center><a href="#top">in&iacute;cio</a></p>
  <h3>Ricoh Embedded Software Architecture</h3>
  <p>O Mobility Pack para CDC oferece suporte a Ricoh Embedded Software Architecture. Para integrar suporte para esta arquitetura, siga estas instru&ccedil;&otilde;es: </p>
  <ol>
    <li>Fa&ccedil;a o download dos seguintes arquivos no site <a href="http://www.ricoh.com/esa/index.html">Ricoh Developer Program Site</a>: </li></ul>
    <ul>
      <li><a href="http://developer.sonyericsson.com/site/global/docstools/symbian/p_symbian.jsp"></a>Embedded Software Architecture Emulator (logon necess&aacute;rio para o <a href="http://www.ricoh.com/esa/index.html">download</a>)<font color="#FF0000"></font></li>
    </ul>
    <li>Descompacte o arquivo <code>Embedded_Software_Architecture_Emulator_1.14c.zip.<br></code>Os arquivos ser&atilde;o extra&iacute;dos em uma pasta<code> <em>&lt;raiz&gt;</em>\Embedded_Software_Architecture_Emulator_1.14c\.</code></li>
    <li> No Menu principal do NetBeans IDE, escolha Ferramentas &gt; Gerenciador de plataformas Java. </li>
    <li>Clique em Adicionar plataforma. A caixa de di&aacute;logo Adicionar plataforma Java &eacute; aberta. </li>
    <li>Selecione Emulador da plataforma CDC Java Micro Edition e clique em Pr&oacute;ximo. </li>
    <li>Selecione a pasta que cont&eacute;m a plataforma SDK. O diret&oacute;rio padr&atilde;o &eacute; <code>C:\Embedded_Software_Architecture_Emulator_1.14c\.</code> Clique em Pr&oacute;ximo.<code> </code></li>
    <li>Se desejar, use a caixa de di&aacute;logo Nome da plataforma para adicionar ou remover bibliotecas de recursos adicionais. </li>
    <li>Clique em Finalizar. O IDE registra a plataforma CDC.</li>
  </ol>
  <p align=center><a href="#top">in&iacute;cio</a></p>
  <h3>Sony Ericsson CDC Platform para o UIQ SDK 3</h3>
  <p>O Mobility Pack para CDC d&aacute; suporte a Sony Ericsson CDC Platform 1. Para integrar o suporte para os dispositivos das s&eacute;ries M600 e P990, siga estas instru&ccedil;&otilde;es: </p>
  <ol>
    <li>Fa&ccedil;a o download dos seguintes arquivos no site <a href="http://developer.sonyericsson.com">developer.sonyericsson.com</a>: </li>
    <ul>
      <li><a href="http://developer.sonymobile.com/downloads/sdks/"></a>UIQ 3 SDK (logon necess&aacute;rio para o <a href="http://developer.sonymobile.com/downloads/sdks/">download</a>)<font color="#FF0000"></font></li>
      <li>M600 Extension Package para o UIQ 3 SDK (<a href="http://developer.sonymobile.com/downloads/sdks/">download</a>)</li>
      <li>P990 Extension Package para o UIQ 3 SDK (<a href="http://developer.sonymobile.com/downloads/sdks/">download</a>)</li>
    </ul>
    <li>Descompacte o arquivo <code>UIQ3SDK_final.zip</code>. </li>
    <li>Navegue at&eacute; o local no sistema em que os arquivos foram extra&iacute;dos e clique duas vezes em <code>UIQS3SDK.exe</code>.<br> &Eacute; aberto o assistente para instala&ccedil;&atilde;o de UIQ 3 SDK. </li>
    <li>Siga as instru&ccedil;&otilde;es do assistente para instalar o SDK. <br> O diret&oacute;rio padr&atilde;o para a instala&ccedil;&atilde;o &eacute; <code>C:\Symbian\UIQ3SDK\</code></li>
    <li>Para instalar os pacotes de extens&atilde;o M600 e P990, navegue at&eacute; os locais de download no sistema e clique duas vezes nos &iacute;cones do instalador para iniciar os assistentes de instala&ccedil;&atilde;o. </li>
    <li>Siga as instru&ccedil;&otilde;es do assistente para instalar cada SDK. </li>
    <li>No Menu principal do NetBeans IDE, escolha Ferramentas &gt; Gerenciador de plataformas Java. </li>
    <li>Clique em Adicionar plataforma. A caixa de di&aacute;logo Adicionar plataforma Java &eacute; aberta. </li>
    <li>Selecione Emulador da plataforma CDC Java Micro Edition e clique em Pr&oacute;ximo. </li>
    <li>Selecione a pasta que cont&eacute;m a plataforma SDK. O diret&oacute;rio padr&atilde;o &eacute; <code>C:\Symbian\UIQ3SDK\.</code> Clique em Pr&oacute;ximo.</li>
    <li>Se desejar, use a caixa de di&aacute;logo Nome da plataforma para adicionar ou remover bibliotecas de recursos adicionais. <br> <br> <strong>Observa&ccedil;&atilde;o:</strong> Se vir a mensagem &quot;A platforma n&atilde;o est&aacute; configurada corretamente. Use as ferramentas de configura&ccedil;&atilde;o do SDK para instalar as ferramentas obrigat&oacute;rias&quot;, um estilo de emulador n&atilde;o foi selecionado.<br> <br> Para corrigir isso:
      <ol>
        <li>Clique na guia Configura&ccedil;&otilde;es e clique no bot&atilde;o Ferramenta de configura&ccedil;&atilde;o do SDK. </li>
        <li>Em Configura&ccedil;&atilde;o do SDK, clique na guia Estilo e escolha um estilo na lista Estilos de emulador. Escolha Aplicar estilos. </li>
        <li>Feche o Configurador do SDK. </li>
      </ol>
    </li>
    <li>Clique em Finalizar. O IDE registra as plataformas CDC.</li>
  </ol>
  <p align=center><a href="#top">in&iacute;cio</a></p>
  <h3>Nokia Series 80 Platform SDK para SO Symbian, para Java, perfil Pessoal</h3>
  <p>O Mobility Pack para CDC d&aacute; suporte a Series 80 Platform SDK para Symbian OS, para Java, perfil Pessoal. Para integrar suporte para os dispositivos Nokia Series 80, siga estas instru&ccedil;&otilde;es: </p>
  <ol>
    <li>Fa&ccedil;a o download de Nokia Series 80 Platform SDK para Symbian OS, para Java, perfil Pessoal, na Sun Developer Network (<a href="http://www.forum.nokia.com/info/sw.nokia.com/id/449a2f84-2a8a-44fa-a7f4-93b53cb9c89a/Series_80_Platform_SDK_s_for_Symbian_OS_for_Java.html">download</a>) O nome do arquivo &eacute; <code>S80_DP_2_0_PP_SDK.zip.</code></li>
    <li>Descompacte o arquivo. </li>
    <li>Navegue at&eacute; o local no sistema em que o arquivo foi descompactado. Clique duas vezes no &iacute;cone do arquivo <code>setup.exe</code>. <br> O assistente do instalador de Nokia &eacute; aberto. </li>
    <li>Siga as instru&ccedil;&otilde;es do assistente para instalar o SDK. <br> O assistente ir&aacute; solicitar a voc&ecirc; que escolha o dispositivo que ser&aacute; o dispositivo padr&atilde;o. Escolha o <code>Series80_DP2_0_PP_SDK</code>.</li>
    <li>No Menu principal do NetBeans IDE, escolha Ferramentas &gt; Gerenciador de plataformas Java. </li>
    <li>Clique em Adicionar plataforma. A caixa de di&aacute;logo Adicionar plataforma Java &eacute; aberta. </li>
    <li>Selecione Emulador da plataforma CDC Java Micro Edition e clique em Pr&oacute;ximo. </li>
    <li>Selecione a pasta que cont&eacute;m a plataforma SDK. O diret&oacute;rio padr&atilde;o &eacute; <code>C:\Symbian\S80_DP2_0_PP_SDK.</code> Clique em Pr&oacute;ximo.<code> </code></li>
    <li>Se desejar, use a caixa de di&aacute;logo Nome da plataforma para adicionar ou remover bibliotecas de recursos adicionais. </li>
    <li>Clique em Finalizar. O IDE registra a plataforma CDC.</li>
  </ol>
</blockquote>
  <p align=center><a href="#top">in&iacute;cio</a></p>

<blockquote>
  <h3>CrEme VM para Windows CE<a name="creme"></a></h3>
  <p>O Mobility Pack para CDC oferece suporte ao NSIcom CrEme VM para Windows CE. Para integrar suporte para dispositivos do Windows CE, siga estas instru&ccedil;&otilde;es:</p>

<ol>
    <li>Fa&ccedil;a o download da plataforma CrEme 4.10 em NSIcom (<a href="http://nsicom.com/shared/CrEmeDevSup410.exe">download</a>)
    </li>
  <li>Navegue at&eacute; o local no sistema em que voc&ecirc; fez o download do arquivo <code>CrEmeDevSup410.exe</code>. Clique duas vezes no arquivo. </li>
  <li>Siga as instru&ccedil;&otilde;es do assistente NSI.com InstallShield para instalar o Developer Kit. </li>
  <li>No Menu principal do NetBeans IDE, escolha Ferramentas &gt; Gerenciador de plataformas Java. </li>
  <li>Clique em Adicionar plataforma. A caixa de di&aacute;logo Adicionar plataforma Java &eacute; aberta. </li>
  <li>Selecione Emulador da plataforma CDC Java Micro Edition e clique em Pr&oacute;ximo. </li>
  <li>Selecione a pasta que cont&eacute;m a plataforma SDK. O diret&oacute;rio padr&atilde;o &eacute; <code>C:\Arquivos de programas\NSIcom\CrE-ME V4.10.</code> Clique em Pr&oacute;ximo.</li>
  <li>Se desejar, use a caixa de di&aacute;logo Nome da plataforma para adicionar ou remover bibliotecas de recursos adicionais. </li>
  <li>Clique em Finalizar. O IDE registra a plataforma CDC.</li>
</ol>
</blockquote>
  <p align=center><a href="#top">in&iacute;cio</a></p>

<blockquote>
  <h3>Microsoft Device Emulator 1.0</h3>
  <p>O Mobility Pack para CDC oferece suporte ao Microsoft Device Emulator 1.0 juntamente com o NSIcom CrEme VM para Windows CE. Para integrar o Microsoft Device Emulator 1.0, siga estas instru&ccedil;&otilde;es:</p>
  <ol>
    <li>Fa&ccedil;a o download do arquivo <code>V1Emulator.zip</code> para o emulador (<a href="http://www.microsoft.com/en-us/download/details.aspx?id=20259">download</a>).
    </li>
    <li>Descompacte o arquivo e clique duas vezes em <code>standalone_emulator_V1.exe</code>. O assistente de instala&ccedil;&atilde;o do Emulador de dispositivo ir&aacute; orientar voc&ecirc; no processo de instala&ccedil;&atilde;o. </li>
    <li>Fa&ccedil;a o download de <code>efp.msi (</code><a href="http://www.microsoft.com/en-us/download/details.aspx?id=20259">download</a><code>)</code>.<code></code>O assistente de instala&ccedil;&atilde;o do Emulador de dispositivo ir&aacute; orientar voc&ecirc; no processo de instala&ccedil;&atilde;o. </li>
    <li>Talvez tamb&eacute;m seja necess&aacute;rio instalar o Virtual Machine Network Driver para Microsoft Device Emulator (<a href="http://www.microsoft.com/en-us/download/details.aspx?id=2863">download</a>) Fa&ccedil;a o download do arquivo e clique duas vezes no arquivo <code>netsvwrap.msi</code>. O assistente de instala&ccedil;&atilde;o ir&aacute; orientar voc&ecirc; no processo de instala&ccedil;&atilde;o. </li>
  </ol>
  <p align=center><a href="#top">in&iacute;cio</a></p>
  <h3>ActiveSync</h3>
  <p>O ActiveSync VM d&aacute; suporte ao NSIcom CrEme VM para executar Java em dispositivos do Windows CE. </p>
  <ol>
    <li>Fa&ccedil;a o download de <code>setup.msi</code> para o ActiveSync VM (<a href="http://www.microsoft.com/downloads/details.aspx?FamilyID=9e641c34-6f7f-404d-a04b-dc09f8141141&DisplayLang=en">download</a>)</li>
    <li>Clique duas vezes no arquivo para instal&aacute;-lo. </li>
  </ol>
  <p align=center><a href="#top">in&iacute;cio</a></p>
  <h3>Plataforma SavaJe Mobile</h3>
  <p>O Mobility Pack para CDC d&aacute; suporte &agrave; cria&ccedil;&atilde;o de Xlets usando o sistema operacional SavaJe. O suporte para o SavaJe est&aacute; incorporado ao Sun Java Wireless Toolkit para CDC. Uma vez que o Jasper S20 est&aacute; dispon&iacute;vel atualmente apenas como uma edi&ccedil;&atilde;o de visualiza&ccedil;&atilde;o, n&atilde;o h&aacute; uma cobertura de emulador dispon&iacute;vel para o Jasper S20. Em vez disso, voc&ecirc; pode usar o dispositivo <code>DefaultColorPhone</code> para simular o comportamento do Jasper S20.</p>
  <div class="indent">
    <p>Se n&atilde;o tiver um Jasper S20, estas instru&ccedil;&otilde;es mostram como implantar o aplicativo para o dispositivo. Eis o que &eacute; necess&aacute;rio: </p>
    <ul>
      <li> O telefone de Jasper S20. </li>
      <li> O sistema operacional SavaJe (OS) (n&atilde;o mais dispon&iacute;vel) </li>
      <li> O software GSPDA Mobile Device (drivers USB MCCI). </li>
    </ul>
    <h4></a>Configurando o fone</h4>
    <p>As etapas a seguir descrevem o processo de instala&ccedil;&atilde;o do software necess&aacute;rio para o tutorial sobre o telefone do Jasper S20. </p>
    <h4 class="tutorial">Instalando o sistema operacional SavaJE</h4>
    <p><strong>OBSERVA&Ccedil;&Atilde;O:</strong> Lamentavelmente, o SavaJe OS n&atilde;o est&aacute; mais dispon&iacute;vel para download. Estas instru&ccedil;&otilde;es est&atilde;o dispon&iacute;veis para quem tem acesso ao software SavaJe Mobile Platform atrav&eacute;s de CD ou outras fontes. Este procedimento foi escrito para o fone Jasper S20 que teve uma vers&atilde;o anterior do SavaJe OS instalada e permite que voc&ecirc; retenha prefer&ecirc;ncias existentes e configura&ccedil;&otilde;es de f&aacute;brica.</p>
    <p>Tr&ecirc;s compila&ccedil;&otilde;es do SavaJe OS foram produzidas:</p>
    <ul>
      <li> <code>JasperS20.zip</code><br> A compila&ccedil;&atilde;o comercial entregue no telefone. </li>
      <li> <code>JasperS20_EA_Developer.zip</code><br> Compila&ccedil;&atilde;o do desenvolvedor JavaOne Early Access sem ativa&ccedil;&atilde;o do Java Debug Wire Protocol (JDWP). </li>
      <li> <code>JasperS20_EA_Developer_debug.zip</code><br> Compila&ccedil;&atilde;o do desenvolvedor de acesso JavaOne com ativa&ccedil;&atilde;o do JDWP. Para executar um pacote com a depura&ccedil;&atilde;o do JDWP, &eacute; necess&aacute;rio carregar esta compila&ccedil;&atilde;o. </li>
    </ul>
    <p>&nbsp;</p>
    <p>Siga estas etapas para instalar uma compila&ccedil;&atilde;o atualizada do SavaJe OS no telefone. </p>
    <ol>
      <li> Extraia (descompacte) o arquivo zip que cont&eacute;m a compila&ccedil;&atilde;o desejada na raiz da placa mini-SD. </li>
      <li>Conecte um cabo de for&ccedil;a/USB ao fone.</li>
      <li>Ligue o fone enquanto pressiona a tecla C&acirc;mera.</li>
      <li>Na tela de menu do atualizador, selecione &quot;Factory Reset&quot; [restaurar configura&ccedil;&otilde;es de f&aacute;brica] movendo o joystick para baixo at&eacute; &quot;Factory Reset&quot; ser real&ccedil;ado. Incie a reconfigura&ccedil;&atilde;o de f&aacute;brica movendo o joystick para a direita. Use o joystick para navegar at&eacute; &quot;Yes&quot; e, em seguida, selecione &quot;Yes&quot; movendo o joystick para a direita. <br> O fone deve come&ccedil;ar a carregar a nova compila&ccedil;&atilde;o. Ap&oacute;s a conclus&atilde;o do carregamento, voc&ecirc; poder&aacute; ser solicitado a pressionar qualquer tecla para reiniciar o telefone. </li>
      <li>O fone &eacute; reiniciado e exibe a tela Xplore. Se a tela de carregamento da bateria for exibida durante a reinicializa&ccedil;&atilde;o, pressione o bot&atilde;o de energia para continuar a reinicializar o telefone. </li>
    </ol>
    <p>A primeira vez que o fone for reiniciado ap&oacute;s a reconfigura&ccedil;&atilde;o de f&aacute;brica, ser&aacute; exibido um menu de sele&ccedil;&atilde;o de Idioma/Localiza&ccedil;&atilde;o. Fa&ccedil;a as sele&ccedil;&otilde;es navegando com o joystick e pressionando o bot&atilde;o do joystick. Voc&ecirc; tamb&eacute;m ser&aacute; solicitado a definir a hora.
    </p>
    <h4 class="tutorial">Registrando a plataforma CDC</h4>
    <p>Siga as instru&ccedil;&otilde;es fornecidas para o<a href="#cdctk"> Sun Java Wireless Toolkit para CDC 1.0</a>. <br>
    </p>
  </div>
</blockquote>
<p align=center><a href="#top">in&iacute;cio</a></p>
<h2><a name=uninstallation>Desinstalando o software</a></h2>
<p>Esta se&ccedil;&atilde;o cont&eacute;m informa&ccedil;&otilde;es para a desinstala&ccedil;&atilde;o do NetBeans Mobility Pack para CDC 5.5.1 do sistema.
<blockquote>
  <ol>
    <li> Feche o IDE. </li>
    <li> No Painel de controle, inicie Adicionar ou remover programas, selecione NetBeans Mobility Pack para CDC 5.5.1 e clique em Alterar/Remover. </li>
    <li> Siga as instru&ccedil;&otilde;es do desinstalador. </li>
  </ol>
</blockquote>
  <p><strong>Observa&ccedil;&atilde;o:</strong> Voc&ecirc; tamb&eacute;m pode desinstalar quaisquer plataformas do Emulador atrav&eacute;s do Painel de controle do Windows. </p>
<p align=center><a href="#top">in&iacute;cio</a></p>
<h2><a name=troubleshoot>Solu&ccedil;&atilde;o de problemas</a></h2>
<p>Se tiver problemas ao instalar ou executar o software, consulte a lista de problemas abaixo para ver as solu&ccedil;&otilde;es. Para obter uma lista completa dos problemas conhecidos, dos requisitos do sistema e de informa&ccedil;&otilde;es de configura&ccedil;&atilde;o, consulte as <a href="relnotes-mobilitycdc_pt_BR.html">Notas da vers&atilde;o</a>. </p>
<p> Se encontrar um problema que n&atilde;o esteja listado nas notas da vers&atilde;o ou quiser solicitar uma melhoria, registre o problema no sistema de controle de erros do NetBeans, IssueZilla, em <a href="https://netbeans.org/community/issues.html">https://netbeans.org/community/issues.html</a>. Para problemas do NetBeans Mobility Pack, selecione o componente &quot;mobility&quot;, selecione a vers&atilde;o &quot;5.5.1&quot; e, em seguida, selecione o subcomponente &quot;cdc pack&quot;. Se n&atilde;o tiver certeza do nome correto do subcomponente, escolha &quot;other&quot;.</p>
<p>Se j&aacute; estiver conectado a netbeans.org, v&aacute; diretamente para a tela de entrada de problemas do Mobility Pack: <a href="https://netbeans.org/bugzilla/enter_bug.cgi?component=mobility&version=5.5.1">https://netbeans.org/bugzilla/enter_bug.cgi?component=mobility&amp;version=5.5.1</a>.</p>
<ul>
<p align=center><a href="#top">in&iacute;cio</a></p>
</ul>
</body>
</html>

