Tool to batch convert android resource bitmaps to

Question

I need to post-release support different display densities on Android

During development drawable-hdpi has grown to 160 png (like 20 of them 9 patch) assets

I now need to convert all those bitmaps to mdpi, ldpi (layouts and drawables XML are already fine, to avoid raising OOM on LayoutInflater

Is there any tool suitable to convert all those bitmaps in batch ?

Answer 1

I created a tool that can batch reisze images of different types (png, jpg, gif, svg, psd, 9-patch..). Uses hiqh quality scaling algorithms and supports certain lossless compression tools like pngcrush. There is a GUI and command line ui.

https://github.com/patrickfav/density-converter

In your case you would set the source scale factor to 2 and check "skip upscaling" also set the platform to Android.

Answer 2

Look at this:

just upload and get back in all pixels.

http://romannurik.github.io/AndroidAssetStudio/nine-patches.html

Answer 3

Android Asset Studio may be helpful, although it is not exactly what you asked for.

Answer 4

Final-Android-Resizer did the job for me and was simple to use but had all the options I needed: https://github.com/asystat/Final-Android-Resizer

Answer 5

I would recommend Respresso which is an online tool capable to create all the required sizes (from xxxhdpi to mdpi) for Android (and for iOS also).

You have to upload the images (in batch) then sync the resized/converted ones directly to your project using the tool's gradle plugin.

Please note that it will require you to create an account (for free) as it will sync any change to your project directly. (So you can add/change an image (svg, pdf, png, jpeg) and it will automatically add/change the converted files in your project at the next build.)

Currently it does not support 9 patch images.

(I should note that I worked on the tool and I think it is really cool and I use it personally. I have no shares in it.)

Answer 6

Here is a simple script to create lower-resolution Android drawables from higher-resolution ones.

For example, given a batch of -xhdpi images, it can generate -hdpi and -mdpi images.

With this script, it’s possible to export only highest-resolution artwork from authoring tools and then create the lower-resolution versions with a few batch commands.

Script usage:

drawable_convert.py -d res/drawable-mdpi -d res/drawable-hdpi res/drawable-xhdpi-v14/*.png

This will take every png file from xhdpi and place lower-resolution versions into mdpi and hdpi folders.

http://kmansoft.com/2012/05/23/scale-android-drawables-with-a-script/
original script, https://gist.github.com/2771791

---

Script itself, to avoid dependency on github gist/original blogpost.
name drawable_convert.py

#!/usr/bin/python

import sys
import argparse
import os
import re

'''
A simple script to create lower-resolution Android drawables from higher-resolution ones.

For example, given a batch of -xhdpi images, you can generate -hdpi and -mdpi images.

This makes it possible to only export highest-resolution artwork from image authoring tools, and
automate the rest.

Usage:

   drawable_convert.py -d res/drawable-mdpi -d res/drawable-hdpi res/drawable-xhdpi-v14/select*.png

   ... will take select*.png from xhdpi and place versions into mdpi and hdpi folders.

   Correct resize ratios are computed based on resource directory names.

   Actual scaling is done by ImageMagick's convert command.
'''

class Converter:
    def __init__(self, dstList):
        print u'Dst list: {0}'.format(dstList)
        self.mDstList = dstList

    def convert(self, src):
        for dstpath in self.mDstList:
            (srcpath, srcname) = os.path.split(src)
            dst = os.path.join(dstpath, srcname)
            self.convertOne(src, dst)

    def convertOne(self, src, dst):
        print u'\n*****\n{0} to {1}\n*****\n'.format(src, dst)
        '''
        Determine relative density
        '''
        srcDpi = self.getDpi(src)
        dstDpi = self.getDpi(dst)

        if srcDpi < dstDpi:
            print u'NOT converting from {0}dpi to {1}dpi'.format(srcDpi, dstDpi)
        else:
            factor = dstDpi*100/srcDpi
            print u'Converting from {0}dpi to {1}dpi, {2}%'.format(srcDpi, dstDpi, factor)
            cmd = u'convert -verbose "{0}" -resize "{2}%x{2}%" "{1}"'.format(src, dst, factor)
            os.system(cmd)

    def getDpi(self, f):
        p = os.path.dirname(f)
        if re.match('.*drawable.*\\-mdpi.*', p):
            return 160
        elif re.match('.*drawable.*\\-hdpi.*', p):
            return 240
        elif re.match('.*drawable.*\\-xhdpi.*', p):
            return 320
        else:
            raise ValueError(u'Cannot determine densitiy for {0}'.format(p))

if __name__ == "__main__":
    '''
    Parse command line arguments
    '''
    parser = argparse.ArgumentParser(description='Converts drawable resources in Android applications')
    parser.add_argument('-d', dest='DST', action='append', required=True, help='destination directory')
    parser.add_argument('src', nargs='+', help='files to convert (one or more)')
    args = parser.parse_args()

    cv = Converter(args.DST)
    for src in args.src:
        cv.convert(src)


'''


if [ $# -lt 1 ] ; then
    echo "Usage: $0 file_list"
    exit 1
fi

for f in $*
do
    echo "File: ${f}"
    convert -verbose "${f}" -resize "75%x75%" "../drawable-hdpi/${f}"
    convert -verbose "${f}" -resize "50%x50%" "../drawable-mdpi/${f}"
done

'''