Создайте NinePatch/NinePatchDrawable во время выполнения

getNinePatchChunk работает нормально. Он вернул null, потому что вы дали Bitmap "исходный" девятый патч. Нужен "скомпилированный" образ с девятью патчами.

В мире Android существует два типа форматов файлов с девятью патчами («исходный» и «скомпилированный»). В исходной версии вы повсюду добавляете границу прозрачности 1px — когда вы позже скомпилируете свое приложение в .apk, aapt преобразует ваши файлы *.9.png в двоичный формат, который ожидает Android. Именно здесь файл png получает метаданные «фрагмента». (подробнее)

Хорошо, теперь к делу (вы слушаете DJ kanzure).

1. Код клиента, примерно такой:

   InputStream stream = .. //whatever
   Bitmap bitmap = BitmapFactory.decodeStream(stream);
   byte[] chunk = bitmap.getNinePatchChunk();
   boolean result = NinePatch.isNinePatchChunk(chunk);
   NinePatchDrawable patchy = new NinePatchDrawable(bitmap, chunk, new Rect(), null);
   

2. На стороне сервера вам необходимо подготовить изображения. Вы можете использовать компилятор двоичных ресурсов Android. Это автоматизирует часть усилий, связанных с созданием нового проекта Android, просто для компиляции некоторых файлов *.9.png в родной формат Android. Если бы вы делали это вручную, вы бы, по сути, сделали проект и добавили несколько файлов *.9.png («исходные» файлы), скомпилировали все в формат .apk, разархивировали файл .apk, затем нашли файл *. 9.png, и именно его вы отправляете своим клиентам.

Кроме того: я не знаю, знает ли BitmapFactory.decodeStream о фрагменте npTc в этих png-файлах, поэтому он может правильно обрабатывать поток изображения или нет. Существование Bitmap.getNinePatchChunk предполагает, что BitmapFactory может... вы можете поискать его в кодовой базе основной ветки разработки.

В том случае, если он не знает о чанке npTc и ваши образы сильно лажают, то мой ответ немного меняется.

Вместо отправки скомпилированных изображений с девятью патчами клиенту вы пишете быстрое приложение для Android, которое загружает скомпилированные изображения и выдает фрагмент byte[]. Затем вы передаете этот байтовый массив своим клиентам вместе с обычным изображением — без прозрачных границ, не с «исходным» изображением с девятью патчами, не с «скомпилированным» изображением с девятью патчами. Вы можете напрямую использовать фрагмент для создания своего объекта.

Другой альтернативой является использование сериализации объектов для отправки изображений с девятью исправлениями (NinePatch) вашим клиентам, например, с помощью JSON или встроенного сериализатора.

Изменить Если вам действительно нужно создать собственный массив байтов фрагментов, я бы начал с просмотра do_9patch, isNinePatchChunk, Res_png_9patch и Res_png_9patch::serialize() в ResourceTypes.cpp. Также есть самодельный считыватель фрагментов npTc от Дмитрия Скибы. Я не могу публиковать ссылки, поэтому, если кто-то сможет отредактировать мой ответ, это будет здорово.

do_9patch: https://android.googlesource.com/platform/frameworks/base/+/gingerbread/tools/aapt/Images.cpp

isNinePatchChunk: http://netmite.com/android/mydroid/1.6/frameworks/base/core/jni/android/graphics/NinePatch.cpp

struct Res_png_9patch: https://scm.sipfoundry.org/rep/sipX/main/sipXmediaLib/contrib/android/androidBitmap0_headers/frameworks/base/include/utils/ResourceTypes.h

Материал Дмитрия Скибы: http://code.google.com/p/android4me/source/browse/src/android/graphics/Bitmap.java

Если вам нужно создать 9 исправлений на лету, ознакомьтесь с этой сутью, которую я сделал: https://gist.github.com/4391807

Вы передаете ему любое растровое изображение, а затем даете ему заглавные вставки, как в iOS.

Я создаю инструмент для создания NinePatchDrawable из (нескомпилированного) растрового изображения NinePatch. См. https://gist.github.com/knight9999/86bec38071a9e0a781ee.

Вам поможет метод NinePatchDrawable createNinePatchDrawable(Resources res, Bitmap bitmap).

Например,

    ImageView imageView = (ImageView) findViewById(R.id.imageview);
    Bitmap bitmap = loadBitmapAsset("my_nine_patch_image.9.png", this);
    NinePatchDrawable drawable = NinePatchBitmapFactory.createNinePatchDrawable(getResources(), bitmap);
    imageView.setBackground( drawable );

