path: root/NET/worlds/scape/PendingDrone.java

package NET.worlds.scape;

import NET.worlds.core.Archive;
import NET.worlds.core.IniFile;
import NET.worlds.network.Cache;
import NET.worlds.network.CacheFile;
import NET.worlds.network.NetUpdate;
import NET.worlds.network.URL;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;

public class PendingDrone {
   static boolean doAvatarUpdates = true;
   protected PosableDrone drone;
   protected URL url;
   protected boolean loaded;
   static final boolean debug = false;

   static {
      doAvatarUpdates = IniFile.gamma().getIniInt("noAvUpdates", 0) == 0;
   }

   PendingDrone(PosableDrone _drone, URL _url) {
      this.drone = _drone;
      this.url = _url;
      this.loaded = false;
   }

   public PosableDrone getDrone() {
      return this.drone;
   }

   public URL getUrl() {
      return this.url;
   }

   public boolean getLoaded() {
      return this.loaded;
   }

   public void setLoaded() {
      this.loaded = true;
   }

   public synchronized void download(URL avURL) {
      if (doAvatarUpdates) {
         if (avURL != null) {
            try {
               if (PosableDroneLoader.avatarExistsLocally(avURL)) {
                  return;
               }
            } catch (MalformedURLException var5) {
               return;
            }

            String s = PosableDroneLoader.getAvatarBaseName(avURL);

            assert s != null;

            s = s.toLowerCase();
            URL realFile = URL.make(NetUpdate.getUpgradeServerURL() + "AvatarUpgrades/" + s + ".zip");
            CacheFile cf = Cache.getFile(realFile);
            cf.waitUntilLoaded();
            if (!cf.error()) {
               this.finishDownload(cf.getLocalName());
               cf.close();
            }
         }
      }
   }

   public synchronized boolean finishDownload(String localName) {
      ZipFile patchArchive;
      try {
         patchArchive = new ZipFile(localName);
      } catch (IOException var11) {
         this.notify();
         return false;
      }

      Enumeration enums = patchArchive.entries();

      while (enums.hasMoreElements()) {
         ZipEntry ze = (ZipEntry)enums.nextElement();
         String filename = ze.getName();
         String avatarFile = URL.homeUnalias("avatars/" + filename);
         String[] validExtensions = new String[]{".bod", ".seq", ".dat", ".cmp", ".mov"};
         boolean validFile = false;

         for (int idx = 0; idx < validExtensions.length; idx++) {
            if (avatarFile.toString().endsWith(validExtensions[idx])) {
               validFile = true;
               break;
            }
         }

         if (validFile) {
            if (avatarFile.toString().endsWith("avatars.dat")) {
               avatarFile = URL.homeUnalias("avatars/avatars.tmp");
               this.CopyAvatarFile(patchArchive, ze, avatarFile);
               this.AppendAvatarsDat();
            } else {
               this.CopyAvatarFile(patchArchive, ze, avatarFile);
            }
         }
      }

      try {
         patchArchive.close();
      } catch (IOException var10) {
      }

      this.notify();
      return false;
   }

   public Room getBackgroundLoadRoom() {
      return this.drone != null && this.drone.getOwner() != null ? this.drone.getOwner().getRoom() : null;
   }

