Was ist der Schnellste Weg, um mehrere Ansichten zu einem LinearLayout?

Ich habe eine LinearLayout Ansicht, dass bereits viele Elemente enthält. Ich möchte hinzufügen, viel mehr Ansichten, um es programmatisch. Und weil dies innerhalb einer ScrollView alles wird gescrollt werden.

Also, was ich tun ist, gehen durch meine Liste, und fügen Sie neue Instanzen meiner benutzerdefinierte Ansicht zu. Das benutzerdefinierte Ansicht bläst ein XML-layout und fügt ein paar Methoden.

Dieser Ansatz gut funktioniert. Das problem ist, dass es super langsam, auch ohne crazy-code... eine Liste mit 10 items dauert etwa 500ms zu instanziieren. Als user-experience-Sicht ist das schwer zu schlucken.

Meine Frage ist, ist das der richtige/beste Ansatz? Android scheint zu viel Zeit in Anspruch nehmen aufblasen das layout, auch wenn "R. layout.my_list_item" ist super einfach. Ich Frage mich, ob es einen Weg gibt, um vielleicht wiederverwenden "aufgeblasen" layouts für zusätzliche Ansichten, irgendwie Zwischenspeichern, die komplexere Analyse?

Habe ich versucht, dies mit einer ListView (und adapter und wrapper) und es scheint zu sein, viel schneller. Das problem ist, dass ich nicht verwenden können, ein einfaches ListView; mein layout komplexer ist als eine einfache Liste (die LinearLayout selbst enthält zusätzliche benutzerdefinierte Symbole, und es hat den anderen Elternteil mit noch mehr Aussicht, bevor es eingewickelt durch den ScrollView).

Aber gibt es eine Möglichkeit, einen adapter für ein LinearLayout? Wäre das schneller, als Sie versuchen, um den Blick auf mich selbst?

Jede Hilfe ist willkommen. Ich würde gerne, um diese schneller.

Code folgt.

Haupttätigkeit:

//The LinearLayout that will contain everything
lineList = (LinearLayout) findViewById(R.id.lineList);

//Add a lot of items for testing
for (int i = 0; i < 10; i++) {
    addListItem("Item number " + i);
}

protected void addListItem(String __title) {
    MyListItem li;
    li = new MyListItem(this);
    li.setTitle(__title);
    lineList.addView(li);       
}

MyListItem:

public class MyListItem extends RelativeLayout {

    protected TextView textTitle;

    public MyListItem(Context __context) {
        super(__context);
        init();
    }

    public MyListItem(Context __context, AttributeSet __attrs) {
        super(__context, __attrs);
        init();
    }

    public MyListItem(Context __context, AttributeSet __attrs, int __attrsdefStyle) {
        super(__context, __attrs, __attrsdefStyle);
        init();
    }

    protected void init() {
        //Inflate the XML layout
        LayoutInflater inflater = (LayoutInflater) getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        inflater.inflate(R.layout.my_list_item, this);

        //Create references
        textTitle = (TextView)findViewById(R.id.textTitle);
    }

    public void setTitle(String __text) {
        textTitle.setText(__text);
    }
}

Was ich versuche zu erreichen ist. Betrachten Sie dieses layout:

Was ist der Schnellste Weg, um mehrere Ansichten zu einem LinearLayout?

Dieses layout ist ein FrameLayout (Umkarton) mit einer ImageView (in Grau), eine TextView (innere Rechteck, oben) und eine LinearLayout (innere Rechteck, unten). Diese LinearLayout Rechteck ist die eine, die ich dynamisch füllen mit ein paar items.

Nachdem ich ihn bevölkern, möchte ich das Ergebnis dieser (wo jedes neue Rechteck ist eine neue MyListItem Instanz):

Was ist der Schnellste Weg, um mehrere Ansichten zu einem LinearLayout?

Das ist alles, was ist Scrollbar (hintergrund Bild, zum Beispiel, ist ausgerichtet auf die Oberseite). Die LinearLayout ist nicht Scrollbar von selbst (alles andere folgt) das ist der Grund, warum ein ListView, von dem was ich weiß, würde nicht gut funktionieren
in meinem Fall.

Wie viele Elemente haben Sie in dieser Tätigkeit, und Sie haben keine individuelle Klasse erbt, die UI-Elemente?
ListViews sind so schnell, da Sie recyceln den Artikel-layouts. Blasen Sie die Anzahl des Artikel-layouts erforderlich, um den Bildschirm zu füllen. Wenn Sie nach unten scrollen, einen Blick an der Spitze steht, verdeckt und eine auf der Unterseite wird angezeigt. Die listview nimmt die alten, unsichtbaren, von oben und setzen Sie die neuen Daten auf der Unterseite. Teure inflation. Gesamteindruck: Dieser hier sieht sehr ineffizient, ich bin mir ziemlich sicher, dass was auch immer Sie tun möchten, können erreicht werden mit einer listview. Wenn Sie zeigen, was du versucht hast und poste eine Skizze Ihres gewünschten layout können wir Ihnen helfen, das herausfinden.
Paul: das werden nicht viele Elemente. Vielleicht 4 oder 5. Ja, einige von Ihnen sind benutzerdefinierte Klassen Erben von der Grundstruktur. alextsc: danke für die Erklärung. Ich habe ein Diagramm, dass besser erklärt meine situation so klar ist, ob und wie könnte ich mit einem ListView statt (oder auch nicht).
Es kann nicht viel helfen, aber die Tatsache, dass Sie sind "immer" die LayoutInflater jedes mal in init() kann das hinzufügen eines fairen Betrag von Zeit für jeden Anruf. Ich würde sofort den inflater, einmal in der Haupt-Aktivität und dann übergeben Sie einen Verweis, um ihn in init(). So, Sie rufen nur getSystemService(Context.LAYOUT_INFLATER_SERVICE) einmal, und Sie brauchen nicht die getContext() rufen Sie entweder als Haupt-Aktivität kann es direkt tun. Nur eine Idee - es könnte die Dinge beschleunigen leicht.
danke. Eine gültige Idee. Ich habe versucht es aber keinen Unterschied in der Zeit. Ich bin mir ziemlich sicher, dass es mehr optimiert zu tun, aber der performance-Unterschied zu vernachlässigen ist.
Ok, ich sehe, dass diese etwas komplexer, als ich zunächst aber. Bevor ich Schreibe eine lange Antwort, wie dies zu tun: ich schrieb eine kurze Wegwerf-layout-Prototyp-Projekt mit einer ListView. Werfen Sie einen Blick und sehen, ob diese ist ca. das Ergebnis, die Sie wollen. Es ist ein bisschen vereinfacht: Der hintergrund ist nicht ein Bild, sondern ein einfaches Grau. Sie können das ändern, indem Sie die Einstellung des listviews android:background um ein Bild aus dem drawable-Ordner (in main.xml). Auch die Elemente der Liste sind einfache Standard-Elemente. Dies kann leicht geändert werden, indem mithilfe einer benutzerdefinierten adapter.
danke. Dies ist hilfreich. Das Bild ist immer noch ein problem, da, wie es ausgerichtet ist/skaliert (ich konnte es nicht haben, als eine einfache Hintergrundbild). Vielleicht ist der Weg, es zu tun mit einem ListView ist durch anschließen einer Veranstaltung der ListView's scrollen und dann Blättern Sie eine LinearLayout parallel auf dem hintergrund, mit allen Elementen, die ich brauche. Ein bisschen hacky, aber es könnte funktionieren. Ich wünschte nur, es war ein Weg zur Optimierung der ein linearlayout.addView() ein bisschen, obwohl, es wäre genug für meinen Fall (es ist nicht eine riesige Liste).
OK, ich dachte, es würde nicht viel helfen. Übrigens, testen Sie diese auf einem realen Gerät oder mit einem AVD-emulator? Es gibt einen großen Unterschied in der Leistung (sorry, wenn Sie schon realisieren, aber dachte, ich würde es erwähnen).
Follow-up - entweder Sie testen diese auf einem emulator oder Ihre Liste Einzelteile sind extrem Komplex (viel mehr als in deinem Beispiel-code). Mit Ihrem code mit MyListItem wie von Ihnen dargestellt, auf einem HTC Desire, die ich erzeugen kann, die 10 in unter 20ms und 500 in unter 500ms. Ich weiß, Sie sagen, dass die Liste Elemente, die Sie anzeigen möchten, enthalten Symbole etc, aber die Erzeugung dauert 10 500ms??? Das ist ein 25-facher Anstieg auf, was es braucht, meine Lust zu erzeugen, die einfache TextView-basierte Elemente - einen großen Unterschied.
Ich Teste auf einem Gerät (Nexus One, Android 2.3, Projekt-Ziele 2.3). Die Artikel sind nicht sehr Komplex - im Grunde 2 ImageViews, und eine TextView, die alle in einem RelativeLayout. Gut zu wissen, dass Ihre Ergebnisse; vielleicht mache ich etwas anderes falsch? Meine apk ist nur ein test und nicht zipaligned oder irgendetwas, vielleicht einen Einfluss hat. Der code auf meinen post ist ein bisschen vereinfacht, aber es gibt nichts verrücktes Hinzugefügt. Ich werde benchmark mehr, nehme ich an, um zu sehen, wo der Engpass ist (obwohl meine ersten tests wirklich gemacht, es so Aussehen, wie das aufblasen der übeltäter war).
Das Nexus One hat einen 1GHz Snapdragon-Prozessor (wenn ich das richtig verstanden habe) - das ist das gleiche wie das Desire. Können Sie nach dem layout-und Artikel-inflater-code, schließt die ImageViews als auch, was die Größe der Bilder sind und wo Sie sich befinden (/res/drawable-oder SD-Karte etc.)? Ich werde führen Sie einige tests mit den Bildern und sehen, wie es vergleicht.

