23 de janeiro de 2019

Desenvolvimento android - lembretes e comandos

Como listar os dispositivos conectados ao computador

adb devices


Como desinstalar um aplicativo de um dispositivo (celular) específico

adb -s xxxxxxxx uninstall com.dominio


Como instalar um aplicativo em um dispositivo (celular) específico

adb -s xxxxxxxx install aplicativo.apk


onde:

  • xxxxxxxx é um dos dispositivos listados pelo adb devices
  • com.dominio é o id do aplicativo


Listando os pacotes dos aplicativos instalados no aparelho

adb shell pm list packages

O resultado vai ser algo do tipo
   package:br.com.zzzz


Obtendo o caminho do apk instalado

adb shell pm path br.com.zzzz

O resultado vai ser algo do tipo
   package:WWWW/base.apk


Retirando o aplicativo do aparelho

adb pull WWWW/base.apk

O resultado vai ser algo do tipo


WWWW/base.apk: 1 file pulled. 26.1 MB/s (35556390 bytes in 1.297s)


Filtrando o Log do adb

Para filtrar o log do adb por palavra (ou palavras) basta utilizar ele em conjunto com o Grep

adb -s xxxxxxxx logcat | grep 'Unity\|Ads'




20 de dezembro de 2018

Godot Engine - Criando um módulo customizado para o android

Em algum momento você via precisar criar um módulo customizado na Godot Engine para alguma plataforma (como android ou IOS). 

Como exemplo de um módulo customizado teríamos um módulo para a apresentação de anúncios (ads), como o Admob, Chartboost, ou Heyzap. Isso é necessário pois o módulo de ads não faz parte do núcleo do Godot.



Propaganda é o sustento do desenvolvedor de jogos


Para demonstrar a criação de um módulo para o android na Godot Engine, vamos criar um módulo simples que obtém as informações do aparelho celular e retorna o resultado em um Dictionary. Vamos chamar o módulo de device_info.

A seguinte estrutura de arquivos/pastas é necessária para a criação do módulo:

  • device_info
    • SCub
    • register_types.h
    • register_types.cpp
    • config.py
    • android
      • DeviceInfo.java


Pasta device_info

É a pasta raiz do projeto, que vai ser copiada para a pasta modules do projeto do Godot. 


Arquivo SCub

Arquivo a ser utilizado pelo Scons para a compilação do módulo. 


1
2
3
4
5
Import('env')

sources = [
           'register_types.cpp'
           ]


Arquivo register_types.h

Utilizado para registrar o módulo na Engine

1
2
void register_device_info();
void unregister_device_info();


Arquivo register_types.cpp

Implementação do .h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
#include "register_types.h"
#include "object_type_db.h"
#include "core/globals.h"
#include "ios/src/device_info.h"

void register_device_info() {
    Globals::get_singleton()->add_singleton(Globals::Singleton("DeviceInfo", memnew(DeviceInfo)));
}

void unregister_device_info() {
}


Arquivo config.py

Arquivo a ser utilizado pelo Scons

1
2
3
4
5
6
7
def can_build(plat):
 return plat=="android"

def configure(env):
 if (env['platform'] == 'android'):
  env.android_add_java_dir("android")
  env.disable_module()


Arquivo DeviceInfo.java

Arquivo com a implementação do módulo para o android.


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package org.godotengine.godot;

import java.util.HashMap;

import android.app.Activity;

import android.util.Log;

import android.os.Build;

public class DeviceInfo extends Godot.SingletonBase
{

 private Activity activity;

 static public Godot.SingletonBase initialize(Activity p_activity)
 {
  return new DeviceInfo(p_activity);
 }
 
 public DeviceInfo(Activity p_activity)
 {
  /*
   * Registrando os métodos que serão exportados para o GDscript  
   */
  registerClass("DeviceInfo", new String[]
  {
   "get_info_array"
  });
  activity = p_activity;
  
 }

