Android: “Hello World”

maio 1, 2009

AndroidA plataforma Android desenvolvida pela google, é uma das grandes novidades hoje no mercado. É considerada a primeira plataforma para dispositivos móvel aberta, com uma grande variedade de recursos. Mantida pelo Open Handset Aliance, que contém um grupo de 30 empresas: Entre fabricantes, empresas de tecnologia e etc.

Android foi desenvolvido e baseado no Kernel 2.6 Linux, responsável por gerenciar a memória, threads os processos, segurança, redes e drivers. Com esse gerenciamento é permitido executar varias aplicações ao mesmo tempo, tanto aplicativos em segundo plano onde o usuário não visualiza (Services) e aplicativos acessados pelo usuário.

Para o desenvolvimento de aplicações, é utilizada a linguagem Java, permitindo usufruir de todos os recursos.

Para desenvolvimento a google disponibiliza: Emulador, Ferramenta de analise e performance, Plugin(ADT) para a IDE Eclipse. Atualmente o android esta na versão 1.5 esta versão veio com várias novidades.

A estrutura para desenvolvimento é muito organizada: Diretórios, criação de layout, arquivos de internacionalização, imagens e etc. Além de permitir que suas aplicações possam integrar-se com aplicações nativas ou criar. Novidades também são as “widgets” que estão fortes nessa nova versão. Resumindo Android é Robusto e Completo, disponibilizando de inúmeras variedades de inovações.

Para informações acesse: http://developer.android.com

A seguir vou mostrar uma pequena aplicação “Hello World” dando uma idéia inicial da plataforma.

Ambiente para desenvolvimento:

  • SDK:  Neste artigo utilizei a SDK 1.5, onde pode ser baixada em: http://developer.android.com/sdk/1.5_r1/index.html .
    • Ao baixar a SDK, descompacte e coloque no diretório “C:\” por padrão, pois esta pasta pode esta localizada em qualquer parte do sistema operacional.
    • Com a SDK decompactada e supondo que esteja em “C:\android-sdk-windows-1.5_r1” adicione no seu PATH (Variavel de Ambiente do Windows) “C:\android-sdk-windows-1.5_r1\tools”. Nessa primeira release da versão 1.5, esta com erro na execução do emulador, a seguir vou explicarei como corrigir o erro.
    • Acesse o diretório pelo prompt do DOS “C:\android-sdk-windows-1.5_r1\tools”.
    • Execute os seguintes comandos somente para a versão 1.5, isso fará com que funcione corretamente, assim como para a versão 1.1 embutida nesta nova versão:
      • android create avd –target 1 –name NormalVM01
      • android create avd –target 2 –name CupcakeVM01
    • Com a SDK configurada você agora pode executar o emulador localizado na pasta “C:\android-sdk-windows-1.5_r1\tools”.
  • Plugin para o eclipse ADT (Android Development Tools). Para instalação do ADT foi utilizado a versão 3.4 do eclipse:
    • Com o eclipse aberto acesse o menu Help / Software Updates.
    • Na janela software updates, acesse a aba Available Software e clique no botão Add Site, insira a URL
    • Com a URL adicionada selecione a mesma e clique no botão install. Quando finalizar a instalação será pedido para reiniciar o eclipse.
    • Após instalado e reiniciado, acesso o menu Window / Preferences e seleciona a opção Android. No campo SDK Location informe o diretório que esta localizada a SDK.

