Dlaczego moje skalowanie do rysowania wektorów nie jest zgodne z oczekiwaniami?

Próbuję użyć rysunków wektorowych w mojej aplikacji na Androida. Z http://developer.android.com/training/material/drawables.html (moje wyróżnienie):

W systemie Android 5.0 (poziom interfejsu API 21) i nowszych można zdefiniować elementy wektorowe, które skalują się bez utraty definicji.

Korzystanie z tego do rysowania:

<vector xmlns:android="http://schemas.android.com/apk/res/android"
android:height="24dp"
android:width="24dp"
android:viewportWidth="24"
android:viewportHeight="24">
<path android:fillColor="@color/colorPrimary" android:pathData="M14,20A2,2 0 0,1 12,22A2,2 0 0,1 10,20H14M12,2A1,1 0 0,1 13,3V4.08C15.84,4.56 18,7.03 18,10V16L21,19H3L6,16V10C6,7.03 8.16,4.56 11,4.08V3A1,1 0 0,1 12,2Z" />

i ten ImageView:

<ImageView
    android:layout_width="400dp"
    android:layout_height="400dp"
    android:src="@drawable/icon_bell"/>

powoduje wyświetlenie tego rozmytego obrazu podczas próby wyświetlenia ikony w rozdzielczości 400 dp (na dużym urządzeniu mobilnym o wysokiej rozdzielczości z około 2015 r., na którym działa Lollipop):

Zmiana szerokości i wysokości w definicji wektora rysowanego do 200dp znacząco poprawia sytuację przy wyrenderowanym rozmiarze 400dp. Jednak ustawienie tego jako możliwego do rysowania dla elementu TextView (tj. Ikony po lewej stronie tekstu) tworzy teraz ogromną ikonę.

Moje pytania:

1) Dlaczego w wektorze do rysowania istnieje specyfikacja szerokości / wysokości? Myślałem, że chodzi o to, że skalują się w górę iw dół bezstratnie, przez co szerokość i wysokość nie mają znaczenia w swojej definicji?

2) Czy możliwe jest użycie pojedynczego wektora do rysowania, który działa jako rysowany w formacie 24dp na TextView, ale dobrze skaluje się, aby używać również znacznie większych obrazów? Np. Jak uniknąć tworzenia wielu rysunków wektorowych o różnych rozmiarach i zamiast tego użyć takiego, który skaluje się do moich renderowanych wymagań?

3) Jak efektywnie wykorzystać atrybuty szerokości / wysokości i jaka jest różnica z viewportWidth / Height?

Dodatkowe Szczegóły:

• Na urządzeniu działa API 22
• Korzystanie z Android Studio w wersji 1.5.1 z Gradle w wersji 1.5.0
• Manifest jest kompilacją i docelowym poziomem 23, minimalnym poziomem 15. Próbowałem również przenieść minimalny poziom na 21, ale to nie miało znaczenia.
• Dekompilacja APK (z minimalnym poziomem ustawionym na 21) pokazuje pojedynczy zasób XML w folderze do rysowania. Nie są tworzone żadne obrazy rasteryzowane.

Tutaj są nowe informacje na temat tego problemu:

https://code.google.com/p/android/issues/detail?id=202019

Wygląda na to, że użycie android:scaleType="fitXY"spowoduje poprawne skalowanie w Lollipopie.

Od inżyniera Google:

Cześć, daj mi znać, jeśli scaleType = 'fitXY' może być dla Ciebie obejściem, aby uzyskać ostry obraz.

Prawoślaz lekarski Vs Lollipop jest efektem specjalnego zabiegu złuszczającego dodanego do ptasie mleczko.

Również dla twoich komentarzy: „Prawidłowe zachowanie: wektor, który można rysować, powinien skalować się bez utraty jakości. Więc jeśli chcemy użyć tego samego zasobu w 3 różnych rozmiarach w naszej aplikacji, nie musimy 3 razy powtarzać vector_drawable.xml z różnymi rozmiary zakodowane na stałe ”.

Chociaż całkowicie się zgadzam, że tak powinno być, w rzeczywistości platforma Android ma problemy z wydajnością, tak że nie dotarliśmy jeszcze do idealnego świata. Dlatego faktycznie zaleca się użycie 3 różnych vector_drawable.xml, aby uzyskać lepszą wydajność, jeśli na pewno chcesz narysować na ekranie 3 różne rozmiary w tym samym czasie.

Szczegóły techniczne są takie, że używamy bitmapy pod hakiem do buforowania złożonego renderowania ścieżki, tak abyśmy mogli uzyskać najlepszą wydajność przerysowywania, na równi z przerysowywaniem mapy bitowej do rysowania.

