Programação Para Dispositivos Móveis A3

Prévia do material em texto

21/12/22, 00:32 Ilumno
ilumno.sgp.starlinetecnologia.com.br/ilumno/schedule/resultcandidatedetailprint/7886738/39eb5790-ac22-11eb-b60f-02e55ba8948d/ 1/9
Local: Sala 1 - Botafogo - Prova On-line / Andar / Polo UVA Botafogo / POLO UVA BOTAFOGO - RJ
Acadêmico: EAD-IL10315-20224A
Aluno: WALLACE FABIANO PEREIRA
Avaliação: A3
Matrícula: 20212300881
Data: 16 de Dezembro de 2022 - 08:00 Finalizado
Correto Incorreto Anulada  Discursiva  Objetiva Total: 6,50/10,00
21/12/22, 00:32 Ilumno
ilumno.sgp.starlinetecnologia.com.br/ilumno/schedule/resultcandidatedetailprint/7886738/39eb5790-ac22-11eb-b60f-02e55ba8948d/ 2/9
1  Código: 38791 - Enunciado: No desenvolvimento de uma aplicação para dispositivos móveis
baseada no Android é necessário armazenar em um arquivo, de preferência (SharedPreferences),
os valores de entrada da base, da altura em reais e o valor da opção de escolha (opção do tipo
inteiro), sendo 1 para Triângulo e 2 para Retângulo. A aplicação possui o layout e a tabela de
identificadores e relacionamentos a seguir: 
Sabe-se que os componentes já foram declarados, os relacionamentos realizados e as bibliotecas
já foram importadas. A aplicação precisa armazenar os valores de entrada no arquivo de
preferências.Compare e avalie, dentre as opções a seguir, aquela que apresenta corretamente o
conjunto de instruções correto para realizar o armazenamento dos dados no arquivo de
preferências chamado Geometria. Você deve avaliar:A abertura do arquivo.O modo de edição.A
finalização da gravação.
 a) prefs = getSharedPreferences(“Geometria”, MODE _ PRIVATE);SharedPreferences.Editor
prefUsuario = prefs.open();prefUsuario.putFloat(“base”, Float.parseFloat(edt1.getText().
toString())); prefUsuario.putFloat(“altura”,
Float.parseFloat(edt2.getText().toString()));if(rd1.isChecked()){prefUsuario.putInt(“opcao”, 1);}
else{prefUsuario.putInt(“opcao”, 2);}prefUsuario.commit();
 b) prefs = getSharedPreferences(“Geometria”, MODE _ PRIVATE);SharedPreferences.Editor
prefUsuario = prefs.edit();prefUsuario.putFloat(“base”, Float.parseFloat(edt1.getText().
toString())); prefUsuario.putFloat(“altura”,
Float.parseFloat(edt2.getText().toString()));if(rd1.isChecked()){prefUsuario.putInt(“opcao”, 1);}
else{prefUsuario.putInt(“opcao”, 2);}prefUsuario.save();
 c) prefs = getSharedPreferences(“prefUsuario”, MODE _ PRIVATE);SharedPreferences.Editor
Geometria = prefs.edit();Geometria.putFloat(“base”, Float.parseFloat(edt1.getText(). toString())); 
 Geometria.putFloat(“altura”, Float.parseFloat(edt2.getText().toString()));if(rd1.isChecked())
{Geometria.putInt(“opcao”, 1);} else{Geometria.putInt(“opcao”, 2);}Geometria.commit();
 d) prefs = getSharedPreferences(“prefUsuario”, MODE _ PRIVATE);SharedPreferences.Editor
Geometria = prefs.edit();Geometria.putFloat(“base”, Float.parseFloat(edt1.getText(). toString())); 
 Geometria.putFloat(“altura”, Float.parseFloat(edt2.getText().toString()));if(rd1.isChecked())
{Geometria.putInt(“opcao”, 1);} else{Geometria.putInt(“opcao”, 2);}Geometria.save();
 e) prefs = getSharedPreferences(“Geometria”, MODE _ PRIVATE);SharedPreferences.Editor
