A2 - dispositivos moveis

Prévia do material em texto

Local: Sala 1 - BT - Prova On-line / Andar / Polo Barra da Tijuca / POLO UVA BARRA MARAPENDI - RJ
Acadêmico: EAD-IL10315-20203A
Aluno: DANIEL FRANCISCO ALVES FELICIANO
Avaliação: A2-
Matrícula: 20182300254
Data: 26 de Setembro de 2020 - 08:00 Finalizado
Correto Incorreto Anulada  Discursiva  Objetiva Total: 5,70/10,00
1  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) RadioButton.
 b) Button.
 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
2  Código: 36520 - Enunciado: No desenvolvimento de aplicações para dispositivos móveis, é comum a necessidade de envio de dados (mensagens) entre diferentes telas do sistema. Dessa forma, é necessário que o dado
em questão seja enviado explicitamente de uma tela para outra.Identifique, dentre as opções a seguir, a instrução correta que utiliza o método necessário para realizar o envio do dado de uma tela para a outra e o método
que busca o dado armazenado no componente EditText relacionado da tela identificado por edt1, para a chamada de Intent de uma aplicação, enviando um nome para a atividade identificada como
CalculaIMC.Class: Intent i = new Intent(getApplicationContext(), CalculaIMC.class);
 a) i.getExtras("nome", edt1.setText().toString());
 b) i.putExtra("nome", edt1.setText().toString());
 c) i.putExtra("nome", edt1.getText().toString());
 d) i.getExtras("nome", edt1.getText().toString());
 e) i.sendExtra("nome", edt1.getText().toString());
Alternativa marcada:
c) i.putExtra("nome", edt1.getText().toString());
Justificativa: Resposta correta: i.putExtra("nome", edt1.getText().toString());.O método de envio de dado é o putExtra() e o método correto para buscar um valor ou dado armazenado em um EditText é o
GetText(); Distratores:i.getExtras("nome", edt1.setText().toString());. Incorreta. O método getExtras() é usado no recebimento de um dado pela tela, e não para o envio. Além disso, é usado o método setText(), que realiza a
ação inversa de armazenamento de um valor no componente.i.putExtra("nome", edt1.setText().toString());. Incorreta. Apesar de usar o método correto de envio de dado putExtra(), a instrução não realiza a busca do dado
no componente edt1, realizando incorretamente a ação inversa de armazenamento de um valor no componente.i.getExtras("nome", edt1.getText().toString());. Incorreta. O método getExtras() é usado na  recebimento de
um dado pela tela, e não para o envio, apesar de ser usado corretamente o método de busca do dado no componente EditText edt1.i.sendExtra("nome", edt1.getText().toString());. Incorreta. O método sendExtras() não é
usado para o envio de dados de uma tela para outra, apesar de ser usado corretamente o método de busca do dado no componente EditText edt1.
0,50/ 0,50
3  Código: 36866 - Enunciado: Uma ONG (organização não governamental) deseja cadastrar os moradores de uma certa região da cidade. Esse cadastramento será feito por meio de um aplicativo para dispositivos móveis
disponibilizado na plataforma Android. Serão cadastrados vários tipos de dados de diferentes pessoas de cada família, os dados serão armazenados em tabelas que deverão estar relacionadas. Os dados deverão ser
armazenados localmente e enviados para um servidor ao final do expediente pela pessoa que está realizando o cadastramento.Avalie as necessidades aplicadas pela aplicação e selecione a opção que apresenta a forma
adequada para armazenar dados e que utilize o método adequado do ciclo de vida de uma aplicação para enviar os dados da aplicação para o servidor.
 a) Deve-se usar um arquivo SQLite para o armazenamento e executar o envio dos dados por meio do método onDestroy().
 b) Deve-se usar um arquivo SQLite para o armazenamento e executar o envio dos dados por meio do método onResume().
 c) Deve-se usar um arquivo local para o armazenamento e executar o envio dos dados por meio do método onCreate().
 d) Deve-se usar um arquivo local para o armazenamento e executar o envio dos dados por meio do método onDestroy().
 e) Deve-se usar um arquivo SQLite para o armazenamento e executar o envio dos dados por meio do método onRestart().
