Versão mínima do SDK do Android vs. versão do SDK de destino

No que diz respeito ao desenvolvimento de aplicativos para Android, qual é a diferença entre as versões Min e Target SDK? O Eclipse não me permitirá criar um novo projeto, a menos que as versões Min e Target sejam iguais!

android: minSdkVersion

Um número inteiro que designa o nível mínimo da API necessário para a execução do aplicativo. O sistema Android impedirá o usuário de instalar o aplicativo se o nível da API do sistema for menor que o valor especificado neste atributo. Você sempre deve declarar esse atributo.

android: targetSdkVersion

Um número inteiro que designa o nível da API que o aplicativo está direcionando.

Com esse conjunto de atributos, o aplicativo diz que é capaz de executar em versões mais antigas (até minSdkVersion), mas foi explicitamente testado para funcionar com a versão especificada aqui. A especificação desta versão de destino permite que a plataforma desative as configurações de compatibilidade que não são necessárias para a versão de destino (que podem ser ativadas para manter a compatibilidade com a frente) ou habilitar os recursos mais novos que não estão disponíveis para aplicativos mais antigos. Isso não significa que você pode programar recursos diferentes para diferentes versões da plataforma - simplesmente informa a plataforma que você testou em relação à versão de destino e a plataforma não deve executar nenhum trabalho extra para manter a compatibilidade com a versão de destino.

Para mais informações, consulte este URL:

http://developer.android.com/guide/topics/manifest/uses-sdk-element.html

O comentário enviado pelo OP à pergunta (basicamente afirmando que o targetSDK não afeta a compilação de um aplicativo) está totalmente errado! Desculpe por ser franco.

Em resumo, aqui está o objetivo de declarar um targetSDK diferente do minSDK: significa que você está usando recursos de um SDK de nível superior ao mínimo, mas garantiu a compatibilidade com versões anteriores . Em outras palavras, imagine que você deseja usar um recurso que foi introduzido apenas recentemente, mas que não é crítico para o seu aplicativo. Você definiria o targetSDK para a versão em que esse novo recurso foi introduzido e o mínimo para algo mais baixo, para que todos ainda pudessem usar seu aplicativo.

