381 lines
26 KiB
TypeScript
381 lines
26 KiB
TypeScript
// Game Center (App Store) and Play Games Services (Google Play) from ONE config section, `games`: the switches per
|
|
// store plus one shared list of leaderboards and achievements, each mapped to both stores. Pure: config types and
|
|
// validation, the request bodies, the create / update / keep plans against what the store returned, and the project
|
|
// checks (Game Center entitlement, the PGS APP_ID resource and Gradle dependency).
|
|
//
|
|
// Why one shared list: a game ships the same leaderboards and achievements on both stores, the texts are per config
|
|
// language like products' listings, and only the ids differ (Apple: our vendor id; Play: an id Google generates). So
|
|
// `id` is the vendorIdentifier on the App Store, and `playId` is the generated Play id once known (until then the
|
|
// Play side is matched by its default-language name).
|
|
//
|
|
// Names verified in specs/app-store-connect.oas.json: gameCenterDetails (POST, app relationship; GET
|
|
// /v1/apps/{id}/gameCenterDetail), gameCenterAppVersions (POST with appStoreVersion; GET
|
|
// /v1/appStoreVersions/{id}/gameCenterAppVersion; the older /v1/apps/{id}/gameCenterEnabledVersions is deprecated),
|
|
// gameCenterLeaderboards / gameCenterAchievements v1 (POST, PATCH; GET /v1/gameCenterDetails/{id}/gameCenterLeaderboards
|
|
// and .../gameCenterAchievements) and their v1 localizations (GET /v1/gameCenterLeaderboards/{id}/localizations).
|
|
// Play: the Google Play Games Services Configuration API (gamesconfiguration.googleapis.com/games/v1configuration,
|
|
// achievementConfigurations / leaderboardConfigurations: list, insert, update; scope androidpublisher). Its discovery
|
|
// document is not pinned in specs/ (only androidpublisher and the reporting API are): shapes follow Google's reference.
|
|
import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
|
|
import { join, relative } from 'node:path';
|
|
import type { Language, Platform, ShipConfig } from './config';
|
|
import { consoleLink } from './console-links';
|
|
|
|
export const GC_FORMATS = ['INTEGER', 'DECIMAL_POINT_1_PLACE', 'DECIMAL_POINT_2_PLACE', 'DECIMAL_POINT_3_PLACE', 'ELAPSED_TIME_CENTISECOND',
|
|
'ELAPSED_TIME_MINUTE', 'ELAPSED_TIME_SECOND', 'MONEY_POUND_DECIMAL', 'MONEY_POUND', 'MONEY_DOLLAR_DECIMAL', 'MONEY_DOLLAR', 'MONEY_EURO_DECIMAL',
|
|
'MONEY_EURO', 'MONEY_FRANC_DECIMAL', 'MONEY_FRANC', 'MONEY_KRONER_DECIMAL', 'MONEY_KRONER', 'MONEY_YEN'] as const;
|
|
export type GcFormat = typeof GC_FORMATS[number];
|
|
|
|
export interface GameLeaderboard {
|
|
/** Your id: the App Store vendorIdentifier (letters, digits, . _ -; e.g. "com.example.game.highscore"). */
|
|
id: string;
|
|
/** high (default): a higher score is better (Apple DESC, Play LARGER_IS_BETTER); low: lower is better (a race time). */
|
|
sort?: 'high' | 'low';
|
|
/** Score format, Apple's formatter names (default INTEGER); Play gets the matching NUMERIC / TIME_DURATION / CURRENCY. */
|
|
format?: GcFormat;
|
|
/** best (default): the best score counts (Apple BEST_SCORE); recent: the latest (Apple only; Play keeps the best). */
|
|
submission?: 'best' | 'recent';
|
|
min?: number;
|
|
max?: number;
|
|
/** Texts per config language id: name (Apple: 32 characters; Play: 100) and an optional score suffix (" points"). */
|
|
locales: Record<string, { name: string; suffix?: string }>;
|
|
/** The Play leaderboard id Google generated (CgkI...), once it exists. */
|
|
playId?: string;
|
|
platforms?: Platform[];
|
|
}
|
|
|
|
export interface GameAchievement {
|
|
id: string;
|
|
/** Apple: 0-100 each, 1000 in total; Play: a multiple of 5, 1000 in total. */
|
|
points: number;
|
|
/** Hidden until earned (Apple showBeforeEarned false; Play initialState HIDDEN). Default false. */
|
|
hidden?: boolean;
|
|
/** Apple only: can be earned again. Default false. */
|
|
repeatable?: boolean;
|
|
/** Play only: an incremental achievement with this many steps (Apple reports progress in percent from the game). */
|
|
steps?: number;
|
|
/** name, description (before earned) and earned (after; default the description). */
|
|
locales: Record<string, { name: string; description: string; earned?: string }>;
|
|
playId?: string;
|
|
platforms?: Platform[];
|
|
}
|
|
|
|
export interface GamesConfig {
|
|
/** Game Center: the App ID capability, the app's Game Center detail and the version's Game Center switch. */
|
|
gameCenter?: boolean;
|
|
/** Play Games Services: the games project id (the digits of games_APP_ID / com.google.android.gms.games.APP_ID). */
|
|
playGames?: { appId?: string };
|
|
leaderboards?: GameLeaderboard[];
|
|
achievements?: GameAchievement[];
|
|
}
|
|
|
|
const ID_RE = /^[A-Za-z0-9._-]{1,100}$/;
|
|
|
|
export function validateGames(g: GamesConfig | undefined, languages: Language[] = []): string[] {
|
|
if (g === undefined) return [];
|
|
const e: string[] = [];
|
|
if (!g || typeof g !== 'object') return ['games: an object { gameCenter, playGames, leaderboards, achievements }'];
|
|
if (g.gameCenter !== undefined && typeof g.gameCenter !== 'boolean') e.push('games.gameCenter: true | false');
|
|
if (g.playGames !== undefined && (typeof g.playGames !== 'object' || (g.playGames.appId !== undefined && !/^\d{6,20}$/.test(String(g.playGames.appId)))))
|
|
e.push('games.playGames.appId: the digits of the Play Games Services project id (games_APP_ID)');
|
|
const langs = new Set(languages.map(l => l.id));
|
|
const seen = new Set<string>();
|
|
const checkId = (kind: string, id: unknown) => {
|
|
if (typeof id !== 'string' || !ID_RE.test(id)) e.push(`games.${kind}: id "${String(id)}" (letters, digits, . _ -; at most 100)`);
|
|
else if (seen.has(id)) e.push(`games.${kind}: id "${id}" is used twice (ids are unique across leaderboards and achievements)`);
|
|
else seen.add(id);
|
|
};
|
|
const checkLocales = (kind: string, id: string, loc: Record<string, unknown> | undefined, keys: string[]) => {
|
|
if (!loc || typeof loc !== 'object' || !Object.keys(loc).length) { e.push(`games.${kind} ${id}: locales needs at least one language`); return; }
|
|
for (const [k, v] of Object.entries(loc)) {
|
|
if (langs.size && !langs.has(k)) e.push(`games.${kind} ${id}: locales.${k} is not a language id of the config (${[...langs].join(', ')})`);
|
|
for (const f of keys) if (typeof (v as Record<string, unknown>)?.[f] !== 'string' || !(v as Record<string, string>)[f]!.trim()) e.push(`games.${kind} ${id}: locales.${k}.${f} is missing`);
|
|
const name = (v as { name?: string })?.name ?? '';
|
|
if (name.length > 32 && g.gameCenter) e.push(`games.${kind} ${id}: locales.${k}.name is ${name.length} characters (Game Center: at most 32)`);
|
|
}
|
|
};
|
|
for (const l of g.leaderboards ?? []) {
|
|
checkId('leaderboards', l?.id);
|
|
if (l.sort !== undefined && !['high', 'low'].includes(l.sort)) e.push(`games.leaderboards ${l.id}: sort high | low`);
|
|
if (l.format !== undefined && !GC_FORMATS.includes(l.format)) e.push(`games.leaderboards ${l.id}: format one of ${GC_FORMATS.slice(0, 4).join(', ')}, ...`);
|
|
if (l.submission !== undefined && !['best', 'recent'].includes(l.submission)) e.push(`games.leaderboards ${l.id}: submission best | recent`);
|
|
if (l.min !== undefined && l.max !== undefined && l.min >= l.max) e.push(`games.leaderboards ${l.id}: min must be below max`);
|
|
checkLocales('leaderboards', l.id, l.locales, ['name']);
|
|
}
|
|
let apple = 0, play = 0;
|
|
for (const a of g.achievements ?? []) {
|
|
checkId('achievements', a?.id);
|
|
if (!Number.isInteger(a.points) || a.points < 0 || a.points > 100) e.push(`games.achievements ${a.id}: points 0-100 (Game Center's limit per achievement)`);
|
|
else if (g.playGames && a.points % 5) e.push(`games.achievements ${a.id}: points ${a.points} is not a multiple of 5 (Play Games Services refuses it)`);
|
|
if (a.steps !== undefined && (!Number.isInteger(a.steps) || a.steps < 2 || a.steps > 10000)) e.push(`games.achievements ${a.id}: steps 2-10000 (an incremental Play achievement)`);
|
|
checkLocales('achievements', a.id, a.locales, ['name', 'description']);
|
|
if (!a.platforms || a.platforms.includes('ios')) apple += a.points || 0;
|
|
if (!a.platforms || a.platforms.includes('android')) play += a.points || 0;
|
|
}
|
|
if (g.gameCenter && apple > 1000) e.push(`games.achievements: ${apple} points in total (Game Center: at most 1000)`);
|
|
if (g.playGames && play > 1000) e.push(`games.achievements: ${play} points in total (Play Games Services: at most 1000)`);
|
|
if ((g.achievements?.length ?? 0) > 200 && g.playGames) e.push('games.achievements: more than 200 (Play Games Services: at most 200)');
|
|
return e;
|
|
}
|
|
|
|
export const onStore = (item: { platforms?: Platform[] }, store: 'apple' | 'play'): boolean => !item.platforms || item.platforms.includes(store === 'apple' ? 'ios' : 'android');
|
|
export const usesGameCenter = (c: Pick<ShipConfig, 'games'>): boolean => c.games?.gameCenter === true;
|
|
export const usesPlayGames = (c: Pick<ShipConfig, 'games'>): boolean => !!c.games?.playGames;
|
|
|
|
// ------------------------------------------------------------------------------------------- plans (both stores)
|
|
|
|
export type Action = 'create' | 'update' | 'keep';
|
|
export interface LocPlan { locale: string; action: Action; id?: string; attributes: Record<string, unknown>; changed: string[] }
|
|
export interface ItemPlan { kind: 'leaderboard' | 'achievement'; id: string; action: Action; storeId?: string; attributes: Record<string, unknown>; changed: string[]; locales: LocPlan[] }
|
|
|
|
/** Fields of `want` that differ from `have` (JSON compare per field; a missing field on the store counts as different). */
|
|
export function changedFields(have: Record<string, unknown> | undefined, want: Record<string, unknown>): string[] {
|
|
return Object.keys(want).filter(k => JSON.stringify(have?.[k] ?? null) !== JSON.stringify(want[k] ?? null));
|
|
}
|
|
|
|
const appleLocale = (languages: Language[], id: string): string | undefined => languages.find(l => l.id === id)?.apple;
|
|
|
|
export function gcLeaderboardAttrs(l: GameLeaderboard): Record<string, unknown> {
|
|
return {
|
|
referenceName: l.id, defaultFormatter: l.format ?? 'INTEGER', submissionType: l.submission === 'recent' ? 'MOST_RECENT_SCORE' : 'BEST_SCORE',
|
|
scoreSortType: l.sort === 'low' ? 'ASC' : 'DESC',
|
|
...(l.min !== undefined ? { scoreRangeStart: String(l.min) } : {}), ...(l.max !== undefined ? { scoreRangeEnd: String(l.max) } : {}),
|
|
};
|
|
}
|
|
|
|
export function gcAchievementAttrs(a: GameAchievement): Record<string, unknown> {
|
|
return { referenceName: a.id, points: a.points, showBeforeEarned: !a.hidden, repeatable: !!a.repeatable };
|
|
}
|
|
|
|
export interface GcExisting { id: string; attributes: Record<string, unknown>; localizations: { id: string; attributes: Record<string, unknown> }[] }
|
|
|
|
/** Game Center plan: matched by vendorIdentifier; create what is missing, PATCH what differs, keep the rest. Archived
|
|
* items on the store are left alone (an archived vendor id cannot be reused; the plan names it). */
|
|
export function planGameCenter(g: GamesConfig, languages: Language[], have: { leaderboards: GcExisting[]; achievements: GcExisting[] }): ItemPlan[] {
|
|
const out: ItemPlan[] = [];
|
|
const one = (kind: ItemPlan['kind'], id: string, attrs: Record<string, unknown>, locs: Record<string, Record<string, unknown>>, list: GcExisting[]) => {
|
|
const cur = list.find(x => x.attributes.vendorIdentifier === id);
|
|
const locales: LocPlan[] = Object.entries(locs).map(([locale, want]) => {
|
|
const l = cur?.localizations.find(x => x.attributes.locale === locale);
|
|
const changed = changedFields(l?.attributes, want);
|
|
return { locale, action: !l ? 'create' : changed.length ? 'update' : 'keep', id: l?.id, attributes: want, changed: l ? changed : Object.keys(want) };
|
|
});
|
|
const changed = changedFields(cur?.attributes, attrs);
|
|
out.push({ kind, id, action: !cur ? 'create' : changed.length ? 'update' : 'keep', storeId: cur?.id, attributes: attrs, changed: cur ? changed : Object.keys(attrs), locales });
|
|
};
|
|
for (const l of (g.leaderboards ?? []).filter(x => onStore(x, 'apple'))) {
|
|
const locs: Record<string, Record<string, unknown>> = {};
|
|
for (const [k, v] of Object.entries(l.locales)) {
|
|
const loc = appleLocale(languages, k);
|
|
if (loc) locs[loc] = { name: v.name, ...(v.suffix ? { formatterSuffix: v.suffix } : {}) };
|
|
}
|
|
one('leaderboard', l.id, gcLeaderboardAttrs(l), locs, have.leaderboards);
|
|
}
|
|
for (const a of (g.achievements ?? []).filter(x => onStore(x, 'apple'))) {
|
|
const locs: Record<string, Record<string, unknown>> = {};
|
|
for (const [k, v] of Object.entries(a.locales)) {
|
|
const loc = appleLocale(languages, k);
|
|
if (loc) locs[loc] = { name: v.name, beforeEarnedDescription: v.description, afterEarnedDescription: v.earned ?? v.description };
|
|
}
|
|
one('achievement', a.id, gcAchievementAttrs(a), locs, have.achievements);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
// Play Games Services Configuration API bodies
|
|
|
|
type Bundle = { kind: 'gamesConfiguration#localizedStringBundle'; translations: { kind: 'gamesConfiguration#localizedString'; locale: string; value: string }[] };
|
|
|
|
function bundle(languages: Language[], locales: Record<string, unknown>, pick: (v: never) => string | undefined): Bundle {
|
|
const translations: Bundle['translations'] = [];
|
|
for (const [k, v] of Object.entries(locales)) {
|
|
const l = languages.find(x => x.id === k);
|
|
const codes = l?.play === undefined ? [] : Array.isArray(l.play) ? l.play : [l.play];
|
|
const value = pick(v as never);
|
|
if (value) for (const locale of codes) translations.push({ kind: 'gamesConfiguration#localizedString', locale, value });
|
|
}
|
|
return { kind: 'gamesConfiguration#localizedStringBundle', translations };
|
|
}
|
|
|
|
export function playAchievementBody(a: GameAchievement, languages: Language[]): Record<string, unknown> {
|
|
return {
|
|
kind: 'gamesConfiguration#achievementConfiguration',
|
|
achievementType: a.steps ? 'INCREMENTAL' : 'STANDARD', initialState: a.hidden ? 'HIDDEN' : 'REVEALED', ...(a.steps ? { stepsToUnlock: a.steps } : {}),
|
|
draft: {
|
|
kind: 'gamesConfiguration#achievementConfigurationDetail',
|
|
name: bundle(languages, a.locales, (v: { name: string }) => v.name),
|
|
description: bundle(languages, a.locales, (v: { description: string }) => v.description),
|
|
pointValue: a.points,
|
|
},
|
|
};
|
|
}
|
|
|
|
function playScoreFormat(f: GcFormat | undefined): Record<string, unknown> {
|
|
const fmt = f ?? 'INTEGER';
|
|
if (fmt.startsWith('ELAPSED_TIME')) return { numberFormatType: 'TIME_DURATION' };
|
|
if (fmt.startsWith('MONEY_')) {
|
|
const cur = { POUND: 'GBP', DOLLAR: 'USD', EURO: 'EUR', FRANC: 'CHF', KRONER: 'DKK', YEN: 'JPY' }[fmt.replace(/^MONEY_|_DECIMAL$/g, '')] ?? 'USD';
|
|
return { numberFormatType: 'CURRENCY', currencyCode: cur };
|
|
}
|
|
const m = /DECIMAL_POINT_(\d)_PLACE/.exec(fmt);
|
|
return { numberFormatType: 'NUMERIC', numDecimalPlaces: m ? Number(m[1]) : 0 };
|
|
}
|
|
|
|
export function playLeaderboardBody(l: GameLeaderboard, languages: Language[]): Record<string, unknown> {
|
|
const suffix = Object.values(l.locales).some(v => v.suffix) ? bundle(languages, l.locales, (v: { suffix?: string }) => v.suffix) : undefined;
|
|
return {
|
|
kind: 'gamesConfiguration#leaderboardConfiguration',
|
|
scoreOrder: l.sort === 'low' ? 'SMALLER_IS_BETTER' : 'LARGER_IS_BETTER',
|
|
...(l.min !== undefined ? { scoreMin: String(l.min) } : {}), ...(l.max !== undefined ? { scoreMax: String(l.max) } : {}),
|
|
draft: {
|
|
kind: 'gamesConfiguration#leaderboardConfigurationDetail',
|
|
name: bundle(languages, l.locales, (v: { name: string }) => v.name),
|
|
scoreFormat: { ...playScoreFormat(l.format), ...(suffix ? { suffix: { other: suffix } } : {}) },
|
|
},
|
|
};
|
|
}
|
|
|
|
export interface PlayExisting { id: string; draft?: { name?: Bundle }; [k: string]: unknown }
|
|
|
|
const defaultName = (x: PlayExisting, locale: string): string | undefined => x.draft?.name?.translations.find(t => t.locale === locale)?.value;
|
|
|
|
/** Comparable part of a Play configuration (what we send, without ids / tokens / published / icon / sortRank). */
|
|
function comparable(body: Record<string, unknown>, have: PlayExisting | undefined): Record<string, unknown> {
|
|
if (!have) return {};
|
|
const draft = (have.draft ?? {}) as Record<string, unknown>;
|
|
const want = body.draft as Record<string, unknown>;
|
|
const out: Record<string, unknown> = {};
|
|
for (const k of Object.keys(body)) if (k !== 'draft') out[k] = have[k];
|
|
out.draft = Object.fromEntries(Object.keys(want).map(k => [k, draft[k]]));
|
|
return out;
|
|
}
|
|
|
|
/** Play plan: matched by playId, else by the name in the default language (Play ids are generated). Update = PUT of
|
|
* the whole configuration (Google's update replaces it); the existing icon / sort rank are kept in the body. */
|
|
export function planPlayGames(g: GamesConfig, languages: Language[], defaultLocale: string, have: { leaderboards: PlayExisting[]; achievements: PlayExisting[] }): ItemPlan[] {
|
|
const out: ItemPlan[] = [];
|
|
const one = (kind: ItemPlan['kind'], item: GameLeaderboard | GameAchievement, body: Record<string, unknown>, list: PlayExisting[]) => {
|
|
const name = (body.draft as { name: Bundle }).name.translations.find(t => t.locale === defaultLocale)?.value;
|
|
const cur = item.playId ? list.find(x => x.id === item.playId) : list.find(x => name !== undefined && defaultName(x, defaultLocale) === name);
|
|
const changed = cur ? changedFields(comparable(body, cur), body).flatMap(k => (k === 'draft' ? changedFields(comparable(body, cur).draft as Record<string, unknown>, body.draft as Record<string, unknown>).map(d => `draft.${d}`) : [k])) : Object.keys(body);
|
|
if (cur) {
|
|
// keep what Play has that we do not manage (icon, sort rank)
|
|
const d = cur.draft as Record<string, unknown> | undefined;
|
|
body = { ...body, id: cur.id, draft: { ...(d?.iconUrl ? { iconUrl: d.iconUrl } : {}), ...(d?.sortRank !== undefined ? { sortRank: d.sortRank } : {}), ...(body.draft as object) } };
|
|
}
|
|
out.push({ kind, id: item.id, action: !cur ? 'create' : changed.length ? 'update' : 'keep', storeId: cur?.id, attributes: body, changed, locales: [] });
|
|
};
|
|
for (const l of (g.leaderboards ?? []).filter(x => onStore(x, 'play'))) one('leaderboard', l, playLeaderboardBody(l, languages), have.leaderboards);
|
|
for (const a of (g.achievements ?? []).filter(x => onStore(x, 'play'))) one('achievement', a, playAchievementBody(a, languages), have.achievements);
|
|
return out;
|
|
}
|
|
|
|
/** Dry-plan rows (cli/lib/dry.ts) of a plan. */
|
|
export function planRows(plan: ItemPlan[]): { item: string; action: string; detail?: string }[] {
|
|
const rows: { item: string; action: string; detail?: string }[] = [];
|
|
for (const p of plan) {
|
|
rows.push({ item: `${p.kind} ${p.id}`, action: p.action, detail: p.action === 'keep' ? undefined : p.changed.join(', ') });
|
|
for (const l of p.locales) rows.push({ item: `${p.kind} ${p.id} ${l.locale}`, action: l.action, detail: l.action === 'keep' ? undefined : l.changed.map(k => `${k}=${JSON.stringify(l.attributes[k])}`).join(', ') });
|
|
}
|
|
return rows;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------ project checks
|
|
|
|
export interface Finding { level: 'error' | 'warn' | 'ok'; id: string; msg: string; fix?: string }
|
|
|
|
const SKIP = new Set(['node_modules', '.git', 'build', 'Pods', 'DerivedData', '.gradle', 'intermediates', 'generated', '.storebound']);
|
|
|
|
function walk(dir: string, depth: number, pick: (f: string) => boolean, out: string[] = []): string[] {
|
|
let names: string[] = [];
|
|
try { names = readdirSync(dir); } catch { return out; }
|
|
for (const n of names) {
|
|
if (SKIP.has(n) || n.startsWith('.')) continue;
|
|
const f = join(dir, n);
|
|
let dirp = false;
|
|
try { dirp = statSync(f).isDirectory(); } catch { continue; }
|
|
if (dirp) { if (depth > 0) walk(f, depth - 1, pick, out); } else if (pick(f)) out.push(f);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
export interface PgsProject {
|
|
/** Gradle files that use play-services-games(-v2). */
|
|
gradle: string[];
|
|
/** Manifest meta-data com.google.android.gms.games.APP_ID: the raw value (literal or @string/name) and where. */
|
|
manifest: { file: string; value: string } | null;
|
|
/** The resolved project id (digits) and the resource file it came from. */
|
|
appId: { value: string; file: string } | null;
|
|
}
|
|
|
|
/** Reads the Android project for Play Games Services: the Gradle dependency, the manifest meta-data and the string
|
|
* resource it points at (res/values/games-ids.xml or strings.xml). */
|
|
export function readPgsProject(root: string): PgsProject {
|
|
const files = walk(root, 7, f => /\.gradle(\.kts)?$|AndroidManifest\.xml$|[\\/]res[\\/]values[^\\/]*[\\/][^\\/]+\.xml$/.test(f));
|
|
const rel = (f: string) => relative(root, f);
|
|
const gradle = files.filter(f => /\.gradle(\.kts)?$/.test(f) && /play-services-games(-v2)?\b|games-v2/.test(readFileSync(f, 'utf8'))).map(rel);
|
|
let manifest: PgsProject['manifest'] = null;
|
|
for (const f of files.filter(x => x.endsWith('AndroidManifest.xml'))) {
|
|
const t = readFileSync(f, 'utf8');
|
|
const m = /<meta-data[^>]*android:name\s*=\s*"com\.google\.android\.gms\.games\.APP_ID"[^>]*android:value\s*=\s*"([^"]+)"|<meta-data[^>]*android:value\s*=\s*"([^"]+)"[^>]*android:name\s*=\s*"com\.google\.android\.gms\.games\.APP_ID"/.exec(t);
|
|
if (m) { manifest = { file: rel(f), value: (m[1] ?? m[2])!.trim() }; break; }
|
|
}
|
|
let appId: PgsProject['appId'] = null;
|
|
const literal = manifest?.value.replace(/^\\ ?/, '').trim();
|
|
if (literal && /^\d+$/.test(literal)) appId = { value: literal, file: manifest!.file };
|
|
else {
|
|
const names = manifest && /^@string\//.test(manifest.value) ? [manifest.value.slice(8)] : ['game_services_project_id', 'app_id', 'games_APP_ID'];
|
|
for (const f of files.filter(x => /[\\/]res[\\/]values[\\/][^\\/]+\.xml$/.test(x))) {
|
|
const t = readFileSync(f, 'utf8');
|
|
for (const n of names) {
|
|
const m = new RegExp(`<string[^>]*name\\s*=\\s*"${n}"[^>]*>\\s*([^<]*?)\\s*</string>`).exec(t);
|
|
if (m && /^\d+$/.test(m[1]!)) { appId = { value: m[1]!, file: rel(f) }; break; }
|
|
}
|
|
if (appId) break;
|
|
}
|
|
}
|
|
return { gradle, manifest, appId };
|
|
}
|
|
|
|
/** PGS project checks: the dependency, the manifest meta-data, the resource and the config's id. */
|
|
export function pgsFindings(config: Pick<ShipConfig, 'games'>, p: PgsProject, hasAndroid = true): Finding[] {
|
|
const out: Finding[] = [];
|
|
const want = config.games?.playGames?.appId;
|
|
if (!hasAndroid) return out;
|
|
if (!p.gradle.length && !usesPlayGames(config)) return out;
|
|
if (p.gradle.length && !usesPlayGames(config))
|
|
out.push({ level: 'warn', id: 'pgs.config', msg: `the Android code uses Play Games Services (${p.gradle[0]}) but the config has no games.playGames`, fix: 'add games: { playGames: { appId: "<project id>" } } so storebound checks and syncs it' });
|
|
if (usesPlayGames(config) && !p.gradle.length)
|
|
out.push({ level: 'warn', id: 'pgs.gradle', msg: 'games.playGames is set but no Gradle file uses com.google.android.gms:play-services-games-v2', fix: 'add implementation "com.google.android.gms:play-services-games-v2:<version>" to the app module' });
|
|
if (!p.manifest) out.push({ level: 'error', id: 'pgs.manifest', msg: 'no <meta-data android:name="com.google.android.gms.games.APP_ID"> in AndroidManifest.xml: sign-in fails at runtime', fix: 'add <meta-data android:name="com.google.android.gms.games.APP_ID" android:value="@string/game_services_project_id"/> inside <application>' });
|
|
else if (!p.appId) out.push({ level: 'error', id: 'pgs.app-id', msg: `the manifest's APP_ID (${p.manifest.value}) points at no string resource with the project id`, fix: `add res/values/games-ids.xml from ${consoleLink('play.games-services', '> Get resources')}` });
|
|
else if (want && p.appId.value !== String(want)) out.push({ level: 'error', id: 'pgs.app-id', msg: `games_APP_ID ${p.appId.value} (${p.appId.file}) differs from games.playGames.appId ${want}`, fix: `use the resources of the games project linked to this app: ${consoleLink('play.games-services')}` });
|
|
else out.push({ level: 'ok', id: 'pgs.app-id', msg: `games_APP_ID ${p.appId.value} (${p.appId.file})${want ? ' matches the config' : ''}` });
|
|
if (p.appId && !want) out.push({ level: 'warn', id: 'pgs.config-id', msg: `games.playGames.appId is not set (the project has ${p.appId.value})`, fix: `set games.playGames.appId: "${p.appId.value}"` });
|
|
return out;
|
|
}
|
|
|
|
/** Game Center project checks: the entitlement in the iOS project (and that CODE_SIGN_ENTITLEMENTS references it). */
|
|
export function gcFindings(config: Pick<ShipConfig, 'games'>, ents: { file: string; caps: { cap: string }[]; referenced: boolean | null }[] | null): Finding[] {
|
|
if (!ents) return [];
|
|
const has = ents.filter(e => e.caps.some(c => c.cap === 'GAME_CENTER'));
|
|
if (!usesGameCenter(config)) return has.length ? [{ level: 'warn', id: 'gc.config', msg: `${has[0]!.file} has com.apple.developer.game-center but games.gameCenter is not true`, fix: 'set games: { gameCenter: true } so signing ensure and apple game-center keep the store in step' }] : [];
|
|
if (!has.length) return [{ level: 'error', id: 'gc.entitlement', msg: 'games.gameCenter is true but no .entitlements file has com.apple.developer.game-center', fix: 'Xcode > the app target > Signing & Capabilities > + Game Center (adds the key and CODE_SIGN_ENTITLEMENTS)' }];
|
|
if (has.every(e => e.referenced === false)) return [{ level: 'error', id: 'gc.entitlement', msg: `${has[0]!.file} has the Game Center key but no CODE_SIGN_ENTITLEMENTS points at it`, fix: 'set CODE_SIGN_ENTITLEMENTS of the app target to that file' }];
|
|
return [{ level: 'ok', id: 'gc.entitlement', msg: `com.apple.developer.game-center in ${has[0]!.file}` }];
|
|
}
|
|
|
|
/** Declarations reminders: a platform player id is a User ID on both stores. */
|
|
export function gamesPrivacyFindings(config: Pick<ShipConfig, 'games' | 'dataSafety' | 'appPrivacy'>): Finding[] {
|
|
const out: Finding[] = [];
|
|
if (!usesGameCenter(config) && !usesPlayGames(config)) return out;
|
|
const ds = (config.dataSafety as { data?: Record<string, unknown> } | undefined)?.data;
|
|
if (usesPlayGames(config) && ds && !ds.PSL_USER_ACCOUNT)
|
|
out.push({ level: 'warn', id: 'games.data-safety', msg: 'Play Games Services gives the game a player id: Data safety > Personal info > User IDs (PSL_USER_ACCOUNT) is not declared', fix: 'add PSL_USER_ACCOUNT to dataSafety.data (collected, app functionality), store-declarations skill' });
|
|
const types = (config.appPrivacy as { types?: Record<string, unknown> } | undefined)?.types;
|
|
if (usesGameCenter(config) && types && !types.USER_ID)
|
|
out.push({ level: 'warn', id: 'games.app-privacy', msg: 'Game Center gives the game a player id: App Privacy > Identifiers > User ID (USER_ID) is not declared', fix: 'add USER_ID (App Functionality, linked to the user) to appPrivacy.types, store-declarations skill' });
|
|
return out;
|
|
}
|
|
|
|
export const hasAndroidProject = (root: string): boolean => existsSync(join(root, 'android')) || walk(root, 3, f => f.endsWith('AndroidManifest.xml')).length > 0;
|