推送通知发送给发送消息的用户，而不是接收者

Question

如果他们向您发送消息，我已经创建了一种向其他用户发送通知的方法。 我目前遇到的问题是发送消息的用户是接收通知的用户。 显然，我希望其他用户，即通知要接收它的用户。

所以我在我的模拟器和实际设备上对此进行了测试，当我发送通知时，我会收到通知，然后当我用另一个设备查看消息时，我会收到另一个发送到同一设备的通知。

所以基本上我收到两个通知都发送到发送消息的同一设备。 如何修复它，以便只有通知所针对的用户接收它，而没有其他人，我也没有收到它？

我一直在尝试更改我的if statement ，我认为这是这里的关键，但一直无法弄清楚。 建议？

在我的sendNotification(); 方法我有这条线if(mFirebaseUser.getUid.equals(receiver)) {...}所以不应该让它显示在通知的设备上吗？

消息活动

public class MessageActivity extends AppCompatActivity {

    TextView mUsername;
    TextView mButtonSend;
    EditText mTextSend;

    FirebaseUser mFirebaseUser;
    DatabaseReference mReference;

    MessageAdapter mMessageAdapter;
    List<Chat> mChat;
    RecyclerView mRecyclerView;

    String mId;
    String mMessageId;
    String mUserId;

    String NOTIFICATION_CHANNEL_ID = "e.events.Notifications.test";
    String NOTIFICATION_CHANNEL_NAME = "Events";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_message);

        mId = getIntent().getStringExtra("id");
        mFirebaseUser = FirebaseAuth.getInstance().getCurrentUser();
        mUserId = getIntent().getStringExtra("userid");

        mButtonSend.setOnClickListener(v -> {
            String message = mTextSend.getText().toString();
            if (!message.equals("")) {
                sendMessage(mFirebaseUser.getUid(), mId, message);
                sendNotification();
            } else {
                Toast.makeText(MessageActivity.this, "Write something", Toast.LENGTH_SHORT).show();
            }
            mTextSend.setText("");
        });

        getUserInfo();
        seenMessage(mId);
    }

    private void sendNotification() {
        DatabaseReference reference = FirebaseDatabase.getInstance().getReference("Chats").child(mMessageId);
        reference.addValueEventListener(new ValueEventListener() {
            @Override
            public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
                if (dataSnapshot.exists()) {
                    String receiver = dataSnapshot.child("receiver").getValue(String.class);
                    if (mFirebaseUser.getUId().equals(receiver)) {
                            showNotification();
                }
            }

            @Override
            public void onCancelled(@NonNull DatabaseError databaseError) {

            }
        });
    }

    private void showNotification() {
        DatabaseReference reference = FirebaseDatabase.getInstance().getReference("Chats").child(mMessageId);
        reference.addValueEventListener(new ValueEventListener() {
            @Override
            public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
                if (dataSnapshot.exists()) {
                    String message = dataSnapshot.child("message").getValue(String.class);

                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                        NotificationChannel notificationChannel = new NotificationChannel(NOTIFICATION_CHANNEL_ID, NOTIFICATION_CHANNEL_NAME, NotificationManager.IMPORTANCE_HIGH);

                        NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
                        notificationManager.createNotificationChannel(notificationChannel);

                        NotificationCompat.Builder builder = new NotificationCompat.Builder(MessageActivity.this, NOTIFICATION_CHANNEL_ID)
                                .setContentTitle("Events")
                                .setContentText(message)
                                .setSmallIcon(R.mipmap.ic_launcher)
                                .setAutoCancel(true);

                        NotificationManagerCompat notificationManagerCompat = NotificationManagerCompat.from(MessageActivity.this);
                        notificationManagerCompat.notify(999, builder.build());
                    }
                }
            }

            @Override
            public void onCancelled(@NonNull DatabaseError databaseError) {

            }
        });
    }

    private void sendMessage(String sender, final String receiver, String message) {
        DatabaseReference reference = FirebaseDatabase.getInstance().getReference("Chats");

        Date date = Calendar.getInstance().getTime();
        String formattedDate = DateFormat.getDateInstance(DateFormat.FULL).format(date);

        String time = null;
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
            time = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm"));
        }

        mMessageId = reference.push().getKey();

        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("sender", sender);
        hashMap.put("receiver", receiver);
        hashMap.put("message", message);
        hashMap.put("isseen", false);
        hashMap.put("date", formattedDate);
        hashMap.put("time", time);
        hashMap.put("timestamp", ServerValue.TIMESTAMP);
        hashMap.put("messageId", mMessageId);

        reference.child(mMessageId).setValue(hashMap);

        final DatabaseReference chatReference = FirebaseDatabase.getInstance().getReference("Chatlist").child(mFirebaseUser.getUid()).child(mId);
        chatReference.addListenerForSingleValueEvent(new ValueEventListener() {
            @Override
            public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
                if (!dataSnapshot.exists()) {
                    chatReference.child("receiver").setValue(mId);
                }
            }

            @Override
            public void onCancelled(@NonNull DatabaseError databaseError) {

            }
        });

        final DatabaseReference chatReferenceReceiver = FirebaseDatabase.getInstance().getReference("Chatlist").child(mId).child(mFirebaseUser.getUid());
        chatReferenceReceiver.child("receiver").setValue(mFirebaseUser.getUid());
    }

    private void readMessages(final String myid, final String userid, final String imageurl) {
        mChat = new ArrayList<>();
        mReference = FirebaseDatabase.getInstance().getReference("Chats");
        mReference.addValueEventListener(new ValueEventListener() {
            @Override
            public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
                mChat.clear();
                for (DataSnapshot snapshot : dataSnapshot.getChildren()) {
                    Chat chat = snapshot.getValue(Chat.class);
                    if (chat != null) {
                        if (chat.getReceiver().equals(myid) && chat.getSender().equals(userid) || chat.getReceiver().equals(userid) && chat.getSender().equals(myid)) {
                            mChat.add(chat);
                        }
                    }

                    mMessageAdapter = new MessageAdapter(MessageActivity.this, mChat, imageurl);
                    mRecyclerView.setAdapter(mMessageAdapter);
                }
            }

            @Override
            public void onCancelled(@NonNull DatabaseError databaseError) {

            }
        });
    }

