Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8bb10e8f authored by Colin Cross's avatar Colin Cross
Browse files

Add a script to inject values into manifests 

Add a script that can inject a <uses-sdk minSdkVersion=""> into
AndroidManifest.xml files.  This will help with merging
LOCAL_STATIC_ANDROID_LIBRARIES, because ManifestMerger treats
a missing minSdkVersion as minSdkVersion=1 and throws errors
if libraries use a larger minSdkVersion.  It will also help
with cases where an app has a manifest that specifies an old
minSdkVersion, but the build system is compiling the app in
a way that is not compatibile with old devices, for example
using a newer dex format.

Bug: 110167203
Test: m java
Test: build/soong/scripts/manifest_fixer_test.py
Change-Id: I528d71a225feb86464c530e11b223babb0ea9edf
parent 30485c92

java/config/config.go

+2 −0
Original line number Diff line number Diff line
@@ -132,4 +132,6 @@ func init() { 
	}



	hostBinToolVariableWithPrebuilt("Aapt2Cmd", "prebuilts/sdk/tools", "aapt2")



	pctx.SourcePathVariable("ManifestFixerCmd", "build/soong/scripts/manifest_fixer.py")

}

java/config/makevars.go

+2 −0
Original line number Diff line number Diff line
@@ -72,4 +72,6 @@ func makeVarsProvider(ctx android.MakeVarsContext) { 
	ctx.Strict("DEFAULT_JACOCO_EXCLUDE_FILTER", strings.Join(DefaultJacocoExcludeFilter, ","))



	ctx.Strict("EXTRACT_JAR_PACKAGES", "${ExtractJarPackagesCmd}")



	ctx.Strict("MANIFEST_FIXER", "${ManifestFixerCmd}")

}

scripts/manifest_fixer.py

0 → 100755
+180 −0
Original line number Diff line number Diff line 
#!/usr/bin/env python

#

# Copyright (C) 2018 The Android Open Source Project

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#      http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

#

"""A tool for inserting values from the build system into a manifest."""



from __future__ import print_function

import argparse

import sys

from xml.dom import minidom





android_ns = 'http://schemas.android.com/apk/res/android'





def get_children_with_tag(parent, tag_name):

  children = []

  for child in  parent.childNodes:

    if child.nodeType == minidom.Node.ELEMENT_NODE and \

       child.tagName == tag_name:

      children.append(child)

  return children





def parse_args():

  """Parse commandline arguments."""



  parser = argparse.ArgumentParser()

  parser.add_argument('--minSdkVersion', default='', dest='min_sdk_version',

                      help='specify minSdkVersion used by the build system')

  parser.add_argument('input', help='input AndroidManifest.xml file')

  parser.add_argument('output', help='input AndroidManifest.xml file')

  return parser.parse_args()





def parse_manifest(doc):

  """Get the manifest element."""



  manifest = doc.documentElement

  if manifest.tagName != 'manifest':

    raise RuntimeError('expected manifest tag at root')

  return manifest





def ensure_manifest_android_ns(doc):

  """Make sure the manifest tag defines the android namespace."""



  manifest = parse_manifest(doc)



  ns = manifest.getAttributeNodeNS(minidom.XMLNS_NAMESPACE, 'android')

  if ns is None:

    attr = doc.createAttributeNS(minidom.XMLNS_NAMESPACE, 'xmlns:android')

    attr.value = android_ns

    manifest.setAttributeNode(attr)

  elif ns.value != android_ns:

    raise RuntimeError('manifest tag has incorrect android namespace ' +

                       ns.value)





def as_int(s):

  try:

    i = int(s)

  except ValueError:

    return s, False

  return i, True





def compare_version_gt(a, b):

  """Compare two SDK versions.



  Compares a and b, treating codenames like 'Q' as higher

  than numerical versions like '28'.



  Returns True if a > b



  Args:

    a: value to compare

    b: value to compare

  Returns:

    True if a is a higher version than b

  """



  a, a_is_int = as_int(a.upper())

  b, b_is_int = as_int(b.upper())



  if a_is_int == b_is_int:

    # Both are codenames or both are versions, compare directly

    return a > b

  else:

    # One is a codename, the other is not.  Return true if

    # b is an integer version

    return b_is_int





