import com.google.firebase.database.Transaction; //导入依赖的package包/类
private TransactionData(
    Path path,
    Transaction.Handler handler,
    ValueEventListener outstandingListener,
    TransactionStatus status,
    boolean applyLocally,
    long order) {
  this.path = path;
  this.handler = handler;
  this.outstandingListener = outstandingListener;
  this.status = status;
  this.retryCount = 0;
  this.applyLocally = applyLocally;
  this.order = order;
  this.abortReason = null;
  this.currentInputSnapshot = null;
  this.currentOutputSnapshotRaw = null;
  this.currentOutputSnapshotResolved = null;
}
 

import com.google.firebase.database.Transaction; //导入依赖的package包/类
public static void runPostViewsCountTransition(DatabaseReference postRef) {
    postRef.runTransaction(new Transaction.Handler() {
        @Override
        public Transaction.Result doTransaction(MutableData mutableData) {
            Post post = mutableData.getValue(Post.class);
            if (post == null) {
                return Transaction.success(mutableData);
            }

            int viewsCount = post.getViews() + 1;

            post.setViews(viewsCount);
            mutableData.setValue(post);
            return Transaction.success(mutableData);
        }

        @Override
        public void onComplete(DatabaseError databaseError, boolean b, DataSnapshot dataSnapshot) {
            showLog("runCommentsCountTransition " + (databaseError != null));

                    /* if (databaseError == null) {
                        errorListener.onError();
                    }*/
        }
    });
}
 

import com.google.firebase.database.Transaction; //导入依赖的package包/类
public void updateProfileLikeCountAfterRemovingPost(Post post) {
    DatabaseReference profileRef = database.getReference("profiles/" + post.getAuthorId() + "/likesCount");
    final long likesByPostCount = post.getLikesCount();

    profileRef.runTransaction(new Transaction.Handler() {
        @Override
        public Transaction.Result doTransaction(MutableData mutableData) {
            Integer currentValue = mutableData.getValue(Integer.class);
            if (currentValue != null && currentValue >= likesByPostCount) {
                mutableData.setValue(currentValue - likesByPostCount);
            }

            return Transaction.success(mutableData);
        }

        @Override
        public void onComplete(DatabaseError databaseError, boolean b, DataSnapshot dataSnapshot) {
            LogUtil.logInfo(TAG, "Updating likes count transaction is completed.");
        }
    });

}
 

import com.google.firebase.database.Transaction; //导入依赖的package包/类
public void decrementCommentsCount(String postId, final OnTaskCompleteListener onTaskCompleteListener) {
    DatabaseReference postRef = database.getReference("posts/" + postId + "/commentsCount");
    postRef.runTransaction(new Transaction.Handler() {
        @Override
        public Transaction.Result doTransaction(MutableData mutableData) {
            Integer currentValue = mutableData.getValue(Integer.class);
            if (currentValue != null && currentValue >= 1) {
                mutableData.setValue(currentValue - 1);
            }

            return Transaction.success(mutableData);
        }

        @Override
        public void onComplete(DatabaseError databaseError, boolean b, DataSnapshot dataSnapshot) {
            LogUtil.logInfo(TAG, "Updating comments count transaction is completed.");
            if (onTaskCompleteListener != null) {
                onTaskCompleteListener.onTaskComplete(true);
            }
        }
    });
}
 

import com.google.firebase.database.Transaction; //导入依赖的package包/类
public void incrementWatchersCount(String postId) {
    DatabaseReference postRef = database.getReference("posts/" + postId + "/watchersCount");
    postRef.runTransaction(new Transaction.Handler() {
        @Override
        public Transaction.Result doTransaction(MutableData mutableData) {
            Integer currentValue = mutableData.getValue(Integer.class);
            if (currentValue == null) {
                mutableData.setValue(1);
            } else {
                mutableData.setValue(currentValue + 1);
            }

            return Transaction.success(mutableData);
        }

        @Override
        public void onComplete(DatabaseError databaseError, boolean b, DataSnapshot dataSnapshot) {
            LogUtil.logInfo(TAG, "Updating Watchers count transaction is completed.");
        }
    });
}
 

