From e266b1acd804c428cde26fa99fac265d9811612e Mon Sep 17 00:00:00 2001 From: Fernando Ramirez Date: Mon, 31 Oct 2016 13:48:22 -0300 Subject: [PATCH] Push Notifications (XEP-0357) implementation Fixes SMACK-738 --- documentation/extensions/index.md | 1 + documentation/extensions/pushnotifications.md | 82 +++++++++ .../PushNotificationsManager.java | 169 ++++++++++++++++++ .../element/DisablePushNotificationsIQ.java | 82 +++++++++ .../element/EnablePushNotificationsIQ.java | 119 ++++++++++++ .../element/PushNotificationsElements.java | 100 +++++++++++ .../element/package-info.java | 20 +++ .../push_notifications/package-info.java | 20 +++ .../provider/RemoteDisablingProvider.java | 60 +++++++ .../provider/package-info.java | 20 +++ .../experimental.providers | 9 +- .../DisablePushNotificationsIQTest.java | 49 +++++ .../EnablePushNotificationsIQTest.java | 58 ++++++ .../RemoteDisablingPushNotificationsTest.java | 67 +++++++ 14 files changed, 855 insertions(+), 1 deletion(-) create mode 100644 documentation/extensions/pushnotifications.md create mode 100644 smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/PushNotificationsManager.java create mode 100644 smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/element/DisablePushNotificationsIQ.java create mode 100644 smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/element/EnablePushNotificationsIQ.java create mode 100644 smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/element/PushNotificationsElements.java create mode 100644 smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/element/package-info.java create mode 100644 smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/package-info.java create mode 100644 smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/provider/RemoteDisablingProvider.java create mode 100644 smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/provider/package-info.java create mode 100644 smack-experimental/src/test/java/org/jivesoftware/smackx/push_notifications/DisablePushNotificationsIQTest.java create mode 100644 smack-experimental/src/test/java/org/jivesoftware/smackx/push_notifications/EnablePushNotificationsIQTest.java create mode 100644 smack-experimental/src/test/java/org/jivesoftware/smackx/push_notifications/RemoteDisablingPushNotificationsTest.java diff --git a/documentation/extensions/index.md b/documentation/extensions/index.md index e20802474..adc963263 100644 --- a/documentation/extensions/index.md +++ b/documentation/extensions/index.md @@ -86,6 +86,7 @@ Experimental Smack Extensions and currently supported XEPs of smack-experimental | JSON Containers | [XEP-0335](http://xmpp.org/extensions/xep-0335.html) | Encapsulation of JSON data within XMPP Stanzas. | | [Internet of Things - Discovery](iot.md) | [XEP-0347](http://xmpp.org/extensions/xep-0347.html) | Describes how Things can be installed and discovered by their owners. | | Client State Indication | [XEP-0352](http://xmpp.org/extensions/xep-0352.html) | A way for the client to indicate its active/inactive state. | +| [Push Notifications](pushnotifications.md) | [XEP-0357](http://xmpp.org/extensions/xep-0357.html) | Defines a way to manage push notifications from an XMPP Server. | | Google GCM JSON payload | n/a | Semantically the same as XEP-0335: JSON Containers | diff --git a/documentation/extensions/pushnotifications.md b/documentation/extensions/pushnotifications.md new file mode 100644 index 000000000..4d9134ad6 --- /dev/null +++ b/documentation/extensions/pushnotifications.md @@ -0,0 +1,82 @@ +Push Notifications +================== + +Allows to manage how XMPP servers deliver information for use in push notifications to mobile and other devices. + + * Check push notifications support + * Enable push notifications + * Disable push notifications + * Remote disabling of push notifications + + +**XEP related:** [XEP-0357](http://xmpp.org/extensions/xep-0357.html) + + +Get push notifications manager +------------------------------ +``` +PushNotificationsManager pushNotificationsManager = PushNotificationsManager.getInstanceFor(connection); +``` + + +Check push notifications support +-------------------------------- + +``` +boolean isSupported = pushNotificationsManager.isSupportedByServer(); +``` + + +Enable push notifications +----------------------- + +``` +pushNotificationsManager.enable(pushJid, node); +``` +or +``` +pushNotificationsManager.enable(pushJid, node, publishOptions); +``` +*pushJid* is a `Jid` + +*node* is a `String` + +*publishOptions* is a `HashMap` (which means [option name, value]) + + +Disable push notifications +-------------------------- + +``` +pushNotificationsManager.disable(pushJid, node); +``` +*pushJid* is a `Jid` + +*node* is a `String` + +**Disable all** + +``` +pushNotificationsManager.disableAll(pushJid); +``` +*pushJid* is a `Jid` + + +Remote disabling of push notifications +-------------------------------------- + +``` +// check if the message is because remote disabling of push notifications +if (message.hasExtension(PushNotificationsElements.RemoteDisablingExtension.ELEMENT, PushNotificationsElements.RemoteDisablingExtension.NAMESPACE)) { + + // Get the remote disabling extension + PushNotificationsElements.RemoteDisablingExtension remoteDisablingExtension = PushNotificationsElements.RemoteDisablingExtension.from(message); + + // Get the user Jid + Jid userJid = remoteDisablingExtension.getUserJid(); + + // Get the node + String node = remoteDisablingExtension.getNode(); + +} +``` diff --git a/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/PushNotificationsManager.java b/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/PushNotificationsManager.java new file mode 100644 index 000000000..38a4b9a62 --- /dev/null +++ b/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/PushNotificationsManager.java @@ -0,0 +1,169 @@ +/** + * + * Copyright © 2016 Fernando Ramirez + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jivesoftware.smackx.push_notifications; + +import java.util.HashMap; +import java.util.Map; +import java.util.WeakHashMap; + +import org.jivesoftware.smack.ConnectionCreationListener; +import org.jivesoftware.smack.Manager; +import org.jivesoftware.smack.SmackException.NoResponseException; +import org.jivesoftware.smack.SmackException.NotConnectedException; +import org.jivesoftware.smack.XMPPConnection; +import org.jivesoftware.smack.XMPPConnectionRegistry; +import org.jivesoftware.smack.XMPPException.XMPPErrorException; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.IQ.Type; +import org.jivesoftware.smackx.disco.ServiceDiscoveryManager; +import org.jivesoftware.smackx.push_notifications.element.DisablePushNotificationsIQ; +import org.jivesoftware.smackx.push_notifications.element.EnablePushNotificationsIQ; +import org.jivesoftware.smackx.push_notifications.element.PushNotificationsElements; +import org.jxmpp.jid.Jid; + +/** + * Push Notifications manager class. + * + * @see XEP-0357: Push + * Notifications + * @author Fernando Ramirez + * + */ +public final class PushNotificationsManager extends Manager { + + static { + XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() { + @Override + public void connectionCreated(XMPPConnection connection) { + getInstanceFor(connection); + } + }); + } + + private static final Map INSTANCES = new WeakHashMap<>(); + + /** + * Get the singleton instance of PushNotificationsManager. + * + * @param connection + * @return the instance of PushNotificationsManager + */ + public static synchronized PushNotificationsManager getInstanceFor(XMPPConnection connection) { + PushNotificationsManager pushNotificationsManager = INSTANCES.get(connection); + + if (pushNotificationsManager == null) { + pushNotificationsManager = new PushNotificationsManager(connection); + INSTANCES.put(connection, pushNotificationsManager); + } + + return pushNotificationsManager; + } + + private PushNotificationsManager(XMPPConnection connection) { + super(connection); + } + + /** + * Returns true if Push Notifications is supported by the server. + * + * @return true if Push Notifications is supported by the server. + * @throws NoResponseException + * @throws XMPPErrorException + * @throws NotConnectedException + * @throws InterruptedException + */ + public boolean isSupportedByServer() + throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException { + return ServiceDiscoveryManager.getInstanceFor(connection()) + .serverSupportsFeature(PushNotificationsElements.NAMESPACE); + } + + /** + * Enable push notifications. + * + * @param pushJid + * @param node + * @return true if it was successfully enabled, false if not + * @throws NoResponseException + * @throws XMPPErrorException + * @throws NotConnectedException + * @throws InterruptedException + */ + public boolean enable(Jid pushJid, String node) + throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException { + return enable(pushJid, node, null); + } + + /** + * Enable push notifications. + * + * @param pushJid + * @param node + * @param publishOptions + * @return true if it was successfully enabled, false if not + * @throws NoResponseException + * @throws XMPPErrorException + * @throws NotConnectedException + * @throws InterruptedException + */ + public boolean enable(Jid pushJid, String node, HashMap publishOptions) + throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException { + EnablePushNotificationsIQ enablePushNotificationsIQ = new EnablePushNotificationsIQ(pushJid, node, + publishOptions); + return changePushNotificationsStatus(enablePushNotificationsIQ); + } + + /** + * Disable all push notifications. + * + * @param pushJid + * @return true if it was successfully disabled, false if not + * @throws NoResponseException + * @throws XMPPErrorException + * @throws NotConnectedException + * @throws InterruptedException + */ + public boolean disableAll(Jid pushJid) + throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException { + return disable(pushJid, null); + } + + /** + * Disable push notifications of an specific node. + * + * @param pushJid + * @param node + * @return true if it was successfully disabled, false if not + * @throws NoResponseException + * @throws XMPPErrorException + * @throws NotConnectedException + * @throws InterruptedException + */ + public boolean disable(Jid pushJid, String node) + throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException { + DisablePushNotificationsIQ disablePushNotificationsIQ = new DisablePushNotificationsIQ(pushJid, node); + return changePushNotificationsStatus(disablePushNotificationsIQ); + } + + private boolean changePushNotificationsStatus(IQ iq) + throws NotConnectedException, InterruptedException, NoResponseException, XMPPErrorException { + final XMPPConnection connection = connection(); + IQ responseIQ = connection.createPacketCollectorAndSend(iq).nextResultOrThrow(); + return responseIQ.getType() != Type.error; + } + +} diff --git a/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/element/DisablePushNotificationsIQ.java b/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/element/DisablePushNotificationsIQ.java new file mode 100644 index 000000000..278dc3ad6 --- /dev/null +++ b/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/element/DisablePushNotificationsIQ.java @@ -0,0 +1,82 @@ +/** + * + * Copyright © 2016 Fernando Ramirez + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jivesoftware.smackx.push_notifications.element; + +import org.jivesoftware.smack.packet.IQ; +import org.jxmpp.jid.Jid; + +/** + * Disable Push Notifications IQ. + * + * @see XEP-0357: Push + * Notifications + * @author Fernando Ramirez + * + */ +public class DisablePushNotificationsIQ extends IQ { + + /** + * disable element. + */ + public static final String ELEMENT = "disable"; + + /** + * the IQ NAMESPACE. + */ + public static final String NAMESPACE = PushNotificationsElements.NAMESPACE; + + private final Jid jid; + private final String node; + + public DisablePushNotificationsIQ(Jid jid, String node) { + super(ELEMENT, NAMESPACE); + this.jid = jid; + this.node = node; + this.setType(Type.set); + } + + public DisablePushNotificationsIQ(Jid jid) { + this(jid, null); + } + + /** + * Get the JID. + * + * @return the JID + */ + public Jid getJid() { + return jid; + } + + /** + * Get the node. + * + * @return the node + */ + public String getNode() { + return node; + } + + @Override + protected IQChildElementXmlStringBuilder getIQChildElementBuilder(IQChildElementXmlStringBuilder xml) { + xml.attribute("jid", jid); + xml.optAttribute("node", node); + xml.rightAngleBracket(); + return xml; + } + +} diff --git a/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/element/EnablePushNotificationsIQ.java b/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/element/EnablePushNotificationsIQ.java new file mode 100644 index 000000000..ea403ca3a --- /dev/null +++ b/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/element/EnablePushNotificationsIQ.java @@ -0,0 +1,119 @@ +/** + * + * Copyright © 2016 Fernando Ramirez + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jivesoftware.smackx.push_notifications.element; + +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; + +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smackx.pubsub.packet.PubSub; +import org.jivesoftware.smackx.xdata.FormField; +import org.jivesoftware.smackx.xdata.packet.DataForm; +import org.jxmpp.jid.Jid; + +/** + * Enable Push Notifications IQ. + * + * @see XEP-0357: Push + * Notifications + * @author Fernando Ramirez + * + */ +public class EnablePushNotificationsIQ extends IQ { + + /** + * enable element. + */ + public static final String ELEMENT = "enable"; + + /** + * the IQ NAMESPACE. + */ + public static final String NAMESPACE = PushNotificationsElements.NAMESPACE; + + private final Jid jid; + private final String node; + private final HashMap publishOptions; + + public EnablePushNotificationsIQ(Jid jid, String node, HashMap publishOptions) { + super(ELEMENT, NAMESPACE); + this.jid = jid; + this.node = node; + this.publishOptions = publishOptions; + this.setType(Type.set); + } + + public EnablePushNotificationsIQ(Jid jid, String node) { + this(jid, node, null); + } + + /** + * Get the JID. + * + * @return the JID + */ + public Jid getJid() { + return jid; + } + + /** + * Get the node. + * + * @return the node + */ + public String getNode() { + return node; + } + + /** + * Get the publish options. + * + * @return the publish options + */ + public HashMap getPublishOptions() { + return publishOptions; + } + + @Override + protected IQChildElementXmlStringBuilder getIQChildElementBuilder(IQChildElementXmlStringBuilder xml) { + xml.attribute("jid", jid); + xml.attribute("node", node); + xml.rightAngleBracket(); + + if (publishOptions != null) { + DataForm dataForm = new DataForm(DataForm.Type.form); + + FormField formTypeField = new FormField("FORM_TYPE"); + formTypeField.addValue(PubSub.NAMESPACE + "#publish-options"); + dataForm.addField(formTypeField); + + Iterator> publishOptionsIterator = publishOptions.entrySet().iterator(); + while (publishOptionsIterator.hasNext()) { + Map.Entry pairVariableValue = publishOptionsIterator.next(); + FormField field = new FormField(pairVariableValue.getKey()); + field.addValue(pairVariableValue.getValue()); + dataForm.addField(field); + } + + xml.element(dataForm); + } + + return xml; + } + +} diff --git a/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/element/PushNotificationsElements.java b/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/element/PushNotificationsElements.java new file mode 100644 index 000000000..f1805127c --- /dev/null +++ b/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/element/PushNotificationsElements.java @@ -0,0 +1,100 @@ +/** + * + * Copyright © 2016 Fernando Ramirez + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jivesoftware.smackx.push_notifications.element; + +import org.jivesoftware.smack.packet.ExtensionElement; +import org.jivesoftware.smack.packet.Message; +import org.jivesoftware.smack.util.XmlStringBuilder; +import org.jivesoftware.smackx.pubsub.packet.PubSub; +import org.jxmpp.jid.Jid; + +/** + * Push Notifications elements. + * + * @see XEP-0357: Push + * Notifications + * @author Fernando Ramirez + * + */ +public class PushNotificationsElements { + + public static final String NAMESPACE = "urn:xmpp:push:0"; + + public static class RemoteDisablingExtension implements ExtensionElement { + + public static final String NAMESPACE = PubSub.NAMESPACE; + public static final String ELEMENT = PubSub.ELEMENT; + + private final String node; + private final Jid userJid; + + public RemoteDisablingExtension(String node, Jid userJid) { + this.node = node; + this.userJid = userJid; + } + + @Override + public String getElementName() { + return PubSub.ELEMENT; + } + + @Override + public String getNamespace() { + return PubSub.NAMESPACE; + } + + /** + * Get the node. + * + * @return the node + */ + public String getNode() { + return node; + } + + /** + * Get the user JID. + * + * @return the user JID + */ + public Jid getUserJid() { + return userJid; + } + + @Override + public CharSequence toXML() { + XmlStringBuilder xml = new XmlStringBuilder(this); + + xml.attribute("node", node); + xml.rightAngleBracket(); + + xml.halfOpenElement("affiliation"); + xml.attribute("jid", userJid); + xml.attribute("affiliation", "none"); + xml.closeEmptyElement(); + + xml.closeElement(this); + return xml; + } + + public static RemoteDisablingExtension from(Message message) { + return message.getExtension(ELEMENT, NAMESPACE); + } + + } + +} diff --git a/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/element/package-info.java b/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/element/package-info.java new file mode 100644 index 000000000..2d41b16e0 --- /dev/null +++ b/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/element/package-info.java @@ -0,0 +1,20 @@ +/** + * + * Copyright © 2016 Fernando Ramirez + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/** + * Push Notifications elements (XEP-0357). + */ +package org.jivesoftware.smackx.push_notifications.element; diff --git a/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/package-info.java b/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/package-info.java new file mode 100644 index 000000000..796e7ad71 --- /dev/null +++ b/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/package-info.java @@ -0,0 +1,20 @@ +/** + * + * Copyright © 2016 Fernando Ramirez + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/** + * Classes and interfaces to manage Push Notifications (XEP-0357). + */ +package org.jivesoftware.smackx.push_notifications; diff --git a/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/provider/RemoteDisablingProvider.java b/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/provider/RemoteDisablingProvider.java new file mode 100644 index 000000000..e642f91b0 --- /dev/null +++ b/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/provider/RemoteDisablingProvider.java @@ -0,0 +1,60 @@ +/** + * + * Copyright © 2016 Fernando Ramirez + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jivesoftware.smackx.push_notifications.provider; + +import org.jivesoftware.smack.provider.ExtensionElementProvider; +import org.jivesoftware.smackx.push_notifications.element.PushNotificationsElements.RemoteDisablingExtension; +import org.jxmpp.jid.Jid; +import org.jxmpp.jid.impl.JidCreate; +import org.xmlpull.v1.XmlPullParser; + +/** + * Push Notifications Remote Disabling Provider class. + * + * @see XEP-0357: Push + * Notifications + * @author Fernando Ramirez + */ +public class RemoteDisablingProvider extends ExtensionElementProvider { + + @Override + public RemoteDisablingExtension parse(XmlPullParser parser, int initialDepth) throws Exception { + Jid userJid = null; + String node = parser.getAttributeValue("", "node"); + + outerloop: while (true) { + int eventType = parser.next(); + if (eventType == XmlPullParser.START_TAG) { + if (parser.getName().equals("affiliation")) { + userJid = JidCreate.from(parser.getAttributeValue("", "jid")); + + String affiliation = parser.getAttributeValue("", "affiliation"); + if (affiliation == null || !affiliation.equals("none")) { + return null; + } + } + } else if (eventType == XmlPullParser.END_TAG) { + if (parser.getDepth() == initialDepth) { + break outerloop; + } + } + } + + return new RemoteDisablingExtension(node, userJid); + } + +} diff --git a/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/provider/package-info.java b/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/provider/package-info.java new file mode 100644 index 000000000..86dcf6043 --- /dev/null +++ b/smack-experimental/src/main/java/org/jivesoftware/smackx/push_notifications/provider/package-info.java @@ -0,0 +1,20 @@ +/** + * + * Copyright © 2016 Fernando Ramirez + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/** + * Push Notifications providers (XEP-0357). + */ +package org.jivesoftware.smackx.push_notifications.provider; diff --git a/smack-experimental/src/main/resources/org.jivesoftware.smack.experimental/experimental.providers b/smack-experimental/src/main/resources/org.jivesoftware.smack.experimental/experimental.providers index a88e9aae7..def9951bd 100644 --- a/smack-experimental/src/main/resources/org.jivesoftware.smack.experimental/experimental.providers +++ b/smack-experimental/src/main/resources/org.jivesoftware.smack.experimental/experimental.providers @@ -171,5 +171,12 @@ urn:xmpp:iot:control org.jivesoftware.smackx.iot.control.provider.IoTSetResponseProvider - + + + + pubsub + http://jabber.org/protocol/pubsub + org.jivesoftware.smackx.push_notifications.provider.RemoteDisablingProvider + + diff --git a/smack-experimental/src/test/java/org/jivesoftware/smackx/push_notifications/DisablePushNotificationsIQTest.java b/smack-experimental/src/test/java/org/jivesoftware/smackx/push_notifications/DisablePushNotificationsIQTest.java new file mode 100644 index 000000000..04a080457 --- /dev/null +++ b/smack-experimental/src/test/java/org/jivesoftware/smackx/push_notifications/DisablePushNotificationsIQTest.java @@ -0,0 +1,49 @@ +/** + * + * Copyright © 2016 Fernando Ramirez + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jivesoftware.smackx.push_notifications; + +import org.jivesoftware.smackx.push_notifications.element.DisablePushNotificationsIQ; +import org.junit.Assert; +import org.junit.Test; +import org.jxmpp.jid.impl.JidCreate; + +public class DisablePushNotificationsIQTest { + + String disableAllNotificationsIQExample = "" + + "" + "" + ""; + + String disableNodeNotificationsIQExample = "" + + "" + "" + + ""; + + @Test + public void checkDisableAllPushNotificationsIQ() throws Exception { + DisablePushNotificationsIQ disablePushNotificationsIQ = new DisablePushNotificationsIQ( + JidCreate.from("push-5.client.example")); + disablePushNotificationsIQ.setStanzaId("x97"); + Assert.assertEquals(disableAllNotificationsIQExample, disablePushNotificationsIQ.toXML().toString()); + } + + @Test + public void checkDisableNodePushNotificationsIQ() throws Exception { + DisablePushNotificationsIQ disablePushNotificationsIQ = new DisablePushNotificationsIQ( + JidCreate.from("push-5.client.example"), "yxs32uqsflafdk3iuqo"); + disablePushNotificationsIQ.setStanzaId("x97"); + Assert.assertEquals(disableNodeNotificationsIQExample, disablePushNotificationsIQ.toXML().toString()); + } + +} diff --git a/smack-experimental/src/test/java/org/jivesoftware/smackx/push_notifications/EnablePushNotificationsIQTest.java b/smack-experimental/src/test/java/org/jivesoftware/smackx/push_notifications/EnablePushNotificationsIQTest.java new file mode 100644 index 000000000..644c62f83 --- /dev/null +++ b/smack-experimental/src/test/java/org/jivesoftware/smackx/push_notifications/EnablePushNotificationsIQTest.java @@ -0,0 +1,58 @@ +/** + * + * Copyright © 2016 Fernando Ramirez + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jivesoftware.smackx.push_notifications; + +import java.util.HashMap; + +import org.jivesoftware.smackx.push_notifications.element.EnablePushNotificationsIQ; +import org.junit.Assert; +import org.junit.Test; +import org.jxmpp.jid.impl.JidCreate; + +public class EnablePushNotificationsIQTest { + + String exampleEnableIQ = "" + + "" + "" + + ""; + + String exampleEnableIQWithPublishOptions = "" + + "" + + "" + + "http://jabber.org/protocol/pubsub#publish-options" + + "eruio234vzxc2kla-91" + "" + "" + ""; + + @Test + public void checkEnablePushNotificationsIQ() throws Exception { + EnablePushNotificationsIQ enablePushNotificationsIQ = new EnablePushNotificationsIQ( + JidCreate.from("push-5.client.example"), "yxs32uqsflafdk3iuqo"); + enablePushNotificationsIQ.setStanzaId("x42"); + Assert.assertEquals(exampleEnableIQ, enablePushNotificationsIQ.toXML().toString()); + } + + @Test + public void checkEnablePushNotificationsIQWithPublishOptions() throws Exception { + HashMap publishOptions = new HashMap<>(); + publishOptions.put("secret", "eruio234vzxc2kla-91"); + + EnablePushNotificationsIQ enablePushNotificationsIQ = new EnablePushNotificationsIQ( + JidCreate.from("push-5.client.example"), "yxs32uqsflafdk3iuqo", publishOptions); + enablePushNotificationsIQ.setStanzaId("x42"); + + Assert.assertEquals(exampleEnableIQWithPublishOptions, enablePushNotificationsIQ.toXML().toString()); + } + +} diff --git a/smack-experimental/src/test/java/org/jivesoftware/smackx/push_notifications/RemoteDisablingPushNotificationsTest.java b/smack-experimental/src/test/java/org/jivesoftware/smackx/push_notifications/RemoteDisablingPushNotificationsTest.java new file mode 100644 index 000000000..58630feda --- /dev/null +++ b/smack-experimental/src/test/java/org/jivesoftware/smackx/push_notifications/RemoteDisablingPushNotificationsTest.java @@ -0,0 +1,67 @@ +/** + * + * Copyright © 2016 Fernando Ramirez + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jivesoftware.smackx.push_notifications; + +import org.jivesoftware.smack.packet.Message; +import org.jivesoftware.smack.util.PacketParserUtils; +import org.jivesoftware.smackx.push_notifications.element.PushNotificationsElements.RemoteDisablingExtension; +import org.junit.Assert; +import org.junit.Test; +import org.jxmpp.jid.impl.JidCreate; + +public class RemoteDisablingPushNotificationsTest { + + String remoteDisablingExample = "" + + "" + + "" + "" + ""; + + String wrongRemoteDisabling1 = "" + + "" + + "" + "" + ""; + + String wrongRemoteDisabling2 = "" + + "" + + "" + "" + ""; + + String wrongRemoteDisabling3 = "" + + "" + "" + ""; + + @Test + public void checkRemoteDisablingPushNotificationsParse() throws Exception { + Message message = (Message) PacketParserUtils.parseStanza(remoteDisablingExample); + RemoteDisablingExtension remoteDisablingExtension = RemoteDisablingExtension.from(message); + + Assert.assertEquals("yxs32uqsflafdk3iuqo", remoteDisablingExtension.getNode()); + Assert.assertEquals(JidCreate.from("user@example.com"), remoteDisablingExtension.getUserJid()); + } + + @Test + public void checkWrongRemoteDisablighPushNotifications() throws Exception { + Message message1 = (Message) PacketParserUtils.parseStanza(wrongRemoteDisabling1); + RemoteDisablingExtension remoteDisablingExtension1 = RemoteDisablingExtension.from(message1); + Assert.assertNull(remoteDisablingExtension1); + + Message message2 = (Message) PacketParserUtils.parseStanza(wrongRemoteDisabling1); + RemoteDisablingExtension remoteDisablingExtension2 = RemoteDisablingExtension.from(message2); + Assert.assertNull(remoteDisablingExtension2); + + Message message3 = (Message) PacketParserUtils.parseStanza(wrongRemoteDisabling1); + RemoteDisablingExtension remoteDisablingExtension3 = RemoteDisablingExtension.from(message3); + Assert.assertNull(remoteDisablingExtension3); + } + +}