Bepaal het originele presentatieformaat op Android

Waar deze pagina over gaat

Lees het originele formaat van een geladen presentatie op Android met Aspose.Slides voor Android via Java, vergelijk detectie‑API’s en verwerk bestanden, streams en legacy‑formaten.

Overzicht

Na het laden van een presentatie roep je de Presentation.getSourceFormat methode aan om het oorspronkelijke formaat te bepalen. De methode is ook beschikbaar via IPresentation.getSourceFormat. Gebruik deze wanneer de daaropvolgende verwerking afhangt van het formaat waarin de huidige instantie is geladen.

Het bronformaat verschilt van het SaveFormat dat voor een uitvoerbestand is geselecteerd. Opslaan naar een ander formaat wijzigt het bronformaat van de bestaande instantie niet.

De voorbeelden gebruiken Java en bestands‑paden. Op Android vervang je de voorbeeldpaden door paden in de door de app toegankelijke opslag, bijvoorbeeld de interne bestandenmap van je app.

Het bronformaat van een bestand lezen

Dit voorbeeld vereist een bestaand sample.pptx‑bestand. Het laadt het bestand en kiest een toepassingsverwerkingsbeleid met Presentation.getSourceFormat, in plaats van de bestandsnaam. Pas het invoer‑pad aan om andere formaten te proberen. Het voorbeeld drukt het geselecteerde beleid af; vervang de berichten door je eigen toepassingslogica.

import com.aspose.slides.Presentation;
import com.aspose.slides.SourceFormat;

Presentation presentation = new Presentation("sample.pptx");
try {
    switch (presentation.getSourceFormat()) {
        case SourceFormat.Ppt:
        case SourceFormat.Pps:
        case SourceFormat.Pot:
            System.out.println("Use the legacy PowerPoint processing policy.");
            break;
        case SourceFormat.Pptx:
            System.out.println("Use the standard PPTX processing policy.");
            break;
        default:
            System.out.println("Use the general policy for source format " + presentation.getSourceFormat() + ".");
            break;
    }
} finally {
    presentation.dispose();
}

De ondersteunde waarden herkennen

De class SourceFormat definieert integer‑constanten die de volgende presentatieformaten onderscheiden. De onderstaande extensies zijn conventionele extensies, geen reconstructie van de originele bestandsnaam.

SourceFormat‑waarde	Extensie	Formaat
`Ppt`	`.ppt`	PowerPoint 97–2003‑presentatie
`Pptx`	`.pptx`	Office Open XML‑presentatie
`Pptm`	`.pptm`	Macro‑enabled Office Open XML‑presentatie
`Pps`	`.pps`	PowerPoint 97–2003‑diavoorstelling
`Ppsx`	`.ppsx`	Office Open XML‑diavoorstelling
`Ppsm`	`.ppsm`	Macro‑enabled Office Open XML‑diavoorstelling
`Pot`	`.pot`	PowerPoint 97–2003‑sjabloon
`Potx`	`.potx`	Office Open XML‑sjabloon
`Potm`	`.potm`	Macro‑enabled Office Open XML‑sjabloon
`Odp`	`.odp`	OpenDocument‑presentatie
`Otp`	`.otp`	OpenDocument‑presentatiesjabloon
`Fodp`	`.fodp`	Flat XML ODF‑presentatie
`Xml`	`.xml`	PowerPoint XML‑presentatie

Het bronformaat van een stream lezen

Dit voorbeeld vereist een bestaand sample.pps‑bestand. Het inlezen van de bytes in een geheugenstream modelleert invoer die zonder bestandsnaam wordt ontvangen, bijvoorbeeld een database‑waarde of een geüploade byte‑array. De Presentation‑constructor ontvangt alleen de stream.

import com.aspose.slides.Presentation;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;

try {
    byte[] bytes;
    try (FileInputStream input = new FileInputStream("sample.pps");
         ByteArrayOutputStream output = new ByteArrayOutputStream()) {
        byte[] buffer = new byte[8192];
        int bytesRead;
        while ((bytesRead = input.read(buffer)) != -1) {
            output.write(buffer, 0, bytesRead);
        }
        bytes = output.toByteArray();
    }
    try (ByteArrayInputStream stream = new ByteArrayInputStream(bytes)) {
        Presentation presentation = new Presentation(stream);
        try {
            System.out.println("Source format: " + presentation.getSourceFormat());
        } finally {
            presentation.dispose();
        }
    }
} catch (IOException exception) {
    System.err.println("Cannot read the presentation: " + exception.getMessage());
}