def raise_min_sdk_version(doc, requested):

  """Ensure the manifest contains a <uses-sdk> tag with a minSdkVersion.



  Args:

    doc: The XML document.  May be modified by this function.

    requested: The requested minSdkVersion attribute.

  Raises:

    RuntimeError: invalid manifest

  """



  manifest = parse_manifest(doc)



  # Get or insert the uses-sdk element

  uses_sdk = get_children_with_tag(manifest, 'uses-sdk')

  if len(uses_sdk) > 1:

    raise RuntimeError('found multiple uses-sdk elements')

  elif len(uses_sdk) == 1:

    element = uses_sdk[0]

  else:

    element = doc.createElement('uses-sdk')

    indent = ''

    first = manifest.firstChild

    if first is not None and first.nodeType == minidom.Node.TEXT_NODE:

      text = first.nodeValue

      indent = text[:len(text)-len(text.lstrip())]

    if not indent or indent == '\n':

      indent = '\n    '



    manifest.insertBefore(element, manifest.firstChild)



    # Insert an indent before uses-sdk to line it up with the indentation of the

    # other children of the <manifest> tag.

    manifest.insertBefore(doc.createTextNode(indent), manifest.firstChild)



  # Get or insert the minSdkVersion attribute

  min_attr = element.getAttributeNodeNS(android_ns, 'minSdkVersion')

  if min_attr is None:

    min_attr = doc.createAttributeNS(android_ns, 'android:minSdkVersion')

    min_attr.value = '1'

    element.setAttributeNode(min_attr)



  # Update the value of the minSdkVersion attribute if necessary

  if compare_version_gt(requested, min_attr.value):

    min_attr.value = requested





def write_xml(f, doc):

  f.write('<?xml version="1.0" encoding="utf-8"?>\n')

  for node in doc.childNodes:

    f.write(node.toxml(encoding='utf-8') + '\n')





def main():

  """Program entry point."""

  try:

    args = parse_args()



    doc = minidom.parse(args.input)



    ensure_manifest_android_ns(doc)



    if args.min_sdk_version:

      raise_min_sdk_version(doc, args.min_sdk_version)



    with open(args.output, 'wb') as f:

      write_xml(f, doc)



  # pylint: disable=broad-except

  except Exception as err:

    print('error: ' + str(err), file=sys.stderr)

    sys.exit(-1)



if __name__ == '__main__':

  main()

scripts/manifest_fixer_test.py

0 → 100755
+162 −0
Original line number Diff line number Diff line 
#!/usr/bin/env python

#

# Copyright (C) 2018 The Android Open Source Project

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#      http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

#

"""Unit tests for manifest_fixer_test.py."""



import StringIO

import sys

import unittest

from xml.dom import minidom



import manifest_fixer



sys.dont_write_bytecode = True





class CompareVersionGtTest(unittest.TestCase):

  """Unit tests for compare_version_gt function."""



  def test_sdk(self):

    """Test comparing sdk versions."""

    self.assertTrue(manifest_fixer.compare_version_gt('28', '27'))

    self.assertFalse(manifest_fixer.compare_version_gt('27', '28'))

    self.assertFalse(manifest_fixer.compare_version_gt('28', '28'))



  def test_codename(self):

    """Test comparing codenames."""

    self.assertTrue(manifest_fixer.compare_version_gt('Q', 'P'))

    self.assertFalse(manifest_fixer.compare_version_gt('P', 'Q'))

    self.assertFalse(manifest_fixer.compare_version_gt('Q', 'Q'))



  def test_sdk_codename(self):

    """Test comparing sdk versions with codenames."""

    self.assertTrue(manifest_fixer.compare_version_gt('Q', '28'))

    self.assertFalse(manifest_fixer.compare_version_gt('28', 'Q'))



  def test_compare_numeric(self):

    """Test that numbers are compared in numeric and not lexicographic order."""

    self.assertTrue(manifest_fixer.compare_version_gt('18', '8'))