import com.google.firebase.database.Transaction; //导入依赖的package包/类
@Override public void subscribe(final CompletableEmitter emitter) {
  final Transaction.Handler handler = new Transaction.Handler() {
    @Override public Transaction.Result doTransaction(MutableData mutableData) {
      try {
        return task.apply(mutableData);
      } catch (Exception e) {
        //TODO: Is this enough?
        throw new RuntimeException(e);
      }
    }

    @Override public void onComplete(DatabaseError databaseError, boolean committed,
        DataSnapshot dataSnapshot) {
      if (!emitter.isDisposed()) {
        if (null == databaseError) {
          emitter.onComplete();
        } else {
          emitter.onError(databaseError.toException());
        }
      }
    }
  };

  ref.runTransaction(handler, fireLocalEvents);
}
 

import com.google.firebase.database.Transaction; //导入依赖的package包/类
public void doTransaction(String uid, final OnMilestoneTransaction listener){
    FirebaseUser user = FirebaseAuth.getInstance().getCurrentUser();
    if(user!=null) {
        String key;
        if(uid==null || uid.isEmpty())
            return;
        DatabaseReference mRef = mDatabase.child(Constants.FIREBASE_MILESTONES).child(user.getUid()).child(SessionSingleton.getInstance().currentCar.getid()).child(uid);
        mRef.runTransaction(new Transaction.Handler() {
            @Override
            public Transaction.Result doTransaction(MutableData mutableData) {
                Milestone milestone = mutableData.getValue(Milestone.class);
                if(milestone==null)
                    return Transaction.success(mutableData);
                milestone = listener.onTransaction(milestone);
                mutableData.setValue(milestone);
                return Transaction.success(mutableData);
            }

            @Override
            public void onComplete(DatabaseError databaseError, boolean b, DataSnapshot dataSnapshot) {

            }
        });
    }
}
 

import com.google.firebase.database.Transaction; //导入依赖的package包/类
public void incrementUserSongRequestCount(String partyTitle, String userId) {
    databaseReference
        .child(partyTitle)
        .child(FirebaseConstants.CHILD_USERS)
        .child(userId)
        .child(FirebaseConstants.CHILD_USERS_SONGS_REQUESTED)
        .runTransaction(new Transaction.Handler() {
            @Override
            public Transaction.Result doTransaction(MutableData currentData) {
                if (currentData.getValue() == null) {
                    currentData.setValue(1);
                }
                else {
                    currentData.setValue((Long) currentData.getValue() + 1);
                }
                return Transaction.success(currentData);
            }

            @Override
            public void onComplete(DatabaseError databaseError, boolean b, DataSnapshot dataSnapshot) {

            }
        });
}
 

import com.google.firebase.database.Transaction; //导入依赖的package包/类
@Override
public void setLeader(String deckId, final String leaderId) {
    DatabaseReference deckReference = mUserReference.child(deckId).child("leaderId");

    // Transactions will ensure concurrency errors don't occur.
    deckReference.runTransaction(new Transaction.Handler() {
        @Override
        public Transaction.Result doTransaction(MutableData mutableData) {
            // Set value and report transaction success.
            mutableData.setValue(leaderId);
            return Transaction.success(mutableData);
        }

        @Override
        public void onComplete(DatabaseError databaseError, boolean b,
                               DataSnapshot dataSnapshot) {
            // Do nothing.
        }
    });
}
 

import com.google.firebase.database.Transaction; //导入依赖的package包/类
@Override
public void renameDeck(final String deckId, final String newName) {
    DatabaseReference deckReference = mUserReference.child(deckId).child("name");

    // Transactions will ensure concurrency errors don't occur.
    deckReference.runTransaction(new Transaction.Handler() {
        @Override
        public Transaction.Result doTransaction(MutableData mutableData) {
            // Set value and report transaction success.
            mutableData.setValue(newName);
            return Transaction.success(mutableData);
        }

        @Override
        public void onComplete(DatabaseError databaseError, boolean b,
                               DataSnapshot dataSnapshot) {
            // Do nothing.
        }
    });
}
 

