Technè

Em agosto de 2010 o IBOPE realizou uma pesquisa com 2002 brasileiros em 141 municípios perguntando quais seriam as maiores preocupações em suas vidas naquele momento, o resultado apontou que a primeira delas é com saúde, a segunda educação e a terceira, mas não menos importante, segurança pública. Não é preciso falar muito sobre criminalidade para entender porque segurança figura como uma preocupação nacional: tráfico de drogas, assaltos e furtos já são parte (desagradável) do cotidiano dos cidadãos brasileiros. Delitos relacionados a veículos são um preocupante caso a parte, só no estado de Pernambuco, de maio de 2007 a abril de 2008 quase 18.500 ocorrências de furtos ou roubos de veículos e 551 arrombamentos de veículos foram registradas, causando prejuízos financeiros e pessoais a cidadãos e ao estado.

Que estes delitos são resultado de uma série de problemas sociais como pobreza, macrocefalia urbana, ausência do estado nas comunidades carentes dentre outras políticas falíveis isso todos nós sabemos e que esse problema se resolve com educação e inclusão social e qualidade de vida todos nós também já sabemos. No entanto, mais além da esfera política e social, há de se fazer o seguinte questionamento: não serão esses crimes também um problema de design? Será que como configuradores de objetos de desejo também não somos responsáveis por parte de delitos que visam produtos ou se valem de falhas neles? O pensamento deste artigo parte do princípio de que sim, o designer, como criador de diversos objetos que permeiam o cotidiano das pessoas, tem responsabilidade também sobre os delitos, porque existem aspectos do design dos produtos que, mal projetados ou desconsiderados, culminam por se tornar facilitadores ou alvos de crimes. Existe no delito uma estrutura intelectual mais ou menos recorrente e que se divide em fases específicas, interferindo com design em certas fases desta estrutura é possível tornar prevenir crimes e proteger produtos, essa série de princípios integra o conceito de Design Contra o Crime.

Criado na Inglaterra na década de 90 pelas universidades de Sheffield Hallam, Cambridge e Salford e atualmente estudado e desenvolvido no Brasil no projeto Design Contra o Crime, no SENAI do Paraná, design contra o crime é uma avançada técnica de prevenção situacional do delito. Abaixo segue a compilação de alguns princípios que podem e devem ser considerados na fase de projeto, a fim de tornar produtos resistentes ao delito.

Camuflagem

Por camuflagem, entendemos uma forma de esconder o produto, atribuindo a ele o valor ou a aparência de outro objeto, geralmente de menor valor. Tendo este princípio em vista, a empresa espanhola Mite Mite criou uma série de capas para Notebooks com a aparência muito próxima a de um jornal local, só olhando de muito perto se tem certeza que não é um jornal.

Ocultar a presença do valor

A oportunidade para o delito por vezes se caracteriza por objetos de valor expostos, deixados a esmo em locais movimentados, manter objetos bem guardados auxilia na prevenção do delito, pois descaracteriza a oportunidade, desestimula o delinquente. Recursos como porta-objetos em veículos levam em conta este princípio e mantendo objetos de valor como players de MP3, cd´s, Aparelhos telefônicos e carteiras acomodados e fora da vista, evitando o interesse de delinqüentes. Esta percepção de segurança e resistência ao delito já é percebida por boa parte dos consumidores de automóveis brasileiros, segundo a revista Quatro Rodas de maio de 2010, durante o projeto do novo Fiat Uno, quando em fase de pesquisa com os usuários, estes comentaram a utilidade de porta objetos para organizar objetos de valor e assim manter o carro protegido da ação de delinqüentes. Neste quesito, automóveis são especialistas, muitos modelos de veículos apresentam soluções criativas e práticas de porta objetos, o Honda City e o Ford Ecosport trazem um porta objetos abaixo do assento do carona, o Dodge Journey tem um porta objetos acoplado ao assoalho do banco traseiro, a versão 1998 do Corsa Wagon trazia porta objetos integrados ao assoalho falso do porta malas e o Peugeot 405 1995 por exemplo possuía uma prática tampa que encobria o toca-fitas, ocultando a existência deste dispositivo, à época valioso.

Bloquear ou trancar.