Alternativa marcada:
b) Deve-se usar um arquivo SQLite para o armazenamento e executar o envio dos dados por meio do método onResume().
Justificativa: Resposta correta: Deve-se usar um arquivo SQLite para o armazenamento e executar o envio dos dados por meio do método onDestroy().Como a aplicação necessita armazenar um conjunto grande de
dados, por meio do uso de diversas tabelas com relacionamento, a forma mais adequada de realizar o armazenamento local é por meio do uso SQLite. Como os dados só serão enviados ao término do expediente, os
dados deverão ser enviados por meio de um método chamado pelo método onDestroy(), que será chamado quando o usuário que realizou o cadastramento encerrar a aplicação ao final do expediente. Distratores:Deve-se
usar um arquivo local para o armazenamento e executar o envio dos dados por meio do método onCreate(). Errada. Um arquivo local não é adequado para armazenar grande quantidade de dados, com tabelas com
relacionamento. Além disso, o método onCreate() é executado no início, quando ainda não haverá dados cadastrados.Deve-se usar um arquivo SQLite para o armazenamento e executar o envio dos dados por meio do
método onResume(). Errada. O SQLite é a forma adequada de armazenamento de dados para o uso de diferentes tabelas com relacionamento. Já o método onResume() é executado quando a atividade volta ao foco
durante o uso de outro aplicativo. Como o usuário que realiza o cadastramento deverá realizar outros usos de aplicativos durante a jornada de trabalho e voltará por várias vezes à aplicação de cadastro, mas isso tudo
antes de encerrar o expediente.Deve-se usar um arquivo local para o armazenamento e executar o envio dos dados por meio do método onDestroy(). Errada. Um arquivo local não é adequado para armazenar grande
quantidade de dados, com tabelas com relacionamento. Já o uso do método onDestroy() é adequado, porque o mesmo será chamado quando o usuário que realizou o cadastramento encerrar a aplicação ao final do
expediente.Deve-se usar um arquivo SQLite para o armazenamento e executar o envio dos dados por meio do método onRestart(). Errada. O SQLite é a forma adequada de armazenamento de dados para o uso de
diferentes tabelas com relacionamento. Já o método onRestart() será executado quando o usuário navegar de volta à atividade, não sendo necessariamente o momento de encerramento do expediente.
0,00/ 1,50
4  Código: 38048 - 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.edit();prefUsuario.putFloat(“base”, Float.parseFloat(edt1.getText(). toString()));      
 prefUsuario.putFloat(“altura”, Float.parseFloat(edt2.getText().toString()));if(rd1.isisChecked()){prefUsuario.putInt(“opcao”, 1);} else{prefUsuario.putInt(“opcao”, 2);}prefUsuario.save();
 b) 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.isisChecked()){Geometria.putInt(“opcao”, 1);} else{Geometria.putInt(“opcao”, 2);}Geometria.save();
 c) 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.isisChecked()){prefUsuario.putInt(“opcao”, 1);} else{prefUsuario.putInt(“opcao”, 2);}prefUsuario.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.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.isisChecked()){prefUsuario.putInt(“opcao”, 1);} else{prefUsuario.putInt(“opcao”, 2);}prefUsuario.commit();
Alternativa marcada:
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.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”, 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().
0,00/ 1,50
5  Código: 36738 - 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:
 a) As duas afirmativas são verdadeiras e a segunda não justifica a primeira.
 b) A primeira afirmativa é verdadeira e a segunda é falsa.
 c) As duas afirmativas são falsas.
 d) A primeira afirmativa é falsa e a segunda verdadeira.
 e) As duas afirmativas são verdadeiras e a segunda justifica a primeira.
Alternativa marcada:
d) A primeira afirmativa é falsa e a segunda verdadeira.
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 naController. 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.
0,00/ 1,00
6  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 III.
 b) I e II.
 c) II e IV.
 d) I e IV.
 e) II e III.
Alternativa marcada:
e) 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
7  Código: 36526 - Enunciado: Uma forma de armazenamento local de dados de uma aplicação para dispositivos móveis é por meio do uso de armazenamento local com o SQLite. Apesar de o SQLite possuir compatibilidade
de dados com diversos outros gerenciadores de banco de dados, ele utiliza o conceito de afinidade para a definição dos tipos de dados suportados por ele.Cite os cinco tipos de dados suportados pelo SQLite para o
armazenamento de dados em suas tabelas.
Resposta:
Os 5 tipos sao: Integer, real, numeric, none e  text
 
