Preserve Android plugin CPU value in exports.json for ExportUnityPackage

source/ExportUnityPackage/export_unity_package.py

@@ -1374,6 +1374,55 @@ def set_cpu_for_desktop_platforms(importer_metadata):
           second["settings"] = settings
     return importer_metadata
 
+  @staticmethod
+  def set_cpu_for_android(importer_metadata, cpu_string):
+    """Sets the CPU for Android in the metadata if enabled.
+
+    Args:
+      importer_metadata: Metadata to modify.
+      cpu_string: The desired CPU string value.
+
+    Returns:
+      Modified importer_metadata.
+    """
+    plugin_importer = safe_dict_get_value(
+        importer_metadata, "PluginImporter", default_value={})
+    serialized_version = safe_dict_get_value(
+        plugin_importer, "serializedVersion", default_value=1)
+
+    if serialized_version == 1:
+      platform_data = safe_dict_get_value(plugin_importer, "platformData",
+                                          default_value={})
+      for platform_name, options in platform_data.items():
+        if not safe_dict_get_value(options, "enabled", default_value=0):
+          continue
+        if not cpu_string:
+          continue
+        if platform_name == "Android":
+          settings = options.get("settings", collections.OrderedDict())
+          settings["CPU"] = cpu_string
+          options["settings"] = settings
+    else:
+      platform_data = safe_dict_get_value(plugin_importer, "platformData",
+                                          default_value=[])
+      for entry in platform_data:
+        # Parse the platform name tuple from the "first" dictionary.
+        first, second = Asset.platform_data_get_entry(entry)
+        platform_tuple = list(first.items())[0]
+        if len(platform_tuple) < 2:
+          continue
+        unused_platform_target, platform_name = platform_tuple
+        if not second.get("enabled", 0):
+          continue
+        if not cpu_string:
+          continue
+        settings = safe_dict_get_value(second, "settings",
+                                       default_value=collections.OrderedDict())
+        if platform_name == "Android":
+          settings["CPU"] = cpu_string
+          second["settings"] = settings
+    return importer_metadata
+
   @staticmethod
   def apply_any_platform_selection(importer_metadata):
     """Enable / disable all platforms if the "Any" platform is enabled.
@@ -1799,6 +1848,9 @@ def importer_metadata(self):
         platform_data_options["enabled"] = 1
       importer_metadata = Asset.set_cpu_for_desktop_platforms(
           importer_metadata)
+      if "Android" in platforms and cpu_string != "AnyCPU":
+        importer_metadata = Asset.set_cpu_for_android(
+            importer_metadata, cpu_string)
     else:
       raise ProjectConfigurationError(
           "Unknown importer type %s for package %s, paths %s" % (

source/ExportUnityPackage/export_unity_package_test.py

@@ -1665,6 +1665,39 @@ def test_set_cpu_for_desktop_platforms_serializationv2(self):
         export_unity_package.Asset.set_cpu_for_desktop_platforms(linux_enabled))
     self.assertEqual(expected_metadata, linux_enabled_with_cpu)
 
+  def test_set_cpu_for_android_serializationv1(self):
+    """Set CPU field for the enabled Android platform in v1 metadata format."""
+    android_enabled = copy.deepcopy(
+        export_unity_package.PLUGIN_IMPORTER_METADATA_TEMPLATE)
+    android_enabled["PluginImporter"]["platformData"]["Android"]["enabled"] = 1
+    expected_metadata = copy.deepcopy(android_enabled)
+    expected_metadata["PluginImporter"]["platformData"]["Android"]["settings"][
+        "CPU"] = "ARMv7"
+    android_enabled_with_cpu = (
+        export_unity_package.Asset.set_cpu_for_android(android_enabled, "ARMv7"))
+    self.assertEqual(expected_metadata, android_enabled_with_cpu)
+
+  def test_set_cpu_for_android_serializationv2(self):
+    """Set CPU field for the enabled Android platform in v2 metadata format."""
+    android_enabled = collections.OrderedDict([
+        ("PluginImporter", collections.OrderedDict([
+            ("serializedVersion", 2),
+            ("platformData", [
+                collections.OrderedDict([
+                    ("first", collections.OrderedDict([
+                        ("Android", "Android")])),
+                    ("second", collections.OrderedDict([
+                        ("enabled", 1)]))])
+            ])
+        ]))
+    ])
+    expected_metadata = copy.deepcopy(android_enabled)
+    expected_metadata["PluginImporter"]["platformData"][0]["second"][
+        "settings"] = collections.OrderedDict([("CPU", "ARMv7")])
+    android_enabled_with_cpu = (
+        export_unity_package.Asset.set_cpu_for_android(android_enabled, "ARMv7"))
+    self.assertEqual(expected_metadata, android_enabled_with_cpu)
+
   def test_apply_any_platform_selection_serializationv1(self):
     """Modify v1 importer metadata to enable all platforms."""
     # Enable all platforms.
@@ -2044,6 +2077,19 @@ def test_importer_metadata_android_only(self):
             self.package, {"importer": "PluginImporter",
                            "platforms": ["Android"]}).importer_metadata)
 
+  def test_importer_metadata_android_only_armv7(self):
+    """Create metadata with ARMv7 CPU set."""
+    self.plugin_metadata["PluginImporter"]["platformData"]["Android"][
+        "enabled"] = 1
+    self.plugin_metadata["PluginImporter"]["platformData"]["Android"][
+        "settings"]["CPU"] = "ARMv7"
+    self.assertEqual(
+        self.plugin_metadata,
+        export_unity_package.AssetConfiguration(
+            self.package, {"importer": "PluginImporter",
+                           "platforms": ["Android"],
+                           "cpu": "ARMv7"}).importer_metadata)
+
   def test_importer_metadata_ios_only(self):
     """Create metadata that only targets iOS."""
     self.plugin_metadata["PluginImporter"]["platformData"]["iOS"]["enabled"] = 1