Xamarin.Android
Veröffentlichen Ihres Xamarin.Android APK
Suche…
Einführung
In diesem Thema erfahren Sie, wie Sie Ihre Xamarin.Android-App für den Freigabemodus vorbereiten und wie Sie sie optimieren können.
Vorbereiten der APK im Visual Studio
Sie haben Ihre App fertiggestellt, im Debug-Modus getestet und funktionieren einwandfrei. Nun möchten Sie es für die Veröffentlichung im Google Play Store vorbereiten.
Die Xamarin-Dokumentation bietet hier gute Informationen:
Android Manifest
Klicken Sie mit der rechten Maustaste in Visual Studio auf Ihr Xamarin.Android-Projekt im Projektmappen-Explorer, und wählen Sie Eigenschaften aus. Wechseln Sie dann zur Registerkarte Android Manifest, um diesen Bildschirm anzuzeigen:
Im Gegensatz zu Android Studio oder Eclipse müssen Sie die Datei AndroidManifest.xml nicht durch Schreiben festlegen. Xamarin und Visual Studio erledigen das für Sie. Aktivitäten, BroadcastReceiver und Services werden in Android Manifest eingefügt, indem bestimmte Attribute in ihren Klassen deklariert werden .
In diesem Bildschirm stehen folgende Optionen zur Verfügung:
- Anwendungsname : Dies ist der Anwendungsname , der für den Benutzer sichtbar ist.
- Paketname: Dies ist der Name des Pakets. Es muss eindeutig sein, dh es darf nicht den gleichen Paketnamen anderer Apps im Google Play Store verwenden.
- Anwendungssymbol : Dies ist das Symbol, das für den Benutzer sichtbar ist. Dies entspricht dem in Android Studio- oder Eclipse-Projekten verwendeten @ drawable / ic_launcher.
- Versionsnummer : Die Versionsnummer wird von Google Play zur Versionskontrolle verwendet. Wenn Sie ein APK für eine aktualisierte Version Ihrer App veröffentlichen möchten, müssen Sie diese Nummer für jedes neue Upgrade um 1 erhöhen.
- Versionsname : Dies ist der Versionsname, der dem Benutzer angezeigt wird.
- Installationsort: Dies bestimmt , wo Ihre APK, im Gerätespeicher oder auf der SD - Karte installiert wird.
- Erforderliche Berechtigungen : Hier legen Sie fest, welche Berechtigungen für Ihre App erforderlich sind.
Android-Optionen
Im folgenden Bildschirm können Sie die Compiler-Optionen konfigurieren. Wenn Sie hier die richtigen Optionen verwenden, können Sie Ihre APK-Größe erheblich reduzieren und Fehler vermeiden.
- Konfiguration : Aktiv (Freigabe) .
- Plattform : Aktiv (beliebige CPU) . Diese sind erforderlich, um Ihr APK für den Google Play Store zu erstellen. Wenn die Konfiguration auf "Debuggen" eingestellt ist, wird sie von Google Play nicht akzeptiert.
- Shared Runtime verwenden : false . Wenn Sie den Wert auf true setzen, verwendet der APK Mono Runtime zur Ausführung. Die Mono Runtime wird beim Debuggen über USB automatisch installiert, nicht jedoch in der Release-APK. Wenn Mono Runtime nicht auf dem Gerät installiert ist und diese Option in Release APK auf true gesetzt ist, stürzt die App ab.
- Generieren Sie ein Paket (.apk) pro ausgewähltem ABI : false . Erstellen Sie aus Gründen der Kompatibilität Ihr APK für so viele Plattformen wie möglich.
- Aktivieren Sie Multi-Dex : true , aber Sie können es auf false setzen, wenn Ihre App nicht sehr komplex ist (dh weniger als 65536 Methoden enthält, siehe hier ).
- Proguard aktivieren : true . Dadurch wird das Proguard-Tool aktiviert, das Java-Code in Ihrer App verschleiert. Beachten Sie, dass es nicht für .NET-Code gilt. Wenn Sie .NET-Code verschleiern möchten, müssen Sie Dotfuscator verwenden . Weitere Informationen zu Proguard for Xamarin.Android finden Sie hier .
- Aktivieren Sie die Entwicklerinstrumentierung (Debugging und Profiling) : false für Release APK.
- Verknüpfen : SDK und Benutzerbaugruppen . Dadurch entfernt der Xamarin Linker alle nicht verwendeten Klassen aus dem SDK und Ihren Code, wodurch die APK-Größe reduziert wird.
Wichtig
Xamarin.Linker entfernt möglicherweise Klassen, die scheinbar von Ihrem Code nicht verwendet werden, insbesondere wenn sie sich im Kern des Projekts (PCL-Bibliothek) befinden. Um dies zu vermeiden, können Sie entweder die Verknüpfung auf "Nur Sdk-Assemblies" setzen oder das Attribut "Preserve" in Ihren Klassen verwenden. Beispiel:
PreserveAttribute.cs
namespace My_App_Core.Models
{
public sealed class PreserveAttribute : System.Attribute
{
public bool AllMembers;
public bool Conditional;
}
}
In einer Klasse:
using System;
namespace My_App_Core.Models
{
[Preserve(AllMembers = true)]
public class ServiceException : Exception
{
public int errorCode;
[Preserve(AllMembers = true)]
public ServiceException() { }
[Preserve(AllMembers = true)]
public ServiceException(int errorCode)
{
this.errorCode = errorCode;
}
}
}
- Unterstützte Architekturen : Wählen Sie alle aus Kompatibilitätsgründen aus.
Erstellen Sie nach dem Konfigurieren alles neu, um sicherzustellen, dass es erfolgreich erstellt wird.
Erstellen der APK für den Freigabemodus
Sie haben die Konfiguration Ihres Android-Projekts für Release abgeschlossen. Das folgende Tutorial zeigt, wie Sie den APK in Visual Studio generieren. Ein vollständiges Tutorial aus der Xamarin-Dokumentation finden Sie hier:
Um die APK-Datei zu erstellen, klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt Xamarin.Android und wählen Sie Archiv ...
Dadurch wird der Archivmanager geöffnet, das Projekt wird archiviert und die Erstellung der APK-Datei vorbereitet.
Klicken Sie nach Abschluss der Archivierung des Projekts auf Verteilen, um fortzufahren.
Auf dem Bildschirm "Verteilen" werden zwei Optionen angezeigt: Ad-hoc und Google Play. Beim ersten wird ein APK erstellt und auf Ihrem Computer gespeichert. Der zweite wird die App direkt in Google Play veröffentlichen.
Es wird empfohlen, die erste zu wählen, damit Sie den APK bei Bedarf in anderen Geräten testen können.
Im folgenden Bildschirm wird ein Android Key Store benötigt, um den APK zu signieren. Wenn Sie bereits über eines verfügen, klicken Sie auf Importieren ...; Wenn Sie dies nicht tun, können Sie einen neuen Android Key Store erstellen, indem Sie auf + klicken.
Erstellen eines neuen Android Key Store-Bildschirms:
Um die APK zu erstellen, klicken Sie auf Speichern unter. Sie werden möglicherweise aufgefordert, das Schlüsselspeicher-Kennwort einzugeben.
Wenn der Vorgang abgeschlossen ist, können Sie im Ordner "Archiv" auf "Ordner öffnen" klicken, um die generierte APK-Datei anzuzeigen.
Aktivieren von MultiDex in Ihrem Xamarin.Android APK
MultiDex ist eine Bibliothek im Android APK, mit der die App über 65.536 Methoden verfügt.
Die Android-APKs verfügen über ausführbare Dalvik-Dateien (.dex), die die generierten Bytecodes enthalten, die aus Ihrem Java-Code kompiliert wurden. Jede DEX-Datei kann bis zu 65.536 Methoden enthalten (2 ^ 16).
Android-Betriebssystemversionen vor Android 5.0 Lollipop (API 21) verwenden die Dalvik-Laufzeitumgebung, die nur eine .dex-Datei pro APK unterstützt, wobei die APK auf 65.536 Methoden beschränkt ist. Ab Android 5.0 wird für das Android-Betriebssystem die ART-Laufzeitumgebung verwendet, die mehr als eine .dex-Datei pro APK unterstützt, wodurch das Limit vermieden wird.
Um das 65k-Methodenlimit in Android-Versionen unter API 21 zu überschreiten, müssen die Entwickler die MultiDex-Unterstützungsbibliothek verwenden. Der MultiDex erstellt zusätzliche classes.dex-Dateien (classes2.dex, classes3.dex, ...), die diese in der classes.dex-Datei referenzieren. Wenn die App mit dem Laden beginnt, verwendet sie eine MultiDexApplication-Klasse, um die zusätzlichen .dex-Dateien zu laden.
Wenn Ihre Android-App eine Mindest-SDK-Version über oder gleich API 21 (Android 5.0 Lollipop) anstrebt, ist es nicht erforderlich, die MultiDex-Bibliothek zu verwenden, da das Betriebssystem die zusätzlichen .dex-Dateien nativ verarbeitet. Wenn der Entwickler jedoch aus Kompatibilitätsgründen ältere Android-Betriebssysteme unterstützen möchte, sollte er die MultiDex-Bibliothek verwenden.
So verwenden Sie MultiDex in Ihrer Xamarin.Android-App
Um MultiDex in Ihrer Xamarin.Android-App zu aktivieren, gehen Sie zu Ihrem Projekt Eigenschaften -> Android-Optionen -> Paketierung -> Multi-Dex aktivieren, wie im folgenden Druckbildschirm:
Dann müssen Sie eine MultiDexApplication-Klasse in Ihrer App erstellen. Erstellen Sie im Stammverzeichnis des Projekts eine neue Klasse (klicken Sie im Projektmappen-Explorer mit der rechten Maustaste in das Projekt, Hinzufügen ... -> Klasse oder Umschalt + Alt + C). Kopieren Sie in der neuen Klassendatei den folgenden Code und ersetzen Sie den Namespace Sample durch den Namen Ihres Xamarin.Android-Projekt-Namespaces.
using System;
using Android.App;
using Android.Runtime;
using Java.Interop;
namespace Sample
{
[Register("android/support/multidex/MultiDexApplication", DoNotGenerateAcw = true)]
public class MultiDexApplication : Application
{
internal static readonly JniPeerMembers _members =
new XAPeerMembers("android/support/multidex/MultiDexApplication", typeof (MultiDexApplication));
internal static IntPtr java_class_handle;
private static IntPtr id_ctor;
[Register(".ctor", "()V", "", DoNotGenerateAcw = true)]
public MultiDexApplication()
: base(IntPtr.Zero, JniHandleOwnership.DoNotTransfer)
{
if (Handle != IntPtr.Zero)
return;
try
{
if (GetType() != typeof (MultiDexApplication))
{
SetHandle(
JNIEnv.StartCreateInstance(GetType(), "()V"),
JniHandleOwnership.TransferLocalRef);
JNIEnv.FinishCreateInstance(Handle, "()V");
return;
}
if (id_ctor == IntPtr.Zero)
id_ctor = JNIEnv.GetMethodID(class_ref, "<init>", "()V");
SetHandle(
JNIEnv.StartCreateInstance(class_ref, id_ctor),
JniHandleOwnership.TransferLocalRef);
JNIEnv.FinishCreateInstance(Handle, class_ref, id_ctor);
}
finally
{
}
}
protected MultiDexApplication(IntPtr javaReference, JniHandleOwnership transfer)
: base(javaReference, transfer)
{
}
internal static IntPtr class_ref
{
get { return JNIEnv.FindClass("android/support/multidex/MultiDexApplication", ref java_class_handle); }
}
protected override IntPtr ThresholdClass
{
get { return class_ref; }
}
protected override Type ThresholdType
{
get { return typeof (MultiDexApplication); }
}
}
}
Wenn Sie in Visual Studio für Windows entwickeln, gibt es auch einen Fehler in den Android SDK-Build-Tools, die Sie beheben müssen, um die classes.dex-Dateien beim Erstellen Ihres Projekts ordnungsgemäß zu erstellen.
Gehen Sie zu Ihrem Android SDK-Ordner, öffnen Sie den Build-Tools-Ordner, und es werden Ordner mit den Nummern der Android SDK-Compiler angezeigt, z.
C: \ android-sdk \ build-tools \ 23.0.3 \
C: \ android-sdk \ build-tools \ 24.0.1 \
C: \ android-sdk \ build-tools \ 25.0.2 \
In jedem dieser Ordner befindet sich eine Datei namens mainClassesDex.bat , ein Batch-Skript, das zum Erstellen der classes.dex-Dateien verwendet wird. Öffnen Sie jede mainClassesDex.bat-Datei mit einem Texteditor (Notepad oder Notepad ++) und suchen und ersetzen Sie den Block in seinem Skript:
if DEFINED output goto redirect
call "%java_exe%" -Djava.ext.dirs="%frameworkdir%" com.android.multidex.MainDexListBuilder "%disableKeepAnnotated%" "%tmpJar%" "%params%"
goto afterClassReferenceListBuilder
:redirect
call "%java_exe%" -Djava.ext.dirs="%frameworkdir%" com.android.multidex.MainDexListBuilder "%disableKeepAnnotated%" "%tmpJar%" "%params%" 1>"%output%"
:afterClassReferenceListBuilder
Mit dem Block:
SET params=%params:'=%
if DEFINED output goto redirect
call "%java_exe%" -Djava.ext.dirs="%frameworkdir%" com.android.multidex.MainDexListBuilder %disableKeepAnnotated% "%tmpJar%" %params%
goto afterClassReferenceListBuilder
:redirect
call "%java_exe%" -Djava.ext.dirs="%frameworkdir%" com.android.multidex.MainDexListBuilder %disableKeepAnnotated% "%tmpJar%" %params% 1>"%output%"
:afterClassReferenceListBuilder
Speichern Sie jede mainClassesDex.bat nach Änderungen im Texteditor.
Nach den obigen Schritten sollten Sie in der Lage sein, Ihre Xamarin.Android-App mit MultiDex erfolgreich zu erstellen.
Aktivieren von ProGuard in Ihrem Xamarin.Android APK
ProGuard ist ein Werkzeug, das im Erstellungsprozess verwendet wird, um den Java-Code Ihres APK zu optimieren und zu verschleiern sowie nicht verwendete Klassen zu entfernen. Die resultierende APK bei Verwendung von ProGuard hat eine geringere Größe und ist schwieriger zu entwickeln (Dekompilierung).
ProGuard kann auch in Xamarin.Android-Apps verwendet werden. Außerdem wird die APK-Dateigröße reduziert und der Java-Code verschleiert. Beachten Sie jedoch, dass die ProGuard-Verschleierung nur für Java-Code gilt. Um .NET-Code zu verschleiern, sollte der Entwickler Dotfuscator oder ähnliche Tools verwenden.
So verwenden Sie ProGuard in Ihrer Xamarin.Android-App
Um ProGuard in Ihrer Xamarin.Android-App zu aktivieren, gehen Sie zu Ihrem Projekt Eigenschaften -> Android-Optionen -> Paketierung -> ProGuard aktivieren, wie im folgenden Druckbildschirm:
Dies ermöglicht ProGuard beim Erstellen Ihrer App.
Xamarin.Android legt standardmäßig seine eigenen Konfigurationen für ProGuard fest, die sich in den Ordnern obj/Debug/proguard oder obj/Release/proguard in den Dateien proguard_project_primary.cfg , proguard_project_references.cfg und proguard_xamarin.cfg . Die drei Dateien werden als Konfigurationen für ProGuard zusammengefasst und beim Erstellen automatisch von Xamarin erstellt.
Wenn der Entwickler die ProGuard-Optionen weiter anpassen möchte, kann er im Projektstamm eine Datei mit dem Namen proguard.cfg (andere Namen sind ebenfalls gültig, sofern die Erweiterung .cfg ist) und die Build-Aktion auf ProguardConfiguration setzen. wie im Bild unten:
In die Datei können benutzerdefinierte ProGuard-Optionen eingefügt werden, z. B. -dontwarn , -keep class und andere .
Wichtig
Wie üblich (April / 2017) enthält das normalerweise heruntergeladene Android SDK eine ältere ProGuard-Version, die zu Fehlern beim Erstellen der App mit Java 1.8 führen kann. Beim Erstellen zeigt die Fehlerliste die folgende Meldung an:
Error
Can't read [C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\MonoAndroid\v7.0\mono.android.jar]
(Can't process class [android/app/ActivityTracker.class] (Unsupported class version number [52.0] (maximum 51.0, Java 1.7))) [CREATEMULTIDEXMAINDEXCLASSLIST]
Um dieses Problem zu beheben, müssen Sie die neueste Version von ProGuard ( hier ) herunterladen und den Inhalt der ZIP-Datei nach android-sdk\tools\proguard\ . Dadurch wird der ProGuard aktualisiert und der Bauprozess sollte problemlos ablaufen.
Danach sollten Sie in der Lage sein, Ihre Xamarin.Android-App mit ProGuard erfolgreich zu erstellen.
"Rätselhafte" Fehler im Zusammenhang mit ProGuard und Linker
Sie haben eine großartige App erstellt und in Debug getestet, mit guten Ergebnissen. Alles hat gut funktioniert!
Dann haben Sie sich jedoch entschieden, Ihre App für die Veröffentlichung vorzubereiten. Sie haben MultiDex, ProGuard und Linker eingerichtet und dann funktioniert es nicht mehr.
Dieses Tutorial soll Ihnen helfen, allgemeine Probleme im Zusammenhang mit ProGuard und Linker herauszufinden, die mysteriöse Fehler verursachen können.
Informationen zu Xamarin.Linker
Xamarin.Linker ist ein Werkzeug im Erstellungsprozess, das nicht verwendeten Code und Klassen aus Ihrem .NET-Code (nicht Java-Code) entfernt . In den Eigenschaften Ihres Projekts -> Android-Optionen -> Linker wird ein Auswahlfeld angezeigt, das mit den Optionen verknüpft wird:
Keine : Es wird kein Code entfernt.
Nur Sdk-Assemblys : Diese Option veranlasst den Xamarin.Linker, nur in den Xamarin-Bibliotheken nach nicht verwendetem Code zu suchen . Diese Option ist sicher.
Sdk- und Benutzerbaugruppen : Mit dieser Option wird der Xamarin.Linker in den Xamarin-Bibliotheken und im Projektcode (einschließlich PCLs, Xamarin-Komponenten und NuGet-Paketen) auf nicht verwendeten Code überprüft. Diese Option ist nicht immer sicher!
Bei Verwendung der Option "Sdk and User Assemblies" kann Xamarin.Linker denken, dass Teile des Codes nicht verwendet werden, wenn sie tatsächlich verwendet werden! Dies kann dazu führen, dass einige Bibliotheken nicht mehr ordnungsgemäß funktionieren und Fehler in Ihrer App verursachen.
Damit der Xamarin.Linker keinen Code entfernt, gibt es 3 Optionen:
- Festlegen der Linking-Option auf Keine oder Nur Sdk-Assemblies;
- Überspringen Sie Verknüpfungsanordnungen.
- Verwenden des Attributs "Preserve".
Beispiel für 2. Überspringen von Verknüpfungsbaugruppen
In dem folgenden Beispiel verursachte die Verwendung von Xamarin.Linker ein NuGet-Paket ( Octokit ), das funktioniert, um nicht mehr zu funktionieren, da es keine Verbindung zum Internet mehr herstellen konnte:
[0:] ERROR
[0:] SOURCE: mscorlib
[0:] MESSAGE: Object reference not set to an instance of an object.
[0:] STACK TRACE: at Octokit.PocoJsonSerializerStrategy.DeserializeObject (System.Object value, System.Type type) [0x003d8] in D:\repos\octokit.net\Octokit\SimpleJson.cs:1472
at Octokit.Internal.SimpleJsonSerializer+GitHubSerializerStrategy.DeserializeObject (System.Object value, System.Type type) [0x001c3] in D:\repos\octokit.net\Octokit\Http\SimpleJsonSerializer.cs:165
at Octokit.SimpleJson.DeserializeObject (System.String json, System.Type type, Octokit.IJsonSerializerStrategy jsonSerializerStrategy) [0x00007] in D:\repos\octokit.net\Octokit\SimpleJson.cs:583
at Octokit.SimpleJson.DeserializeObject[T] (System.String json, Octokit.IJsonSerializerStrategy jsonSerializerStrategy) [0x00000] in D:\repos\octokit.net\Octokit\SimpleJson.cs:595
at Octokit.Internal.SimpleJsonSerializer.Deserialize[T] (System.String json) [0x00000] in D:\repos\octokit.net\Octokit\Http\SimpleJsonSerializer.cs:21
at Octokit.Internal.JsonHttpPipeline.DeserializeResponse[T] (Octokit.IResponse response) [0x000a7] in D:\repos\octokit.net\Octokit\Http\JsonHttpPipeline.cs:62
at Octokit.Connection+<Run>d__54`1[T].MoveNext () [0x0009c] in D:\repos\octokit.net\Octokit\Http\Connection.cs:574
--- End of stack trace from previous location where exception was thrown ---
Damit die Bibliothek wieder funktioniert, musste der Paketreferenzname im Feld Verknüpfungsassetten überspringen in Projekt -> Eigenschaften -> Android-Optionen -> Linker wie in der folgenden Abbildung hinzugefügt werden:
Danach begann die Bibliothek ohne Probleme zu arbeiten.
Beispiel für 3. Verwendung des Attributs "Preserve":
Xamarin.Linker erkennt als ungenutzten Code hauptsächlich Code aus Modellklassen im Kern Ihres Projekts.
Um die Klasse während des Verknüpfungsprozesses beizubehalten, können Sie das Attribut Preserve verwenden.
Erstellen Sie zunächst in Ihrem Projektkern eine Klasse namens PreserveAttribute.cs , fügen Sie den folgenden Code ein und ersetzen Sie den Namespace durch den Namespace Ihres Projekts:
PreserveAttribute.cs:
namespace My_App_Core.Models
{
public sealed class PreserveAttribute : System.Attribute
{
public bool AllMembers;
public bool Conditional;
}
}
Fügen Sie in jede Modellklasse Ihres Projektkerns das Attribut "Preserve" wie im folgenden Beispiel ein:
Country.cs:
using System;
using System.Collections.Generic;
namespace My_App_Core.Models
{
[Preserve(AllMembers = true)]
public class Country
{
public String name { get; set; }
public String ISOcode { get; set; }
[Preserve(AllMembers = true)]
public Country(String name, String ISOCode)
{
this.name = name;
this.ISOCode = ISOCode;
}
}
}
Danach entfernt der Verknüpfungsvorgang den erhaltenen Code nicht mehr.
Grundlegendes zu ProGuard
ProGuard ist ein Werkzeug im Aufbauprozess, das nicht verwendeten Code und Klassen aus Ihrem Java-Code entfernt . Es verschleiert und optimiert den Code.
Es kann jedoch vorkommen, dass ProGuard möglicherweise Code entfernt, den es als nicht verwendet erkennt, wenn dies nicht der Fall ist. Um dies zu vermeiden, muss der Entwickler die App debuggen (in Android Device Monitor und in Visual Studio Debug) und feststellen, welche Klasse entfernt wurde, um dann die ProGuard-Konfigurationsdatei so zu konfigurieren, dass die Klasse beibehalten wird.
Beispiel
Im nachstehenden Beispiel hat ProGuard zwei Klassen (Android.Support.V7.Widget.FitWindowsLinearLayout und Android.Support.Design.Widget.AppBarLayout) entfernt, die in AXML-Layoutdateien verwendet werden, aber im Code als nicht verwendet angesehen wurden. Die Entfernung verursachte beim Rendern des Aktivitätslayouts ClassNotFoundException im Java-Code:
layout_activitymain.axml:
<?xml version="1.0" encoding="utf-8"?>
<android.support.v4.widget.DrawerLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/activitymain_drawerlayout"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:fitsSystemWindows="true" <!-- ### HERE ### -->
tools:openDrawer="start">
<RelativeLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:fitsSystemWindows="true">
<!-- ### HERE ## -->
<android.support.design.widget.AppBarLayout
android:id="@+id/activitymain_appbarlayout"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:theme="@style/AppTheme.AppBarOverlay">
...
LogCat zeigt einen Fehler beim Erstellen des Layouts in SetContentView:
Um diesen Fehler zu beheben, mussten der ProGuard-Konfigurationsdatei des Projekts die folgenden Zeilen hinzugefügt werden:
-keep public class android.support.v7.widget.FitWindowsLinearLayout
-keep public class android.support.design.widget.AppBarLayout
Danach wurden beim Erstellen des Layouts keine Fehler mehr angezeigt.
ProGuard-Warnungen
ProGuard zeigt manchmal Warnungen in der Fehlerliste an, nachdem Sie Ihr Projekt erstellt haben. Obwohl sie die Frage aufwerfen, ob Ihre App in Ordnung ist oder nicht, weisen nicht alle Warnungen auf Probleme hin, insbesondere wenn Ihre App erfolgreich erstellt wurde.
Ein Beispiel dafür ist , wenn die Verwendung von Picasso Bibliothek: wenn ProGuard Verwendung dieser Warnungen zeigen kann wie okio.Okio: can't find referenced class (...) oder can't write resource [META-INF/MANIFEST.MF] (Duplicate zip entry [okhttp.jar:META-INF/MANIFEST.MF]) (...) , aber die App baut und die Bibliothek funktioniert ohne Probleme.