Programação para Dispositivos Móveis - AVA3

Prévia do material em texto

BRUNO






Informações da avaliação
 BRUNO CÉSAR MENEZES DE SÁ  1240201010
 21_2025_2_IL10315_21ADS5252B
 Avaliação 3 - Prova Substituta - 04/10/2025 08:00:00 (Finalizado)
 Sala Online / Andar Online / Prédio Online / Polo Online
Total: 10.00 / 10.00
 Legenda
 Discursiva  Objetiva
 Questão 1 | Código 36518 | 1.00 / 1.00
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.
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.
 >b)CheckBox.
Alternativa marcada
b) CheckBox.
https://uj-uva.provafacilnaweb.com.br/uj-uva/test/mockonlinetest/?new_layout=true&legacy_key=1240201010
 Questão 2 | Código 36516 | 1.00 / 1.00
Enunciado
O controle do ciclo de vida de uma aplicação no Android é muito importante, por permitir que possamos programar seus métodos de forma a aproveitar melhor os momentos
em que temos a oportunidade de recuperar ou armazenar dados da aplicação, por exemplo. Ao iniciar uma aplicação, onde a atividade é iniciada, temos um conjunto de três
métodos do ciclo de vida que são ativados sequencialmente.Identifique, entre as opções a seguir, aquela que define e encadeia corretamente a ordem de execução desses
métodos.
Justificativa
Resposta correta: onCreate(), onStart() e onResume().A aplicação deve primeiro ser criada em memória (onCreate()), depois ela é iniciada (onStart()) e, por fim, sempre
ocorre a execução do método onResume().Distratores: onCreate(), onResume() e onStart(). Errada. O método onResume() é executado após a criação (onCreate()) e a
inicializaqção (onStart()).onStart(), onCreate() e onRestart(). Errada. O método onRestart() não é executado na iniciação da atividade, mas sim quando a atividade retorna de
uma parada (onStop()).onStart(), onCreate() e onResume(). Errada. A aplicação precisa ser criada (onCreate()), antes de seriniciada (onStart()).onCreate(), onRestart() e
onStart(). Errada. O método onStart() é executado logo após a criação (onCreate()), além disso, o método onRestart() não é executado na iniciação da atividade, mas sim
quando a atividade retorna de uma parada (onStop()).
 >b)onCreate(), onStart() e onResume().
Alternativa marcada
b) onCreate(), onStart() e onResume().
 Questão 3 | Código 36737 | 1.00 / 1.00
Enunciado
Os projetos de aplicações para dispositivos móveis são baseados no modelo MVC (Model, View, Controller), onde os projetos seguem características da arquitetura Cliente X
Servidor em três camadas.Analise as afirmações acerca do modelo MVC apresentadas a seguir, definindo aquelas que são consideradas vantagens ao se aplicar esse
modelo.I. Determinadas mudanças em uma camada podem não afetar as demais.II. O desenvolvimento de aplicações de pequeno porte é dificultado.III. É necessário o
treinamento adequado para as equipes de desenvolvimento.IV. O desenvolvimento e a manutenção do sistema podem ficar a cargo de diferentes equipes, otimizando e
especializando o desenvolvimento.São vantagens da aplicação do modelo MVC apenas as que se apresentam nas afirmações:
Justificativa
Resposta correta: I e IV.Determinadas mudanças em uma camada podem não afetar as demais. É uma vantagem. Mudanças no layout da tela (camada View) podem não
influenciar outras partes do modelo, fazendo comque apenas a equipe de produção gráfica seja afetada.O desenvolvimento e a manutenção do sistema podem ficar a cargo
de diferentes equipes, otimizando e especializando o desenvolvimento. É uma vantagem. Assim como as mudanças podem afetar apenas uma camada do modelo, tanto o
desenvolvimento quanto a manutenção podem ser restritas a equipes específicas, não exigindo mudanças em outras camadas.O desenvolvimento de aplicações de
pequeno porte é dificultado. É uma desvantagem. Ao aplicar o modelo MVC em pequenas aplicações, será necessário o uso de diferentes equipes, o que aumentará o
tempo de desenvolvimento e os custos do projeto.É necessário o treinamento adequado para as equipes de desenvolvimento. É uma desvantagem. Ao aplicar o modelo
MVC, serão necessários diferentes treinamentos para as diferentes equipes de projeto, o que ocasionará aumento nos custos de treinamento.
 >d)I e IV.
