A Adobe liberou hoje a nova versão do Adobe AIR para ambiente desktop e mobile(runtime e SDK). O foco dessa versão foi a implementação de melhorias significativas em relação o suporte ao iOS e atingir a paridade de recursos entre Android e iOS. Confira a vasta lista de novidades no blog do Christian Cantrell e no blog do Adobe AIR Team.

Veja esse video do Adobe TV onde Ryan Stewart mostra as novas funcionalidades do AIR for Mobile 2.6, e como possibilita criar aplicativos ricos para dispositivos iOS.

Daeee galera!
Esse port é para mostra um Skin bacana que catei na internet.
Original em http://flexdevtips.blogspot.com/2010/07/spark-textarea-with-line-numbers.html

Vamos ao Skin:

xml version="1.0" encoding="utf-8"?>
<s:SparkSkin xmlns:fx="http://ns.adobe.com/mxml/2009"
			 xmlns:s="library://ns.adobe.com/flex/spark"
			 xmlns:mx="library://ns.adobe.com/flex/mx"
			 xmlns:fb="http://ns.adobe.com/flashbuilder/2009"
			 creationComplete="created(event)"
			 alpha.disabled="0.5"
			 blendMode="normal">
?
	<fx:Metadata>
		[CDATA[
		[HostComponent("spark.components.TextArea")]
		]]>
	fx:Metadata>
?
	<fx:Script fb:purpose="styling">
		private var lineBreakChanged:Boolean;
?
		private var paddingChanged:Boolean;
?
		private var verticalAlignChanged:Boolean;
?
		/* Define the skin elements that should not be colorized.
		For text area, the skin itself is colorized but the individual parts are not. */
		static private const exclusions:Array = ["background", "scroller"];
?
		/**
		 * @private
		 */
		override public function get colorizeExclusions():Array {
			return exclusions;
		}
?
		/* Define the content fill items that should be colored by the "contentBackgroundColor" style. */
		static private const contentFill:Array = ["bgFill"];
?
		/**
		 *  @private
		 */
		override public function get contentItems():Array {
			return contentFill
		}
		;
?
		/**
		 *  @private
		 */
		override protected function commitProperties():void {
			super.commitProperties();
?
			if (lineBreakChanged) {
				updateStringStyle("lineBreak");
				lineBreakChanged = false;
?
				if (textDisplay != null) {
					if (getStyle("lineBreak") == "explicit") {
						if (textDisplay.percentWidth == 100) {
							textDisplay.width = NaN;
						}
					} else if (textDisplay.percentWidth != 100) {
						textDisplay.percentWidth = 100;
					}
				}
			}
			if (paddingChanged) {
				updatePadding();
				paddingChanged = false;
			}
			if (verticalAlignChanged) {
				updateStringStyle("verticalAlign");
				verticalAlignChanged = false;
			}
		}
?
		/**
		 * @private
		 */
		override protected function initializationComplete():void {
			useChromeColor = true;
			super.initializationComplete();
		}
?
		/**
		 *  @private
		 */
		override protected function updateDisplayList(unscaledWidth:Number, unscaledHeight:Number):void {
			if (getStyle("borderVisible") == true) {
				border.visible = true;
				shadow.visible = true;
				background.left = background.top = background.right = background.bottom = 1;
				scroller.left = scroller.top = scroller.right = scroller.bottom = 1;
			} else {
				border.visible = false;
				shadow.visible = false;
				background.left = background.top = background.right = background.bottom = 0;
				scroller.left = scroller.top = scroller.right = scroller.bottom = 0;
			}
?
			borderStroke.color = getStyle("borderColor");
			borderStroke.alpha = getStyle("borderAlpha");
?
			super.updateDisplayList(unscaledWidth, unscaledHeight);
		}
?
		/**
		 *  @private
		 */
		private function updatePadding():void {
			if (!textDisplay)
				return;
?
			// Push padding styles into the textDisplay
			var padding:Number;
?
			padding = getStyle("paddingLeft");
			if (textDisplay.getStyle("paddingLeft") != padding)
				textDisplay.setStyle("paddingLeft", padding);
?
			padding = getStyle("paddingTop");
			if (textDisplay.getStyle("paddingTop") != padding)
				textDisplay.setStyle("paddingTop", padding);
?
			padding = getStyle("paddingRight");
			if (textDisplay.getStyle("paddingRight") != padding)
				textDisplay.setStyle("paddingRight", padding);
?
			padding = getStyle("paddingBottom");
			if (textDisplay.getStyle("paddingBottom") != padding)
				textDisplay.setStyle("paddingBottom", padding);
		}
?
		/**
		 *  @private
		 */
		private function updateStringStyle(styleName:String):void {
			if (!textDisplay)
				return;
?
			// Push style into the textDisplay
			var style:String;
?
			style = getStyle(styleName);
			if (textDisplay.getStyle(styleName) != style) {
				textDisplay.setStyle(styleName, style);
			}
		}
?
		/**
		 *  @private
		 */
		override public function styleChanged(styleProp:String):void {
			var allStyles:Boolean = !styleProp || styleProp == "styleName";
?
			super.styleChanged(styleProp);
?
			if (allStyles || styleProp.indexOf("lineBreak") == 0) {
				lineBreakChanged = true;
				invalidateProperties();
			}
			if (allStyles || styleProp.indexOf("padding") == 0) {
				paddingChanged = true;
				invalidateProperties();
			}
			if (allStyles || styleProp.indexOf("verticalAlign") == 0) {
				verticalAlignChanged = true;
				invalidateProperties();
			}
		}
	fx:Script>
?
	<fx:Script>
		[CDATA[
			import mx.events.FlexEvent;
?
			/**
			 * @private
			 */
			private static const focusExclusions:Array = ["textDisplay"];
?
			/**
			 *  @private
			 */
			override public function get focusSkinExclusions():Array {
				return focusExclusions;
			}
?
			protected function created(event:FlexEvent):void {
				updateLineNumbers(event);
				hostComponent.addEventListener(FlexEvent.UPDATE_COMPLETE, updateLineNumbers, false, 0, true);
			}
?
			private var _lines:int = 0;
?
			private function updateLineNumbers(event:Event):void {
				var lines:int = textDisplay.mx_internal::textContainerManager.numLines;
				if (lines != _lines) {
					var old:int = _lines;
					this._lines = lines;
					var diff:int = lines - old;
					var linesString:String;
					var i:int;
					if (diff > 0) {
						linesString = lineNumbersLabel.text;
						for (i = old + 1; i <= _lines; i++) {
							if (i > 1) {
								linesString += "n";
							}
							linesString += i.toString(10);
						}
					} else {
						linesString = "";
						for (i = 1; i <= _lines; i++) {
							if (i > 1) {
								linesString += "n";
							}
							linesString += i.toString(10);
						}
					}
					lineNumbersLabel.text = linesString;
				}
			}
		]]>
	fx:Script>
?
	<s:states>
		<s:State name="normal"/>
		<s:State name="disabled"/>
	s:states>
?
	
	
	<s:Rect id="border"
			bottom="0"
			left="0"
			right="0"
			top="0">
		<s:stroke>
			
			<s:SolidColorStroke id="borderStroke"
								weight="1"/>
		s:stroke>
	s:Rect>
?
	
	
	
		
			
			
		
	
?
	
	
	
		
			
		
	
?
	
	
		
			
				
			
			
			
				
					
				
			
			
				
					
				
			
		
?
		
			
			
		
	
?

E ao Uso do mesmo no componente

xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009"
			   xmlns:s="library://ns.adobe.com/flex/spark"
			   xmlns:mx="library://ns.adobe.com/flex/mx" width="100%" height="100%">
	<fx:Declarations>
?
	fx:Declarations>
?
	<s:TextArea width="400" height="200" skinClass="br.com.fborella.SkinTextArea">
	s:TextArea>
s:Application>

Lembre-se de colocar o arquivo no seu pacore e ajustar o mesmo no skinClass

Exemplo:

Abraço

Felipe

Todos sabemos que com a vinda do Flash Builder 4 nós ganhamos o suporte a visualização do ASDoc, mas algo que deixou a desejar foi na criação de novas libs através do Flex Library Project pois não há como adicionar o conteúdo do ASDoc sem que haja a inclusão dos sources dentro da lib.

Essa situação não agrada muito quando o seu objetivo é distribuir uma biblioteca que tenha todo o suporte do ASDoc mas que não contenha os sources do seu projeto, visando manter a propriedade intelectual do que está sendo distribuído.

Reconhecido o erro, a Adobe liberou um Ant simples que você pode usar em seus Flex Library Projects.

O Ant faz as seguintes ações:
1. Compila o SWC.
2. Compila o ASDoc.
3. Adiciona ao SWC os novos xml/DITA gerados pelo ASDoc.

Entendido o problema, segue o Ant feito pela adobe com algumas modificações.
(Observem os comentários e não esqueça de substituir o CAMINHO_PARA_O_FLEXTASKS.JAR e o CAMINHO_PARA_A_SDK_DO_FLEX)

Agora que já entendemos o problema e já temos a solução, que tal automatizar o processo? Vamos adicionar o Ant no processo automático de compilação do projeto.

1. Adicione o ant dentro do path do seu projeto.

2. Acesse as propriedades do projeto e vá em Builders.

2. Clique no botão import e adicione o Ant file.

3. Desmarque a opção Flex.

Pronto, agora seu projeto Flex Library já está pronto para compilar o seu ASDoc sem comprometer o source dos seus arquivos.

Para baixa o ant clique aqui.

Este tutorial é o primeiro de uma série de tutoriais sobre o sistema operacional Android. Inicialmente falarei um pouco sobre o que é o android, para que os iniciantes entendam um pouco melhor o que está por trás deste Sistema Operacional que, em tão pouco tempo, conquistou uma fatia tão grande do mercado de mobiles.

O Android