PPT, PPS en POT gebruiken hetzelfde onderliggende binaire formaat. Bij het laden via een bestands‑pad kan de extensie helpen om een diavoorstelling of sjabloon te onderscheiden. Zonder bestandsnaam kan legacy‑inhoud van PPS en POT gerapporteerd worden als SourceFormat.Ppt; het PPS‑voorbeeld hierboven drukt de integer‑waarde van SourceFormat.Ppt af.

Moet je applicatie dit onderscheid behouden, bewaar dan de originele bestandsnaam of sub‑type‑metadata apart. Een extensie is een bruikbare hint voor deze legacy‑subtypes, maar mag niet de enige basis zijn om willekeurige presentatiedata te identificeren.

Detectie vóór en na het laden vergelijken

Gebruik PresentationFactory.getPresentationInfo en IPresentationInfo.getLoadFormat wanneer je een bestand moet inspecteren voordat je het volledige presentatie‑objectmodel laadt. Gebruik Presentation.getSourceFormat wanneer de instantie al bestaat.

Dit voorbeeld vereist sample.pptx en drukt de integer‑waarden van LoadFormat.Pptx en SourceFormat.Pptx respectievelijk af. In productie kies je de API die past bij je verwerkingsfase; een reeds geladen presentatie hoeft niet opnieuw geïnspecteerd te worden alleen om het bronformaat te verkrijgen.

import com.aspose.slides.Presentation;
import com.aspose.slides.IPresentationInfo;
import com.aspose.slides.PresentationFactory;

String path = "sample.pptx";
IPresentationInfo information = PresentationFactory.getInstance().getPresentationInfo(path);
System.out.println("Before loading: " + information.getLoadFormat());

Presentation presentation = new Presentation(path);
try {
    System.out.println("After loading: " + presentation.getSourceFormat());
} finally {
    presentation.dispose();
}

De resultaten gebruiken constante waarden uit verschillende classes: LoadFormat en SourceFormat. Vergelijk hun numerieke waarden niet en ga er niet van uit dat elk formaat identieke detectieresultaten oplevert. PowerPoint XML kan vóór het laden gerapporteerd worden als LoadFormat.Unknown en na het laden als SourceFormat.Xml.

Bron‑ en uitvoerformaten gescheiden houden

Dit voorbeeld vereist sample.pptx en schrijft converted.odp. Het drukt de integer‑waarde van SourceFormat.Pptx zowel vóór als ná het opslaan van de originele instantie af. Alleen de nieuwe instantie die wordt geladen uit de ODP‑output rapporteert Odp.

import com.aspose.slides.Presentation;
import com.aspose.slides.SaveFormat;

Presentation presentation = new Presentation("sample.pptx");
try {
    System.out.println("Before saving: " + presentation.getSourceFormat());

    presentation.save("converted.odp", SaveFormat.Odp);
    System.out.println("After saving: " + presentation.getSourceFormat());

    Presentation reopened = new Presentation("converted.odp");
    try {
        System.out.println("Reopened output: " + reopened.getSourceFormat());
    } finally {
        reopened.dispose();
    }
} finally {
    presentation.dispose();
}

Een presentatie die van nul wordt aangemaakt met new Presentation() rapporteert SourceFormat.Pptx. Ze heeft geen invoerbestand: dit is de standaardwaarde voor een pas aangemaakte instantie, niet een aanwijzing dat er een PPTX‑bestand is geladen. Houd bij of je applicatie de instantie heeft gecreëerd of geladen, als dat onderscheid van belang is.

Een bronformaat omzetten naar een extensie

Het volgende voorbeeld vereist sample.pptx. Het zet elke momenteel ondersteunde SourceFormat‑waarde om naar een conventionele extensie, zonder de invoer‑bestandsnaam te analyseren. De fallback voorkomt dat er stilzwijgend een extensie wordt toegewezen aan een niet‑herkende waarde.

import com.aspose.slides.Presentation;
import com.aspose.slides.SourceFormat;

Presentation presentation = new Presentation("sample.pptx");
try {
    String extension;
    switch (presentation.getSourceFormat()) {
        case SourceFormat.Ppt:
            extension = ".ppt";
            break;
        case SourceFormat.Pptx:
            extension = ".pptx";
            break;
        case SourceFormat.Pptm:
            extension = ".pptm";
            break;
        case SourceFormat.Pps:
            extension = ".pps";
            break;
        case SourceFormat.Ppsx:
            extension = ".ppsx";
            break;
        case SourceFormat.Ppsm:
            extension = ".ppsm";
            break;
        case SourceFormat.Pot:
            extension = ".pot";
            break;
        case SourceFormat.Potx:
            extension = ".potx";
            break;
        case SourceFormat.Potm:
            extension = ".potm";
            break;
        case SourceFormat.Odp:
            extension = ".odp";
            break;
        case SourceFormat.Otp:
            extension = ".otp";
            break;
        case SourceFormat.Fodp:
            extension = ".fodp";
            break;
        case SourceFormat.Xml:
            extension = ".xml";
            break;
        default:
            extension = null;
            break;
    }

    System.out.println(extension != null ? extension : "No extension mapping is available.");
} finally {
    presentation.dispose();
}

