Aspose.Slides para Xamarin

Visión general

Xamarin es un framework utilizado para el desarrollo móvil en .NET C#. Xamarin tiene herramientas y bibliotecas que amplían las capacidades de la plataforma .NET. Permite a los desarrolladores crear aplicaciones para el sistema operativo Android.

Para el desarrollo en Xamarin, los programadores pueden usar sus entornos de desarrollo habituales (C#, Visual Studio y bibliotecas de terceros).

Aspose.Slides API funciona en la plataforma Xamarin. Para lograrlo, el paquete Aspose.Slides .NET agrega un DLL separado para Xamarin. Aspose.Slides para Xamarin admite la mayoría de las funciones disponibles en la versión .NET:

• conversión y visualización de presentaciones.
• edición de contenidos en presentaciones: texto, formas, gráficos, SmartArt, audio/video, fuentes, etc.
• manejo de animaciones, efectos 2D, WordArt, etc.
• manejo de metadatos y propiedades del documento.
• impresión, clonación, combinación, comparación, división, etc.

Proporcionamos una comparación de todas las funciones en otra sección cerca del final de esta página.

En la API Aspose.Slides para Xamarin, las clases, espacios de nombres, lógica y comportamiento son lo más similar posible a la versión .NET. Puede migrar sus aplicaciones Aspose.Slides .NET a Xamarin con costos mínimos.

Ejemplo rápido

Puede usar Aspose.Slides para Xamarin para crear y utilizar su aplicación C# a través de Slides para Android.

Estamos proporcionando un ejemplo de aplicación Android via Xamarin que usa Aspose.Slides para mostrar diapositivas de presentación y agrega una nueva forma en la diapositiva al tocarla. Puede encontrar el código completo de los ejemplos en GitHub.

Comencemos creando una aplicación Xamarin Android:

Primero, creamos un diseño de contenido que contendrá una vista de imagen, los botones Prev y Next:

XML - content_main.xml - Crear diseño de contenido

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

Aquí, hacemos referencia a la biblioteca “Aspose.Slides.Droid.dll” que incluye una presentación de ejemplo (“HelloWorld.pptx”) en los Assets de la aplicación Xamarin y añadimos su inicialización a MainActivity:

C# - MainActivity.cs - Inicialización

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

Agreguemos la función para mostrar las diapositivas Prev y Next al pulsar los botones:

C# - MainActivity.cs - Mostrar diapositivas al hacer clic en los botones Prev y Next

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

}

Finalmente, implementemos una función para agregar una forma elíptica al tocar la diapositiva:

C# - MainActivity.cs - Agregar elipse al hacer clic en la 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);
}

Cada clic en la diapositiva de la presentación causa que se añada una elipse de color aleatorio:

Características compatibles

CARACTERÍSTICAS	Aspose.Slides para .NET	Aspose.Slides para Xamarin
Características de presentación:
Crear nuevas presentaciones
Abrir/guardar formatos PowerPoint 97 - 2003
Abrir/guardar formatos PowerPoint 2007
Soporte de extensiones PowerPoint 2010
Soporte de extensiones PowerPoint 2013
Soporte de funciones PowerPoint 2016	restringido	restringido
Soporte de funciones PowerPoint 2019	restringido	restringido
Conversión PPT a PPTX
Conversión PPTX a PPT
PPTX dentro de PPT	restringido	restringido
Procesamiento de temas
Procesamiento de macros
Procesamiento de propiedades del documento
Protección con contraseña
Extracción rápida de texto
Incrustación de fuentes
Renderizado de comentarios
Interrupción de tareas de larga duración
Formatos de exportación:
PDF
XPS
HTML
TIFF
ODP	restringido	restringido
SWF	restringido	restringido
SVG
Formatos de importación:
HTML	restringido	restringido
ODP
THMX
Características de diapositivas maestra:
Acceso a todas las diapositivas maestras existentes
Crear/eliminar diapositivas maestras
Clonar diapositivas maestras
Características de diapositivas de diseño:
Acceso a todas las diapositivas de diseño existentes
Crear/eliminar diapositivas de diseño
Clonar diapositivas de diseño
Características de diapositivas:
Acceso a todas las diapositivas existentes
Crear/eliminar diapositivas
Clonar diapositivas
Exportar diapositivas a imágenes
Crear/editar/eliminar secciones de diapositivas
Características de notas:
Acceso a todas las notas existentes
Características de formas:
Acceso a todas las formas de la diapositiva
Agregar nuevas formas
Clonar formas
Exportar formas independientes a imágenes
Tipos de forma admitidos:
Todas las formas predefinidas
Marcos de imagen
Tablas
Gráficos
SmartArt
Diagramas heredados
WordArt
OLE, objetos ActiveX	restringido	restringido
Marcos de video
Marcos de audio
Conectores
Características de grupos de formas:
Acceso a grupos de formas
Crear grupos de formas
Desagrupar grupos de formas existentes
Características de efectos de forma:
Efectos 2D	restringido	restringido
Efectos 3D
Características de texto:
Formato de párrafos
Formato de porciones
Características de animación:
Exportar animación a SWF
Exportar animación a HTML