É uma plataforma open source criada, como muitos devem saber, pelo Google. Mas não apenas por ele. Do desenvolvimento deste SO participou o grupo Open Handset Alliance, que conta com outros 47 grandes nomes, como: HTC, LG, Samsung, Motorola, Toshiba, Sprint Nextel, T-Mobile, Asus, Intel, e muitos outros (Mais informações sobre a OHA podem ser encontradas em: http://www.openhandsetalliance.com/).

O SO e a máquina virtual

Baseado no kernel 2.6 do Linux, o SO do Android é responsável por gerenciar a memória, os processos, segurança de arquivos e pastas e também redes e drivers. Cada aplicativo dispara um processo no sistema operacional e cada processo possui uma thread dedicada. O sistema operacional tem total controle sobre os processos e pode, se necessário, encerrá-los e reiniciá-los para liberar recursos.

A linguagem utilizada para desenvolvimento de aplicações em Android, como muitos devem saber, é Java. Mas o que poucos sabem é que o SO não possui uma JVM, e sim uma máquina virtual chamada Dalvik, otimizada para mobile.

Configuração inicial

A seguir está um tutorial passo-a-passo sobre como instalar o SDK do Android no Eclipse para que possamos começar a desenvolver para esta plataforma.

Assumirei que o Eclipse já está instalado e configurado na sua máquina. Desta forma, a primeira coisa que deve-se fazer é o download do SDK do android. Que pode ser obtido no seguinte endereço:

http://developer.android.com/sdk/index.html

Após fazer o download do SDK, extraia-o para alguma pasta do seu sistema, como “D:/Android_SDK”, por exemplo. Utilize o update manager do Eclipse para instalar os plug-ins disponíveis para o Android Development Tools (ADT) pela URL: https://dll-ssl.google.com/android/eclipse

Em seguida deve-se configurar o “caminho” para onde você salvou o SDK na guia “preferences” do seu Eclipse:

O próximo passo é instalar os pacotes do SDK disponíveis através do ADT:

Após selecionar os pacotes desejados, clique em “Install Selected” e confirme as licenças para cada um deles. O passo seguinte é instalar um AVD (Android Virtual Device) para que você possa testar seus aplicativos.

Na mesma janela do ADT, selecione a aba “Virtual Devices” , clique em “New”, configure como desejar e clique em “Create AVD”:

Em seguida teste seu AVD. Selecione-o na lista, clique em “Start…” e em seguida em “Launch”:

Parabéns! Seu Eclipse agora está configurado para que você comece a desenvolver aplicativos para Android.

Hello, World!

Agradecimentos ao @eduardohorvath pelo apoio e auxílio na estruturação do post.

Bom, acho que essa dica vai ajudar se você está pensando em testar componentes visuais.

No projeto do componente de organograma para a Petrobrás, além dos testes unitários padrões eu me aventurei um pouco com testes visuais do componente para me assegurar que dada uma modificação de algumas propriedades no componente o mesmo estava modificando corretamente sua visualização e avisando os componentes de suporte como Navigator, Logger dessas modificações.

O problema de testes visuais que acredito que todos saibam está no ciclo de vida dos componentes. Não conseguimos ser determinísticos em quanto tempo o componente estará pronto para sofrer asserts em suas propriedades. Vamos começar com o setUp e o tearDown de um teste unitário visual.

Vamos utilizar o FlexUnit 4.x nos casos de teste

[Before( async, ui )]
Será executado antes de todos os casos de teste. As indicações async e ui na metadata dizem para o Runner do teste que esse método possui processos assíncronos e que o mesmo deve verificar a classe Async para proceder com o teste.

Async.proceedOnEvent( this, _chart, FlexEvent.CREATION_COMPLETE, 1000 )
Avisa que o teste só deve continuar quando o evento FlexEvent.CREATION_COMPLETE for disparado pelo componente.

UIImpersonator.addChild( _chart );
Adiciona o componente como um filho de uma espécie de Application que iniciará o ciclo de vida de criação do componente.

[After( ui )]
Executando após o teste em questão ser executado. Faz a limpeza dos elementos criados anteriormente.

UIImpersonator.removeChild( _chart );
Remove o componente da lista de filhos e executa o ciclo de vida de destruição do componente.

No caso do componente, ao setar o dataProvider ele modifica o dataProvider de um DataGroup interno, que consequentemente vai efetuar a criação dos renderers. Nesse teste estamos validando se “ao preencher o dataProvider o DataGroup está criando os renderers enviados na coleção” efetuando a contagem de elementos presentes no DataGroup.

Utilizando o mesmo tipo de teste assíncrono podemos testar algumas interações do usuário como MouseEvent.MOUSE_CLICK, MouseEvent.MOUSE_MOVE simplesmente pegando a instância do componente criado e executando o evento manualmente. Com isso os listeners serão disparados e você poderá utilizar o Async.asyncHandler para escutar um determinado do componente e efetuar os asserts necessários para validar se a interação modificou as propriedades do componente.

No post anterior eu mostrei como fazer ligações de uma aplicação air para o android. Agora eu vou mostrar como enviar mensagens e e-mails pelo celular através de uma aplicação air-android.

O processo de envio de mensagem de texto (sms) é muito parecido com o de fazer uma chamada. Você altera o url string para sms e concatena o número para o qual você deseja enviar a mensagem, logo depois abrirá o compose para você digitar a mensagem. eu (ainda) não possuou um android, mas em breve eu terei um para poder fazer os testes e melhorar assim a qualidade das aplicações. Abaixo segue o código de como enviar uma mensagem de texto (sms) para um celular.

Já para enviar e-mail o processo é semelhante, porém você deve configurar mais alguns itens. O código abaixo mostra como fazer.

UPDATE
Aplicação Emulada no Android.

Como podem ver, o processo para enviar e-mails é semelhante ao de enviar mensagem sms e fazer ligações, a diferença é que você deve adicionar o destinatário, assunto e corpo da mensagem.

Espero que vocês tenham gostado e aproveitem bastante.

Clique aqui para fazer o download do código fonte para enviar mensagens, emails e fazer ligações.

Olá,

Esse sera o primeiro post que escrevo sobre android, estou começando a “brincar” com ele e resolvi compartilhar um pouco do pouco que descobri.
Nesse post vou dar uma ideia de como implementar o seu próprio ContentProvider.

SQLite :

Uma das grandes facilidades do android e o suporte ao SQLite.
As aplicações poderiam acessar diretamente o banco porem é uma boa pratica encapsular isso em um ContentProviders
de forma que isso fique acessível para sua aplicação ou qualquer outra que precise acessar esses dados.

ContentProviders :

O ContentProviders é uma parte muito importante da arquitetura de um sistema android.
São eles quem provem os dados para a aplicação.

Uri :

No Android a comunicação entre aplicações e providers é feita através de Uri.
Cada ContentProviders expõe URIs públicas que identificam o seu conjunto de dados
e controla uma ou mais tabelas e expondo uma URI diferente para cada uma delas.

Uma Uri segue o formato: “content://{authority}/{table}/parametroN”
{authority} é o “nome” do ContentProviders
{table} é a tabela que esta acessando
{parametroN} são os parâmetros esperados pelo provider.

EX :
Todos os registros da tabela (Diretório): content://br.com.flexria.jobsdroid.jobsdroidprovider/jobs
Um único registro com id 1 (Item) : content://br.com.flexria.jobsdroid.jobsdroidprovider/jobs/1

Escrevendo seu ContentProvider :

Bom, vajamos na pratica com isso funciona.
Para escrever seu ContentProviders vc precisa basicamente de quatro coisas.

• BaseColumns
• ContentProviders
• SQLiteOpenHelper
• Registrar o provider no AndroidManifest.xml :

ContentProvider :

E a classe que provera os dados a nossa aplicação,
A classe abstrata ContentProvider exige a implementação dos métodos :

* query(Uri, String[], String, String[], String)- Recuperar dados.
* insert(Uri, ContentValues) – Insere um novo registro.
* update(Uri, ContentValues, String, String[]) – Atualiza um registro existente.
* delete(Uri, String, String[]) – Deleta um registro.
* getType(Uri) – Obter o MIME type do dado.

Dentro desses métodos iremos implementar a logica que encapsula esses comportamentos.
Isso é valido para cada uma das tabelas que o provider esteja acessando,
Como aqui só tenho uma tabela e esse é apenas um exemplo didático esta tudo na mesma classe,
porem isso pode ficar meio confuso com quando temos varias tabelas e comportamentos diferentes.
Uma solução para isso seria implementar o Pattern Strategy para encapsular cada comportamento.

O exemplo é bem básico porem gostaria de salientar três pontos
* Método getType – Informa que tipo de dado esta sendo requisitado, se é um item ou o diretório.
* Variável mMatcher – Usado para verificar qual Uri esta sendo acessada, se é um item ou o diretório.
* Constante AUTHORITY – Mesma identificação do provider utilizado no AndroidManifest.xml

Bom, como uma Imagem diz mais que mil palavras ai vai o código:

public class JobsDroidProvider extends ContentProvider {
  /**
  * Provider Authority
  */
  public static final String AUTHORITY = "br.com.flexria.jobsdroid.jobsdroidprovider";
  /**
  * DataBase Name
  */
  private static  final String DATABASE_NAME = "jobsdroid.db";
  /**
  * DataBase Version
  */
  private static  final int  DATABASE_VERSION = 1;
  /**
  * match for directory of jobs.
  */
  private  static final int MATCH_JOBS 		= 1;
  /**
  * match for sub-directory of a single jobs.
  */
  private  static final int MATCH_JOBS_ID 	= 2;
  /**
  * Log Tag
  */
  public static final String TAG = "JobsDroidProvider";
  /**
  * DBHelper instance
  */
  private DBHelper mHelper;
  /**
  * UriMatcher instance
  */
   private static final UriMatcher mMatcher;
   /**
   * Projection Map instance
   */
   private static HashMap<String, String> mProjection;
?
   static {
	mProjection = new HashMap<String, String>();
	mProjection.put(Jobs._ID, 	Jobs._ID);
	mProjection.put(Jobs.NAME, 	Jobs.NAME);
    }
?
    static {
    	mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
	mMatcher.addURI(AUTHORITY, Jobs.TABLE, 		MATCH_JOBS);
	mMatcher.addURI(AUTHORITY, Jobs.TABLE+"/#", 	MATCH_JOBS_ID);
    }
?
?
    @Override
    public String getType(Uri uri) {
?
	switch (mMatcher.match(uri)) {
		case MATCH_JOBS:
			return Jobs.CONTENT_TYPE;
		case MATCH_JOBS_ID:
			return Jobs.CONTENT_ITEM;
		default:
			throw new IllegalArgumentException("Unsupported URI: " + uri);
	}
    }
?
?
    @Override
    public boolean onCreate() {
	mHelper = new DBHelper(getContext());
	return (mHelper != null);
    }
?
?
    @Override
    public Cursor query(Uri uri, String[] projection, String selection,String[] selectionArgs, String sortOrder) {
	String type = this.getType(uri);
	Log.i(TAG, "query " + uri.toString());
?
	Cursor cursor;
	SQLiteQueryBuilder builder = new SQLiteQueryBuilder();
	SQLiteDatabase database = mHelper.getReadableDatabase();
	builder.setTables(Jobs.TABLE);
	builder.setProjectionMap(mProjection);
?
	if (type.equals(Jobs.CONTENT_ITEM)) {
		builder.appendWhere(this.whereItem(uri, selection));
	}
?
	if (sortOrder == null || sortOrder.length() == 0) {
		sortOrder = Jobs.NAME;
	}
?
	cursor = builder.query(database, projection, selection, selectionArgs,null, null, sortOrder);
	cursor.setNotificationUri(getContext().getContentResolver(), uri);
?
	return cursor;
    }
?
?
    @Override
    public Uri insert(Uri uri, ContentValues values) {
	this.getType(uri);
	Log.i(TAG, "insert " + uri.toString());
?
	SQLiteDatabase db = mHelper.getWritableDatabase();
	long rowId = db.insert(Jobs.TABLE, Jobs.NAME, values);
?
	if (rowId > 0) {
	    Uri itemUri = ContentUris.withAppendedId(Jobs.CONTENT_URI, rowId);
	    getContext().getContentResolver().notifyChange(itemUri, null);
	    return itemUri;
	}
?
	throw new RuntimeException("Failed to insert row into : " + uri);
    }
?
?
    @Override
    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
	String type 		= this.getType(uri);
	SQLiteDatabase db 	= mHelper.getWritableDatabase();
?
	Log.i(TAG, "update " + uri.toString());
?
	if(type.equals(Jobs.CONTENT_ITEM)){
		selection = this.whereItem(uri, selection);
	}
?
      	int count = db.update(Jobs.TABLE, values, selection, selectionArgs);
	getContext().getContentResolver().notifyChange(uri, null);
?
	return count;
    }
?
?
    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
	String type 		= this.getType(uri);
	SQLiteDatabase db 	= mHelper.getWritableDatabase();
?
	Log.i(TAG, "delete " + uri.toString());
?
	if(type.equals(Jobs.CONTENT_ITEM)){
		selection = this.whereItem(uri, selection);
	}
?
	int count = db.delete(Jobs.TABLE, selection, selectionArgs);
	getContext().getContentResolver().notifyChange(uri, null);
	return count;
    }