где

public static final Bitmap loadBitmapAsset(String fileName,Context context) {
    final AssetManager assetManager = context.getAssets();
    BufferedInputStream bis = null;
    try {
        bis = new BufferedInputStream(assetManager.open(fileName));
        return BitmapFactory.decodeStream(bis);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            bis.close();
        } catch (Exception e) {

        }
    }
    return null;
}

В этом примере my_nine_patch_image.9.png находится в каталоге ресурсов.

Нет необходимости использовать компилятор двоичных ресурсов Android для подготовки скомпилированных файлов 9patch png, достаточно использовать aapt в android-sdk, командная строка выглядит следующим образом:
aapt.exe c -v -S /path/to/project -C /path/to/destination

Итак, вы в основном хотите создать NinePatchDrawable по запросу, не так ли? Я попробовал следующий код, возможно, он работает для вас:

InputStream in = getResources().openRawResource(R.raw.test);
Drawable d = NinePatchDrawable.createFromStream(in, null);
System.out.println(d.getMinimumHeight() + ":" + d.getMinimumHeight());

Я думаю, это должно сработать. Вам просто нужно изменить первую строку, чтобы получить InputStream из Интернета. Согласно документации, getNinePatchChunk() не предназначен для вызова разработчиками и может сломаться в будущем.

РАБОТАЕТ И ПРОВЕРЕН - СОЗДАНИЕ NINEPATCH

Это моя реализация Android Ninepatch Builder, вы можете создавать NinePatches во время выполнения с помощью этого класса и примеров кода ниже, предоставляя любой Bitmap

