android - programacion - leer el archivo de los activos

manual de android en pdf

Question

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");    
     }
}

Estoy usando este código tratando de leer un archivo de los activos. Intenté dos formas de hacer esto. En primer lugar, cuando utilizo File I, recibí FileNotFoundException , cuando se usa el AssetManager getAssets() no se reconoce. ¿Hay alguna solución aquí?

Answer 1

Aquí hay un método para leer un archivo en activos:

/**
 * 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;
}

Answer 2

En 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)));
        }
    }

Además, puedes crear una clase separada que haga todo el trabajo

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();
    }
}

En mi opinión, es mejor crear una interfaz, pero no es necesario

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

Answer 3

Esto es lo que hago en una actividad para ampliar / modificar la lectura en búfer para que coincida con sus necesidades

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: Mi respuesta es quizás inútil si su pregunta es sobre cómo hacerlo fuera de una actividad. Si su pregunta es simplemente cómo leer un archivo del activo, entonces la respuesta está arriba.

ACTUALIZAR :

Para abrir un archivo que especifica el tipo, simplemente agregue el tipo en la llamada InputStreamReader de la siguiente manera.

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
         }
    }
}

EDITAR

Como @Stan dice en el comentario, el código que estoy dando no es un resumen de las líneas. mLine se reemplaza cada pase. Es por eso que escribí //process line . Supongo que el archivo contiene algún tipo de datos (es decir, una lista de contactos) y cada línea debe procesarse por separado.

En caso de que simplemente quiera cargar el archivo sin ningún tipo de procesamiento, deberá resumir la cantidad de mLine en cada pasada usando StringBuilder() y anexando cada pase.

OTRO EDITAR

De acuerdo con el comentario de @Vincent, agregué el bloque finally .

También tenga en cuenta que en Java 7 y superior puede usar try-with-resources para usar las características AutoCloseable y Closeable de Java reciente.

CONTEXTO

En un comentario, @LunarWatcher señala que getAssets() es una class en context . Por lo tanto, si lo llama fuera de una activity , debe consultarlo y pasar la instancia de contexto a la actividad.

ContextInstance.getAssets();

Esto se explica en la respuesta de @Maneesh. Entonces, si esto es útil para usted, vote su respuesta porque es él quien lo señaló.

Answer 4

Leer y escribir archivos siempre ha sido prolijo y propenso a errores. Evite estas respuestas y simplemente use Okio en Okio lugar:

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

Answer 5

Mejor tarde que nunca.

Tuve dificultades para leer archivos línea por línea en algunas circunstancias. El método a continuación es el mejor que encontré, hasta ahora, y lo recomiendo.

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

Donde se supone que YourDataFile.txt reside en activos /

 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;

 }

EDITAR Problema aparente: esta función puede devolver esta cadena:

''android.content.res.AssetManager $ AssetInputStream @ [code]''

en lugar de los contenidos del archivo. Todavía no puedo reproducir el problema. Hasta que actualice mi respuesta cuando sepa cuál es el problema, considere el código de arriba ''probablemente no confiable''.

Answer 6

Puede cargar el contenido del archivo. Considere que el archivo está presente en la carpeta de activos.

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;
}

Ahora puede obtener el contenido llamando a la función de la siguiente manera

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

Teniendo en cuenta los datos. Json se almacena en Application / app / src / main / assets / data.json

Answer 7

Si usa otra clase que no sea Actividad, es posible que desee hacer algo como,

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

Answer 8

Usando Kotlin, puede hacer lo siguiente para leer el archivo del activo en 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())
    }

Answer 9

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 + "";

    }

Answer 10

getAssets() método getAssets() funcionará cuando llame dentro de la clase Activity.

Si llama a este método en clase no activa, debe llamar a este método desde el contexto que se pasa desde la clase de actividad. A continuación se muestra la línea por la que puede acceder al método.

ContextInstance.getAssets();

ContextInstance se puede pasar como este de la clase Activity.

Answer 11

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

Answer 12

getAssets()

solo funciona en Activity en otra clase, tienes que usar Context para ello.

Cree un constructor para la referencia de paso de clase Utils de la actividad (manera fea) o el contexto de la aplicación como un parámetro para ello. Usando eso use getAsset () en su clase de Utils.

Answer 13

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();
}