Android Min SDK Version vs. Target SDK Version

Komentarz zamieszczony przez OP do pytania (w zasadzie stwierdzający, że targetSDK nie wpływa na kompilację aplikacji) jest całkowicie błędny! Przepraszam za szczerość.

Krótko mówiąc, oto cel deklaracji innego targetSDK od minSDK: oznacza to, że używasz funkcji z wyższego poziomu SDK niż minimum, ale masz zapewniona kompatybilność wsteczna. Innymi słowy, wyobraź sobie, że chcesz korzystać z funkcji, która została wprowadzona dopiero niedawno, ale to nie ma znaczenia dla Twojej aplikacji. Następnie ustawisz targetSDK na wersję, w której wprowadzono tę nową funkcję, a minimum na coś niższego, aby każdy mógł nadal korzystać z Twojej aplikacji.

Aby podać przykład, załóżmy, że piszesz aplikację, która szeroko wykorzystuje wykrywanie gestów. Jednak każde polecenie, które można rozpoznać gestem, można również wykonać za pomocą przycisku lub z menu. W tym przypadku gesty są "ekstra fajne", ale nie są wymagane. Dlatego ty ustawia docelowe sdk na 7 ("Eclair", gdy Biblioteka GestureDetection została wprowadzona), a minimumSDK na poziom 3 ("Cupcake"), aby nawet osoby z naprawdę starymi telefonami mogły korzystać z Twojej aplikacji. Wszystko, co musisz zrobić, to upewnić się, że aplikacja sprawdziła wersję Androida, na której była uruchomiona, zanim spróbujesz użyć biblioteki gestów, aby uniknąć próby użycia jej, jeśli nie istnieje. (Co prawda jest to datowany przykład, ponieważ prawie nikt jeszcze nie ma telefonu v1. 5, ale był czas, gdy utrzymywanie kompatybilność z v1. 5 była bardzo ważna.)

Aby podać inny przykład, możesz użyć tego, jeśli chcesz użyć funkcji z piernika lub plastra miodu. Niektóre osoby wkrótce otrzymają aktualizacje, ale wiele innych, szczególnie w przypadku starszego sprzętu, może pozostać przy Eclair, dopóki nie kupią nowego urządzenia. To pozwoli Ci korzystać z niektórych fajnych nowych funkcji, ale bez wyłączania części potencjalnego rynku.

Jest naprawdę dobry artykuł z Android developer ' s blog o tym, jak korzystać z tej funkcji, a w szczególności, jak zaprojektować kod "Sprawdź, czy funkcja istnieje przed jej użyciem", o którym wspomniałem powyżej.

Do OP: napisałem to głównie z korzyścią dla każdego, kto zdarzy się natknąć na to pytanie w przyszłości, ponieważ zdaję sobie sprawę, że twoje pytanie zostało zadane dawno temu.

Kiedy ustawisz targetSdkVersion= "xx", poświadczasz, że Twoja aplikacja działa poprawnie (np. została gruntownie i pomyślnie przetestowana) na poziomie API xx.

Wersja Androida działająca na poziomie API powyżej xx automatycznie zastosuje kod zgodności do obsługi wszelkich funkcji, na których możesz polegać, które były dostępne na poziomie API xx lub przed nim, ale które są obecnie przestarzałe na wyższym poziomie tej wersji Androida.

Odwrotnie, jeśli używasz jakichkolwiek funkcji to stało się przestarzałe nalub przeddo poziomu xx, kod zgodności Nie będzie automatycznie stosowany przez wersje systemu operacyjnego na wyższych poziomach API (które nie zawierają już tych funkcji) do obsługi tych zastosowań. W takiej sytuacji Twój własny kod musi mieć specjalne klauzule przypadków, które testują poziom API, a jeśli wykryty poziom systemu operacyjnego jest wyższy, który nie ma już danej funkcji API, Twój kod musi używać alternatywnych funkcji, które są Dostępne w API systemu operacyjnego poziom.

Jeśli tego nie zrobi, niektóre funkcje interfejsu mogą po prostu nie pojawiać się, które normalnie wyzwalałyby zdarzenia w kodzie, i może brakować Ci krytycznej funkcji interfejsu, której użytkownik potrzebuje do wyzwalania tych zdarzeń i dostępu do ich funkcjonalności (jak w przykładzie poniżej).