A idéia de trancar um objeto ou prendê-lo um ponto fixo e assim evitar que seja levado é um princípio primário e básico da proteção de produtos, muito útil à proteção de objetos leves, de alto valor agregado e que podem ser facilmente levados ou a ambientes onde estão contidos valores. Neste sentido trancas, cadeados, travas para computadores e travas de coluna de direção cumprem esta função. O princípio da tranca ou bloqueio, no entanto, é um dos mais primários e mais facilmente burláveis, uma vez que não auxilia a descaracterizar a oportunidade do delito, o objeto de roubo (seja um aparelho telefônico, um carro, um notebook) permanece aparente, cada vez mais comum são delinqüentes que agem com uma motivação mais específica, munidos de ferramentas, que tornam possível violar  travas e trancas. O bloqueio ou tranca deve funcionar sempre como complemento a outros componentes de proteção ao delito.

Tornar evidente o delito

Consiste de munir o produto de meios ou dispositivos que atraiam a atenção para o delinqüente e tornem visível ou evidente o delito, este pensamento de projeto visa causar constrangimento e intimidação ao delinqüente e desestimula a ação delitiva ou pode alertar às autoridades, possibilitando que seja detido o criminoso. Um exemplo muito curioso do uso deste pensamento de projeto foi utilizado em 2006 pela secretaria de estado da educação do Paraná, diante do habitual problema de furto de televisores das escolas públicas, a Secretaria decidiu encomendar televisores pintados de laranja e com a inscrição “Secretaria de Estado da Educação do Paraná”, uma vez que nenhum televisor no mercado é vendido na cor laranja, o indivíduo que fosse pego com um destes aparelhos só poderia tê-lo adquirido por vias ilegais como furto ou receptação de roubo e portanto estaria tornando óbvio o delito.

Aparentar valor reduzido.

Há razões diversas para um produto ser roubado, um carro antigo pode ser roubado por suas peças, uma mercadoria pode ser roubada de uma loja na ausência de sistemas de segurança, mas muitas vezes um produto é roubado por sua boa aparência e por seu alto valor agregado chamarem a atenção o caso de pequenos eletrônicos ou belos carros que saltam à vista. Uma técnica bem humorada de design contra o crime possível para a prevenção de furtos de objetos, neste caso, é utilizar artifícios que confiram ao produto aparência de usado, desgastado ou estragado, uma embalagem que confira ao sanduíche aparência de estragado ou até uma pintura que confira ao veículo uma aparência mais simples e chame menos a atenção ao seu valor são exemplos do uso deste princípio. Na Inglaterra, país onde o roubo e furto de veículos rende prejuízos públicos de mais de 85 milhões de libras, o site dominicwilcox.com vende adesivos em vinil que simulam aparência de ferrugem, podendo ser colados em sua motocicleta, bicicleta ou automóvel e protegê-lo de gatunos. Um bom exemplo desta tática, ainda que não trate de proteger contra um delito, é a embalagem de sanduíche a prova de roubo vendida pelo site thinkofthe.com que confere ao sanduíche a aparência de estar estragado, portanto eliminando o interesse no seu conteúdo.

Rastrear

O princípio de rastreabilidade, ao contrário dos demais princípios que pretendem prevenir o delito, preconiza a capacidade de rastrear o produto quando subtraído, tornando possível identificação do delinqüente e recuperação dos bens furtados, a rastreabilidade de produtos geralmente se configura em forma de um sistema de telecomunicação instalado a um produto, bons exemplos do uso desta técnica são sistemas de rastreio veicular e softwares de rastreio de computadores pessoais. A empresa Fork Ltd. criou o Prey Project, que consiste de uma base online, onde o usuário pode cadastrar e rastrear gratuitamente dispositivos de sistemas operacionais diversos (Windows, Android, OSX Apple, Linux e Ubuntu). Se roubados, é possível, remotamente e através do Prey, acionar a câmera do dispositivo e fotografar e identificar o surrupiador.

O objetivo deste post é apresentar brevemente(10 munutos) o recurso que o framework  .net nos oferece chamado LINQ.

Uma consulta (Query) é normalmente expressa em uma linguagem especializada de consulta, tal como SQL para bancos de dados relacionais e XQuery para XML.  O LINQ simplifica a construção e execução de uma query, oferecendo um modelo para trabalhar com dados tipos de fontes de dados diferentes. Em uma consulta LINQ, o programador está sempre trabalhando com objetos.

Abaixo mostrarei como é simples construir uma query utilizando o LINQ com uma lista.

Segue o código:

using System;

using System.Collections.Generic;

using System.Linq;

namespace ConsoleApplication1

