O Google Glass é uma tecnologia futurística que promete revolucionar a forma como usamos nossos dispositivos para interagir com o mundo. Mas, do ponto de vista do desenvolvedor, o que há de tão especial no desenvolvimento para o vidro? A resposta é “Nada!” Na verdade, da perspectiva de um experiente desenvolvedor Android , O Google Glass é apenas mais um dispositivo Android com uma tela muito pequena e recursos limitados!
O fato de qualquer pessoa com conhecimento de desenvolvimento Android poder se tornar um membro desta comunidade de “elite” de evangelistas futuristas de tecnologia vestível é parte do que torna o Google Glass tão incrível. Claro, você precisará aprender algumas coisas novas, como a diferença entre “Imersão” e “Cartão Ativo”, mas como você verá, a curva de aprendizado não é íngreme.
O objetivo deste tutorial do Google Glass é estabelecer as bases para o desenvolvimento de qualquer aplicativo Glass, por meio da criação de um aplicativo simples que engloba todas as etapas comuns. Meu objetivo é economizar seu tempo em pesquisas e tentativas e erros, e permitir que você execute seu primeiro aplicativo Glass o mais rápido possível.
Neste tutorial, primeiro veremos como configurar seu ambiente de desenvolvimento e conectar o Google Glass ao computador. Em seguida, criaremos um aplicativo Glass “Hello World” simples que incluirá comandos de voz personalizados e integração com o menu Iniciar do Glass. Depois de desenvolver e executar seu primeiro aplicativo no Glass, você aprenderá os fundamentos da navegação em aplicativos do Glass, menus ativados por voz e criação de conteúdo dinâmico.
O Glass ainda está em uma espécie de fase de “teste beta”, para o qual o Google inventou o termo “Programa Explorer”. Seja qual for o seu nome, o Glass ainda não é algo que você pode obter na loja como um smartphone. Infelizmente, as ferramentas de desenvolvimento do Android ainda não têm um emulador que você possa usar para desenvolver seu aplicativo sem hardware real.
Portanto, para executar e depurar seu aplicativo, você precisará colocar as mãos em um Google Glass real por meio do Programa Explorer. Para participar do programa visite a página de inscrição e inscreva-se para obter acesso. Depois de aprovado, prepare seu cartão de crédito e aguarde a entrega do copo. A versão Explorer do Glass atualmente custa US $ 1.500, mas o preço deve cair significativamente antes que o dispositivo chegue às lojas.
Devido à falta de qualquer emulador, é necessário que você tenha um hardware Google Glass real para desenvolver o aplicativo neste tutorial (ou qualquer aplicativo Glass), mas se comprar um estiver fora do seu orçamento, não desanime - ele valerá a pena acompanhar de qualquer maneira. O que ficará claro no tutorial é que desenvolver para o Glass é quase o mesmo que desenvolver para qualquer outra plataforma Android!
Se você ainda não usou o Google Glass, mas está tão animado quanto eu, dê uma olhada nestes dois vídeos, pois eles devem fornecer informações suficientes para entender os fundamentos da interface do usuário.
Existem vídeos ainda mais úteis para configuração e navegação Aqui e muitos mais detalhes sobre a interface do usuário Aqui .
este Desenvolvedor do Google Glass tutorial faz as seguintes suposições:
Tudo bem, vamos começar!
A primeira coisa que você precisa fazer é habilitar o modo de depuração em seu Glass. Você tem que fazer algo assim em cada dispositivo Android que usa para o desenvolvimento de seus aplicativos, então isso pode ser familiar. Para habilitar a depuração, deslize para “ Definições '->' Informação do dispositivo ”E toque em para abrir o menu do dispositivo. Selecione “ Ativar depuração ”E será ativado.
Em seguida, você precisa preparar seu ambiente de desenvolvimento. A versão atual do Google Glass requer que você use a API versão 19, portanto, certifique-se de que esteja instalada. Além disso, você precisa ter o Glass Development Kit instalado. Use o Android SDK Manager para instalar esses dois pacotes, caso ainda não tenha feito isso.
Então, vamos fazer nossa primeira peça de “Glassware”. (Sim, o Google cunhou outro termo! “Glassware” é o nome de qualquer aplicativo executado no Google Glass). Começaremos desenvolvendo um bom e velho 'Olá, mundo!' inscrição. Como a maioria dos principais ambientes de desenvolvimento Android, o Android Studio preenche automaticamente novos aplicativos com um modelo para exibir essa frase famosa. Como resultado, obtendo “Hello World!” instalado e funcionando é apenas um exercício de implantação de aplicativo fundamental.
No Android Studio, clique em “ Novo projeto ”E preencha o formulário do projeto. Você pode usar algo semelhante a este:
Ao selecionar fatores de forma e API, certifique-se de selecionar “ Vidro ”E API 19
Selecione “ Atividade de Imersão ”Como sua atividade inicial.
Você se lembra de que mencionei que você precisará aprender a diferença entre Immersion e Live Card? Do Google Artigo sobre interface do usuário explica os diferentes tipos de telas de vidro. Aqui está um breve resumo:
Cartas vivas são adicionados à linha do tempo do Glass e exibem informações em tempo real sobre algo por meio de atualizações de alta frequência. Eles estão constantemente sendo executados em segundo plano, mesmo quando os usuários estão interagindo com cartões diferentes. Isso permite aos usuários realizar multitarefas com acesso constante a diferentes tipos de informações em tempo real.
Imersões são telas totalmente personalizáveis que funcionam fora da experiência da linha do tempo. Isso permite que você projete sua própria IU e processe a entrada do usuário da maneira que achar conveniente. É isso que vamos usar!
Na próxima tela do assistente, deixe os valores padrão para “ Nome ”E“ Título ”E clique em“ Terminar ”.
Depois de Gradle cuida de suas dependências e deixa seu projeto pronto, é hora de colocar seu Glass e conectá-lo. Agora, este é um desenvolvimento futurista!
Supondo que todos os drivers ADB do Android estejam no lugar e que o Glass seja reconhecido pelo sistema, você deve colocar o Glass na lista de dispositivos.
Se esta for a primeira vez que você conectou seu dispositivo a um computador, seu Glass solicitará aprovação / confiança para ser estabelecida. Basta tocar no vidro para permitir a conexão e você deve estar pronto.
Clique em “ Corre ”E implantar seu“ APK padrão ”com“ MainActivity ”como a atividade de inicialização para iniciar no dispositivo“ USB ”.
Após alguns segundos, você deverá ver algo assim na tela do Glass:
Viva! Seu aplicativo está sendo executado no Glass! E tudo o que você precisa fazer é preencher alguns valores padrão ao criar o aplicativo!
Como não especificamos de forma diferente, o Glass mostrará seu aplicativo com o nome “Mostrar demonstração”. Se você deslizar de volta para a tela inicial e tocar para abrir o menu do aplicativo, você o verá listado assim:
Ok, você o colocou em execução, mas não se parece com um aplicativo Glass real, e você não quer que o aplicativo seja iniciado por “Mostrar demonstração”.
Neste tutorial, vamos apenas ajustá-lo um pouco para ter uma sensação real.
Primeiro, você não quer ocupar nada da sua pequena tela do Glass com esta barra de título de atividade “Hello World Immersion” feia de cabeçalho, e você definitivamente não quer que sua tela fique cinza com fonte preta. Para corrigir isso, só precisamos mudar o tema em nosso Android e deixar o Glass OS cuidar disso.
Aberto res/values/styles.xml
para edição. Deve ter o seguinte conteúdo:
android:Theme.Holo.Light
Basta alterar android:Theme.DeviceDefault
para AndroidManifest.xml
. Isso deve cuidar do layout e das cores do aplicativo automaticamente, usando o tema padrão do Glass.
quais são os diferentes tipos de llc
Ok, a próxima coisa que queremos fazer neste tutorial de desenvolvimento do Glass é configurar nosso aplicativo para ter um nome apropriado e uma boa inicialização controlada por voz. Abra seu Manifesto Android (
DEVELOPMENT
tag:
DEVELOPMENT
O motivo pelo qual deseja usar voice_trigger.xml
permissões são para que você possa jogar com controles de voz personalizados. O Google é bastante rígido sobre quais comandos de voz são permitidos em aplicativos do Glass aprovados, e todos os novos comandos devem ser aprovados. Como este tutorial é para fins de aprendizado e você não enviará este aplicativo para a loja oficial do Glassware, não se preocupe com isso. Basta ligar res/xml/
permissões e você terá acesso a “comandos de voz não listados”. Para obter mais informações sobre isso, leia esta página GDK .
Aberto android:label='@string/app_name'
para edição. É aqui que o comando de voz para iniciar seu aplicativo é definido. Deve estar localizado em @string/app_name
pasta. Você deve obter conteúdo semelhante a este:
Hello Glass
Em vez de dizer 'Mostre-me uma demonstração' para iniciar nosso aplicativo, vamos apenas dizer o nome do aplicativo. Altere o conteúdo do arquivo para:
android:label='@string/app_name'
Se você voltar ao seu arquivo de manifesto, poderá notar que o res/values/strings.xml
foi atualizado automaticamente para usar também a string de recurso app_name
em vez do codificado Hello Glass
valor como era antes. Se esta configuração não foi atualizada, certifique-se de definir o valor para voice_trigger.xml
.
E qual é o nome do seu aplicativo, exatamente? Se você abrir network='true'
, seu FEATURE_VOICE_COMMANDS
deve ser listado como:
onCreate
Isso deve encerrar o seu primeiro aplicativo Hello Glass. Vamos ver como funciona agora!
Na tela inicial, você pode dizer “Ok copo” para abrir o menu de voz. Seu aplicativo agora está na lista de comandos ativados por voz.
Com este tutorial para guiá-lo, esta é a aparência da tela inicial do seu aplicativo Glass agora.
Se você diz ' Olá copo ”Seu aplicativo deve iniciar e você deve obter uma experiência padronizada do Glass:
Se não quiser usar sua voz para ativar o aplicativo, basta tocar em na tela inicial e você verá que seu aplicativo está disponível no menu:
É muito importante que você preste muita atenção à interface de seu aplicativo e à interação de seus usuários com ele. Lembre-se de que seus usuários nem sempre estão em condições de usar a voz - por exemplo, enquanto assistem a uma palestra ou apresentação. Como alternativa, eles podem estar com as mãos ocupadas e não conseguir usar o toque. Eu sugiro que você forneça interação de menu de toque e voz sempre que possível, permitindo que seus usuários naveguem por seu aplicativo usando voz e touchpad em paralelo.
Agora que você está confortável com o desenvolvimento do Glass e criou o Hello Glass, é hora de criar um aplicativo real que colocará os novos recursos do Glass para funcionar. Vamos construir um aplicativo que permite navegar pelos perfis dos principais desenvolvedores do ApeeScape com base na plataforma de desenvolvimento.
A estrutura de nosso aplicativo de exemplo do Glass será simples:
Vamos recapitular rapidamente o que você já adicionou ao seu conhecimento do Android:
Usando esse conhecimento, coloque seu novo aplicativo em funcionamento. Você pode atualizar o aplicativo Hello Glass acima ou iniciar um novo aplicativo seguindo as mesmas etapas. Nomeie este aplicativo “ Top Finder ”E faça o seu MainActivity
arquivo tem esta aparência.
getWindow().requestFeature(WindowUtils.FEATURE_VOICE_COMMANDS);
O res/menu
restrição diz ao vidro para verificar a conectividade de rede ao iniciar este aplicativo, que precisaremos conectar às listas de desenvolvedores do ApeeScape. Se não houver conexão, o Glass exibirá uma mensagem de aviso.
Vamos deixar a tela inicial do nosso aplicativo mais ou menos assim:
Quando você vê o “Ok copo” mensagem na tela significa que o aplicativo possui menu ativado por voz naquele local. Falando a frase “Ok copo” aqui ativa o menu de voz para este local. Esta frase é predefinida pelo Glass e você não pode alterá-la.
Você pode pensar em “Ok copo” como um “menu de aplicativos”, assim como você usou no desenvolvimento do seu smartphone / tablet, e tem exatamente a mesma função. Assim como você “tocaria” no “ícone do menu de aplicativos” na tela (geralmente 3 pontos ou linhas) para abrir um menu de aplicativos Android, você precisa dizer “Ok copo” para abrir o menu ativado por voz em seu aplicativo Glassware.
A fim de habilitar o “Ok copo” menu que você precisa solicitar main.xml
da API. Para fazer isso, adicione a seguinte linha em onCreatePanelMenu
manipulador em seu MainActivity
:
@Override public boolean onCreatePanelMenu(int featureId, Menu menu){ if (featureId == WindowUtils.FEATURE_VOICE_COMMANDS || featureId == Window.FEATURE_OPTIONS_PANEL) { getMenuInflater().inflate(R.menu.main, menu); return true; } return super.onCreatePanelMenu(featureId, menu); }
Cada atividade que tem esse recurso incluído será renderizada com “Ok copo” texto na parte inferior central.
A próxima coisa que você precisa fazer é criar um menu para a tela principal. Em seu findDevelopers
pasta cria uma nova definição de menu XML chamada public void findDevelopers(String platform){ } @Override public boolean onMenuItemSelected(int featureId, MenuItem item) { if (featureId == WindowUtils.FEATURE_VOICE_COMMANDS || featureId == Window.FEATURE_OPTIONS_PANEL) { switch (item.getItemId()) { case R.id.find_android: findDevelopers('Android'); break; case R.id.find_javascript: findDevelopers('Java Script'); break; case R.id.find_ios: findDevelopers('iOS'); break; } return true; } return super.onMenuItemSelected(featureId, item); }
. Para simplificar, habilitaremos apenas três plataformas de desenvolvedor ApeeScape, mas sinta-se à vontade para fazer as alterações conforme desejar.
Deve ter o seguinte conteúdo:
res/drawable/logo.png
Você deve estar se perguntando por que escolhi títulos de menu bastante longos em vez de simplesmente Android, JavaScript e iOS. Bem, a razão é muito simples. Os caras da equipe de desenvolvimento do Glass ainda estão melhorando o reconhecimento de voz. É prática recomendada usar duas ou três palavras em seus menus para que o Glass as reconheça mais facilmente.
Eu já mencionei que o “Ok copo” O menu não é diferente do menu padrão do aplicativo Android. Anexar um menu a uma atividade é praticamente o mesmo. Basta substituir o MainActivity
manipulador em seu private CardScrollView mCardScroller; private View mView; private GestureDetector mGestureDetector;
e aumente o menu principal que você acabou de criar:
buildView
Agora precisamos adicionar um manipulador de menu. Antes de fazer isso, crie um método vazio denominado private View buildView() { Card card = new Card(this); card.setText(R.string.app_name); card.setImageLayout(Card.ImageLayout.LEFT); card.addImage(R.drawable.logo); return card.getView(); }
. Voltaremos a isso mais tarde para iniciar uma pesquisa e mostrar os resultados. Depois disso, você pode substituir seu manipulador de menu.
onCreate
Agora é hora de tornar a tela inicial de nosso aplicativo de exemplo do Google Glass bonita. Importe um logotipo do ApeeScape em seu aplicativo como protected void onCreate(Bundle bundle) { super.onCreate(bundle); getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON); getWindow().requestFeature(WindowUtils.FEATURE_VOICE_COMMANDS); mView = buildView(); mCardScroller = new CardScrollView(this); mCardScroller.setAdapter(new CardScrollAdapter() { @Override public int getCount() { return 1; } @Override public Object getItem(int position) { return mView; } @Override public View getView(int position, View convertView, ViewGroup parent) { return mView; } @Override public int getPosition(Object item) { if (mView.equals(item)) { return 0; } return AdapterView.INVALID_POSITION; } }); // Handle the TAP event. mCardScroller.setOnItemClickListener(new AdapterView.OnItemClickListener() { @Override public void onItemClick(AdapterView parent, View view, int position, long id) { openOptionsMenu(); } }); mGestureDetector = createGestureDetector(this); setContentView(mCardScroller); }
. Usei esta imagem:
Em seu MainActivity
classe, faça as seguintes alterações.
usar raspberry pi como servidor
Certifique-se de que as seguintes variáveis privadas sejam declaradas no início da aula:
private GestureDetector createGestureDetector(Context context) { GestureDetector gestureDetector = new GestureDetector(context); //Create a base listener for generic gestures gestureDetector.setBaseListener( new GestureDetector.BaseListener() { @Override public boolean onGesture(Gesture gesture) { if (gesture == Gesture.TAP) { openOptionsMenu(); return true; } else if (gesture == Gesture.TWO_TAP) { // do something on two finger tap return true; } else if (gesture == Gesture.SWIPE_RIGHT) { // do something on right (forward) swipe return true; } else if (gesture == Gesture.SWIPE_LEFT) { // do something on left (backwards) swipe return true; } else if (gesture == Gesture.SWIPE_DOWN){ finish(); } return false; } }); gestureDetector.setFingerListener(new GestureDetector.FingerListener() { @Override public void onFingerCountChanged(int previousCount, int currentCount) { // do something on finger count changes } }); gestureDetector.setScrollListener(new GestureDetector.ScrollListener() { @Override public boolean onScroll(float displacement, float delta, float velocity) { // do something on scrolling return true; } }); return gestureDetector; } @Override public boolean onGenericMotionEvent(MotionEvent event) { if (mGestureDetector != null) { return mGestureDetector.onMotionEvent(event); } return false; }
Altere o findDevelopers
método para personalizar o layout do cartão:
DeveloperModel.java
E mude o seu java/models
manipulador para ser assim:
public class DeveloperModel implements Serializable { private String name; public String getName(){ return name; } public void setName(String name){ this.name=name; } private String platform; public String getPlatform(){ return platform; } public void setPlatform(String platform){ this.platform=platform; } private String image; public String getImage(){ return image; } public void setImage(String image){ this.image=image; } }
Como eu disse antes, queremos incluir o menu ativado por toque junto com “Ok copo” , então apenas habilite os gestos como faria em seu aplicativo Android. Adicione os seguintes métodos em CardScrollAdapter
classe:
DeveloperAdapter.java
Deve ser isso! Agora você pode iniciar seu aplicativo e tentar os dois métodos de ativação do menu. Se você diz “Ok copo” você obtém três itens de menu exibidos na tela e, se tocar no vidro, um menu rolável será aberto. Para navegar pelos itens do menu, você pode deslizar para frente e para trás.
Esta é a aparência do menu de voz:
E aqui está o menu de gestos:
Se você selecionar um item de menu, nada acontecerá, pois java/adapters
método ainda não foi implementado.
Continuaremos a usar o layout padrão do Glass Card, com uma imagem à esquerda, texto à direita e algumas informações de rodapé. Para obter mais informações sobre as práticas recomendadas para projetar seus cartões, consulte o Google Glass Guia de estilo .
Nosso perfil de desenvolvedor é definido por propriedades simples:
Então, vamos ter certeza de ter a estrutura adequada de classes em nosso aplicativo. Crie uma nova classe chamada public class DeveloperAdapter extends CardScrollAdapter { private List mCards; private List mData; public DeveloperAdapter(List cards){ this.mCards = cards; } @Override public int getCount() { return mCards.size(); } @Override public Object getItem(int i) { return mCards.get(i); } @Override public View getView(int i, View view, ViewGroup viewGroup) { return mCards.get(i).getView(); } @Override public int getPosition(Object o) { return this.mCards.indexOf(o); } }
em seu ResultsActivity
pasta. Queremos que esta classe seja serializável, pois conterá perfis que estão em uma lista.
MainActivity
Queremos que nossos cartões sejam fortemente vinculados aos dados de nosso perfil de desenvolvedor. Porque o padrão java/com.helloglass
é um pouco genérico em relação ao seu modelo de dados, precisamos estendê-lo e torná-lo nosso. Criar extends Activity
em seu developer.xml
pasta:
ResultsActivity
Não queremos que nossos resultados de pesquisa sejam adicionados à tela inicial do aplicativo, portanto, criaremos uma nova Activity que fará a pesquisa e exibirá os resultados. Crie uma nova atividade, MainActivity
, ao lado de ResultsActivity
(provavelmente em public static final String SEARCH = 'search'; private String mPlatform='Android';
).
Certifique-se de que ResultsActivity
.
Em seguida, precisamos especificar um menu para nossos cartões de perfil de desenvolvedor. Crie um novo menu, MainActivity
, com o seguinte conteúdo:
private CardScrollView mCardScroller; private List mCards; private GestureDetector mGestureDetector;
Para habilitar a passagem de parâmetros entre findDevelopers
e ResultsActivity
adicione as seguintes linhas no início de private void findDevelopers(String platform){ for (int i=1; i<=10; i++){ Card card = new Card(this); card.setText(platform+' '+Integer.toString(i)); card.setTimestamp(platform); card.setImageLayout(Card.ImageLayout.LEFT); card.addImage(R.drawable.ic_person_50); mCards.add(card); } mCardScroller.setSelection(0); }
classe:
MainActivity
Certifique-se de adicionar sua nova atividade ao arquivo de manifesto:
findDevelopers
Configurando a tela inicial de ResultsActivity
e configurar os cartões é muito semelhante ao que fizemos em platform
. Primeiro, verifique se você tem seus cartões e rolagem definidos no início:
public void findDevelopers(String platform){ Intent resultsIntent = new Intent(this, ResultsActivity.class); resultsIntent.putExtra(ResultsActivity.SEARCH, platform); startActivity(resultsIntent); }
Crie um método de pesquisa temporário que voltaremos a implementar posteriormente. Adicionar novos cartões à lista de perfis é tão simples quanto adicionar itens a um Array. Chamaremos esse método de ResultsActivity
também, mas este pertence a @Override public boolean onCreatePanelMenu(int featureId, Menu menu){ if (featureId == WindowUtils.FEATURE_VOICE_COMMANDS || featureId == Window.FEATURE_OPTIONS_PANEL) { getMenuInflater().inflate(R.menu.developer, menu); return true; } return super.onCreatePanelMenu(featureId, menu); }
:
ResultsActivity
Agora volte para o seu openOptionsMenu()
e atualizar onGesture(Gesture gesture)
lá para começar o seu private GestureDetector createGestureDetector(Context context) { // … @Override public boolean onGesture(Gesture gesture) { if (gesture == Gesture.TAP) { openOptionsMenu(); return true; } else if // …
e passe no @Override public boolean onMenuItemSelected(int featureId, MenuItem item) { if (featureId == WindowUtils.FEATURE_VOICE_COMMANDS || featureId == Window.FEATURE_OPTIONS_PANEL) { switch (item.getItemId()) { case R.id.developer_fav: Toast.makeText(getApplicationContext(), 'Favorite', Toast.LENGTH_LONG).show(); break; case R.id.developer_hire: Toast.makeText(getApplicationContext(), 'Message', Toast.LENGTH_LONG).show(); break; case R.id.go_back: break; } return true; } return super.onMenuItemSelected(featureId, item); }
propriedade:
ic_person_50.png
Anexe o menu do desenvolvedor a resdrawable
. Você poderá abrir o menu em qualquer cartão de perfil.
onCreate
Assim como antes, ative os gestos para lidar com o touchpad no Glass quando ResultsActivity
é exibido. Para fazer isso, basta chamar MainActivity
em seu @Override protected void onCreate(Bundle bundle) { super.onCreate(bundle); getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON); getWindow().requestFeature(WindowUtils.FEATURE_VOICE_COMMANDS); mCardScroller = new CardScrollView(this); mCards = new ArrayList(); if(getIntent().hasExtra(SEARCH)){ mPlatform = getIntent().getStringExtra(SEARCH); } findDevelopers(mPlatform); mCardScroller.setAdapter(new DeveloperAdapter(mCards)); // Handle the TAP event. mCardScroller.setOnItemClickListener(new AdapterView.OnItemClickListener() { @Override public void onItemClick(AdapterView parent, View view, int position, long id) { openOptionsMenu(); } }); mGestureDetector = createGestureDetector(this); setContentView(mCardScroller); }
método:
onResume
Além disso, adicione um manipulador de menu às ações relacionadas ao desenvolvedor. Vamos deixar mensagens simples do brinde por enquanto.
onPause
Cada aplicativo deve usar alguns bons elementos visuais, ícones etc. A equipe do Google Glass forneceu um conjunto muito grande de ícones padronizados comuns que são gratuitos para os desenvolvedores do Glass usarem em seus aplicativos. Você pode encontrar um conjunto completo de ícones padrão do Glass, bem como fontes na biblioteca deles
Por enquanto, você só precisa de um ícone MainActivity
, então vá em frente e baixe-o para o seu MainActivity
pasta. Usaremos este ícone em vez de baixar uma foto do desenvolvedor.
A última coisa que resta em nosso tutorial de desenvolvimento de aplicativo Glass por enquanto é substituir nosso
handler em , onde verificaremos qual plataforma de desenvolvimento foi encaminhada de e preencher nossa lista.Você pode sair de
|_+_|e métodos da mesma forma que em
|_+_|.
Se você iniciar seu aplicativo agora, poderá verificar como seus perfis de desenvolvedor são criados dinamicamente com base no menu selecionado em
. Novamente, você tem a opção de exibir seu menu usando “Ok copo” ou tocando no touchpad ou usando a ativação por voz. Esta é a aparência do perfil do “10º desenvolvedor Android” no momento:
Tocar traz o menu de toque:
E dizendo “Ok copo” abre o menu de voz:
Deslize para baixo na lista para voltar à tela inicial do seu aplicativo.
Para encerrar, vamos preencher o menu com informações reais para os 10 principais desenvolvedores do ApeeScape para JavaScript , Android e iOS .
Você precisará baixar suas fotos de perfil e disponibilizá-las em HTTP ou apenas usar URLs diretamente de toptal.com .
Como construir um rastreador da web apenas para obter os nomes dos principais desenvolvedores do ApeeScape pode ser um desvio muito grande para este artigo, criei arquivos JSON para você usar no Android , JavaScript e iOS .
Em seu aplicativo, a primeira coisa que você precisa fazer é solicitar acesso à Internet do seu sistema operacional Android. Adicione a seguinte linha ao seu arquivo de manifesto
|_+_|
Esteja ciente de que o Glass não permitirá que você bloqueie o thread principal usando solicitações HTTP diretamente. Você precisará lidar com downloads de JSON e imagens individuais de maneira assíncrona. Você pode usar uma tarefa assíncrona, criar seu próprio serviço ou intenção de download ou o que preferir em seu trabalho diário.
A construção dessa funcionalidade não é específica do Google Glass, então vou pular os trechos de código. Se você seguir em frente e conseguir que esta última funcionalidade funcione, seus cartões de perfil devem ter a seguinte aparência:
Espero que você tenha se divertido acompanhando este tutorial de desenvolvimento do Google Glass e construindo seu primeiro aplicativo Glassware. Agora, você deve estar confortável com a ideia de que escrever aplicativos para o Glass não é muito diferente de qualquer outra plataforma Android.
Neste ponto, você aprendeu como estender a tela inicial ativada por voz do Google Glass, como criar seus próprios menus ativados por voz e como combinar controles de voz com gestos de toque. Você também deve compreender os conceitos e os blocos de construção básicos da IU do Glass, como cartões, layouts e elementos. Você viu como criar cartões dinamicamente e como navegar entre diferentes atividades.
Para se aprofundar, consulte os recursos para desenvolvedores do Google em developers.google.com/glass . Quando você começar a construir aplicativos mais complexos, será um recurso muito útil.
Lembre-se de que o Glass ainda está em fase de desenvolvimento e provavelmente haverá muitos outros aprimoramentos a serem implementados antes de chegar ao mercado consumidor. Com isso em mente, tenho uma observação importante para você:
Ainda há muito trabalho a fazer sobre reconhecimento de voz e você pode se pegar gritando com seu amigo imaginário enquanto tenta iniciar sua atividade ou preencher algumas informações. Não se preocupe - todos que experimentam o desenvolvimento do Google Glass sentem o mesmo, então você não está sozinho.
A tecnologia vai melhorar e o vidro estará pronto para o varejo em nenhum momento. Com certeza causará uma grande onda assim que chegar às lojas, então espero que você esteja tão animado quanto eu por ser um dos primeiros a estar na vanguarda dessa tecnologia incrível!
Gritar : As capturas de tela neste artigo são feitas usando [email protegido] .