InformationsquelleAutor zeh | 2011-12-16

7

3 Optionen:
1. Ersetzen alles, was mit einem ListView, mit dem anderen Elternteil und eigene Symbole wie eine header-Ansicht des ListView. ListView ist schneller, weil es nur schafft die Aussicht, wie es Sie braucht.
2. Programmgesteuert erstellen Sie den Inhalt der my_list_item statt aufblasen, könnte schneller sein
3. Verwendung von ViewStubs erlauben kann, Sie zu laden-Ansichten-on-demand.
4. Vielleicht ist es nicht das laden der Aussicht, aber die Daten? in diesem Fall bereiten Sie die Daten in einem hintergrund-thread.
- Vielen Dank für diese gerade, in die Praxis umzusetzen. Ich würde hinzufügen "erstellen Sie die Ansichten auf einer separaten thread" Liste (als user1031312 schlug in einem Kommentar unten). Außer, dass ich denke, dass Sie die Summe der möglichen Lösungen auch.
InformationsquelleAutor FunkTheMonk
2

Einen ListView ist der Weg zu gehen.

Du sagen, dass dein layout ist zu kompliziert. Aber es ist völlig okay, zum aufblasen, ein Komplexes layout als ein Kind. Zum Beispiel ein layout, das text hat, und dann ein Symbol:
```
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content" >
    <TextView
        android:layout_width="wrap_content" 
        android:layout_height="wrap_content" />
    <ImageView 
        android:layout_width="wrap_content" 
        android:layout_height="wrap_content" />
</LinearLayout>
```
Könnte aufgeblasen werden den adapter ein, etwa so:
```
@Override
public View getView(final int position, View convertView, ViewGroup parent) {
    LinearLayout root = null;
    ImageView editImageView;

    if (convertView == null) {
        LayoutInflater inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        root = (LinearLayout)inflater.inflate(R.layout.item, null);
    } else {
        root = (LinearLayout)convertView;
    }
}
```
Können Sie auch ein wenig klüger zu werden, um ein header. Fügen Sie einfach ein Häkchen, wenn der index der Wurzel und Blasen eine andere Ansicht. Da der header ist das einzige, das unterscheidet Sie immer noch nutzen Sie alle anderen Zeilen wiederverwendbar. Sie können auch pre-aufpumpen und speichern Sie die header und verwenden es, um vollständig loszuwerden der inflation.
- Danke. Aber beachten Sie, sagte ich, das layout ist "komplexer als eine einfache Liste", eher als "zu Komplex" (das layout selbst ist einfach). Ich hätte kein problem das aufblasen der ganzen Sache. Das problem ist, dass ich nicht sehen, wie ich meine Layouts mit Header auf eine ListView, wenn man bedenkt ich habe Elemente der Gang hinter der Liste (das Bild in meinem Diagramm). Kann ich ein Bild angehängt, an die Spitze der ListView aber unter der Kind-Elemente?
InformationsquelleAutor Grimmace
1