Jak wspomniano w innych odpowiedziach, możesz ustawić targetSdkVersion wyżej niż minSdkVersion, jeśli chcesz używać niektórych funkcji API wstępnie zdefiniowanych na wyższych poziomach API niż twój minSdkVersion i podjął kroki w celu zapewnienia, że Twój kod może wykryć i obsłużyć brak tych funkcji na niższych poziomach niż targetSdkVersion.

Aby ostrzec programistów, aby specjalnie przetestowali minimalny poziom API wymagany do użycia funkcji, kompilator wyda błąd (nie tylko ostrzeżenie), jeśli kod zawiera wywołanie dowolnej metody, która została zdefiniowana na późniejszym poziomie API niż minSdkVersion, nawet jeśli targetSdkVersion jest większy lub równy poziomowi API, na którym ta funkcja działa. metoda została po raz pierwszy udostępniona. Aby usunąć ten błąd, dyrektywa kompilatora

@TargetApi(nn)

Mówi kompilatorowi, że kod w ramach tej dyrektywy (który poprzedzi metodę lub klasę) został napisany do testowania na poziomie API co najmniej nn przed wywołaniem dowolnej metody, która zależy od posiadania co najmniej tego poziomu API. Na przykład poniższy kod definiuje metodę, którą można wywołać z kodu w aplikacji, która ma minSdkVersion mniejszą niż 11 i targetSdkVersion o wartości 11 lub wyższej:

@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();
    }
}

Możesz również chcieć zadeklarować wyższy targetSdkVersion, jeśli testowałeś na tym wyższym poziomie i wszystko działało, nawet jeśli używałeś Nie żadnych funkcji z poziomu API wyższego niż twój minSdkVersion. Byłoby to tylko po to, aby uniknąć kosztów dostępu do kodu kompatybilności, który ma dostosować się z poziomu docelowego do poziomu min, ponieważ potwierdziłbyś (poprzez testowanie), że taka adaptacja nie jest wymagane.

Przykładem funkcji interfejsu użytkownika, która zależy od zadeklarowanego targetSdkVersion, jest przycisk menu z trzema pionowymi kropkami, który pojawia się na pasku stanu aplikacji o targetSdkVersion mniejszym niż 11, gdy te aplikacje działają pod interfejsem API 11 i wyższym. Jeśli aplikacja ma targetSdkVersion 10 lub poniżej, zakłada się, że interfejs aplikacji zależy od istnienia dedykowanego przycisku menu, a więc przycisk z trzema kropkami wydaje się zastępować wcześniejszy dedykowany przycisk Gingerbread), gdy system operacyjny ma wyższy poziom API, dla którego dedykowany przycisk menu na urządzeniu nie jest już zakładany. Jeśli jednak ustawisz targetSdkVersion w aplikacji na 11 lub wyższy, zakłada się, że skorzystałeś z funkcji wprowadzonych na tym poziomie, które zastępują dedykowany przycisk menu (np. pasek akcji) lub w inny sposób ominąłeś potrzebę posiadania przycisku menu systemowego; w związku z tym znika menu z trzema pionowymi kropkami "przycisk zgodności". W takim przypadku, jeśli użytkownik nie może znaleźć przycisk menu, ona nie może go nacisnąć, a to z kolei oznacza, że Twoja aktywność oncreateoptionsmenu (menu) override może nigdy nie zostać wywołana,co ponownie z kolei oznacza, że znaczna część funkcjonalności aplikacji może zostać pozbawiona interfejsu użytkownika. O ile oczywiście Nie zaimplementowano paska akcji lub innych alternatywnych środków dostępu dla użytkownika funkcje.

MinSdkVersion, z kolei, określa wymóg, że wersja systemu operacyjnego urządzenia ma co najmniej ten poziom API, aby uruchomić aplikację. Ma to wpływ na to, które urządzenia mogą zobaczyć i pobrać aplikację, gdy znajduje się ona w sklepie z aplikacjami Google Play (i ewentualnie w innych sklepach z aplikacjami). Jest to sposób na stwierdzenie, że Twoja aplikacja opiera się na funkcjach systemu operacyjnego (API lub innych), które zostały ustanowione na tym poziomie i nie ma akceptowalnego sposobu radzenia sobie z ich brakiem funkcje.

