安卓：编译9补丁文件要在绘制文件夹以外的使用呢？ [英] Android: compiling 9-patch files to be used outside of the drawable folder?

问题描述

我有一个需要从可绘制文件夹的外部加载9补丁文件。这是为了让我的应用程序可以从服务器下载新的外观，例如。我们已经发现，储存在可提拉夹9补丁图像时的apk由编译。从资产的文件夹中读取的完全相同的文件不具有的9补丁块。使得.apk文件的这样的行为被编译源9补丁文件在绘制文件夹，而不是在资产目录。

I have a need to load 9-patch files from outside of the drawable folder. This is so that my application can download new skins from a server, for example. I have discovered that a 9-patch image stored in the drawable folder is compiled when the .apk is made. The exact same file read from the assets folder does not have the 9-patch chunk. Thus the act of making the .apk is compiling the source 9-patch files in the drawable folder, but not in the assets directory.

我如何编译一个9补丁文件我自己，让我可以在资产目录中安装呢？是否有一个（批）工具将源转换为编译版本与9补丁块？我真的，真的很喜欢不必使用Eclipse / Ant来构建一个.apk文件，然后挑选它拆开来提取编译9补丁文件，如果在所有可能的。

How can I compile a 9-patch file myself, so that I can install it in the assets directory? Is there a (batch) tool to convert the source to the compiled version with the 9-patch chunk? I'd really, really like not having to use Eclipse/Ant to build an .apk and then pick it apart to extract the compiled 9-patch file if at all possible.

现在我只是希望能够从资产目录中读取（例如，有每肌肤子目录），以保持它的简单。下一步是编译源图像中的9-补丁添加块。从那以后，我就担心下载的飞行到/ data文件夹 - 如果我不能编译9补丁文件，然后有一个在添加服务器端的努力没有多大意义。

For now I just want to be able to read from the assets directory (for example, have a sub directory per skin) to keep it simple. The next step is to compile the source image to add in the 9-patch chunk. After that I'll worry about downloading on the fly to the /data folder - if I can't compile the 9-patch file then there's little point in adding server side effort.

推荐答案

有没有简单的方法来AFAIK做到这一点。 9补丁编译是由AAPT完成，非常简单：它摒弃了黑色边框和连接codeS的一个PNG块里面的内容。这将是相当琐碎给你写，做类似的工具。请注意，您甚至不需要使用相同的格式。如果你看一下在文档的各种NinePatch的API，你会看到，你可以提交自己的块（这EN codeS拉伸区域和填充。）一大块字节[]数组在此说明的结构

There is no simple way to do this afaik. 9-patch compilation is done by aapt and is rather simple: it discards the black borders and encodes their content inside a PNG chunk. It would be fairly trivial for you to write a tool that does something similar. Note that you don't even need to use the same format. If you look at the various NinePatch APIs in the doc, you will see that you can submit your own "chunk" (which encodes the stretch regions and padding.) The structure of a chunk byte[] array is explained here:

/**
 * This chunk specifies how to split an image into segments for
 * scaling.
 *
 * There are J horizontal and K vertical segments.  These segments divide
 * the image into J*K regions as follows (where J=4 and K=3):
 *
 *      F0   S0    F1     S1
 *   +-----+----+------+-------+
 * S2|  0  |  1 |  2   |   3   |
 *   +-----+----+------+-------+
 *   |     |    |      |       |
 *   |     |    |      |       |
 * F2|  4  |  5 |  6   |   7   |
 *   |     |    |      |       |
 *   |     |    |      |       |
 *   +-----+----+------+-------+
 * S3|  8  |  9 |  10  |   11  |
 *   +-----+----+------+-------+
 *
 * Each horizontal and vertical segment is considered to by either
 * stretchable (marked by the Sx labels) or fixed (marked by the Fy
 * labels), in the horizontal or vertical axis, respectively. In the
 * above example, the first is horizontal segment (F0) is fixed, the
 * next is stretchable and then they continue to alternate. Note that
 * the segment list for each axis can begin or end with a stretchable
 * or fixed segment.
 *
 * The relative sizes of the stretchy segments indicates the relative
 * amount of stretchiness of the regions bordered by the segments.  For
 * example, regions 3, 7 and 11 above will take up more horizontal space
 * than regions 1, 5 and 9 since the horizontal segment associated with
 * the first set of regions is larger than the other set of regions.  The
 * ratios of the amount of horizontal (or vertical) space taken by any
 * two stretchable slices is exactly the ratio of their corresponding
 * segment lengths.
 *
 * xDivs and yDivs point to arrays of horizontal and vertical pixel
 * indices.  The first pair of Divs (in either array) indicate the
 * starting and ending points of the first stretchable segment in that
 * axis. The next pair specifies the next stretchable segment, etc. So
 * in the above example xDiv[0] and xDiv[1] specify the horizontal
 * coordinates for the regions labeled 1, 5 and 9.  xDiv[2] and
 * xDiv[3] specify the coordinates for regions 3, 7 and 11. Note that
 * the leftmost slices always start at x=0 and the rightmost slices
 * always end at the end of the image. So, for example, the regions 0,
 * 4 and 8 (which are fixed along the X axis) start at x value 0 and
 * go to xDiv[0] and slices 2, 6 and 10 start at xDiv[1] and end at
 * xDiv[2].
 *
 * The array pointed to by the colors field lists contains hints for
 * each of the regions.  They are ordered according left-to-right and
 * top-to-bottom as indicated above. For each segment that is a solid
 * color the array entry will contain that color value; otherwise it
 * will contain NO_COLOR.  Segments that are completely transparent
 * will always have the value TRANSPARENT_COLOR.
 *
 * The PNG chunk type is "npTc".
 */
struct Res_png_9patch
{
    Res_png_9patch() : wasDeserialized(false), xDivs(NULL),
                       yDivs(NULL), colors(NULL) { }

    int8_t wasDeserialized;
    int8_t numXDivs;
    int8_t numYDivs;
    int8_t numColors;

    // These tell where the next section of a patch starts.
    // For example, the first patch includes the pixels from
    // 0 to xDivs[0]-1 and the second patch includes the pixels
    // from xDivs[0] to xDivs[1]-1.
    // Note: allocation/free of these pointers is left to the caller.
    int32_t* xDivs;
    int32_t* yDivs;

    int32_t paddingLeft, paddingRight;
    int32_t paddingTop, paddingBottom;

    enum {
        // The 9 patch segment is not a solid color.
        NO_COLOR = 0x00000001,

        // The 9 patch segment is completely transparent.
        TRANSPARENT_COLOR = 0x00000000
    };
    // Note: allocation/free of this pointer is left to the caller.
    uint32_t* colors;

    // Convert data from device representation to PNG file representation.
    void deviceToFile();
    // Convert data from PNG file representation to device representation.
    void fileToDevice();
    // Serialize/Marshall the patch data into a newly malloc-ed block
    void* serialize();
    // Serialize/Marshall the patch data
    void serialize(void* outData);
    // Deserialize/Unmarshall the patch data
    static Res_png_9patch* deserialize(const void* data);
    // Compute the size of the serialized data structure
    size_t serializedSize();
};

这篇关于安卓：编译9补丁文件要在绘制文件夹以外的使用呢？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！