Add smack-resolver-minidns

build.gradle

@@ -19,6 +19,7 @@ allprojects {
 		sonatypeStagingUrl = 'https://oss.sonatype.org/service/local/staging/deploy/maven2'
 		buildDate = (new java.text.SimpleDateFormat("yyyy-MM-dd")).format(new Date())
 		oneLineDesc = 'An Open Source XMPP (Jabber) client library'
+		jxmppVersion = "0.1.0-alpha1-SNAPSHOT"
 	}
 	group = 'org.igniterealtime.smack'
 	sourceCompatibility = 1.7

settings.gradle

@@ -4,6 +4,7 @@ include 'smack-core',
 		'smack-experimental',
 		'smack-debug',
 		'smack-resolver-dnsjava',
+		'smack-resolver-minidns',
 		'smack-resolver-javax',
 		'smack-compression-jzlib',
 		'smack-legacy',

smack-core/src/main/java/org/jivesoftware/smack/SmackConfiguration.java

@@ -36,6 +36,7 @@ import org.jivesoftware.smack.compression.XMPPInputOutputStream;
 import org.jivesoftware.smack.initializer.SmackInitializer;
 import org.jivesoftware.smack.parsing.ExceptionThrowingCallback;
 import org.jivesoftware.smack.parsing.ParsingExceptionCallback;
+import org.jivesoftware.smack.util.DNSUtil;
 import org.jivesoftware.smack.util.FileUtils;
 import org.xmlpull.v1.XmlPullParserFactory;
 import org.xmlpull.v1.XmlPullParser;
@@ -167,6 +168,9 @@ public final class SmackConfiguration {
         catch (Exception e) {
             // Ignore.
         }
+
+        // Initialize the DNS resolvers
+        DNSUtil.init();
     }
 
     /**

smack-core/src/main/java/org/jivesoftware/smack/util/DNSUtil.java

@@ -16,6 +16,8 @@
  */
 package org.jivesoftware.smack.util;
 
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.LinkedList;
@@ -39,6 +41,31 @@ public class DNSUtil {
     private static final Logger LOGGER = Logger.getLogger(DNSUtil.class.getName());
     private static DNSResolver dnsResolver = null;
 
+    /**
+     * Initializes DNSUtil. This method is automatically called by SmackConfiguration, you don't
+     * have to call it manually.
+     */
+    public static void init() {
+        final String[] RESOLVERS = new String[] { "javax.JavaxResolver", "minidns.MiniDnsResolver",
+                        "dnsjava.DNSJavaResolver" };
+        for (String resolver :RESOLVERS) {
+            DNSResolver availableResolver = null;
+            String resolverFull = "org.jivesoftware.smack.util.dns" + resolver;
+            try {
+                Class<?> resolverClass = Class.forName(resolverFull);
+                Method getInstanceMethod = resolverClass.getMethod("getInstance");
+                availableResolver = (DNSResolver) getInstanceMethod.invoke(null);
+                if (availableResolver != null) {
+                    setDNSResolver(availableResolver);
+                    break;
+                }
+            }
+            catch (ClassNotFoundException|NoSuchMethodException|SecurityException|IllegalAccessException|IllegalArgumentException|InvocationTargetException e) {
+                LOGGER.log(Level.FINE, "Exception on init", e);
+            }
+        }
+    }
+
     /**
      * Set the DNS resolver that should be used to perform DNS lookups.
      *

smack-resolver-minidns/build.gradle

@@ -0,0 +1,10 @@
+description = """\
+DNS SRV with minidns
+Use minidns for DNS SRV lookups. For platforms that don't provide the
+javax.naming API (e.g. Android)."""
+
+dependencies {
+	compile project(path: ':smack-core', configuration: 'dns')
+	compile 'de.measite.minidns:minidns:0.1.1'
+	compile "org.igniterealtime.jxmpp:jxmpp-util-cache:$jxmppVersion"
+}

smack-resolver-minidns/src/main/java/org/jivesoftware/smack/util/dns/minidns/MiniDnsResolver.java

@@ -0,0 +1,84 @@
+/**
+ *
+ * Copyright 2014 Florian Schmaus
+ *
+ * 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.smack.util.dns.minidns;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import org.jivesoftware.smack.util.dns.DNSResolver;
+import org.jivesoftware.smack.util.dns.SRVRecord;
+import org.jxmpp.util.cache.ExpirationCache;
+
+import de.measite.minidns.Client;
+import de.measite.minidns.DNSCache;
+import de.measite.minidns.DNSMessage;
+import de.measite.minidns.Question;
+import de.measite.minidns.Record;
+import de.measite.minidns.Record.CLASS;
+import de.measite.minidns.Record.TYPE;
+import de.measite.minidns.record.SRV;
+
+
+/**
+ * This implementation uses the <a href="https://github.com/rtreffer/minidns/">minidns</a> implementation for
+ * resolving DNS addresses.
+ */
+public class MiniDnsResolver implements DNSResolver {
+
+    private static final long ONE_DAY = 24*60*60*1000;
+    private static final MiniDnsResolver instance = new MiniDnsResolver();
+    private static final ExpirationCache<Question, DNSMessage> cache = new ExpirationCache<Question, DNSMessage>(10, ONE_DAY);
+    private final Client client; 
+
+    private MiniDnsResolver() {
+        client = new Client(new DNSCache() {
+
+            @Override
+            public DNSMessage get(Question question) {
+                return cache.get(question);
+            }
+
+            @Override
+            public void put(Question question, DNSMessage message) {
+                long expirationTime = ONE_DAY;
+                for (Record record : message.getAnswers()) {
+                    if (record.isAnswer(question)) {
+                        expirationTime = record.getTtl();
+                        break;
+                    }
+                }
+                cache.put(question, message, expirationTime);
+            }
+
+        });
+    }
+
+    public static DNSResolver getInstance() {
+        return instance;
+    }
+
+    @Override
+    public List<SRVRecord> lookupSRVRecords(String name) {
+        List<SRVRecord> res = new LinkedList<SRVRecord>();
+        DNSMessage message = client.query(name, TYPE.SRV, CLASS.IN);
+        for (Record record : message.getAnswers()) {
+            SRV srv = (SRV) record.getPayload();
+            res.add(new SRVRecord(srv.getName(), srv.getPort(), srv.getPriority(), srv.getWeight()));
+        }
+        return res;
+    }
+}