 /**
  * Implementação do método para obter as informações do dispositivo
  */
 public org.godotengine.godot.Dictionary get_info_array()
 {
  org.godotengine.godot.Dictionary info = new org.godotengine.godot.Dictionary();
  info.put("MANUFACTURER", Build.MANUFACTURER);
  info.put("MODEL", Build.MODEL);
  info.put("PRODUCT", Build.PRODUCT);
  info.put("BRAND", Build.BRAND);
  info.put("DEVICE", Build.DEVICE);

  Log.d("godot", "get_info_array");

  return info;
 }
}


Para compilar o módulo criado, basta seguir as instruções do artigo Compilando a Godot para android - utilizando o Linux.


A animação a seguir apresenta a utilização do módulo criado.




No próximo artigo vamos criar um projeto no Godot demonstrando a utilização do módulo.

19 de dezembro de 2018

Compilando a Godot para android - utilizando o Linux

Para compilar a Godot Engine e criar um pacote customizado para o android basta executar os seguintes passos:

Baixar o código fonte da engine

git clone https://github.com/godotengine/godot.git

Ir para a pasta do projeto

cd godot/

Escolher a versão da engine a ser compilada (*)

git checkout 2.1.5-stable

Executar o comando para compilar a engine e gerar o pacote

scons platform=android target=release && cd platform/android/java/ && ./gradlew build && cd ../../../ 


O pacote customizado vai ficar na pasta bin/

android_release.apk

Para quem não utiliza a parte 3d da engine, a redução do tamanho do package pode ser obtida com os seguinte parâmetros:

scons platform=android disable_3d=yes disable_advanced_gui=yes module_bullet_enabled=no target=release && cd platform/android/java/ && ./gradlew build && cd ../../../


Se for necessário compilar para a arquitetura x86 (utilizada no emulador android - Android Virtual Device - AVD) as instruções anteriores ficam da seguinte forma.


scons platform=android target=release && scons platform=android target=release android_arch=x86 && cd platform/android/java/ && ./gradlew build && cd ../../../ 


scons platform=android disable_3d=yes disable_advanced_gui=yes module_bullet_enabled=no target=release && scons platform=android android_arch=x86 disable_3d=yes disable_advanced_gui=yes module_bullet_enabled=no target=release && cd platform/android/java/ && ./gradlew build && cd ../../../


(*) Atualmente a versão 2.1.5-stable é a única realmente estável para mobile (android/ios)

18 de dezembro de 2018

Compilando a Godot para linux

Para compilar a Godot Engine para o linux basta executar os seguintes passos:

Baixar o código fonte da engine

git clone https://github.com/godotengine/godot.git

Ir para a pasta do projeto

cd godot/

Escolher a versão da engine a ser compilada (*)

git checkout 2.1.5-stable

Executar o comando para compilar a engine

scons platform=x11 target=release_debug


A engine compilada vai ficar na pasta bin/

godot.x11.opt.tools.64



(*) Atualmente a versão 2.1.5-stable é a única realmente estável para mobile (android/ios)

17 de dezembro de 2018

Nextcloud - uma alternativa Gratuita ao Google Drive

O Nextcloud é um conjunto de softwares cliente-servidor para hospedagem de arquivos. O Nextcloud é gratuito e de código aberto, permitindo que qualquer pessoa o utilize em um servidor privado.

Ele é funcionalmente semelhante ao Dropbox, Google Drive, Onedrive, etc. 



Servidor

Instalação via Snap packages


- Instalando o snap

sudo apt install snapd

- Instalando o nextcloud

sudo snap install nextcloud

- Iniciando

sudo snap start nextcloud

- Acessando o admin

http://localhost/

1ª tela vai pedir a criação do usuário admin


Client


sudo snap install nextcloud-client

configurar as informações do servidor 



-----

OBSERVACOES: 

Ativação ssh

https://github.com/nextcloud/nextcloud-snap/wiki/How-to-connect-to-the-Nextcloud-Box-with-SSH
https://github.com/nextcloud/nextcloud-snap/wiki/Enabling-HTTPS-(SSL,-TLS)


https://nextcloud.com/ 

10 de dezembro de 2018

Lubuntu alterar as configurações do Display

Para quem usa a flavour Lubuntu, a alteração do display pode ser acessada através do seguinte comando:

lxrandr

esse é o comando para ajustar as configurações do display.