Justificativa: Expectativa de resposta:Os tipos de dados suportados pelo SQLite são: INTEGER, NONE, NUMERIC, REAL e TEXT. Os demais tipos suportados por outros gerenciadores são assumidos por afinidade a apenas
um desses tipos.
1,50/ 1,50
8  Código: 36870 - Enunciado: Você tem um conhecido que trabalha com a instalação de aparelhos de ar condicionado e pediu uma ajuda para criar um aplicativo que dimensionasse o aparelho de ar condicionado para um
determinado ambiente residencial. A aplicação deverá calcular e apresentar o valor em BTUs necessário para refrigerar adequadamente o ambiente. Para isso, são necessários: o comprimento e a largura do ambiente
(valores reais), a quantidade de pessoas que ficam normalmente no local (inteiro) e a quantidade de aparelhos elétricos que são utilizados no local (inteiro). Além disso, é necessário determinar o fator de insolação e, para
isso, deve-se perguntar ao usuário se o local possui incidência de sol (sim ou não). Locais com incidência de sol (sim) utilizam para o cálculo o valor de 800 BTUs no coeficiente de insolação, já ambientes sem incidência de
sol (não) utilizam 600 BTUs no coeficiente de insolação.Fórmula: Fator (fator de insolação (600 ou 800)).  Área (área do ambiente) = comprimento * largura.NumP (número de pessoas).Qtd (quantidade de aparelhos
elétricos). Siga a seguinte sequência lógica para resolver a questão:Faça as entradas de dados por meio dos componentes do aplicativo.Calcule a área do ambiente.Determine o fator de insolação.Calcule a capacidade
mínima do ar condicionado = (fator * area) + (numP * fator) + (qtd * fator).Apresente a capacidade mínima calculada no componente de saída de dados. Projete o aplicativo para o Android, sendo necessário que sejam
criados: a) O layout da tela e a tabela com as identificações dos componentes e seus respectivos identificadores para a View e para a Controller.b) A declaração dos componentes de entrada e saída da codificação
(Controller).c) Os relacionamentos entre os componentes da tela (View) e da codificação (Controller).d) O método responsável por realizar as entradas de dados, calcular e apresentar o resultado.
Resposta:
View:
<EditText
        android:id="@+id/altura"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:hint="Altura"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />
<EditText
        android:id="@+id/largura"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:hint="Largura"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />
<EditText
        android:id="@+id/pessoas"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:hint="Pessoas"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />
<EditText
        android:id="@+id/qtd"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:hint="Quantidade de Eletronicos"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />
2,20/ 2,50
<TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginStart="16dp"
        android:layout_marginTop="41dp"
       
        android:textSize="30sp"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/editText3" />
    <CheckBox
        android:id="@+id/fator"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:checked="false"
        android:text="Incidencia solar?" />
Controller:
public class MainActivity extends AppCompatActivity {
    
    EditText altura, largura, qtd, pessoas;
    CheckBox fator;
    TextView resultado;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        fator = (CheckBox) findViewById(R.id.fator);
        altura = (EditText) findViewById(R.id.altura);
        largura = (EditText) findViewById(R.id.largura);
        qtd = (EditText) findViewById(R.id.qtd);
        pessoas = (EditText) findViewById(R.id.pessoas);
        resultado = (TextView) findViewById(R.id.textView);
    }
    public void calcular(View v) {
    double altura1 = 0, largura1 = 0;
    int pessoas1, qtd1, fator1;
        String altura11, largura11, pessoas11, qtd11, fator11;
        if(fator.isChecked()) { 
         fator1= “800”; 
         }  else {
         fator1= “600”; 
           }
        altura11 = altura.getText().toString();
        largura11 = largura.getText().toString();pessoas11 = pessoas.getText().toString();
        qtd11 = qtd.getText().toString();
        fator11 = fator.getText().toString();
        situacao.setText(String.format(""));
        aviso.setText(String.format(""));
            altura1 = Double.parseDouble(altura11);
            largura1 = Double.parseDouble(largura11);
            pessoas1 = Integer.parseInter(n3);
            qtd1 = Integer.parseInter(qtd11);
             fator1 = Integer.parseInter(fator11);
double area = altura1 * largura1;
int btufinal = math.round((fator1 * area) + (pessoas1 * fator1) + (qtd1* fator1))
                        resultado.setText(String.format(“%d”, btufinal));
    }
}
Comentários: Faltou o CheckBox.
Justificativa: Expectativa de resposta:a)                 b)EditText edt1, edt2, edt3, edt4, edt5;CheckBox chk1;c)edt1 = (EditText) findViewById(R.id.editText1);edt2 = (EditText) findViewById(R.id.editText2);edt3 = (EditText)
findViewById(R.id.editText3);edt4 = (EditText) findViewById(R.id.editText4);edt4 = (EditText) findViewById(R.id.editText5);chk1 = (CheckBox) findViewById(R.id.check1);d)// onCLick do botão button1 =
dimensionarArCondicionadopublic void dimensionarArCondicionado (View v){      double comprimento, largura, area, capacidade, fator;         int numP, qtd;      comprimento = Double.parseDouble(edt1.getText().toString());   
  largura = Double.parseDouble(edt2.getText().toString());         numP = Integer.parseInt(edt3.getText().toString());         qtd = Integer.parseInt(edt4.getText().toString());         area = comprimento * largura;       
 if(rad1.isChecked()){           fator = 800;         }         else {           fator = 600;         }         capacidade = (fator * area) + (numP * fator) + (qtd * fator)         edt5.setText(String.valueOf(capacidade));}