prefUsuario = prefs.edit();prefUsuario.putFloat(“base”, Float.parseFloat(edt1.getText().
toString())); prefUsuario.putFloat(“altura”,
Float.parseFloat(edt2.getText().toString()));if(rd1.isChecked()){prefUsuario.putInt(“opcao”, 1);}
else{prefUsuario.putInt(“opcao”, 2);}prefUsuario.commit();
Alternativa marcada:
e) prefs = getSharedPreferences(“Geometria”, MODE _ PRIVATE);SharedPreferences.Editor
prefUsuario = prefs.edit();prefUsuario.putFloat(“base”, Float.parseFloat(edt1.getText().
toString())); prefUsuario.putFloat(“altura”,
Float.parseFloat(edt2.getText().toString()));if(rd1.isChecked()){prefUsuario.putInt(“opcao”, 1);}
else{prefUsuario.putInt(“opcao”, 2);}prefUsuario.commit();
Justificativa: Resposta correta:A abertura do arquivo está ao utilizar o identificador Geometria
para o nome do arquivo.O modo de edição está correto ao usar o método prefs.edit();.A
finalização da gravação está correta ao usar o objeto Editor com o método correto:
prefUsuario.commit(). prefs = getSharedPreferences(“Geometria”, MODE _
PRIVATE);SharedPreferences.Editor prefUsuario = prefs.edit();prefUsuario.putFloat(“base”,
Float.parseFloat(edt1.getText(). toString())); prefUsuario.putFloat(“altura”,
Float.parseFloat(edt2.getText().toString()));if(rd1.isChecked()){prefUsuario.putInt(“opcao”, 1);}
else{prefUsuario.putInt(“opcao”, 2);}prefUsuario.commit(); Distratores:A abertura do arquivo não
está correta ao utilizar o identificador PrefUsuario para o nome do arquivo.O modo de edição
está correto ao usar o método prefs.edit();.A finalização da gravação está correta ao usar o objeto
Editor com o método correto: Geometria.commit(), já que o Editor foi identificado como
Geometria.-prefs = getSharedPreferences(“prefUsuario”, MODE _
PRIVATE);SharedPreferences.Editor Geometria = prefs.edit();Geometria.putFloat(“base”,
1,50/ 1,50
21/12/22, 00:32 Ilumno
ilumno.sgp.starlinetecnologia.com.br/ilumno/schedule/resultcandidatedetailprint/7886738/39eb5790-ac22-11eb-b60f-02e55ba8948d/ 3/9
Float.parseFloat(edt1.getText(). toString())); Geometria.putFloat(“altura”,
Float.parseFloat(edt2.getText().toString()));if(rd1.isChecked()){Geometria.putInt(“opcao”, 1);}
else{Geometria.putInt(“opcao”, 2);}Geometria.commit();-prefs =
getSharedPreferences(“Geometria”, MODE _ PRIVATE);SharedPreferences.Editor prefUsuario =
prefs.open();prefUsuario.putFloat(“base”, Float.parseFloat(edt1.getText(). toString())); 
 prefUsuario.putFloat(“altura”, Float.parseFloat(edt2.getText().toString()));if(rd1.isChecked())
{prefUsuario.putInt(“opcao”, 1);} else{prefUsuario.putInt(“opcao”, 2);}prefUsuario.commit();
A abertura do arquivo está correta ao utilizar o identificador Geometria para o nome do arquivo.O
modo de edição não está correto ao usar o método prefs.open(), pois o método correto neste
caso é o edit(), sendo correto usar: prefs.edit();.A finalização da gravação está correta ao usar o
objeto Editor com o método correto: prefUsuario.commit().-prefs =
getSharedPreferences(“Geometria”, MODE _ PRIVATE);SharedPreferences.Editor prefUsuario =
prefs.edit();prefUsuario.putFloat(“base”, Float.parseFloat(edt1.getText(). toString())); 
 prefUsuario.putFloat(“altura”, Float.parseFloat(edt2.getText().toString()));if(rd1.isChecked)
{prefUsuario.putInt(“opcao”, 1);} else{prefUsuario.putInt(“opcao”, 2);}prefUsuario.save();
A abertura do arquivo está correta ao utilizar o identificador Geometria para o nome do arquivo.O
modo de edição está correto ao usar o método prefs.edit();.A finalização da gravação não está
correta ao usar o objeto Editor com o método save(), o correto é a utilização do método commit(),
com a instrução: prefUsuario.commit().-prefs = getSharedPreferences(“prefUsuario”, MODE _
PRIVATE);SharedPreferences.Editor Geometria = prefs.edit();Geometria.putFloat(“base”,
Float.parseFloat(edt1.getText(). toString())); Geometria.putFloat(“altura”,
Float.parseFloat(edt2.getText().toString()));if(rd1.isChecked()){Geometria.putInt(“opcao”, 1);}
else{Geometria.putInt(“opcao”, 2);}Geometria.save();A abertura do arquivo não está correta ao
utilizar o identificador PrefUsuario para o nome do arquivo.O modo de edição está correto ao
usar o método prefs.edit();.A finalização da gravação não está correta ao usar o objeto Editor com
o método save(), o correto é a utilização do método commit(), com a instrução:
Geometria.commit().
21/12/22, 00:32 Ilumno
ilumno.sgp.starlinetecnologia.com.br/ilumno/schedule/resultcandidatedetailprint/7886738/39eb5790-ac22-11eb-b60f-02e55ba8948d/ 4/9
2  Código: 36744 - Enunciado: No desenvolvimento de aplicação para dispositivos móveis no
Android, a entrada de dados digitados pelo usuário deve ser realizada por caixas de textos
(EditText), independentemente de os valores digitados serem do tipo texto ou numérico. Isso
ocorre porque não temos caixas de números, mas caixas de textos que poderãoter o seu
conteúdo convertido para o tipo adequado. Em um projeto, é necessário receber como entrada
de dados o nome, a idade e o CR de um aluno. Os componentes de tela (View) foram
respectivamente identificados por: edit1, edit2 e edit3. Analise as codificações apresentadas a
seguir e selecione aquela que atenderá corretamente às necessidades do projeto, sabendo-se
que os componentes na Controller já foram devidamente declarados com os seguintes
identificadores: ed1 para o nome, ed2 para a idade e ed3 para o CR, além de terem sido
devidamente relacionados aos componentes da tela (View):
 a) String nome = edit1.getText().toString(); int idade =