Alternativa marcada
d) I e IV.
 Questão 4 | Código 36915 | 1.00 / 1.00
Enunciado
O ciclo de vida de uma atividade determina um conjunto de métodos que podem ser executados de acordo com eventos gerados pelo sistema operacional. Esse conjunto de
eventos é capaz de controlar a aplicação desde o seu início até o seu encerramento.Com base nisso, analise as afirmativas a seguir e a relação proposta entre elas.I.
Podemos criar uma aplicação sem a necessidade de uso de nenhum método relacionado ao ciclo de vida da atividade.PORQUEII. Dessa forma, podemos realizar o controle
unicamente por meio de métodos exclusivos criados para controlar a aplicação.É correto concluir que:
Justificativa
Resposta correta:As duas afirmativas são falsas.Podemos criar uma aplicação sem a necessidade de uso de nenhum método relacionado ao ciclo de vida da atividade.
Incorreta. Para a inicialização de uma atividade, é necessário no mínimo o método onCreate(). É por meio desse método que a aplicação é inicializada, portanto o uso desse
método obrigatório.Dessa forma, podemos realizar o controle unicamente por meio de métodos exclusivos criados para controlar a aplicação. Incorreta. O controle de uma
aplicação é realizado pelo sistema operacional por meio das APIs e, sendo assim, não podemos criar métodos que se sobreponham aos métodos do ciclo de vida. Podemos
sobrescrever esses métodos, mas não os substituir por outros.
 >a)As duas afirmativas são falsas.
Alternativa marcada
a) As duas afirmativas são falsas.
 Questão 5 | Código 36517 | 1.00 / 1.00
Enunciado
No controle do ciclo de vida de aplicação, são definidos os tempos de vida da atividade (entire lifetime), o tempo de vida visível da atividade (visible lifetime) e o tempo de
vida em primeiro plano da atividade (foreground lifetime).Indique, dentre as opções a seguir, aquela que apresenta os métodos que são utilizados para determinar o tempo
de vida da atividade (entire lifetime), sendo esse o tempo decorrente entre as suas execuções.
Justificativa
Resposta correta: onCreate() e onDestroy().O tempo de vida da atividade é definido pelo tempo decorrido entre a sua criação (onCreate()) e o seu encerramento pelo
método onDestroy().Distratores:onStart() e onStop(). Errada.Esses métodos são usados para definir o tempo de vida visível da atividade (visible lifetime), e não o tempo de
vida da atividade (entire lifetime).onCreate() e onStop(). Errada.O tempo decorrido entre esses métodos não define nenhum dos tempos de vida estudados em nosso
conteúdo, não representando uma informação útil para o sistema operacional. O onCreate() é usado para determinar o tempo de vidada atividade (entire lifetime) e o
método onStop() é usado para determinar o tempo de vida visível da atividade (visible lifetime).onResume() e onPause(). Errada.Esses métodos são usados para definir o
tempo de vida em primeiro plano da atividade (foreground lifetime), e não o tempo de vida da atividade (entire lifetime).onStart() e onDestroy(). Errada. O tempo decorrido
entre esses métodos não define nenhum dos tempos de vida estudados em nosso conteúdo, não representando uma informação útil para o sistema operacional. O método
onStart() é usado para determinar o tempo de vida visível da atividade (visible lifetime) e o método onDestroy() é usado para determinar o tempo de vida da atividade (entire
lifetime).
 >b)onCreate() e onDestroy().
Alternativa marcada
b) onCreate() e onDestroy().
 Questão 6 | Código 36738 | 1.00 / 1.00
Enunciado
No desenvolvimento de aplicações para dispositivos móveis, é utilizado o modelo MVC para o desenvolvimento de aplicações em camadas.Com base nisso, analise as
afirmativas a seguir e a relação proposta entre elas:(I) Devemos primeiro desenvolver a estrutura da interface gráfica e seus componentes.PORQUE(II) O desenvolvimento
da codificação de controle só deve ser iniciada após a definição dos componentes de entrada e saída da aplicação, que serão relacionados na Controller.É correto concluir
que:
Justificativa
Resposta correta: As duas afirmativas são verdadeiras e a segunda justifica a primeira.Devemos primeiro desenvolver a estrutura da interface gráfica e seus componentes.
Correta. A interface com o usuário precisa ser determinada primeiro para que os componentes que farão parte da tela (View) sejam definidos, para só então podermos criar
os componentes equivalentes na codificação (Controller).O desenvolvimento da codificação de controle só deve ser iniciada após a definição dos componentes de entrada e
saída da aplicação, que serão relacionados na Controller. Correta. A codificação da aplicação (Controller) deve declarar no início os componentes equivalentes aos que que
foram utilizados na tela (View) e relacioná-los com a View, de forma a podermos realizar as ações de entrada e saída de dados, justificando a primeira afirmação, de que a
tela (View) deve ser definida primeiro.
 >a)As duas afirmativas são verdadeiras e a segunda justifica a primeira.
