Merge branch 'dev' into firestore

Change-Id: Ide7735cf4a4114e4d9fac9120c8a479385507bda

Author: samtstern

app/src/main/java/com/firebase/uidemo/database/ChatActivity.java

@@ -146,7 +146,7 @@ protected FirebaseRecyclerAdapter<Chat, ChatHolder> getAdapter() {
                 lastFifty,
                 this) {
             @Override
-            public void populateViewHolder(ChatHolder holder, Chat chat, int position) {
+            public void populateViewHolder(ChatHolder holder, Cgit hat chat, int position) {
                 holder.bind(chat);
             }
 

app/src/main/java/com/firebase/uidemo/database/ChatIndexActivity.java

@@ -1,6 +1,5 @@
 package com.firebase.uidemo.database;
 
-import android.os.Bundle;
 import android.view.View;
 
 import com.firebase.ui.database.FirebaseIndexRecyclerAdapter;
@@ -13,12 +12,6 @@
 public class ChatIndexActivity extends ChatActivity {
     private DatabaseReference mChatIndicesRef;
 
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        mChatIndicesRef = FirebaseDatabase.getInstance().getReference().child("chatIndices");
-    }
-
     @Override
     public void onClick(View v) {
         String uid = FirebaseAuth.getInstance().getCurrentUser().getUid();
@@ -34,6 +27,11 @@ public void onClick(View v) {
 
     @Override
     protected FirebaseRecyclerAdapter<Chat, ChatHolder> getAdapter() {
+        mChatIndicesRef = FirebaseDatabase.getInstance()
+                .getReference()
+                .child("chatIndices")
+                .child(FirebaseAuth.getInstance().getCurrentUser().getUid());
+
         return new FirebaseIndexRecyclerAdapter<Chat, ChatHolder>(
                 Chat.class,
                 R.layout.message,

auth/src/main/java/com/firebase/ui/auth/ui/ImeHelper.java

@@ -17,9 +17,15 @@ public static void setImeOnDoneListener(EditText doneEditText,
         doneEditText.setOnEditorActionListener(new TextView.OnEditorActionListener() {
             @Override
             public boolean onEditorAction(TextView view, int actionId, KeyEvent event) {
-                if (event != null
-                        && event.getKeyCode() == KeyEvent.KEYCODE_ENTER
-                        || actionId == EditorInfo.IME_ACTION_DONE) {
+                if (event != null && event.getKeyCode() == KeyEvent.KEYCODE_ENTER) {
+                    if (event.getAction() == KeyEvent.ACTION_UP) {
+                        listener.onDonePressed();
+                    }
+
+                    // We need to return true even if we didn't handle the event to continue
+                    // receiving future callbacks.
+                    return true;
+                } else if (actionId == EditorInfo.IME_ACTION_DONE) {
                     listener.onDonePressed();
                     return true;
                 }

database/src/main/java/com/firebase/ui/database/FirebaseArray.java

@@ -107,11 +107,10 @@ public void onChildMoved(DataSnapshot snapshot, String previousChildKey) {
         int oldIndex = getIndexForKey(snapshot.getKey());
         mSnapshots.remove(oldIndex);
 
-        int newIndex = previousChildKey == null ? 0 : (getIndexForKey(previousChildKey) + 1);
+        int newIndex = previousChildKey == null ? 0 : getIndexForKey(previousChildKey) + 1;
         mSnapshots.add(newIndex, snapshot);
 
-        notifyListenersOnChildChanged(ChangeEventType.MOVED, snapshot,
-                newIndex, oldIndex);
+        notifyListenersOnChildChanged(ChangeEventType.MOVED, snapshot, newIndex, oldIndex);
     }
 
     @Override

database/src/main/java/com/firebase/ui/database/FirebaseIndexArray.java

@@ -141,18 +141,32 @@ protected List<DataSnapshot> getSnapshots() {
         return mDataSnapshots;
     }
 
-    private int getIndexForKey(String key) {
-        int dataCount = size();
-        int index = 0;
-        for (int keyIndex = 0; index < dataCount; keyIndex++) {
-            String superKey = mKeySnapshots.getObject(keyIndex);
-            if (key.equals(superKey)) {
-                break;
-            } else if (mDataSnapshots.get(index).getKey().equals(superKey)) {
-                index++;
+    private int returnOrFindIndexForKey(int index, String key) {
+        int realIndex;
+        if (isKeyAtIndex(key, index)) {
+            // To optimize this query, if the expected item position is accurate, we simply return
+            // it instead of searching for it in our keys all over again. This ensures developers
+            // correctly indexing their data (i.e. no null values) don't take a performance hit.
+            realIndex = index;
+        } else {
+            int dataCount = size();
+            int dataIndex = 0;
+            int keyIndex = 0;
+
+            while (dataIndex < dataCount && keyIndex < mKeySnapshots.size()) {
+                String superKey = mKeySnapshots.getObject(keyIndex);
+                if (key.equals(superKey)) {
+                    break;
+                } else if (mDataSnapshots.get(dataIndex).getKey().equals(superKey)) {
+                    // Only increment the data index if we aren't passing over a null value snapshot.
+                    dataIndex++;
+                }
+                keyIndex++;
             }
+
+            realIndex = dataIndex;
         }
-        return index;
+        return realIndex;
     }
 
     /**
@@ -174,10 +188,15 @@ protected void onKeyAdded(DataSnapshot data) {
     protected void onKeyMoved(DataSnapshot data, int index, int oldIndex) {
         String key = data.getKey();
 
+        // We can't use `returnOrFindIndexForKey(...)` for `oldIndex` or it might find the updated
+        // index instead of the old one. Unfortunately, this does mean move events will be
+        // incorrectly ignored if our list is a subset of the key list e.g. a key has null data.
         if (isKeyAtIndex(key, oldIndex)) {
             DataSnapshot snapshot = removeData(oldIndex);
+            int realIndex = returnOrFindIndexForKey(index, key);
             mHasPendingMoveOrDelete = true;
-            mDataSnapshots.add(index, snapshot);
+
+            mDataSnapshots.add(realIndex, snapshot);
             notifyListenersOnChildChanged(ChangeEventType.MOVED, snapshot, index, oldIndex);
         }
     }
@@ -187,10 +206,11 @@ protected void onKeyRemoved(DataSnapshot data, int index) {
         ValueEventListener listener = mRefs.remove(mDataRef.getRef().child(key));
         if (listener != null) mDataRef.child(key).removeEventListener(listener);
 
-        if (isKeyAtIndex(key, index)) {
-            DataSnapshot snapshot = removeData(index);
+        int realIndex = returnOrFindIndexForKey(index, key);
+        if (isKeyAtIndex(key, realIndex)) {
+            DataSnapshot snapshot = removeData(realIndex);
             mHasPendingMoveOrDelete = true;
-            notifyListenersOnChildChanged(ChangeEventType.REMOVED, snapshot, index, -1);
+            notifyListenersOnChildChanged(ChangeEventType.REMOVED, snapshot, realIndex, -1);
         }
     }
 
@@ -236,10 +256,13 @@ public String toString() {
      * A ValueEventListener attached to the joined child data.
      */
     protected class DataRefListener implements ValueEventListener {
+        /** Cached index to skip searching for the current index on each update */
+        private int currentIndex;
+
         @Override
         public void onDataChange(DataSnapshot snapshot) {
             String key = snapshot.getKey();
-            int index = getIndexForKey(key);
+            int index = currentIndex = returnOrFindIndexForKey(currentIndex, key);
 
             if (snapshot.getValue() != null) {
                 if (isKeyAtIndex(key, index)) {