mirror of
https://github.com/2009scape/2009Scape-mobile.git
synced 2025-12-20 05:20:14 -07:00
317 lines
12 KiB
Java
317 lines
12 KiB
Java
package net.kdt.pojavlaunch.tasks;
|
|
|
|
import android.app.*;
|
|
import android.content.*;
|
|
import android.graphics.*;
|
|
import android.os.*;
|
|
import android.util.*;
|
|
import com.google.gson.*;
|
|
import java.io.*;
|
|
import java.util.*;
|
|
import net.kdt.pojavlaunch.*;
|
|
import net.kdt.pojavlaunch.prefs.*;
|
|
import net.kdt.pojavlaunch.utils.*;
|
|
import net.kdt.pojavlaunch.value.*;
|
|
import org.apache.commons.io.*;
|
|
|
|
public class MinecraftDownloaderTask extends AsyncTask<String, String, Throwable>
|
|
{
|
|
private BaseLauncherActivity mActivity;
|
|
private boolean launchWithError = false;
|
|
|
|
public MinecraftDownloaderTask(BaseLauncherActivity activity) {
|
|
mActivity = activity;
|
|
}
|
|
|
|
@Override
|
|
protected void onPreExecute() {
|
|
mActivity.mLaunchProgress.setMax(1);
|
|
mActivity.statusIsLaunching(true);
|
|
}
|
|
|
|
private JMinecraftVersionList.Version verInfo;
|
|
@Override
|
|
protected Throwable doInBackground(final String[] p1) {
|
|
Throwable throwable = null;
|
|
try {
|
|
final String downVName = "/" + p1[0] + "/" + p1[0];
|
|
|
|
//Downloading libraries
|
|
String minecraftMainJar = Tools.versnDir + downVName + ".jar";
|
|
JAssets assets = null;
|
|
try {
|
|
//com.pojavdx.dx.mod.Main.debug = true;
|
|
|
|
String verJsonDir = Tools.versnDir + downVName + ".json";
|
|
|
|
verInfo = findVersion(p1[0]);
|
|
|
|
if (verInfo.url != null && !new File(verJsonDir).exists()) {
|
|
publishProgress("1", "Downloading " + p1[0] + " configuration...");
|
|
Tools.downloadFile(
|
|
verInfo.url,
|
|
verJsonDir
|
|
);
|
|
}
|
|
|
|
verInfo = Tools.getVersionInfo(p1[0]);
|
|
assets = downloadIndex(verInfo.assets, new File(Tools.ASSETS_PATH, "indexes/" + verInfo.assets + ".json"));
|
|
|
|
File outLib;
|
|
String libPathURL;
|
|
|
|
setMax(verInfo.libraries.length + 4 + assets.objects.size());
|
|
for (final DependentLibrary libItem : verInfo.libraries) {
|
|
|
|
if (// libItem.name.startsWith("com.google.code.gson:gson") ||
|
|
// libItem.name.startsWith("com.mojang:realms") ||
|
|
libItem.name.startsWith("net.java.jinput") ||
|
|
// libItem.name.startsWith("net.minecraft.launchwrapper") ||
|
|
|
|
// FIXME lib below!
|
|
// libItem.name.startsWith("optifine:launchwrapper-of") ||
|
|
|
|
// libItem.name.startsWith("org.lwjgl.lwjgl:lwjgl") ||
|
|
libItem.name.startsWith("org.lwjgl")
|
|
// libItem.name.startsWith("tv.twitch")
|
|
) { // Black list
|
|
publishProgress("1", "Ignored " + libItem.name);
|
|
//Thread.sleep(100);
|
|
} else {
|
|
|
|
String[] libInfo = libItem.name.split(":");
|
|
String libArtifact = Tools.artifactToPath(libInfo[0], libInfo[1], libInfo[2]);
|
|
outLib = new File(Tools.libraries + "/" + libArtifact);
|
|
outLib.getParentFile().mkdirs();
|
|
|
|
if (!outLib.exists()) {
|
|
publishProgress("1", mActivity.getString(R.string.mcl_launch_download_lib, libItem.name));
|
|
|
|
boolean skipIfFailed = false;
|
|
|
|
if (libItem.downloads == null || libItem.downloads.artifact == null) {
|
|
MinecraftLibraryArtifact artifact = new MinecraftLibraryArtifact();
|
|
artifact.url = (libItem.url == null ? "https://libraries.minecraft.net/" : libItem.url) + libArtifact;
|
|
libItem.downloads = new DependentLibrary.LibraryDownloads(artifact);
|
|
|
|
skipIfFailed = true;
|
|
}
|
|
try {
|
|
libPathURL = libItem.downloads.artifact.url;
|
|
Tools.downloadFile(
|
|
libPathURL,
|
|
outLib.getAbsolutePath()
|
|
);
|
|
} catch (Throwable th) {
|
|
if (!skipIfFailed) {
|
|
throw th;
|
|
} else {
|
|
th.printStackTrace();
|
|
publishProgress("0", th.getMessage());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
publishProgress("1", mActivity.getString(R.string.mcl_launch_download_client, p1[0]));
|
|
File minecraftMainFile = new File(minecraftMainJar);
|
|
if (!minecraftMainFile.exists() || minecraftMainFile.length() == 0l) {
|
|
try {
|
|
Tools.downloadFile(
|
|
verInfo.downloads.values().toArray(new MinecraftClientInfo[0])[0].url,
|
|
minecraftMainJar
|
|
);
|
|
} catch (Throwable th) {
|
|
if (verInfo.inheritsFrom != null) {
|
|
minecraftMainFile.delete();
|
|
IOUtils.copy(new FileInputStream(new File(Tools.versnDir, verInfo.inheritsFrom + "/" + verInfo.inheritsFrom + ".jar")), new FileOutputStream(minecraftMainFile));
|
|
} else {
|
|
throw th;
|
|
}
|
|
}
|
|
}
|
|
} catch (Throwable e) {
|
|
launchWithError = true;
|
|
throw e;
|
|
}
|
|
|
|
publishProgress("1", mActivity.getString(R.string.mcl_launch_cleancache));
|
|
// new File(inputPath).delete();
|
|
|
|
for (File f : new File(Tools.versnDir).listFiles()) {
|
|
if(f.getName().endsWith(".part")) {
|
|
Log.d(Tools.APP_NAME, "Cleaning cache: " + f);
|
|
f.delete();
|
|
}
|
|
}
|
|
|
|
mActivity.mIsAssetsProcessing = true;
|
|
mActivity.mPlayButton.post(new Runnable(){
|
|
|
|
@Override
|
|
public void run()
|
|
{
|
|
mActivity.mPlayButton.setText("Skip");
|
|
mActivity.mPlayButton.setEnabled(true);
|
|
}
|
|
});
|
|
publishProgress("1", mActivity.getString(R.string.mcl_launch_download_assets));
|
|
try {
|
|
downloadAssets(assets, verInfo.assets, new File(Tools.ASSETS_PATH));
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
|
|
// Ignore it
|
|
launchWithError = false;
|
|
} finally {
|
|
mActivity.mIsAssetsProcessing = false;
|
|
}
|
|
} catch (Throwable th){
|
|
throwable = th;
|
|
} finally {
|
|
return throwable;
|
|
}
|
|
}
|
|
private int addProgress = 0; // 34
|
|
|
|
public void zeroProgress()
|
|
{
|
|
addProgress = 0;
|
|
}
|
|
|
|
public void setMax(final int value)
|
|
{
|
|
mActivity.mLaunchProgress.post(new Runnable(){
|
|
|
|
@Override
|
|
public void run()
|
|
{
|
|
mActivity.mLaunchProgress.setMax(value);
|
|
}
|
|
});
|
|
}
|
|
|
|
@Override
|
|
protected void onProgressUpdate(String... p1)
|
|
{
|
|
int addedProg = Integer.parseInt(p1[0]);
|
|
if (addedProg != -1) {
|
|
addProgress = addProgress + addedProg;
|
|
mActivity.mLaunchProgress.setProgress(addProgress);
|
|
|
|
mActivity.mLaunchTextStatus.setText(p1[1]);
|
|
}
|
|
|
|
if (p1.length < 3) {
|
|
mActivity.mConsoleView.putLog(p1[1] + (p1.length < 3 ? "\n" : ""));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void onPostExecute(Throwable p1)
|
|
{
|
|
mActivity.mPlayButton.setText("Play");
|
|
mActivity.mPlayButton.setEnabled(true);
|
|
mActivity.mLaunchProgress.setMax(100);
|
|
mActivity.mLaunchProgress.setProgress(0);
|
|
mActivity.statusIsLaunching(false);
|
|
if(p1 != null) {
|
|
p1.printStackTrace();
|
|
Tools.showError(mActivity, p1);
|
|
}
|
|
if(!launchWithError) {
|
|
mActivity.mCrashView.setLastCrash("");
|
|
|
|
try {
|
|
/*
|
|
List<String> jvmArgs = ManagementFactory.getRuntimeMXBean().getInputArguments();
|
|
jvmArgs.add("-Xms128M");
|
|
jvmArgs.add("-Xmx1G");
|
|
*/
|
|
Intent mainIntent = new Intent(mActivity, MainActivity.class /* MainActivity.class */);
|
|
// mainIntent.addFlags(Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT);
|
|
mainIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_DOCUMENT);
|
|
mainIntent.addFlags(Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
|
|
if (LauncherPreferences.PREF_FREEFORM) {
|
|
DisplayMetrics dm = new DisplayMetrics();
|
|
mActivity.getWindowManager().getDefaultDisplay().getMetrics(dm);
|
|
|
|
ActivityOptions options = (ActivityOptions) ActivityOptions.class.getMethod("makeBasic").invoke(null);
|
|
Rect freeformRect = new Rect(0, 0, dm.widthPixels / 2, dm.heightPixels / 2);
|
|
options.getClass().getDeclaredMethod("setLaunchBounds", Rect.class).invoke(options, freeformRect);
|
|
mActivity.startActivity(mainIntent, options.toBundle());
|
|
} else {
|
|
mActivity.startActivity(mainIntent);
|
|
}
|
|
}
|
|
catch (Throwable e) {
|
|
Tools.showError(mActivity, e);
|
|
}
|
|
|
|
/*
|
|
FloatingIntent maini = new FloatingIntent(PojavLauncherActivity.this, MainActivity.class);
|
|
maini.startFloatingActivity();
|
|
*/
|
|
}
|
|
|
|
mActivity.mTask = null;
|
|
}
|
|
|
|
public static final String MINECRAFT_RES = "http://resources.download.minecraft.net/";
|
|
|
|
public JAssets downloadIndex(String versionName, File output) throws Throwable {
|
|
if (!output.exists()) {
|
|
output.getParentFile().mkdirs();
|
|
DownloadUtils.downloadFile(verInfo.assetIndex != null ? verInfo.assetIndex.url : "http://s3.amazonaws.com/Minecraft.Download/indexes/" + versionName + ".json", output);
|
|
}
|
|
|
|
return Tools.GLOBAL_GSON.fromJson(Tools.read(output.getAbsolutePath()), JAssets.class);
|
|
}
|
|
|
|
public void downloadAsset(JAssetInfo asset, File objectsDir) throws IOException, Throwable {
|
|
String assetPath = asset.hash.substring(0, 2) + "/" + asset.hash;
|
|
File outFile = new File(objectsDir, assetPath);
|
|
if (!outFile.exists()) {
|
|
DownloadUtils.downloadFile(MINECRAFT_RES + assetPath, outFile);
|
|
}
|
|
}
|
|
|
|
public void downloadAssets(JAssets assets, String assetsVersion, File outputDir) throws IOException, Throwable {
|
|
File hasDownloadedFile = new File(outputDir, "downloaded/" + assetsVersion + ".downloaded");
|
|
if (!hasDownloadedFile.exists()) {
|
|
System.out.println("Assets begin time: " + System.currentTimeMillis());
|
|
Map<String, JAssetInfo> assetsObjects = assets.objects;
|
|
mActivity.mLaunchProgress.setMax(assetsObjects.size());
|
|
zeroProgress();
|
|
File objectsDir = new File(outputDir, "objects");
|
|
int downloadedSs = 0;
|
|
for (JAssetInfo asset : assetsObjects.values()) {
|
|
if (!mActivity.mIsAssetsProcessing) {
|
|
return;
|
|
}
|
|
|
|
downloadAsset(asset, objectsDir);
|
|
publishProgress("1", mActivity.getString(R.string.mcl_launch_downloading, assetsObjects.keySet().toArray(new String[0])[downloadedSs]));
|
|
downloadedSs++;
|
|
}
|
|
hasDownloadedFile.getParentFile().mkdirs();
|
|
hasDownloadedFile.createNewFile();
|
|
System.out.println("Assets end time: " + System.currentTimeMillis());
|
|
}
|
|
}
|
|
|
|
|
|
private JMinecraftVersionList.Version findVersion(String version) {
|
|
if (mActivity.mVersionList != null) {
|
|
for (JMinecraftVersionList.Version valueVer: mActivity.mVersionList.versions) {
|
|
if (valueVer.id.equals(version)) {
|
|
return valueVer;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Custom version, inherits from base.
|
|
return Tools.getVersionInfo(version);
|
|
}
|
|
}
|