Integer.parseInt(edit2.getText().toString()); double peso =
Double.parseDouble(edit3.getText().toString());
 b) String nome = edit1.getText().toString(); int idade = edit2.getText().toString(); double
peso = edit3.getText().toString();
 c) String nome = ed1.getText().toString(); int idade =
Integer.parseInt(ed2.getText().toString()); double peso =
Double.parseDouble(ed3.getText().toString());
 d) String nome = ed1.setText().toString(); int idade = ed2.setText().toString(); double peso
= ed3.setText().toString();
 e) String nome = edit1.setText().toString(); int idade =
Integer.parseInt(edit2.setText().toString()); double peso =
Double.parseDouble(edit3.setText().toString());
Alternativa marcada:
b) String nome = edit1.getText().toString(); int idade = edit2.getText().toString(); double peso =
edit3.getText().toString();
Justificativa: Resposta correta:String nome = ed1.getText().toString();int idade =
Integer.parseInt(ed2.getText().toString());double peso =
Double.parseDouble(ed3.getText().toString());Os componentes para uso na Controller são
respectivamente ed1, ed2 e ed3 para o nome, idade e CR. Também é necessário realizar a leitura
do dado de entrada, realizado pelo método getText(). Além disso, também é necessário realizar a
conversão do tipo do dado para os atributos numéricos, sendo para int o Integer.parseInt() e para
double deve-se usar Double.parseDouble(). Distratores:String nome =
edit1.getText().toString();int idade = edit2.getText().toString();double peso =
edit3.getText().toString();Incorreta. Esta opção utiliza como identificadores da controller: edit1,
edit2 e edit3, que são os identificadores definidos para tela (View), e não da Controller, além
disso, não é realizada a conversão dos tipos numéricos. Esta opção realiza a busca dos dados nos
componentes corretamente ao utilizar o método getText().
String nome = ed1.setText().toString();int idade = ed2.setText().toString();double peso =
ed3.setText().toString();Incorreta. Esta opção utiliza corretamente os identificadores da
Controller como: ed1, ed2 e ed3, mas não realiza a conversão dos tipos numéricos. Esta opção
não realiza a leitura dos dados dos componentes, mas sim realiza uma escrita por meio do
método setText(), utilizado para a saída de dados.
String nome = edit1.setText().toString();int idade =
Integer.parseInt(edit2.setText().toString());double peso =
Double.parseDouble(edit3.setText().toString());Incorreta. Esta opção utiliza como identificadores
da controller: edit1, edit2 e edit3, que são os identificadores definidos para tela (View), e não da
Controller, além disso, utiliza o método setText(), que não é usado para buscar um valor digitado,
mas para escrever um valor como saída no componente. Esta opção realiza corretamente a
conversão dos valores numéricos.
String nome = edit1.getText().toString();int idade =
Integer.parseInt(edit2.getText().toString());double peso =
0,00/ 1,00
21/12/22, 00:32 Ilumno
ilumno.sgp.starlinetecnologia.com.br/ilumno/schedule/resultcandidatedetailprint/7886738/39eb5790-ac22-11eb-b60f-02e55ba8948d/ 5/9
Double.parseDouble(edit3.getText().toString());Incorreta. Esta opção utiliza como identificadores
da controller: edit1, edit2 e edit3, que são os identificadores definidos para tela (View), e não da
Controller, além disso, utiliza o método setText(), que não é usado para buscar um valor digitado,
mas para escrever um valor como saída no componente. Esta opção realiza corretamente a
conversão dos valores numéricos.
3  Código: 36813 - Enunciado: O desenvolvimento de aplicativos móveis para o Android possui
uma série de características e ações que podem ser determinadas pelo desenvolvedor para o uso
de diferentes atividades e aplicações. Veja as características para o desenvolvimento de
aplicações no Android apresentadas a seguir. I. No Android é permitido apenas a chamada de
atividades se especificarmos obrigatoriamente no Intent o nome da classe que será executada.II.
O Android permite a troca de mensagens (informações e dados) entre diferentes aplicações, e
não apenas em uma mesma aplicação.III. O Android permite o envio de dados de uma atividade
para outra, assim como o retorno de dados da atividade chamada para a atividade chamadora.IV.
Para a realização de troca de mensagens entre atividades de uma mesma aplicação devemos
usar apenas Intents implícitas.
Analise cada afirmação apresentada e determine aquelas que são verdadeiras.
 a) I e II.
 b) II e III.
 c) I e III.
 d) I e IV.
 e) II e IV.
