So speichern Sie eine Datei mit einem hintergrund-thread in Android

Ich habe derzeit erstellt eine Funktion mit XmlSerializer eine XML-Datei erstellen von Objekten. Ich habe geforscht über die Verwendung verschiedener Formen von multi-threading, um die Datei zu speichern in den hintergrund, während die GUI ist noch brauchbar und wird noch aktualisiert. Ich schaute mit AsyncTask um dies zu tun, aber ich bin mir nicht sicher, was ist der beste Weg, es zu implementieren. Bitte kann mir jemand helfen mit dieser, und vielen Dank im Voraus.

Hier ist der code, den ich bisher:

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

InformationsquelleAutor James Meade | 2013-11-19

11

Die AsyncTask-Klasse implementiert einen best-practice-Muster für das verschieben zeitaufwendig (aber kurzlebigen) die Verarbeitung zu einem hintergrund-thread und synchronisieren Sie zurück zum UI-Faden, verwenden, um Aktualisierungen an der Benutzeroberfläche, wenn Sie fertig. Beachten Sie, dass solche Aufgaben nicht bleiben in Aktivität neu gestartet, so zum Beispiel abgebrochen, wenn die Ausrichtung des Geräts ändert.

Allerdings, wenn Sie nicht brauchen, um die Aktualisierung der Benutzeroberfläche als Teil der hintergrund die Aufgabe (das scheint hier der Fall sein), dann verwenden Sie einfach die normale Thread-Klasse, die ist viel einfacher zu implementieren (edit: code Hinzugefügt für die Aktualisierung der Benutzeroberfläche von einem hintergrund-thread):
```
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();
```
Beachten Sie, dass diese Art von threading andauern, über die Aktivität neu gestartet, so sollte es in der Regel bis zum Abschluss ausgeführt.

Dazu als einen AsyncTask (das kann sein ein bessere Wahl, wenn das UI aktualisiert werden muss) das gleiche kann erreicht werden durch:

In Ihrer Tätigkeit erstellen Sie eine Instanz der Async-Klasse und ausführen.
```
SaveData save = new SaveData();
save.execute();
```
Unterklasse AsyncTask als private Klasse innerhalb Ihrer Tätigkeit
```
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
 }
}
```
Ich denke, dass Sie vielleicht Recht. Obwohl ich will, dass die GUI angezeigt, dass die Datei gespeichert wurde oder es irgendeine Art von Anzeige. Aber ich will, dass die operation durchgeführt werden, in einem separaten thread. Würden Sie vorschlagen, eine neue Klasse zu erstellen mit der thread-Funktion und rufen Sie dann die Klasse, die habe ich bereits erstellt, oder erstellen Sie den Faden in der Funktion?
Siehe mein edit, wie zum aktualisieren der Benutzeroberfläche aus in einem hintergrund-thread. Ich empfehle Ihnen, erstellen und verwalten der thread der activity-Klasse und rufen Sie die Funktion von dort aus. Aber ich will nicht präskriptiv - Experimentieren und sehen, was funktioniert (und sieht saubersten code wise) für Sie.
Ich danke Ihnen sehr für Ihre Hilfe. AsyncTask scheint am meisten Sinn machen mit dem, was ich Tue, und ich habe beide getestet Methoden und AsyncTask ist für mich die beste Lösung und ist die Schnellste Ausführungszeit als gut.
Mit Bezug auf handler-Methode : Sie können nicht beziehen sich auf eine nicht-Finale variable handler im inneren eine innere Klasse definiert, die in einer anderen Methode

InformationsquelleAutor NigelK
1

Eins hinzufügen NigelK die Antwort ist, dass bei Verwendung von AsyncTask können Sie nur verwenden Sie es einmal. So kann man nicht nennen es zweimal wie folgt:
```
SaveData save = new SaveData();
save.execute();
//Later
save.execute();
```
Stattdessen müssten Sie etwas tun, wie:
```
SaveData save1 = new SaveData();
save1.execute();
//Later
SaveData save2 = new SaveData();
save2.execute();
```
Darüber hinaus, wenn Sie benötigen, um ausführen die Aufgabe wiederholt, die Sie verwenden möchten, können Sie einen handler und rufen es in dem Thread wie dieser:
```
Handler handler = new Handler();
Runnable runnable = new Runnable() {
    public void run() {
        SaveData save = new SaveData();
        save.execute();       
    }
};
handler.postDelayed(runnable, 500);
```
Finden Sie unter diesen links. AsyncTask Threading-Regel - Kann es wirklich nur einmal verwendet werden?
Rufen Sie asynctask in hf

InformationsquelleAutor Walter Morawa

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.