Criando a primeira aplicação Android:

  • Para criar um novo projeto android no eclipse acesse o menu File / New / Project, acesse o diretório Android e seleciona Android Project, clique em Next.
  • Configuração do projeto:
  • Build Target: Seleciona a versão 1.5.
    • Project Name: Neste campo é informado o nome do projeto criado no eclipse. Daremos o nome de ProjectHelloWorld.
    • Application Name: Este campo representa o titulo da nossa apresentação que será exibida para o usuário. Daremos o nome de HelloWorld.
    • Package Name: É informado o nome do pacote onde estará a Activity principal. Daremos o nome de br.com.helloworld.
    • Create Activity: Nome da Activity principal do projeto. Activity representa uma tela, e esta vai ser a Activity pricipal do projeto.  Daremos o nome de ActHelloWorld.
    • Com o projeto criado é possível visualizar a sua estrutura:

      Estrutura

      • src: Pasta que contém pacotes de classes Java. Nesta pasta esta contido a classe ActHelloWorld definida na criação do projeto.
      • gen: Como o nome já diz , contém arquivos Javas gerados automaticamente, são arquivos padrão. A classe R é a classe padrão de android e não deve ser modificada.
      • assets: Pode ser incluídos arquivos opcionais para o projeto.
      • res: Esta pasta contém as pastas de recursos da nossa aplicação:
        • drawable: Pasta padrão para imagens da aplicação.
        • layout: Contém arquivos XML de layout, responsáveis por construir as telas da aplicação.
        • values: Contém arquivos de internacionalização XML para a aplicação e outras configurações.

      Para cada arquivo localizado na pasta res, contém uma referencia na classe R. A cada alteração ,remoção ou inclusão no diretório res, a classe R é atualizada automaticamente.

      Abaixo temos o código fonte da classe ActHelloWorl:

      package br.com.helloworld;

      import android.app.Activity;

      import android.os.Bundle;

      public class ActHelloWorld extends Activity {

      /** Called when the activity is first created. */

      @Override

      public void onCreate(Bundle savedInstanceState) {

      super.onCreate(savedInstanceState);

      setContentView(R.layout.main);

      }

      }

      Observe que a classe R é invocada no método setContentView, passando no parâmetro a referencia do arquivo de layout main. Já da pra ter uma idéia da importância dessa classe, com essa estrutura você pode montar seus layouts em arquivos XML e chamados nos eu código Java, sem precisar misturar designer e lógica.

      Para executar seu projeto, basta clicar com o botão direito no projeto e selecionar a opção Run / Android Application.

      Este foi o primeiro exemplo da configuração e construção de uma aplicação Android. Nas cenas do próximo capitulo estarei mostrando mais exemplo e detalhando mais. Espero que todos os leitores tenham gostado, qualquer duvida postem!!!.

      J2ME: RMS – Básico

      abril 8, 2009

      Galera, vou postar aqui um exemplo básico de manipulação de dados em J2ME (RMS), utilizando seu repositório de dados o RecordStore. Para aqueles que não conhecem o RecordSotore, ele é muito mas ao mesmo tempo complexo em relação a manipulação de dados, muita coisa tem que ser feita na mão e bem configurada. Neste exemplo terá métodos de criação de um RecordSotore, métodos para inserir e consultar dados. Coisa muito simples, somente para dar uma idéia de como funciona este recurso.  No futuro vou inserir um novo post já com uma visão mais avançada. A Midlet tem dois formulários um Main e outro de Cadastro, o FormMain exibirá os dados cadastrados, e o FormCadastro fará a inclusão de uma string. Uma Midlet realmente muito simples somente para mostrar o básico. Espero que ajude e qualquer duvida é só postar!!!

      package com.RMS;

      import java.util.Vector;

      import javax.microedition.lcdui.Command;
      import javax.microedition.lcdui.CommandListener;
      import javax.microedition.lcdui.Display;
      import javax.microedition.lcdui.Displayable;
      import javax.microedition.lcdui.Form;
      import javax.microedition.lcdui.TextField;
      import javax.microedition.midlet.MIDlet;
      import javax.microedition.midlet.MIDletStateChangeException;
      import javax.microedition.rms.RecordStore;
      /***
      *
      * @author Marcelo Alves
      * MIdlet Básica para Criar um RecordStore, Deletar, Salvar dados e Ler dados.
      */
      public class RMSBasic extends MIDlet implements CommandListener {

      private RecordStore rs = null;
      private final String REC_STORE = “db_1”;
      private Form frmMain = null;
      private Form frmCadastro = null;
      private TextField txtNome = null;
      private Command cmdSair = null;
      private Command cmdNovo = null;
      private Command cmdGravar = null;

      public RMSBasic() {

      txtNome = new TextField(“Nome: “,””,20,TextField.ANY);
      cmdGravar = new Command(“Salvar”,Command.OK,0);
      cmdSair = new Command(“Sair”,Command.EXIT,1);
      cmdNovo = new Command(“Novo Registro”, Command.SCREEN,1);

      frmCadastro = new Form(“Cadastro”);
      frmCadastro.append(txtNome);
      frmCadastro.addCommand(cmdGravar);
      frmCadastro.addCommand(cmdSair);
      frmCadastro.setCommandListener(this);

      frmMain = new Form(“Principal”);
      frmMain.addCommand(cmdSair);
      frmMain.addCommand(cmdNovo);
      frmMain.setCommandListener(this);

      //Inicio com RS zerado
      this.deleteRecodStore();
      this.openRecordStore();
      }

      protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
      notifyDestroyed();
      }

      protected void pauseApp() {}

      protected void startApp() throws MIDletStateChangeException {
      Display.getDisplay(this).setCurrent(frmMain);
      }
      //Método responsável por abrir um Record Store desejado
      public void openRecordStore(){
      try {
      /**
      * O Segundo parâmetro indica que o registro
      * deve ser criado, se ele não existir
      */
      rs = RecordStore.openRecordStore(REC_STORE, true);
      } catch (Exception e) {
      e.printStackTrace();
      }

      }

      /**
      * @param cmd – Captura o comando do Display
      * @param dsp – Captura o display corrent
      */
      public void commandAction(Command command, Displayable display) {
      //Caso o display corrente seja frmMain verifica qual comando esta sendo solicitado
      if(display == frmMain){
      if(command == cmdNovo){
      txtNome.setString(“”);
      Display.getDisplay(this).setCurrent(frmCadastro);
      }else if(command == cmdSair){
      try {
      destroyApp(true);
      } catch (Exception e) {
      e.printStackTrace();
      }

      }

      }else if(display == frmCadastro){
      if(command == cmdGravar){
      //Recupera o texto digitado e envia para o método que grava no repositório
      this.writeRecord(txtNome.getString());
      this.popularFormMain(readRecords());
      Display.getDisplay(this).setCurrent(frmMain);

      }else if(command == cmdSair){
      Display.getDisplay(this).setCurrent(frmMain);
      }
      }

      }
      //Exibe dados contidos no repositório
      public void popularFormMain(Vector dados){
      frmMain.deleteAll();
      for (int i = 0; i < dados.size(); i++) {
      frmMain.append(dados.elementAt(i).toString());
      }
      }

      //Fecha a “conexão” com o RecordStore
      public void closeRecordStore(){
      try {
      rs.closeRecordStore();
      } catch (Exception e) {
      e.printStackTrace();
      }
      }
      //Delete um RecordStore criado.
      public void deleteRecodStore(){
      // Verifica se o exite algum RecordSotore criado
      if(RecordStore.listRecordStores() != null){
      try {
      RecordStore.deleteRecordStore(REC_STORE);
      } catch (Exception e) {
      e.printStackTrace();
      }
      }
      }
      //Salva uma String no RecordStore que foi aberto
      public void writeRecord(String str) {
      byte[] rec = str.getBytes();

      try {
      rs.addRecord(rec, 0, rec.length);
      } catch (Exception e) {
      e.printStackTrace();
      }
      }

      //Faz uma leitura dos dados contidos no RecordStore que foi aberto
      public Vector readRecords(){
      Vector dados = new Vector();

      try {
      byte[] recData = new byte[5];
      int len;

      for (int i = 1; i <= rs.getNumRecords(); i++) {
      if(rs.getRecordSize(i) > recData.length){
      recData = new byte[rs.getRecordSize(i)];
      }
      len = rs.getRecord(i, recData, 0);
      dados.addElement(new String(recData, 0, len));
      }

      } catch (Exception e) {
      e.printStackTrace();
      }

      return dados;
      }
      }

      []’s

      Marcelo Alves!

      Criando Games J2ME no NetBeans

      abril 1, 2009

      Boa Noite

      Vi este video onde é mostrado a criação da parte de Designer de um game no netbeans, desde a criação da animação do personagem até o mapa do game.

      Creating Mobile Games in NetBeans

      []’s

      Att,

      Marcelo Alves

      Android

      março 27, 2009
      Android

      Android

      Foi lançando um livro sobre Google Android em Português, aqueles que estiverem interessados acessem este link da notícia:

      Portal Android.

      Abraços!

      Marcelo Alves

      Google lança seu novo navegador: Chrome

      setembro 2, 2008

      Aqueles que conhecem a Google como a grande inovadora de ferramentas para web 2.0, agora pode contar com o seu novo navegador Chrome, lançado nesta tarde. Particularmente achei do C@#$%. Abre as paginas mais rápido e fácil. É claro que precisa de melhorias como toda ferramenta recém lançada. Obs.: Estou utilizando ele para postar esta notícia🙂 .

      Pra quem quiser fazer um Teste-Drive, faça o download no endereço: http://tools.google.com/chrome/

       By Marcelo Alves

      GINGA – Middleware para TV Digital

      agosto 15, 2008

      Para aqueles que se interessam em desenvolver aplicativos para TV Digital, ta ai um middleware muito interessante de se estudar e envolver com o projeto. Hoje um tópico muito discutido entre empresas e desenvolvedores para inovações em TV Digital, vale a pena para aqueles que buscam cada dia novos rumos ou MultiThread (rsrs), é interessante participar desta comunidade que esta crescendo. Acessem: www.ginga.org.br

      Até a proxima!

      JavaMe: Gauge Não Interativo

      março 25, 2008

      package j2me.marcelo.interfaceAN.gauge;

      import java.util.Timer;
      import java.util.TimerTask;

      import javax.microedition.lcdui.Command;
      import javax.microedition.lcdui.CommandListener;
      import javax.microedition.lcdui.Display;
      import javax.microedition.lcdui.Displayable;
      import javax.microedition.lcdui.Form;
      import javax.microedition.lcdui.Gauge;
      import javax.microedition.midlet.MIDlet;
      import javax.microedition.midlet.MIDletStateChangeException;

      public class GaugeNInterativo extends MIDlet implements CommandListener
      {
      private Display display;
      private Form frmMain;
      private Command cmdExit;
      private Command cmdStop;
      public Gauge gaProgress;
      private Timer tm;
      private DownloadTimer tt;

      public GaugeNInterativo() {
      display = Display.getDisplay(this);
      cmdExit = new Command(“Sair”,Command.EXIT,1);
      cmdStop = new Command(“Stop”,Command.STOP,1);
      gaProgress = new Gauge(“Progresso do Download”,false,20,1);

      frmMain = new Form(“Form Gauge Interativo”);
      frmMain.addCommand(cmdStop);
      frmMain.append(gaProgress);
      frmMain.setCommandListener(this);

      }

      protected void startApp() throws MIDletStateChangeException {
      //Cria o cronômetro que é acionado a cada 1000 milissegundos
      tm = new Timer();
      tt = new DownloadTimer();
      tm.scheduleAtFixedRate(tt,0, 1000);
      display.setCurrent(frmMain);

      }

      protected void pauseApp() {

      }

      protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
      notifyDestroyed();

      }

      public void commandAction(Command c, Displayable d){
      if(c == cmdExit){
      try {
      destroyApp(true);
      } catch (MIDletStateChangeException e) {

      e.printStackTrace();
      }
      }
      //Ao Cancelar o download cancela o timer e remove cmdStop e adiciona cmdExit
      if(c == cmdStop){
      tm.cancel();
      frmMain.removeCommand(cmdStop);
      frmMain.addCommand(cmdExit);
      gaProgress.setLabel(“Download Cancelado!!”);

      }
      }

      /**
      * Processa a Task cronômetro
      */

      private class DownloadTimer extends TimerTask
      {

      public final void run()
      {
      //Verifica se o valor atual do gauge é menor que seu valor máximo
      if(gaProgress.getValue() < gaProgress.getMaxValue())
      {
      //Incrementa + 1
      gaProgress.setValue(gaProgress.getValue() + 1);
      }else
      {
      frmMain.removeCommand(cmdStop);
      frmMain.addCommand(cmdExit);

      gaProgress.setLabel(“Download Concluido”);

      cancel();
      }
      }
      }
      }

      JAVA: HelloWord J2ME CLDC e MIDP

      janeiro 21, 2008

      import javax.microedition.lcdui.Command;
      import javax.microedition.lcdui.CommandListener;
      import javax.microedition.lcdui.Display;
      import javax.microedition.lcdui.Displayable;
      import javax.microedition.lcdui.TextBox;
      import javax.microedition.midlet.MIDlet;
      import javax.microedition.midlet.MIDletStateChangeException;

      public class HelloWord extends MIDlet implements CommandListener{
      private Display display; //Referencia para o objeto privado Display
      private TextBox tbMain; // Caixa de texto para exibir uma mensagem
      private Command cmExit; // Comando para sair da MIDlet

      public HelloWord() {
      //Retorna display e passa por parametro MIDlet
      display = Display.getDisplay(this);
      cmExit = new Command(“Sair”,Command.EXIT,1);
      tbMain = new TextBox(“Bem-Vindo”,“HelloWorld”,50,0);
      tbMain.addCommand(cmExit);
      tbMain.setCommandListener(this);
      }

      protected void destroyApp(boolean arg0) throws MIDletStateChangeException {}

      protected void pauseApp() {}

      //Chamado pelo gerenciador de aplicações para iniciar o MIDlet
      protected void startApp() throws MIDletStateChangeException {
      display.setCurrent(tbMain);

      }
      public void commandAction(Command c,Displayable s){
      if(c == cmExit){
      try {
      //Destroi a aplicação
      destroyApp(false);
      //Notifica a App. Manager para finalizar o sistema
      notifyDestroyed();
      } catch (MIDletStateChangeException e) {

      e.printStackTrace();
      }
      }
      }

      }

      JAVA: Exceptions, mostrando descrição da exceção

      janeiro 18, 2008

      package pckException;

      public class TesteException {

      public void exec1(){
      try {
      exec2();
      } catch (Exception e) {
      System.out.printf(“%s\n\n”,e.getMessage());

      //Imprime o rastreamento de pilha
      e.printStackTrace();

       //Recebe as informações do rastreamento de pilha
      StackTraceElement[]  stkTraceElements = e.getStackTrace();

      System.out.println(“\nMostra a descrição da exceção”);
      System.out.println(“Classe\t\t\t\tArquivo\t\t\tLinha\tMetodo”);

      //Loop em stkTraceElements para mostrar toda a descrição da exceção
      for(StackTraceElement element : stkTraceElements){

      System.out.printf(“%s\t”,element.getClassName());
      System.out.printf(“%s\t”,element.getFileName());
      System.out.printf(“%s\t”,element.getLineNumber());
      System.out.printf(“%s\n”,element.getMethodName());

      }
      }
      }
      public void exec2() throws Exception{
      exec3();
      }
      public void exec3() throws Exception{
      throw new Exception(“Exception lançada em exec3”);
      }

      public static void main(String[] args) {

      TesteException te = new TesteException();
      te.exec1();

      }

      }

      JAVA : JTable Implementada

      dezembro 6, 2007

      Neste Exemplo teremos duas Classes, uma que implementa o modelo da JTable estudada no tutorial: http://www.guj.com.br/java.tutorial.artigo.147.1.guj , e a outra que é responsavel por criar e preencher os dados buscados via banco de dados. Estou colocando mais um post aqui sobre JTable pois existe muitos que tem duvida de como trabalhar com esta swing.

      1 – Classe JTableModel:

      package myPck;

      import java.util.ArrayList;

      import java.util.Iterator;

      import javax.swing.table.AbstractTableModel;

      /**

      * Classe Responsável por definir o modelo da JTable

      * Foi utilizado o tipo ArrayList para o atributo linhas

      * pois não é definido qual tamanho total de linhas podendo

      * ser alterada em tempo de execução(remover ou incluir).

      * Obs.: Este código foi implementado juntamente com os comentários

      * do site http://www.guj.com.br pelo autor Bruno Rios Lima

      * @author Marcelo Alves

      */

      public class JTableModel extends AbstractTableModel {

      private ArrayList linhas;

      private String[] colunas;

      public JTableModel(ArrayList dados,String[] colunas){

      setLinhas(dados);

      setColunas(colunas);

      }

      //Retorna o numero de colunas

      public int getColumnCount(){

      return getColunas().length;

      }

      //Retorna o numero de linhas

      public int getRowCount(){

      return getLinhas().size();

      }

      //Obtem o valor da linhas e coluna

      public Object getValueAt(int rowIndex, int columnIndex){

      //Recebe a linha, passando por cast para String[]

      String[] linha = (String[])getLinhas().get(rowIndex);

      //Retorna o objeto na posição de columnIndex

      return linha[columnIndex];

      }

      //Seta valor da linha e coluna

      public void setValueAt(Object value,int rowIndex, int columnIndex){

      String[] linha = (String[])getLinhas().get(rowIndex);

      //Altera o conteúdo da linha na posição do indice columnIndex

      linha[columnIndex] = (String)value;

      //Dispara o evento da celula alterada

      fireTableCellUpdated(rowIndex, columnIndex);

      }

      //Adiciona nova linha

      public void addRow(String[] dadosLinha){

      getLinhas().add(dadosLinha);

      //Informa ao JTable que ouve linhas incluidas no modelo

      //Como os dados são adicionados no final pega o tamanho total das linhas

      //menos 1 para obter a linha incluida.

      int linha = getLinhas().size() -1;

      fireTableRowsInserted(linha,linha);

      }

      //Remove linha

      public boolean removeRow(String val, int col){

      //obtem o iterator

      Iterator i = getLinhas().iterator();

      //Guarda as linhas percorridas

      int linha = 0;

      //Faz um loop enquando obtiver dados

      while(i.hasNext()){

      //Obtem as colunas da linha atual

      String[] linhaCorrente = (String[])i.next();

      linha++;

      //Compara o valor da linha atual na coluna e valor

      //informado por parametro

      if(linhaCorrente[col].equals(val)){

      getLinhas().remove(linha);

      //informa a JTable que houve dados deletados

      //passando a linha removida

      fireTableRowsDeleted(linha,linha);

      return true;

      }

      }

      //Caso não encontre o valor

      return false;

      }

      //Retorna o nome da coluna

      //getColumnName[col] retorna na posição do indice!

      public String getColumnName(int col){

      return getColunas()[col];

      }

      public ArrayList getLinhas(){

      return linhas;

      }

      public String[] getColunas(){

      return colunas;

      }

      public void setLinhas(ArrayList dados){

      linhas = dados;

      }

      public void setColunas(String[] dados){

      colunas = dados;

      }

      }

      2 – Classe JTableCreate:

      package myPck;

      import java.sql.ResultSet;

      import java.sql.ResultSetMetaData;

      import java.sql.SQLException;

      import java.sql.Types;

      import java.util.ArrayList; import javax.swing.JTable;

      /**

      * Classe responsável por criar e definir o modelo

      * de JTable

      * Além das funções de preenchimento dos dados na tabela

      * buscandos via banco

      * @author Marcelo Alves

      */

      public class JTableCreate {

      private JTable jTable;

      private JTableModel modelo;

      /**

      * Construtor recebe os parametros das linhas e colunas

      * e execulta o metodo createJTable

      * @param linhas

      * @param colunas

      */

      public JTableCreate(ArrayList linhas, String[] colunas){

      createJTable(linhas,colunas);

      }

      /**

      * Define o modelo e cria jTable indicando o modelo criado

      * @param linhas

      * @param colunas

      */

      public void createJTable(ArrayList linhas, String[] colunas){

      modelo = new JTableModel(linhas,colunas);

      jTable = new JTable(modelo);

      }

      /**

      * Responsável por preencher a jTable com dados buscados via

      * Banco. Dentro do laço for utilizase um switch para verificar

      * os dados de dados buscado no banco.

      * @param rs

      * @throws SQLException

      */

      public void popularJTable(ResultSet rs)throws SQLException{

      //Obtem os Meta dados do resultset

      ResultSetMetaData rsmd = rs.getMetaData();

      /**

      * Cria a Array de Strings definindo o tamanho com o total de linhas retornada pela consulta

      */

      String[] linhaNova = new String[rsmd.getColumnCount()];

      //Enquanto existir dados

      while(rs.next()){

      for(int i=0; i < modelo.getColumnCount(); i++){

      switch (rsmd.getColumnType(i + 1)) {

      case Types.INTEGER:

      linhaNova[i] = “”+rs.getInt(i + 1);

      break;

      case Types.VARCHAR:

      linhaNova[i] = rs.getString(i + 1);

      break;

      }

      }

      modelo.addRow(linhaNova);

      }

      }

      /**

      * Retorna {@link JTable}

      * @return jTable

      */

      public JTable getJTable(){

      return jTable;

      }

      /**

      * Altera jTable

      * @param jTable

      */

      public void setJTable(JTable jTable){

      this.jTable = jTable;

      }

      }

      Você pode utilizar o tutorial passado juntamente com estas classes, é claro que deverá ser feitas alguma alterações principalmente o acesso a um Banco de Dados.