Aspose.Slides für Xamarin

Übersicht

Xamarin ist ein Framework, das für die mobile Entwicklung in .NET C# verwendet wird. Xamarin verfügt über Werkzeuge und Bibliotheken, die die Fähigkeiten der .NET‑Plattform erweitern. Es ermöglicht Entwicklern, Anwendungen für das Android‑Betriebssystem zu erstellen.

Für die Entwicklung mit Xamarin können Entwickler ihre üblichen Entwicklungsumgebungen (C#, Visual Studio und Bibliotheken von Drittanbietern) verwenden.

Aspose.Slides API funktioniert auf der Xamarin‑Plattform. Dafür fügt das Aspose.Slides .NET‑Paket eine separate DLL für Xamarin hinzu. Aspose.Slides für Xamarin unterstützt die meisten Funktionen, die in der .NET‑Version verfügbar sind:

Konvertieren und Anzeigen von Präsentationen.
Bearbeiten von Inhalten in Präsentationen: Text, Formen, Diagramme, SmartArt, Audio/Video, Schriftarten usw.
Umgang mit Animationen, 2D‑Effekten, WordArt usw.
Umgang mit Metadaten und Dokumenteigenschaften.
Drucken, Klonen, Zusammenführen, Vergleichen, Aufteilen usw.

Wir haben einen Vergleich der gesamten Funktionen in einem anderen Abschnitt nahe dem Ende dieser Seite bereitgestellt.

In der Aspose.Slides für Xamarin API sind Klassen, Namespaces, Logik und Verhalten so ähnlich wie möglich an die .NET‑Version angelehnt. Sie können Ihre Aspose.Slides .NET‑Anwendungen mit minimalen Aufwand nach Xamarin migrieren.

Schnelles Beispiel

Sie können Aspose.Slides für Xamarin nutzen, um Ihre C#‑Anwendung über Slides for Android zu erstellen und zu verwenden.

Wir stellen ein Beispiel einer Android‑App über Xamarin bereit, das Aspose.Slides verwendet, um Präsentationsfolien anzuzeigen und bei Berührung eine neue Form auf der Folie hinzuzufügen. Den vollständigen Quellcode der Beispiele finden Sie auf GitHub.

Lassen Sie uns beginnen, indem wir eine Xamarin‑Android‑App erstellen:

todo:image_alt_text

Zuerst erstellen wir ein Inhalts‑Layout, das eine Image‑View sowie Vor‑ und Zurück‑Buttons enthält:

todo:image_alt_text

XML - content_main.xml - Inhaltlayout erstellen

 <LinearLayout
    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:orientation=    "vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:showIn="@layout/activity_main">
    <LinearLayout
        android:orientation="horizontal"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_weight="1"
        android:id="@+id/linearLayout1">
        <ImageView
            android:src="@android:drawable/ic_menu_gallery"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:id="@+id/imageView"
            android:scaleType="fitCenter" />
    </LinearLayout>

    <LinearLayout
        android:orientation="horizontal"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_weight="10"
        android:id="@+id/linearLayout2">
        <Button
            android:text="Prev"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:id="@+id/buttonPrev" />
        <Button
            android:text="Next"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:id="@+id/buttonNext"/>
    </LinearLayout>
</LinearLayout>

Hier referenzieren wir die Bibliothek „Aspose.Slides.Droid.dll“, die eine Beispieldatei („HelloWorld.pptx“) in die Xamarin‑Anwendung‑Assets einbindet und deren Initialisierung in MainActivity hinzufügt:

C# - MainActivity.cs - Initialisierung

[Activity(Label = "@string/app_name", Theme = "@style/AppTheme.NoActionBar", MainLauncher = true)]
public class MainActivity : AppCompatActivity
{
    private Aspose.Slides.Presentation presentation;

    protected override void OnCreate(Bundle savedInstanceState)
    {
        base.OnCreate(savedInstanceState);
        SetContentView(Resource.Layout.activity_main);
    }

    protected override void OnResume()
    {
        if (presentation == null)
        {
            using (Stream input = Assets.Open("HelloWorld.pptx"))
            {
                presentation = new Aspose.Slides.Presentation(input);
            }
        }
    }

    protected override void OnPause()
    {
        if (presentation != null)
        {
            presentation.Dispose();
            presentation = null;
        }
    }
}

Fügen wir nun die Funktion hinzu, um bei Betätigung der Vor‑ und Zurück‑Buttons die entsprechenden Folien anzuzeigen:

C# - MainActivity.cs - Folien bei Vor‑ und Zurück‑Button‑Klick anzeigen

[Activity(Label = "@string/app_name", Theme = "@style/AppTheme.NoActionBar", MainLauncher = true)]
public class MainActivity : AppCompatActivity
{
    private Button buttonNext;
    private Button buttonPrev;
    ImageView imageView;

    private Aspose.Slides.Presentation presentation;

    private int currentSlideNumber;

    protected override void OnCreate(Bundle savedInstanceState)
    {
        base.OnCreate(savedInstanceState);
        SetContentView(Resource.Layout.activity_main);
    }

    protected override void OnResume()
    {
        base.OnResume();
        LoadPresentation();
        currentSlideNumber = 0;
        if (buttonNext == null)
        {
            buttonNext = FindViewById<Button>(Resource.Id.buttonNext);
        }

        if (buttonPrev == null)
        {
            buttonPrev = FindViewById<Button>(Resource.Id.buttonPrev);
        }

        if(imageView == null)
        {
            imageView= FindViewById<ImageView>(Resource.Id.imageView);
        }

        buttonNext.Click += ButtonNext_Click;
        buttonPrev.Click += ButtonPrev_Click;
        RefreshButtonsStatus();
        ShowSlide(currentSlideNumber);
    }

    private void ButtonNext_Click(object sender, System.EventArgs e)
    {
        if (currentSlideNumber > (presentation.Slides.Count - 1))
        {
            return;
        }

        ShowSlide(++currentSlideNumber);
        RefreshButtonsStatus();
    }

    private void ButtonPrev_Click(object sender, System.EventArgs e)
    {
        if (currentSlideNumber == 0)
        {
            return;
        }

        ShowSlide(--currentSlideNumber);
        RefreshButtonsStatus();
    }

    protected override void OnPause()
    {
        base.OnPause();
        if (buttonNext != null)
        {
            buttonNext.Dispose();
            buttonNext = null;
        }

        if (buttonPrev != null)
        {
            buttonPrev.Dispose();
            buttonPrev = null;
        }

        if(imageView != null)
        {
            imageView.Dispose();
            imageView = null;
        }

        DisposePresentation();
    }

    private void RefreshButtonsStatus()
    {
        buttonNext.Enabled = currentSlideNumber < (presentation.Slides.Count - 1);
        buttonPrev.Enabled = currentSlideNumber > 0;
    }

    private void ShowSlide(int slideNumber)
    {
        Aspose.Slides.Drawing.Xamarin.Size size = presentation.SlideSize.Size.ToSize();
        Aspose.Slides.Drawing.Xamarin.Bitmap bitmap = presentation.Slides[slideNumber].GetThumbnail(size);
        imageView.SetImageBitmap(bitmap.ToNativeBitmap());
    }

    private void LoadPresentation()
    {
        if(presentation != null)
        {
            return;
        }

        using (Stream input = Assets.Open("HelloWorld.pptx"))
        {
            presentation = new Aspose.Slides.Presentation(input);
        }
    }

    private void DisposePresentation()
    {
        if(presentation == null)
        {
            return;
        }
        
        presentation.Dispose();
        presentation = null;
    }

}

Abschließend implementieren wir eine Funktion, die bei Berührung der Folie eine Ellipse hinzufügt:

C# - MainActivity.cs - Ellipse per Folien‑Klick hinzufügen

 private void ImageView_Touch(object sender, Android.Views.View.TouchEventArgs e)
{
    int[] location = new int[2];
    imageView.GetLocationOnScreen(location);
    int x = (int)e.Event.GetX();
    int y = (int)e.Event.GetY();
    int posX = x - location[0];
    int posY = y - location[0];
    
    Aspose.Slides.Drawing.Xamarin.Size presSize = presentation.SlideSize.Size.ToSize();

    float coeffX = (float)presSize.Width / imageView.Width;
    float coeffY = (float)presSize.Height / imageView.Height;
    int presPosX = (int)(posX * coeffX);
    int presPosY = (int)(posY * coeffY);
    int width = presSize.Width / 50;

    int height = width;
    Aspose.Slides.IAutoShape ellipse = presentation.Slides[currentSlideNumber].Shapes.AddAutoShape(Aspose.Slides.ShapeType.Ellipse, presPosX, presPosY, width, height);
    ellipse.FillFormat.FillType = Aspose.Slides.FillType.Solid;

    Random random = new Random();
    Aspose.Slides.Drawing.Xamarin.Color slidesColor = Aspose.Slides.Drawing.Xamarin.Color.FromArgb(random.Next(256), random.Next(256), random.Next(256));
    ellipse.FillFormat.SolidFillColor.Color = slidesColor;
    ShowSlide(currentSlideNumber);
}

Jeder Klick auf die Präsentationsfolie fügt eine zufällig gefärbte Ellipse hinzu:

todo:image_alt_text

Unterstützte Funktionen

FUNKTIONEN	Aspose.Slides for .NET	Aspose.Slides for Xamarin
Präsentationsfunktionen:
Neue Präsentationen erstellen
PowerPoint 97 ‑ 2003‑Formate öffnen/speichern
PowerPoint 2007‑Formate öffnen/speichern
PowerPoint 2010‑Erweiterungen unterstützen
PowerPoint 2013‑Erweiterungen unterstützen
PowerPoint 2016‑Funktionen unterstützen	eingeschränkt	eingeschränkt
PowerPoint 2019‑Funktionen unterstützen	eingeschränkt	eingeschränkt
PPT → PPTX‑Konvertierung
PPTX → PPT‑Konvertierung
PPTX in PPT	eingeschränkt	eingeschränkt
Themes verarbeiten
Makros verarbeiten
Dokumenteigenschaften verarbeiten
Passwortschutz
Schnelle Textextraktion
Schriftarten einbetten
Kommentare rendern
Unterbrechen von langlaufenden Aufgaben
Exportformate:
PDF
XPS
HTML
TIFF
ODP	eingeschränkt	eingeschränkt
SWF	eingeschränkt	eingeschränkt
SVG
Importformate:
HTML	eingeschränkt	eingeschränkt
ODP
THMX
Master‑Folien‑Funktionen:
Zugriff auf alle vorhandenen Master‑Folien
Erstellen/Entfernen von Master‑Folien
Klonen von Master‑Folien
Layout‑Folien‑Funktionen:
Zugriff auf alle vorhandenen Layout‑Folien
Erstellen/Entfernen von Layout‑Folien
Klonen von Layout‑Folien
Folien‑Funktionen:
Zugriff auf alle vorhandenen Folien
Erstellen/Entfernen von Folien
Klonen von Folien
Exportieren von Folien zu Bildern
Erstellen/Bearbeiten/Entfernen von Folien‑Abschnitten
Notizfolien‑Funktionen:
Zugriff auf alle vorhandenen Notizfolien
Form‑Funktionen:
Zugriff auf alle Folien‑Formen
Neue Formen hinzufügen
Formen klonen
Einzelne Formen zu Bildern exportieren
Unterstützte Form‑Typen:
Alle vordefinierten Form‑Typen
Bild‑Frames
Tabellen
Diagramme
SmartArt
Legacy‑Diagramme
WordArt
OLE, ActiveX‑Objekte	eingeschränkt	eingeschränkt
Video‑Frames
Audio‑Frames
Verbinder
Gruppenformen‑Funktionen:
Zugriff auf Gruppenformen
Erstellen von Gruppenformen
Gruppenformen auflösen
Form‑Effekt‑Funktionen:
2D‑Effekte	eingeschränkt	eingeschränkt
3D‑Effekte
Text‑Funktionen:
Absatzformatierung
Portionen‑Formatierung
Animations‑Funktionen:
Animation zu SWF exportieren
Animation zu HTML exportieren

Wie man Aspose.Slides in Docker ausführt Sicherheit