Para dar um exemplo, digamos que você esteja escrevendo um aplicativo que faça amplo uso da detecção de gestos. No entanto, todo comando que pode ser reconhecido por um gesto também pode ser executado por um botão ou no menu. Nesse caso, os gestos são um 'extra legal', mas não são necessários. Portanto, você definiria o sdk de destino como 7 ("Eclair" quando a biblioteca GestureDetection foi introduzida) e o mínimo de SDK para o nível 3 ("Cupcake") para que mesmo pessoas com telefones realmente antigos possam usar seu aplicativo. Tudo o que você precisa fazer é garantir que seu aplicativo verifique a versão do Android em que estava sendo executado antes de tentar usar a biblioteca de gestos, para evitar usá-lo se ele não existir. (É certo que este é um exemplo datado, pois quase ninguém ainda tem um telefone v1.5, mas houve um tempo em que a compatibilidade com a v1 foi mantida.

Para dar outro exemplo, você pode usar isso se quiser usar um recurso do Gingerbread ou Honeycomb. Algumas pessoas receberão as atualizações em breve, mas muitas outras, principalmente em hardware mais antigo, podem ficar paralisadas com a Eclair até que comprem um novo dispositivo. Isso permitiria que você usasse alguns dos novos recursos interessantes, mas sem excluir parte do seu mercado possível.

Existe um artigo muito bom no blog do desenvolvedor do Android sobre como usar esse recurso e, em particular, como criar o código "verifique se o recurso existe antes de usá-lo" que mencionei acima.

Para o OP: escrevi isso principalmente para o benefício de quem se deparar com essa pergunta no futuro, pois percebo que sua pergunta foi feita há muito tempo.

Ao definir targetSdkVersion = "xx", você certifica que seu aplicativo funciona corretamente (por exemplo, foi exaustivamente testado com êxito) no nível da API xx.

Uma versão do Android em execução no nível da API acima de xx aplicará o código de compatibilidade automaticamente para oferecer suporte a todos os recursos em que você possa confiar que estavam disponíveis no nível xx da API ou antes, mas que agora estão obsoletos no nível superior da versão do Android.

Por outro lado, se você estiver usando quaisquer recursos que se tornaram obsoletos no nível xx ou anterior , o código de compatibilidade não será aplicado automaticamente pelas versões do SO em níveis mais altos da API (que não incluem mais esses recursos) para dar suporte a esses usos. Nessa situação, o seu próprio código deve ter cláusulas de casos especiais que teste o nível API e, se o nível OS detectado é um superior que já não tem a determinado recurso API, seu código deve usar recursos alternativos que estão disponíveis nos executam de OS Nível da API.

Se isso não for possível, talvez alguns recursos da interface não apareçam que normalmente acionariam eventos dentro do seu código, e talvez você esteja perdendo um recurso crítico da interface que o usuário precisa para acionar esses eventos e acessar sua funcionalidade (como no exemplo abaixo).

Conforme indicado em outras respostas, você pode definir targetSdkVersion maior que minSdkVersion se desejar usar alguns recursos da API definidos inicialmente em níveis de API mais altos que o minSdkVersion e tiver tomado medidas para garantir que seu código possa detectar e manipular a ausência desses recursos em níveis mais baixos que targetSdkVersion.

Para avisar os desenvolvedores a testarem especificamente o nível mínimo de API necessário para usar um recurso, o compilador emitirá um erro (não apenas um aviso) se o código contiver uma chamada para qualquer método definido em um nível de API posterior a minSdkVersion, mesmo que targetSdkVersion seja maior ou igual ao nível da API em que esse método foi disponibilizado pela primeira vez. Para remover esse erro, a diretiva do compilador

@TargetApi(nn)

informa ao compilador que o código no escopo dessa diretiva (que precederá um método ou uma classe) foi gravado para testar um nível de API de pelo menos nn antes de chamar qualquer método que dependa de pelo menos esse nível de API . Por exemplo, o código a seguir define um método que pode ser chamado a partir do código em um aplicativo que possui uma minSdkVersion menor que 11 e uma targetSdkVersion 11 ou superior:

@TargetApi(11)
    public void refreshActionBarIfApi11OrHigher() {
      //If the API is 11 or higher, set up the actionBar and display it
      if(Build.VERSION.SDK_INT >= 11) {
        //ActionBar only exists at API level 11 or higher
        ActionBar actionBar = getActionBar();

        //This should cause onPrepareOptionsMenu() to be called.
        // In versions of the API prior to 11, this only occurred when the user pressed 
        // the dedicated menu button, but at level 11 and above, the action bar is 
        // typically displayed continuously and so you will need to call this
        // each time the options on your menu change.
        invalidateOptionsMenu();

        //Show the bar
        actionBar.show();
    }
}

Você também pode declarar um targetSdkVersion mais alto se tivesse testado nesse nível mais alto e tudo funcionasse, mesmo se você não estivesse usando nenhum recurso de um nível de API superior ao seu minSdkVersion. Isso seria apenas para evitar a sobrecarga de acessar o código de compatibilidade destinado a se adaptar do nível de destino até o nível mínimo, pois você teria confirmado (por meio de testes) que essa adaptação não era necessária.

Um exemplo de um recurso de interface do usuário que depende do targetSdkVersion declarado seria o botão de menu com três pontos verticais que aparece na barra de status de aplicativos com targetSdkVersion menor que 11, quando esses aplicativos estão em execução na API 11 e superior. Se o seu aplicativo tiver uma targetSdkVersion igual ou inferior a 10, presume-se que a interface do aplicativo dependa da existência de um botão de menu dedicado e, portanto, o botão de três pontos parece substituir o hardware dedicado anterior e / ou as versões na tela desse botão (por exemplo, como visto no Gingerbread) quando o sistema operacional tiver um nível de API mais alto para o qual um botão de menu dedicado no dispositivo não será mais assumido. No entanto, se você definir o targetSdkVersion do seu aplicativo para 11 ou superior, presume-se que você tenha aproveitado os recursos introduzidos nesse nível que substituem o botão de menu dedicado (e. g., a Barra de Ação), ou que você contornou a necessidade de ter um botão de menu do sistema; consequentemente, o menu de três pontos verticais "botão de compatibilidade" desaparece. Nesse caso, se o usuário não conseguir encontrar um botão de menu, ele não poderá pressioná-lo e isso, por sua vez, significa que a substituição de onCreateOptionsMenu (menu) da sua atividade nunca poderá ser chamada, o que, por sua vez, significa que uma parte significativa da funcionalidade do seu aplicativo pode ser privada da interface do usuário. A menos, é claro, que você tenha implementado a Barra de Ação ou algum outro meio alternativo para o usuário acessar esses recursos. para encontrar um botão de menu, ela não pode pressioná-lo, e isso, por sua vez, significa que a substituição onCreateOptionsMenu (menu) da sua atividade talvez nunca seja invocada, o que, por sua vez, significa que uma parte significativa da funcionalidade do seu aplicativo pode ser privado de sua interface com o usuário. A menos, é claro, que você tenha implementado a Barra de Ação ou outro meio alternativo para o usuário acessar esses recursos. para encontrar um botão de menu, ela não pode pressioná-lo, e isso, por sua vez, significa que a substituição onCreateOptionsMenu (menu) da sua atividade talvez nunca seja invocada, o que, por sua vez, significa que uma parte significativa da funcionalidade do seu aplicativo pode ser privado de sua interface com o usuário. A menos, é claro, que você tenha implementado a Barra de Ação ou outro meio alternativo para o usuário acessar esses recursos.

O minSdkVersion, por outro lado, estabelece um requisito de que a versão do sistema operacional de um dispositivo tenha pelo menos esse nível de API para executar seu aplicativo. Isso afeta quais dispositivos podem ver e baixar seu aplicativo quando ele está na loja de aplicativos do Google Play (e possivelmente em outras lojas de aplicativos). É uma maneira de afirmar que seu aplicativo depende de recursos do SO (API ou outro) que foram estabelecidos nesse nível e não possui uma maneira aceitável de lidar com a ausência desses recursos.

Um exemplo do uso de minSdkVersion para garantir a presença de um recurso não relacionado à API seria definir minSdkVersion como 8 para garantir que seu aplicativo seja executado apenas em uma versão habilitada para JIT do interpretador Dalvik (desde que o JIT foi introduzido para o intérprete do Android no nível 8 da API). Como o desempenho de um intérprete habilitado para JIT pode ser até cinco vezes maior do que aquele que não possui esse recurso, se o aplicativo fizer uso pesado do processador, convém exigir o nível 8 ou superior da API para garantir o desempenho adequado.

Um conceito pode ser melhor entregue com exemplos, sempre . Eu tive problemas para entender esse conceito até pesquisar o código-fonte da estrutura do Android e fazer algumas experiências, mesmo depois de ler todos os documentos nos sites de desenvolvedores do Android e nos threads relacionados ao stackoverflow. Vou compartilhar dois exemplos que me ajudaram muito a entender completamente esses conceitos.

Um DatePickerDialog terá uma aparência diferente com base no nível que você coloca no targetSDKversion ( <uses-sdk android:targetSdkVersion="INTEGER_VALUE"/>) do arquivo AndroidManifest.xml . Se você definir o valor 10 ou menos, seu DatePickerDialog será semelhante à esquerda. Por outro lado, se você definir o valor 11 ou superior, um DatePickerDialog parecerá correto, com o mesmo código .

O código que eu usei para criar este exemplo é super simples. MainActivity.javaparece :

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    public void onClickButton(View v) {
        DatePickerDialog d = new DatePickerDialog(this, null, 2014, 5, 4);
        d.show();       
    }
}