Alternativa marcada:
b) II e III.
Justificativa: Resposta correta: II e III.O Android permite a troca de mensagens (informações e
dados) entre diferentes aplicações, e não apenas em uma mesma aplicação. Correta. As
chamadas para Intents podem definir a chamada para uma atividade da mesma aplicação ou
para outra aplicação.O Android permite o envio de dados de uma atividade para outra, assim
como o retorno de dados da atividade chamada para a atividade chamadora. Correta. Podemos
enviar dados para uma segunda atividade e receber dados de retorno na atividade chamadora
através do método: onActivityResult();.
Distratores:No Android é permitido apenas a chamada de atividades se especificarmos
obrigatoriamente no Intent o nome da classe que será executada. Errada. Podemos usar uma
chamada implícita para outra aplicação, determinando apenas o tipo de aplicação que deverá
ser utilizada, e não o seu identificador direto.Para a realização de troca de mensagens entre
atividades de uma mesma aplicação devemos usar apenas Intents implícitas. Errada. Ao realizar
uma chamada para outra atividade de uma mesma aplicação, devemos informar explicitamente
a classe responsável pela atividade.
1,00/ 1,00
21/12/22, 00:32 Ilumno
ilumno.sgp.starlinetecnologia.com.br/ilumno/schedule/resultcandidatedetailprint/7886738/39eb5790-ac22-11eb-b60f-02e55ba8948d/ 6/9
4  Código: 36741 - Enunciado: No desenvolvimento de projetos de aplicações para dispositivos
móveis, a utilização de intentes (Intent) para acessar outros recursos do Android serve para
diferentes propósitos. Como visto, a Intent é um objeto para troca de mensagens em aplicações
móveis. Por meio do uso de Intents, é possível solicitar a execução de um outro componente do
aplicativo ou de outra aplicação.Analise as opções a seguir e selecione aquela que apresenta as
três maneiras pelas quais as Intents são utilizadas normalmente:
 a) Iniciar uma View (tela), um serviço ou uma transmissão (troca de mensagens).
 b) Iniciar uma View (tela), uma transmissão (troca de mensagens) ou um acesso a banco de