Przykładem użycia minSdkVersion w celu zapewnienia obecności funkcji, która nie jest związana z API , a nie byłoby ustawienie minSdkVersion na 8, aby upewnić się, że aplikacja będzie działać tylko na wersji Dalvik z obsługą JIT (ponieważ JIT został wprowadzony do interpretera Androida na poziomie API 8). Ponieważ wydajność dla interpretera z obsługą JIT może być aż pięć razy większa niż w przypadku jednego bez tej funkcji, jeśli Twoja aplikacja intensywnie wykorzystuje procesor, może wymagać API na poziomie 8 lub wyższym w celu zapewnienia odpowiedniej wydajności.

koncepcja może być lepiej dostarczona z przykładami, zawsze. Miałem problemy w zrozumieniu tych koncepcji, dopóki nie zagłębiłem się w kod źródłowy Android framework i nie przeprowadziłem kilku eksperymentów, nawet po przeczytaniu wszystkich dokumentów w witrynach programistów Androida i powiązanych wątkach stackoverflow. Podzielę się dwoma przykładami, które bardzo pomogły mi w pełni zrozumieć te pojęcia.

A DatePickerDialog będzie wyglądał inaczej w zależności od poziomu, który umieścisz w AndroidManifest.xml targetSDKversion pliku (<uses-sdk android:targetSdkVersion="INTEGER_VALUE"/>). Jeśli ustawisz wartość 10 lub niższą, Twój DatePickerDialog będzie wyglądał jak lewy. Z drugiej strony, jeśli ustawisz wartość 11 lub wyższą, DatePickerDialog będzie wyglądał tak, z tym samym kodem.

Kod, którego użyłem do stworzenia tej próbki jest super-prosty. MainActivity.java wygląda:

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();       
    }
}

I activity_main.xml wygląda:

<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>

To wszystko. To naprawdę każdy kod, który muszę przetestować.

I ta zmiana wyglądu jest krystalicznie czysta, gdy widzisz kod źródłowy Android framework. It goes like :

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);
}

Jak widać, framework Pobiera bieżący targetSDKversion i ustawia inny motyw. Ten rodzaj fragmentu kodu (getApplicationInfo().targetSdkVersion >= SOME_VERSION) można znaleźć tu i ówdzie w Android framework.

Inny przykład dotyczy klasy WebView. Publiczne metody klasy Webview powinny być wywoływane w głównym wątku, a jeśli nie, runtime system wyrzuca RuntimeException, po ustawieniu targetSDKversion 18 lub wyższej. To zachowanie może być wyraźnie Dostarczone za pomocą jego kodu źródłowego . Tak to jest napisane.

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

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

Android doc mówi: "W miarę rozwoju Androida z każdą nową wersją, niektóre zachowania, a nawet wygląd mogą się zmieniać."Przyjrzeliśmy się więc zmianie zachowania i wyglądu oraz temu, w jaki sposób ta zmiana jest dokonywana.

Podsumowując, Android doc mówi " to atrybut (targetSdkVersion) informuje system, że zostały przetestowane w wersji docelowej i system nie powinien włączać żadnych zachowań kompatybilności , aby utrzymać kompatybilność aplikacji z wersją docelową.". Jest to naprawdę jasne w przypadku WebView. Było OK, dopóki JELLY_BEAN_MR2 nie został wydany, aby wywołać publiczną metodę klasy WebView w wątku not-main. To nonsens, jeśli Android framework rzuca RuntimeException na urządzeniach JELLY_BEAN_MR2. To po prostu nie powinno umożliwiać nowo wprowadzone zachowania dla jego zainteresowania, które powodują fatalny wynik. Więc, co musimy zrobić, to sprawdzić, czy wszystko jest OK na niektórych targetSDKversions. Otrzymujemy korzyści takie jak poprawa wyglądu z ustawianiem wyższych celówsdkversion, ale wiąże się to z odpowiedzialnością.