   private void AppendAvatarsDat() {
      String contentZip = URL.homeUnalias("avatars/content.zip");
      Archive.flushAll();

      ZipFile contentZipArchive;
      try {
         contentZipArchive = new ZipFile(contentZip);
      } catch (IOException var12) {
         contentZipArchive = null;
      }

      if (contentZipArchive != null) {
         ZipEntry origAvatarDat = contentZipArchive.getEntry("avatars.dat");
         if (origAvatarDat != null) {
            this.CopyAvatarFile(contentZipArchive, origAvatarDat, URL.homeUnalias("avatars/avatars.dat"));
            this.StripAvatarDat(contentZipArchive);
         } else {
            try {
               contentZipArchive.close();
            } catch (IOException var11) {
            }
         }
      }

      FileOutputStream avDat;
      try {
         avDat = new FileOutputStream(URL.homeUnalias("avatars/avatars.dat"), true);
      } catch (IOException var10) {
         System.out.println(var10);
         return;
      }

      FileInputStream avTmp;
      try {
         avTmp = new FileInputStream(URL.homeUnalias("avatars/avatars.tmp"));
      } catch (FileNotFoundException var9) {
         try {
            avDat.close();
         } catch (IOException var7) {
         }

         return;
      }

      byte[] buf = new byte[1024];

      while (true) {
         try {
            int bytesRead = avTmp.read(buf);
            if (bytesRead == -1) {
               break;
            }

            avDat.write(buf, 0, bytesRead);
         } catch (IOException var13) {
            break;
         }
      }

      try {
         avDat.close();
         avTmp.close();
      } catch (IOException var8) {
      }

      File avTmpFile = new File(URL.homeUnalias("avatars/avatars.tmp"));
      avTmpFile.delete();
      DroneAnimator.loadconfig(URL.make("home:avatars/avatars.dat").unalias());
   }

   private void StripAvatarDat(ZipFile contentZipArchive) {
      FileOutputStream os;
      try {
         os = new FileOutputStream(URL.homeUnalias("avatars/content.tmp"));
      } catch (IOException var13) {
         return;
      }

      ZipOutputStream zs = new ZipOutputStream(os);
      Enumeration enums = contentZipArchive.entries();

      while (enums.hasMoreElements()) {
         ZipEntry ze = (ZipEntry)enums.nextElement();
         String filename = ze.getName();
         if (!filename.equals("avatars.dat")) {
            try {
               InputStream is = contentZipArchive.getInputStream(ze);
               ZipEntry ze2 = new ZipEntry(ze.getName());
               zs.putNextEntry(ze2);
               byte[] buffer = new byte[1024];

               while (true) {
                  try {
                     int bytesRead = is.read(buffer);
                     if (bytesRead != -1) {
                        zs.write(buffer, 0, bytesRead);
                        continue;
                     }
                  } catch (IOException var14) {
                     System.out.println("IOException " + ze.getName() + " " + var14.getMessage());
                  }

                  zs.closeEntry();
                  is.close();
                  break;
               }
            } catch (IOException var15) {
               System.out.println("IOException 2 " + var15.getMessage());
            }
         }
      }

      try {
         contentZipArchive.close();
         zs.close();
      } catch (IOException var12) {
         System.out.println("Error closing zip files " + var12);
      }

      File origFile = new File(URL.homeUnalias("avatars/content.zip"));
      File newFile = new File(URL.homeUnalias("avatars/content.tmp"));
      File oldFile = new File(URL.homeUnalias("avatars/content.old"));
      Archive.flushAll();

      try {
         boolean b = origFile.renameTo(oldFile);
         b = newFile.renameTo(origFile);
      } catch (Exception var11) {
         System.out.println(var11);
      }
   }

   private void CopyAvatarFile(ZipFile patchArchive, ZipEntry ze, String avatarFile) {
      InputStream is;
      try {
         is = patchArchive.getInputStream(ze);
      } catch (IOException var11) {
         return;
      }

      FileOutputStream os;
      try {
         os = new FileOutputStream(avatarFile);
      } catch (IOException var10) {
         try {
            is.close();
         } catch (IOException var8) {
         }

         return;
      }

      byte[] buffer = new byte[1024];

      while (true) {
         try {
            int bytesRead = is.read(buffer);
            if (bytesRead == -1) {
               break;
            }

            os.write(buffer, 0, bytesRead);
         } catch (IOException var12) {
            break;
         }
      }

      try {
         is.close();
         os.close();
      } catch (IOException var9) {
      }
   }
}