Question

这是我的代码，虽然编码很粗糙：

public void loadStack(AssetManager manager, String path) {
            String[] list;
            String thePath;
            try {
                list = manager.list(path);
                if (list != null) {
                    for (int i = 0; i < list.length; i++) {
                        try {
                            if (list.length != 0) {
                                if (path.toString() == "") loadStack(manager, list[i]);
                                else {
                                    thePath = path + "/" + list[i];
                                    loadStack(manager, thePath);
                                }
                            }
                            String[] test = manager.list(list[i]);
                            if (test.length != 0) {
                                for (int j = 0; j < test.length; j++) {
                                    byte[] assetBytes = readFromStream(list[i] + "/" + test[j]);
                                    assetStack.push(assetBytes);
                                    totalByteSize += assetBytes.length;
                                    Log.d("Loading", "Stack loads assetBytes of length: " + Integer.toString(assetBytes.length));
                                    // totalStackElementSize = assetStack.size();
                                }
                            }
                            // loadStack(manager, path + "/" + list[i]);
                        }
                        catch (IOException e) {
                            continue;
                        }
                    }
                }
            }
            catch (IOException e1) {
                return;
            }
        }

我仍然在尝试改进代码，而我所缺乏的只是分辨出子目录的相对路径，以及相对路径是加载所需文件的实际路径。

这样，我可以依靠使用递归方法遍历资产文件夹的每个子目录，并仅加载我需要的子目录。

有人能指出我正确的方向吗？或者我在AssetManager文档中遗漏了一些东西？提前致谢。到目前为止，我正在尽我所能。

更新：

改进了我的代码：

public void loadStack(AssetManager manager, String path, int level) {
            try {
                String[] list = manager.list(path);
                if (list != null) {
                    for (int i = 0; i < list.length; i++) {
                        if (level >= 1) loadStack(manager, path + "/" + list[i], level + 1);
                        else if (level == 0) loadStack(manager, list[i], level + 1);
                        else {
                            byte[] byteBuffer = readFromStream(path);
                            assetStack.push(byteBuffer);
                            totalByteSize += byteBuffer.length;
                        }
                    }
                }
            }
            catch (IOException e) {
                Log.e("Loading", "Occurs in AssetLoad.loadStack(AssetManager, String, int), file can't be loaded: " + path);
                throw new RuntimeException("Couldn't load the files correctly.");
            }
        }

我仍在努力改进我的代码。唯一的问题是它倾向于读取我没有添加到assets文件夹的文件夹，或者我之前从未创建过的文件夹。那些导致逻辑错误，我尽可能避免。

Answer 1

这是一个模糊问题的具体答案，但是，它的工作方式相同。

package nttu.edu.activities;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.LinkedList;
import java.util.Queue;

import nttu.edu.R;
import nttu.edu.graphics.Art;
import android.app.Activity;
import android.content.Intent;
import android.content.res.AssetManager;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Handler;
import android.widget.ProgressBar;

public class NewLoadingActivity extends Activity {
    public ProgressBar bar;
    private AssetManager assetManager;
    public Handler handler;
    public ProgressTask task;

    private final String[] list = {
    // Art.sprites
    "art/sprites.png" };

    private class ProgressTask extends AsyncTask<Void, Void, Void> {
        public int totalByteSize;
        public int currentByteSize;
        public Queue<Bitmap> bitmapQueue;
        public Queue<byte[]> byteQueue;

        public ProgressTask() {
            totalByteSize = 0;
            currentByteSize = 0;
            bitmapQueue = new LinkedList<Bitmap>();
            byteQueue = new LinkedList<byte[]>();
        }

        public void onPostExecute(Void params) {
            Art.sprites = bitmapQueue.remove();
            finish();
        }

        public void onPreExecute() {
            try {
                for (int i = 0; i < list.length; i++) {
                    byte[] bytes = readFromStream(list[i]);
                    totalByteSize += bytes.length;
                    byteQueue.add(bytes);
                }
                bar.setMax(totalByteSize);
            }
            catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        public void onProgressUpdate(Void... params) {
            bar.setProgress(currentByteSize);
        }

        @Override
        protected Void doInBackground(Void... params) {
            while (currentByteSize < totalByteSize) {
                try {
                    Thread.sleep(1000);
                    if (byteQueue.size() > 0) {
                        byte[] bytes = byteQueue.remove();
                        Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
                        bitmapQueue.add(bitmap);
                        currentByteSize += bytes.length;
                        this.publishProgress();
                    }
                }
                catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return null;
        }

        private byte[] readFromStream(String path) throws IOException {
            ByteArrayOutputStream output = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int length = 0;
            InputStream input = assetManager.open(path);
            while (input.available() > 0 && (length = input.read(buffer)) != -1)
                output.write(buffer, 0, length);
            return output.toByteArray();
        }

    }

    public void onCreate(Bundle b) {
        super.onCreate(b);
        this.setContentView(R.layout.progressbar);
        assetManager = this.getAssets();
        handler = new Handler();
        task = new ProgressTask();
        bar = (ProgressBar) this.findViewById(R.id.loadingBar);
        if (bar == null) throw new RuntimeException("Failed to load the progress bar.");
        task.execute();
    }

    public void finish() {
        Intent intent = new Intent(this, MenuActivity.class);
        intent.putExtra("Success Flag", Art.sprites != null);
        this.setResult(RESULT_OK, intent);
        super.finish();
    }
}

有没有一种有效的方法来检查子目录并通过Android资产文件夹中的相对路径加载资产？

1 个答案: