mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 04:46:08 +00:00
Stores: Epic Games - web sign-in, library, store shelves, installs, per-launch sign-in code
Epic's web login in StoreLoginActivity (the code read off the redirect's JSON page and exchanged for tokens with the launcher's public client); the library from the library service enriched by the catalog; the Store tab from the store's GraphQL and the free-games feed. An install runs the ported pipeline: manifest API, manifest binary (or the older JSON), base files plus the device's language, a delta pass over what is on disk, the chunk fetch through the native engine or the built-in pool, assembly. The manifest's launch exe names the game's exe; the sidecar carries the EpicPortal identity arguments, and a launch gets a fresh exchange code through the launcher .bat. The EOS overlay is never provisioned.
This commit is contained in:
1 parent
0687e3477e
commit
0c59f551af
13 files changed
+1940
No files matched your search
@@ -0,0 +1,44 @@
|
||||
package com.droiddeck.launcher.stores
|
||||
|
||||
import java.io.File
|
||||
|
||||
/**
|
||||
* Which .exe in an install folder is the game. The store's own hint (a manifest's launch
|
||||
* executable) wins when the file exists; else the candidates, helpers and installers left out,
|
||||
* the one named most like the title first, then the shallowest. Relative to the folder, forward
|
||||
* slashes; "" when the folder has none.
|
||||
*/
|
||||
object StoreExe {
|
||||
private val SKIP = listOf("redist", "unins", "setup", "crash", "report", "helper", "dotnet", "vcredist", "directx", "eac", "easyanticheat", "battleye", "launcher", "updater", "config")
|
||||
|
||||
fun pick(folder: File, hint: String?, title: String): String {
|
||||
val hinted = hint?.takeIf { it.isNotBlank() }?.replace('\\', '/')?.trimStart('/')?.let { File(folder, it) }
|
||||
if (hinted != null && hinted.isFile) return relative(folder, hinted)
|
||||
val candidates = ArrayList<File>()
|
||||
collect(folder, candidates, 0)
|
||||
if (candidates.isEmpty()) return ""
|
||||
val key = title.lowercase().replace(Regex("[^a-z0-9]"), "")
|
||||
val best = candidates.firstOrNull { f ->
|
||||
val n = f.nameWithoutExtension.lowercase().replace(Regex("[^a-z0-9]"), "")
|
||||
n.isNotEmpty() && (n == key || (key.length >= 4 && key.startsWith(n)) || (n.length >= 4 && n.startsWith(key)))
|
||||
} ?: candidates.sortedWith(compareBy<File> { depth(folder, it) }.thenByDescending { it.length() }).first()
|
||||
return relative(folder, best)
|
||||
}
|
||||
|
||||
private fun collect(dir: File, out: MutableList<File>, depth: Int) {
|
||||
if (depth > 4) return
|
||||
val files = dir.listFiles() ?: return
|
||||
for (f in files) {
|
||||
if (f.isFile && f.name.endsWith(".exe", ignoreCase = true)) {
|
||||
val lower = f.name.lowercase()
|
||||
if (SKIP.none { lower.contains(it) }) out.add(f)
|
||||
}
|
||||
}
|
||||
for (f in files) if (f.isDirectory && !f.name.startsWith(".")) collect(f, out, depth + 1)
|
||||
}
|
||||
|
||||
private fun depth(root: File, f: File): Int = relative(root, f).count { it == '/' }
|
||||
|
||||
fun relative(root: File, f: File): String =
|
||||
f.absolutePath.removePrefix(root.absolutePath).trimStart('/').replace('\\', '/')
|
||||
}
|
||||
@@ -0,0 +1,191 @@
|
||||
package com.droiddeck.launcher.stores.epic;
|
||||
|
||||
import android.util.Log;
|
||||
|
||||
import com.droiddeck.launcher.stores.StoreLog;
|
||||
|
||||
import org.json.JSONArray;
|
||||
import org.json.JSONObject;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Epic's library, catalog and launcher-assets services, as the launcher calls them:
|
||||
* library-service.live.use1a.on.epicgames.com/library/api/public/items (owned items, paginated)
|
||||
* catalog-public-service-prod06.ol.epicgames.com/catalog/api/shared/namespace/{ns}/bulk/items
|
||||
* launcher-public-service-prod06.ol.epicgames.com/launcher/api/public/assets/v2/platform/Windows/...
|
||||
* All with a bearer token.
|
||||
*/
|
||||
public final class EpicApiClient {
|
||||
|
||||
private static final String TAG = "EpicApi";
|
||||
private static final String LIBRARY_URL = "https://library-service.live.use1a.on.epicgames.com/library/api/public/items?includeMetadata=true";
|
||||
private static final String CATALOG_BASE = "https://catalog-public-service-prod06.ol.epicgames.com/catalog/api/shared/namespace";
|
||||
private static final String MANIFEST_BASE = "https://launcher-public-service-prod06.ol.epicgames.com/launcher/api/public/assets/v2/platform/Windows/namespace";
|
||||
private static final String LEGENDARY_UA = "Legendary/0.1.0 (GameNative)";
|
||||
|
||||
private EpicApiClient() {}
|
||||
|
||||
/** The owned games, every page; Unreal assets, private sandboxes and non-Windows items left out. */
|
||||
public static List<EpicGame> getLibraryItems(String accessToken) {
|
||||
List<EpicGame> result = new ArrayList<>();
|
||||
String cursor = null;
|
||||
do {
|
||||
try {
|
||||
String url = LIBRARY_URL + (cursor != null ? "&cursor=" + cursor : "");
|
||||
String resp = EpicAuthClient.getRequest(url, accessToken);
|
||||
if (resp == null) break;
|
||||
JSONObject json = new JSONObject(resp);
|
||||
JSONArray records = json.optJSONArray("records");
|
||||
if (records == null) break;
|
||||
for (int i = 0; i < records.length(); i++) {
|
||||
JSONObject rec = records.getJSONObject(i);
|
||||
String appName = rec.optString("appName", "");
|
||||
if (appName.isEmpty() || appName.equals("1")) continue;
|
||||
String namespace = rec.optString("namespace", "");
|
||||
if ("ue".equals(namespace) || "89efe5924d3d467c839449ab6ab52e7f".equals(namespace)) continue;
|
||||
if ("PRIVATE".equals(rec.optString("sandboxType", ""))) continue;
|
||||
JSONArray platforms = rec.optJSONArray("platform");
|
||||
if (platforms != null && platforms.length() > 0) {
|
||||
boolean windows = false;
|
||||
for (int j = 0; j < platforms.length(); j++) {
|
||||
String p = platforms.optString(j, "");
|
||||
if ("Windows".equals(p) || "Win32".equals(p)) { windows = true; break; }
|
||||
}
|
||||
if (!windows) continue;
|
||||
}
|
||||
EpicGame game = new EpicGame();
|
||||
game.appName = appName;
|
||||
game.namespace = namespace;
|
||||
game.catalogItemId = rec.optString("catalogItemId", "");
|
||||
result.add(game);
|
||||
}
|
||||
JSONObject meta = json.optJSONObject("responseMetadata");
|
||||
String next = meta != null ? meta.optString("nextCursor", null) : null;
|
||||
cursor = (next == null || next.isEmpty() || next.equals(cursor)) ? null : next;
|
||||
} catch (Exception e) {
|
||||
Log.e(TAG, "library page failed: " + e.getClass().getSimpleName());
|
||||
break;
|
||||
}
|
||||
} while (cursor != null);
|
||||
return result;
|
||||
}
|
||||
|
||||
/** Fills title, developer, art, description and the DLC flag from the catalog; true on success. */
|
||||
public static boolean enrichFromCatalog(String accessToken, EpicGame game) {
|
||||
if (game.namespace.isEmpty() || game.catalogItemId.isEmpty()) return false;
|
||||
try {
|
||||
String url = CATALOG_BASE + "/" + game.namespace + "/bulk/items?id=" + game.catalogItemId + "&includeDLCDetails=true&includeMainGameDetails=true&country=US";
|
||||
String resp = getWithLegendaryUA(url, accessToken);
|
||||
if (resp == null) return false;
|
||||
JSONObject root = new JSONObject(resp);
|
||||
JSONObject item = root.optJSONObject(game.catalogItemId);
|
||||
if (item == null && root.length() > 0) item = root.optJSONObject(root.keys().next());
|
||||
if (item == null) return false;
|
||||
game.title = item.optString("title", game.title.isEmpty() ? game.appName : game.title);
|
||||
game.developer = item.optString("developer", "");
|
||||
game.description = item.optString("description", "");
|
||||
game.isDLC = item.has("mainGameItem");
|
||||
if (game.isDLC) {
|
||||
JSONObject main = item.optJSONObject("mainGameItem");
|
||||
if (main != null) game.baseGameCatalogItemId = main.optString("id", "");
|
||||
}
|
||||
JSONArray keyImages = item.optJSONArray("keyImages");
|
||||
if (keyImages != null) for (int i = 0; i < keyImages.length(); i++) {
|
||||
JSONObject img = keyImages.getJSONObject(i);
|
||||
String type = img.optString("type", ""), imgUrl = img.optString("url", "");
|
||||
if (imgUrl.isEmpty()) continue;
|
||||
if ("DieselGameBoxTall".equals(type)) game.artCover = imgUrl;
|
||||
else if (("DieselGameBox".equals(type) || "Thumbnail".equals(type)) && game.artSquare.isEmpty()) game.artSquare = imgUrl;
|
||||
}
|
||||
JSONObject attrs = item.optJSONObject("customAttributes");
|
||||
if (attrs != null) {
|
||||
JSONObject offline = attrs.optJSONObject("CanRunOffline");
|
||||
if (offline != null) game.canRunOffline = !"false".equalsIgnoreCase(offline.optString("value", "true"));
|
||||
}
|
||||
String rd = item.optString("viewableDate", "");
|
||||
if (rd.isEmpty()) rd = item.optString("effectiveDate", "");
|
||||
if (!rd.isEmpty()) game.releaseDate = rd;
|
||||
return true;
|
||||
} catch (Exception e) {
|
||||
Log.e(TAG, "catalog enrich failed for " + game.appName + ": " + e.getClass().getSimpleName());
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The manifest API answer for a game, flattened to {"manifests": [...], "versionId": "..."} as
|
||||
* the download manager reads it. {@code appName} is the library record's, not the catalog's.
|
||||
*/
|
||||
public static String getManifestApiJson(String accessToken, String namespace, String catalogItemId, String appName) {
|
||||
try {
|
||||
String url = MANIFEST_BASE + "/" + namespace + "/catalogItem/" + catalogItemId + "/app/" + appName + "/label/Live";
|
||||
String resp = getWithLegendaryUA(url, accessToken);
|
||||
if (resp == null) return null;
|
||||
JSONObject root = new JSONObject(resp);
|
||||
JSONArray elements = root.optJSONArray("elements");
|
||||
if (elements == null || elements.length() == 0) return null;
|
||||
JSONObject first = elements.getJSONObject(0);
|
||||
JSONObject wrapper = new JSONObject();
|
||||
wrapper.put("manifests", first.optJSONArray("manifests"));
|
||||
String ver = first.optString("buildVersion", "");
|
||||
if (ver.isEmpty()) ver = first.optString("versionId", "");
|
||||
wrapper.put("versionId", ver);
|
||||
// The sidecar's EOS deployment id, when the app has one.
|
||||
JSONObject sidecar = first.optJSONObject("sidecar");
|
||||
if (sidecar != null) {
|
||||
String config = sidecar.optString("config", "");
|
||||
if (!config.isEmpty()) {
|
||||
try { wrapper.put("deploymentId", new JSONObject(config).optString("deploymentId", "")); } catch (Exception ignored) {}
|
||||
}
|
||||
}
|
||||
return wrapper.toString();
|
||||
} catch (Exception e) {
|
||||
Log.e(TAG, "manifest API failed for " + appName + ": " + e.getClass().getSimpleName());
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/** `customAttributes.AdditionalCommandLine.value` for the game, "" when it has none, null when the call failed. */
|
||||
public static String getAdditionalCommandLine(String accessToken, String namespace, String catalogItemId) {
|
||||
try {
|
||||
String url = CATALOG_BASE + "/" + namespace + "/bulk/items?id=" + catalogItemId + "&country=US";
|
||||
String resp = getWithLegendaryUA(url, accessToken);
|
||||
if (resp == null) return null;
|
||||
JSONObject root = new JSONObject(resp);
|
||||
JSONObject item = root.optJSONObject(catalogItemId);
|
||||
if (item == null && root.length() > 0) item = root.optJSONObject(root.keys().next());
|
||||
if (item == null) return "";
|
||||
JSONObject attrs = item.optJSONObject("customAttributes");
|
||||
if (attrs == null) return "";
|
||||
JSONObject attr = attrs.optJSONObject("AdditionalCommandLine");
|
||||
return attr == null ? "" : attr.optString("value", "");
|
||||
} catch (Exception e) {
|
||||
Log.w(TAG, "additional command line: " + e.getClass().getSimpleName());
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
static String getWithLegendaryUA(String urlStr, String accessToken) {
|
||||
java.net.HttpURLConnection conn = null;
|
||||
try {
|
||||
conn = (java.net.HttpURLConnection) new java.net.URL(urlStr).openConnection();
|
||||
conn.setRequestMethod("GET");
|
||||
conn.setConnectTimeout(30000);
|
||||
conn.setReadTimeout(30000);
|
||||
conn.setRequestProperty("Authorization", "Bearer " + accessToken);
|
||||
conn.setRequestProperty("User-Agent", LEGENDARY_UA);
|
||||
int code = conn.getResponseCode();
|
||||
java.io.InputStream is = (code < 400) ? conn.getInputStream() : conn.getErrorStream();
|
||||
String body = EpicAuthClient.readStream(is);
|
||||
if (code < 200 || code >= 300) { Log.e(TAG, "GET HTTP " + code + " from " + StoreLog.redactUrl(urlStr)); return null; }
|
||||
return body;
|
||||
} catch (Exception e) {
|
||||
Log.e(TAG, "GET failed: " + StoreLog.redactUrl(urlStr) + " (" + e.getClass().getSimpleName() + ")");
|
||||
return null;
|
||||
} finally {
|
||||
if (conn != null) conn.disconnect();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,180 @@
|
||||
package com.droiddeck.launcher.stores.epic;
|
||||
|
||||
import android.util.Base64;
|
||||
import android.util.Log;
|
||||
|
||||
import com.droiddeck.launcher.stores.StoreLog;
|
||||
|
||||
import org.json.JSONObject;
|
||||
|
||||
import java.io.BufferedReader;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.io.InputStreamReader;
|
||||
import java.io.OutputStream;
|
||||
import java.net.HttpURLConnection;
|
||||
import java.net.URL;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
|
||||
/**
|
||||
* Epic's OAuth2 token endpoint, with the launcher's public client credentials (the ones every
|
||||
* third-party Epic client uses):
|
||||
* POST account-public-service-prod03.ol.epicgames.com/account/api/oauth/token
|
||||
* Basic base64(clientId:clientSecret), form grant_type=authorization_code|refresh_token, token_type=eg1
|
||||
* GET .../account/api/oauth/exchange with a bearer token: a short-lived exchange code for a launch.
|
||||
* Error bodies are never logged: they carry correlation ids and account context.
|
||||
*/
|
||||
public final class EpicAuthClient {
|
||||
|
||||
private static final String TAG = "EpicAuth";
|
||||
|
||||
static final String CLIENT_ID = "34a02cf8f4414e29b15921876da36f9a";
|
||||
static final String CLIENT_SECRET = "daafbccc737745039dffe53d94fc76cf";
|
||||
private static final String TOKEN_URL = "https://account-public-service-prod03.ol.epicgames.com/account/api/oauth/token";
|
||||
private static final String EXCHANGE_URL = "https://account-public-service-prod03.ol.epicgames.com/account/api/oauth/exchange";
|
||||
public static final String USER_AGENT = "UELauncher/11.0.1-14907503+++Portal+Release-Live Windows/10.0.19041.1.256.64bit";
|
||||
|
||||
public static final class TokenResult {
|
||||
public String accessToken;
|
||||
public String refreshToken;
|
||||
public String accountId;
|
||||
public String displayName;
|
||||
public long expiresAt;
|
||||
}
|
||||
|
||||
private EpicAuthClient() {}
|
||||
|
||||
public static TokenResult exchangeCode(String authCode) {
|
||||
return postToken("grant_type=authorization_code&code=" + authCode + "&token_type=eg1");
|
||||
}
|
||||
|
||||
public static TokenResult refreshToken(String refreshToken) {
|
||||
return postToken("grant_type=refresh_token&refresh_token=" + refreshToken + "&token_type=eg1");
|
||||
}
|
||||
|
||||
private static TokenResult postToken(String formBody) {
|
||||
try {
|
||||
String creds64 = Base64.encodeToString((CLIENT_ID + ":" + CLIENT_SECRET).getBytes(StandardCharsets.UTF_8), Base64.NO_WRAP);
|
||||
HttpURLConnection conn = (HttpURLConnection) new URL(TOKEN_URL).openConnection();
|
||||
conn.setRequestMethod("POST");
|
||||
conn.setConnectTimeout(30000);
|
||||
conn.setReadTimeout(30000);
|
||||
conn.setDoOutput(true);
|
||||
conn.setRequestProperty("Authorization", "Basic " + creds64);
|
||||
conn.setRequestProperty("User-Agent", USER_AGENT);
|
||||
conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
|
||||
byte[] bodyBytes = formBody.getBytes(StandardCharsets.UTF_8);
|
||||
conn.setRequestProperty("Content-Length", String.valueOf(bodyBytes.length));
|
||||
try (OutputStream os = conn.getOutputStream()) { os.write(bodyBytes); }
|
||||
int code = conn.getResponseCode();
|
||||
InputStream is = (code < 400) ? conn.getInputStream() : conn.getErrorStream();
|
||||
String resp = readStream(is);
|
||||
conn.disconnect();
|
||||
if (code < 200 || code >= 300) { Log.e(TAG, "token HTTP " + code); return null; }
|
||||
JSONObject json = new JSONObject(resp);
|
||||
TokenResult result = new TokenResult();
|
||||
result.accessToken = json.optString("access_token", null);
|
||||
result.refreshToken = json.optString("refresh_token", null);
|
||||
result.accountId = json.optString("account_id", "");
|
||||
result.displayName = json.optString("displayName", "");
|
||||
long expiresIn = json.optLong("expires_in", 7200L);
|
||||
String expiresAtStr = json.optString("expires_at", null);
|
||||
long expiresAtMs;
|
||||
if (expiresAtStr != null && !expiresAtStr.isEmpty()) {
|
||||
try { expiresAtMs = parseIso8601(expiresAtStr); } catch (Exception e) { expiresAtMs = System.currentTimeMillis() + expiresIn * 1000L; }
|
||||
} else expiresAtMs = System.currentTimeMillis() + expiresIn * 1000L;
|
||||
result.expiresAt = expiresAtMs;
|
||||
return result.accessToken != null ? result : null;
|
||||
} catch (Exception e) {
|
||||
Log.e(TAG, "token request failed: " + e.getClass().getSimpleName());
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/** A short-lived exchange code for a game launch (-AUTH_PASSWORD); null on any failure. */
|
||||
public static String getExchangeCode(String accessToken) {
|
||||
try {
|
||||
String resp = getRequest(EXCHANGE_URL, accessToken);
|
||||
if (resp == null) return null;
|
||||
return new JSONObject(resp).optString("code", null);
|
||||
} catch (Exception e) {
|
||||
Log.e(TAG, "exchange code failed: " + e.getClass().getSimpleName());
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/** Authorized GET; the body or null. */
|
||||
public static String getRequest(String urlStr, String accessToken) {
|
||||
HttpURLConnection conn = null;
|
||||
try {
|
||||
conn = (HttpURLConnection) new URL(urlStr).openConnection();
|
||||
conn.setRequestMethod("GET");
|
||||
conn.setConnectTimeout(30000);
|
||||
conn.setReadTimeout(30000);
|
||||
conn.setRequestProperty("Authorization", "Bearer " + accessToken);
|
||||
conn.setRequestProperty("User-Agent", USER_AGENT);
|
||||
int code = conn.getResponseCode();
|
||||
InputStream is = (code < 400) ? conn.getInputStream() : conn.getErrorStream();
|
||||
String resp = readStream(is);
|
||||
if (code < 200 || code >= 300) { Log.e(TAG, "GET HTTP " + code + " from " + StoreLog.redactUrl(urlStr)); return null; }
|
||||
return resp;
|
||||
} catch (Exception e) {
|
||||
Log.e(TAG, "GET failed: " + StoreLog.redactUrl(urlStr) + " (" + e.getClass().getSimpleName() + ")");
|
||||
return null;
|
||||
} finally {
|
||||
if (conn != null) conn.disconnect();
|
||||
}
|
||||
}
|
||||
|
||||
/** Authorized GET of raw bytes (the manifest binary). */
|
||||
public static byte[] getBytes(String urlStr, String accessToken) {
|
||||
HttpURLConnection conn = null;
|
||||
try {
|
||||
conn = (HttpURLConnection) new URL(urlStr).openConnection();
|
||||
conn.setRequestMethod("GET");
|
||||
conn.setConnectTimeout(30000);
|
||||
conn.setReadTimeout(120000);
|
||||
if (accessToken != null) conn.setRequestProperty("Authorization", "Bearer " + accessToken);
|
||||
conn.setRequestProperty("User-Agent", USER_AGENT);
|
||||
int code = conn.getResponseCode();
|
||||
if (code < 200 || code >= 300) { Log.e(TAG, "bytes HTTP " + code + " from " + StoreLog.redactUrl(urlStr)); return null; }
|
||||
return readAllBytes(conn.getInputStream());
|
||||
} catch (Exception e) {
|
||||
Log.e(TAG, "bytes failed: " + StoreLog.redactUrl(urlStr) + " (" + e.getClass().getSimpleName() + ")");
|
||||
return null;
|
||||
} finally {
|
||||
if (conn != null) conn.disconnect();
|
||||
}
|
||||
}
|
||||
|
||||
static byte[] readAllBytes(InputStream in) throws IOException {
|
||||
java.io.ByteArrayOutputStream out = new java.io.ByteArrayOutputStream();
|
||||
byte[] buf = new byte[131072];
|
||||
int n;
|
||||
while ((n = in.read(buf)) != -1) out.write(buf, 0, n);
|
||||
return out.toByteArray();
|
||||
}
|
||||
|
||||
static String readStream(InputStream is) throws IOException {
|
||||
if (is == null) return "";
|
||||
StringBuilder sb = new StringBuilder();
|
||||
try (BufferedReader br = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8))) {
|
||||
String line;
|
||||
while ((line = br.readLine()) != null) sb.append(line);
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
/** "2026-03-29T12:00:00.000Z" to epoch millis, without java.time. */
|
||||
private static long parseIso8601(String s) {
|
||||
int year = Integer.parseInt(s.substring(0, 4));
|
||||
int month = Integer.parseInt(s.substring(5, 7));
|
||||
int day = Integer.parseInt(s.substring(8, 10));
|
||||
int hour = Integer.parseInt(s.substring(11, 13));
|
||||
int minute = Integer.parseInt(s.substring(14, 16));
|
||||
int second = Integer.parseInt(s.substring(17, 19));
|
||||
long jd = 367L * year - (7 * (year + (month + 9) / 12)) / 4 + (275 * month) / 9 + day + 1721013L;
|
||||
long epochDays = jd - 2440588L;
|
||||
return epochDays * 86400000L + hour * 3600000L + minute * 60000L + second * 1000L;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,169 @@
|
||||
package com.droiddeck.launcher.stores.epic
|
||||
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.util.Log
|
||||
import android.webkit.WebView
|
||||
import com.droiddeck.launcher.stores.CatalogItem
|
||||
import com.droiddeck.launcher.stores.EpicLaunchSupport
|
||||
import com.droiddeck.launcher.stores.InstalledStoreGame
|
||||
import com.droiddeck.launcher.stores.LoginFlows
|
||||
import com.droiddeck.launcher.stores.Store
|
||||
import com.droiddeck.launcher.stores.StoreBackend
|
||||
import com.droiddeck.launcher.stores.StoreExe
|
||||
import com.droiddeck.launcher.stores.StoreGameSidecar
|
||||
import com.droiddeck.launcher.stores.StoreInstallRoot
|
||||
import com.droiddeck.launcher.stores.StoreInstalls
|
||||
import com.droiddeck.launcher.stores.StoreLoginActivity
|
||||
import com.droiddeck.launcher.stores.StoreShelves
|
||||
import com.droiddeck.launcher.stores.StoresState
|
||||
import com.droiddeck.launcher.stores.download.DownloadEntry
|
||||
import com.droiddeck.launcher.stores.download.DownloadQueue
|
||||
import com.droiddeck.launcher.stores.download.DownloadStage
|
||||
import org.json.JSONObject
|
||||
import java.io.File
|
||||
import java.util.concurrent.atomic.AtomicBoolean
|
||||
|
||||
/** Epic Games in the Stores section: sign-in, the library, the public store, installs and the per-launch sign-in code. */
|
||||
object EpicBackend : StoreBackend, EpicLaunchSupport {
|
||||
private const val TAG = "EpicBackend"
|
||||
override val store: Store = Store.EPIC
|
||||
|
||||
init { LoginFlows.epicFlow = { LoginFlow } }
|
||||
|
||||
override fun signIn(context: Context) {
|
||||
context.startActivity(Intent(context, StoreLoginActivity::class.java).putExtra(StoreLoginActivity.EXTRA_STORE, store.id).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK))
|
||||
}
|
||||
|
||||
override fun signOut(context: Context) {
|
||||
EpicPrefs.get(context).edit().remove("library_cache").remove("library_synced_at").apply()
|
||||
}
|
||||
|
||||
override fun syncLibrary(context: Context, force: Boolean) {
|
||||
val app = context.applicationContext
|
||||
val cached = EpicLibrary.cached(app)
|
||||
if (cached.isNotEmpty()) StoresState.post { StoresState.library[store] = cached.map { EpicLibrary.toCatalogItem(app, it) } }
|
||||
StoresState.post { StoresState.status[store] = "Fetching your library…" }
|
||||
Thread({
|
||||
val result = EpicLibrary.sync(app, force) { line -> StoresState.post { StoresState.status[store] = line } }
|
||||
StoresState.post {
|
||||
StoresState.status.remove(store)
|
||||
when (result) {
|
||||
is EpicLibrary.SyncResult.Ok -> { StoresState.library[store] = result.games.map { EpicLibrary.toCatalogItem(app, it) }; StoresState.problems.remove(store) }
|
||||
is EpicLibrary.SyncResult.Failed -> StoresState.problems[store] = result.message
|
||||
EpicLibrary.SyncResult.NotLoggedIn -> StoresState.problems[store] = "Epic session expired: sign in again."
|
||||
EpicLibrary.SyncResult.Throttled -> if (!StoresState.library.containsKey(store)) StoresState.library[store] = cached.map { EpicLibrary.toCatalogItem(app, it) }
|
||||
EpicLibrary.SyncResult.Busy -> {}
|
||||
}
|
||||
}
|
||||
}, "epic-sync").start()
|
||||
}
|
||||
|
||||
override fun loadShelves(context: Context, force: Boolean) {
|
||||
val app = context.applicationContext
|
||||
EpicStoreCatalog.cachedFeatured(app)?.let { StoresState.post { StoresState.shelves[store] = markOwned(it) } }
|
||||
Thread({
|
||||
val shelves = EpicStoreCatalog.featured(app, force)
|
||||
StoresState.post { if (shelves != null) StoresState.shelves[store] = markOwned(shelves) }
|
||||
}, "epic-shelves").start()
|
||||
}
|
||||
|
||||
/** Store offers whose catalog item is in the library are owned: their cards offer Install under the library's id. */
|
||||
private fun markOwned(s: StoreShelves): StoreShelves {
|
||||
val owned = StoresState.library[store] ?: return s
|
||||
val byCatalogItem = owned.associateBy { it.extra["catalogItemId"] ?: "" }
|
||||
fun mark(l: List<CatalogItem>) = l.map { i ->
|
||||
val match = i.extra["items"]?.split(',')?.firstNotNullOfOrNull { byCatalogItem[it] }
|
||||
if (match != null) match.copy(imageUrl = i.imageUrl ?: match.imageUrl, tallImageUrl = i.tallImageUrl ?: match.tallImageUrl) else i
|
||||
}
|
||||
return StoreShelves(mark(s.whatsNew), mark(s.deals), mark(s.free), mark(s.trending))
|
||||
}
|
||||
|
||||
override fun install(context: Context, item: CatalogItem) {
|
||||
val app = context.applicationContext
|
||||
val namespace = item.extra["namespace"] ?: ""
|
||||
val catalogItemId = item.extra["catalogItemId"] ?: ""
|
||||
if (namespace.isEmpty() || catalogItemId.isEmpty()) { StoresState.logLine("Epic: \"${item.title}\" is not in your library"); return }
|
||||
val entry = DownloadEntry(store, item.id, item.title, cover = item.imageUrl, bytesTotal = item.sizeBytes)
|
||||
DownloadQueue.enqueue(app, entry) { InstallJob(app, item, namespace, catalogItemId) }
|
||||
}
|
||||
|
||||
override fun uninstall(context: Context, game: InstalledStoreGame) {}
|
||||
|
||||
/** A fresh exchange code for the signed-in account; null when signed out or offline. Blocking. */
|
||||
override fun exchangeCode(context: Context): String? {
|
||||
val token = EpicCredentialStore.getValidAccessToken(context) ?: return null
|
||||
return EpicAuthClient.getExchangeCode(token)
|
||||
}
|
||||
|
||||
private class InstallJob(val app: Context, val item: CatalogItem, val namespace: String, val catalogItemId: String) : DownloadQueue.DownloadJob {
|
||||
private val cancelled = AtomicBoolean(false)
|
||||
private val folder: File = StoreInstallRoot.folderFor(app, Store.EPIC, item.id, item.title)
|
||||
|
||||
override fun run(handle: DownloadQueue.JobHandle): String? {
|
||||
handle.stage(DownloadStage.MANIFEST, "Checking sign-in…")
|
||||
val token = EpicCredentialStore.getValidAccessToken(app) ?: throw EpicDownloadManager.InstallException("Not signed in to Epic Games")
|
||||
val manifestJson = EpicApiClient.getManifestApiJson(token, namespace, catalogItemId, item.id)
|
||||
?: throw EpicDownloadManager.InstallException("The manifest could not be fetched")
|
||||
val tags = EpicInstallTags.tagsForDevice()
|
||||
var downloading = false
|
||||
val result = EpicDownloadManager.install(app, manifestJson, folder.path, tags, cancelled, object : EpicDownloadManager.Callback {
|
||||
override fun onProgress(message: String, pct: Int) {
|
||||
when {
|
||||
message.startsWith("Writing") || message.startsWith("Complete") -> handle.stage(DownloadStage.INSTALL, message)
|
||||
message.startsWith("Downloading chunks") -> { if (!downloading) { downloading = true; handle.stage(DownloadStage.DOWNLOAD, message) } else handle.progress(-1, -1, message) }
|
||||
message.startsWith("Verifying") -> handle.stage(DownloadStage.VERIFY, message)
|
||||
else -> handle.stage(DownloadStage.MANIFEST, message)
|
||||
}
|
||||
}
|
||||
override fun onBytes(done: Long, total: Long, speedBps: Long) { handle.progress(done, total, null, speedBps) }
|
||||
override fun onLog(line: String) { handle.log(line) }
|
||||
}) ?: return null
|
||||
if (cancelled.get()) return null
|
||||
handle.stage(DownloadStage.INSTALL, "Registering with Steam…")
|
||||
EpicLibrary.rememberSize(app, item.id, result.bytes)
|
||||
val deploymentId = runCatching { JSONObject(manifestJson).optString("deploymentId", "") }.getOrDefault("")
|
||||
val exe = StoreExe.pick(folder, result.launchExe, item.title)
|
||||
if (exe.isEmpty()) handle.log("epic: no exe found in ${folder.name}; pick one in Steam settings › Added games")
|
||||
val args = EpicLaunchData.arguments(app, token, item.id, namespace, catalogItemId, deploymentId)
|
||||
val sidecar = StoreGameSidecar(
|
||||
Store.EPIC, item.id, item.title, exe = exe.ifEmpty { "game.exe" }, args = args,
|
||||
installVersion = result.buildVersion, installedAt = System.currentTimeMillis(),
|
||||
cover = item.tallImageUrl ?: item.imageUrl, hero = item.imageUrl,
|
||||
extra = EpicLaunchData.extras(item.id, namespace, catalogItemId, deploymentId),
|
||||
)
|
||||
StoreInstalls.complete(app, folder, sidecar)
|
||||
return folder.path
|
||||
}
|
||||
|
||||
override fun cancel(deleteFiles: Boolean) {
|
||||
cancelled.set(true)
|
||||
if (deleteFiles) Thread({ StoreInstalls.deleteTree(folder) }, "epic-cancel-clean").start()
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Epic's web sign-in: the login page redirects to a JSON page carrying an authorization code,
|
||||
* read out of the document and exchanged for tokens.
|
||||
*/
|
||||
private object LoginFlow : StoreLoginActivity.Flow {
|
||||
private const val REDIRECT = "https://www.epicgames.com/id/api/redirect"
|
||||
override val startUrl: String = "https://www.epicgames.com/id/login?redirectUrl=https%3A%2F%2Fwww.epicgames.com%2Fid%2Fapi%2Fredirect%3FclientId%3D${EpicAuthClient.CLIENT_ID}%26responseType%3Dcode"
|
||||
override val userAgent: String get() = EpicAuthClient.USER_AGENT
|
||||
override val readsPage: Boolean get() = true
|
||||
override fun isRedirect(url: String): Boolean = url.startsWith(REDIRECT)
|
||||
|
||||
override fun finish(activity: StoreLoginActivity, view: WebView, url: String): String? {
|
||||
// The document's text comes JSON-quoted from evaluateJavascript.
|
||||
var text = url
|
||||
if (text.startsWith("\"")) text = text.substring(1, text.length - 1)
|
||||
text = text.replace("\\n", "").replace("\\r", "").replace("\\\"", "\"")
|
||||
val code = Regex("\"authorizationCode\":\"([^\"]+)\"").find(text)?.groupValues?.get(1)
|
||||
if (code.isNullOrEmpty()) { Log.w(TAG, "login: no authorization code on the redirect page"); return activity.getString(com.droiddeck.launcher.R.string.stores_login_error_verification) }
|
||||
val result = EpicAuthClient.exchangeCode(code) ?: return activity.getString(com.droiddeck.launcher.R.string.stores_login_error_generic)
|
||||
EpicCredentialStore.save(activity, result)
|
||||
Log.i(TAG, "signed in")
|
||||
return null
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
package com.droiddeck.launcher.stores.epic
|
||||
|
||||
import android.content.Context
|
||||
import android.util.Log
|
||||
import com.droiddeck.launcher.stores.Store
|
||||
import com.droiddeck.launcher.stores.StoreAccounts
|
||||
import org.json.JSONObject
|
||||
|
||||
/**
|
||||
* The Epic sign-in in StoreAccounts' private file: access and refresh tokens, the account id and
|
||||
* display name (the launch arguments carry both), the expiry. Refreshed when within five minutes
|
||||
* of expiring.
|
||||
*/
|
||||
object EpicCredentialStore {
|
||||
private const val TAG = "EpicAuth"
|
||||
|
||||
class Credentials(val accessToken: String, val refreshToken: String?, val accountId: String, val displayName: String, val expiresAt: Long)
|
||||
|
||||
@JvmStatic
|
||||
fun save(context: Context, result: EpicAuthClient.TokenResult) {
|
||||
val json = JSONObject().put("access_token", result.accessToken).put("account_id", result.accountId ?: "")
|
||||
.put("display_name", result.displayName ?: "").put("expires_at", result.expiresAt)
|
||||
if (!result.refreshToken.isNullOrEmpty()) json.put("refresh_token", result.refreshToken)
|
||||
StoreAccounts.write(context, Store.EPIC, json)
|
||||
}
|
||||
|
||||
@JvmStatic
|
||||
fun load(context: Context): Credentials? {
|
||||
val json = StoreAccounts.read(context, Store.EPIC) ?: return null
|
||||
val token = json.optString("access_token", "").ifEmpty { return null }
|
||||
return Credentials(token, json.optString("refresh_token", "").ifEmpty { null }, json.optString("account_id", ""), json.optString("display_name", ""), json.optLong("expires_at", 0L))
|
||||
}
|
||||
|
||||
@JvmStatic
|
||||
fun isLoggedIn(context: Context): Boolean = load(context) != null
|
||||
|
||||
/** A valid access token, refreshed when within five minutes of expiry; null when signed out or the refresh failed. */
|
||||
@JvmStatic
|
||||
fun getValidAccessToken(context: Context): String? {
|
||||
val creds = load(context) ?: return null
|
||||
if (creds.expiresAt - System.currentTimeMillis() < 5L * 60L * 1000L && creds.refreshToken != null) {
|
||||
val result = EpicAuthClient.refreshToken(creds.refreshToken)
|
||||
if (result != null) {
|
||||
if (result.refreshToken.isNullOrEmpty()) result.refreshToken = creds.refreshToken
|
||||
if (result.accountId.isNullOrEmpty()) result.accountId = creds.accountId
|
||||
if (result.displayName.isNullOrEmpty()) result.displayName = creds.displayName
|
||||
save(context, result)
|
||||
Log.i(TAG, "token refreshed")
|
||||
return result.accessToken
|
||||
}
|
||||
Log.w(TAG, "token refresh failed; using the stored token")
|
||||
}
|
||||
return creds.accessToken
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,731 @@
|
||||
package com.droiddeck.launcher.stores.epic;
|
||||
|
||||
import android.content.Context;
|
||||
import android.util.Log;
|
||||
|
||||
import com.droiddeck.launcher.stores.StoreLog;
|
||||
import com.droiddeck.launcher.stores.download.StoreDownloadTier;
|
||||
|
||||
import org.json.JSONArray;
|
||||
import org.json.JSONObject;
|
||||
|
||||
import java.io.BufferedOutputStream;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.File;
|
||||
import java.io.FileInputStream;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.net.HttpURLConnection;
|
||||
import java.net.URL;
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.ByteOrder;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.security.MessageDigest;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Iterator;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.LinkedHashSet;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.Executors;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.concurrent.atomic.AtomicBoolean;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
import java.util.concurrent.atomic.AtomicLong;
|
||||
import java.util.zip.Inflater;
|
||||
|
||||
/**
|
||||
* The Epic install pipeline, ported from Bannerlator's EpicDownloadManager: the manifest API's CDN
|
||||
* list, the manifest binary (ChunksV4, or the older JSON form), the files narrowed to the base
|
||||
* set plus the device's language, a delta pass that skips files already on disk with the right
|
||||
* size and SHA-1, the chunk fetch into `.chunks/<GUID>` (the native engine when it is there, the
|
||||
* Java pool otherwise), and the assembly of files from those chunks.
|
||||
*
|
||||
* Chunk URLs carry no auth tokens; the subfolder is the decimal group number; the Cloudflare
|
||||
* mirror is skipped (it refuses chunks). Blocking; the download queue runs it on its own thread.
|
||||
*/
|
||||
public final class EpicDownloadManager {
|
||||
|
||||
private static final String TAG = "EpicDownload";
|
||||
private static final String UA = EpicAuthClient.USER_AGENT;
|
||||
|
||||
public interface Callback {
|
||||
void onProgress(String message, int pct);
|
||||
default void onBytes(long done, long total, long speedBps) {}
|
||||
default void onLog(String line) {}
|
||||
}
|
||||
|
||||
private EpicDownloadManager() {}
|
||||
|
||||
public static final class CdnUrl {
|
||||
public final String baseUrl, cloudDir, authParams;
|
||||
CdnUrl(String baseUrl, String cloudDir, String authParams) { this.baseUrl = baseUrl; this.cloudDir = cloudDir; this.authParams = authParams; }
|
||||
}
|
||||
|
||||
public static final class ChunkInfo {
|
||||
public int[] guid = new int[4];
|
||||
public long hash;
|
||||
public byte[] sha1;
|
||||
public int groupNum;
|
||||
public int windowSize;
|
||||
public long fileSize;
|
||||
public String guidStr() { return String.format("%08X%08X%08X%08X", guid[0], guid[1], guid[2], guid[3]); }
|
||||
public String getPath(String chunkDir) { return chunkDir + "/" + String.format("%02d", groupNum) + "/" + String.format("%016X", hash) + "_" + guidStr() + ".chunk"; }
|
||||
}
|
||||
|
||||
public static final class ChunkPart {
|
||||
public int[] guid = new int[4];
|
||||
public int offset, size;
|
||||
public String guidStr() { return String.format("%08X%08X%08X%08X", guid[0], guid[1], guid[2], guid[3]); }
|
||||
}
|
||||
|
||||
public static final class FileInfo {
|
||||
public String filename = "";
|
||||
public List<ChunkPart> parts = new ArrayList<>();
|
||||
public List<String> installTags = new ArrayList<>();
|
||||
public byte[] sha1 = null;
|
||||
public long fileSize() { long t = 0; for (ChunkPart p : parts) t += (p.size & 0xFFFFFFFFL); return t; }
|
||||
}
|
||||
|
||||
/** The parsed manifest: its chunks, files, and from the meta block the exe the launcher starts. */
|
||||
public static final class Manifest {
|
||||
public String chunkDir = "ChunksV4";
|
||||
public List<ChunkInfo> uniqueChunks = new ArrayList<>();
|
||||
public List<FileInfo> files = new ArrayList<>();
|
||||
public String launchExe = "";
|
||||
public String launchCommand = "";
|
||||
public String buildVersion = "";
|
||||
public List<CdnUrl> cdnUrls = new ArrayList<>();
|
||||
}
|
||||
|
||||
/** What an install leaves for the sidecar. */
|
||||
public static final class Result {
|
||||
public final String launchExe;
|
||||
public final String buildVersion;
|
||||
public final long bytes;
|
||||
Result(String launchExe, String buildVersion, long bytes) { this.launchExe = launchExe; this.buildVersion = buildVersion; this.bytes = bytes; }
|
||||
}
|
||||
|
||||
public static final class InstallException extends Exception {
|
||||
InstallException(String message) { super(message); }
|
||||
}
|
||||
|
||||
/**
|
||||
* Installs the app the manifest API JSON describes into {@code installDir}. {@code installTags}
|
||||
* null = every file. Returns null when cancelled; throws when it fails.
|
||||
*/
|
||||
public static Result install(Context ctx, String manifestApiJson, String installDirPath, List<String> installTags, AtomicBoolean cancel, Callback cb) throws InstallException {
|
||||
try {
|
||||
if (cancel.get()) return null;
|
||||
cb.onProgress("Reading CDN list…", 0);
|
||||
List<CdnUrl> cdnUrls = parseCdnUrls(manifestApiJson);
|
||||
if (cdnUrls.isEmpty()) throw new InstallException("No CDN in the manifest answer");
|
||||
for (CdnUrl c : cdnUrls) cb.onLog("epic: CDN " + c.baseUrl + " auth=" + (c.authParams.isEmpty() ? "no" : "yes"));
|
||||
cb.onProgress("Downloading manifest…", 0);
|
||||
byte[] manifestBytes = downloadManifest(manifestApiJson, cdnUrls);
|
||||
if (manifestBytes == null) throw new InstallException("The manifest could not be downloaded");
|
||||
if (cancel.get()) return null;
|
||||
cb.onProgress("Parsing manifest…", 0);
|
||||
Manifest manifest = parseManifest(manifestBytes);
|
||||
if (manifest == null) throw new InstallException("The manifest could not be parsed");
|
||||
manifest.cdnUrls = cdnUrls;
|
||||
cb.onLog("epic: chunkDir=" + manifest.chunkDir + " chunks=" + manifest.uniqueChunks.size() + " files=" + manifest.files.size() + " exe=" + manifest.launchExe);
|
||||
|
||||
File installDir = new File(installDirPath);
|
||||
installDir.mkdirs();
|
||||
File chunkCacheDir = new File(installDir, ".chunks");
|
||||
chunkCacheDir.mkdirs();
|
||||
|
||||
List<FileInfo> selected = resolveInstallFiles(manifest, installTags);
|
||||
cb.onLog("epic: " + selected.size() + "/" + manifest.files.size() + " files for tags " + (installTags == null ? "(all)" : installTags.toString()));
|
||||
long installBytes = 0;
|
||||
for (FileInfo f : selected) installBytes += f.fileSize();
|
||||
final long planned = installBytes;
|
||||
long usable = installDir.getUsableSpace();
|
||||
if (planned > 0 && usable > 0 && planned > usable) throw new InstallException("Not enough free space: need " + fmt(planned) + ", only " + fmt(usable) + " free");
|
||||
|
||||
cb.onProgress("Verifying existing files…", 0);
|
||||
List<FileInfo> pending = new ArrayList<>(selected.size());
|
||||
int checked = 0, good = 0;
|
||||
for (FileInfo f : selected) {
|
||||
if (cancel.get()) return null;
|
||||
File out = new File(installDir, f.filename.replace("\\", "/"));
|
||||
if (fileExistsWithCorrectHash(out, f.fileSize(), f.sha1)) good++; else pending.add(f);
|
||||
checked++;
|
||||
if ((checked & 63) == 0) cb.onProgress("Verifying existing files… (" + checked + "/" + selected.size() + ")", 0);
|
||||
}
|
||||
cb.onLog("epic: delta " + good + " up to date, " + pending.size() + " to download");
|
||||
if (pending.isEmpty()) {
|
||||
deleteDir(chunkCacheDir);
|
||||
cb.onProgress("Complete", 100);
|
||||
return new Result(manifest.launchExe, manifest.buildVersion, planned);
|
||||
}
|
||||
List<ChunkInfo> needed = uniqueChunksForFiles(manifest, pending);
|
||||
long totalBytes = 0;
|
||||
for (ChunkInfo c : needed) totalBytes += Math.max(c.fileSize, 1);
|
||||
final long fTotalBytes = totalBytes;
|
||||
final int totalChunks = needed.size();
|
||||
final AtomicLong completedBytes = new AtomicLong(0);
|
||||
final AtomicInteger completedCount = new AtomicInteger(0);
|
||||
final AtomicInteger failCount = new AtomicInteger(0);
|
||||
final AtomicLong lastSpeedMs = new AtomicLong(System.currentTimeMillis());
|
||||
final AtomicLong lastSpeedBytes = new AtomicLong(0);
|
||||
final AtomicLong speedBps = new AtomicLong(0);
|
||||
cb.onBytes(0, fTotalBytes, 0);
|
||||
cb.onLog("epic: " + fmt(fTotalBytes) + " in " + totalChunks + " chunks");
|
||||
|
||||
boolean javaPool = true;
|
||||
if (com.droiddeck.launcher.stores.StoresNative.INSTANCE.getAvailable()) {
|
||||
NativeOutcome r = runNativePool(ctx, manifestBytes, manifest, pending, needed, fTotalBytes, installDirPath, cdnUrls, cancel, cb,
|
||||
completedBytes, completedCount, lastSpeedMs, lastSpeedBytes, speedBps);
|
||||
if (r.started) {
|
||||
javaPool = false;
|
||||
if (r.cancelled) return null;
|
||||
if (!r.success) { cb.onLog("epic: engine failed: " + r.error); failCount.incrementAndGet(); }
|
||||
} else cb.onLog("epic: engine not started (" + r.error + "); using the built-in pool");
|
||||
}
|
||||
if (javaPool) {
|
||||
cb.onLog("epic: engine=built-in (8 threads)");
|
||||
ExecutorService pool = Executors.newFixedThreadPool(8);
|
||||
for (ChunkInfo chunk : needed) {
|
||||
final ChunkInfo fc = chunk;
|
||||
pool.submit(() -> {
|
||||
if (cancel.get()) return;
|
||||
File cached = new File(chunkCacheDir, fc.guidStr());
|
||||
if (!cached.exists() && !downloadChunkStreaming(fc, manifest.chunkDir, cdnUrls, cached)) {
|
||||
cb.onLog("FAIL chunk=" + fc.guidStr());
|
||||
failCount.incrementAndGet();
|
||||
return;
|
||||
}
|
||||
long done = completedBytes.addAndGet(Math.max(fc.fileSize, 1));
|
||||
int cnt = completedCount.incrementAndGet();
|
||||
sampleSpeed(done, lastSpeedMs, lastSpeedBytes, speedBps);
|
||||
cb.onProgress("Downloading chunks (" + cnt + "/" + totalChunks + ")" + speedSuffix(speedBps.get()), (int) (done * 80L / Math.max(1, fTotalBytes)));
|
||||
cb.onBytes(done, fTotalBytes, speedBps.get());
|
||||
});
|
||||
}
|
||||
pool.shutdown();
|
||||
try {
|
||||
while (!pool.awaitTermination(250, TimeUnit.MILLISECONDS)) {
|
||||
if (cancel.get()) { pool.shutdownNow(); pool.awaitTermination(5, TimeUnit.SECONDS); return null; }
|
||||
}
|
||||
} catch (InterruptedException e) {
|
||||
Thread.currentThread().interrupt();
|
||||
pool.shutdownNow();
|
||||
throw new InstallException("interrupted");
|
||||
}
|
||||
}
|
||||
if (cancel.get()) return null;
|
||||
if (failCount.get() > 0) throw new InstallException(failCount.get() + " chunk(s) failed to download");
|
||||
|
||||
int totalFiles = pending.size(), doneFiles = 0;
|
||||
for (FileInfo file : pending) {
|
||||
if (cancel.get()) return null;
|
||||
String relPath = file.filename.replace("\\", "/");
|
||||
File outFile = new File(installDir, relPath);
|
||||
File parent = outFile.getParentFile();
|
||||
if (parent != null) parent.mkdirs();
|
||||
cb.onProgress("Writing: " + (relPath.contains("/") ? relPath.substring(relPath.lastIndexOf('/') + 1) : relPath), 80 + (int) (doneFiles * 20L / totalFiles));
|
||||
try (FileOutputStream fos = new FileOutputStream(outFile); BufferedOutputStream bos = new BufferedOutputStream(fos, 65536)) {
|
||||
for (ChunkPart part : file.parts) {
|
||||
File cachedChunk = new File(chunkCacheDir, part.guidStr());
|
||||
if (!cachedChunk.exists()) throw new InstallException("Missing chunk " + part.guidStr() + " for " + relPath);
|
||||
byte[] data = readFile(cachedChunk);
|
||||
bos.write(data, part.offset, part.size);
|
||||
}
|
||||
}
|
||||
doneFiles++;
|
||||
}
|
||||
deleteDir(chunkCacheDir);
|
||||
cb.onProgress("Complete", 100);
|
||||
return new Result(manifest.launchExe, manifest.buildVersion, planned);
|
||||
} catch (InstallException e) {
|
||||
throw e;
|
||||
} catch (Exception e) {
|
||||
Log.w(TAG, "install failed", e);
|
||||
throw new InstallException(e.getClass().getSimpleName() + (e.getMessage() != null ? ": " + e.getMessage() : ""));
|
||||
}
|
||||
}
|
||||
|
||||
private static final class NativeOutcome { boolean started, success, cancelled; String error = ""; }
|
||||
|
||||
/** The native chunk pool on the same counters; never throws. */
|
||||
private static NativeOutcome runNativePool(Context ctx, byte[] manifestBytes, Manifest manifest, List<FileInfo> pending, List<ChunkInfo> needed, long totalBytes,
|
||||
String installDirPath, List<CdnUrl> cdnUrls, AtomicBoolean cancel, Callback cb,
|
||||
AtomicLong completedBytes, AtomicInteger completedCount, AtomicLong lastSpeedMs, AtomicLong lastSpeedBytes, AtomicLong speedBps) {
|
||||
NativeOutcome r = new NativeOutcome();
|
||||
try {
|
||||
java.util.IdentityHashMap<FileInfo, Integer> index = new java.util.IdentityHashMap<>();
|
||||
for (int i = 0; i < manifest.files.size(); i++) index.put(manifest.files.get(i), i);
|
||||
int[] pendingIdx = new int[pending.size()];
|
||||
for (int i = 0; i < pending.size(); i++) {
|
||||
Integer k = index.get(pending.get(i));
|
||||
if (k == null) { r.error = "pending file not in manifest"; return r; }
|
||||
pendingIdx[i] = k;
|
||||
}
|
||||
String[] prefixes = new String[cdnUrls.size()];
|
||||
for (int i = 0; i < cdnUrls.size(); i++) prefixes[i] = cdnUrls.get(i).baseUrl + cdnUrls.get(i).cloudDir;
|
||||
final int totalChunks = needed.size();
|
||||
StoreDownloadTier tier = StoreDownloadTier.Companion.current(ctx);
|
||||
int workers = Math.max(1, Math.min(128, tier.getNetworkWindow()));
|
||||
int process = Math.max(2, tier.getProcessWorkers());
|
||||
cb.onLog("epic: engine=native workers=" + workers + " process_workers=" + process + " tier=" + tier.getId());
|
||||
EpicNative.Result res = EpicNative.run(manifestBytes, installDirPath, prefixes, pendingIdx, totalChunks, totalBytes, "", workers, process, cancel,
|
||||
new EpicNative.Listener() {
|
||||
@Override public void onPlan(int chunksTotal, long bytesTotal, String chunkDir) { cb.onLog("epic: plan chunks=" + chunksTotal + " bytes=" + bytesTotal + " dir=" + chunkDir); }
|
||||
@Override public void onProgress(long bytesDone, long bytesTotal, int chunksDone, int chunksTotal) {
|
||||
completedBytes.set(bytesDone);
|
||||
completedCount.set(chunksDone);
|
||||
sampleSpeed(bytesDone, lastSpeedMs, lastSpeedBytes, speedBps);
|
||||
cb.onProgress("Downloading chunks (" + chunksDone + "/" + totalChunks + ")" + speedSuffix(speedBps.get()), (int) (bytesDone * 80L / Math.max(1, totalBytes)));
|
||||
cb.onBytes(bytesDone, totalBytes, speedBps.get());
|
||||
}
|
||||
@Override public void onLog(String line) { cb.onLog(line); }
|
||||
@Override public void onComplete(boolean success, String error, long bytesCredited) {}
|
||||
});
|
||||
r.started = res.started; r.success = res.success; r.cancelled = res.cancelled; r.error = res.error == null ? "" : res.error;
|
||||
} catch (Throwable t) {
|
||||
r.started = false;
|
||||
r.error = t.getClass().getSimpleName() + ": " + t.getMessage();
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
// ---- CDN list and manifest download ---------------------------------------------------------
|
||||
|
||||
public static List<CdnUrl> parseCdnUrls(String json) {
|
||||
List<CdnUrl> result = new ArrayList<>();
|
||||
try {
|
||||
JSONArray manifests = new JSONObject(json).optJSONArray("manifests");
|
||||
if (manifests == null) return result;
|
||||
for (int i = 0; i < manifests.length(); i++) {
|
||||
JSONObject m = manifests.optJSONObject(i);
|
||||
if (m == null) continue;
|
||||
String uri = m.optString("uri", "");
|
||||
int buildsIdx = uri.indexOf("/Builds");
|
||||
if (buildsIdx < 0) continue;
|
||||
String baseUrl = uri.substring(0, buildsIdx);
|
||||
if (!baseUrl.startsWith("http") || baseUrl.contains("cloudflare.epicgamescdn.com")) continue;
|
||||
String afterBase = uri.substring(buildsIdx);
|
||||
int q = afterBase.indexOf('?');
|
||||
if (q >= 0) afterBase = afterBase.substring(0, q);
|
||||
int lastSlash = afterBase.lastIndexOf('/');
|
||||
if (lastSlash < 0) continue;
|
||||
String cloudDir = afterBase.substring(0, lastSlash);
|
||||
StringBuilder auth = new StringBuilder();
|
||||
JSONArray params = m.optJSONArray("queryParams");
|
||||
if (params != null) for (int j = 0; j < params.length(); j++) {
|
||||
JSONObject p = params.optJSONObject(j);
|
||||
if (p == null) continue;
|
||||
auth.append(auth.length() == 0 ? "?" : "&").append(p.optString("name")).append('=').append(p.optString("value"));
|
||||
}
|
||||
result.add(new CdnUrl(baseUrl, cloudDir, auth.toString()));
|
||||
}
|
||||
} catch (Exception e) {
|
||||
Log.e(TAG, "CDN parse: " + e.getClass().getSimpleName());
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/** The manifest binary from the first CDN that serves it; the auth query goes on this URL only. */
|
||||
public static byte[] downloadManifest(String json, List<CdnUrl> cdnUrls) {
|
||||
try {
|
||||
JSONArray manifests = new JSONObject(json).optJSONArray("manifests");
|
||||
if (manifests == null || manifests.length() == 0) return null;
|
||||
String firstUri = manifests.getJSONObject(0).optString("uri", "");
|
||||
String uriPath = firstUri.contains("?") ? firstUri.substring(0, firstUri.indexOf('?')) : firstUri;
|
||||
int lastSlash = uriPath.lastIndexOf('/');
|
||||
if (lastSlash < 0) return null;
|
||||
String manifestFilename = uriPath.substring(lastSlash + 1);
|
||||
for (CdnUrl cdn : cdnUrls) {
|
||||
byte[] bytes = downloadBytes(cdn.baseUrl + cdn.cloudDir + "/" + manifestFilename + cdn.authParams);
|
||||
if (bytes != null && bytes.length > 4) return bytes;
|
||||
}
|
||||
} catch (Exception e) {
|
||||
Log.e(TAG, "manifest download: " + e.getClass().getSimpleName());
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
// ---- manifest parsing -----------------------------------------------------------------------
|
||||
|
||||
public static Manifest parseManifest(byte[] bytes) {
|
||||
try {
|
||||
ByteBuffer buf = ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN);
|
||||
int magic = buf.getInt();
|
||||
if (magic != 0x44BEC00C) return parseJsonManifest(bytes);
|
||||
int headerSize = buf.getInt();
|
||||
int sizeUncompressed = buf.getInt();
|
||||
buf.getInt();
|
||||
buf.position(buf.position() + 20);
|
||||
int storedAs = buf.get() & 0xFF;
|
||||
int version = buf.getInt();
|
||||
String chunkDir = version >= 15 ? "ChunksV4" : version >= 6 ? "ChunksV3" : version >= 3 ? "ChunksV2" : "Chunks";
|
||||
buf.position(headerSize);
|
||||
byte[] body = new byte[buf.remaining()];
|
||||
buf.get(body);
|
||||
if ((storedAs & 1) != 0) {
|
||||
Inflater inflater = new Inflater();
|
||||
inflater.setInput(body);
|
||||
byte[] decomp = new byte[sizeUncompressed];
|
||||
int got = inflater.inflate(decomp);
|
||||
inflater.end();
|
||||
if (got != sizeUncompressed) { Log.e(TAG, "manifest inflate size mismatch"); return null; }
|
||||
body = decomp;
|
||||
}
|
||||
ByteBuffer b = ByteBuffer.wrap(body).order(ByteOrder.LITTLE_ENDIAN);
|
||||
Manifest m = new Manifest();
|
||||
m.chunkDir = chunkDir;
|
||||
// ManifestMeta: the launch exe and build version live here; the rest is skipped by size.
|
||||
int metaStart = b.position();
|
||||
int metaSize = b.getInt();
|
||||
try {
|
||||
b.get(); // data version
|
||||
b.getInt(); // feature level
|
||||
b.get(); // isFileData
|
||||
b.getInt(); // app id
|
||||
readFString(b); // app name
|
||||
m.buildVersion = readFString(b);
|
||||
m.launchExe = readFString(b).replace('\\', '/');
|
||||
m.launchCommand = readFString(b);
|
||||
} catch (Exception e) {
|
||||
Log.w(TAG, "manifest meta: " + e.getClass().getSimpleName());
|
||||
}
|
||||
b.position(metaStart + metaSize);
|
||||
|
||||
int cdlStart = b.position();
|
||||
int cdlSize = b.getInt();
|
||||
b.get();
|
||||
int chunkCount = b.getInt();
|
||||
List<ChunkInfo> chunks = new ArrayList<>(chunkCount);
|
||||
for (int i = 0; i < chunkCount; i++) chunks.add(new ChunkInfo());
|
||||
for (ChunkInfo c : chunks) { c.guid[0] = b.getInt(); c.guid[1] = b.getInt(); c.guid[2] = b.getInt(); c.guid[3] = b.getInt(); }
|
||||
for (ChunkInfo c : chunks) c.hash = b.getLong();
|
||||
for (ChunkInfo c : chunks) { c.sha1 = new byte[20]; b.get(c.sha1); }
|
||||
for (ChunkInfo c : chunks) c.groupNum = b.get() & 0xFF;
|
||||
for (ChunkInfo c : chunks) c.windowSize = b.getInt();
|
||||
for (ChunkInfo c : chunks) c.fileSize = b.getLong();
|
||||
b.position(cdlStart + cdlSize);
|
||||
|
||||
int fmlStart = b.position();
|
||||
int fmlSize = b.getInt();
|
||||
b.get();
|
||||
int fileCount = b.getInt();
|
||||
List<FileInfo> files = new ArrayList<>(fileCount);
|
||||
for (int i = 0; i < fileCount; i++) files.add(new FileInfo());
|
||||
for (FileInfo f : files) f.filename = readFString(b);
|
||||
for (int i = 0; i < fileCount; i++) readFString(b);
|
||||
for (FileInfo f : files) { f.sha1 = new byte[20]; b.get(f.sha1); }
|
||||
b.position(b.position() + fileCount);
|
||||
for (int i = 0; i < fileCount; i++) {
|
||||
int tagCount = b.getInt();
|
||||
for (int j = 0; j < tagCount; j++) { String tag = readFString(b); if (tag != null && !tag.isEmpty()) files.get(i).installTags.add(tag); }
|
||||
}
|
||||
for (FileInfo f : files) {
|
||||
int partCount = b.getInt();
|
||||
for (int j = 0; j < partCount; j++) {
|
||||
int partStart = b.position();
|
||||
int partStructSize = b.getInt();
|
||||
ChunkPart part = new ChunkPart();
|
||||
part.guid[0] = b.getInt(); part.guid[1] = b.getInt(); part.guid[2] = b.getInt(); part.guid[3] = b.getInt();
|
||||
part.offset = b.getInt(); part.size = b.getInt();
|
||||
f.parts.add(part);
|
||||
b.position(partStart + partStructSize);
|
||||
}
|
||||
}
|
||||
b.position(fmlStart + fmlSize);
|
||||
Map<String, ChunkInfo> seen = new LinkedHashMap<>(chunkCount * 2);
|
||||
for (ChunkInfo c : chunks) seen.put(c.guidStr(), c);
|
||||
m.uniqueChunks = new ArrayList<>(seen.values());
|
||||
m.files = files;
|
||||
return m;
|
||||
} catch (Exception e) {
|
||||
Log.e(TAG, "manifest parse: " + e.getClass().getSimpleName());
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
private static Manifest parseJsonManifest(byte[] bytes) {
|
||||
try {
|
||||
JSONObject root = new JSONObject(new String(bytes, StandardCharsets.UTF_8));
|
||||
int manifestVersion = 0;
|
||||
try { manifestVersion = Integer.parseInt(root.optString("ManifestFileVersion", "0")); } catch (NumberFormatException ignored) {}
|
||||
Manifest m = new Manifest();
|
||||
m.chunkDir = manifestVersion >= 15 ? "ChunksV4" : manifestVersion >= 6 ? "ChunksV3" : manifestVersion >= 3 ? "ChunksV2" : "ChunksV4";
|
||||
m.launchExe = root.optString("LaunchExe", "").replace('\\', '/');
|
||||
m.launchCommand = root.optString("LaunchCommand", "");
|
||||
m.buildVersion = root.optString("BuildVersionString", "");
|
||||
JSONObject chunkHashList = root.optJSONObject("ChunkHashList");
|
||||
JSONObject dataGroupList = root.optJSONObject("DataGroupList");
|
||||
JSONObject chunkFilesizeList = root.optJSONObject("ChunkFilesizeList");
|
||||
if (chunkHashList == null) return null;
|
||||
Map<String, ChunkInfo> chunkMap = new LinkedHashMap<>();
|
||||
Iterator<String> keys = chunkHashList.keys();
|
||||
while (keys.hasNext()) {
|
||||
String guidHex = keys.next();
|
||||
if (guidHex.length() < 32) continue;
|
||||
ChunkInfo c = new ChunkInfo();
|
||||
for (int k = 0; k < 4; k++) c.guid[k] = (int) Long.parseLong(guidHex.substring(k * 8, k * 8 + 8), 16);
|
||||
String hashHex = chunkHashList.getString(guidHex);
|
||||
if (hashHex != null && hashHex.length() >= 16) { try { c.hash = Long.parseUnsignedLong(hashHex.substring(0, 16), 16); } catch (Exception ignored) {} }
|
||||
if (dataGroupList != null) { try { c.groupNum = Integer.parseInt(dataGroupList.optString(guidHex, "0")); } catch (NumberFormatException ignored) {} }
|
||||
if (chunkFilesizeList != null) { try { c.fileSize = Long.parseLong(chunkFilesizeList.optString(guidHex, "0"), 16); } catch (NumberFormatException ignored) {} }
|
||||
chunkMap.put(guidHex, c);
|
||||
}
|
||||
JSONArray fileList = root.optJSONArray("FileManifestList");
|
||||
if (fileList == null) return null;
|
||||
List<FileInfo> files = new ArrayList<>(fileList.length());
|
||||
for (int i = 0; i < fileList.length(); i++) {
|
||||
JSONObject fo = fileList.getJSONObject(i);
|
||||
FileInfo fi = new FileInfo();
|
||||
fi.filename = fo.optString("Filename", "");
|
||||
JSONArray tags = fo.optJSONArray("InstallTags");
|
||||
if (tags != null) for (int t = 0; t < tags.length(); t++) { String tag = tags.optString(t, ""); if (!tag.isEmpty()) fi.installTags.add(tag); }
|
||||
JSONArray parts = fo.optJSONArray("FileChunkParts");
|
||||
if (parts != null) for (int j = 0; j < parts.length(); j++) {
|
||||
JSONObject po = parts.getJSONObject(j);
|
||||
ChunkPart part = new ChunkPart();
|
||||
String g = po.optString("Guid", "");
|
||||
if (g.length() >= 32) for (int k = 0; k < 4; k++) part.guid[k] = (int) Long.parseLong(g.substring(k * 8, k * 8 + 8), 16);
|
||||
try { part.offset = Integer.parseInt(po.optString("Offset", "0")); } catch (NumberFormatException ignored) {}
|
||||
try { part.size = Integer.parseInt(po.optString("Size", "0")); } catch (NumberFormatException ignored) {}
|
||||
fi.parts.add(part);
|
||||
}
|
||||
files.add(fi);
|
||||
}
|
||||
m.uniqueChunks = new ArrayList<>(chunkMap.values());
|
||||
m.files = files;
|
||||
return m;
|
||||
} catch (Exception e) {
|
||||
Log.e(TAG, "json manifest parse: " + e.getClass().getSimpleName());
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
public static String readFString(ByteBuffer buf) {
|
||||
int length = buf.getInt();
|
||||
if (length == 0) return "";
|
||||
if (length < 0) {
|
||||
int chars = (-length) - 1;
|
||||
byte[] bytes = new byte[chars * 2];
|
||||
buf.get(bytes);
|
||||
buf.getShort();
|
||||
return new String(bytes, StandardCharsets.UTF_16LE);
|
||||
}
|
||||
byte[] bytes = new byte[length - 1];
|
||||
buf.get(bytes);
|
||||
buf.get();
|
||||
return new String(bytes, StandardCharsets.US_ASCII);
|
||||
}
|
||||
|
||||
// ---- chunk fetch (the built-in pool) --------------------------------------------------------
|
||||
|
||||
public static byte[] downloadBytes(String urlStr) {
|
||||
HttpURLConnection conn = null;
|
||||
try {
|
||||
conn = (HttpURLConnection) new URL(urlStr).openConnection();
|
||||
conn.setConnectTimeout(30000);
|
||||
conn.setReadTimeout(60000);
|
||||
conn.setRequestProperty("User-Agent", UA);
|
||||
if (conn.getResponseCode() != 200) { Log.w(TAG, "HTTP " + conn.getResponseCode() + " for " + StoreLog.redactUrl(urlStr)); return null; }
|
||||
return EpicAuthClient.readAllBytes(conn.getInputStream());
|
||||
} catch (Exception e) {
|
||||
Log.w(TAG, "download error [" + StoreLog.redactUrl(urlStr) + "]: " + e.getClass().getSimpleName());
|
||||
return null;
|
||||
} finally {
|
||||
if (conn != null) conn.disconnect();
|
||||
}
|
||||
}
|
||||
|
||||
/** One chunk streamed from the first CDN that serves it, SHA-1 checked, published by rename. */
|
||||
private static boolean downloadChunkStreaming(ChunkInfo chunk, String chunkDir, List<CdnUrl> cdnUrls, File outFile) {
|
||||
String chunkPath = chunk.getPath(chunkDir);
|
||||
File tmp = new File(outFile.getPath() + ".part");
|
||||
tmp.delete();
|
||||
for (CdnUrl cdn : cdnUrls) {
|
||||
HttpURLConnection conn = null;
|
||||
try {
|
||||
conn = (HttpURLConnection) new URL(cdn.baseUrl + cdn.cloudDir + "/" + chunkPath).openConnection();
|
||||
conn.setConnectTimeout(30000);
|
||||
conn.setReadTimeout(60000);
|
||||
conn.setRequestProperty("User-Agent", UA);
|
||||
if (conn.getResponseCode() != 200) { conn.disconnect(); continue; }
|
||||
MessageDigest sha = null;
|
||||
if (chunk.sha1 != null && chunk.sha1.length == 20) {
|
||||
boolean allZero = true;
|
||||
for (byte x : chunk.sha1) if (x != 0) { allZero = false; break; }
|
||||
if (!allZero) { try { sha = MessageDigest.getInstance("SHA-1"); } catch (Exception ignored) {} }
|
||||
}
|
||||
try (InputStream in = conn.getInputStream(); FileOutputStream fos = new FileOutputStream(tmp)) {
|
||||
byte[] hdrBuf = new byte[41];
|
||||
readFully(in, hdrBuf);
|
||||
ByteBuffer hdr = ByteBuffer.wrap(hdrBuf).order(ByteOrder.LITTLE_ENDIAN);
|
||||
if (hdr.getInt() != 0xB1FE3AA2) { Log.w(TAG, "bad chunk magic"); continue; }
|
||||
hdr.getInt();
|
||||
int headerSize = hdr.getInt();
|
||||
int compressedSize = hdr.getInt();
|
||||
hdr.position(hdr.position() + 24);
|
||||
int storedAs = hdr.get() & 0xFF;
|
||||
if (headerSize > 41) skipFully(in, headerSize - 41);
|
||||
byte[] iobuf = new byte[131072];
|
||||
if ((storedAs & 1) != 0) {
|
||||
Inflater inflater = new Inflater();
|
||||
byte[] obuf = new byte[131072];
|
||||
int remaining = compressedSize;
|
||||
try {
|
||||
while (remaining > 0 && !inflater.finished()) {
|
||||
if (inflater.needsInput()) {
|
||||
int n = in.read(iobuf, 0, Math.min(iobuf.length, remaining));
|
||||
if (n <= 0) break;
|
||||
remaining -= n;
|
||||
inflater.setInput(iobuf, 0, n);
|
||||
}
|
||||
int out = inflater.inflate(obuf);
|
||||
if (out > 0) { fos.write(obuf, 0, out); if (sha != null) sha.update(obuf, 0, out); }
|
||||
}
|
||||
int out;
|
||||
while ((out = inflater.inflate(obuf)) > 0) { fos.write(obuf, 0, out); if (sha != null) sha.update(obuf, 0, out); }
|
||||
} finally {
|
||||
inflater.end();
|
||||
}
|
||||
} else {
|
||||
int remaining = compressedSize;
|
||||
while (remaining > 0) {
|
||||
int n = in.read(iobuf, 0, Math.min(iobuf.length, remaining));
|
||||
if (n <= 0) break;
|
||||
fos.write(iobuf, 0, n);
|
||||
if (sha != null) sha.update(iobuf, 0, n);
|
||||
remaining -= n;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (sha != null && !MessageDigest.isEqual(sha.digest(), chunk.sha1)) { tmp.delete(); conn.disconnect(); continue; }
|
||||
if (!tmp.renameTo(outFile)) { tmp.delete(); conn.disconnect(); continue; }
|
||||
conn.disconnect();
|
||||
return true;
|
||||
} catch (Exception e) {
|
||||
tmp.delete();
|
||||
if (conn != null) conn.disconnect();
|
||||
}
|
||||
}
|
||||
tmp.delete();
|
||||
Log.e(TAG, "every CDN failed for chunk " + chunk.guidStr());
|
||||
return false;
|
||||
}
|
||||
|
||||
private static void readFully(InputStream in, byte[] buf) throws IOException {
|
||||
int off = 0;
|
||||
while (off < buf.length) { int n = in.read(buf, off, buf.length - off); if (n < 0) throw new IOException("stream ended"); off += n; }
|
||||
}
|
||||
|
||||
private static void skipFully(InputStream in, int count) throws IOException {
|
||||
byte[] skip = new byte[Math.min(count, 4096)];
|
||||
int remaining = count;
|
||||
while (remaining > 0) { int n = in.read(skip, 0, Math.min(skip.length, remaining)); if (n < 0) throw new IOException("stream ended"); remaining -= n; }
|
||||
}
|
||||
|
||||
// ---- selection and verification -------------------------------------------------------------
|
||||
|
||||
public static List<FileInfo> getRequiredInstallFiles(Manifest manifest) {
|
||||
List<FileInfo> required = new ArrayList<>();
|
||||
for (FileInfo f : manifest.files) if (f.installTags.isEmpty()) required.add(f);
|
||||
return required.isEmpty() ? new ArrayList<>(manifest.files) : required;
|
||||
}
|
||||
|
||||
/** Base files plus any file carrying one of the tags; null tags = every file; nothing matched = base only. */
|
||||
public static List<FileInfo> resolveInstallFiles(Manifest manifest, List<String> selectedTags) {
|
||||
if (selectedTags == null) return new ArrayList<>(manifest.files);
|
||||
if (selectedTags.isEmpty()) return getRequiredInstallFiles(manifest);
|
||||
Set<String> want = new LinkedHashSet<>(selectedTags);
|
||||
List<FileInfo> out = new ArrayList<>();
|
||||
for (FileInfo f : manifest.files) {
|
||||
if (f.installTags.isEmpty()) { out.add(f); continue; }
|
||||
for (String t : f.installTags) if (want.contains(t)) { out.add(f); break; }
|
||||
}
|
||||
return out.isEmpty() ? getRequiredInstallFiles(manifest) : out;
|
||||
}
|
||||
|
||||
public static List<ChunkInfo> uniqueChunksForFiles(Manifest manifest, List<FileInfo> files) {
|
||||
Map<String, ChunkInfo> byGuid = new LinkedHashMap<>();
|
||||
for (ChunkInfo c : manifest.uniqueChunks) byGuid.put(c.guidStr(), c);
|
||||
Set<String> seen = new LinkedHashSet<>();
|
||||
List<ChunkInfo> chunks = new ArrayList<>();
|
||||
for (FileInfo f : files) for (ChunkPart p : f.parts) { String g = p.guidStr(); if (seen.add(g)) { ChunkInfo c = byGuid.get(g); if (c != null) chunks.add(c); } }
|
||||
return chunks;
|
||||
}
|
||||
|
||||
public static boolean fileExistsWithCorrectHash(File outputFile, long expectedSize, byte[] expectedHash) {
|
||||
if (outputFile == null || !outputFile.exists() || outputFile.length() != expectedSize) return false;
|
||||
if (expectedHash == null || expectedHash.length != 20) return false;
|
||||
boolean allZero = true;
|
||||
for (byte x : expectedHash) if (x != 0) { allZero = false; break; }
|
||||
if (allZero) return false;
|
||||
try (FileInputStream fis = new FileInputStream(outputFile)) {
|
||||
MessageDigest digest = MessageDigest.getInstance("SHA-1");
|
||||
byte[] buf = new byte[64 * 1024];
|
||||
int n;
|
||||
while ((n = fis.read(buf)) != -1) digest.update(buf, 0, n);
|
||||
return MessageDigest.isEqual(digest.digest(), expectedHash);
|
||||
} catch (Exception e) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/** The install size for the tags (null = every file), from the manifest alone; -1 on failure. Blocking. */
|
||||
public static long fetchInstallSizeBytes(String manifestApiJson, List<String> installTags) {
|
||||
try {
|
||||
List<CdnUrl> cdnUrls = parseCdnUrls(manifestApiJson);
|
||||
if (cdnUrls.isEmpty()) return -1;
|
||||
byte[] bytes = downloadManifest(manifestApiJson, cdnUrls);
|
||||
if (bytes == null) return -1;
|
||||
Manifest m = parseManifest(bytes);
|
||||
if (m == null) return -1;
|
||||
long total = 0;
|
||||
for (FileInfo f : resolveInstallFiles(m, installTags)) total += Math.max(f.fileSize(), 0);
|
||||
return total > 0 ? total : -1;
|
||||
} catch (Exception e) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
// ---- helpers --------------------------------------------------------------------------------
|
||||
|
||||
static byte[] readFile(File f) throws IOException {
|
||||
try (FileInputStream fis = new FileInputStream(f)) {
|
||||
byte[] data = new byte[(int) f.length()];
|
||||
int off = 0;
|
||||
while (off < data.length) { int r = fis.read(data, off, data.length - off); if (r < 0) break; off += r; }
|
||||
return data;
|
||||
}
|
||||
}
|
||||
|
||||
static void deleteDir(File dir) {
|
||||
if (!dir.exists()) return;
|
||||
File[] files = dir.listFiles();
|
||||
if (files != null) for (File f : files) { if (f.isDirectory()) deleteDir(f); else f.delete(); }
|
||||
dir.delete();
|
||||
}
|
||||
|
||||
private static void sampleSpeed(long done, AtomicLong lastSpeedMs, AtomicLong lastSpeedBytes, AtomicLong speedBps) {
|
||||
long nowMs = System.currentTimeMillis(), prevMs = lastSpeedMs.get();
|
||||
if (nowMs - prevMs >= 500 && lastSpeedMs.compareAndSet(prevMs, nowMs)) {
|
||||
long prevB = lastSpeedBytes.getAndSet(done);
|
||||
long dt = nowMs - prevMs;
|
||||
if (dt > 0) speedBps.set((done - prevB) * 1000L / dt);
|
||||
}
|
||||
}
|
||||
|
||||
private static String speedSuffix(long bps) {
|
||||
if (bps <= 0) return "";
|
||||
return " " + (bps >= 1048576 ? String.format("%.1f MB/s", bps / 1048576.0) : (bps / 1024) + " KB/s");
|
||||
}
|
||||
|
||||
private static String fmt(long bytes) {
|
||||
if (bytes >= 1073741824L) return String.format("%.1f GB", bytes / 1073741824.0);
|
||||
if (bytes >= 1048576L) return String.format("%.1f MB", bytes / 1048576.0);
|
||||
return String.format("%.0f KB", bytes / 1024.0);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
package com.droiddeck.launcher.stores.epic;
|
||||
|
||||
/**
|
||||
* One Epic Games library entry. {@code appName} is the launcher's app slug (the manifest URL and
|
||||
* the launch arguments take it), {@code namespace} the product's sandbox, {@code catalogItemId}
|
||||
* the catalog UUID; the three together address every Epic API call for the game.
|
||||
*/
|
||||
public class EpicGame {
|
||||
public String appName = "";
|
||||
public String namespace = "";
|
||||
public String catalogItemId = "";
|
||||
public String title = "";
|
||||
public String developer = "";
|
||||
public String description = "";
|
||||
/** DieselGameBoxTall: the tall portrait art. */
|
||||
public String artCover = "";
|
||||
/** DieselGameBox or Thumbnail. */
|
||||
public String artSquare = "";
|
||||
public String version = "";
|
||||
public long installSize = 0L;
|
||||
public boolean canRunOffline = true;
|
||||
public boolean isDLC = false;
|
||||
public String baseGameCatalogItemId = "";
|
||||
public String releaseDate = "";
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
package com.droiddeck.launcher.stores.epic
|
||||
|
||||
import java.util.Locale
|
||||
|
||||
/**
|
||||
* Epic tags a manifest's files by language so a client installs the base files plus one language
|
||||
* instead of every language. The table (the launcher's tag names per language) is Legendary's;
|
||||
* the language is the device's locale, English when it is not one Epic ships.
|
||||
*/
|
||||
object EpicInstallTags {
|
||||
private val LANGUAGE_TO_TAGS: Map<String, List<String>> = mapOf(
|
||||
"ar" to listOf("Arabic", "ar"), "bg" to listOf("Bulgarian", "bg-BG", "bg"),
|
||||
"zh-Hans" to listOf("Chinese", "ChineseSimplified", "zh-Hans", "zh_Hans", "zh"), "zh-Hant" to listOf("ChineseTraditional", "zh-Hant", "zh_Hant"),
|
||||
"cs" to listOf("Czech", "cs-CZ", "cs"), "da" to listOf("Danish", "da-DK", "da"), "nl" to listOf("Dutch", "nl-NL", "nl"),
|
||||
"en" to listOf("English", "en-US", "en"), "fi" to listOf("Finnish", "fi-FI", "fi"), "fr" to listOf("French", "fr-FR", "fr"),
|
||||
"de" to listOf("German", "de-DE", "de"), "el" to listOf("Greek", "el-GR", "el"), "hu" to listOf("Hungarian", "hu-HU", "hu"),
|
||||
"it" to listOf("Italian", "it-IT", "it"), "ja" to listOf("Japanese", "ja-JP", "ja"), "ko" to listOf("Korean", "ko-KR", "ko"),
|
||||
"no" to listOf("Norwegian", "nb-NO", "no"), "pl" to listOf("Polish", "pl-PL", "pl"), "pt" to listOf("Portuguese", "pt-PT", "pt"),
|
||||
"pt-BR" to listOf("PortugueseBrazilian", "Brazilian", "pt-BR", "br"), "ro" to listOf("Romanian", "ro-RO", "ro"),
|
||||
"ru" to listOf("Russian", "ru-RU", "ru"), "es" to listOf("Spanish", "es-ES", "es"), "es-419" to listOf("SpanishLatinAmerica", "Latam", "es-MX", "es_mx"),
|
||||
"sv" to listOf("Swedish", "sv-SE", "sv"), "th" to listOf("Thai", "th-TH", "th"), "tr" to listOf("Turkish", "tr-TR", "tr"),
|
||||
"uk" to listOf("Ukrainian", "uk-UA", "uk"), "vi" to listOf("Vietnamese", "vi-VN", "vi"),
|
||||
)
|
||||
|
||||
private fun key(locale: Locale): String? {
|
||||
val l = locale.language.lowercase(Locale.ROOT)
|
||||
val r = locale.country.uppercase(Locale.ROOT)
|
||||
return when (l) {
|
||||
"zh" -> if (r == "TW" || r == "HK" || r == "MO") "zh-Hant" else "zh-Hans"
|
||||
"pt" -> if (r == "BR") "pt-BR" else "pt"
|
||||
"es" -> if (r == "ES" || r.isEmpty()) "es" else "es-419"
|
||||
"nb", "nn" -> "no"
|
||||
else -> if (LANGUAGE_TO_TAGS.containsKey(l)) l else null
|
||||
}
|
||||
}
|
||||
|
||||
/** The install tags for the device's language; English when Epic has no tags for it. Never empty. */
|
||||
@JvmStatic
|
||||
fun tagsForDevice(): List<String> = LANGUAGE_TO_TAGS[key(Locale.getDefault()) ?: "en"] ?: LANGUAGE_TO_TAGS.getValue("en")
|
||||
|
||||
/** The two-letter code handed to the game as -epiclocale; "en" when the language is not one Epic knows. */
|
||||
@JvmStatic
|
||||
fun localeCodeForDevice(): String = key(Locale.getDefault())?.substringBefore('-') ?: "en"
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
package com.droiddeck.launcher.stores.epic
|
||||
|
||||
import android.content.Context
|
||||
import android.util.Log
|
||||
import com.droiddeck.launcher.stores.StoreGameSidecar
|
||||
|
||||
/**
|
||||
* What an Epic game's launch line needs beyond the exe, built once at install time into the
|
||||
* sidecar's arguments: the portal and identity arguments every EOS title expects
|
||||
* (`-EpicPortal -epicusername -epicuserid -epicsandboxid -epiclocale -epicapp -epicenv=Prod`), the
|
||||
* deployment id when the app has an EOS sidecar, and the extra flags Epic ships for the title
|
||||
* (`AdditionalCommandLine`). The sign-in triple (`-AUTH_LOGIN/-AUTH_PASSWORD/-AUTH_TYPE`) is not
|
||||
* here: the exchange code lives minutes, so the launcher .bat takes it from a file the app writes
|
||||
* right before a launch (StoreLaunch.prepare).
|
||||
*
|
||||
* The EOS overlay is never provisioned: nothing points the game's EOS SDK at an overlay component.
|
||||
*/
|
||||
object EpicLaunchData {
|
||||
private const val TAG = "EpicLaunch"
|
||||
|
||||
/** The static launch arguments for [appName] in [namespace]. Blocking: one catalog call for the extra flags. */
|
||||
fun arguments(context: Context, token: String?, appName: String, namespace: String, catalogItemId: String, deploymentId: String): List<String> {
|
||||
val creds = EpicCredentialStore.load(context)
|
||||
val displayName = creds?.displayName?.takeIf { it.isNotEmpty() } ?: "EpicUser"
|
||||
val accountId = creds?.accountId?.takeIf { it.isNotEmpty() } ?: "0"
|
||||
val args = ArrayList<String>()
|
||||
args += "-EpicPortal"
|
||||
args += "-epicusername=\"${sanitize(displayName).replace("\"", "")}\""
|
||||
args += "-epicuserid=${sanitize(accountId)}"
|
||||
args += "-epicsandboxid=${sanitize(namespace)}"
|
||||
args += "-epiclocale=${EpicInstallTags.localeCodeForDevice()}"
|
||||
args += "-epicapp=${sanitize(appName)}"
|
||||
args += "-epicenv=Prod"
|
||||
if (deploymentId.isNotEmpty()) args += "-epicdeploymentid=${sanitize(deploymentId)}"
|
||||
if (token != null && catalogItemId.isNotEmpty()) {
|
||||
val extra = EpicApiClient.getAdditionalCommandLine(token, namespace, catalogItemId)
|
||||
if (!extra.isNullOrBlank()) {
|
||||
val clean = extra.filter { it >= ' ' && it != '\u007f' }.trim()
|
||||
if (clean.isNotEmpty()) { args += clean; Log.i(TAG, "$appName: extra command line present") }
|
||||
}
|
||||
}
|
||||
return args
|
||||
}
|
||||
|
||||
/** The sidecar's identifiers the launcher reads back. */
|
||||
fun extras(appName: String, namespace: String, catalogItemId: String, deploymentId: String): Map<String, String> = buildMap {
|
||||
put("appName", appName); put("namespace", namespace); put("catalogItemId", catalogItemId)
|
||||
if (deploymentId.isNotEmpty()) put("deploymentId", deploymentId)
|
||||
}
|
||||
|
||||
/** True when [sidecar] is an Epic install that can take a sign-in code. */
|
||||
fun wantsExchangeCode(sidecar: StoreGameSidecar): Boolean = sidecar.store == com.droiddeck.launcher.stores.Store.EPIC
|
||||
|
||||
private fun sanitize(s: String): String = s.replace("\n", "").replace("\r", "").replace("\u0000", "")
|
||||
}
|
||||
@@ -0,0 +1,119 @@
|
||||
package com.droiddeck.launcher.stores.epic
|
||||
|
||||
import android.content.Context
|
||||
import android.content.SharedPreferences
|
||||
import android.util.Log
|
||||
import com.droiddeck.launcher.stores.CatalogItem
|
||||
import com.droiddeck.launcher.stores.Store
|
||||
import org.json.JSONArray
|
||||
import org.json.JSONObject
|
||||
import java.util.concurrent.atomic.AtomicBoolean
|
||||
|
||||
/**
|
||||
* The signed-in account's Epic library: the library service's records, each enriched from the
|
||||
* catalog (title, art, DLC flag), cached so the tab paints at once and re-synced when forced or
|
||||
* 15 minutes stale. DLC entries are folded away under their base game. Ported from Bannerlator's
|
||||
* EpicLibraryRepo.
|
||||
*/
|
||||
object EpicLibrary {
|
||||
private const val TAG = "EpicLibrary"
|
||||
private const val CACHE_KEY = "library_cache"
|
||||
private const val LAST_SYNC_KEY = "library_synced_at"
|
||||
private const val THROTTLE_MS = 15L * 60L * 1000L
|
||||
|
||||
private val syncing = AtomicBoolean(false)
|
||||
|
||||
sealed interface SyncResult {
|
||||
class Ok(val games: List<EpicGame>) : SyncResult
|
||||
class Failed(val message: String) : SyncResult
|
||||
object NotLoggedIn : SyncResult
|
||||
object Busy : SyncResult
|
||||
object Throttled : SyncResult
|
||||
}
|
||||
|
||||
fun cached(context: Context): List<EpicGame> {
|
||||
val json = EpicPrefs.get(context).getString(CACHE_KEY, null) ?: return emptyList()
|
||||
return runCatching {
|
||||
val arr = JSONArray(json)
|
||||
val list = ArrayList<EpicGame>(arr.length())
|
||||
for (i in 0 until arr.length()) {
|
||||
val j = arr.optJSONObject(i) ?: continue
|
||||
val g = EpicGame()
|
||||
g.appName = j.optString("appName", ""); g.namespace = j.optString("namespace", ""); g.catalogItemId = j.optString("catalogItemId", "")
|
||||
g.title = j.optString("title", ""); g.artCover = j.optString("artCover", ""); g.artSquare = j.optString("artSquare", "")
|
||||
g.developer = j.optString("developer", ""); g.description = j.optString("description", ""); g.version = j.optString("version", "")
|
||||
g.installSize = j.optLong("installSize", 0L).let { if (it > 1_099_511_627_776L) 0L else it }
|
||||
g.canRunOffline = j.optBoolean("canRunOffline", true)
|
||||
if (g.appName.isNotEmpty()) list.add(g)
|
||||
}
|
||||
list.distinctBy { it.appName }.sortedBy { it.title.lowercase() }
|
||||
}.getOrDefault(emptyList())
|
||||
}
|
||||
|
||||
/** Remembers a game's install size once the manifest said it, for the Install button. */
|
||||
fun rememberSize(context: Context, appName: String, bytes: Long) {
|
||||
if (bytes <= 0) return
|
||||
val p = EpicPrefs.get(context)
|
||||
p.edit().putLong("size_$appName", bytes).apply()
|
||||
}
|
||||
|
||||
fun sync(context: Context, force: Boolean = false, onStatus: (String) -> Unit = {}): SyncResult {
|
||||
if (!syncing.compareAndSet(false, true)) return SyncResult.Busy
|
||||
try {
|
||||
val app = context.applicationContext
|
||||
val p = EpicPrefs.get(app)
|
||||
val cachedList = cached(app)
|
||||
val lastSync = p.getLong(LAST_SYNC_KEY, 0L)
|
||||
if (!force && cachedList.isNotEmpty() && System.currentTimeMillis() - lastSync < THROTTLE_MS) return SyncResult.Throttled
|
||||
onStatus("Checking sign-in…")
|
||||
val token = EpicCredentialStore.getValidAccessToken(app) ?: return SyncResult.NotLoggedIn
|
||||
onStatus("Fetching game list…")
|
||||
val raw = EpicApiClient.getLibraryItems(token)
|
||||
if (raw.isNullOrEmpty()) return if (cachedList.isEmpty()) SyncResult.Failed("No games found in your Epic library") else SyncResult.Ok(cachedList)
|
||||
val total = raw.size
|
||||
var done = 0
|
||||
for (game in raw) {
|
||||
EpicApiClient.enrichFromCatalog(token, game)
|
||||
if (game.releaseDate.isNotEmpty()) p.edit().putString("release_${game.appName}", game.releaseDate).apply()
|
||||
done++
|
||||
if (done % 5 == 0) onStatus("Loading game details… ($done/$total)")
|
||||
}
|
||||
val main = raw.filter { !it.isDLC }
|
||||
val display = (if (main.isEmpty()) raw else main).distinctBy { it.appName }.sortedWith { a, b -> a.title.compareTo(b.title, ignoreCase = true) }
|
||||
for (fresh in display) {
|
||||
val old = cachedList.firstOrNull { it.appName == fresh.appName } ?: continue
|
||||
fresh.version = old.version
|
||||
fresh.installSize = old.installSize
|
||||
}
|
||||
saveCache(p, display)
|
||||
p.edit().putLong(LAST_SYNC_KEY, System.currentTimeMillis()).apply()
|
||||
Log.i(TAG, "sync: raw=${raw.size} shown=${display.size}")
|
||||
return SyncResult.Ok(display)
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "sync failed: ${e.message}")
|
||||
return SyncResult.Failed(e.message ?: "Sync failed")
|
||||
} finally {
|
||||
syncing.set(false)
|
||||
}
|
||||
}
|
||||
|
||||
private fun saveCache(prefs: SharedPreferences, games: List<EpicGame>) {
|
||||
runCatching {
|
||||
val arr = JSONArray()
|
||||
for (g in games) arr.put(JSONObject().put("appName", g.appName).put("namespace", g.namespace).put("catalogItemId", g.catalogItemId)
|
||||
.put("title", g.title).put("artCover", g.artCover).put("artSquare", g.artSquare).put("developer", g.developer)
|
||||
.put("description", g.description).put("version", g.version).put("installSize", g.installSize).put("canRunOffline", g.canRunOffline))
|
||||
prefs.edit().putString(CACHE_KEY, arr.toString()).apply()
|
||||
}
|
||||
}
|
||||
|
||||
fun toCatalogItem(context: Context, g: EpicGame): CatalogItem = CatalogItem(
|
||||
store = Store.EPIC, id = g.appName, title = g.title.ifBlank { g.appName },
|
||||
imageUrl = g.artSquare.ifBlank { null } ?: g.artCover.ifBlank { null },
|
||||
tallImageUrl = g.artCover.ifBlank { null } ?: g.artSquare.ifBlank { null },
|
||||
developer = g.developer, description = g.description, owned = true,
|
||||
sizeBytes = EpicPrefs.get(context).getLong("size_${g.appName}", g.installSize),
|
||||
storeUrl = "https://store.epicgames.com/en-US/browse?q=${java.net.URLEncoder.encode(g.title, "UTF-8")}",
|
||||
extra = mapOf("namespace" to g.namespace, "catalogItemId" to g.catalogItemId),
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
// JNI symbols depend on this package path and class name (app/src/main/rust/stores/JNI.md).
|
||||
package com.droiddeck.launcher.stores.epic
|
||||
|
||||
import android.util.Log
|
||||
import com.droiddeck.launcher.stores.StoresNative
|
||||
import java.util.concurrent.CountDownLatch
|
||||
import java.util.concurrent.TimeUnit
|
||||
import java.util.concurrent.atomic.AtomicBoolean
|
||||
import java.util.concurrent.atomic.AtomicReference
|
||||
|
||||
/**
|
||||
* The native Epic chunk fetcher in `libdroiddeckstores.so`: it fills `<installDir>/.chunks/<GUID>`
|
||||
* with verified, decompressed chunks for the files the manager says are pending. Everything
|
||||
* around it (manifest, install tags, delta pass, assembly, post-install) stays in the manager.
|
||||
*
|
||||
* [run] blocks like the Java pool it replaces and polls [AtomicBoolean] `cancel` every 250 ms: on
|
||||
* cancel it flips the native flag, waits up to 5 s for the run to wind down, then returns.
|
||||
*/
|
||||
object EpicNative {
|
||||
private const val TAG = "EpicNative"
|
||||
|
||||
/** Callbacks from the native run; every method is called on a native thread. */
|
||||
interface Listener {
|
||||
/** Once, before any fetch: the plan the engine derived (the manager cross-checks it). */
|
||||
fun onPlan(chunksTotal: Int, bytesTotal: Long, chunkDir: String)
|
||||
/** Per accounted chunk (cached-skip or fetched). */
|
||||
fun onProgress(bytesDone: Long, bytesTotal: Long, chunksDone: Int, chunksTotal: Int)
|
||||
/** Engine log line (already in logcat under `EpicNative`). */
|
||||
fun onLog(line: String)
|
||||
/** Terminal. */
|
||||
fun onComplete(success: Boolean, error: String, bytesCredited: Long)
|
||||
}
|
||||
|
||||
/** Outcome of [run]. `started == false`: nothing was fetched, the caller runs its own pool. */
|
||||
class Result(
|
||||
@JvmField val started: Boolean, @JvmField val success: Boolean, @JvmField val cancelled: Boolean,
|
||||
@JvmField val error: String, @JvmField val bytesCredited: Long, @JvmField val chunksDone: Int, @JvmField val chunksTotal: Int,
|
||||
)
|
||||
|
||||
private class Completion(val success: Boolean, val error: String, val bytes: Long)
|
||||
|
||||
@JvmStatic
|
||||
fun run(
|
||||
manifest: ByteArray, installDir: String, cdnPrefixes: Array<String>, pendingFileIdx: IntArray, expectedChunks: Int, expectedBytes: Long,
|
||||
caBundlePath: String, maxWorkers: Int, processWorkers: Int, cancel: AtomicBoolean?, listener: Listener,
|
||||
): Result {
|
||||
if (!StoresNative.ensureLoaded()) return Result(false, false, false, "engine not built", 0L, 0, 0)
|
||||
val latch = CountDownLatch(1)
|
||||
val completion = AtomicReference<Completion?>(null)
|
||||
val doneRef = AtomicReference(0)
|
||||
val totalRef = AtomicReference(0)
|
||||
val inner = object : Listener {
|
||||
override fun onPlan(chunksTotal: Int, bytesTotal: Long, chunkDir: String) { totalRef.set(chunksTotal); listener.onPlan(chunksTotal, bytesTotal, chunkDir) }
|
||||
override fun onProgress(bytesDone: Long, bytesTotal: Long, chunksDone: Int, chunksTotal: Int) { doneRef.set(chunksDone); listener.onProgress(bytesDone, bytesTotal, chunksDone, chunksTotal) }
|
||||
override fun onLog(line: String) = listener.onLog(line)
|
||||
override fun onComplete(success: Boolean, error: String, bytesCredited: Long) {
|
||||
completion.set(Completion(success, error, bytesCredited))
|
||||
latch.countDown()
|
||||
runCatching { listener.onComplete(success, error, bytesCredited) }
|
||||
}
|
||||
}
|
||||
val handle: Long = try {
|
||||
nativeStart(manifest, installDir, cdnPrefixes, pendingFileIdx, expectedChunks, expectedBytes, caBundlePath, maxWorkers, processWorkers, inner)
|
||||
} catch (t: Throwable) {
|
||||
Log.w(TAG, "engine unavailable: ${t.javaClass.simpleName}: ${t.message}")
|
||||
return Result(false, false, false, "nativeStart: ${t.javaClass.simpleName}", 0L, 0, 0)
|
||||
}
|
||||
if (handle == 0L) return Result(false, false, false, completion.get()?.error ?: "not started", 0L, 0, totalRef.get())
|
||||
var cancelSent = false
|
||||
try {
|
||||
while (!latch.await(250, TimeUnit.MILLISECONDS)) {
|
||||
if (cancel != null && cancel.get()) {
|
||||
nativeCancel(handle)
|
||||
cancelSent = true
|
||||
latch.await(5, TimeUnit.SECONDS)
|
||||
break
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
nativeRelease(handle)
|
||||
}
|
||||
val c = completion.get()
|
||||
val success = !cancelSent && c != null && c.success
|
||||
val error = when { cancelSent -> "cancelled"; c == null -> "no completion"; else -> c.error }
|
||||
return Result(true, success, cancelSent, error, c?.bytes ?: 0L, doneRef.get(), totalRef.get())
|
||||
}
|
||||
|
||||
@JvmStatic
|
||||
private external fun nativeStart(
|
||||
manifest: ByteArray, installDir: String, cdnPrefixes: Array<String>, pendingFileIdx: IntArray, expectedChunks: Int, expectedBytes: Long,
|
||||
caBundlePath: String, maxWorkers: Int, processWorkers: Int, listener: Listener,
|
||||
): Long
|
||||
|
||||
@JvmStatic
|
||||
private external fun nativeCancel(handle: Long)
|
||||
|
||||
@JvmStatic
|
||||
private external fun nativeRelease(handle: Long)
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
package com.droiddeck.launcher.stores.epic
|
||||
|
||||
import android.content.Context
|
||||
import android.content.SharedPreferences
|
||||
|
||||
/**
|
||||
* Epic's own records that are not credentials: the library cache, each game's release date, the
|
||||
* cached deployment id and extra command line a launch needs. App-private preferences; the sign-in
|
||||
* lives in StoreAccounts. Public: the Java clients read it too.
|
||||
*/
|
||||
object EpicPrefs {
|
||||
@JvmStatic
|
||||
fun get(context: Context): SharedPreferences = context.applicationContext.getSharedPreferences("stores.epic", Context.MODE_PRIVATE)
|
||||
}
|
||||
@@ -0,0 +1,214 @@
|
||||
package com.droiddeck.launcher.stores.epic
|
||||
|
||||
import android.content.Context
|
||||
import android.util.Log
|
||||
import com.droiddeck.launcher.stores.CatalogItem
|
||||
import com.droiddeck.launcher.stores.Store
|
||||
import com.droiddeck.launcher.stores.StoreNet
|
||||
import com.droiddeck.launcher.stores.StoreShelves
|
||||
import org.json.JSONArray
|
||||
import org.json.JSONObject
|
||||
import java.text.SimpleDateFormat
|
||||
import java.util.Date
|
||||
import java.util.Locale
|
||||
import java.util.TimeZone
|
||||
import java.util.concurrent.ConcurrentHashMap
|
||||
|
||||
/**
|
||||
* The Epic Games Store catalog through the GraphQL endpoint the store website uses
|
||||
* (`store.epicgames.com/graphql`, which wants a browser User-Agent): `Catalog.searchStore` with
|
||||
* the base-game category, sorted by price / release date / relevance, on sale or free. Elements
|
||||
* carry the offer id, the namespace, the catalog item ids (what the library records, so ownership
|
||||
* is matched on those), key images and pre-formatted prices. "Free this week" comes from the
|
||||
* static `freeGamesPromotions` feed.
|
||||
*/
|
||||
object EpicStoreCatalog {
|
||||
private const val TAG = "EpicStore"
|
||||
private const val GRAPHQL = "https://store.epicgames.com/graphql"
|
||||
private const val PROMOS = "https://store-site-backend-static-ipv4.ak.epicgames.com/freeGamesPromotions"
|
||||
private const val FEATURED_TTL_MS = 30 * 60 * 1000L
|
||||
private const val SEARCH_TTL_MS = 5 * 60 * 1000L
|
||||
private const val KEY_FEATURED = "store_featured"
|
||||
|
||||
private const val ELEMENT_FIELDS =
|
||||
"title id namespace description effectiveDate releaseDate offerType productSlug urlSlug " +
|
||||
"items{id namespace} keyImages{type url} seller{name} tags{name} " +
|
||||
"catalogNs{mappings(pageType:\"productHome\"){pageSlug pageType}} " +
|
||||
"price(country:\$country){totalPrice{discountPrice originalPrice discount currencyCode " +
|
||||
"fmtPrice(locale:\$locale){originalPrice discountPrice}}}"
|
||||
|
||||
private class Cached<T>(val value: T, val at: Long)
|
||||
private var featuredCache: Cached<StoreShelves>? = null
|
||||
private val searchCache = ConcurrentHashMap<String, Cached<List<CatalogItem>>>()
|
||||
|
||||
private fun country(): String = Locale.getDefault().country.takeIf { it.length == 2 }?.uppercase(Locale.ROOT) ?: "US"
|
||||
|
||||
private fun nowIso(): String {
|
||||
val f = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US)
|
||||
f.timeZone = TimeZone.getTimeZone("UTC")
|
||||
return f.format(Date())
|
||||
}
|
||||
|
||||
private fun searchStore(count: Int, keywords: String? = null, sortBy: String = "relevancy", sortDir: String = "DESC", onSale: Boolean? = null, freeGame: Boolean? = null, releasedOnly: Boolean = false): List<CatalogItem> {
|
||||
val args = StringBuilder("category:\"games/edition/base\",count:\$count,country:\$country,locale:\$locale,sortBy:\$sortBy,sortDir:\$sortDir,allowCountries:\$country")
|
||||
if (keywords != null) args.append(",keywords:\$keywords")
|
||||
if (onSale != null) args.append(",onSale:$onSale")
|
||||
if (freeGame != null) args.append(",freeGame:$freeGame")
|
||||
if (releasedOnly) args.append(",releaseDate:\"[,${nowIso()}]\"")
|
||||
val query = "query q(\$count:Int,\$country:String!,\$locale:String,\$sortBy:String,\$sortDir:String" +
|
||||
(if (keywords != null) ",\$keywords:String" else "") + "){Catalog{searchStore($args){elements{$ELEMENT_FIELDS} paging{total}}}}"
|
||||
val vars = JSONObject().put("count", count).put("country", country()).put("locale", "en-US").put("sortBy", sortBy).put("sortDir", sortDir)
|
||||
if (keywords != null) vars.put("keywords", keywords)
|
||||
val resp = StoreNet.postJson(GRAPHQL, JSONObject().put("query", query).put("variables", vars).toString()) ?: return emptyList()
|
||||
val elements = runCatching { JSONObject(resp).optJSONObject("data")?.optJSONObject("Catalog")?.optJSONObject("searchStore")?.optJSONArray("elements") }
|
||||
.onFailure { Log.w(TAG, "searchStore parse failed: ${it.message}") }.getOrNull() ?: return emptyList()
|
||||
return parseElements(elements)
|
||||
}
|
||||
|
||||
private fun parseElements(arr: JSONArray): List<CatalogItem> {
|
||||
val out = ArrayList<CatalogItem>(arr.length())
|
||||
for (i in 0 until arr.length()) arr.optJSONObject(i)?.let { e -> parseElement(e)?.let { out.add(it) } }
|
||||
return out.distinctBy { it.id }
|
||||
}
|
||||
|
||||
fun parseElement(e: JSONObject): CatalogItem? {
|
||||
val id = e.optString("id", "")
|
||||
val title = e.optString("title", "")
|
||||
if (id.isEmpty() || title.isEmpty()) return null
|
||||
val ns = e.optString("namespace", "")
|
||||
var wide: String? = null; var tall: String? = null; var thumb: String? = null
|
||||
e.optJSONArray("keyImages")?.let { imgs ->
|
||||
for (k in 0 until imgs.length()) {
|
||||
val img = imgs.optJSONObject(k) ?: continue
|
||||
val url = img.optString("url", "")
|
||||
if (url.isBlank()) continue
|
||||
when (img.optString("type", "")) {
|
||||
"OfferImageWide", "DieselStoreFrontWide" -> if (wide == null) wide = url
|
||||
"OfferImageTall", "DieselStoreFrontTall", "DieselGameBoxTall" -> if (tall == null) tall = url
|
||||
"Thumbnail" -> if (thumb == null) thumb = url
|
||||
}
|
||||
}
|
||||
}
|
||||
val price = e.optJSONObject("price")?.optJSONObject("totalPrice")
|
||||
val original = price?.optLong("originalPrice", -1L) ?: -1L
|
||||
val discounted = price?.optLong("discountPrice", -1L) ?: -1L
|
||||
val fmt = price?.optJSONObject("fmtPrice")
|
||||
val fmtOriginal = fmt?.optString("originalPrice", "").orEmpty()
|
||||
val fmtDiscount = fmt?.optString("discountPrice", "").orEmpty()
|
||||
val hasPrice = original >= 0 && discounted >= 0
|
||||
val isFree = hasPrice && discounted == 0L
|
||||
val discountPct = if (hasPrice && original > 0 && discounted < original) ((original - discounted) * 100 / original).toInt() else 0
|
||||
val finalPrice = when { isFree -> "Free"; fmtDiscount.isNotBlank() && fmtDiscount != "0" -> fmtDiscount; else -> fmtOriginal }
|
||||
val tagLine = buildList {
|
||||
e.optJSONArray("tags")?.let { tags -> for (t in 0 until tags.length()) { val n = tags.optJSONObject(t)?.optString("name").orEmpty(); if (n.isNotBlank() && n != "Windows" && size < 3) add(n) } }
|
||||
}.joinToString(", ")
|
||||
val itemIds = buildList {
|
||||
e.optJSONArray("items")?.let { items -> for (j in 0 until items.length()) items.optJSONObject(j)?.optString("id")?.takeIf { it.isNotBlank() }?.let { add(it) } }
|
||||
}
|
||||
val slug = pageSlugOf(e)
|
||||
val storeUrl = if (slug.isNotBlank()) "https://store.epicgames.com/en-US/p/$slug" else "https://store.epicgames.com/en-US/browse?q=${java.net.URLEncoder.encode(title, "UTF-8")}"
|
||||
return CatalogItem(
|
||||
store = Store.EPIC, id = id, title = title, imageUrl = wide ?: thumb, tallImageUrl = tall ?: thumb, tags = tagLine,
|
||||
isFree = isFree, hasPrice = hasPrice, finalPrice = finalPrice, originalPrice = if (discountPct > 0) fmtOriginal else "", discountPercent = discountPct,
|
||||
storeUrl = storeUrl, developer = e.optJSONObject("seller")?.optString("name", "").orEmpty(),
|
||||
releaseDate = e.optString("releaseDate", e.optString("effectiveDate", "")), description = e.optString("description", ""),
|
||||
extra = buildMap { put("namespace", ns); if (itemIds.isNotEmpty()) put("items", itemIds.joinToString(",")); if (slug.isNotBlank()) put("slug", slug) },
|
||||
)
|
||||
}
|
||||
|
||||
private fun pageSlugOf(e: JSONObject): String {
|
||||
e.optJSONObject("catalogNs")?.optJSONArray("mappings")?.let { m ->
|
||||
for (i in 0 until m.length()) { val map = m.optJSONObject(i) ?: continue; if (map.optString("pageType") == "productHome") { val s = map.optString("pageSlug", ""); if (s.isNotBlank()) return s } }
|
||||
}
|
||||
var slug = e.optString("productSlug", "")
|
||||
if (slug == "null") slug = ""
|
||||
return slug.removeSuffix("/home")
|
||||
}
|
||||
|
||||
/** The Store tab's shelves: this week's giveaways as Free, sales as Deals, newest releases, trending = free-to-play picks. Blocking. */
|
||||
fun featured(context: Context, force: Boolean = false): StoreShelves? {
|
||||
val now = System.currentTimeMillis()
|
||||
featuredCache?.let { if (!force && now - it.at < FEATURED_TTL_MS) return it.value }
|
||||
val freeNow = fetchPromos()
|
||||
val onSale = searchStore(24, sortBy = "currentPrice", sortDir = "ASC", onSale = true).filter { it.discountPercent > 0 }
|
||||
val newest = searchStore(24, sortBy = "releaseDate", sortDir = "DESC", releasedOnly = true)
|
||||
val freeToPlay = searchStore(24, sortBy = "relevancy", sortDir = "DESC", freeGame = true)
|
||||
val result = StoreShelves(whatsNew = newest, deals = onSale, free = (freeNow + freeToPlay).distinctBy { it.id }, trending = searchStore(24, sortBy = "relevancy", sortDir = "DESC", releasedOnly = true))
|
||||
if (!result.isEmpty) {
|
||||
featuredCache = Cached(result, now)
|
||||
persist(context, result)
|
||||
Log.i(TAG, "shelves: freeNow=${freeNow.size} sale=${onSale.size} new=${newest.size} f2p=${freeToPlay.size}")
|
||||
return result
|
||||
}
|
||||
Log.w(TAG, "every store feed came back empty; using the on-disk mirror")
|
||||
return loadPersisted(context)
|
||||
}
|
||||
|
||||
fun cachedFeatured(context: Context): StoreShelves? = featuredCache?.value ?: loadPersisted(context)
|
||||
|
||||
fun search(query: String): List<CatalogItem> {
|
||||
val term = query.trim()
|
||||
if (term.length < 2) return emptyList()
|
||||
val key = term.lowercase(Locale.ROOT)
|
||||
val now = System.currentTimeMillis()
|
||||
searchCache[key]?.let { if (now - it.at < SEARCH_TTL_MS) return it.value }
|
||||
val results = searchStore(30, keywords = term)
|
||||
searchCache[key] = Cached(results, now)
|
||||
return results
|
||||
}
|
||||
|
||||
/** This week's giveaway titles (100% off right now). */
|
||||
private fun fetchPromos(): List<CatalogItem> {
|
||||
val body = StoreNet.get("$PROMOS?locale=en-US&country=${country()}&allowCountries=${country()}") ?: return emptyList()
|
||||
return runCatching {
|
||||
val elements = JSONObject(body).optJSONObject("data")?.optJSONObject("Catalog")?.optJSONObject("searchStore")?.optJSONArray("elements") ?: JSONArray()
|
||||
val out = ArrayList<CatalogItem>()
|
||||
for (i in 0 until elements.length()) {
|
||||
val el = elements.optJSONObject(i) ?: continue
|
||||
val current = el.optJSONObject("promotions")?.optJSONArray("promotionalOffers")
|
||||
if (current == null || current.length() == 0) continue
|
||||
val inner = current.optJSONObject(0)?.optJSONArray("promotionalOffers") ?: continue
|
||||
if (inner.length() == 0) continue
|
||||
val discount = inner.optJSONObject(0)?.optJSONObject("discountSetting")
|
||||
if (discount == null || discount.optInt("discountPercentage", -1) != 0) continue
|
||||
val end = inner.optJSONObject(0)?.optString("endDate", "").orEmpty()
|
||||
val base = parseElement(el) ?: continue
|
||||
out.add(base.copy(isFree = true, hasPrice = true, finalPrice = "Free", originalPrice = base.originalPrice.ifBlank {
|
||||
el.optJSONObject("price")?.optJSONObject("totalPrice")?.optJSONObject("fmtPrice")?.optString("originalPrice", "").orEmpty()
|
||||
}, discountPercent = 100, tags = if (end.length >= 10) "Free until ${end.take(10)}" else base.tags))
|
||||
}
|
||||
out.distinctBy { it.id }
|
||||
}.onFailure { Log.w(TAG, "promos parse failed: ${it.message}") }.getOrDefault(emptyList())
|
||||
}
|
||||
|
||||
private fun itemToJson(i: CatalogItem): JSONObject = JSONObject().apply {
|
||||
put("id", i.id); put("title", i.title); put("image", i.imageUrl ?: ""); put("tall", i.tallImageUrl ?: ""); put("tags", i.tags)
|
||||
put("free", i.isFree); put("hasPrice", i.hasPrice); put("final", i.finalPrice); put("orig", i.originalPrice); put("disc", i.discountPercent)
|
||||
put("url", i.storeUrl); put("dev", i.developer); put("rel", i.releaseDate); put("desc", i.description); put("extra", JSONObject(i.extra as Map<*, *>))
|
||||
}
|
||||
|
||||
private fun itemFromJson(o: JSONObject): CatalogItem {
|
||||
val extra = HashMap<String, String>()
|
||||
o.optJSONObject("extra")?.let { e -> e.keys().forEach { k -> extra[k] = e.optString(k) } }
|
||||
return CatalogItem(
|
||||
store = Store.EPIC, id = o.optString("id"), title = o.optString("title"), imageUrl = o.optString("image").ifBlank { null }, tallImageUrl = o.optString("tall").ifBlank { null },
|
||||
tags = o.optString("tags"), isFree = o.optBoolean("free"), hasPrice = o.optBoolean("hasPrice"), finalPrice = o.optString("final"), originalPrice = o.optString("orig"),
|
||||
discountPercent = o.optInt("disc"), storeUrl = o.optString("url"), developer = o.optString("dev"), releaseDate = o.optString("rel"), description = o.optString("desc"), extra = extra,
|
||||
)
|
||||
}
|
||||
|
||||
private fun listToJson(l: List<CatalogItem>) = JSONArray().apply { l.forEach { put(itemToJson(it)) } }
|
||||
private fun listFromJson(a: JSONArray?): List<CatalogItem> = if (a == null) emptyList() else List(a.length()) { a.optJSONObject(it) }.filterNotNull().map(::itemFromJson)
|
||||
|
||||
private fun persist(context: Context, f: StoreShelves) {
|
||||
runCatching {
|
||||
EpicPrefs.get(context).edit().putString(KEY_FEATURED, JSONObject().put("new", listToJson(f.whatsNew)).put("deals", listToJson(f.deals)).put("free", listToJson(f.free)).put("trending", listToJson(f.trending)).toString()).apply()
|
||||
}
|
||||
}
|
||||
|
||||
private fun loadPersisted(context: Context): StoreShelves? = runCatching {
|
||||
val s = EpicPrefs.get(context).getString(KEY_FEATURED, null) ?: return null
|
||||
val o = JSONObject(s)
|
||||
StoreShelves(listFromJson(o.optJSONArray("new")), listFromJson(o.optJSONArray("deals")), listFromJson(o.optJSONArray("free")), listFromJson(o.optJSONArray("trending"))).takeIf { !it.isEmpty }
|
||||
}.getOrNull()
|
||||
}
|
||||
Reference in new issue
Block a user