{

class Pessoa

{

#region Atributos

private ushort _idade;

private string _cpf;

private string _nome;

#endregion

#region Construtor

public Pessoa(string nome, ushort idade, string cpf)

{

_nome = nome;

_idade = idade;

_cpf = cpf;

}

#endregion

#region Propriedades

public ushort Idade

{

get { return _idade; }

set { _idade = value; }

}

public string Cpf

{

get { return _cpf; }

set { _cpf = value; }

}

public string Nome

{

get { return _nome; }

set { _nome = value; }

}

#endregion

#region Metodos

public override string ToString()

{

return string.Format(“Nome: {0}\t Idade: {1}\t CPF: {2}”,_nome,_idade,_cpf);

}

#endregion

}//class pessoa

class Program

{

static void Main(string[] args)

{

IList<Pessoa> listaDePessoas = new List<Pessoa>();

listaDePessoas.Add(new Pessoa(“Eduardo”, 30, “01000812454″));

listaDePessoas.Add(new Pessoa(“Davi”, 24, “11122233344″));

listaDePessoas.Add(new Pessoa(“Emerson”, 31, “55566677788″));

listaDePessoas.Add(new Pessoa(“Manuel”, 34, “01000101010″));

listaDePessoas.Add(new Pessoa(“Caio”, 23, “24240101010″));

//Exemplo 1: Seleção com WHERE

var query1 = from p in listaDePessoas

where p.Idade > 30

select p;

Console.WriteLine(“Resultado da Query 1:”);

foreach (var pessoa in query1)

{

Console.WriteLine(pessoa);

}

Console.ReadKey();

//Exemplo 2: Seleção com conversão

IList<Pessoa> query2 = (from p in listaDePessoas

where p.Nome.StartsWith(“E”)

select p).ToList<Pessoa>();

Console.WriteLine(“Resultado da Query 2:”);

foreach (var pessoa in query2)

{

Console.WriteLine(pessoa);

}

Console.ReadKey();

}

}

}

No exemplo 2 é feita uma seleção que retorna pessoas cujo nome começa com a letra “E”. Em seguida é feita uma conversão para o tipo List<Pessoa>.

Abaixo segue o resultado das duas queries.

Resultado da Query 1:

Nome: Emerson    Idade: 31       CPF: 55566677788

Nome: Manuel     Idade: 34       CPF: 01000101010

Resultado da Query 2:

Nome: Eduardo    Idade: 30       CPF: 01000812454

Nome: Emerson    Idade: 31       CPF: 55566677788

Este post apresentou resumidamente uma das funcionalidades do LINQ. Uma maneira simples e rápida de realizar consultas.

Para um estudo mais profundo você pode pesquisar no MSDN  http://msdn.microsoft.com/en-us/vcsharp/aa336746 ou pelo livro LINQ  in Action http://linqinaction.net/.

Você já pensou em interagir com um aplicativo na sua televisão? Não? Isso é estranho? Hoje isso é pura realidade. O brasileiro ganhou e muito com a chegada da TV Digital e Internet-TV: áudio e vídeo de qualidade, multiprogramação, INTERATIVIDADE e conteúdo sob demanda. O que isso muda? De cara você deixa de ser só telespectador, e passa a ser chamado também de usuário.

No Sistema Brasileiro de Televisão Digital(SBTVD) as emissoras poderão transmitir sinal totalmente digital – ou seja, áudio, vídeo e aplicativos como dados, bits… 0 ou 1. Esta mudança leva a uma alteração gigante no processo televisivo, seja na produção de conteúdo, na transmissão da informação ou na recepção dos serviços na sua casa. Isto tudo pode ser encarado como um desafio estimulante para todos os envolvidos no ecossistema: academia, fabricantes, emissoras, agências de publicidade e claro, as empresas de software – os mais novos “integrantes” no mundo da TV.

Mas afinal, o que é interatividade? No contexto de TV a interatividade “ideal” pode ser definida como sendo a participação colaborativa dos telespectadores/usuários, gerando feedback que permita adaptação do conteúdo originalmente transmitido. Ou seja, a informação que você fornece altera o conteúdo que você esta visualizando. Nesse processo cíclico os usuários passam a ser co-autores do conteúdo propagado, não existindo distinção clara entre quem envia e quem recebe a informação, e sim uma bidirecionalidade entre eles (figura abaixo). Considerando esse cenário, podemos até falar na formação da TV 2.0, onde o usuário deixa de ser simplesmente passivo e começa a atuar como também provedor de conteúdo.

Que maravilha… Aplicativos, internet e interatividade na TV. Então teremos um PC na TV, é isso? NÃO. São 2 “paradigmas” distintos. Na internet a principal maneira de “contar uma história” é baseada em texto, muitas vezes com um caráter informal onde o usuário é quem seleciona o conteúdo que deseja – imagem e vídeo é algo quase sempre complementar. Na TV a imagem sempre vai prevalecer, o vídeo é tudo. O “tom” é mais formal, e o lado cultural ainda predomina ao juntar família e amigos para assistir jogos, filmes entre outros em frente a uma única TV, diferente do PC onde a experiência é mais individual. Por fim, a TV alcança mais de 95% da população, enquanto que mais de 112 milhões de brasileiros ainda não usam a internet [ComScore/2010].