?
    private String whereItem(Uri uri, String selection) {
	if(this.getType(uri).equals(Jobs.CONTENT_ITEM)){
		String where  =  Jobs._ID + " = " + uri.getPathSegments().get(1);
		if(!TextUtils.isEmpty(selection)){
			return where + " AND (" + selection + ")" ;
		}else{
			return where;
		}
	}
	return selection;
    }
?
    /**
    * Inner class Jobs
    */
    public static final class Jobs implements  BaseColumns {
    	    ....
    }
?
    /**
    * Inner class DBHelper
    */
    private static class DBHelper extends SQLiteOpenHelper {
       	....
    }
}

BaseColumns :

Inner class que representa a tabela do banco de dados,
estende a interface BaseColumns que possue as constantes _ID e _COUNT.
A classe Jobs possuí as constantes que representam as colunas da tabela e a Uri que a identifica

/**
* Inner class Jobs
*/
 public static final class Jobs implements  BaseColumns {
    public static final Uri CONTENT_URI = Uri.parse("content://"+ JobsDroidProvider.AUTHORITY + "/" + Jobs.TABLE);
?
    /**
    * The MIME type of a directory.
    */
    private static final String CONTENT_TYPE = "vnd.android.cursor.dir/vnd.flexria." + Jobs.TABLE;
?
?
    /**
    * The MIME type of a single Jobs.
    */
    private static final String CONTENT_ITEM = "vnd.android.cursor.item/vnd.flexria." + Jobs.TABLE;
?
    /**
     * Table name
     */
    private static final String TABLE 	= "jobs";
?
    /**
     * Column name
     */
    public static final String 	NAME = "name";
}

