572 lines
21 KiB
C#
572 lines
21 KiB
C#
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Xml.Linq;
|
|
using UnityEditor;
|
|
using UnityEditor.AddressableAssets;
|
|
using UnityEngine;
|
|
|
|
public class ChannelBuildTool
|
|
{
|
|
private const string ChannelConfigRoot = "../ChannelConfigs/Android";
|
|
private const string TysdkPlugins = "Packages/tysdk/Plugins/Android";
|
|
private const string TysdkFiles = "Packages/tysdk/Files";
|
|
private const string AssetsPlugins = "Assets/Plugins/Android";
|
|
|
|
private const string AddressablesContentState = "AddressableAssetsData/Android/addressables_content_state.bin";
|
|
private const string AndroidAddressablesContentState = "Assets/AddressableAssetsData/Android/addressables_content_state.bin";
|
|
private const string DefaultProductName = "Fishing Travel";
|
|
private const string EnjoyPayProductName = "Fishing Travel: Hook & Explore";
|
|
private const string ChannelManifestLib = "channel_manifest_lib";
|
|
private const string ChannelGradle = "channel_gradle";
|
|
private const string ChannelMetaName = "com.arkgame.ft.channel";
|
|
private const string EmptyManifest = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<manifest xmlns:android=\"http://schemas.android.com/apk/res/android\" />\n";
|
|
private static readonly XNamespace AndroidNamespace = "http://schemas.android.com/apk/res/android";
|
|
private static readonly XNamespace ToolsNamespace = "http://schemas.android.com/tools";
|
|
|
|
// ==================== Channel Switching ====================
|
|
|
|
public static void SwitchChannel(string channel)
|
|
{
|
|
channel = NormalizeChannelName(channel);
|
|
var cfgDir = Path.Combine(ChannelConfigRoot, channel.ToLowerInvariant());
|
|
|
|
Debug.Log($"[ChannelSwitch] Switching to {channel}...");
|
|
CleanChannelManifestLibBuildArtifacts();
|
|
|
|
// 1. Sync root Android config files
|
|
SyncRootAndroidConfigFiles(channel, cfgDir);
|
|
|
|
// 2. Sync channel SDK adapter Java files to tysdk package
|
|
SyncChannelAdapterFiles(cfgDir);
|
|
|
|
// 3. Sync google-services.json
|
|
SyncGoogleServices(cfgDir);
|
|
|
|
// 4. Sync channel plugin files (.aar, .jar, etc.) to tysdk package
|
|
SyncChannelPluginFiles(cfgDir);
|
|
|
|
// 5. Set Bundle Identifier per channel
|
|
var bundleId = GetBundleId(channel);
|
|
PlayerSettings.SetApplicationIdentifier(BuildTargetGroup.Android, bundleId);
|
|
Debug.Log($"[ChannelSwitch] Bundle Identifier -> {bundleId}");
|
|
|
|
var productName = channel == "EnjoyPay" ? EnjoyPayProductName : DefaultProductName;
|
|
PlayerSettings.productName = productName;
|
|
Debug.Log($"[ChannelSwitch] Product Name -> {productName}");
|
|
|
|
// 6. Set runtime channel
|
|
tysdk.ChannelConfig.SetChannel(channel);
|
|
|
|
// 7. Set Addressables profile and optional channel content state
|
|
SetAddressablesProfile(channel);
|
|
SyncAddressablesContentState(channel, cfgDir);
|
|
|
|
AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
|
|
Debug.Log($"[ChannelSwitch] Done. Channel: {channel}");
|
|
}
|
|
|
|
// ==================== Menu ====================
|
|
|
|
[MenuItem("Tools/Channel/Switch Channel/GooglePlay", false, 10000)]
|
|
public static void Switch_GooglePlay() => SwitchChannelTo("GooglePlay");
|
|
|
|
[MenuItem("Tools/Channel/Switch Channel/Flexion", false, 10001)]
|
|
public static void Switch_Flexion() => SwitchChannelTo("Flexion");
|
|
|
|
[MenuItem("Tools/Channel/Switch Channel/Rustore", false, 10002)]
|
|
public static void Switch_Rustore() => SwitchChannelTo("Rustore");
|
|
|
|
[MenuItem("Tools/Channel/Switch Channel/EnjoyPay", false, 10003)]
|
|
public static void Switch_EnjoyPay() => SwitchChannelTo("EnjoyPay");
|
|
|
|
private static void SwitchChannelTo(string channel)
|
|
{
|
|
RestoreChannelWorkspace(skipOnCi: true);
|
|
SwitchChannel(channel);
|
|
}
|
|
|
|
// ==================== Build ====================
|
|
|
|
private static void BuildAndroidForChannel(string channel, bool debug)
|
|
{
|
|
try
|
|
{
|
|
RestoreChannelWorkspace(skipOnCi: true);
|
|
CleanChannelManifestLibBuildArtifacts();
|
|
SwitchChannel(channel);
|
|
|
|
var fileName = debug ? $"tysdkTest_{channel}_debug.apk" : $"tysdkTest_{channel}.apk";
|
|
var outPath = $"../Bin/{fileName}";
|
|
var buildOptions = debug
|
|
? BuildOptions.Development | BuildOptions.AllowDebugging | BuildOptions.WaitForPlayerConnection
|
|
: BuildOptions.None;
|
|
|
|
var buildPlayerOptions = new BuildPlayerOptions
|
|
{
|
|
scenes = EditorBuildSettings.scenes.Select(x => x.path).ToArray(),
|
|
locationPathName = outPath,
|
|
target = BuildTarget.Android,
|
|
options = buildOptions,
|
|
};
|
|
|
|
Debug.Log($"[ChannelBuild] Building {channel} -> {outPath}");
|
|
var buildReport = BuildPipeline.BuildPlayer(buildPlayerOptions);
|
|
|
|
if (buildReport?.summary.result == UnityEditor.Build.Reporting.BuildResult.Succeeded)
|
|
{
|
|
Debug.Log($"[ChannelBuild] Success: {Path.GetFullPath(outPath)}");
|
|
AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
|
|
}
|
|
else
|
|
{
|
|
Debug.LogError($"[ChannelBuild] Failed: {buildReport?.summary}");
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
RestoreChannelWorkspace(skipOnCi: true);
|
|
AssetDatabase.SaveAssets();
|
|
}
|
|
}
|
|
|
|
[MenuItem("Tools/Channel/Build Android (Channel)/GooglePlay", false, 10100)]
|
|
public static void Build_GooglePlay() => BuildAndroidForChannel("GooglePlay", false);
|
|
|
|
[MenuItem("Tools/Channel/Build Android (Channel)/GooglePlay Debug", false, 10101)]
|
|
public static void Build_GooglePlay_Debug() => BuildAndroidForChannel("GooglePlay", true);
|
|
|
|
[MenuItem("Tools/Channel/Build Android (Channel)/Rustore", false, 10102)]
|
|
public static void Build_Rustore() => BuildAndroidForChannel("Rustore", false);
|
|
|
|
[MenuItem("Tools/Channel/Build Android (Channel)/Rustore Debug", false, 10103)]
|
|
public static void Build_Rustore_Debug() => BuildAndroidForChannel("Rustore", true);
|
|
|
|
[MenuItem("Tools/Channel/Build Android (Channel)/Flexion", false, 10104)]
|
|
public static void Build_Flexion() => BuildAndroidForChannel("Flexion", false);
|
|
|
|
[MenuItem("Tools/Channel/Build Android (Channel)/Flexion Debug", false, 10105)]
|
|
public static void Build_Flexion_Debug() => BuildAndroidForChannel("Flexion", true);
|
|
|
|
[MenuItem("Tools/Channel/Build Android (Channel)/EnjoyPay", false, 10106)]
|
|
public static void Build_EnjoyPay() => BuildAndroidForChannel("EnjoyPay", false);
|
|
|
|
[MenuItem("Tools/Channel/Build Android (Channel)/EnjoyPay Debug", false, 10107)]
|
|
public static void Build_EnjoyPay_Debug() => BuildAndroidForChannel("EnjoyPay", true);
|
|
|
|
[MenuItem("Tools/Channel/Restore Workspace (Git Checkout)", false, 10200)]
|
|
public static void RestoreChannelWorkspaceWithGitCheckoutMenu()
|
|
{
|
|
RestoreChannelWorkspace(skipOnCi: false);
|
|
}
|
|
|
|
private static string NormalizeChannelName(string channel)
|
|
{
|
|
if (string.IsNullOrEmpty(channel))
|
|
return channel;
|
|
|
|
switch (channel.Trim().ToLowerInvariant())
|
|
{
|
|
case "googleplay":
|
|
return "GooglePlay";
|
|
case "flexion":
|
|
return "Flexion";
|
|
case "enjoypay":
|
|
return "EnjoyPay";
|
|
case "rustore":
|
|
return "Rustore";
|
|
default:
|
|
return channel.Trim();
|
|
}
|
|
}
|
|
|
|
private static string GetBundleId(string channel)
|
|
{
|
|
return channel switch
|
|
{
|
|
"Flexion" => "com.arkgame.ft.flexion",
|
|
"EnjoyPay" => "com.arkgame.ft.ep",
|
|
_ => "com.arkgame.ft"
|
|
};
|
|
}
|
|
|
|
private static void RestoreChannelWorkspace(bool skipOnCi)
|
|
{
|
|
if (skipOnCi && IsCiBuild())
|
|
{
|
|
Debug.Log("[ChannelSwitch] Skip git checkout restore on CI.");
|
|
return;
|
|
}
|
|
|
|
RunCommand("git", "checkout -- .");
|
|
RunCommand("git", "clean -fd -- .");
|
|
AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
|
|
Debug.Log("[ChannelSwitch] Workspace restored from git index.");
|
|
}
|
|
|
|
private static bool IsCiBuild()
|
|
{
|
|
return !string.IsNullOrEmpty(System.Environment.GetEnvironmentVariable("JENKINS_URL")) ||
|
|
!string.IsNullOrEmpty(System.Environment.GetEnvironmentVariable("JENKINS_HOME")) ||
|
|
!string.IsNullOrEmpty(System.Environment.GetEnvironmentVariable("BUILD_NUMBER"));
|
|
}
|
|
|
|
private static void RunCommand(string fileName, string arguments)
|
|
{
|
|
var startInfo = new System.Diagnostics.ProcessStartInfo
|
|
{
|
|
FileName = fileName,
|
|
Arguments = arguments,
|
|
UseShellExecute = false,
|
|
RedirectStandardOutput = true,
|
|
RedirectStandardError = true,
|
|
CreateNoWindow = true
|
|
};
|
|
|
|
using (var process = System.Diagnostics.Process.Start(startInfo))
|
|
{
|
|
var output = process.StandardOutput.ReadToEnd();
|
|
var error = process.StandardError.ReadToEnd();
|
|
process.WaitForExit();
|
|
|
|
if (process.ExitCode != 0)
|
|
{
|
|
throw new System.InvalidOperationException($"{fileName} {arguments} failed.\n{output}\n{error}");
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void SyncRootAndroidConfigFiles(string channel, string cfgDir)
|
|
{
|
|
SyncChannelGradleFiles(channel, cfgDir);
|
|
SetMainManifestChannel(channel);
|
|
SyncChannelManifestLib(channel, cfgDir);
|
|
}
|
|
|
|
private static void SyncChannelAdapterFiles(string cfgDir)
|
|
{
|
|
// ChannelAdapterManager, ChannelAdapterBase, ConfigManager and SDKManager
|
|
// are fixed platform files and are not copied per channel.
|
|
foreach (var oldJava in Directory.GetFiles(TysdkPlugins, "*Adapter.java"))
|
|
{
|
|
File.Delete(oldJava);
|
|
}
|
|
|
|
if (!Directory.Exists(cfgDir))
|
|
{
|
|
return;
|
|
}
|
|
|
|
foreach (var javaFile in Directory.GetFiles(cfgDir, "*Adapter.java"))
|
|
{
|
|
var fileName = Path.GetFileName(javaFile);
|
|
var dest = Path.Combine(TysdkPlugins, fileName);
|
|
File.Copy(javaFile, dest, true);
|
|
Debug.Log($"[ChannelSwitch] Adapter: {javaFile} -> {dest}");
|
|
}
|
|
}
|
|
|
|
private static void SyncGoogleServices(string cfgDir)
|
|
{
|
|
var dest = Path.Combine(TysdkFiles, "google-services.json");
|
|
var src = Path.Combine(cfgDir, "Files", "google-services.json");
|
|
if (!File.Exists(src))
|
|
{
|
|
Debug.Log($"[ChannelSwitch] google-services.json not copied. Checked={src}");
|
|
return;
|
|
}
|
|
|
|
var destDir = Path.GetDirectoryName(dest);
|
|
if (!Directory.Exists(destDir)) Directory.CreateDirectory(destDir);
|
|
File.Copy(src, dest, true);
|
|
Debug.Log($"[ChannelSwitch] google-services.json -> {dest}");
|
|
}
|
|
|
|
private static void SyncChannelPluginFiles(string cfgDir)
|
|
{
|
|
var pluginsSrcDir = Path.Combine(cfgDir, "Plugins", "Android");
|
|
if (!Directory.Exists(pluginsSrcDir))
|
|
{
|
|
Debug.Log($"[ChannelSwitch] Plugin directory not found. Checked={pluginsSrcDir}");
|
|
return;
|
|
}
|
|
|
|
foreach (var oldPlugin in Directory.GetFiles(TysdkPlugins, "tuyoosdk_*.aar"))
|
|
{
|
|
File.Delete(oldPlugin);
|
|
}
|
|
|
|
foreach (var pluginFile in Directory.GetFiles(pluginsSrcDir))
|
|
{
|
|
if (pluginFile.EndsWith(".meta")) continue;
|
|
var fileName = Path.GetFileName(pluginFile);
|
|
var dest = Path.Combine(TysdkPlugins, fileName);
|
|
File.Copy(pluginFile, dest, true);
|
|
Debug.Log($"[ChannelSwitch] Plugin: {pluginFile} -> {dest}");
|
|
}
|
|
}
|
|
|
|
private static void SyncChannelManifestLib(string channel, string cfgDir)
|
|
{
|
|
var dest = Path.Combine(AssetsPlugins, ChannelManifestLib, "src");
|
|
if (channel == "GooglePlay" || !Directory.Exists(cfgDir))
|
|
{
|
|
WriteEmptyChannelManifestLib(dest);
|
|
Debug.Log($"[ChannelSwitch] Manifest lib reset to empty default. Channel={channel}");
|
|
return;
|
|
}
|
|
|
|
var srcManifest = Path.Combine(cfgDir, "AndroidManifest.xml");
|
|
if (!File.Exists(srcManifest))
|
|
{
|
|
throw new FileNotFoundException($"[ChannelSwitch] Channel manifest not found: {srcManifest}");
|
|
}
|
|
|
|
WriteChannelManifestLib(srcManifest, Path.Combine(cfgDir, "res"), dest);
|
|
Debug.Log($"[ChannelSwitch] Manifest: {srcManifest} -> {Path.Combine(dest, "main", "AndroidManifest.xml")}");
|
|
}
|
|
|
|
private static void SyncChannelGradleFiles(string channel, string cfgDir)
|
|
{
|
|
var src = Path.Combine(cfgDir, "Plugins", "Android", "gradle");
|
|
var dest = Path.Combine(AssetsPlugins, ChannelGradle);
|
|
if (Directory.Exists(dest))
|
|
{
|
|
Directory.Delete(dest, true);
|
|
}
|
|
|
|
var destMeta = dest + ".meta";
|
|
if (File.Exists(destMeta))
|
|
{
|
|
File.Delete(destMeta);
|
|
}
|
|
|
|
if (!Directory.Exists(src))
|
|
{
|
|
Debug.Log($"[ChannelSwitch] Gradle increment reset to empty default. Channel={channel}");
|
|
return;
|
|
}
|
|
|
|
CopyDirectoryClean(src, dest);
|
|
Debug.Log($"[ChannelSwitch] Gradle increment: {src} -> {dest}");
|
|
}
|
|
|
|
private static void SetMainManifestChannel(string channel)
|
|
{
|
|
var manifestPath = Path.Combine(AssetsPlugins, "AndroidManifest.xml");
|
|
if (!File.Exists(manifestPath))
|
|
{
|
|
throw new FileNotFoundException($"[ChannelSwitch] Main AndroidManifest not found: {manifestPath}");
|
|
}
|
|
|
|
var doc = XDocument.Load(manifestPath);
|
|
var root = doc.Root;
|
|
var application = root?.Elements().FirstOrDefault(x => x.Name.LocalName == "application");
|
|
if (application == null)
|
|
{
|
|
throw new InvalidDataException($"[ChannelSwitch] Main AndroidManifest application node not found: {manifestPath}");
|
|
}
|
|
|
|
root.SetAttributeValue("package", GetBundleId(channel));
|
|
SetMainManifestChannelMeta(application, channel);
|
|
SetMainManifestBackupRules(application, channel);
|
|
doc.Save(manifestPath);
|
|
AssetDatabase.ImportAsset(manifestPath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
|
|
Debug.Log($"[ChannelSwitch] Main manifest channel -> {channel}");
|
|
}
|
|
|
|
private static void SetMainManifestChannelMeta(XElement application, string channel)
|
|
{
|
|
var channelMeta = application.Elements()
|
|
.FirstOrDefault(x => x.Name.LocalName == "meta-data" &&
|
|
(string)x.Attribute(AndroidNamespace + "name") == ChannelMetaName);
|
|
|
|
if (channelMeta == null)
|
|
{
|
|
channelMeta = new XElement("meta-data",
|
|
new XAttribute(AndroidNamespace + "name", ChannelMetaName));
|
|
application.Add(channelMeta);
|
|
}
|
|
|
|
channelMeta.SetAttributeValue(AndroidNamespace + "name", ChannelMetaName);
|
|
channelMeta.SetAttributeValue(AndroidNamespace + "value", channel);
|
|
}
|
|
|
|
private static void SetMainManifestBackupRules(XElement application, string channel)
|
|
{
|
|
const string fullBackupContent = "android:fullBackupContent";
|
|
var replaceAttr = application.Attribute(ToolsNamespace + "replace");
|
|
var replaceItems = replaceAttr?.Value
|
|
.Split(',')
|
|
.Select(x => x.Trim())
|
|
.Where(x => !string.IsNullOrEmpty(x))
|
|
.ToList() ?? new List<string>();
|
|
|
|
if (channel == "Flexion")
|
|
{
|
|
application.SetAttributeValue(AndroidNamespace + "fullBackupContent", "@xml/flexion_backup_rules");
|
|
if (!replaceItems.Contains(fullBackupContent))
|
|
{
|
|
replaceItems.Add(fullBackupContent);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
application.SetAttributeValue(AndroidNamespace + "fullBackupContent", null);
|
|
replaceItems.RemoveAll(x => x == fullBackupContent);
|
|
}
|
|
|
|
application.SetAttributeValue(ToolsNamespace + "replace",
|
|
replaceItems.Count > 0 ? string.Join(",", replaceItems) : null);
|
|
}
|
|
|
|
private static void WriteEmptyChannelManifestLib(string dest)
|
|
{
|
|
if (Directory.Exists(dest))
|
|
{
|
|
Directory.Delete(dest, true);
|
|
}
|
|
|
|
var manifestDir = Path.Combine(dest, "main");
|
|
Directory.CreateDirectory(manifestDir);
|
|
File.WriteAllText(Path.Combine(manifestDir, "AndroidManifest.xml"), EmptyManifest);
|
|
}
|
|
|
|
private static void CleanChannelManifestLibBuildArtifacts()
|
|
{
|
|
var buildDir = Path.Combine(AssetsPlugins, ChannelManifestLib, "build");
|
|
if (Directory.Exists(buildDir))
|
|
{
|
|
Directory.Delete(buildDir, true);
|
|
}
|
|
|
|
var buildMeta = buildDir + ".meta";
|
|
if (File.Exists(buildMeta))
|
|
{
|
|
File.Delete(buildMeta);
|
|
}
|
|
}
|
|
|
|
private static void WriteChannelManifestLib(string srcManifest, string srcResDir, string dest)
|
|
{
|
|
if (Directory.Exists(dest))
|
|
{
|
|
Directory.Delete(dest, true);
|
|
}
|
|
|
|
var manifestDir = Path.Combine(dest, "main");
|
|
Directory.CreateDirectory(manifestDir);
|
|
File.Copy(srcManifest, Path.Combine(manifestDir, "AndroidManifest.xml"), true);
|
|
|
|
if (Directory.Exists(srcResDir))
|
|
{
|
|
CopyDirectoryClean(srcResDir, Path.Combine(manifestDir, "res"));
|
|
}
|
|
}
|
|
|
|
private static void CopyDirectoryClean(string src, string dest)
|
|
{
|
|
if (Directory.Exists(dest))
|
|
{
|
|
Directory.Delete(dest, true);
|
|
}
|
|
|
|
Directory.CreateDirectory(dest);
|
|
foreach (var srcFile in Directory.GetFiles(src, "*", SearchOption.AllDirectories))
|
|
{
|
|
if (srcFile.EndsWith(".meta")) continue;
|
|
|
|
var relativePath = srcFile.Substring(src.Length).TrimStart(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
|
|
var destFile = Path.Combine(dest, relativePath);
|
|
var destDir = Path.GetDirectoryName(destFile);
|
|
if (!Directory.Exists(destDir)) Directory.CreateDirectory(destDir);
|
|
|
|
File.Copy(srcFile, destFile, true);
|
|
}
|
|
}
|
|
|
|
private static void SetAddressablesProfile(string channel)
|
|
{
|
|
var settings = AddressableAssetSettingsDefaultObject.Settings;
|
|
if (settings == null)
|
|
{
|
|
Debug.LogWarning("[ChannelSwitch] Addressables settings not found.");
|
|
return;
|
|
}
|
|
|
|
var profileName = UsesRustoreAddressablesProfile(channel) ? "arksgameru" : "arksgamecos";
|
|
var profileId = settings.profileSettings.GetProfileId(profileName);
|
|
if (string.IsNullOrEmpty(profileId))
|
|
{
|
|
Debug.LogError($"[ChannelSwitch] Addressables profile not found: {profileName}");
|
|
return;
|
|
}
|
|
|
|
settings.activeProfileId = profileId;
|
|
var remoteLoadPath = settings.RemoteCatalogLoadPath.GetValue(settings);
|
|
var remoteBuildPath = settings.RemoteCatalogBuildPath.GetValue(settings);
|
|
Debug.Log($"[ChannelSwitch] Addressables profile -> {profileName}, profileId={profileId}, Remote.LoadPath={remoteLoadPath}, Remote.BuildPath={remoteBuildPath}");
|
|
}
|
|
|
|
private static void SyncAddressablesContentState(string channel, string cfgDir)
|
|
{
|
|
var src = Path.Combine(cfgDir, AddressablesContentState);
|
|
if (!File.Exists(src) && UsesRustoreAddressablesContentState(channel))
|
|
{
|
|
Debug.Log($"[ChannelSwitch] Channel content state not found, try legacy Rustore content state path. Channel={channel}, checked={src}");
|
|
src = Path.Combine("../ChannelConfigs", AddressablesContentState);
|
|
}
|
|
|
|
if (!File.Exists(src))
|
|
{
|
|
ClearAddressablesContentState(channel);
|
|
Debug.Log($"[ChannelSwitch] Addressables content state not copied. Channel={channel}, checked={src}");
|
|
return;
|
|
}
|
|
|
|
var destDir = Path.GetDirectoryName(AndroidAddressablesContentState);
|
|
if (!Directory.Exists(destDir)) Directory.CreateDirectory(destDir);
|
|
|
|
File.Copy(src, AndroidAddressablesContentState, true);
|
|
Debug.Log($"[ChannelSwitch] Addressables content state: {src} -> {AndroidAddressablesContentState}");
|
|
}
|
|
|
|
private static void ClearAddressablesContentState(string channel)
|
|
{
|
|
if (File.Exists(AndroidAddressablesContentState))
|
|
{
|
|
File.Delete(AndroidAddressablesContentState);
|
|
}
|
|
|
|
var meta = AndroidAddressablesContentState + ".meta";
|
|
if (File.Exists(meta))
|
|
{
|
|
File.Delete(meta);
|
|
}
|
|
|
|
var dir = Path.GetDirectoryName(AndroidAddressablesContentState);
|
|
if (Directory.Exists(dir) && !Directory.EnumerateFileSystemEntries(dir).Any())
|
|
{
|
|
Directory.Delete(dir);
|
|
}
|
|
|
|
var dirMeta = dir + ".meta";
|
|
if (File.Exists(dirMeta) && !Directory.Exists(dir))
|
|
{
|
|
File.Delete(dirMeta);
|
|
}
|
|
|
|
Debug.Log($"[ChannelSwitch] Addressables content state cleared. Channel={channel}");
|
|
}
|
|
|
|
private static bool UsesRustoreAddressablesContentState(string channel)
|
|
{
|
|
return channel == "Rustore" || channel == "EnjoyPay";
|
|
}
|
|
|
|
private static bool UsesRustoreAddressablesProfile(string channel)
|
|
{
|
|
return channel == "Rustore" || channel == "EnjoyPay";
|
|
}
|
|
}
|