Comment enregistrer un fichier à l'aide d'un thread d'arrière-plan dans Android

Actuellement j'ai créé une fonction qui utilise XmlSerializer pour créer un fichier XML à partir d'objets. J'ai fait des recherches sur l'utilisation de différentes formes de multi-threading pour enregistrer le fichier en arrière-plan tandis que le GUI est encore utilisable et est encore la mise à jour. J'ai regardé à l'aide de AsyncTask pour ce faire, mais je ne suis pas sûr de ce qui est la meilleure façon de la mettre en œuvre. Svp quelqu'un peut m'aider et je vous en remercie à l'avance.

Voici le code que j'ai jusqu'à présent:

private String fileName;
private DataObjects dataObjects;
public SetCachedValuesFile() 
{
}
public void setFileName(String refFileName)
{
fileName = refFileName;
}
public void setDataObjects(DataObjects refDataObjects)
{
dataObjects = refDataObjects;
}
public String getFileName()
{
return fileName;
}
public DataObjects getDataObjects()
{
return dataObjects;
}
public void updateValues()
{
ArrayList<DataObject> arrayListDataObject = dataObjects.getDataObjects();
try 
{
/* Creates a new file and its directory. */
File directory = new File(Environment.getExternalStorageDirectory() + "/XML_FILES/");
directory.mkdirs();
File newFile = new File(directory, fileName + ".xml");
FileOutputStream fos = new FileOutputStream(newFile);
/* Creates a new XML serializer which creates the structure of the XML file. */
XmlSerializer serializer = Xml.newSerializer();
serializer.setOutput(fos, "UTF-8");
serializer.startDocument(null, true);
serializer.startTag("", "CachedValues");
for(DataObject dataObject : arrayListDataObject)
{
if(dataObject.getClass().equals(StringDataObject.class))
{
StringDataObject stringDataObject = (StringDataObject) dataObject;
String address = HexFunctions.toString(stringDataObject.getAddress());
String value = stringDataObject.getValue();
serializer.startTag("", "DataObject");
serializer.startTag("", "Address");
serializer.text(address);
serializer.endTag("", "Address");
serializer.startTag("", "Value");
serializer.text(value);
serializer.endTag("", "Value");
serializer.endTag("", "DataObject");
System.out.println("String data object added to file.");
}
else if(dataObject.getClass().equals(IntDataObject.class))
{
IntDataObject intDataObject = (IntDataObject) dataObject;
String address = HexFunctions.toString(intDataObject.getAddress());
String value = Integer.toString(intDataObject.getValue());
serializer.startTag("", "DataObject");
serializer.startTag("", "Address");
serializer.text(address);
serializer.endTag("", "Address");
serializer.startTag("", "Value");
serializer.text(value);
serializer.endTag("", "Value");
serializer.endTag("", "DataObject");
System.out.println("Int data object added to file.");
}
else if(dataObject.getClass().equals(FloatDataObject.class))
{
FloatDataObject floatDataObject = (FloatDataObject) dataObject;
String address = HexFunctions.toString(floatDataObject.getAddress());
String value = Float.toString(floatDataObject.getValue());
serializer.startTag("", "DataObject");
serializer.startTag("", "Address");
serializer.text(address);
serializer.endTag("", "Address");
serializer.startTag("", "Value");
serializer.text(value);
serializer.endTag("", "Value");
serializer.endTag("", "DataObject");
System.out.println("Float data object added to file.");
}
else if(dataObject.getClass().equals(DoubleDataObject.class))
{
DoubleDataObject doubleDataObject = (DoubleDataObject) dataObject;
String address = HexFunctions.toString(doubleDataObject.getAddress());
String value = Double.toString(doubleDataObject.getValue());
serializer.startTag("", "DataObject");
serializer.startTag("", "Address");
serializer.text(address);
serializer.endTag("", "Address");
serializer.startTag("", "Value");
serializer.text(value);
serializer.endTag("", "Value");
serializer.endTag("", "DataObject");
System.out.println("Double data object added to file.");
}
}
serializer.endTag("", "CachedValues");
serializer.endDocument();
serializer.flush();
fos.close();
System.out.println("File created");
System.out.println("File name: " + newFile.getAbsolutePath());
} 
catch (IllegalArgumentException e) 
{
e.printStackTrace();
} 
catch (IllegalStateException e) 
{
e.printStackTrace();
}
catch (IOException e) 
{
e.printStackTrace();
}
}

