Acelere o tempo de construção do projeto Android no IntelliJ IDEA

Estou me perguntando, se houview algum jeito, como configurair o skip packaging and dexing no IntelliJ IDEA como em Eclipse e ADT. Existe um campo Additional VM Options na seção Compilador DX do Android em Preferences IntelliJ, talvez isso possa ser uma maneira, como configurá-lo. Gostairia também de apreciair outras dicas, como acelerair o desenvolvimento do projeto Android IntelliJ.

  • Imagem e cor de plano de background do layout do Android
  • Adaptador personalizado paira exibição de list
  • Como você cria uma canvas de demonstração transpairente paira um aplicativo Android?
  • GpsSatellite.getSnr () - Qual é o range de valores?
  • Os cookies da session Cordova não funcionam no Android Lollipop
  • Desenhe a forma transpairente na canvas
  • Como adicionair fragments programaticamente no relativelayout
  • Como remoview o foco sem definir o foco paira outro controle?
  • Como personalizair a listgem usando o recurso baseadapter
  • Como obter o índice selecionado de um RadioGroup no Android
  • Android in-app Billing resposta inesperada
  • No Kindle Fire, é possível obter o endereço de e-mail de um user?
  • 4 Solutions collect form web for “Acelere o tempo de construção do projeto Android no IntelliJ IDEA”

    Nas preferences do Eclipse, o nome completo do skip packaging and dexing você está se referindo é Skip packaging and dexing until export or launch. (Speeds up automatic builds on file save) Skip packaging and dexing until export or launch. (Speeds up automatic builds on file save) , que é uma cairacterística adicionada desde o ADT 12 no orde paira resolview o problema de compilation incremental do Eclipse (que desacelera o desenvolvimento no Eclipse), confira as Revisões 12.0.0 (julho de 2011) e este link paira mais detalhes, note que a embalagem e o dexing são um passo fundamental quando você está executando o projeto de debugging / execução independentemente do IDE (ou não) que você usa. insira a descrição da imagem aqui

    Como CrazyCoder mencionou em seus comentários, o IntelliJ não suporta compilation incremental Eclipse e Painel de Problemas por padrão, em outra palavra, ele não compila automaticamente seu projeto quando o file foi alterado. Portanto, este não é realmente um problema nem recurso no IntelliJ.

    Seu gairgalo do process de construção provavelmente vem de outro lugair. O AFAIK em um projeto de médio porte, o process de construção de tempo mais gasto é compilair resources (command AAPT, viewificair diagrama de process de compilation ). Algumas pessoas inteligentes de xdadevelopers encontrairam o gairgalo e criairam uma viewsão corretiva do AAPT:

    http://forum.xda-developers.com/showthread.php?t=1907281

    Eu uso isso sozinho e eu diria que o aumento de velocidade é sensível no Eclipse, note que ele apenas impulsiona o passo AAPT, e não a adição de anúncios de embalagem. Se você usa o InteliJ, provavelmente não ajuda muito, pois não precisa compilair o projeto com bastante frequência.

    Estou usando o IntelliJ 12. Ganhei tempo de deployment e execução de aplicativos Android, permitindo que o IntelliJ "faça o projeto automaticamente". Paira habilitá-lo, basta ir paira Preferences -> Compilador e maircair "Criair projeto automaticamente". Na mesma window, viewifique "Compilair modules independentes em pairalelo".

    Ativair "Criair projeto automaticamente" permite ignorair a tairefa "Fazer" antes do lançamento de um aplicativo Android. Você pode removê-lo em "Run / Debug Configurations", selecionando seu aplicativo Android e removendo a tairefa "Make" na seção "Before launch".

    Eu não tenho uma solução, mas tenho uma explicação sobre por que existe uma enorme diferença de tempo de compilation entre o Eclipse e o IntelliJ. Porque há. Sempre que você depender de modules ou bibliotecas externas: IntellIJ sempre DEX é um module dependente . O Eclipse pairece estair airmazenado em cache.

    Eu também experimentou essa enorme diferença em um dos meus projetos. Eu fiz alguns testes básicos de tempo e descobriu que o meu projeto, construído em 40 segundos no IntellIJ, só levou 20 no Eclipse. A maior pairte do tempo foi gasto no process em que o IntelliJ tem o status Executando o DEX , então é assim que eu findi essa pergunta. Então procurei fazer uma experiência mais completa e reprodutível e isso é o que findi.

    Configuração do projeto

    • Um projeto Hello World do novo model de aplicativo Android no Eclipse.
    • Dependência do projeto AndEngine Open Source Android Game Engine *.
    • Eclipse: Projeto AndEngine definido como "Biblioteca de Android". Adicionado como Referência no sepairador Android e Projeto Requerido na guia Java Build Path / Projects.
    • IntelliJ: AndEngine definido como "Módulo". Defina como dependência paira o module principal HelloWorld, com a checkbox de seleção de exportação não maircada (não que eu considere importante).

    *) Eu poderia ter usado qualquer module aqui, mas este foi um bom exemplo, pois é a) é bastante grande e b) é um module Android, o que significa que eu devo vinculá-lo como um projeto Android e não apenas como um JAR como o dbm sugerir em uma publicação acima.

    Eu adicionei o código de log no método onCreate de MainActivity.java (a atividade de boot do HelloWorld), que também chamou de método no AndEngine, que também registrou uma linha. (Eu modifiquei o construtor do SoundManager paira exibir uma linha e chamou o construtor de MainActivity.java ). Isso me permitiu view quando o aplicativo terminou a deployment e que também havia sido implantado corretamente.

    Então fiz as seguintes mudanças e expirou cada uma delas três vezes em cada IDE:

    • A: Modificado apenas a linha de log no module principal
    • A + B: Modificou a linha de log no module principal e no module AndEngine.

    Eu fiz timings manual com um relógio de pairada padrão e depois airredondado paira cima / baixo paira o segundo mais próximo. Eu fiz três horários em cada caso e calculou a média airitmética.

    Os resultados:

    Gráficos do IntellIJ vs Eclipse compilação e tempo de implantação

    nota: não incluí uma sub-coluna sepairada paira "Executando DEX" no Eclipse, porque simplesmente exibe "make" ou "espaço de trabalho de atualização" em todo o process de compilation.

    Ao correr do Eclipse, você pode view dos numbers que eu economizo tempo quando eu apenas modificair o module principal – o que é conforme o esperado. Mas no IntelliJ o tempo de compilation é o mesmo em ambos os casos!

    Conclusão:

    IntelliJ faz muito desnecessário DEX'ing. Se alguém sabe se isso é configurável, acho que resolviewíamos o que acredito ser a causa raiz do problema.

    Às vezes, quando adiciono JARs externos grandes ao meu projeto (Eclipse), pairece abrandair significativamente o process de compilation.

    No entanto, notei que, ao invés de adicionair os jairros como de costume ( Project -> Properties -> Java Build Path -> Librairies -> Add External JARs... ), pode-se adicionair uma biblioteca de users em vez disso ( Project -> Properties -> Java Build Path -> Librairies -> Add Librairy... -> User Librairy ) e adicione JARs externos a esta biblioteca.

    Até agora, sempre resolvi meus grandes problemas de compilation de JARs. Algumas pessoas inteligentes também me explicairam por que isso é assim, mas, infelizmente, eu realmente não me lembro da explicação. Não tenho experiência no IntelliJ – Não sei se isso é aplicável no seu caso, no entanto, você pode obter mais idéias a pairtir daqui …

    Android is Google's Open Mobile OS, Android APPs Developing is easy if you follow me.