dados.
 c) Iniciar uma atividade, um serviço ou um acesso a banco de dados.
 d) Iniciar uma atividade, uma transmissão (troca de mensagens) ou um acesso a banco de
dados.
 e) Iniciar uma atividade, um serviço ou uma transmissão (troca de mensagens).
Alternativa marcada:
e) Iniciar uma atividade, um serviço ou uma transmissão (troca de mensagens).
Justificativa: Resposta correta: Iniciar uma atividade, um serviço ou uma transmissão (troca de
mensagens).Uma intente (Intent) pode iniciar uma nova atividade, que pode conter uma nova
tela (View), um serviço do Android que pode executar em segundo plano ou uma transmissão,
realizando a troca de mensagens entre diferentes aplicativos.
Distratores:Iniciar uma atividade, um serviço ou um acesso a banco de dados. Incorreta.Um
acesso a banco de dados é realizado a partir de um serviço, que pode ser local ou remoto. Uma
intente (Intent) também é utilizada para a iniciação de serviços, que podem ser executados em
segundo plano pelo sistema operacional.Iniciar uma View (tela), uma transmissão (troca de
mensagens) ou um acesso a banco de dados. Incorreta. A inicialização de uma View pode ser
realizada a qualquer momento, apenas alterando o contexto para a nova View. Uma atividade é
composta não apenas pela View, mas também por uma Controller própria, que são iniciadas em
conjunto quando iniciamos a atividade. Um acesso a banco de dados é realizado a partir de um
serviço, que pode ser local ou remoto.Iniciar uma atividade, uma transmissão (troca de
mensagens) ou um acesso a banco de dados. Incorreta. Um acesso a banco de dados é realizado
a partir de um serviço, que pode ser local ou remoto.Iniciar uma View (tela), um serviço ou uma
transmissão (troca de mensagens). Incorreta. A inicialização de uma View pode ser realizada a
qualquer momento, apenas alterando o contexto para a nova View. Uma atividade é composta
não apenas pela View, mas também por uma Controller própria, que são iniciadas em conjunto
quando iniciamos a atividade.
0,50/ 0,50
21/12/22, 00:32 Ilumno
ilumno.sgp.starlinetecnologia.com.br/ilumno/schedule/resultcandidatedetailprint/7886738/39eb5790-ac22-11eb-b60f-02e55ba8948d/ 7/9
5  Código: 36518 - Enunciado: Na criação de uma interface gráfica com o usuário de uma aplicação
para dispositivos móveis, quando precisamos identificar uma resposta do usuário a um
questionamento que seja na forma de opções do tipo sim ou não, é importante definir
corretamente o componente que será utilizado para esse caso.Indique o componente adequado
para atender a esse requisito do sistema.
 a) Button.
 b) RadioButton.
 c) EditText.
 d) TextView.
 e) CheckBox.
