android - read file from assets


Translate
public class Utils {
    public static List<Message> getMessages() {
        //File file = new File("file:///android_asset/helloworld.txt");
        AssetManager assetManager = getAssets();
        InputStream ims = assetManager.open("helloworld.txt");    
     }
}

I am using this code trying to read a file from assets. I tried two ways to do this. First, when use File I received FileNotFoundException, when using AssetManager getAssets() method isn't recognized. Is there any solution here?


All Answers
  • Translate

    Here is what I do in an activity for buffered reading extend/modify to match your needs

    BufferedReader reader = null;
    try {
        reader = new BufferedReader(
            new InputStreamReader(getAssets().open("filename.txt")));
    
        // do reading, usually loop until end of file reading  
        String mLine;
        while ((mLine = reader.readLine()) != null) {
           //process line
           ...
        }
    } catch (IOException e) {
        //log the exception
    } finally {
        if (reader != null) {
             try {
                 reader.close();
             } catch (IOException e) {
                 //log the exception
             }
        }
    }
    

    EDIT : My answer is perhaps useless if your question is on how to do it outside of an activity. If your question is simply how to read a file from asset then the answer is above.

    UPDATE :

    To open a file specifying the type simply add the type in the InputStreamReader call as follow.

    BufferedReader reader = null;
    try {
        reader = new BufferedReader(
            new InputStreamReader(getAssets().open("filename.txt"), "UTF-8")); 
    
        // do reading, usually loop until end of file reading 
        String mLine;
        while ((mLine = reader.readLine()) != null) {
           //process line
           ...
        }
    } catch (IOException e) {
        //log the exception
    } finally {
        if (reader != null) {
             try {
                 reader.close();
             } catch (IOException e) {
                 //log the exception
             }
        }
    }
    

    EDIT

    As @Stan says in the comment, the code I am giving is not summing up lines. mLine is replaced every pass. That's why I wrote //process line. I assume the file contains some sort of data (i.e a contact list) and each line should be processed separately.

    In case you simply want to load the file without any kind of processing you will have to sum up mLine at each pass using StringBuilder() and appending each pass.

    ANOTHER EDIT

    According to the comment of @Vincent I added the finally block.

    Also note that in Java 7 and upper you can use try-with-resources to use the AutoCloseable and Closeable features of recent Java.

    CONTEXT

    In a comment @LunarWatcher points out that getAssets() is a class in context. So, if you call it outside of an activity you need to refer to it and pass the context instance to the activity.

    ContextInstance.getAssets();
    

    This is explained in the answer of @Maneesh. So if this is useful to you upvote his answer because that's him who pointed that out.


  • Translate
    getAssets()
    

    is only works in Activity in other any class you have to use Context for it.

    Make a constructor for Utils class pass reference of activity (ugly way) or context of application as a parameter to it. Using that use getAsset() in your Utils class.


  • Translate

    Better late than never.

    I had difficulties reading files line by line in some circumstances. The method below is the best I found, so far, and I recommend it.

    Usage: String yourData = LoadData("YourDataFile.txt");

    Where YourDataFile.txt is assumed to reside in assets/

     public String LoadData(String inFile) {
            String tContents = "";
    
        try {
            InputStream stream = getAssets().open(inFile);
    
            int size = stream.available();
            byte[] buffer = new byte[size];
            stream.read(buffer);
            stream.close();
            tContents = new String(buffer);
        } catch (IOException e) {
            // Handle exceptions here
        }
    
        return tContents;
    
     }
    

  • Translate
    public String ReadFromfile(String fileName, Context context) {
        StringBuilder returnString = new StringBuilder();
        InputStream fIn = null;
        InputStreamReader isr = null;
        BufferedReader input = null;
        try {
            fIn = context.getResources().getAssets()
                    .open(fileName, Context.MODE_WORLD_READABLE);
            isr = new InputStreamReader(fIn);
            input = new BufferedReader(isr);
            String line = "";
            while ((line = input.readLine()) != null) {
                returnString.append(line);
            }
        } catch (Exception e) {
            e.getMessage();
        } finally {
            try {
                if (isr != null)
                    isr.close();
                if (fIn != null)
                    fIn.close();
                if (input != null)
                    input.close();
            } catch (Exception e2) {
                e2.getMessage();
            }
        }
        return returnString.toString();
    }
    

  • Translate
    AssetManager assetManager = getAssets();
    InputStream inputStream = null;
    try {
        inputStream = assetManager.open("helloworld.txt");
    }
    catch (IOException e){
        Log.e("message: ",e.getMessage());
    }
    

  • Translate

    getAssets() method will work when you are calling inside the Activity class.

    If you calling this method in non-Activity class then you need to call this method from Context which is passed from Activity class. So below is the line by you can access the method.

    ContextInstance.getAssets();
    

    ContextInstance may be passed as this of Activity class.


  • Translate

    Reading and writing files have always been verbose and error-prone. Avoid these answers and just use Okio instead:

    InputStream input = context.getAssets().open("helloworld.txt");
    BufferedSource source = Okio.buffer(Okio.source(input));
    String text = source.readByteString().string(Charset.forName("utf-8"));
    

  • Translate

    Here is a method to read a file in assets:

    /**
     * Reads the text of an asset. Should not be run on the UI thread.
     * 
     * @param mgr
     *            The {@link AssetManager} obtained via {@link Context#getAssets()}
     * @param path
     *            The path to the asset.
     * @return The plain text of the asset
     */
    public static String readAsset(AssetManager mgr, String path) {
        String contents = "";
        InputStream is = null;
        BufferedReader reader = null;
        try {
            is = mgr.open(path);
            reader = new BufferedReader(new InputStreamReader(is));
            contents = reader.readLine();
            String line = null;
            while ((line = reader.readLine()) != null) {
                contents += '\n' + line;
            }
        } catch (final Exception e) {
            e.printStackTrace();
        } finally {
            if (is != null) {
                try {
                    is.close();
                } catch (IOException ignored) {
                }
            }
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException ignored) {
                }
            }
        }
        return contents;
    }
    

  • Translate

    In MainActivity.java

    @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            TextView tvView = (TextView) findViewById(R.id.tvView);
    
            AssetsReader assetsReader = new AssetsReader(this);
            if(assetsReader.getTxtFile(your_file_title)) != null)
            {
                tvView.setText(assetsReader.getTxtFile(your_file_title)));
            }
        }
    

    Also, you can create separate class that does all the work

    public class AssetsReader implements Readable{
    
        private static final String TAG = "AssetsReader";
    
    
        private AssetManager mAssetManager;
        private Activity mActivity;
    
        public AssetsReader(Activity activity) {
            this.mActivity = activity;
            mAssetManager = mActivity.getAssets();
        }
    
        @Override
        public String getTxtFile(String fileName)
        {
            BufferedReader reader = null;
            InputStream inputStream = null;
            StringBuilder builder = new StringBuilder();
    
            try{
                inputStream = mAssetManager.open(fileName);
                reader = new BufferedReader(new InputStreamReader(inputStream));
    
                String line;
    
                while((line = reader.readLine()) != null)
                {
                    Log.i(TAG, line);
                    builder.append(line);
                    builder.append("\n");
                }
            } catch (IOException ioe){
                ioe.printStackTrace();
            } finally {
    
                if(inputStream != null)
                {
                    try {
                        inputStream.close();
                    } catch (IOException ioe){
                        ioe.printStackTrace();
                    }
                }
    
                if(reader != null)
                {
                    try {
                        reader.close();
                    } catch (IOException ioe)
                    {
                        ioe.printStackTrace();
                    }
                }
            }
            Log.i(TAG, "builder.toString(): " + builder.toString());
            return builder.toString();
        }
    }
    

    In my opinion it's better to create an interface, but it's not neccessary

    public interface Readable {
        /**
         * Reads txt file from assets
         * @param fileName
         * @return string
         */
        String getTxtFile(String fileName);
    }
    

  • Translate

    You can load the content from the file. Consider the file is present in asset folder.

    public static InputStream loadInputStreamFromAssetFile(Context context, String fileName){
        AssetManager am = context.getAssets();
        try {
            InputStream is = am.open(fileName);
            return is;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
    
    public static String loadContentFromFile(Context context, String path){
        String content = null;
        try {
            InputStream is = loadInputStreamFromAssetFile(context, path);
            int size = is.available();
            byte[] buffer = new byte[size];
            is.read(buffer);
            is.close();
            content = new String(buffer, "UTF-8");
        } catch (IOException ex) {
            ex.printStackTrace();
            return null;
        }
        return content;
    }
    

    Now you can get the content by calling the function as follow

    String json= FileUtil.loadContentFromFile(context, "data.json");
    

    Considering the data.json is stored at Application\app\src\main\assets\data.json


  • Translate

    one line solution for kotlin:

    fun readFileText(fileName: String): String {
        return assets.open(fileName).bufferedReader().use { it.readText() }
    }
    

  • Translate

    If you use other any class other than Activity, you might want to do like,

    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader( YourApplication.getInstance().getAssets().open("text.txt"), "UTF-8"));
    

  • Translate

    Using Kotlin, you can do the following to read a file from assets in Android:

    try {
        val inputStream:InputStream = assets.open("helloworld.txt")
        val inputString = inputStream.bufferedReader().use{it.readText()}
        Log.d(TAG,inputString)
    } catch (e:Exception){
        Log.d(TAG, e.toString())
    }
    

  • Translate

    cityfile.txt

       public void getCityStateFromLocal() {
            AssetManager am = getAssets();
            InputStream inputStream = null;
            try {
                inputStream = am.open("city_state.txt");
            } catch (IOException e) {
                e.printStackTrace();
            }
            ObjectMapper mapper = new ObjectMapper();
            Map<String, String[]> map = new HashMap<String, String[]>();
            try {
                map = mapper.readValue(getStringFromInputStream(inputStream), new TypeReference<Map<String, String[]>>() {
                });
            } catch (IOException e) {
                e.printStackTrace();
            }
            ConstantValues.arrayListStateName.clear();
            ConstantValues.arrayListCityByState.clear();
            if (map.size() > 0)
            {
                for (Map.Entry<String, String[]> e : map.entrySet()) {
                    CityByState cityByState = new CityByState();
                    String key = e.getKey();
                    String[] value = e.getValue();
                    ArrayList<String> s = new ArrayList<String>(Arrays.asList(value));
                    ConstantValues.arrayListStateName.add(key);
                    s.add(0,"Select City");
                    cityByState.addValue(s);
                    ConstantValues.arrayListCityByState.add(cityByState);
                }
            }
            ConstantValues.arrayListStateName.add(0,"Select States");
        }
     // Convert InputStream to String
        public String getStringFromInputStream(InputStream is) {
            BufferedReader br = null;
            StringBuilder sb = new StringBuilder();
            String line;
            try {
                br = new BufferedReader(new InputStreamReader(is));
                while ((line = br.readLine()) != null) {
                    sb.append(line);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (br != null) {
                    try {
                        br.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
            return sb + "";
    
        }
    

  • Translate

    Here is a way to get an InputStream for a file in the assets folder without a Context, Activity, Fragment or Application. How you get the data from that InputStream is up to you. There are plenty of suggestions for that in other answers here.

    Kotlin

    val is = ClassLoader::class.java.classLoader.getResourceAsStream("assets/your_file.ext")

    Java

    InputStream is = ClassLoader.class.getClassLoader().getResourceAsStream("assets/your_file.ext");

    All bets are off if a custom ClassLoader is in play.


  • Translate

    @HpTerm answer Kotlin version:

    private fun getDataFromAssets(): String? {
    
        var bufferedReader: BufferedReader? = null
        var data: String? = null
    
        try {
            bufferedReader = BufferedReader(
                InputStreamReader(
                    activity?.assets?.open("Your_FILE.html"),     
                    "UTF-8"
                )
            )                  //use assets? directly if in activity
    
           var mLine:String = bufferedReader?.readLine()
            while (mLine != null) {
                data+= mLine
                mLine=bufferedReader.readLine()
            }
    
        } catch (e: Exception) {
            e.printStackTrace()
        } finally {
            try {
                bufferedReader?.close()
            } catch (e: Exception) {
               e.printStackTrace()
            }
        }
        return data
    }