SQLiteOpenHelper :

Inner class que é responsável pela criação e alteração do banco de dados,
A classe abstrata SQLiteOpenHelper exige a implementação dos métodos :

* onCreate() – Chamado quando o banco de dados for aberto pela primeira vez. Aqui que criaremos o banco de dados.
* onUpdate() – Chamado quando a versão do banco de dados muda. Quando uma nova versão da app for instalada.

Como nesse caso temos a primeira versão não tenho nada no método onUpdate.

/**
* Inner class DBHelper
*/
private static class DBHelper extends SQLiteOpenHelper {
    private static final String SQL_CREATE_TASKS = "CREATE TABLE " + Jobs.TABLE +
                     " (" +
                           Jobs._ID 	+ " INTEGER PRIMARY KEY AUTOINCREMENT," +
                           Jobs.NAME 	+ " TEXT" +
                       " );";
?
    DBHelper(Context context) {
       super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }
?
    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(SQL_CREATE_TASKS);
    }
?
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
?
    }
}

AndroidManifest :

Depois disso podemos registrar o provider no AndroidManifest.xml

 android:authorities="br.com.flexria.jobsdroid.jobsdroidprovider"
			android:name=".JobsDroidProvider" />

Utilizando o Provider :

Feito isso ja podemos utilizar o provider na Activity,
quando utilizamos o método getContentResolver da Activity e passamos como parâmetro a Uri do conteúdo
o nosso provider é chamado e os métodos que implementamos podem ser utilizados.