Alternativa marcada
a) As duas afirmativas são verdadeiras e a segunda justifica a primeira.
 Questão 7 | Código 38791 | 1.00 / 1.00
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.
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”, 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().
 >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();
 Questão 8 | Código 36813 | 1.00 / 1.00
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 Intento 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.
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.
 >a)II e III.
Alternativa marcada
a) II e III.
 Questão 9 | Código 36604 | 1.00 / 1.00
Enunciado
Usando o modelo MVC, é importante realizar o relacionamento entre os componentes da tela (View) e da codificação (Controler) de um aplicativo móvel para o Android.
Observe a tabela de relacionamento a seguir: Sabe-se que os componentes já foram declarados, os relacionamentos realizados e as bibliotecas já foram importadas. A
aplicação precisa calcular a área do triângulo ou do retângulo e, para isso, as fórmulas são:Área do triângulo = Área do retângulo = Analise as opções a seguir e assinale a
que faz corretamente a criação dos métodos para obter os dados, identificar a ação de cálculo e apresentar o resultado:
Justificativa
Resposta correta:public void calcularArea(View v){double base, altura, area;base = Double.parseDouble(edt1.getText().toString());altura =
Double.parseDouble(edt2.getText().toString());if(rd1.isChecked()){area = base * altura / 2;} else {area = base * altura;}edt3.setText(String.valueOf(area));}O nome do método
está correto em função da propriedade onClick do componente de tela (View) button1. A identificação do cálculo da área também está correta, realizando o cálculo da área
do triângulo se o botão de rádio rd1 for selecionado.Distratores:public void calcularArea(View v){double base, altura, area;base =
Double.parseDouble(edt1.getText().toString());altura = Double.parseDouble(edt2.getText().toString());if(rd1.isChecked()){area = base * altura;} else {area = base * altura /
2;}edt3.setText(String.valueOf(area));}O nome do método está correto em função da propriedade onClick do componente de tela (View) button1, mas a identificação do
cálculo da área não está correta, pois está realizando o cálculo da área do retângulo se o botão de rádio rd1 for selecionado, e não para botão de rádio rd2.public void
bt1.onClick(View v){double base, altura, area;base = Double.parseDouble(edt1.getText().toString());altura = Double.parseDouble(edt2.getText().toString());if(rd1.isChecked())
{area = base * altura;} else {area = base * altura / 2;}edt3.setText(String.valueOf(area));}O nome do método não está correto em função da propriedade onClick do
componente de tela (View) button1, pois o método deveria se chamar calcularArea e não bt1.onclick, além disso, a identificação do cálculo da área também não está correta,
pois está realizando o cálculo da área do retângulo se o botão de rádio rd1 for selecionado, e não para botão de rádio rd2.public void button1.onClick(View v){double base,
altura, area;base = Double.parseDouble(edt1.getText().toString());altura = Double.parseDouble(edt2.getText().toString());if(rd1.isChecked()){area = base * altura / 2;} else
{area = base * altura;}edt3.setText(String.valueOf(area));}O nome do método não está correto em função da propriedade onClick do componente de tela (View) button1, pois
o método deveria se chamar calcularArea, e não button1.onclick. Já a identificação do cálculo da área está correta, realizando o cálculo da área do triângulo se o botão de
rádio rd1 for selecionado.public void bt1.onClick(View v){double base, altura, area;base = Double.parseDouble(edt1.getText().toString());altura =
Double.parseDouble(edt2.getText().toString());if(rd1.isChecked()){area = base * altura / 2;} else {area = base * altura;}edt3.setText(String.valueOf(area));}O nome do método
não está correto em função da propriedade onClick do componente de tela (View) button1, pois o método deveria se chamar calcularArea, e não bt1.onclick. Já a
identificação do cálculo da área está correta, realizando o cálculo da área do triângulo se o botão de rádio rd1 for selecionado.
 >d)public void calcularArea(View v){double base, altura, area;base = Double.parseDouble(edt1.getText().toString());altura =
Double.parseDouble(edt2.getText().toString());if(rd1.isChecked()){area = base * altura / 2;} else {area = base * altura;}edt3.setText(String.valueOf(area));}
Alternativa marcada
d) public void calcularArea(View v){double base, altura, area;base = Double.parseDouble(edt1.getText().toString());altura =
Double.parseDouble(edt2.getText().toString());if(rd1.isChecked()){area = base * altura / 2;} else {area = base * altura;}edt3.setText(String.valueOf(area));}
 Questão 10 | Código 36865 | 1.00 / 1.00