import com.google.firebase.database.Transaction; //导入依赖的package包/类
@Override
public void deleteDeck(final String deckId) {
    DatabaseReference deckReference = mUserReference.child(deckId).child("deleted");

    // Transactions will ensure concurrency errors don't occur.
    deckReference.runTransaction(new Transaction.Handler() {
        @Override
        public Transaction.Result doTransaction(MutableData mutableData) {
            // Set value and report transaction success.
            mutableData.setValue(true);
            return Transaction.success(mutableData);
        }

        @Override
        public void onComplete(DatabaseError databaseError, boolean b,
                               DataSnapshot dataSnapshot) {
            // Do nothing.
        }
    });
}
 

import com.google.firebase.database.Transaction; //导入依赖的package包/类
private void runTransactionOnComplete(Transaction.Handler handler, DatabaseError error,
    boolean committed, DataSnapshot snapshot) {
  try {
    handler.onComplete(error, committed, snapshot);
  } catch (Exception e) {
    operationLogger.error("Exception in transaction onComplete callback", e);
  }
}
 

import com.google.firebase.database.Transaction; //导入依赖的package包/类
private void onStarClicked(DatabaseReference postRef) {
    postRef.runTransaction(new Transaction.Handler() {
        @Override
        public Transaction.Result doTransaction(MutableData mutableData) {
            Post p = mutableData.getValue(Post.class);
            if (p == null) {
                return Transaction.success(mutableData);
            }

            if (p.stars.containsKey(getUid())) {
                // Unstar the post and remove self from stars
                p.starCount = p.starCount - 1;
                p.stars.remove(getUid());
            } else {
                // Star the post and add self to stars
                p.starCount = p.starCount + 1;
                p.stars.put(getUid(), true);
            }

            // Set value and report transaction success
            mutableData.setValue(p);
            return Transaction.success(mutableData);
        }

        @Override
        public void onComplete(DatabaseError databaseError, boolean b,
                               DataSnapshot dataSnapshot) {
            // Transaction completed
            Log.d(TAG, "postTransaction:onComplete:" + databaseError);
        }
    });
}
 

import com.google.firebase.database.Transaction; //导入依赖的package包/类
/**
 * Run a transaction on the data at this location. For more information on running transactions, see
 *
 * @param ref              reference represents a particular location in your database.
 * @param fireLocalEvents  boolean which allow to receive calls of your transaction in your local device.
 * @param transactionValue value of the transaction.
 * @return a {@link Single} which emits the final {@link DataSnapshot} value if the transaction success.
 */
@NonNull
public static Single<DataSnapshot> runTransaction(@NonNull final DatabaseReference ref,
                                                  @NonNull final boolean fireLocalEvents,
                                                  @NonNull final long transactionValue) {
   return Single.create(new SingleOnSubscribe<DataSnapshot>() {
      @Override public void subscribe(final SingleEmitter emitter) throws Exception {
         ref.runTransaction(new Transaction.Handler() {
            @Override
            public Transaction.Result doTransaction(MutableData mutableData) {
               Integer currentValue = mutableData.getValue(Integer.class);
               if (currentValue == null) {
                  mutableData.setValue(transactionValue);
               } else {
                  mutableData.setValue(currentValue + transactionValue);
               }
               return Transaction.success(mutableData);
            }

            @Override
            public void onComplete(DatabaseError databaseError, boolean b, DataSnapshot dataSnapshot) {
               if (databaseError != null) {
                  emitter.onError(new RxFirebaseDataException(databaseError));
               } else {
                  emitter.onSuccess(dataSnapshot);
               }
            }
         }, fireLocalEvents);
      }
   });
}
 

import com.google.firebase.database.Transaction; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
@SuppressWarnings("unchecked")
public <T, R extends T> void transaction(final Class<T> dataType, final TransactionCallback<R> transactionCallback, final CompleteCallback completeCallback)
{
    databaseReference().runTransaction(new Transaction.Handler() {
        @Override
        public Transaction.Result doTransaction(MutableData mutableData)
        {
            R transactionData = null;
            if (dataType == List.class || dataType == Map.class) {
                transactionData = (R) mutableData.getValue();
            } else {
                transactionData = (R) mutableData.getValue(dataType);
            }
            mutableData.setValue(transactionCallback.run(transactionData));
            return Transaction.success(mutableData);
        }

        @Override
        public void onComplete(DatabaseError databaseError, boolean b, DataSnapshot dataSnapshot)
        {
            if (completeCallback == null) return;
            if (databaseError != null) {
                completeCallback.onError(databaseError.toException());
            } else {
                completeCallback.onSuccess();
            }
        }
    });
    terminateOperation();
}
 

import com.google.firebase.database.Transaction; //导入依赖的package包/类
/**
 * Decrement or increment commentsCount
 *
 * @param postRef   the Post reference to run transaction
 * @param increment if TRUE it wil increment, if FALSE it will decrement.
 */
public static void runCommentsCountTransition(DatabaseReference postRef, final boolean increment) {
    postRef.runTransaction(new Transaction.Handler() {
        @Override
        public Transaction.Result doTransaction(MutableData mutableData) {
            Post post = mutableData.getValue(Post.class);
            if (post == null) {
                return Transaction.success(mutableData);
            }

            int commentsCount = post.getCommentsCount();
            int data = increment ? commentsCount + 1 : commentsCount - 1;

            post.setCommentsCount(data);

            //update localy
            RepositoryManager.getInstance()
                    .getPostsRepository()
                    .updateLocaly(post);

            mutableData.setValue(post);
            return Transaction.success(mutableData);
        }

        @Override
        public void onComplete(DatabaseError databaseError, boolean b, DataSnapshot dataSnapshot) {
            showLog("runCommentsCountTransition: " + (databaseError != null));
        }
    });
}
 

import com.google.firebase.database.Transaction; //导入依赖的package包/类
@Before public void setup() {
  MockitoAnnotations.initMocks(this);

  childEventListener = ArgumentCaptor.forClass(ChildEventListener.class);
  valueEventListener = ArgumentCaptor.forClass(ValueEventListener.class);
  transactionHandler = ArgumentCaptor.forClass(Transaction.Handler.class);
  onCompleteListener = ArgumentCaptor.forClass(OnCompleteListener.class);
}
 

import com.google.firebase.database.Transaction; //导入依赖的package包/类
private void onLikeClicked(final DatabaseReference likeRef) {
    likeRef.runTransaction(new Transaction.Handler() {
        @Override
        public Transaction.Result doTransaction(MutableData mutableData) {
            Photo p = mutableData.getValue(Photo.class);
            if (p == null) {
                return Transaction.success(mutableData);
            }

            if (p.likes.containsKey(mUserId)) {
                // Unlike the photo and remove self from likes
                p.starCount = p.starCount - 1;
                p.likes.remove(mUserId);
                Log.d(TAG, "doTransaction: Unlike");
            } else {
                // Like the photo
                Log.d(TAG, "doTransaction: Like");
                p.starCount = p.starCount + 1;
                p.likes.put(mUserId, true);
            }
            // Set value and report transaction success
            mutableData.setValue(p);
            return Transaction.success(mutableData);
        }

        @Override
        public void onComplete(DatabaseError databaseError, boolean b,
                               DataSnapshot dataSnapshot) {
            // Transaction completed
            Log.d(TAG, "postTransaction:onComplete:" + databaseError);
        }
    });
}
 

import com.google.firebase.database.Transaction; //导入依赖的package包/类
public void incrementApkDownloads(Apk app) {
    databaseReference.child(app.getKey()).child("downloads").runTransaction(
            new Transaction.Handler() {
        @Override
        public Transaction.Result doTransaction(MutableData mutableData) {
            Long updatedViews = mutableData.getValue(Long.class) + 1;
            mutableData.setValue(updatedViews);
            return Transaction.success(mutableData);
        }

        @Override
        public void onComplete(DatabaseError databaseError, boolean b, DataSnapshot dataSnapshot) {
        }
    });
}
 

import com.google.firebase.database.Transaction; //导入依赖的package包/类
public void incrementApkViews(Apk app) {
    databaseReference.child(app.getKey()).child("views").runTransaction(
            new Transaction.Handler() {
        @Override
        public Transaction.Result doTransaction(MutableData mutableData) {
            Long updatedViews = mutableData.getValue(Long.class) + 1;
            mutableData.setValue(updatedViews);
            return Transaction.success(mutableData);
        }

        @Override
        public void onComplete(DatabaseError databaseError, boolean b, DataSnapshot dataSnapshot) {
        }
    });
}