Nutzen Sie einfach die Listenansicht!

Es ist am einfachsten einzurichten und am einfachsten zu pflegen. Definieren Sie ein XML-layout für die Listen-Zeile, und ein XML-layout für die Ansicht hält, die die gesamte Liste. Der ListAdapter übernimmt den rest für Sie.

Erstellen Sie einfach ein:
```
List<HashMap<String, String>> services = new ArrayList<HashMap<String, String>>();
```
...und Durchlaufen Ihre Daten und fügen Sie so viele Artikel wie Sie möchten auf die Karte. Dann setzen Sie diese Karte, um Ihre ListAdapter. Ob 10 Stück oder 100 Elemente die ListAdapter erstellen eine Liste, die viele Elemente.

Beispiel:
```
    public void updateProductList(String searchTerm) {
        createOrOpenDB(this);
        Cursor cursor = (searchTerm!=null)? dbAdapter.fetchWhere(TBL_NAME, KEY_NAME+" LIKE '%"+searchTerm+"%'")
                : dbAdapter.fetchAll(TBL_NAME);
        int rows = cursor.getCount();
        if (rows<=0) return;
        services.clear(); //clear current list
        for (int i=0; i<rows; i++) {
            HashMap<String, String> map = new HashMap<String, String>();
            cursor.moveToPosition(i);
            map.put(KEY_NAME, "" + cursor.getString(cursor.getColumnIndex(KEY_NAME)));
            map.put(KEY_DESC, "" + cursor.getString(cursor.getColumnIndex(KEY_DESC)));
            map.put(KEY_COST, "" + cursor.getDouble(cursor.getColumnIndex(KEY_COST)));
            services.add(map);
        }
        cursor.close();
        closeDB();

        ListAdapter adapter = new SimpleAdapter(this, services, R.layout.products_view_row,
                new String[] {KEY_NAME, KEY_DESC, KEY_COST},
                new int[] {R.id.listViewText1, R.id.listViewText2, R.id.listViewText3});
        setListAdapter(adapter);
    }
```
- Danke. Ich habe eine ListView mit einem richtigen adapter in andere Teile der gleichen Applikation erstellt werden, jedoch so, das problem ist nicht die Implementierung einer ListView. Der Grund, warum ich bin nicht mit einem ListView-hier ist, weil es scheint nicht das zu erreichen, was ich brauche (scrolling anderen nicht-Liste, nicht-header-Elemente, parallel). Ich würde gerne als falsch erwiesen, aber die Antwort ist komplexer, als "nur mit einem listview".
- Ohh ich sehe. Dann, was Sie wollen, ist diese: stackoverflow.com/questions/3192595/... (siehe akzeptierte Antwort) gepaart mit einem ScrollView zu Kapseln Ihre gesamte layout.
- Äh, wie ich schon sagte, auf den original-post, das ist genau das, was ich mache, aber ich habe ein Problem mit der Leistung (manuell hinzufügen von Elementen zu einem LinearLayout langsam ist).
- Ach ja, richtig. Haben Sie einen AsyncTask ausgeführt diese Schleife im hintergrund? Man könnte die Liste der Elemente ein, indem Sie *mit einem Handler.post () - Methode. Das sollte helfen, die performance?
- Ja, das ist, was ich jetzt tun für eine ähnliche Liste (ich habe mehrere ähnliche Listen auf die Anwendung): ich habe nur die ersten paar Elemente, die erforderlich für die Initiale viewport, dann hab ich aber einen thread, füllt den rest der Liste auf dem hintergrund. Ich bin mit Handler und Runnables und Threads obwohl, wusste nichts von der AsyncTask - besser klingt, für das, danke!
- Es ist im Grunde der SwingWorker Klasse, aber für Android (wenn Sie beide Klassen sind Sie fast eineiige Zwillinge)
InformationsquelleAutor Ozzy

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.