Então o que esperar da televisão interativa?

Essa é uma das interrogações que só o tempo vai responder… Interatividade televisiva é algo “ainda novo” no mundo todo. Nos países que possuem um padrão para TV Digital aberta interativa, nenhum modelo realmente vingou. Aqui no Brasil existe forte apoio do governo, apesar da demora nas definições normativas.

Desde quando existe interação com a TV? Para responder essa pergunta, podemos fazer uma viagem ao passado vendo alguns exemplos que já aconteceram na TV analógica (Analógica? Isso mesmo ):

	Wink Dink and You, 1953 – programa interativo na TV analógica Preto e Branco. Uso de Lápis e “Papel”… Isso mesmo. Apresentador “controla” o ritmo no conteúdo propagado e você na sua casa participa através de um plástico “estaticamente colado” na tela da TV. Sensacional – isso em 1953.
	TV POWWW, 1978 – Game interativo baseado no jogo Shotting Gallery, ganhou inúmeras variantes. Chegou ao Brasil através do SBT em 1984. Telespectador ligava para a emissora, e falava “POW” para atirar.
	Você Decide, 1992 – Case de sucesso para Globo onde os telespectadores escolhiam o bloco final do programa através do telefone.
	Big Brother, 2002, Criado pela Endemol e reproduzido no Brasil pela Globo. Telespectador interage por SMS, telefone e internet escolhendo qual participante deve ou não ficar na casa.

Existem vários outros exemplos, mas esses são marcos que mostram como muito antes da digitalização a interatividade já podia ser feita.

E interação na TV Digital? As transmissões começaram em 2007, e até agora nada de aplicativo. OPA !! Em 2007 foi “lançada” a TV Digital ABERTA. Vale lembrar que a SKY, NET etc. realizam transmissão digital bem antes de 2007, e o C.E.S.A.R desenvolve aplicativos para TV fechada desde 2006. A empresa OpenTV domina o mercado global de interatividade na TV fechada, e tem o C.E.S.A.R como parceiro oficial no desenvolvimento de aplicativos – Isso mesmo . Abaixo a tela da aplicação que foi ao ar pela NET Digital na Copa do Mundo de 2006, carnaval do Rio e Pan-Americano 2007.

Imagens do projeto CESAR/NET

Com mais de 3 anos de TV Digital brasileira, a interatividade ainda não deslanchou. O sistema, apesar de especificado, é raro nas TVs comercializadas. O governo ainda não liberou o conjunto de testes (Test Suite) conforme prometido, fazendo com que as poucas TVs no mercado não tenham passado por testes oficiais. Também não existe um modelo de negócios que estimule o desenvolvimento por parte da comunidade de software.

Tecnicamente falando, o middleware Ginga (plataforma da TVD Aberta) permite execução de aplicações NCL e Java, podendo estas se comunicar entre si, mas as complexidades principais do desenvolvimento de aplicativos não são de caráter técnico, e sim comportamentais e políticos. Desenvolver aplicações para TV aberta é atingir público em massa – ou seja, mais de 180 milhões de pessoas (95% da população) – e quem são os principais usuários da TV brasileira?

Imagens retiradas dos blogs: Pensando Bem e Blog do Valente

Isso mesmo: crianças, idosos e pessoas simples que muitas vezes nunca interagiram com uma aplicação.

Enquanto o próprio governo não apresenta definições claras para a TV Digital aberta, a Internet-TV ou TV conectada deslancha com fabricantes e provedores de conteúdo apostando forte no mundo todo.

Imagens retirados dos sites: slashgear.com e samsung.com

Aqui no Brasil podemos falar que banda larga ainda está longe de ser algo popular, mas no ritmo atual a TV ligada à internet parece ser bem mais promissora. Achar esse tipo de TV no mercado é bem mais fácil que encontrar o famoso selo DTVi (TVs com Ginga) nas “prateleiras” das lojas, sem falar que o modelo de comercialização de aplicativos via AppStore já é um sucesso. Um bom exemplo é a Samsung, que já registrou mais de 2 milhões de downloads no mundo todo através de sua loja de aplicativos (Samsung TV Apps).