Deze mapping converteert geen bestand en herstelt geen legacy‑PPS/POT‑subtype dat verloren ging tijdens het laden van een stream. Voor daadwerkelijk opslaan, selecteer je expliciet een SaveFormat of gebruik je de conversie die wordt getoond in Save Presentations in Their Original Format.

Formaten verifiëren door op te slaan en opnieuw te openen

Dit zelf‑containende voorbeeld maakt een presentatie aan en schrijft drie bestanden in de werkmap, waarbij bestanden met dezelfde naam overschreven worden. Het opent elke output zowel via pad als via een geheugenstream opnieuw. Voor PPTX en ODP rapporteren beide routes het opgeslagen formaat. Voor PPS rapporteert het laden via pad Pps, terwijl het laden van dezelfde bytes zonder bestandsnaam Ppt rapporteert.

import com.aspose.slides.Presentation;
import com.aspose.slides.SaveFormat;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;

Presentation presentation = new Presentation();
try {
    int[] formats = { SaveFormat.Pptx, SaveFormat.Odp, SaveFormat.Pps };
    String[] extensions = { "pptx", "odp", "pps" };

    for (int i = 0; i < formats.length; i++) {
        String path = "roundtrip." + extensions[i];
        presentation.save(path, formats[i]);

        Presentation fromFile = new Presentation(path);
        try {
            byte[] bytes;
            try (FileInputStream input = new FileInputStream(path);
                 ByteArrayOutputStream output = new ByteArrayOutputStream()) {
                byte[] buffer = new byte[8192];
                int bytesRead;
                while ((bytesRead = input.read(buffer)) != -1) {
                    output.write(buffer, 0, bytesRead);
                }
                bytes = output.toByteArray();
            }
            try (ByteArrayInputStream stream = new ByteArrayInputStream(bytes)) {
                Presentation fromStream = new Presentation(stream);
                try {
                    System.out.println(extensions[i] + ": file=" + fromFile.getSourceFormat() + ", stream=" + fromStream.getSourceFormat());
                } finally {
                    fromStream.dispose();
                }
            }
        } finally {
            fromFile.dispose();
        }
    }
} catch (IOException exception) {
    System.err.println("Cannot read a saved presentation: " + exception.getMessage());
} finally {
    presentation.dispose();
}

De volgende tabel geeft een overzicht van bron‑formaat‑identificatie voor presentaties met overeenkomstige extensies. De namen duiden op constanten; de Java‑voorbeelden drukken hun integer‑waarden af:

Opgeslagen formaat	SourceFormat via bestands‑pad	SourceFormat via naamloze stream
PPT	`Ppt`	`Ppt`
PPTX, PPTM	respectievelijk `Pptx`, `Pptm`	Zelfde als bestands‑pad
PPS	`Pps`	`Ppt`
PPSX, PPSM	respectievelijk `Ppsx`, `Ppsm`	Zelfde als bestands‑pad
POT	`Pot`	`Ppt`
POTX, POTM	respectievelijk `Potx`, `Potm`	Zelfde als bestands‑pad
ODP, OTP	respectievelijk `Odp`, `Otp`	Zelfde als bestands‑pad
FODP	`Fodp`	`Fodp`
PowerPoint XML	`Xml`	`Xml`

PPS/POT‑inhoud wordt geïdentificeerd als Ppt voor naamloze streams. De tabel beschrijft format‑identificatie, niet het behoud van elk presentatiefunctie‑aspect tijdens conversie.

FAQ

Verandert het opslaan naar ODP het bronformaat van een presentatie die uit PPTX is geladen?

Nee. De bestaande instantie rapporteert nog steeds Pptx. Een instantie die wordt geladen uit het opgeslagen ODP‑bestand rapporteert Odp.

Kan een stream altijd een legacy‑presentatie, diavoorstelling en sjabloon onderscheiden?

Nee. PPT, PPS en POT delen hetzelfde binaire formaat. Bewaar de bestandsnaam of sub‑type‑metadata apart wanneer dat onderscheid vereist is.

Welke API moet ik gebruiken wanneer de presentatie al is geladen?

Lees Presentation.getSourceFormat. Gebruik PresentationFactory.getPresentationInfo voor inspectie vóór het laden.

Presentatie‑informatie ophalen en bijwerken op Android Efficiënt presentaties samenvoegen op Android