Alternativa marcada:
e) CheckBox.
Justificativa: Resposta correta: CheckBox.Esse componente é o ideal quando precisamos que o
usuário responda a uma entrada de dados do tipo sim ou não, pois ele apresenta apenas dois
estados, sendo o marcado (sim) e o desmarcado, (não). Distratores:TextView. Incorreta. Esse
componente não permite a entrada de dados, sendo restrito à apresentação de mensagens ou
mesmo saída de dados. EditText. Incorreta. Esse componente permite a entrada de dados em
formato livre, não sendo indicado para a necessidade apresentada no requisito do sistema para a
entrada de dados do tipo sim ou não.Button. Incorreta. Esse componente não permite a entrada
de dados, sendo restrito à interação do usuário para a execução de ação. RadioButton. Incorreta.
Esse componente é mais adequado ao uso de duas ou mais opções diferentes. Pode ser usado
para apresentar as opções de sim ou não, mas não é o componente adequado, pois o CheckBox
foi idealizado exclusivamente para esse fim, sendo intuitivo para esse fim.
0,50/ 0,50
21/12/22, 00:32 Ilumno
ilumno.sgp.starlinetecnologia.com.br/ilumno/schedule/resultcandidatedetailprint/7886738/39eb5790-ac22-11eb-b60f-02e55ba8948d/ 8/9
6  Código: 36758 - Enunciado: Uma aplicação para dispositivos móveis precisa chamar para
execução o recurso de envio de SMS, para o envio de uma mensagem. Para isso, devemos definir
a chamada de uma Intent para a realização da tarefa. Compare e avalie, dentre as opções a
seguir, aquela que apresenta corretamente a definição da Intent, envio dos dados (troca de
mensagens entre as aplicações) e a execução da Intent.
 a) uri = Uri.parse(“sms: +5521900000001”); intent = new Intent(Intent.ACTION_VIEW, uri); 
 intent.getExtra(“sms_body”, “Corpo de conteúdo do SMS”); startActivity(intent);
 b) uri = Uri.parse(“sms: +5521900000001”); intent = new Intent(Intent. ACTION_VIEW, uri); 
 intent.getExtra(“sms_body”, “Corpo de conteúdo do SMS”); initializeActivity(intent);
 c) uri = Uri.parse(“sms: +5521900000001”); Intent(Intent.ACTION_VIEW, uri); 
 intent.putExtra(“sms_body”, “Corpo de conteúdo do SMS”); initializeActivity(intent);
 d) uri = Uri.parse(“sms: +5521900000001”); intent = new Intent(Intent.ACTION_VIEW, uri); 
 intent.putExtra(“sms_body”, “Corpo de conteúdo do SMS”); startActivity(intent);
 e) uri = Uri.parse(“sms: +5521900000001”); Intent(Intent. ACTION_VIEW, uri); 
 intent.putExtra(“sms_body”, “Corpo de conteúdo do SMS”); startActivity(intent);
Alternativa marcada:
d) uri = Uri.parse(“sms: +5521900000001”); intent = new Intent(Intent.ACTION_VIEW, uri); 
 intent.putExtra(“sms_body”, “Corpo de conteúdo do SMS”); startActivity(intent);
