Firebase Données Desc Tri dans Android

Je suis le stockage des données dans Firebase de stockage.

Objet Comment avec l'attribut timestamp. Lorsque que j'appuie sur les données de l'appareil avec Firebase je suis remplissage timestamp avec currentTime et de les stocker dans long type de données.

Quand je fais de la récupération des données avec firebaseRef.orderByChild("timestamp").limitToLast(15) résultat n'est pas le tri de la façon dont je m'attendais.

J'ai même joué un peu avec les règles et pas de résultat:

{
    "rules": {
        ".read": true,
        ".write": true,
        ".indexOn": "streetrate",
        "streetrate": {
          ".indexOn": ".value"
        }
    }
}

J'ai essayé magasin timestamp dans String type de données, même problème.

Je suggère de les trier en fonction de la valeur que vous voulez et puis la page vers l'arrière. (Tri asc, puis la page de fin moins x entrées.)

InformationsquelleAutor Farrukh Okhunov | 2015-12-08

53

Firebase pouvez commander les éléments dans l'ordre croissant par une propriété donnée, puis renvoie les N premiers éléments (limitToFirst()) ou les N derniers éléments (limitToLast()). Il n'y a aucun moyen d'indiquer que vous voulez que les éléments dans l'ordre décroissant.

Il y a deux options pour obtenir le comportement que vous voulez:
1. Utiliser un Firebase requête pour obtenir des données correctes, puis re-commander côté client
2. Ajouter un champ qui est un descendant de la valeur aux données
Pour cette dernière approche, il est courant d'avoir un inversé d'horodatage.
```
-1 * new Date().getTime();
```
- Salut Frank, la deuxième approche est la meilleure. Pour obtenir les dernières 15 lignes ajoutées, je suis en utilisant une requête firebaseRef.orderByChild("timestamp").limitToFirst(15), tandis que le magasin -1*horodatage.
- Vous préférez la deuxième approche, mais ce n'est pas mieux. Il a beaucoup de compromis avec la première, en particulier à l'échelle. L'un est le stockage-la première approche nécessite pas de données supplémentaires pour être stocké, depuis push() id seront naturellement les données de l'ordre chronologique, et en général, la quantité de données que vous tirez à côté client à un moment donné est facilement réversible avec négligeables incidence sur les performances. Aucune de ces approches devraient être rejetés comme des êtres inférieurs.
- vous intelligent fox 😀 superbement fait
- van Puffelen je pense que cette approche est très bonne. Mais pouvez-vous nous donner une astuce pour le desc de tri lorsque la valeur d'horodatage est utilisé Valeurserveur.TIMESTAMP?
- Cela peut-il être atteint que si le domaine de la commande est de deux niveaux au lieu d'un enfant direct?
InformationsquelleAutor Frank van Puffelen

une bonne solution que j'ai trouver si vous utilisez recycleur vue de rendre les données...

mLayoutManager = new LinearLayoutManager(getActivity());
mLayoutManager.setReverseLayout(true);
mLayoutManager.setStackFromEnd(true);

//And set it to RecyclerView
mRecyclerView.setLayoutManager(mLayoutManager);

il va inverser les données de rendu...

private static class ChatMessageViewHolder extends RecyclerView.ViewHolder {
         TextView messageText;
         TextView nameText;

         public ChatMessageViewHolder(View itemView) {
             super(itemView);
             nameText = (TextView)itemView.findViewById(android.R.id.text1);
             messageText = (TextView) itemView.findViewById(android.R.id.text2);
         }
     }

     FirebaseRecyclerViewAdapter<ChatMessage, ChatMessageViewHolder> adapter;
     ref = new Firebase("https://<yourapp>.firebaseio.com");

     RecyclerView recycler = (RecyclerView) 

     findViewById(R.id.messages_recycler);
         recycler.setHasFixedSize(true);

         //////////////////////////////////////////////////////////
         mLayoutManager = new LinearLayoutManager(getActivity());
         mLayoutManager.setReverseLayout(true);
         mLayoutManager.setStackFromEnd(true);
         recycler.setLayoutManager(mLayoutManager);
         /////////////////////////////////////////////////////////

         adapter = new FirebaseRecyclerViewAdapter<ChatMessage, ChatMessageViewHolder>(ChatMessage.class, android.R.layout.two_line_list_item, ChatMessageViewHolder.class, mRef) {
         public void populateViewHolder(ChatMessageViewHolder chatMessageViewHolder, ChatMessage chatMessage) {
             chatMessageViewHolder.nameText.setText(chatMessage.getName());
             chatMessageViewHolder.messageText.setText(chatMessage.getMessage());
         }
     };
     recycler.setAdapter(mAdapter);

-1. Vous semblez prendre les problèmes de serveur dans les problèmes du client. Cela signifie que chaque client doit traiter cette question. Si nous avons de l'iOS, Android et web, tous sera nécessaire pour ce faire. Une meilleure utilisation des Fonctions avec des valeurs négatives.
fonctionne parfaitement
Notez que stackFromEnd n'est pas pris en charge par GridLayoutManager

InformationsquelleAutor RBK

Je ne vois aucune option pour inverser les données. Mais Une Brute façon est d'obtenir les données.