Enunciado
No desenvolvimento de aplicativos baseados no Android, o uso de Intents permite o acesso a de uma aplicação a outras atividades da mesma aplicação ou o uso de outras
aplicações para realizar tarefas específicas. O uso de Intents permite então o reaproveitamento não apenas de códigos, mas também de outras aplicações. Para a criação
de um uma Intent, é necessário determinar algumas características. Sabe-se que uma aplicação precisa enviar dados para uma outra atividade e que não haverá retorno de
dados da atividade chamada para a atividade chamadora.De acordo com as premissas apresentadas, compare a avalie as configurações necessárias para a criação de uma
Intent, em consonância com a ordem de definição de cada etapa, conforme as opções apresentadas a seguir, e selecione aquela que se encontra na ordem adequada de
execução e que atenda aos requisitos para o envio dos dados para uma atividade da mesma aplicação.
Justificativa
Resposta correta: String nome = ed1.getText().toString()); intent = new Intent(getApplicationContext(), Calcula.class); intent.putExtra(“nome”, nome); startActivity(intent);Está
correto, porque é realizada a uma chamada a Intent Explícita, necessária para a chamada de uma atividade da própria aplicação, onde devemos salvar o contexto atual e
determinar a classe da aplicação que será executada. Como não haverá retorno de dados por parte da atividade chamada, não devemos utilizar o método
startActivityForResult(), que só deve ser utilizando quando houver retorno de dados para a atividade chamadora, sendo correta a utilização do método startActivity() para
atender aos requisitos da aplicação.Distratores: uri = Uri.parse(“sms: ++5521900000001”); intent = new Intent(Intent.ACTION_VIEW, uri); intent.putExtra(“sms_ body”, “Corpo
de conteúdo do SMS”); startActivity(intent);Esta opção utiliza uma implícita na Intent. As chamadas implícitas não são usadas para a chamada de atividades pertencentes à
mesma aplicação, e sim para a chamada de outras aplicações através do Android. String nome = ed1.getText().toString()); intent = newIntent(getApplicationContext(),
Calcula.class); intent.putExtra(“nome”, nome); startActivityForResult(intent, ACTIVITY_REQUEST_VALOR);Esta opção utiliza a chamada explícita de forma correta para uma
atividade da própria classe, mas utiliza o método startActivityForResult(), que só deve ser utilizado quando irá ocorrer retorno de dados da atividade chamada para a
atividade chamadora. String nome = ed1.getText().toString()); intent = new Intent(getApplicationContext(), Calcula.class); intent.putExtra(“nome”, nome); startActivity(intent,
ACTIVITY_REQUEST_VALOR);Esta opção utiliza a chamada explícita correta para uma atividade da própria classe, mas utiliza o parâmetro para a inicialização da atividade,
que só deve ser definido quando haverá retorno de dados da atividade chamada para a atividade chamadora. uri = Uri.parse(“sms: ++5521900000001”); intent = new
Intent(Intent.ACTION _ VIEW, uri); intent.putExtra(“sms_ body”, “Corpo de conteúdo do SMS”); startActivityForResult(intent, ACTIVITY_REQUEST_VALOR);Esta opção
utiliza uma implícita na Intent. As chamadas implícitas não são usadas para a chamada de atividades pertencentes à mesma aplicação, e sim para a chamada de outras
aplicações através do Android. Também foi utilizado o método startActivityForResult(), que só deve ser quando irá ocorrer retorno de dados da atividade chamada para a
atividade chamadora.
 >c)String nome = ed1.getText().toString()); intent = new Intent(getApplicationContext(), Calcula.class);intent.putExtra(“nome”, nome);startActivity(intent);
Alternativa marcada
c) String nome = ed1.getText().toString()); intent = new Intent(getApplicationContext(), Calcula.class);intent.putExtra(“nome”, nome);startActivity(intent);