Bom, uma coisa é certa: quem vai ditar o ritmo destas tecnologias é o público. A TV analógica vai cedendo espaço cada vez mais para a TV Moderna (Digital ou conectada), e cabe a nós consumidores escolher a melhor opção – afinal, interagir na TV precisa e muito da avaliação daqueles que realmente validam o mercado: os usuários.

Em outro momento falaremos sobre os desafios ligados ao telespectador, e outros relacionados à TV Digital Aberta.

Jorge Fonsêca – @jcbfonseca (From CESAR TV Lab).

As we’ve learned, FormMgr is another Form in the application responsible for Forms management. The FormMgr just change screens in bada. FormMgr don’t present labels, images, etc…

Steps:
1. create your Forms (Forms that app needs);

In this post I will just send an information from one Form to another (easiest way).
Note that in Forms properties you must set Form name, Labels name, Editfields names, …

2. update application class to start with FormMgr (and not with FormMain)

bool
FormManagerSample::OnAppInitializing(AppRegistry& appRegistry)
{
 result r = E_SUCCESS;
 FormMgr *pFormMgr = new FormMgr();
 if(pFormMgr->Initialize())
 {
  r = Application::GetInstance()->GetAppFrame()
                    ->GetFrame()->AddControl(*pFormMgr);
  TryCatch(r == E_SUCCESS, , GetErrorMessage(r));
  pFormMgr->SetStarterForm(FormMgr::REQUEST_MAINFORM,
                                         null);
 }

 return true;

 CATCH:
  SetLastResult(r);//we'll see this soon, in next posts
  return false;
}

3. create FormMgr.cpp and FormMgr.h
Now, let’s see FormMgr code…
FormMgr.h>>

#ifndef _FORMMGR_H_
#define _FORMMGR_H_

#include
#include
#include
#include
#include
#include 

class FormMgr :
 public Osp::Ui::Controls::Form //derived from Form;
{
public:
 FormMgr(void);
 virtual ~FormMgr(void);

public:
 bool Initialize(void);
 bool SetStarterForm(RequestId requestId,
 Osp::Base::Collection::IList* pArgs);
 static const RequestId REQUEST_MAINFORM = 100; //Form 1
 static const RequestId REQUEST_RESULTFORM = 101; //Form 2

protected:
 void SwitchToForm(RequestId requestId,
 Osp::Base::Collection::IList* pArgs);
 Osp::Ui::Controls::Form *__pPreviousForm;
 FormMain* __pMainForm; //Main Form - will send the data
 FormResult* __pResultForm; //Result Form - will receive the data

public:
 virtual void OnUserEventReceivedN(RequestId requestId,
Osp::Base::Collection::IList* pArgs);
};

#endif

FormMgr.cpp>>

#include "FormMgr.h"
#include "FormMain.h"
#include
#include "FormResult.h"

using namespace Osp::App;
using namespace Osp::Base;
using namespace Osp::Ui;
using namespace Osp::Ui::Controls;

FormMgr::FormMgr(void)
{
 __pPreviousForm = null;
 __pMainForm = null;
 __pResultForm = null;
}

FormMgr::~FormMgr(void)
{
}

bool
FormMgr::Initialize(void)
{
 result r = E_SUCCESS;
 //FormMgr must be constructed...
 r = Form::Construct(FORM_STYLE_NORMAL);
 if (r != E_SUCCESS)
 {
  SetLastResult(r);
 }else{
  //and you must set a name!
  SetName(L"FormMgr");
 }
 return r == E_SUCCESS;
}

bool FormMgr::SetStarterForm(RequestId requestId,
Osp::Base::Collection::IList* pArgs)
{
 Form *pCurrentForm = Application::GetInstance()->GetAppFrame()
                      ->GetFrame()->GetCurrentForm();

 if (pCurrentForm == this)
  SwitchToForm(requestId, pArgs);
 else
  return false;

 return true;
}

void FormMgr::OnUserEventReceivedN(RequestId requestId,
Osp::Base::Collection::IList* pArgs)
{
 SwitchToForm(requestId, pArgs);
}