EX :
* getContentResolver().query(JobsDroidProvider.Jobs.CONTENT_URI, null, null, null, null);

ContentValues values 	= new ContentValues();
values.put(JobsDroidProvider.Jobs.NAME, "Fabio B. Silva");
?
getContentResolver().query(JobsDroidProvider.Jobs.CONTENT_URI, null, null, null, null);
getContentResolver().insert(JobsDroidProvider.Jobs.CONTENT_URI, values);
?
?
Uri uri = ContentUris.withAppendedId(JobsDroidProvider.Jobs.CONTENT_URI, 1);
// uri = content://br.com.flexria.jobsdroid.jobsdroidprovider/jobs/1
getContentResolver().update(uri, values,null,null);
getContentResolver().delete(uri, null, null);

Em um próximo momento volto a falar sobre isso, mais por hora é só.

Espero que essa dicas possam ajudar aos que como eu estão começando com o android

Abraço e até a próxima….

Quando comecei a estudar aplicações air no android uma das primeiras perguntas que eu fiz foi “Como explorar recursos do Sistema Operacional?”. Então depois de algumas googladas eu encontrei alguns artigos que satisfizeram minha curiosidade, pelo menos até a necessidade que eu tinha. Pude notar que o air no adroid ainda não possui muitos recursos do s.o mas esperamos que pelo menos até o lançamento oficial mais coisas possam aparecer.

O código abaixo mostra como fazer uma ligação para um número através da sua aplicação air. Notem que é bastante simples.

Abaixo uma imagem da aplicação

Infelizmente eu não tenho aqui nenhum celular android para mostrar como fica a aplicação executando pra valer (é em casa de ferreiro o espeto é de pau hehe).

UPDATE

Eu consegui executar a aplicação em um avd (Android Virtual Device) do SDK do android. Portanto, a aplicação deverá aparecer no celular de acordo com a figura abaixo.

Já temos há algum tempo a possibilidade de criar aplicativos para Android com a Flash Platform, usando o Adobe AIR ou Flash Player. Além disso o Android vem se tornando a cada dia mais popular, diariamente surgem varios aparelhos cada vez mais poderosos rodando o sistema operacional do Google e a Android Market foi reformulada para facilitar os usuarios e desenvolvedores.
Um detalhe importante é que não são todas as versões do Android que suportam o Adobe AIR e o Flash Player, é necessario que o smartphone tenha o Android 2.2(Froyo) ou posterior, e as versões do AIR deve ser a 2.5 ou Flash Player 10.1.

O desenvolvimento de aplicativos com a Flash Platform para o Android só é possivel a partir do Android 2.2(Froyo) e usando Adobe AIR 2.5 e Flash Player 10.1

Ferramentas de desenvolvimento
Adobe Flash CS5 Professional – É possivel desenvolver aplicativos para Android usando o Adobe Flash CS5 Professional, na ultima versão foi adicionado um profile “AIR for Android”, gerando o arquivo ja com o tamanho padrão de 480?800. Por enquanto não existem componentes pré-programados para Android e não é recomendado usar os já existentes no Flash.

Adobe Flash Builder 4 (burrito) – A Adobe disponilibizou juntamente com o Flash Builder 4 (burrito), o SDK do Flex versão 4.5, com componentes otimizados para dispositivos moveis, para quem se recordar, a Adobe tinha um projeto de uma versão do Flex para mobile chamado “Slider”, em virtude do rápido crescimento do processamento do smartphones atuais, a Adobe decidiu juntar esse projeto ao SDK padrao do Flex.