E activity_main.xmlolha:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >
<Button
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:onClick="onClickButton"
    android:text="Button" />
</RelativeLayout>

É isso aí. Esse é realmente todo código que eu preciso para testar isso.

E essa mudança na aparência é clara quando você vê o código-fonte da estrutura do Android . É assim:

public DatePickerDialog(Context context,
    OnDateSetListener callBack,
    int year,
    int monthOfYear,
    int dayOfMonth,
    boolean yearOptional) {
        this(context, context.getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.HONEYCOMB
                ? com.android.internal.R.style.Theme_Holo_Light_Dialog_Alert
                : com.android.internal.R.style.Theme_Dialog_Alert,
        callBack, year, monthOfYear, dayOfMonth, yearOptional);
}

Como você pode ver, a estrutura obtém o targetSDKversion atual e define um tema diferente. Esse tipo de trecho de código ( getApplicationInfo().targetSdkVersion >= SOME_VERSION) pode ser encontrado aqui e ali na estrutura do Android.

Outro exemplo é sobre a classe WebView . Os métodos públicos da classe Webview devem ser chamados no thread principal e, se não, o sistema de tempo de execução lança a RuntimeException, quando você define o targetSDKversion 18 ou superior. Esse comportamento pode ser claramente entregue com seu código-fonte . Está escrito assim.

sEnforceThreadChecking = context.getApplicationInfo().targetSdkVersion >=
            Build.VERSION_CODES.JELLY_BEAN_MR2;

if (sEnforceThreadChecking) {
    throw new RuntimeException(throwable);
}

O documento do Android diz: " À medida que o Android evolui a cada nova versão, alguns comportamentos e até aparências podem mudar ". Então, observamos mudanças de comportamento e aparência, e como essa mudança é realizada.

Em resumo, o documento do Android diz " Este atributo (targetSdkVersion) informa o sistema que você testou em relação à versão de destino e o sistema não deve permitir nenhum comportamento de compatibilidade para manter a compatibilidade direta do aplicativo com a versão de destino ". Isso é realmente claro no caso do WebView. Não havia problema até JELLY_BEAN_MR2 ser liberado para chamar o método público da classe WebView no thread não principal. Não faz sentido se a estrutura do Android lança uma RuntimeException nos dispositivos JELLY_BEAN_MR2. Apenas não deve permitir comportamentos recém-introduzidos para o seu interesse, que causam resultados fatais. Portanto, o que precisamos fazer é verificar se está tudo bem em determinadas versões do targetSDK. Temos benefícios como aprimoramento da aparência ao definir targetSDKversion mais alto,