public class NinePatchBuilder {
    int width,height;
    Bitmap bitmap;
    Resources resources;
    private ArrayList<Integer> xRegions=new ArrayList<Integer>();
    private ArrayList<Integer> yRegions=new ArrayList<Integer>();
    public NinePatchBuilder(Resources resources,Bitmap bitmap){
        width=bitmap.getWidth();
        height=bitmap.getHeight();
        this.bitmap=bitmap;
        this.resources=resources;
    }
    public NinePatchBuilder(int width, int height){
        this.width=width;
        this.height=height;
    }
    public NinePatchBuilder addXRegion(int x, int width){
        xRegions.add(x);
        xRegions.add(x+width);
        return this;
    }
    public NinePatchBuilder addXRegionPoints(int x1, int x2){
        xRegions.add(x1);
        xRegions.add(x2);
        return this;
    }
    public NinePatchBuilder addXRegion(float xPercent, float widthPercent){
        int xtmp=(int)(xPercent*this.width);
        xRegions.add(xtmp);
        xRegions.add(xtmp+(int)(widthPercent*this.width));
        return this;
    }
    public NinePatchBuilder addXRegionPoints(float x1Percent, float x2Percent){
        xRegions.add((int)(x1Percent*this.width));
        xRegions.add((int)(x2Percent*this.width));
        return this;
    }
    public NinePatchBuilder addXCenteredRegion(int width){
        int x=(int)((this.width-width)/2);
        xRegions.add(x);
        xRegions.add(x+width);
        return this;
    }
    public NinePatchBuilder addXCenteredRegion(float widthPercent){
        int width=(int)(widthPercent*this.width);
        int x=(int)((this.width-width)/2);
        xRegions.add(x);
        xRegions.add(x+width);
        return this;
    }
    public NinePatchBuilder addYRegion(int y, int height){
        yRegions.add(y);
        yRegions.add(y+height);
        return this;
    }
    public NinePatchBuilder addYRegionPoints(int y1, int y2){
        yRegions.add(y1);
        yRegions.add(y2);
        return this;
    }
    public NinePatchBuilder addYRegion(float yPercent, float heightPercent){
        int ytmp=(int)(yPercent*this.height);
        yRegions.add(ytmp);
        yRegions.add(ytmp+(int)(heightPercent*this.height));
        return this;
    }
    public NinePatchBuilder addYRegionPoints(float y1Percent, float y2Percent){
        yRegions.add((int)(y1Percent*this.height));
        yRegions.add((int)(y2Percent*this.height));
        return this;
    }
    public NinePatchBuilder addYCenteredRegion(int height){
        int y=(int)((this.height-height)/2);
        yRegions.add(y);
        yRegions.add(y+height);
        return this;
    }
    public NinePatchBuilder addYCenteredRegion(float heightPercent){
        int height=(int)(heightPercent*this.height);
        int y=(int)((this.height-height)/2);
        yRegions.add(y);
        yRegions.add(y+height);
        return this;
    }
    public byte[] buildChunk(){
        if(xRegions.size()==0){
            xRegions.add(0);
            xRegions.add(width);
        }
        if(yRegions.size()==0){
            yRegions.add(0);
            yRegions.add(height);
        }
        /* example code from a anwser above
        // The 9 patch segment is not a solid color.
        private static final int NO_COLOR = 0x00000001;
        ByteBuffer buffer = ByteBuffer.allocate(56).order(ByteOrder.nativeOrder());
        //was translated
        buffer.put((byte)0x01);
        //divx size
        buffer.put((byte)0x02);
        //divy size
        buffer.put((byte)0x02);
        //color size
        buffer.put(( byte)0x02);

        //skip
        buffer.putInt(0);
        buffer.putInt(0);

        //padding
        buffer.putInt(0);
        buffer.putInt(0);
        buffer.putInt(0);
        buffer.putInt(0);

        //skip 4 bytes
        buffer.putInt(0);

        buffer.putInt(left);
        buffer.putInt(right);
        buffer.putInt(top);
        buffer.putInt(bottom);
        buffer.putInt(NO_COLOR);
        buffer.putInt(NO_COLOR);

        return buffer;*/
        int NO_COLOR = 1;//0x00000001;
        int COLOR_SIZE=9;//could change, may be 2 or 6 or 15 - but has no effect on output 
        int arraySize=1+2+4+1+xRegions.size()+yRegions.size()+COLOR_SIZE;
        ByteBuffer byteBuffer=ByteBuffer.allocate(arraySize * 4).order(ByteOrder.nativeOrder());
        byteBuffer.put((byte) 1);//was translated
        byteBuffer.put((byte) xRegions.size());//divisions x
        byteBuffer.put((byte) yRegions.size());//divisions y
        byteBuffer.put((byte) COLOR_SIZE);//color size

        //skip
        byteBuffer.putInt(0);
        byteBuffer.putInt(0);

        //padding -- always 0 -- left right top bottom
        byteBuffer.putInt(0);
        byteBuffer.putInt(0);
        byteBuffer.putInt(0);
        byteBuffer.putInt(0);

        //skip
        byteBuffer.putInt(0);

        for(int rx:xRegions)
            byteBuffer.putInt(rx); // regions left right left right ...
        for(int ry:yRegions)
            byteBuffer.putInt(ry);// regions top bottom top bottom ...

        for(int i=0;i<COLOR_SIZE;i++)
            byteBuffer.putInt(NO_COLOR);

        return byteBuffer.array();
    }
    public NinePatch buildNinePatch(){
        byte[] chunk=buildChunk();
        if(bitmap!=null)
            return new NinePatch(bitmap,chunk,null);
        return null;
    }
    public NinePatchDrawable build(){
        NinePatch ninePatch=buildNinePatch();
        if(ninePatch!=null)
            return new NinePatchDrawable(resources, ninePatch);
        return null;
    }
}

Теперь мы можем использовать NinePatch Builder для создания NinePatch или NinePatchDrawable или для создания NinePatch Chunk.

Пример:

NinePatchBuilder builder=new NinePatchBuilder(getResources(), bitmap);
NinePatchDrawable drawable=builder.addXCenteredRegion(2).addYCenteredRegion(2).build();

//or add multiple patches

NinePatchBuilder builder=new NinePatchBuilder(getResources(), bitmap);
builder.addXRegion(30,2).addXRegion(50,1).addYRegion(20,4);
byte[] chunk=builder.buildChunk();
NinePatch ninepatch=builder.buildNinePatch();
NinePatchDrawable drawable=builder.build();

//Here if you don't want ninepatch and only want chunk use
NinePatchBuilder builder=new NinePatchBuilder(width, height);
byte[] chunk=builder.addXCenteredRegion(1).addYCenteredRegion(1).buildChunk();

Просто скопируйте и вставьте код класса NinePatchBuilder в файл Java и используйте примеры для создания NinePatch на лету во время выполнения вашего приложения с любым разрешением.

Класс Bitmap предоставляет для этого метод yourbitmap.getNinePatchChunk(). Я никогда не использовал его, но кажется, что это то, что вы ищете.