Qualquer editor de texto – Você pode usar qualquer editor de texto salvando na extensão .as ou seu editor ActionScript favorito.

Runtime Adobe AIR
Para que seu aplicativo rode em um dispotivo com Android, é necessario que seja instalado o runtime do Adobe AIR para logo em seguida você instalar seu aplicativo.

Distribuição
Você pode gerar o instalador do seu aplicativo pelo Flash Builder, Flash CS5 ou por linha de comando usando o ADT. É gerado um aplicativo com a extensão .apk. A distribuição pode ser feita atraves da Android Market, para se tornar um publisher da Android Market, basta pagar a inscrição de 25 dolares.
Acompanhe esse tutorial sobre como publicar seu aplicativo na Android Market
Caso você crie algo para rodar no Flash Player, basta rodar pelo navegador do smartphone, a Adobe tem uma página para que você possa ver alguns sites que usam Flash Player e que foram otimizados para mobile. Acesse o Adobe Flash Showcase for Mobile

Acompanhe alguns tutoriais:
Exemplos no Adobe Labs
Advanced Android development
Creating mobile apps for Android using Flash Builder “Burrito” and Flex SDK “Hero”
Test Drive for Mobile: Style the application

Nos proximos artigos, mostrarei como usar alguns recursos do AIR for Android

Depois de muito tempo fora dos palcos estou de volta, dessa vez com uma série de tutoriais focados principalmente no desenvolvimento de aplicações para android utilizando o flash builder burrito.

Neste primeiro tutorial eu irei mostrar como criar algumas operações do CRUD em uma aplicação android utilizando um banco de dados local, neste caso o SQLITE. Não vou explicar como criar um novo projeto ou mesmo os componentes de uma aplicação android, para isso assista aos screencasts no site do Igor costa e também no blog da dclick.

Primeiramente vamos criar no nosso arquivo principal a conexão com o banco e também a criação de uma tabela.

protected function createDb():void 

var sqlConnection:SQLConnection = new SQLConnection();

sqlConnection.open(File.applicationStorageDirectory.resolvePath("testeDb.sqlite"));

var stmt:SQLStatement = new SQLStatement();

stmt.sqlConnection = sqlConnection;

stmt.text = "CREATE TABLE IF NOT EXISTS contatos (" +
"id INTEGER PRIMARY KEY AUTOINCREMENT," +
"nome VARCHAR(200) NOT NULL," +
"telefone VARCHAR(45) NOT NULL," +
"email VARCHAR(200) DEFAULT NULL)";

stmt.execute();

A função createDb é executada na método initialize da aplicação.
A variável sqlConnection na linha 3 é responsável pela conexão.
Na linha 5 é criado o arquivo SQLite para a aplicação
Na linha 7 a varável stmt é responsável pelas instruções SQLite.
É criada a conexão na linha 9.
Na linha 11 é a instrução SQLite que será executada, nesse caso a criação da tabela na nossa base testeDb.sqlite.
Na linha 17 é executada a instrução SQLite da linha 11.

Pronto, depois da tabela criada vamos criar a nossa view para poder cadastrar dados nela.

A função para salvar os dados é bem simples. Adicione um evento para o clique do botão e nele adicione o seguinte código.

var sqlConnection:SQLConnection = new SQLConnection();
sqlConnection.open(File.applicationStorageDirectory.resolvePath("testeDb.sqlite"));

var stmt:SQLStatement = new SQLStatement();
stmt.sqlConnection = sqlConnection;

stmt.text = "INSERT INTO contatos (nome, telefone, email) VALUES" +
"('" + txiNome.text + "', '" + txiTelefone.text + "', '" + txiEmail.text + "')";

stmt.execute();

navigator.popView();

Bom para quem já desenvolveu alguma app em Air utilizando o SQLite percebe que a conexão é feita da mesma forma. Se você deseja melhorar seu código (assim como eu) sugiro a leitura do post do Andre Casertano no site da Imasters. Ele mostra como criar uma classe de conexão com o SQLite e também explica um pouco melhor sobre como é feita essa conexão no primeiro posto sobre o assunto.

No código fonte eu coloquei também as operações de update e delete. Esta bastante simples. No próximo post eu prometo melhorar um pouco… =D

Download do fonte.