Justificativa: Resposta correta:- Na codificação a seguir, a Intent é instanciada, isso é necessário
porque uma Intent é um objeto; o dado é enviado através do método putExtra(), responsável
pelo envio de mensagens de uma aplicação para outra; por final o forma correta de executar uma
atividade através de um Intent é através do método startActivity(). uri = Uri.parse(“sms:
+5521900000001”); intent = new Intent(Intent.ACTION_VIEW, uri); 
intent.putExtra(“sms_body”, “Corpo de conteúdo do SMS”); startActivity(intent); Distratores:-
Na codificação a seguir, o envio dos dados através de mensagens de uma aplicação para outra
deve ser feita através do método putExtra(). Apesar das demais instruções estarem corretas. uri
= Uri.parse(“sms: +5521900000001”); intent = new Intent(Intent.ACTION_VIEW, uri); 
intent.getExtra(“sms_body”, “Corpo de conteúdo do SMS”); startActivity(intent); - Na
codificação a seguir, o objeto da Intent não foi instanciado, como o Intent é uma classe, a mesma
deve ser instaciada para que o objeto criado partir dela possa ser utilizado; Além disso, o método
para executar uma Intent é o startActivity() e não o initializeActivity(). uri = Uri.parse(“sms:
+5521900000001”); Intent(Intent.ACTION_VIEW, uri); intent.putExtra(“sms_body”, “Corpo
de conteúdo do SMS”); initializeActivity(intent); - Na codificação a seguir, o envio dos dados
através de mensagens de uma aplicação para outra deve ser feita através do método putExtra();
Além disso, o método para executar uma Intent é o startActivity() e não o initializeActivity(). uri =
Uri.parse(“sms: +5521900000001”); intent = new Intent(Intent. ACTION_VIEW, uri); 
intent.getExtra(“sms_body”, “Corpo de conteúdo do SMS”); initializeActivity(intent); - Na
codificação a seguir, o objeto da Intent não foi instanciado, como o Intent é uma classe, a mesma
deve ser instaciada para que o objeto possa ser utilizado. uri = Uri.parse(“sms:
+5521900000001”); Intent(Intent. ACTION_VIEW, uri); intent.putExtra(“sms_body”, “Corpo
de conteúdo do SMS”); startActivity(intent);
1,50/ 1,50
21/12/22, 00:32 Ilumno
ilumno.sgp.starlinetecnologia.com.br/ilumno/schedule/resultcandidatedetailprint/7886738/39eb5790-ac22-11eb-b60f-02e55ba8948d/ 9/9
7  Código: 36525 - Enunciado: Na criação de sistemas para dispositivos móveis, a interface gráfica é
produzida separadamente da codificação do sistema. Dessa forma, devemos identificar todos os
componentes da interface por meio de um id.Explicite a principal importância da identificação
do id de cada componente para o desenvolvimento da codificação do projeto.
Resposta:
Na codificação do projeto, os componentes gráficos da tela (interface) devem ser ligados aos
componentes de programação na codificaçãos. Isso é necessário para a programação
realizar as ações sobre a tela.
Justificativa: Expectativa de resposta:Na codificação do projeto, os componentes gráficos da
tela (interface) devem ser relacionados aos componentes de programação na codificação. Isso é
importante para que a programação possa realizar as ações necessárias sobre os componentes
da tela gráfica.
1,50/ 1,50
8  Código: 36864 - Enunciado: Uma empresa foi contratada para desenvolver um projeto de um
aplicativo para o Android. O projeto possui diversas atividades e você foi escolhido para realizar
uma dessas atividades. A atividade pela qual você ficouresponsável deverá receber o valor de
uma compra a digitado em um EditText e definir se será calculado um desconto único de 10%,
caso o CheckBox tenha sido selecionado, ou não será calculado o desconto, caso o mesmo não
tenha sido selecionado. O valor do imposto depende do tipo de produto, 5% para produtos
nacionais e 8% para produtos importados.A atividade deverá receber o preço valor total da
compra, se será calculado o desconto ou não, além do tipo de produto (Nacional ou Importado).
Ao se clicar sobre o botão de Calcular Imposto, a atividade deverá calcular ou não o desconto e
descontar (se for o caso) do Valor total e, só depois, calcular o valor do imposto. O valor do
imposto deverá ser exibido no final da tela.
 
Sabe-se que o método a ser executado ao se clicar no botão de Calcular chama-se:
calcularImposto e que os componentes de tela já tiveram a importação de bibliotecas,
declaração e relacionamentos realizados.Construa apenas a codificação do método
calcularImposto na linguagem Java para a aplicação Android, onde os dados de entrada: valor
total; Calcular desconto (Sim ou Não); e Tipo de produto (Nacional ou Importado), que devem ser
lidos ou identificados, calcular valor do imposto, com ou sem desconto e de acordo com o tipo de
produto, ao final a atividade, deverá apresentar o Valor do Imposto como resposta.
Resposta:
Justificativa: Expectativa de resposta:public void calcularImposto(View v){ double imposto,
desconto, valorTotal; valorTotal = Double.parseDouble(edt1.getText().toString()); 
 if(ch1.isChecked()){ desconto = 0.90; // (1 – 0,10) } else { desconto = 1.00; // sem
desconto (1 – 0,00)}valorTotal = valorTotal * desconto; if(rd1.isChecked()){ imposto =
valorTotal * (0.05); } else { imposto = valorTotal * (0.08);} 
 edt2.setText(String.format(“%.2f”, imposto));}
0,00/ 2,50