OriginalL'auteur James Meade | 2013-11-19

  1. 11

    L'AsyncTask classe implémente une meilleure pratique de motif pour le déplacement de temps (mais de courte durée) de traitement d'un thread d'arrière-plan et la synchronisation de retour vers le thread de l'INTERFACE utilisateur, pour appliquer les mises à jour de l'INTERFACE utilisateur, lors de l'achever. Notez que ces tâches ne sont pas conservées entre l'Activité redémarre donc, par exemple, sera annulée si l'orientation de votre appareil changements.

    Toutefois, si vous n'avez pas besoin de mise à jour de l'INTERFACE utilisateur dans le cadre de votre tâche en arrière-plan (ce qui semble être le cas ici), alors il suffit d'utiliser la normale de la classe Thread qui est beaucoup plus simple à mettre en œuvre (edit: code ajouté pour la mise à jour de l'INTERFACE utilisateur à partir d'un thread d'arrière-plan):

    Handler handler = new Handler();  //Optional. Define as a variable in your activity.
Runnable r = new Runnable()
{
@Override
public void run()
{
//your code here
handler.post(new Runnable()  //If you want to update the UI, queue the code on the UI thread
{
public void run()
{
//Code to update the UI 
}
});
}
};
Thread t = new Thread(r);
t.start();

    Noter que ce type d'enfilage de ne conserver sur l'activité redémarre donc, il devrait généralement exécuter jusqu'à la fin.

    À faire cela comme un AsyncTask (qui peut être un meilleur choix si l'INTERFACE utilisateur doit être mis à jour), la même chose peut être réalisé par:

    Dans votre activité, de créer une instance de votre Asynchrone de la classe et de l'exécuter.

    SaveData save = new SaveData();
save.execute();

    Sous-classe AsyncTask en classe privée au sein de votre activité

    private class SaveData extends AsyncTask<String, Void, Boolean>{
@Override
protected Boolean doInBackground(String... params) {
//your background code here. Don't touch any UI components
if(your code worked...)
return true;                
else
return false;
}
protected void onPostExecute(Boolean result) {
//This is run on the UI thread so you can do as you wish here
if(result)
Toast successful
else
Toast unsuccessful
}
}
    Je pense que vous avez peut-être raison. Même si je veux de l'interface graphique pour afficher le fichier a été sauvegardé ou ont-il y avoir une sorte d'indication. Mais je veux que l'opération soit exécutée dans un thread séparé. Voulez-vous suggérer la création d'une nouvelle classe avec la fonction de thread, puis d'appeler la classe que j'ai déjà créé ou créez-le fil dans la fonction?
    Voir mon edit pour mettre à jour l'INTERFACE utilisateur de l'intérieur d'un thread d'arrière-plan. Je vous recommande de créer et de gérer le fil dans votre classe d'activité et appelez votre fonction à partir de là. Mais je ne veux pas être prescriptif - expérimenter et voir ce qui fonctionne (et semble plus propre code sage) pour vous.
    Merci beaucoup pour votre aide. AsyncTask semble faire le plus de sens avec ce que je fais et j'ai testé les deux méthodes et AsyncTask est la meilleure solution pour moi et c'est le plus rapide en temps d'exécution.
    À l'égard de méthode de gestionnaire d' : vous ne peut pas se référer à un non-dernière variable handler à l'intérieur d'un intérieur classe définie dans une méthode différente

    OriginalL'auteur NigelK

  2. 1

    Une chose à ajouter à NigelK la réponse est que si vous utilisez l'AsyncTask vous ne pouvez utiliser qu'une seule fois. Si vous ne pouvez pas appeler deux fois comme suit:

    SaveData save = new SaveData();
save.execute();
//Later
save.execute();

    Au lieu de cela, vous aurez besoin de faire quelque chose comme:

    SaveData save1 = new SaveData();
save1.execute();
//Later
SaveData save2 = new SaveData();
save2.execute();

    En outre, si vous avez besoin pour exécuter la tâche de façon répétitive, vous pouvez utiliser un gestionnaire et de l'appeler dans l'exécutable, comme ceci:

    Handler handler = new Handler();
Runnable runnable = new Runnable() {
public void run() {
SaveData save = new SaveData();
save.execute();       
}
};
handler.postDelayed(runnable, 500);

    Voir ces liens. AsyncTask le Filetage de la Règle - Peut-il vraiment être utilisé une seule fois?
    Appel asynctask dans le gestionnaire de

    OriginalL'auteur Walter Morawa