List<ModelClass> mList=new ArrayList();
public void onDataChange(DataSnapshot dataSnapshot) 
{
     mList.clear();
     for(DataSnapshot children: dataSnapshot.getChildren()){
        ModelClass modelClass=children.getValue(ModelClass.class);
        mList.add(modelClass);
     }
     Collections.reverse(mList);
     Adapter.notifyDataSetChanged();
}

Je pense que c'est la meilleure solution générique
C'est le plus générique-solide-solution simple que j'ai trouvé pour ce problème! Doit être accepté de répondre!
merci pour vos généreux commentaires 😀

InformationsquelleAutor Himanshu Rawat

J'ai résolu le problème en étendant FirebaseListAdapter et supérieur de la méthode getItem:

public abstract class ReverseFirebaseListAdapter<T> extends FirebaseListAdapter<T>  {

public ReverseFirebaseListAdapter(Activity activity, Class<T> modelClass, int modelLayout, Query ref) {
    super(activity, modelClass, modelLayout, ref);
}

public ReverseFirebaseListAdapter(Activity activity, Class<T> modelClass, int modelLayout, DatabaseReference ref) {
    super(activity, modelClass, modelLayout, ref);
}

@Override
public T getItem(int position) {
  return super.getItem(getCount() - (position + 1));
}

}

Solution sympa. Je vous remercie.

InformationsquelleAutor Monet_z_Polski

4

L' @Monet_z_Polski de l'approche fondée sur
```
@Override
public T getItem(int position) {
  return super.getItem(getCount() - (position + 1));
}
```
a un effet bizarre sur les pas de mise à jour FirebaseRecyclerView automatiquement (PopulateViewHolder n'est pas déclenché en temps réel les modifications). Donc, la meilleure option est utiliser un négatif clés pour indexer les données.

InformationsquelleAutor Ricardo Carmo

De tri à côté client est simple et pas besoin de plus de ressources système.
Chaque instantané de données a previousChildkey champ. Si vous voulez desc de tri, imaginez previousChildkey est nextChildKey.
Voici mon exemple:

class LessonFirebaseArray<ObjectModel>{

  private ArrayList<ObjectModel> mItems;
  ...
  public LessonFirebaseArray() {
    mItems = new ArrayList<>();
  }

  public int addItem(ObjectModel item, boolean isReverse){
    int index;
    if (item.getPreviousChildKey() != null) {
      index = getIndexForKey(item.getPreviousChildKey());
      if (index < 0) {
        index = mItems.size();
      }else if(index>0 && !isReverse) {
        index = index + 1;      
      }
    }else{
      index = mItems.size();
    }
    mItems.add(index, item);
    notifyInsertedListeners(index);
    return index;
  }

  private int getIndexForKey(String key) {
    int index = 0;
    for (ObjectModel snapshot : mItems) {
      if (snapshot.getKey().equals(key)) {
         return index;
      } else {
         index++;
      }
    }
    return -1;
  }

  private void notifyInsertedListeners(int index) {
    if (mListener != null) {
      mListener.onInserted(index);
    }
  }
}

InformationsquelleAutor lee

Tri des articles par date peut être fait en utilisant android.support.v7.util.SortedList

  class post{
private Object time; 

public Object getTime() {
        return time;
    }

public void setTime(Object time) {
    this.time = time;
}
                        ...//rest code}

SortedList<post> data;

 data = new SortedList<post>(post.class, new SortedList.Callback<post>() {
        @Override
        public int compare(post o1, post o2) {
            Long o1l = Long.parseLong(o1.getTime().toString());
            Long o2l = Long.parseLong(o2.getTime().toString());

            return o2l.compareTo(o1l);
        }......//rest code


ref.addChildEventListener(new ChildEventListener() {
              @Override
              public void onChildAdded(DataSnapshot dataSnapshot, String s) {
                 mSwipeRefreshLayout.setRefreshing(true);
                  post p=dataSnapshot.getValue(post.class);


                  data.add(p);



              }...//rest code

android.support.v7.util.SortedList peut également être utilisé avec RecyclerView

InformationsquelleAutor Asad Mirza

Si vous le faites sur le web, alors vous pouvez le pousser à valeurs dans un tableau et ensuite imprimer les valeurs stockées dans l'ordre inverse.

var a=[]; //declaring an array a.
var num=snapshot.numChildren(); //storing number of children in var num.
a.push(snapshot.val()); //pushing data in the array.
if (a.length==num){ //checking if length of array is same as number of children.
a.reverse(); //reversing the array elements.
for(i=0; i<num; i++){
a[i].name;//this will sort the data in descending order.
}
}

InformationsquelleAutor Saurabh

0

ajouter une colonne à savoir timestamp avec des valeurs (-1*System.currentTimeMillis())
et lors de l'extraction de données à utiliser orderByChild("timestamp").limitToFirst(15)
ou orderByChild("timestamp").limitToLast(15) selon votre condition.
il est smartway pour obtenir des données de tri, comme firebase a pas de règle pour l'ordre décroissant.
- je ne sais pas pourquoi certaines personnes donnent des votes négatifs? au moins, ils sud donner raison. 🙁
InformationsquelleAutor Durgesh Kumar

-1

Swift 3:

    let query = firebase.child(YourQueryPath).queryOrdered(byChild: YourQueryChild).queryLimited(toLast: YourLimit)

    query.observeSingleEvent(of: .value, with: { (snapshot) in
         //Reverse order here to get top **YourLimit** results in descending order
    })

InformationsquelleAutor Crashalot

Vous devez vous connecter pour publier un commentaire.