Edytuj : zastrzeżenie. Konstruktor DatePickerDialog, który ustawia różne motywy w oparciu o bieżący targetSDKversion (który pokazałem powyżej) został zmieniony w później commit. Niemniej jednak używałem ten przykład, ponieważ logika nie została zmieniona, a ten fragment kodu wyraźnie pokazuje koncepcję targetSDKversion.

Dla tych, którzy chcą podsumowania,

android:minSdkVersion

Jest wersją minimalną, dopóki aplikacja nie obsługuje. Jeśli Twoje urządzenie ma niższą wersję Androida , aplikacja nie zostanie zainstalowana.

While,

android:targetSdkVersion

To poziom API, do którego aplikacja jest przeznaczona. Oznacza to, że system Twojego telefonu nie musi używać żadnych zachowań zgodnych, aby zachować kompatybilność, ponieważ przetestowałeś ją przed tym API.

Twoja aplikacja będzie nadal działać na Androidzie w wersjach wyższych niż biorąc pod uwagę targetSdkVersion, ale zachowanie zgodności z Androidem będzie działać.

Freebie -

android:maxSdkVersion

Jeśli wersja API Twojego urządzenia jest wyższa, aplikacja nie zostanie zainstalowana. Ie. to jest max API, do którego zezwalasz na instalację aplikacji.

Ie. dla MinSDK -4, maxSDK - 8, targetSDK-8 Moja aplikacja będzie działać na minimum 1.6, ale użyłem również funkcje, które są obsługiwane tylko w 2.2, które będą widoczne, jeśli jest zainstalowany na urządzeniu 2.2. Ponadto, dla maxSDK-8, Ta aplikacja nie będzie instalowany na telefonach przy użyciu API > 8.

W momencie pisania tej odpowiedzi dokumentacja Androida nie spisywała się najlepiej w wyjaśnianiu jej. Teraz jest to bardzo dobrze wyjaśnione. sprawdź tutaj

Jeśli pojawią się jakieś błędy kompilacji, na przykład:

<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**
        //...
    }

Pojawia się błąd kompilacji:

Pole wymaga API level 11 (current min is 10): android.grafika.BitmapFactory$Options#inBitmap

Od wersji 17 Android Development Tools (ADT) istnieje jedna nowa i bardzo przydatna adnotacja @TargetApi, która może to bardzo łatwo naprawić. Dodaj go przed metodą, która załącza problematyczną deklarację:

@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**
            //...
      }
    }

Brak błędów kompilacji i będzie działać !

EDIT: spowoduje to błąd runtime na poziomie API niższym niż 11. Na 11 lub wyższej będzie działać bez problemów. Musisz więc mieć pewność, że wywołujesz tę metodę na ścieżce wykonania strzeżonej przez Sprawdzanie wersji. TargetApi pozwala tylko skompilować go, ale uruchamiasz go na własne ryzyko.

android:minSdkVersion i android:targetSdkVersion obie są wartością całkowitą, którą musimy zadeklarować w pliku manifestu Androida, ale obie mają różne właściwości.

android:minSdkVersion: jest to minimalny wymagany poziom API do uruchomienia aplikacji na Androida. Jeśli zainstalujemy tę samą aplikację w niższej wersji API, pojawi się błąd parsera i pojawi się problem z obsługą aplikacji.

android:targetSdkVersion: docelowa wersja sdk ma ustawić docelowy poziom API aplikacji. jeśli ten atrybut nie jest zadeklarowany w manifeście, minSdk wersja będzie twoją wersją TargetSdk. Jest to zawsze prawda ,że "instalacja obsługi aplikacji na wszystkich wyższych wersjach API zadeklarowaliśmy jako wersję TargetSdk". Aby app limited target musimy zadeklarować maxSdkVersion w naszym pliku manifest...

Target sdk jest wersją, którą chcesz kierować, A min sdk jest minimalną.

Jeśli tworzysz aplikacje, które wymagają niebezpiecznych uprawnień i ustawiasz targetSDK na 23 lub powyżej, powinieneś być ostrożny. Jeśli nie sprawdzisz uprawnień w środowisku uruchomieniowym, otrzymasz SecurityException, a jeśli używasz kodu wewnątrz bloku try, na przykład open camera, wykrycie błędu może być trudne, jeśli nie sprawdzisz logcat.