Java tutorial
/* * Copyright (c) 2014 tabletoptool.com team. * All rights reserved. This program and the accompanying materials * are made available under the terms of the GNU Public License v3.0 * which accompanies this distribution, and is available at * http://www.gnu.org/licenses/gpl.html * * Contributors: * rptools.com team - initial implementation * tabletoptool.com team - further development */ package com.t3.persistence; import java.awt.Dimension; import java.awt.Graphics2D; import java.awt.RenderingHints; import java.awt.image.BufferedImage; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.net.URL; import java.text.ParseException; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import javax.imageio.ImageIO; import org.apache.commons.io.FileUtils; import org.apache.commons.io.IOUtils; import org.apache.log4j.Logger; import com.jidesoft.utils.StringUtils; import com.t3.CodeTimer; import com.t3.MD5Key; import com.t3.client.AppConstants; import com.t3.client.AppUtil; import com.t3.client.TabletopTool; import com.t3.client.ui.Scale; import com.t3.client.ui.zone.PlayerView; import com.t3.client.ui.zone.ZoneRenderer; import com.t3.guid.GUID; import com.t3.image.ImageUtil; import com.t3.model.Asset; import com.t3.model.AssetManager; import com.t3.model.LookupTable; import com.t3.model.MacroButtonProperties; import com.t3.model.Token; import com.t3.model.Zone; import com.t3.model.campaign.Campaign; import com.t3.model.campaign.CampaignProperties; import com.t3.swing.SwingUtil; import com.t3.util.ImageManager; import com.t3.util.StringUtil; import com.t3.util.guidreference.ZoneReference; import com.t3.xstreamversioned.version.SerializationVersion; import com.thoughtworks.xstream.converters.ConversionException; /** * @author trevor */ public class PersistenceUtil { private static final Logger log = Logger.getLogger(PersistenceUtil.class); private static final String ASSET_DIR = "assets/"; //$NON-NLS-1$ static { PackedFile.init(AppUtil.getAppHome("tmp")); //$NON-NLS-1$ } @SerializationVersion(0) public static class PersistedMap { public Zone zone; public Map<MD5Key, Asset> assetMap = new HashMap<MD5Key, Asset>(); public String tabletopToolVersion; } @SerializationVersion(0) public static class PersistedCampaign { public Campaign campaign; public Map<MD5Key, Asset> assetMap = new HashMap<MD5Key, Asset>(); public ZoneReference currentZone; public Scale currentView; public String tabletopToolVersion; } public static void saveMap(Zone z, File mapFile) throws IOException { PersistedMap pMap = new PersistedMap(); pMap.zone = z; // Save all assets in active use (consolidate duplicates) Set<MD5Key> allAssetIds = z.getAllAssetIds(); for (MD5Key key : allAssetIds) { // Put in a placeholder pMap.assetMap.put(key, null); } PackedFile pakFile = null; try { pakFile = new PackedFile(mapFile); saveAssets(z.getAllAssetIds(), pakFile); pakFile.setContent(pMap); pakFile.save(); } finally { if (pakFile != null) pakFile.close(); } } public static PersistedMap loadMap(File mapFile) { PackedFile pakFile = null; try { pakFile = new PackedFile(mapFile); PersistedMap persistedMap = (PersistedMap) pakFile.getContent(); // Now load up any images that we need loadAssets(persistedMap.assetMap.keySet(), pakFile); // FJE We only want the token's graphical data, so loop through all tokens and // destroy all properties and macros. Keep some fields, though. Since that type // of object editing doesn't belong here, we just call Token.imported() and let // that method Do The Right Thing. for (Iterator<Token> iter = persistedMap.zone.getAllTokens().iterator(); iter.hasNext();) { Token token = iter.next(); token.imported(); } // XXX FJE This doesn't work the way I want it to. But doing this the Right Way // is too much work right now. :-} Zone z = persistedMap.zone; String n = fixupZoneName(z.getName()); z.setName(n); z.imported(); // Resets creation timestamp and init panel, among other things z.optimize(); // Collapses overlaid or redundant drawables return persistedMap; } catch (IOException ioe) { TabletopTool.showError("PersistenceUtil.error.mapRead", ioe); } finally { if (pakFile != null) pakFile.close(); } return null; } /** * Determines whether the incoming map name is unique. If it is, it's * returned as-is. If it's not unique, a newly generated name is returned. * * @param n * name from imported map * @return new name to use for the map */ private static String fixupZoneName(String n) { List<Zone> zones = TabletopTool.getCampaign().getZones(); for (Zone zone : zones) { if (zone.getName().equals(n)) { String count = n.replaceFirst("Import (\\d+) of.*", "$1"); //$NON-NLS-1$ Integer next = 1; try { next = StringUtil.parseInteger(count) + 1; n = n.replaceFirst("Import \\d+ of", "Import " + next + " of"); //$NON-NLS-1$ } catch (ParseException e) { n = "Import " + next + " of " + n; //$NON-NLS-1$ } } } return n; } public static void saveCampaign(Campaign campaign, File campaignFile) throws IOException { CodeTimer saveTimer; // FJE Previously this was 'private static' -- why? saveTimer = new CodeTimer("CampaignSave"); saveTimer.setThreshold(5); saveTimer.setEnabled(log.isDebugEnabled()); // Don't bother keeping track if it won't be displayed... // Strategy: save the file to a tmp location so that if there's a failure the original file // won't be touched. Then once we're finished, replace the old with the new. File tmpDir = AppUtil.getTmpDir(); File tmpFile = new File(tmpDir.getAbsolutePath(), campaignFile.getName()); if (tmpFile.exists()) tmpFile.delete(); PackedFile pakFile = null; try { pakFile = new PackedFile(tmpFile); // Configure the meta file (this is for legacy support) PersistedCampaign persistedCampaign = new PersistedCampaign(); persistedCampaign.campaign = campaign; // Keep track of the current view ZoneRenderer currentZoneRenderer = TabletopTool.getFrame().getCurrentZoneRenderer(); if (currentZoneRenderer != null) { persistedCampaign.currentZone = new ZoneReference(currentZoneRenderer.getZone()); persistedCampaign.currentView = currentZoneRenderer.getZoneScale(); } // Save all assets in active use (consolidate duplicates between maps) saveTimer.start("Collect all assets"); Set<MD5Key> allAssetIds = campaign.getAllAssetIds(); for (MD5Key key : allAssetIds) { // Put in a placeholder; all we really care about is the MD5Key for now... persistedCampaign.assetMap.put(key, null); } saveTimer.stop("Collect all assets"); // And store the asset elsewhere saveTimer.start("Save assets"); saveAssets(allAssetIds, pakFile); saveTimer.stop("Save assets"); try { saveTimer.start("Set content"); pakFile.setContent(persistedCampaign); saveTimer.stop("Set content"); saveTimer.start("Save"); pakFile.save(); saveTimer.stop("Save"); } catch (OutOfMemoryError oom) { /* * This error is normally because the heap space has been * exceeded while trying to save the campaign. Since TabletopTool * caches the images used by the current Zone, and since the * VersionManager must keep the XML for objects in memory in * order to apply transforms to them, the memory usage can spike * very high during the save() operation. A common solution is * to switch to an empty map and perform the save from there; * this causes TabletopTool to unload any images that it may have had * cached and this can frequently free up enough memory for the * save() to work. We'll tell the user all this right here and * then fail the save and they can try again. */ saveTimer.start("OOM Close"); pakFile.close(); // Have to close the tmpFile first on some OSes pakFile = null; tmpFile.delete(); // Delete the temporary file saveTimer.stop("OOM Close"); if (log.isDebugEnabled()) { log.debug(saveTimer); } TabletopTool.showError("msg.error.failedSaveCampaignOOM"); return; } } finally { saveTimer.start("Close"); IOUtils.closeQuietly(pakFile); saveTimer.stop("Close"); pakFile = null; } // Copy to the new location // Not the fastest solution in the world if renameTo() fails, but worth the safety net it provides saveTimer.start("Backup"); File bakFile = new File(tmpDir.getAbsolutePath(), campaignFile.getName() + ".bak"); bakFile.delete(); if (campaignFile.exists()) { if (!campaignFile.renameTo(bakFile)) { saveTimer.start("Backup campaignFile"); FileUtil.copyFile(campaignFile, bakFile); campaignFile.delete(); saveTimer.stop("Backup campaignFile"); } } if (!tmpFile.renameTo(campaignFile)) { saveTimer.start("Backup tmpFile"); FileUtil.copyFile(tmpFile, campaignFile); tmpFile.delete(); saveTimer.stop("Backup tmpFile"); } if (bakFile.exists()) bakFile.delete(); saveTimer.stop("Backup"); // Save the campaign thumbnail saveTimer.start("Thumbnail"); saveCampaignThumbnail(campaignFile.getName()); saveTimer.stop("Thumbnail"); if (log.isDebugEnabled()) { log.debug(saveTimer); } } /* * A public function because I think it should be called when a campaign is * opened as well so if it is opened then closed without saving, there is * still a preview created; however, the rendering of the campaign appears * to complete after AppActions.loadCampaign returns, causing the preview to * always appear as black if this method is called from within loadCampaign. * Either need to find another place to call saveCampaignThumbnail upon * opening, or code to delay it's call until the render is complete. =P */ static public void saveCampaignThumbnail(String fileName) { BufferedImage screen = TabletopTool.takeMapScreenShot(new PlayerView(TabletopTool.getPlayer().getRole())); if (screen == null) return; Dimension imgSize = new Dimension(screen.getWidth(null), screen.getHeight(null)); SwingUtil.constrainTo(imgSize, 200, 200); BufferedImage thumb = new BufferedImage(imgSize.width, imgSize.height, BufferedImage.TYPE_INT_BGR); Graphics2D g2d = thumb.createGraphics(); g2d.drawImage(screen, 0, 0, imgSize.width, imgSize.height, null); g2d.dispose(); File thumbFile = getCampaignThumbnailFile(fileName); try { ImageIO.write(thumb, "jpg", thumbFile); } catch (IOException ioe) { TabletopTool.showError("msg.error.failedSaveCampaignPreview", ioe); } } /** * Gets a file pointing to where the campaign's thumbnail image should be. * * @param fileName * The campaign's file name. */ public static File getCampaignThumbnailFile(String fileName) { return new File(AppUtil.getAppHome("campaignthumbs"), fileName + ".jpg"); } public static PersistedCampaign loadCampaign(File campaignFile) throws IOException { PersistedCampaign persistedCampaign = null; // Try the new way first PackedFile pakFile = null; try { pakFile = new PackedFile(campaignFile); try { persistedCampaign = (PersistedCampaign) pakFile.getContent(); } catch (ConversionException ce) { // Ignore the exception and check for "campaign == null" below... TabletopTool.showError("PersistenceUtil.error.campaignVersion", ce); } if (persistedCampaign != null) { // Now load up any images that we need // Note that the values are all placeholders Set<MD5Key> allAssetIds = persistedCampaign.assetMap.keySet(); loadAssets(allAssetIds, pakFile); for (Zone zone : persistedCampaign.campaign.getZones()) { zone.optimize(); } return persistedCampaign; } } catch (OutOfMemoryError oom) { TabletopTool.showError("Out of memory while reading campaign.", oom); return null; } catch (RuntimeException rte) { TabletopTool.showError("PersistenceUtil.error.campaignRead", rte); } catch (Error e) { TabletopTool.showError("PersistenceUtil.error.unknown", e); } finally { if (pakFile != null) pakFile.close(); } if (persistedCampaign == null) TabletopTool.showWarning("PersistenceUtil.warn.campaignNotLoaded"); return persistedCampaign; } public static BufferedImage getTokenThumbnail(File file) throws Exception { PackedFile pakFile = new PackedFile(file); BufferedImage thumb; try { thumb = null; if (pakFile.hasFile(Token.FILE_THUMBNAIL)) { try (InputStream is = pakFile.getFileAsInputStream(Token.FILE_THUMBNAIL)) { thumb = ImageIO.read(is); } } } finally { pakFile.close(); } return thumb; } public static void saveToken(Token token, File file) throws IOException { saveToken(token, file, false); } public static void saveToken(Token token, File file, boolean doWait) throws IOException { // Thumbnail BufferedImage image = null; if (doWait) image = ImageManager.getImageAndWait(token.getImageAssetId()); else image = ImageManager.getImage(token.getImageAssetId()); Dimension sz = new Dimension(image.getWidth(), image.getHeight()); SwingUtil.constrainTo(sz, 50); BufferedImage thumb = new BufferedImage(sz.width, sz.height, BufferedImage.TRANSLUCENT); Graphics2D g = thumb.createGraphics(); g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY); g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR); g.drawImage(image, 0, 0, sz.width, sz.height, null); g.dispose(); PackedFile pakFile = null; try { pakFile = new PackedFile(file); saveAssets(token.getAllImageAssets(), pakFile); pakFile.putFile(Token.FILE_THUMBNAIL, ImageUtil.imageToBytes(thumb, "png")); pakFile.setContent(token); pakFile.save(); } finally { if (pakFile != null) pakFile.close(); } } public static Token loadToken(File file) { PackedFile pakFile = null; Token token = null; try { pakFile = new PackedFile(file); token = (Token) pakFile.getContent(); loadAssets(token.getAllImageAssets(), pakFile); } catch (ConversionException ce) { TabletopTool.showError("PersistenceUtil.error.tokenVersion", ce); } catch (IOException ioe) { TabletopTool.showError("PersistenceUtil.error.tokenRead", ioe); } if (pakFile != null) pakFile.close(); return token; } public static Token loadToken(URL url) throws IOException { // Create a temporary file from the downloaded URL GUID guid = new GUID(); File newFile = new File(PackedFile.getTmpDir(guid.toString()), guid + ".url"); FileUtils.copyURLToFile(url, newFile); Token token = loadToken(newFile); newFile.delete(); return token; } private static void loadAssets(Collection<MD5Key> assetIds, PackedFile pakFile) { List<Asset> addToServer = new ArrayList<Asset>(assetIds.size()); for (MD5Key key : assetIds) { if (key == null) continue; if (!AssetManager.hasAsset(key)) { String pathname = ASSET_DIR + key; Asset asset = null; try { asset = (Asset) pakFile.getFileObject(pathname); // XML deserialization //this fixes a bug where asset objects were serialized without their extension if (asset.getId() == null) { String imageDataPath = null; for (String path : pakFile.getPaths()) { if (path.startsWith(pathname + '.')) { imageDataPath = path; break; } } if (imageDataPath == null) continue; else { String ext = imageDataPath.substring(imageDataPath.lastIndexOf('.') + 1); if (org.apache.commons.lang3.StringUtils.isEmpty(ext)) continue; else asset = new Asset(key, ext); } } } catch (Exception e) { // Do nothing. log.error("Exception while handling asset '" + pathname + "'", e); continue; } // If the asset was marked as "broken" then ignore it completely. The end // result is that MT will attempt to load it from a repository again, as normal. if ("broken".equals(asset.getName())) { log.warn("Reference to 'broken' asset '" + pathname + "' not restored."); ImageManager.flushImage(asset); continue; } // pre 1.3b52 campaign files stored the image data directly in the asset serialization. // New XStreamConverter creates empty byte[] for image. if (asset.getImage() == null || asset.getImage().length < 4) { String ext = asset.getImageExtension(); pathname = pathname + "." + (StringUtil.isEmpty(ext) ? "dat" : ext); try (InputStream is = pakFile.getFileAsInputStream(pathname)) { asset.setImage(IOUtils.toByteArray(is)); } catch (FileNotFoundException fnf) { log.error("Image data for '" + pathname + "' not found?!", fnf); continue; } catch (Exception e) { log.error("While reading image data for '" + pathname + "'", e); continue; } } AssetManager.putAsset(asset); addToServer.add(asset); } } if (!addToServer.isEmpty()) { // Isn't this the same as (TabletopTool.getServer() == null) ? And won't there always // be a server? Even if we don't start one explicitly, TabletopTool keeps a server // running in the background all the time (called a "personal server") so that the rest // of the code is consistent with regard to client<->server operations... boolean server = !TabletopTool.isHostingServer() && !TabletopTool.isPersonalServer(); if (server) { if (TabletopTool.isDevelopment()) TabletopTool.showInformation( "Please report this: (!isHostingServer() && !isPersonalServer()) == true"); // If we are remotely installing this token, we'll need to send the image data to the server. for (Asset asset : addToServer) { TabletopTool.serverCommand().putAsset(asset); } } addToServer.clear(); } } private static void saveAssets(Collection<MD5Key> assetIds, PackedFile pakFile) throws IOException { for (MD5Key assetId : assetIds) { if (assetId == null) continue; // And store the asset elsewhere // As of 1.3.b64, assets are written in binary to allow them to be readable // when a campaign file is unpacked. Asset asset = AssetManager.getAsset(assetId); if (asset == null) { log.error("AssetId " + assetId + " not found while saving?!"); continue; } pakFile.putFile(ASSET_DIR + assetId + "." + asset.getImageExtension(), asset.getImage()); pakFile.putFile(ASSET_DIR + assetId, asset); // Does not write the image } } private static void clearAssets(PackedFile pakFile) throws IOException { for (String path : pakFile.getPaths()) { if (path.startsWith(ASSET_DIR) && !path.equals(ASSET_DIR)) pakFile.removeFile(path); } } public static CampaignProperties loadLegacyCampaignProperties(File file) throws IOException { if (!file.exists()) throw new FileNotFoundException(); try (FileInputStream in = new FileInputStream(file)) { return loadCampaignProperties(in); } } public static CampaignProperties loadCampaignProperties(InputStream in) throws IOException { CampaignProperties props = null; try { props = (CampaignProperties) Persister.newInstance().fromXML(new InputStreamReader(in, "UTF-8")); } catch (ConversionException ce) { TabletopTool.showError("PersistenceUtil.error.campaignPropertiesVersion", ce); } return props; } public static CampaignProperties loadCampaignProperties(File file) { PackedFile pakFile = new PackedFile(file); CampaignProperties props = null; try { props = (CampaignProperties) pakFile.getContent(); loadAssets(props.getAllImageAssets(), pakFile); } catch (ConversionException ce) { TabletopTool.showError("PersistenceUtil.error.campaignPropertiesVersion", ce); } catch (IOException ioe) { TabletopTool.showError("Could not load campaign properties", ioe); } return props; } public static void saveCampaignProperties(Campaign campaign, File file) throws IOException { // Put this in FileUtil if (file.getName().indexOf(".") < 0) { file = new File(file.getAbsolutePath() + AppConstants.CAMPAIGN_PROPERTIES_FILE_EXTENSION); } PackedFile pakFile = null; try { pakFile = new PackedFile(file); clearAssets(pakFile); saveAssets(campaign.getCampaignProperties().getAllImageAssets(), pakFile); pakFile.setContent(campaign.getCampaignProperties()); pakFile.save(); } finally { if (pakFile != null) pakFile.close(); } } // Macro import/export support public static MacroButtonProperties loadLegacyMacro(File file) throws IOException { if (!file.exists()) throw new FileNotFoundException(); try (FileInputStream in = new FileInputStream(file)) { return loadMacro(in); } } public static MacroButtonProperties loadMacro(InputStream in) { MacroButtonProperties mbProps = null; try { mbProps = (MacroButtonProperties) Persister.newInstance().fromXML(new InputStreamReader(in, "UTF-8")); } catch (ConversionException ce) { TabletopTool.showError("PersistenceUtil.error.macroVersion", ce); } catch (IOException ioe) { TabletopTool.showError("PersistenceUtil.error.macroRead", ioe); } return mbProps; } public static MacroButtonProperties loadMacro(File file) throws IOException { PackedFile pakFile = null; try { pakFile = new PackedFile(file); MacroButtonProperties macroButton = (MacroButtonProperties) pakFile.getContent(); return macroButton; } catch (IOException e) { if (pakFile != null) pakFile.close(); pakFile = null; return loadLegacyMacro(file); } finally { if (pakFile != null) pakFile.close(); } } public static void saveMacro(MacroButtonProperties macroButton, File file) throws IOException { // Put this in FileUtil if (file.getName().indexOf(".") < 0) { file = new File(file.getAbsolutePath() + AppConstants.MACRO_FILE_EXTENSION); } PackedFile pakFile = null; try { pakFile = new PackedFile(file); pakFile.setContent(macroButton); pakFile.save(); } finally { if (pakFile != null) pakFile.close(); } } public static List<MacroButtonProperties> loadLegacyMacroSet(File file) throws IOException { if (!file.exists()) { throw new FileNotFoundException(); } try (FileInputStream in = new FileInputStream(file)) { return loadMacroSet(in); } } @SuppressWarnings("unchecked") public static List<MacroButtonProperties> loadMacroSet(InputStream in) throws IOException { List<MacroButtonProperties> macroButtonSet = null; try { macroButtonSet = (List<MacroButtonProperties>) Persister.newInstance() .fromXML(new InputStreamReader(in, "UTF-8")); } catch (ConversionException ce) { TabletopTool.showError("PersistenceUtil.error.macrosetVersion", ce); } return macroButtonSet; } @SuppressWarnings("unchecked") public static List<MacroButtonProperties> loadMacroSet(File file) throws IOException { PackedFile pakFile = null; List<MacroButtonProperties> macroButtonSet = null; try { pakFile = new PackedFile(file); macroButtonSet = (List<MacroButtonProperties>) pakFile.getContent(); } catch (ConversionException ce) { TabletopTool.showError("PersistenceUtil.error.macrosetVersion", ce); } catch (IOException e) { return loadLegacyMacroSet(file); } finally { if (pakFile != null) pakFile.close(); } return macroButtonSet; } public static void saveMacroSet(List<MacroButtonProperties> macroButtonSet, File file) throws IOException { // Put this in FileUtil if (file.getName().indexOf(".") < 0) { file = new File(file.getAbsolutePath() + AppConstants.MACROSET_FILE_EXTENSION); } PackedFile pakFile = null; try { pakFile = new PackedFile(file); pakFile.setContent(macroButtonSet); pakFile.save(); } finally { if (pakFile != null) pakFile.close(); } } // end of Macro import/export support // Table import/export support public static LookupTable loadLegacyTable(File file) throws IOException { if (!file.exists()) throw new FileNotFoundException(); try (FileInputStream in = new FileInputStream(file)) { return loadTable(in); } } public static LookupTable loadTable(InputStream in) { LookupTable table = null; try { table = (LookupTable) Persister.newInstance().fromXML(new InputStreamReader(in, "UTF-8")); } catch (ConversionException ce) { TabletopTool.showError("PersistenceUtil.error.tableVersion", ce); } catch (IOException ioe) { TabletopTool.showError("PersistenceUtil.error.tableRead", ioe); } return table; } public static LookupTable loadTable(File file) { PackedFile pakFile = null; try { pakFile = new PackedFile(file); LookupTable lookupTable = (LookupTable) pakFile.getContent(); loadAssets(lookupTable.getAllAssetIds(), pakFile); return lookupTable; } catch (ConversionException ce) { TabletopTool.showError("PersistenceUtil.error.tableVersion", ce); } catch (IOException e) { try { if (pakFile != null) pakFile.close(); pakFile = null; return loadLegacyTable(file); } catch (IOException ioe) { TabletopTool.showError("PersistenceUtil.error.tableRead", ioe); } } finally { if (pakFile != null) pakFile.close(); } return null; } public static void saveTable(LookupTable lookupTable, File file) throws IOException { // Put this in FileUtil if (file.getName().indexOf(".") < 0) { file = new File(file.getAbsolutePath() + AppConstants.TABLE_FILE_EXTENSION); } PackedFile pakFile = null; try { pakFile = new PackedFile(file); pakFile.setContent(lookupTable); saveAssets(lookupTable.getAllAssetIds(), pakFile); pakFile.save(); } finally { if (pakFile != null) pakFile.close(); } } }