class RaiseMinSdkVersionTest(unittest.TestCase):

  """Unit tests for raise_min_sdk_version function."""



  def raise_min_sdk_version_test(self, input_manifest, min_sdk_version):

    doc = minidom.parseString(input_manifest)

    manifest_fixer.raise_min_sdk_version(doc, min_sdk_version)

    output = StringIO.StringIO()

    manifest_fixer.write_xml(output, doc)

    return output.getvalue()



  manifest_tmpl = (

      '<?xml version="1.0" encoding="utf-8"?>\n'

      '<manifest xmlns:android="http://schemas.android.com/apk/res/android">\n'

      '%s'

      '</manifest>\n')



  def uses_sdk(self, v, extra=''):

    if extra:

      extra = ' ' + extra

    return '    <uses-sdk android:minSdkVersion="%s"%s/>\n' % (v, extra)



  def test_no_uses_sdk(self):

    """Tests inserting a uses-sdk element into a manifest."""



    manifest_input = self.manifest_tmpl % ''

    expected = self.manifest_tmpl % self.uses_sdk('28')

    output = self.raise_min_sdk_version_test(manifest_input, '28')

    self.assertEqual(output, expected)



  def test_no_min(self):

    """Tests inserting a minSdkVersion attribute into a uses-sdk element."""



    manifest_input = self.manifest_tmpl % '    <uses-sdk extra="foo"/>\n'

    expected = self.manifest_tmpl % self.uses_sdk('28', 'extra="foo"')

    output = self.raise_min_sdk_version_test(manifest_input, '28')

    self.assertEqual(output, expected)



  def test_raise_min(self):

    """Tests inserting a minSdkVersion attribute into a uses-sdk element."""



    manifest_input = self.manifest_tmpl % self.uses_sdk('27')

    expected = self.manifest_tmpl % self.uses_sdk('28')

    output = self.raise_min_sdk_version_test(manifest_input, '28')

    self.assertEqual(output, expected)



  def test_raise(self):

    """Tests raising a minSdkVersion attribute."""



    manifest_input = self.manifest_tmpl % self.uses_sdk('27')

    expected = self.manifest_tmpl % self.uses_sdk('28')

    output = self.raise_min_sdk_version_test(manifest_input, '28')

    self.assertEqual(output, expected)



  def test_no_raise_min(self):

    """Tests a minSdkVersion that doesn't need raising."""



    manifest_input = self.manifest_tmpl % self.uses_sdk('28')

    expected = manifest_input

    output = self.raise_min_sdk_version_test(manifest_input, '27')

    self.assertEqual(output, expected)



  def test_raise_codename(self):

    """Tests raising a minSdkVersion attribute to a codename."""



    manifest_input = self.manifest_tmpl % self.uses_sdk('28')

    expected = self.manifest_tmpl % self.uses_sdk('P')

    output = self.raise_min_sdk_version_test(manifest_input, 'P')

    self.assertEqual(output, expected)



  def test_no_raise_codename(self):

    """Tests a minSdkVersion codename that doesn't need raising."""



    manifest_input = self.manifest_tmpl % self.uses_sdk('P')

    expected = manifest_input

    output = self.raise_min_sdk_version_test(manifest_input, '28')

    self.assertEqual(output, expected)



  def test_extra(self):

    """Tests that extra attributes and elements are maintained."""



    manifest_input = self.manifest_tmpl % (

        '    <!-- comment -->\n'

        '    <uses-sdk android:minSdkVersion="27" extra="foo"/>\n'

        '    <application/>\n')



    expected = self.manifest_tmpl % (

        '    <!-- comment -->\n'

        '    <uses-sdk android:minSdkVersion="28" extra="foo"/>\n'

        '    <application/>\n')



    output = self.raise_min_sdk_version_test(manifest_input, '28')



    self.assertEqual(output, expected)



  def test_indent(self):

    """Tests that an inserted element copies the existing indentation."""



    manifest_input = self.manifest_tmpl % '  <!-- comment -->\n'



    expected = self.manifest_tmpl % (

        '  <uses-sdk android:minSdkVersion="28"/>\n'

        '  <!-- comment -->\n')



    output = self.raise_min_sdk_version_test(manifest_input, '28')



    self.assertEqual(output, expected)



if __name__ == '__main__':

  unittest.main()