Aspose.Slides per Xamarin

Introduzione

Xamarin è un framework utilizzato per lo sviluppo mobile in .NET C#. Xamarin dispone di strumenti e librerie che estendono le capacità della piattaforma .NET. Consente agli sviluppatori di creare applicazioni per il sistema operativo Android.

Per lo sviluppo in Xamarin, i programmatori possono usare i loro ambienti di sviluppo abituali (C#, Visual Studio e librerie di terze parti).

L’API Aspose.Slides funziona sulla piattaforma Xamarin. Per questo, il pacchetto Aspose.Slides .NET aggiunge un DLL separato per Xamarin. Aspose.Slides per Xamarin supporta la maggior parte delle funzionalità disponibili nella versione .NET:

• conversione e visualizzazione di presentazioni.
• modifica dei contenuti nelle presentazioni: testo, forme, grafici, SmartArt, audio/video, caratteri, ecc.
• gestione/gestione delle animazioni, effetti 2D, WordArt, ecc.
• gestione/gestione dei metadati e delle proprietà del documento.
• stampa, clonazione, unione, confronto, divisione, ecc.

Abbiamo fornito un confronto delle funzionalità complete in un’altra sezione verso la fine di questa pagina.

Nell’API Aspose.Slides per Xamarin, le classi, gli spazi dei nomi, la logica e il comportamento sono il più simile possibile alla versione .NET. È possibile migrare le proprie applicazioni Aspose.Slides .NET su Xamarin con costi minimi.

Esempio rapido

È possibile utilizzare Aspose.Slides per Xamarin per creare e sfruttare la propria applicazione C# tramite Slides per Android.

Forniamo un esempio di applicazione Android tramite Xamarin che utilizza Aspose.Slides per visualizzare le diapositive di una presentazione e aggiunge una nuova forma alla diapositiva al tocco. È possibile trovare il codice sorgente completo degli esempi su GitHub.

Iniziamo creando un’app Xamarin Android:

Per prima cosa, creiamo un layout di contenuto che conterrà una vista immagine, i pulsanti Precedente e Successivo:

XML - content_main.xml - Creare layout di contenuto

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

Qui, facciamo riferimento alla libreria “Aspose.Slides.Droid.dll” che include una presentazione di esempio (“HelloWorld.pptx”) negli Assets dell’applicazione Xamarin e aggiungiamo la sua inizializzazione a MainActivity:

C# - MainActivity.cs - Inizializzazione

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

Aggiungiamo la funzione per visualizzare le diapositive Precedente e Successivo al tocco dei pulsanti:

C# - MainActivity.cs - Visualizzare diapositive al clic dei pulsanti Precedente e Successivo

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

}

Infine, implementiamo una funzione per aggiungere una forma ellittica al tocco sulla diapositiva:

C# - MainActivity.cs - Aggiungere ellisse al clic della diapositiva

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

Ogni clic sulla diapositiva della presentazione aggiunge un’ellisse di colore casuale:

Funzionalità supportate

CARATTERISTICHE	Aspose.Slides per .NET	Aspose.Slides per Xamarin
Caratteristiche della presentazione:
Creare nuove presentazioni
Apertura/Salvataggio formati PowerPoint 97 - 2003
Apertura/Salvataggio formati PowerPoint 2007
Supporto estensioni PowerPoint 2010
Supporto estensioni PowerPoint 2013
Supporto funzionalità PowerPoint 2016	restricted	restricted
Supporto funzionalità PowerPoint 2019	restricted	restricted
Conversione PPT a PPTX
Conversione PPTX a PPT
PPTX in PPT	restricted	restricted
Elaborazione temi
Elaborazione macro
Elaborazione proprietà documento
Protezione con password
Estrazione rapida del testo
Incorporamento caratteri
Rendering dei commenti
Interruzione di operazioni a lunga durata
Formati di esportazione:
PDF
XPS
HTML
TIFF
ODP	restricted	restricted
SWF	restricted	restricted
SVG
Formati di importazione:
HTML	restricted	restricted
ODP
THMX
Caratteristiche delle master slide:
Accesso a tutte le master slide esistenti
Creazione/rimozione master slide
Clonazione master slide
Caratteristiche delle layout slide:
Accesso a tutti i layout slide esistenti
Creazione/rimozione layout slide
Clonazione layout slide
Caratteristiche delle slide:
Accesso a tutte le slide esistenti
Creazione/rimozione slide
Clonazione slide
Esportazione slide in immagini
Creazione/modifica/rimozione sezioni slide
Caratteristiche delle note slide:
Accesso a tutte le note slide esistenti
Caratteristiche delle forme:
Accesso a tutte le forme delle slide
Aggiunta di nuove forme
Clonazione forme
Esportazione forme separate in immagini
Tipi di forma supportati:
Tutti i tipi di forma predefiniti
Cornici immagine
Tabelle
Grafici
SmartArt
Diagrammi legacy
WordArt
OLE, oggetti ActiveX	restricted	restricted
Cornici video
Cornici audio
Connettori
Caratteristiche delle forme di gruppo:
Accesso a forme di gruppo
Creazione di forme di gruppo
Separazione di forme di gruppo esistenti
Caratteristiche degli effetti delle forme:
Effetti 2D	restricted	restricted
Effetti 3D
Caratteristiche del testo:
Formattazione paragrafi
Formattazione porzioni
Caratteristiche di animazione:
Esportazione animazione in SWF
Esportazione animazione in HTML