void FormMgr::SwitchToForm(RequestId requestId,
  Osp::Base::Collection::IList* pArgs)
{
 result r = E_SUCCESS;
 Frame *pFrame = Application::GetInstance()
                 ->GetAppFrame()->GetFrame();
 //BaseForm is adopted to facilitate a large number of Forms...
 BaseForm* pBaseForm = null;

 switch (requestId)
 {
 //MAIN FORM
 case REQUEST_MAINFORM:
 {
  if (null == __pMainForm)
  {
   __pMainForm = new FormMain();
   if(!__pMainForm->Initialize())
   {
       TryCatch(false, , GetErrorMessage(r));
   }
   r = pFrame->AddControl(*__pMainForm);
   TryCatch(r == E_SUCCESS, , GetErrorMessage(r));
  }
  r = pFrame->SetCurrentForm(*__pMainForm);
  TryCatch(r == E_SUCCESS, , GetErrorMessage(r));
  __pMainForm->RequestRedraw(true);
  if (__pPreviousForm != null) {
    if (__pPreviousForm != __pMainForm)
     pFrame->RemoveControl(*__pPreviousForm);
   }
   __pPreviousForm = __pMainForm;
  break;
 }
 //RESULT FORM
 case REQUEST_RESULTFORM:
 {
  FormResult* formResult = new FormResult();
  if (formResult->Initialize()) {
   //Passing parameters from FORMMAIN to FORMRESULT
   formResult->ShowResult(pArgs);
   //BaseForm is now a FormResult
   pBaseForm = formResult;
  }
  break;
 }
 default:
  break;
 }

 if (null != pBaseForm) {
  //It can be used for a large number of Forms
  r = pFrame->AddControl(*pBaseForm);
  TryCatch(r == E_SUCCESS, , GetErrorMessage(r));
  r = pFrame->SetCurrentForm(*pBaseForm);
  TryCatch(r == E_SUCCESS, , GetErrorMessage(r));
  pBaseForm->RequestRedraw(true);
 }

 if (__pPreviousForm != null) {
  if (__pPreviousForm != __pMainForm)
   pFrame->RemoveControl(*__pPreviousForm);
 }
 __pPreviousForm = pBaseForm;

 if (null != pArgs) {
  pArgs->RemoveAll(true);
  delete pArgs;
  pArgs = null;
 }

 return;
 CATCH:
 //Avoid Memory Leak
  SetLastResult(r);
  if(null != __pMainForm)
  {
   delete __pMainForm;
   __pMainForm = null;
  }
  if(null != pBaseForm)
  {
   delete pBaseForm;
   pBaseForm = null;
  }
 return;
}

4. Link FormMgr and new Forms…
Ok, we know how to update application class to call FormMgr, understood FormMgr… Now, lets see how to call FormMgr to switch the Forms and how to receive Args.

From FormMain to FormResult: sending and presenting data texts…
FormMain.cpp>>

void
FormMain::OnActionPerformed(const Osp::Ui::Control& source,
int actionId)
{
 FormMgr *pFormMgr = null;
 Frame *pFrame = null;

 switch(actionId)
 {
        //If Button OK is clicked
 case ID_BUTTON_OK:
  {

//Get editField control
EditField * editField = static_cast(GetControl(L"IDC_EDITFIELD1"));
//Get editField content
String* strData = new String(editField->GetText());
   ArrayList * list = new ArrayList;
   list->Construct(1);
   list->Add(*strData);
//Get Frame Instance
pFrame = Application::GetInstance()->GetAppFrame()->GetFrame();
   if(null != pFrame)
   {
//Get FormMgr Control
    pFormMgr = static_cast (pFrame->GetControl("FormMgr"));
   }
   if (null != pFormMgr)
//Send an user event to FormMgr: note that
//you must say the Form to be presented and the Args.
//In this example, FormMgr will consider
//REQUEST_RESULTFORM switch case.
pFormMgr->SendUserEvent(FormMgr::REQUEST_RESULTFORM, list);
  break;
  }
 default:
  break;
 }
}

After sending… this parameters will be considered in void FormMgr::SwitchToForm(RequestId requestId, Osp::Base::Collection::IList* pArgs) function.

To receive the parameters, lets see FormResult example:
FormResult>>

void
FormResult::ShowResult(Osp::Base::Collection::IList * pArgs)
{
 String * strResultFromFormMain = static_cast<String*>
                                  (pArgs->GetAt(0));
 Label * lblResultado = static_cast<Label *>
                                  (GetControl(L"IDC_LABEL1"));
 lblResultado->SetText(*strResultFromFormMain);
}

This example is available HERE!

Thanks for your visit!

Feel free to ask/suggest/comment.
Twitter: @oliveiraeduardo

In general, I don’t like large posts, but I’m intending to facilitate things here
Form Manager will be detailed in two posts

We’ve seen a lot of bada concepts, bada environment, bada tools, bada docs and we’ve seen a first bada app.

Now, let’s see how to switch forms in bada…

What are Forms?

The Form provides the top level container with an indicator bar, soft key, and title bar. It is attached to a Frame. The Frame provides the main window for an application. There can be only 1 frame, however we can have a lot of forms in bada.

As your applications become more complex, it won’t be enough to have one form only.

Let’s start creating a new Form Manager Sample Code…