Answer 1

您的 sendNotification() 方法看起来是多余的。

据我所知，以下是您期望的流程：

1. 用户 A 点击发送按钮mButtonSend

2. 单击操作触发sendMessage(...)将聊天消息写入 Firestore

3. 用户 B 为chats集合设置了一个侦听器，因此每当在 firestore 中写入新聊天时，侦听器都会收到一个事件

4. 当该侦听器接收到一个事件时，它会做两件事——它通过调用 showNotification() 将通知排队，并将接收到的聊天推送到适配器中。

现在，上面的代码存在几个问题：

1. 您正在设置几个不必要的侦听器。 您应该在接收事件的chat集合上只设置一个侦听器。 目前，您在sendNotification 、 showNotification 、 sendMessage和readMessages方法中设置了监听器。

2. 在mButtonSend点击监听器中，您同时调用了sendMessage和sendNotification方法。 相反，您应该只调用sendMessage方法来写入 Firestore。 您可以删除sendNotification调用以及方法实现本身

3. 一旦将代码重构为只有一个侦听器，就可以在该侦听器事件中调用showNotifcation方法。 您仍然需要实施一些技巧来避免两个用户都收到通知。 例如=当在chat收集监听器中收到新事件时，您可以检查消息的作者是谁。 如果current user id == author id则不显示通知，否则显示。

4. 根据您当前的设计 - 如果接收者用户没有应用程序并且活动打开，他将不会收到通知，因为只要活动存在，侦听器就存在。 如果您希望即使用户没有打开应用程序也能发送通知 - 您需要使用 FCM 或任何其他推送消息机制。