1) Dlaczego w wektorze do rysowania istnieje specyfikacja szerokości / wysokości? Myślałem, że chodzi o to, że skalują się w górę iw dół bezstratnie, przez co szerokość i wysokość nie mają znaczenia w swojej definicji?

W przypadku wersji SDK mniejszych niż 21, w których system kompilacji musi generować obrazy rastrowe i jako domyślny rozmiar w przypadkach, w których nie określono szerokości / wysokości.

2) Czy możliwe jest użycie pojedynczego wektora do rysowania, który działa jako rysowany w trybie 24dp na TextView, a także dużego obrazu o szerokości bliskiej ekranu?

Nie wierzę, że jest to możliwe, jeśli chcesz również kierować reklamy na zestawy SDK mniejsze niż 21.

3) Jak efektywnie wykorzystać atrybuty szerokości / wysokości i jaka jest różnica z viewportWidth / Height?

Dokumentacja: (właściwie niezbyt przydatna teraz, gdy ją ponownie przeczytałem ...)

android:width

Służy do definiowania wewnętrznej szerokości elementu rysunkowego. Obsługuje wszystkie jednostki wymiarowe, zwykle określone w dp.

android:height

Służy do określenia wewnętrznej wysokości wyciąganej. Obsługuje wszystkie jednostki wymiarowe, zwykle określone w dp.

android:viewportWidth

Służy do definiowania szerokości obszaru rzutni. Rzutnia to w zasadzie wirtualne płótno, na którym rysowane są ścieżki.

android:viewportHeight

Służy do definiowania wysokości obszaru rzutni. Rzutnia to w zasadzie wirtualne płótno, na którym rysowane są ścieżki.

Więcej dokumentacji:

Android 4.4 (poziom API 20) i niższy nie obsługuje rysunków wektorowych. Jeśli minimalny poziom interfejsu API jest ustawiony na jednym z tych poziomów interfejsu API, Vector Asset Studio również kieruje Gradle do generowania obrazów rastrowych wektorów, które można rysować w celu zapewnienia zgodności z poprzednimi wersjami. Możesz odwoływać się do zasobów wektorowych, tak jak Drawablew kodzie Java lub @drawablew kodzie XML; po uruchomieniu aplikacji odpowiedni obraz wektorowy lub rastrowy jest wyświetlany automatycznie w zależności od poziomu interfejsu API.

Edycja: dzieje się coś dziwnego. Oto moje wyniki w emulatorze SDK w wersji 23 (urządzenie testowe Lollipop + jest teraz martwe ...):

A w emulatorze SDK w wersji 21:

AppCompat 23.2 wprowadza rysunki wektorowe dla wszystkich urządzeń z systemem Android 2.1 lub nowszym. Obrazy są skalowane prawidłowo, niezależnie od szerokości / wysokości określonej w pliku XML elementu wektorowego do rysowania. Niestety ta implementacja nie jest używana na poziomie API 21 i wyższym (na korzyść implementacji natywnej).

Dobra wiadomość jest taka, że ​​możemy zmusić AppCompat do używania jego implementacji na poziomach API 21 i 22. Zła wiadomość jest taka, że ​​musimy użyć do tego refleksji.

Przede wszystkim upewnij się, że używasz najnowszej wersji AppCompat i że masz włączoną nową implementację wektorów:

android {
  defaultConfig {
    vectorDrawables.useSupportLibrary = true
  }
}

dependencies {
    compile 'com.android.support:appcompat-v7:23.2.0'
}

Następnie wywołaj useCompatVectorIfNeeded();onCreate () swojej aplikacji:

private void useCompatVectorIfNeeded() {
    int sdkInt = Build.VERSION.SDK_INT;
    if (sdkInt == 21 || sdkInt == 22) { //vector drawables scale correctly in API level 23
        try {
            AppCompatDrawableManager drawableManager = AppCompatDrawableManager.get();
            Class<?> inflateDelegateClass = Class.forName("android.support.v7.widget.AppCompatDrawableManager$InflateDelegate");
            Class<?> vdcInflateDelegateClass = Class.forName("android.support.v7.widget.AppCompatDrawableManager$VdcInflateDelegate");

            Constructor<?> constructor = vdcInflateDelegateClass.getDeclaredConstructor();
            constructor.setAccessible(true);
            Object vdcInflateDelegate = constructor.newInstance();

            Class<?> args[] = {String.class, inflateDelegateClass};
            Method addDelegate = AppCompatDrawableManager.class.getDeclaredMethod("addDelegate", args);
            addDelegate.setAccessible(true);
            addDelegate.invoke(drawableManager, "vector", vdcInflateDelegate);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

Na koniec upewnij się, że używasz app:srcCompatzamiast android:srcustawiania obrazu ImageView:

<ImageView
    android:layout_width="400dp"
    android:layout_height="400dp"
    app:srcCompat="@drawable/icon_bell"/>

Twoje rysunki wektorowe powinny teraz poprawnie skalować się!

1) Dlaczego w wektorze do rysowania istnieje specyfikacja szerokości / wysokości? Myślałem, że chodzi o to, że skalują się w górę iw dół bezstratnie, przez co szerokość i wysokość nie mają znaczenia w swojej definicji?

To tylko domyślny rozmiar wektora na wypadek, gdybyś nie zdefiniował go w widoku układu. (tj. używasz zawijania zawartości dla wysokości i szerokości widoku obrazu)

2) Czy możliwe jest użycie pojedynczego wektora do rysowania, który działa jako rysowany w trybie 24dp na TextView, a także dużego obrazu o szerokości bliskiej ekranu?

Tak, jest to możliwe i nie miałem żadnego problemu ze zmianą rozmiaru, o ile uruchomione urządzenie korzysta z Lollipopa lub nowszego. W poprzednich interfejsach API wektor jest konwertowany na pliki PNG dla różnych rozmiarów ekranu podczas tworzenia aplikacji.

3) Jak efektywnie wykorzystać atrybuty szerokości / wysokości i jaka jest różnica z viewportWidth / Height?

Wpływa to na sposób wykorzystania przestrzeni wokół wektora. tzn. możesz go użyć do zmiany "grawitacji" wektora wewnątrz rzutni, sprawić, by wektor miał domyślny margines, zostawić pewne części wektora poza rzutnią itd. Normalnie po prostu ustawiasz je na takie same rozmiar.

Rozwiązuję swój problem po prostu zmieniam rozmiar obrazu wektorowego. Od początku był to zasób:

<vector xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:aapt="http://schemas.android.com/aapt"
    android:width="24dp"
    android:height="24dp"
    android:viewportHeight="300"
    android:viewportWidth="300">

I zmieniłem to na 150dp (rozmiar ImageView w układzie z tym zasobem wektorowym), na przykład:

<vector xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:aapt="http://schemas.android.com/aapt"
    android:width="150dp"
    android:height="150dp"
    android:viewportHeight="300"
    android:viewportWidth="300">

Na mnie to działa.

Muszę próbować tych sposobów, ale niestety żaden z nich nie zadziałał. Staram fitXYsię ImageView, staram używając app:srcCompatale nawet nie można go używać. ale znalazłem podstępny sposób:

ustaw Drawable to backgroundof your ImageView.

Ale celem tej drogi są wymiary widoków. jeśli masz ImageViewnieprawidłowe wymiary, element do rysowania zostanie rozciągnięty. musisz kontrolować to w wersjach wcześniejszych niż Lollipop lub Użyj niektórych widoków PercentRelativeLayout.

Mam nadzieję, że to pomocne.

Po pierwsze : zaimportuj svg do rysowania: (( https://www.learn2crack.com/2016/02/android-studio-svg.html ))

1 Kliknij prawym przyciskiem myszy folder do rysowania i wybierz Nowy -> Zasób wektorowy

2- Vector Asset Studio zapewnia opcję wyboru wbudowanych ikon materiałów lub własnego lokalnego pliku svg. W razie potrzeby możesz zastąpić domyślny rozmiar.

Po drugie : jeśli chcesz uzyskać wsparcie z Android API 7+, musisz użyć nagrania Android Support Library (( https://stackoverflow.com/a/44713221/1140304 ))

1- dodaj

vectorDrawables.useSupportLibrary = true

do pliku build.gradle.

2-Użyj przestrzeni nazw w układzie zawierającym imageView:

xmlns:app="http://schemas.android.com/apk/res-auto"

Po trzecie : ustaw imageView w android: scaleType = "fitXY" i użyj app: srcCompat

 <ImageView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:scaleType="fitXY"
        app:srcCompat="@drawable/ic_menu" />

Po czwarte : jeśli chcesz ustawić svg w kodzie java, musisz dodać poniższy wiersz na oncreate methoed

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

Dla mnie powodem, dla którego wektory były konwertowane na png, był android:fillType="evenodd"atrybut w moim wektorze do rysowania. Kiedy usunąłem wszystkie wystąpienia tego atrybutu z mojego rysunku (w związku z tym domyślny nonzerotyp wypełnienia zastosowany do wektora), następnym razem, gdy aplikacja została zbudowana, wszystko było w porządku.