Xmpp 聊天messenger应用程序的自动化

我想自动化我们的一个官方应用程序，它就像Whatsapp一样工作。为了测试这一点，需要同时打开两个设备，然后使用一个设备发送消息/图像或创建一个组。然后，同时，在其他设备上检查所有操作是否成功完成（收到消息，添加为组成员）。 应用程序基于XMPP

---

有谁能建议如何继续以及我们可以使用哪种工具来自动化功能吗？

好的，您可以实现自己的自定义

节

如

扩展

就像我看到的消息状态一样

首先创建类like Seen类，该类实现了

PacketExtension

like Seen

public class Seen implements PacketExtension, Parcelable {
    public static final String NAMESPACE = "jabber:client";
    public static final String ELEMENT_NAME = "seen";
    public static final String TAG_NAME_NAME = "from";

    private String from;

    public Seen() {}

    public Seen(Parcel parcel) {
        from = parcel.readString();
    }

    public String getName() {
        return name;
    }

    @Override
    public String getElementName() {
        return ELEMENT_NAME;
    }

    @Override
    public String getNamespace() {
        return NAMESPACE;
    }

    @Override
    public CharSequence toXML() {
        return String.format("<seen xmlns='jabber:client'><from>%s</from></seen>", from);
    }

    public String getSeen() {
        return seen;
    }


    public void setSeen(String seen) {
        this.seen = seen;
    }    

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeString(address);
        dest.writeDouble(latitude);
        dest.writeDouble(longitude);
    }

    public static final Parcelable.Creator<Seen> CREATOR = new Creator<Seen>() {

        @Override
        public Seen createFromParcel(Parcel source) {
            return new Seen(source);
        }

        @Override
        public Seen[] newArray(int size) {
            return new Seen[size];
        }
    };
}

第三，您必须拥有实现

PacketListener

的

MessagePacketListener

，当您收到消息节时，您会检查它是否是重写方法processPacket中Seen类的

实例，如：

@Override
    public void processPacket(Packet packet) {
        Message msg = (Message)packet;      

        Collection<PacketExtension> extensions = msg.getExtensions();
        if (extensions != null) {
            Iterator<PacketExtension> iterator = extensions.iterator();
            if (iterator.hasNext()) {
                PacketExtension extension = iterator.next();
                if (extension instanceof Seen) {
                    //Do sth
                }
            }
        }
    }

@Override
    public void processPacket(Packet packet) {
        Message msg = (Message)packet;      

        Collection<PacketExtension> extensions = msg.getExtensions();
        if (extensions != null) {
            Iterator<PacketExtension> iterator = extensions.iterator();
            if (iterator.hasNext()) {
                PacketExtension extension = iterator.next();
                if (extension instanceof Seen) {
                    //Do sth
                }
            }
        }
    }

Seen seen = new Seen();
seen.setFrom("FromUser");
PacketExtension packetExtension = seen;
sendChatMessage(to, body, packetExtension);

public void sendChatMessage(String to, String body, PacketExtension packetExtension) throws SmackInvocationException {
            Message message = new Message(to, Message.Type.chat);
            message.setBody(body);
            if (packetExtension != null) {
                message.addExtension(packetExtension);
            }
            try {
                con.sendPacket(message);
            } catch (NotConnectedException e) {
                throw new SmackInvocationException(e);
            }
        }