EDIT: isenção de responsabilidade. O construtor DatePickerDialog que definiu temas diferentes com base no targetSDKversion atual (que mostrei acima) na verdade foi alterado no commit posterior . No entanto, usei esse exemplo, porque a lógica não foi alterada e esses trechos de código mostram claramente o conceito targetSDKversion.

Para quem quer um resumo,

android:minSdkVersion

é a versão mínima até que seu aplicativo seja compatível. Se o seu dispositivo tiver uma versão inferior do Android, o aplicativo não será instalado.

enquanto,

android:targetSdkVersion

é o nível da API até o qual seu aplicativo foi projetado para execução. Significa que o sistema do seu telefone não precisa usar nenhum comportamento de compatibilidade para manter a compatibilidade direta porque você testou até essa API.

Seu aplicativo ainda será executado em versões do Android mais altas do que as fornecidas, targetSdkVersionmas o comportamento de compatibilidade com o Android será ativado.

Freebie -

android:maxSdkVersion

se a versão da API do seu dispositivo for superior, o aplicativo não será instalado. Ou seja. essa é a API máxima até a qual você permite que seu aplicativo seja instalado.

ie para MinSDK -4, maxSDK - 8, targetSDK - 8 Meu aplicativo funcionará no mínimo 1.6, mas também usei recursos suportados apenas no 2.2, que serão visíveis se estiverem instalados em um dispositivo 2.2. Além disso, para maxSDK - 8, este aplicativo não será instalado em telefones usando API> 8.

No momento em que escrevemos esta resposta, a documentação do Android não estava fazendo um excelente trabalho ao explicá-la. Agora está muito bem explicado. Veja aqui

Se você receber alguns erros de compilação, por exemplo:

<uses-sdk
            android:minSdkVersion="10"
            android:targetSdkVersion="15" />

.

private void methodThatRequiresAPI11() {
        BitmapFactory.Options options = new BitmapFactory.Options();
                options.inPreferredConfig = Config.ARGB_8888;  // API Level 1          
                options.inSampleSize = 8;    // API Level 1
                options.inBitmap = bitmap;   // **API Level 11**
        //...
    }

Você recebe um erro de compilação:

O campo requer o nível 11 da API (o mínimo atual é 10): android.graphics.BitmapFactory $ Options # inBitmap

Desde a versão 17 do Android Development Tools (ADT), há uma anotação nova e muito útil @TargetApique pode corrigir isso com muita facilidade. Adicione-o antes do método que está encerrando a declaração problemática:

@TargetApi
private void methodThatRequiresAPI11() {            
  BitmapFactory.Options options = new BitmapFactory.Options();
      options.inPreferredConfig = Config.ARGB_8888;  // API Level 1          
      options.inSampleSize = 8;    // API Level 1

      // This will avoid exception NoSuchFieldError (or NoSuchMethodError) at runtime. 
      if (Integer.valueOf(android.os.Build.VERSION.SDK) >= android.os.Build.VERSION_CODES.HONEYCOMB) {
        options.inBitmap = bitmap;   // **API Level 11**
            //...
      }
    }

Não há erros de compilação agora e ele será executado!

EDIT: Isso resultará em erro de tempo de execução no nível da API menor que 11. Em 11 ou superior, ele será executado sem problemas. Portanto, certifique-se de chamar esse método em um caminho de execução protegido pela verificação de versão. O TargetApi apenas permite compilá-lo, mas você o executa por sua conta e risco.

android:minSdkVersione android:targetSdkVersionambos são um valor inteiro que precisamos declarar no arquivo de manifesto do Android, mas ambos têm propriedades diferentes.

android:minSdkVersion:Este é o nível mínimo necessário da API para executar um aplicativo Android. Se instalarmos o mesmo aplicativo na versão mais baixa da API, o erro do analisador será exibido e o problema de aplicativo não suportado será exibido.

android:targetSdkVersion:A versão sdk de destino é definir o nível de aplicativo da API de destino. se esse atributo não for declarado no manifesto, a versão minSdk será sua versão do TargetSdk. Sempre é verdade que "a instalação de suporte a aplicativos em todas as versões superiores da API que declaramos como TargetSdk Version". Para tornar o aplicativo limitado, precisamos declarar maxSdkVersion em nosso arquivo de manifesto ...

Se você estiver criando aplicativos que exijam permissões perigosas e defina targetSDK como 23 ou superior , tenha cuidado. Se você não verificar as permissões no tempo de execução, receberá uma SecurityException e, se estiver usando código dentro de um bloco try, por exemplo, abrir a câmera, poderá ser difícil detectar erros se você não verificar o logcat.

Target sdk é a versão que você deseja segmentar e min sdk é a versão mínima.