As we know, we must create a bada Form Based Project

And after these steps, we’ll see our project in workspace.

If you ckeck the code into the header (FormMain.h) you’ll see the declaration of the form’s class.

class FormMain :
 public Osp::Ui::Controls::Form,
 public Osp::Ui::IActionEventListener
{

Every Form are derived from Osp::Ui::Controls::Form.

The Form is created in FormMain.cpp, on Initialize() function.

bool
FormMain::Initialize()
{
 // Construct an XML form
 Construct(L"IDF_FORMMAIN");

 return true;
}

Note that the construct parameter refers to Form name, that could be updated in Form properties, as shown below.

Once you have your form’s class ready, you will need to show it somehow to the user. For such purposes we have to go to the application’s class. The FormMain.cpp, in this example, is not the main class of the project so it must be explicity initialized. When we create a bada project, the class that has the exact name of the project is the main class of the project (application class). In this example, FormManagerSample is the application class.

In FormManagerSample.cpp, you can find a callback function which is called on application’s start: OnAppInitializing()

bool
FormManagerSample::OnAppInitializing(AppRegistry& appRegistry)
{

 // TODO:
 // Initialize UI resources and application
 // specific data.
 // The application's permanent data and context
 //can be obtained from the appRegistry.
 //
 // If this method is successful, return true;
 //otherwise, return false.
 // If this method returns false, the application
 // will be terminated.

 // Uncomment the following statement to listen to
 //the screen on/off events.
 //PowerManager::SetScreenEventListener(*this);

 // Create a form
 FormMain *pFormMain = new FormMain();
 pFormMain->Initialize();

 // Add the form to the frame
 Frame *pFrame = GetAppFrame()->GetFrame();
 pFrame->AddControl(*pFormMain);

 // Set the current form
 pFrame->SetCurrentForm(*pFormMain);

 // Draw and Show the form
 pFormMain->Draw();
 pFormMain->Show();

 return true;
}

And… if you need a lot of Forms (screens)?
Bada suggests FormMgr (code is available in SDK_FOLDER\workspace\UiControls\src\FormMgr.cpp). You can just add UiControls project to your workspace by accessing “bada SDK Samples” view (as shown here).

What is FormMgr?
Another Form in the application responsible for Forms management. The FormMgr just change screens in bada. FormMgr don’t present labels, images, etc…

Let’s better understand FormMgr in next post!

Thanks for your visit!

Next post: Form Manager – How to change screens in bada apps (part 2)

Feel free to ask/suggest/comment.
Twitter: @oliveiraeduardo

Quick steps:

1. Install device driver (example: SDK_FOLDER\Tools\Wave-Driver-V5_02_0_0\Setup.exe for Wave or
SDK_FOLDER\Tools\WaveWQ-Driver-V4_50_7_1 for others);
2. Turn on “Mass storage” on your device (just plug your USB cable and you’ll be asked);
3. Copy rootCACert into a device folder that you could find later (rootCACert location: SDK_FOLDER\Tools\sbuild\rootCACert.cer);
4. Install the certificate on mobile phone;
5. Build your Eclipse project as Target Debug (with device connected via USB);
6. Turn on “USB debugging” on your device (just plug your USB cable and you’ll be asked);
7. Run your project as “bada Target Application”;

That’s it

Thanks for your visit!

Next post: Form Manager – How to change screens in bada apps

Feel free to ask/suggest/comment.
Twitter: @oliveiraeduardo

Original Post: http://mobilecoding.blogspot.com/

– Para mais informações acesse o blog Bytes don’t Bite –

Let’s create our first bada app…

1. Open your bada SDK and create a bada project as shown in Fig. 1

Figure 1. Creating your bada project

2.Select “bada Form Based Application” and give a project name, as shown in Fig. 2

Figure 2. Give a name to your bada project

3. Device Configurations is default… you can just click next button, as presented in Fig. 3. For manifest.xml details, click here and select Generate a New Application Profile link.

Figure 3. Device Configurations

4. Select bada SDK and language package, as shown in Fig. 4

Figure 4. bada SDK

5. As you created a bada Form Based App, now you must give a name to your Form, as shown in Fig 5.

Figure 5. Give a name to your Form

6. Select your device screen size, as presented in Fig. 6. You must select the resolution based on the device that you are intended to emulate. Samsung Wave has 480×800 resolution. The form will be created based on this size.

Figure 6. Auto-scaling Settings

7. Fill the basic settings… as shown in Fig. 7

Figure 7. Basic Settings

8. Select the configurations in which you want to deploy, as presented in Fig. 8. I suggest you to select all the options. Let’s better understand each one:
Simulator-Debug: Emulate your app on windows;
Target-Debug: Allows you to debug your app in the device;
Target-Release: Compiles your code to be released in Samsung Apps (AppLog is disabled in this option).

Figure 8. Select Configurations

9. The next screen presents to you a project summary (Fig. 9)

Figure 9. Summary

10. Now, you’re ready to start developing. Your project was created, as shown in Fig. 10

Figure 10. bada project

If you want to run your default app, you must select your build option, as presented ing Fig. 11. To emulate in Windows, choose Simulator-Debug option.

Figure 11. bada build

Now, you can run your app, as shown in Fig. 12

Figure 12. Running your first bada app

In this example, we’ve selected 240×400 resolution, so we’ve got a Samsung Scotia skin while emulating (Fig. 13). Note that the FORM was created in 240×400 folder.
If you need to edit the Form you must always edit the Form in Resource view. Don’t try to edit the xml file (you can get serious problems).

Figure 13. Scotia emulation (240×400 screen size)

You can see some emulation options, such as Event Injector, right clicking over the device skin, as shown in Fig 14.

Figure 14. Emulation options

Now, a very important tip for you.
Interested in bada sample codes?
In the IDE, select the “bada SDK Samples” view (Fig. 15 and Fig. 16). You’ll see a lot of sample codes.
Double-click and the project will be available into your workspace. Enjoy the codes

Figure 15. Select other views…

Figure 16. Select bada SDK Samples

Today we’ve configured our first bada project!
Now, we’re ready to start seeing bada codes

Thanks for your visit!

Next post: How to enable USB debugging on your bada phone

Feel free to ask/suggest/comment.
Twitter: @oliveiraeduardo

Original post: http://mobilecoding.blogspot.com

The main idea here is to do something simple, just to help you to start developing for mobile technologies. I will present you concepts, tools, good practices, code solutions, etc…

Feel free to contact if you need any help

Why bada?
- I am working with since september (C.E.S.A.R / Samsung Internship);
- I am involved in the development of Bada apps for Samsung;
- Excellent support (docs, forum, tutorials);
- Wide acceptance in the market;
- bada Ecosystem – Samsung App Store;

What is bada?

Samsung bada is a smartphone platform released in 2010. The word “bada” means “ocean” in Korean. Samsung Wave is the first bada-powered phone.
According to Samsung, for developers, bada will bring a new blue ocean of mobile applications. For customers, they will have a wider choice of smartphones with cost-effective yet powerful bada-powered phones.

Bada still don’t support any service or daemon in background (may be in Bada 2.0).
There is no multi-tasking in Bada. Therefore, one user-developer app will be running at a time but more than one Bada system app can run simultaneously. Bada provide Application Controls (detailed post coming soon) as an alternative for apps that need services.

How Samsung see bada

The vision of bada is “Smartphone for Everyone“. bada’s main goal is not to compete with other existing smartphone platforms. Instead, bada will turn Samsung’s conventional customers into smartphone users by providing cost-effective smartphones. This means that bada will open and extend a new smartphone market, which does not exist in the current mobile market.

bada will create a new smartphone market, which will turn into a new blue ocean

Samsung bada OS presentation

Ecosystem Support

To help customers and developers, bada provides well-made ecosystem support. Samsung bada provides an application store, developer support systems with useful information, and a developer-friendly certification process.

For more information: Samsung App Store.

How do you configure your development environment?

We’ve worked with:
- bada SDK v1.2.1.
The bada SDK installation also contains the bada IDE.
Before installing the SDK, make sure that your computer fulfills the system requirements and that the required software has been installed.
* Microsoft Windows® XP, Windows® Vista or Windows® 7 operating system.
* At least 1.4 GB of RAM memory.
* At least 1.8 GB of free disk space.
* Local administrator rights.
* The bada Simulator screen size is 480 * 800. If the screen resolution of your computer monitor is under 800, the Simulator does not show normally for applications that use OpenGL®.

NOTE: For devices with 240×400 screen size (example: Samsung Wave 525), we’ve worked with SDK v1.1.0.

More details here

References

- Tutorials available in SDK\Documents\Tutorial folder.
- Developer bada Site
- BadaDev

- An Introduction to Bada: A Developer’s Guide

- Introduction to Bada (part 1)
- Introduction to Bada (part 2)
- Introduction to Bada (part 3)

- C++ Reference

Thanks for your visit!

Next post: Creating our first bada app!

Feel free to ask/suggest/comment.
Twitter: @oliveiraeduardo

Original post: http://mobilecoding.blogspot.com