Gérer les avertissements de présentation sur Android
Aperçu
Aspose.Slides peut signaler des problèmes récupérables lors du chargement, du rendu, de la conversion ou de l’enregistrement d’une présentation. Par exemple, des enregistrements source endommagés, du contenu qui ne peut être préservé, la substitution de police et les limitations d’un format cible. Un rappel d’avertissement permet à une application d’enregistrer ces conditions et de décider si l’opération en cours peut se poursuivre.
Implémentez l’interface IWarningCallback et examinez les valeurs getWarningType et getDescription renvoyées via IWarningInfo. Retournez ReturnAction.Continue pour accepter l’avertissement ou ReturnAction.Abort pour interrompre l’opération.
Utilisez LoadOptions.setWarningCallback pour les avertissements déclenchés lors de l’ouverture d’une présentation. Les classes d’options de rendu et d’exportation héritent de SaveOptions.setWarningCallback, qui reçoivent les avertissements provenant du rendu de diapositives, de la conversion et de l’enregistrement. Comme l’avertissement ne permet pas d’identifier l’opération de l’application, associez chaque instance de rappel à une étape d’opération lors de la création d’un rapport combiné.
Avertissements et Exceptions
Un avertissement décrit une condition dont Aspose.Slides peut se remettre si le rappel renvoie ReturnAction.Continue. Une exception signifie que l’opération demandée ne peut pas se terminer normalement ; les exceptions ne sont pas converties en avertissements et ne peuvent pas être gérées par une politique d’avertissement.
Le fait de retourner ReturnAction.Abort demande au répartiteur d’avertissements de terminer l’opération en cours en levant une exception. L’exception publique dépend de l’opération et du format de la présentation. Par exemple, le chargement peut déclencher une PptxReadException ou une PptReadException, tandis que l’enregistrement ou l’exportation peut déclencher une PptxException. Gérez l’exception à la limite de l’opération et utilisez le rapport d’avertissement pour déterminer si la politique de l’application a causé la terminaison au lieu de se fier à un sous‑type d’exception ou à un message. Le rappel enregistre l’avertissement avant de retourner ReturnAction.Abort, garantissant que la raison reste disponible pour l’application.
Catégories d’avertissement
La classe WarningType fournit des constantes entières pour les catégories suivantes :
| Type d’avertissement | Signification | Politique typique |
|---|---|---|
| SourceFileCorruption | La présentation source contient des corruptions pouvant rendre un document enregistré dans son format original inutilisable. | Abandonner. |
| DataLoss | Le texte, les graphiques, les images ou d’autres données peuvent être absents après le chargement ou l’enregistrement. | Abandonner. |
| MajorFormattingLoss | La présentation peut perdre un formatage important. | Abandonner en mode de validation strict ; sinon enregistrer et continuer. |
| MinorFormattingLoss | Une différence de formatage limitée peut survenir. | Enregistrer à des fins de diagnostic et continuer. |
| CompatibilityIssue | Le résultat peut ne pas s’ouvrir ou ne pas se comporter correctement dans certaines applications ou versions antérieures. | Journaliser et continuer sauf si la compatibilité est obligatoire. |
| UnexpectedContent | La source contient du contenu non pris en charge ou non reconnu dont l’effet peut ne pas être encore connu. | Enregistrer et continuer, ou considérer comme une erreur dans une politique stricte. |
La catégorie doit guider la décision de politique. Conservez la valeur renvoyée par getDescription à des fins de diagnostic, mais ne vous fiez pas à sa formulation pour la logique de l’application car le texte du message peut varier selon les scénarios d’avertissement et les versions du produit.
Collecter et classer les avertissements
L’exemple suivant utilise un rapport au niveau de l’application pour l’ensemble du pipeline de traitement. Une instance de rappel distincte étiquette les avertissements provenant du chargement, du rendu, de la conversion PDF et de l’enregistrement PPTX. La politique interrompt en cas de corruption de la source ou de perte de données, interrompt éventuellement en cas de perte de formatage majeure, et continue pour les autres avertissements.
Placez input.pptx dans un répertoire d’application accessible en écriture et transmettez ce répertoire à PresentationWarningExample.run. L’exemple enregistre ses sorties dans le même répertoire. Exécutez le traitement de la présentation sur un thread d’arrière‑plan pour garder l’interface utilisateur Android réactive.
import com.aspose.slides.IImage;
import com.aspose.slides.IWarningCallback;
import com.aspose.slides.IWarningInfo;
import com.aspose.slides.ImageFormat;
import com.aspose.slides.LoadOptions;
import com.aspose.slides.PdfOptions;
import com.aspose.slides.PptxOptions;
import com.aspose.slides.Presentation;
import com.aspose.slides.RenderingOptions;
import com.aspose.slides.ReturnAction;
import com.aspose.slides.SaveFormat;
import com.aspose.slides.WarningType;
import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class PresentationWarningExample {
public static void run(File dataDirectory) {
WarningReport report = new WarningReport();
WarningPolicy policy = new WarningPolicy(true);
File inputFile = new File(dataDirectory, "input.pptx");
boolean completed = processPresentation(inputFile.getAbsolutePath(), dataDirectory, report, policy);
System.out.println(completed ? "Processing completed." : "Processing stopped.");
for (WarningEntry entry : report.getEntries()) {
String typeName = warningTypeName(entry.type);
System.out.println("[" + entry.stage + "] " + typeName + ": " + entry.description);
}
}
private static boolean processPresentation(String inputPath, File dataDirectory, WarningReport report, WarningPolicy policy) {
try {
LoadOptions loadOptions = new LoadOptions();
ReportingWarningCallback callback = new ReportingWarningCallback(OperationStage.Loading, report, policy);
loadOptions.setWarningCallback(callback);
Presentation presentation = new Presentation(inputPath, loadOptions);
try {
if (!renderFirstSlide(presentation, dataDirectory, report, policy)) {
return false;
}
if (!convertToPdf(presentation, dataDirectory, report, policy)) {
return false;
}
return saveValidatedCopy(presentation, dataDirectory, report, policy);
}
finally {
presentation.dispose();
}
}
catch (Exception exception) {
System.err.println("Loading stopped: " + exception.getMessage());
return false;
}
}
private static boolean renderFirstSlide(Presentation presentation, File dataDirectory, WarningReport report, WarningPolicy policy) {
if (presentation.getSlides().size() == 0) {
System.err.println("Rendering stopped: the presentation has no slides.");
return false;
}
try {
RenderingOptions options = new RenderingOptions();
ReportingWarningCallback callback = new ReportingWarningCallback(OperationStage.Rendering, report, policy);
options.setWarningCallback(callback);
IImage image = presentation.getSlides().get_Item(0).getImage(options);
try {
File outputFile = new File(dataDirectory, "slide-1.png");
image.save(outputFile.getAbsolutePath(), ImageFormat.Png);
return true;
}
finally {
image.dispose();
}
}
catch (Exception exception) {
System.err.println("Rendering stopped: " + exception.getMessage());
return false;
}
}
private static boolean convertToPdf(Presentation presentation, File dataDirectory, WarningReport report, WarningPolicy policy) {
try {
PdfOptions options = new PdfOptions();
ReportingWarningCallback callback = new ReportingWarningCallback(OperationStage.Conversion, report, policy);
options.setWarningCallback(callback);
File outputFile = new File(dataDirectory, "converted.pdf");
presentation.save(outputFile.getAbsolutePath(), SaveFormat.Pdf, options);
return true;
}
catch (Exception exception) {
System.err.println("Conversion stopped: " + exception.getMessage());
return false;
}
}
private static boolean saveValidatedCopy(Presentation presentation, File dataDirectory, WarningReport report, WarningPolicy policy) {
try {
PptxOptions options = new PptxOptions();
ReportingWarningCallback callback = new ReportingWarningCallback(OperationStage.Saving, report, policy);
options.setWarningCallback(callback);
File outputFile = new File(dataDirectory, "validated-output.pptx");
presentation.save(outputFile.getAbsolutePath(), SaveFormat.Pptx, options);
return true;
}
catch (Exception exception) {
System.err.println("Saving stopped: " + exception.getMessage());
return false;
}
}
private static String warningTypeName(int warningType) {
switch (warningType) {
case WarningType.SourceFileCorruption:
return "SourceFileCorruption";
case WarningType.DataLoss:
return "DataLoss";
case WarningType.MajorFormattingLoss:
return "MajorFormattingLoss";
case WarningType.MinorFormattingLoss:
return "MinorFormattingLoss";
case WarningType.CompatibilityIssue:
return "CompatibilityIssue";
case WarningType.UnexpectedContent:
return "UnexpectedContent";
default:
return "Unknown (" + warningType + ")";
}
}
private enum OperationStage {
Loading,
Rendering,
Conversion,
Saving
}
private static final class WarningEntry {
final OperationStage stage;
final int type;
final String description;
WarningEntry(OperationStage stage, int type, String description) {
this.stage = stage;
this.type = type;
this.description = description;
}
}
private static final class WarningReport {
private final List<WarningEntry> entries = new ArrayList<WarningEntry>();
List<WarningEntry> getEntries() {
return Collections.unmodifiableList(entries);
}
void add(OperationStage stage, IWarningInfo warning) {
WarningEntry entry = new WarningEntry(stage, warning.getWarningType(), warning.getDescription());
entries.add(entry);
}
}
private static final class WarningPolicy {
private final boolean abortOnMajorFormattingLoss;
WarningPolicy(boolean abortOnMajorFormattingLoss) {
this.abortOnMajorFormattingLoss = abortOnMajorFormattingLoss;
}
int getAction(int warningType) {
if (warningType == WarningType.SourceFileCorruption || warningType == WarningType.DataLoss) {
return ReturnAction.Abort;
}
if (warningType == WarningType.MajorFormattingLoss && abortOnMajorFormattingLoss) {
return ReturnAction.Abort;
}
return ReturnAction.Continue;
}
}
private static final class ReportingWarningCallback implements IWarningCallback {
private final OperationStage stage;
private final WarningReport report;
private final WarningPolicy policy;
ReportingWarningCallback(OperationStage stage, WarningReport report, WarningPolicy policy) {
this.stage = stage;
this.report = report;
this.policy = policy;
}
@Override
public int warning(IWarningInfo warning) {
report.add(stage, warning);
return policy.getAction(warning.getWarningType());
}
}
}
Passez false pour abortOnMajorFormattingLoss lors de la construction de WarningPolicy si les différences de formatage majeures sont acceptables. Les problèmes de compatibilité, la perte de formatage mineure et le contenu inattendu restent néanmoins consignés dans le rapport même si l’opération continue. Étendez WarningPolicy.getAction si l’application doit rejeter l’une de ces catégories.
Scénarios d’avertissement courants
Les avertissements peuvent apparaître à différentes étapes d’un flux de travail :
- Signatures numériques : Une présentation signée peut produire un avertissement lors du chargement indiquant que sa signature sera perdue pendant le traitement. Aspose.Slides signale cette condition
DataLossvia IPresentationSignedWarningInfo. Un rappel au stade de chargement permet à l’application de rejeter le fichier ou d’accepter explicitement la perte signalée. - Substitution de police : Une police indisponible peut être remplacée pendant le rendu ou l’exportation d’une diapositive. Les avertissements de substitution de police sont signalés comme
DataLoss, ainsi la politique stricte ci‑dessus interrompt même si l’application considérerait un remplacement particulier comme visuellement acceptable. Pour observer ce comportement, utilisez une présentation d’entrée contenant du texte dans une police indisponible à l’exécution. La description de l’avertissement identifie la substitution ; configurez les polices requises ou règles de substitution de police avant de réessayer. - Contenu non pris en charge ou inattendu : Un chargeur peut rencontrer des enregistrements de présentation ou des fonctionnalités qu’il ne reconnaît pas. De tels avertissements peuvent utiliser
UnexpectedContent, ou une catégorie plus sévère lorsque des données ou du formatage sont connus pour être affectés. - Compatibilité de format : L’enregistrement dans un autre format de présentation peut omettre des fonctionnalités ou produire un résultat qui se comporte différemment dans certaines applications. Par exemple, enregistrer une présentation avec plus de huit repères de dessin horizontaux ou verticaux dans une PPT legacy signale un
CompatibilityIssue. Le rappel au stade d’enregistrement peut consigner la perte et continuer, ou la rejeter si la préservation de tous les repères est requise. - Comportement de chargement : Les options de chargement et les comportements hérités peuvent également produire des avertissements. Par exemple, IObsoletePresLockingBehaviorWarningInfo identifie l’utilisation d’un comportement de verrouillage de présentation obsolète comme un
CompatibilityIssue.
Les avertissements dépendent du document source, du format cible, de l’opération et de la version d’Aspose.Slides. Ne supposez pas que chaque fichier produit un avertissement ou qu’un scénario correspond toujours à une seule catégorie.
Gérer en toute sécurité les opérations interrompues
Lorsque un rappel renvoie ReturnAction.Abort, n’utilisez pas un objet qui n’a pas pu être chargé et ne supposez pas qu’une sortie de rendu ou d’enregistrement est complète. L’opération peut se terminer après la création d’un fichier de sortie mais avant son achèvement.
Enregistrez les résultats validés dans un chemin distinct tel que validated-output.pptx. Remplacez une présentation existante uniquement après que l’opération se soit terminée avec succès, que le rapport d’avertissement satisfasse la politique de l’application et que la sortie puisse être ouverte et vérifiée. Cela évite d’écraser un fichier source valide avec un résultat partiel ou rejeté.
Un rapport d’avertissement vide ne garantit pas que chaque fonctionnalité source a été conservée. Appliquez les contrôles de contenu et visuels supplémentaires requis par l’application. Voir également Ouvrir des présentations et Enregistrer des présentations.
FAQ
Un rappel d’avertissement peut‑il gérer chaque erreur d’Aspose.Slides ?
Non. Il gère les conditions récupérables signalées sous forme d’avertissements. Les exceptions qui surviennent indépendamment du rappel doivent être traitées par l’application autour de l’appel de chargement, de rendu, de conversion ou d’enregistrement.
Le fait de retourner ReturnAction.Continue garantit‑il une sortie identique ?
Non. Cela ne fait que permettre la poursuite du traitement. La condition signalée peut toujours entraîner des différences de données, de formatage ou de compatibilité, il faut donc examiner les types d’avertissements et leurs descriptions collectés.
Comment une application peut‑elle identifier l’opération qui a généré un avertissement ?
Créez une instance de rappel pour chaque opération et stockez une étape définie par l’application ainsi que les valeurs renvoyées par getWarningType et getDescription, comme indiqué dans l’exemple.