[
{
"path": ".github/FUNDING.yml",
"content": "# These are supported funding model platforms\n\ngithub: koush\npatreon: # Replace with a single Patreon username\nopen_collective: # Replace with a single Open Collective username\nko_fi: # Replace with a single Ko-fi username\ntidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel\ncommunity_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry\nliberapay: # Replace with a single Liberapay username\nissuehunt: # Replace with a single IssueHunt username\notechie: # Replace with a single Otechie username\ncustom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']\n"
},
{
"path": ".gitignore",
"content": "bin\n.settings\nlocal.properties\ngen\n.gradle\nbuild\n.idea/\n.DS_Store\nokhttp/\nokio/\nlibs\n*.iml\n"
},
{
"path": "AndroidAsync/.classpath",
"content": "\n\n\t\n\t\n\t\n\n"
},
{
"path": "AndroidAsync/Android.mk",
"content": "#\n# Copyright (C) 2011 The Android Open Source Project\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n\nLOCAL_PATH := $(call my-dir)\n\ninclude $(CLEAR_VARS)\n\nLOCAL_MODULE := AndroidAsync\nLOCAL_SDK_VERSION := 8\nLOCAL_SRC_FILES := $(call all-java-files-under, src)\n\ninclude $(BUILD_STATIC_JAVA_LIBRARY)\n"
},
{
"path": "AndroidAsync/AndroidManifest.xml",
"content": "\n\n \n\n \n \n\n\n"
},
{
"path": "AndroidAsync/build.gradle",
"content": "apply plugin: 'com.android.library'\n\nandroid {\n sourceSets {\n main {\n manifest.srcFile 'AndroidManifest.xml'\n\n jniLibs.srcDirs = ['libs/']\n\n java.srcDirs=['src/'\n// , '../conscrypt/'\n// , '../compat/'\n ]\n }\n androidTest.java.srcDirs=['test/src/']\n androidTest.res.srcDirs=['test/res/']\n androidTest.assets.srcDirs=['test/assets/']\n }\n\n lintOptions {\n abortOnError false\n }\n\n defaultConfig {\n targetSdkVersion 30\n minSdkVersion 21\n\n testInstrumentationRunner \"androidx.test.runner.AndroidJUnitRunner\"\n }\n\n compileOptions {\n sourceCompatibility 1.8\n targetCompatibility 1.8\n }\n\n compileSdkVersion 30\n buildToolsVersion '30.0.2'\n\n dependencies {\n // this is only necessary to get compilation working for self signed certificates. dependency isn't added.\n compileOnly group: 'org.bouncycastle', name: 'bcprov-jdk15on', version: '1.60'\n compileOnly group: 'org.bouncycastle', name: 'bcpkix-jdk15on', version: '1.60'\n\n\n testImplementation 'junit:junit:4.12'\n androidTestImplementation 'com.android.support.test:runner:1.0.2'\n androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'\n // for when i wanna test this against gms conscrypt\n androidTestImplementation 'com.google.android.gms:play-services-base:17.0.0'\n }\n}\n\napply from: 'maven.gradle'\n"
},
{
"path": "AndroidAsync/lint.xml",
"content": "\n\n"
},
{
"path": "AndroidAsync/maven.gradle",
"content": "// Setup\n\n// 0) Setup your sonatype credentials by editing/creating ~/.gradle/gradle.properties and enter:\n// signing.keyId=\n// signing.password=\n// signing.secretKeyRingFile=\n// sonatypeUsername=\n// sonatypePassword=\n\n// 1) Setup your build.gradle for your android project and add this one line of code which imports this gist:\n// apply from: 'https://raw.github.com/koush/mvn-repo/master/maven.gradle'\n\n// 2) gradle clean && gradle build && gradle uploadArchives\n\n// 3) That's it!\n\n\napply plugin: 'maven'\napply plugin: 'signing'\n\n\nif (hasProperty('sonatypeUsername') && hasProperty('sonatypePassword') && hasProperty('githubToken')) {\n\n afterEvaluate { project ->\n String user = null\n String repo = null\n 'git remote -v'.execute(null, project.projectDir).getText().find('.*?git@github.com/(.*?)/(.*?) .*?') {\n match ->\n user = match[1]\n repo = match[2]\n }\n\n String githubUrl = 'https://api.github.com/repos/' + user + '/' + repo\n if (System.getenv().GITHUB_TOKEN)\n githubUrl += '?access_token=' + System.getenv().GITHUB_TOKEN\n def repoInfo = new groovy.json.JsonSlurper().parseText(new URL(githubUrl).getText())\n\n def android_manifest\n try {\n android_manifest = new XmlParser(false, false).parseText(new File(project.projectDir, 'AndroidManifest.xml').getText())\n }\n catch (e) {\n android_manifest = new XmlParser(false, false).parseText(new File(project.projectDir, 'src/main/AndroidManifest.xml').getText())\n }\n def versionName = android_manifest.'@android:versionName'\n def package_name = android_manifest.'@package'\n def artifact_id = project.projectDir.getName().toLowerCase()\n project.version = versionName\n project.group = package_name\n\n uploadArchives {\n repositories {\n mavenDeployer {\n\n beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }\n pom.groupId = package_name\n pom.artifactId = artifact_id\n pom.version = versionName\n\n repository(url: \"https://oss.sonatype.org/service/local/staging/deploy/maven2/\") {\n authentication(userName: sonatypeUsername, password: sonatypePassword)\n }\n\n pom.project {\n name repo\n packaging 'jar'\n description repoInfo.description\n url repoInfo.html_url\n\n scm {\n url repoInfo.git_url\n connection repoInfo.git_url\n developerConnection repoInfo.ssh_url\n }\n\n licenses {\n license {\n name 'The Apache Software License, Version 2.0'\n url 'http://www.apache.org/licenses/LICENSE-2.0.txt'\n distribution 'repo'\n }\n }\n\n developers {\n developer {\n id user\n name user\n }\n }\n }\n }\n }\n }\n\n signing {\n sign configurations.archives\n }\n\n task androidJavadocs(type: Javadoc) {\n source = android.sourceSets.main.java.srcDirs\n }\n\n task androidJavadocsJar(type: Jar) {\n classifier = 'javadoc'\n baseName = artifact_id\n from androidJavadocs.destinationDir\n }\n\n task androidSourcesJar(type: Jar) {\n classifier = 'sources'\n baseName = artifact_id\n from android.sourceSets.main.java.srcDirs\n }\n\n artifacts {\n // archives packageReleaseJar\n archives androidSourcesJar\n archives androidJavadocsJar\n }\n }\n}"
},
{
"path": "AndroidAsync/proguard-project.txt",
"content": "# To enable ProGuard in your project, edit project.properties\n# to define the proguard.config property as described in that file.\n#\n# Add project specific ProGuard rules here.\n# By default, the flags in this file are appended to flags specified\n# in ${sdk.dir}/tools/proguard/proguard-android.txt\n# You can edit the include path and order by changing the ProGuard\n# include property in project.properties.\n#\n# For more details, see\n# http://developer.android.com/guide/developing/tools/proguard.html\n\n# Add any project specific keep options here:\n\n# If your project uses WebView with JS, uncomment the following\n# and specify the fully qualified class name to the JavaScript interface\n# class:\n#-keepclassmembers class fqcn.of.javascript.interface.for.webview {\n# public *;\n#}\n\n-keep class * extends com.koushikdutta.async.TapCallback {\n public protected private *;\n}\n"
},
{
"path": "AndroidAsync/project.properties",
"content": "# This file is automatically generated by Android Tools.\n# Do not modify this file -- YOUR CHANGES WILL BE ERASED!\n#\n# This file must be checked in Version Control Systems.\n#\n# To customize properties used by the Ant build system edit\n# \"ant.properties\", and override values to adapt the script to your\n# project structure.\n#\n# To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home):\n#proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt\n\n# Project target.\ntarget=android-19\nandroid.library=true\n\n\n"
},
{
"path": "AndroidAsync/res/.gitignore",
"content": ""
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/AsyncDatagramSocket.java",
"content": "package com.koushikdutta.async;\n\nimport java.io.IOException;\nimport java.net.InetSocketAddress;\nimport java.nio.ByteBuffer;\n\npublic class AsyncDatagramSocket extends AsyncNetworkSocket {\n public void disconnect() throws IOException {\n socketAddress = null;\n ((DatagramChannelWrapper)getChannel()).disconnect();\n }\n\n @Override\n public InetSocketAddress getRemoteAddress() {\n if (isOpen())\n return super.getRemoteAddress();\n return ((DatagramChannelWrapper)getChannel()).getRemoteAddress();\n }\n\n public void connect(InetSocketAddress address) throws IOException {\n socketAddress = address;\n ((DatagramChannelWrapper)getChannel()).mChannel.connect(address);\n }\n\n public void send(final String host, final int port, final ByteBuffer buffer) {\n if (getServer().getAffinity() != Thread.currentThread()) {\n getServer().run(new Runnable() {\n @Override\n public void run() {\n send(host, port, buffer);\n }\n });\n return;\n }\n\n try {\n ((DatagramChannelWrapper)getChannel()).mChannel.send(buffer, new InetSocketAddress(host, port));\n }\n catch (IOException e) {\n// close();\n// reportEndPending(e);\n// reportClose(e);\n }\n\n }\n public void send(final InetSocketAddress address, final ByteBuffer buffer) {\n if (getServer().getAffinity() != Thread.currentThread()) {\n getServer().run(new Runnable() {\n @Override\n public void run() {\n send(address, buffer);\n }\n });\n return;\n }\n\n try {\n int sent = ((DatagramChannelWrapper)getChannel()).mChannel.send(buffer, new InetSocketAddress(address.getHostName(), address.getPort()));\n }\n catch (IOException e) {\n// Log.e(\"SEND\", \"send error\", e);\n// close();\n// reportEndPending(e);\n// reportClose(e);\n }\n }\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/AsyncNetworkSocket.java",
"content": "package com.koushikdutta.async;\n\nimport android.util.Log;\n\nimport com.koushikdutta.async.callback.CompletedCallback;\nimport com.koushikdutta.async.callback.DataCallback;\nimport com.koushikdutta.async.callback.WritableCallback;\nimport com.koushikdutta.async.util.Allocator;\n\nimport java.io.IOException;\nimport java.net.InetAddress;\nimport java.net.InetSocketAddress;\nimport java.net.Socket;\nimport java.nio.ByteBuffer;\nimport java.nio.channels.CancelledKeyException;\nimport java.nio.channels.DatagramChannel;\nimport java.nio.channels.SelectionKey;\nimport java.nio.channels.SocketChannel;\n\npublic class AsyncNetworkSocket implements AsyncSocket {\n AsyncNetworkSocket() {\n }\n\n @Override\n public void end() {\n mChannel.shutdownOutput();\n }\n\n public boolean isChunked() {\n return mChannel.isChunked();\n }\n\n InetSocketAddress socketAddress;\n void attach(SocketChannel channel, InetSocketAddress socketAddress) throws IOException {\n this.socketAddress = socketAddress;\n allocator = new Allocator();\n mChannel = new SocketChannelWrapper(channel);\n }\n \n void attach(DatagramChannel channel) throws IOException {\n mChannel = new DatagramChannelWrapper(channel);\n // keep udp at roughly the mtu, which is 1540 or something\n // letting it grow freaks out nio apparently.\n allocator = new Allocator(8192);\n }\n \n ChannelWrapper getChannel() {\n return mChannel;\n }\n \n public void onDataWritable() {\n if (!mChannel.isChunked()) {\n // turn write off\n mKey.interestOps(~SelectionKey.OP_WRITE & mKey.interestOps());\n }\n if (mWriteableHandler != null)\n mWriteableHandler.onWriteable();\n }\n\n private ChannelWrapper mChannel;\n private SelectionKey mKey;\n private AsyncServer mServer;\n \n void setup(AsyncServer server, SelectionKey key) {\n mServer = server;\n mKey = key;\n }\n \n @Override\n public void write(final ByteBufferList list) {\n if (mServer.getAffinity() != Thread.currentThread()) {\n mServer.run(new Runnable() {\n @Override\n public void run() {\n write(list);\n }\n });\n return;\n }\n if (!mChannel.isConnected()) {\n return;\n }\n\n try {\n int before = list.remaining();\n ByteBuffer[] arr = list.getAllArray();\n mChannel.write(arr);\n list.addAll(arr);\n handleRemaining(list.remaining());\n mServer.onDataSent(before - list.remaining());\n }\n catch (IOException e) {\n closeInternal();\n reportEndPending(e);\n reportClose(e);\n }\n }\n \n private void handleRemaining(int remaining) throws IOException {\n if (!mKey.isValid())\n throw new IOException(new CancelledKeyException());\n if (remaining > 0) {\n // chunked channels should not fail\n // register for a write notification if a write fails\n // turn write on\n mKey.interestOps(SelectionKey.OP_WRITE | mKey.interestOps());\n }\n else {\n // turn write off\n mKey.interestOps(~SelectionKey.OP_WRITE & mKey.interestOps());\n }\n }\n private ByteBufferList pending = new ByteBufferList();\n// private ByteBuffer[] buffers = new ByteBuffer[8];\n\n Allocator allocator;\n int onReadable() {\n spitPending();\n // even if the socket is paused,\n // it may end up getting a queued readable event if it is\n // already in the selector's ready queue.\n if (mPaused)\n return 0;\n int total = 0;\n boolean closed = false;\n\n// ByteBufferList.obtainArray(buffers, Math.min(Math.max(mToAlloc, 2 << 11), maxAlloc));\n ByteBuffer b = allocator.allocate();\n // keep track of the max mount read during this read cycle\n // so we can be quicker about allocations during the next\n // time this socket reads.\n long read;\n try {\n read = mChannel.read(b);\n }\n catch (Exception e) {\n read = -1;\n closeInternal();\n reportEndPending(e);\n reportClose(e);\n }\n\n if (read < 0) {\n closeInternal();\n closed = true;\n }\n else {\n total += read;\n }\n if (read > 0) {\n allocator.track(read);\n b.flip();\n// for (int i = 0; i < buffers.length; i++) {\n// ByteBuffer b = buffers[i];\n// buffers[i] = null;\n// b.flip();\n// pending.add(b);\n// }\n pending.add(b);\n Util.emitAllData(this, pending);\n }\n else {\n ByteBufferList.reclaim(b);\n }\n\n if (closed) {\n reportEndPending(null);\n reportClose(null);\n }\n\n return total;\n }\n \n boolean closeReported;\n protected void reportClose(Exception e) {\n if (closeReported)\n return;\n closeReported = true;\n if (mClosedHander != null) {\n mClosedHander.onCompleted(e);\n mClosedHander = null;\n }\n }\n\n @Override\n public void close() {\n closeInternal();\n reportClose(null);\n }\n\n private void closeInternal() {\n mKey.cancel();\n try {\n mChannel.close();\n }\n catch (IOException e) {\n }\n }\n\n WritableCallback mWriteableHandler;\n @Override\n public void setWriteableCallback(WritableCallback handler) {\n mWriteableHandler = handler; \n }\n\n DataCallback mDataHandler;\n @Override\n public void setDataCallback(DataCallback callback) {\n mDataHandler = callback;\n }\n\n @Override\n public DataCallback getDataCallback() {\n return mDataHandler;\n }\n\n CompletedCallback mClosedHander;\n @Override\n public void setClosedCallback(CompletedCallback handler) {\n mClosedHander = handler; \n }\n\n @Override\n public CompletedCallback getClosedCallback() {\n return mClosedHander;\n }\n\n @Override\n public WritableCallback getWriteableCallback() {\n return mWriteableHandler;\n }\n\n void reportEnd(Exception e) {\n if (mEndReported)\n return;\n mEndReported = true;\n if (mCompletedCallback != null)\n mCompletedCallback.onCompleted(e);\n else if (e != null) {\n Log.e(\"NIO\", \"Unhandled exception\", e);\n }\n }\n boolean mEndReported;\n Exception mPendingEndException;\n void reportEndPending(Exception e) {\n if (pending.hasRemaining()) {\n mPendingEndException = e;\n return;\n }\n reportEnd(e);\n }\n \n private CompletedCallback mCompletedCallback;\n @Override\n public void setEndCallback(CompletedCallback callback) {\n mCompletedCallback = callback;\n }\n\n @Override\n public CompletedCallback getEndCallback() {\n return mCompletedCallback;\n }\n\n @Override\n public boolean isOpen() {\n return mChannel.isConnected() && mKey.isValid();\n }\n \n boolean mPaused = false;\n @Override\n public void pause() {\n if (mServer.getAffinity() != Thread.currentThread()) {\n mServer.run(new Runnable() {\n @Override\n public void run() {\n pause();\n }\n });\n return;\n }\n \n if (mPaused)\n return;\n\n mPaused = true;\n try {\n mKey.interestOps(~SelectionKey.OP_READ & mKey.interestOps());\n }\n catch (Exception ex) {\n }\n }\n \n private void spitPending() {\n if (pending.hasRemaining()) {\n Util.emitAllData(this, pending);\n }\n }\n \n @Override\n public void resume() {\n if (mServer.getAffinity() != Thread.currentThread()) {\n mServer.run(new Runnable() {\n @Override\n public void run() {\n resume();\n }\n });\n return;\n }\n \n if (!mPaused)\n return;\n mPaused = false;\n try {\n mKey.interestOps(SelectionKey.OP_READ | mKey.interestOps());\n }\n catch (Exception ex) {\n }\n spitPending();\n if (!isOpen())\n reportEndPending(mPendingEndException);\n }\n \n @Override\n public boolean isPaused() {\n return mPaused;\n }\n\n @Override\n public AsyncServer getServer() {\n return mServer;\n }\n\n\n public InetSocketAddress getRemoteAddress() {\n return socketAddress;\n }\n\n public InetAddress getLocalAddress() {\n return mChannel.getLocalAddress();\n }\n\n public int getLocalPort() {\n return mChannel.getLocalPort();\n }\n\n public Object getSocket() {\n return getChannel().getSocket();\n }\n\n @Override\n public String charset() {\n return null;\n }\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/AsyncSSLException.java",
"content": "package com.koushikdutta.async;\n\npublic class AsyncSSLException extends Exception {\n public AsyncSSLException(Throwable cause) {\n super(\"Peer not trusted by any of the system trust managers.\", cause);\n }\n private boolean mIgnore = false;\n public void setIgnore(boolean ignore) {\n mIgnore = ignore;\n }\n \n public boolean getIgnore() {\n return mIgnore;\n }\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/AsyncSSLServerSocket.java",
"content": "package com.koushikdutta.async;\n\nimport java.security.PrivateKey;\nimport java.security.cert.Certificate;\n\npublic interface AsyncSSLServerSocket extends AsyncServerSocket {\n PrivateKey getPrivateKey();\n Certificate getCertificate();\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/AsyncSSLSocket.java",
"content": "package com.koushikdutta.async;\n\nimport java.security.cert.X509Certificate;\n\nimport javax.net.ssl.SSLEngine;\n\npublic interface AsyncSSLSocket extends AsyncSocket {\n public X509Certificate[] getPeerCertificates();\n public SSLEngine getSSLEngine();\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/AsyncSSLSocketWrapper.java",
"content": "package com.koushikdutta.async;\n\nimport android.content.Context;\nimport android.os.Build;\nimport android.util.Base64;\nimport android.util.Log;\nimport android.util.Pair;\n\nimport com.koushikdutta.async.callback.CompletedCallback;\nimport com.koushikdutta.async.callback.ConnectCallback;\nimport com.koushikdutta.async.callback.DataCallback;\nimport com.koushikdutta.async.callback.ListenCallback;\nimport com.koushikdutta.async.callback.WritableCallback;\nimport com.koushikdutta.async.future.Cancellable;\nimport com.koushikdutta.async.future.SimpleCancellable;\nimport com.koushikdutta.async.http.SSLEngineSNIConfigurator;\nimport com.koushikdutta.async.util.Allocator;\nimport com.koushikdutta.async.util.StreamUtility;\nimport com.koushikdutta.async.wrapper.AsyncSocketWrapper;\n\nimport org.apache.http.conn.ssl.StrictHostnameVerifier;\nimport org.bouncycastle.asn1.ASN1ObjectIdentifier;\nimport org.bouncycastle.asn1.x500.X500Name;\nimport org.bouncycastle.asn1.x509.BasicConstraints;\nimport org.bouncycastle.cert.jcajce.JcaX509CertificateConverter;\nimport org.bouncycastle.cert.jcajce.JcaX509v3CertificateBuilder;\nimport org.bouncycastle.jce.provider.BouncyCastleProvider;\nimport org.bouncycastle.operator.ContentSigner;\nimport org.bouncycastle.operator.OperatorCreationException;\nimport org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;\n\nimport java.io.ByteArrayInputStream;\nimport java.io.File;\nimport java.io.FileInputStream;\nimport java.io.IOException;\nimport java.math.BigInteger;\nimport java.net.InetAddress;\nimport java.nio.ByteBuffer;\nimport java.security.GeneralSecurityException;\nimport java.security.KeyFactory;\nimport java.security.KeyPair;\nimport java.security.KeyPairGenerator;\nimport java.security.KeyStore;\nimport java.security.NoSuchAlgorithmException;\nimport java.security.PrivateKey;\nimport java.security.Provider;\nimport java.security.PublicKey;\nimport java.security.Security;\nimport java.security.cert.Certificate;\nimport java.security.cert.CertificateException;\nimport java.security.cert.CertificateFactory;\nimport java.security.cert.X509Certificate;\nimport java.security.spec.PKCS8EncodedKeySpec;\nimport java.security.spec.RSAPublicKeySpec;\nimport java.security.spec.X509EncodedKeySpec;\nimport java.util.Calendar;\nimport java.util.Date;\n\nimport javax.net.ssl.HostnameVerifier;\nimport javax.net.ssl.KeyManagerFactory;\nimport javax.net.ssl.SSLContext;\nimport javax.net.ssl.SSLEngine;\nimport javax.net.ssl.SSLEngineResult;\nimport javax.net.ssl.SSLEngineResult.HandshakeStatus;\nimport javax.net.ssl.SSLEngineResult.Status;\nimport javax.net.ssl.SSLException;\nimport javax.net.ssl.SSLSession;\nimport javax.net.ssl.TrustManager;\nimport javax.net.ssl.TrustManagerFactory;\nimport javax.net.ssl.X509TrustManager;\n\npublic class AsyncSSLSocketWrapper implements AsyncSocketWrapper, AsyncSSLSocket {\n private static final String LOGTAG = \"AsyncSSLSocketWrapper\";\n\n public interface HandshakeCallback {\n public void onHandshakeCompleted(Exception e, AsyncSSLSocket socket);\n }\n\n static SSLContext defaultSSLContext;\n static SSLContext trustAllSSLContext;\n static TrustManager[] trustAllManagers;\n static HostnameVerifier trustAllVerifier;\n\n AsyncSocket mSocket;\n BufferedDataSink mSink;\n boolean mUnwrapping;\n SSLEngine engine;\n boolean finishedHandshake;\n private int mPort;\n private String mHost;\n private boolean mWrapping;\n HostnameVerifier hostnameVerifier;\n HandshakeCallback handshakeCallback;\n X509Certificate[] peerCertificates;\n WritableCallback mWriteableCallback;\n DataCallback mDataCallback;\n TrustManager[] trustManagers;\n boolean clientMode;\n\n static {\n // following is the \"trust the system\" certs setup\n try {\n // critical extension 2.5.29.15 is implemented improperly prior to 4.0.3.\n // https://code.google.com/p/android/issues/detail?id=9307\n // https://groups.google.com/forum/?fromgroups=#!topic/netty/UCfqPPk5O4s\n // certs that use this extension will throw in Cipher.java.\n // fallback is to use a custom SSLContext, and hack around the x509 extension.\n if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1)\n throw new Exception();\n defaultSSLContext = SSLContext.getInstance(\"Default\");\n }\n catch (Exception ex) {\n try {\n defaultSSLContext = SSLContext.getInstance(\"TLS\");\n TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {\n public java.security.cert.X509Certificate[] getAcceptedIssuers() {\n return new X509Certificate[0];\n }\n\n public void checkClientTrusted(java.security.cert.X509Certificate[] certs, String authType) {\n }\n\n public void checkServerTrusted(java.security.cert.X509Certificate[] certs, String authType) {\n for (X509Certificate cert : certs) {\n if (cert != null && cert.getCriticalExtensionOIDs() != null)\n cert.getCriticalExtensionOIDs().remove(\"2.5.29.15\");\n }\n }\n } };\n defaultSSLContext.init(null, trustAllCerts, null);\n }\n catch (Exception ex2) {\n ex.printStackTrace();\n ex2.printStackTrace();\n }\n }\n\n\n try {\n trustAllSSLContext = SSLContext.getInstance(\"TLS\");\n trustAllManagers = new TrustManager[] { new X509TrustManager() {\n public java.security.cert.X509Certificate[] getAcceptedIssuers() {\n return new X509Certificate[0];\n }\n\n public void checkClientTrusted(java.security.cert.X509Certificate[] certs, String authType) {\n }\n\n public void checkServerTrusted(java.security.cert.X509Certificate[] certs, String authType) {\n }\n } };\n trustAllSSLContext.init(null, trustAllManagers, null);\n trustAllVerifier = (hostname, session) -> true;\n }\n catch (Exception ex2) {\n ex2.printStackTrace();\n }\n }\n\n public static SSLContext getDefaultSSLContext() {\n return defaultSSLContext;\n }\n\n public static void handshake(AsyncSocket socket,\n String host, int port,\n SSLEngine sslEngine,\n TrustManager[] trustManagers, HostnameVerifier verifier, boolean clientMode,\n final HandshakeCallback callback) {\n AsyncSSLSocketWrapper wrapper = new AsyncSSLSocketWrapper(socket, host, port, sslEngine, trustManagers, verifier, clientMode);\n wrapper.handshakeCallback = callback;\n socket.setClosedCallback(new CompletedCallback() {\n @Override\n public void onCompleted(Exception ex) {\n if (ex != null)\n callback.onHandshakeCompleted(ex, null);\n else\n callback.onHandshakeCompleted(new SSLException(\"socket closed during handshake\"), null);\n }\n });\n try {\n wrapper.engine.beginHandshake();\n wrapper.handleHandshakeStatus(wrapper.engine.getHandshakeStatus());\n } catch (SSLException e) {\n wrapper.report(e);\n }\n }\n\n public static Cancellable connectSocket(AsyncServer server, String host, int port, ConnectCallback callback) {\n return connectSocket(server, host, port, false, callback);\n }\n public static Cancellable connectSocket(AsyncServer server, String host, int port, boolean trustAllCerts, ConnectCallback callback) {\n SimpleCancellable cancellable = new SimpleCancellable();\n Cancellable connect = server.connectSocket(host, port, (ex, netSocket) -> {\n if (ex != null) {\n if (cancellable.setComplete())\n callback.onConnectCompleted(ex, null);\n return;\n }\n\n handshake(netSocket, host, port,\n (trustAllCerts ? trustAllSSLContext : defaultSSLContext).createSSLEngine(host, port),\n trustAllCerts ? trustAllManagers : null,\n trustAllCerts ? trustAllVerifier : null,\n true, (e, socket) -> {\n if (!cancellable.setComplete()) {\n if (socket != null)\n socket.close();\n return;\n }\n\n if (e != null)\n callback.onConnectCompleted(e, null);\n else\n callback.onConnectCompleted(null, socket);\n });\n });\n\n cancellable.setParent(connect);\n return cancellable;\n }\n\n boolean mEnded;\n Exception mEndException;\n final ByteBufferList pending = new ByteBufferList();\n\n private AsyncSSLSocketWrapper(AsyncSocket socket,\n String host, int port,\n SSLEngine sslEngine,\n TrustManager[] trustManagers, HostnameVerifier verifier, boolean clientMode) {\n mSocket = socket;\n hostnameVerifier = verifier;\n this.clientMode = clientMode;\n this.trustManagers = trustManagers;\n this.engine = sslEngine;\n\n mHost = host;\n mPort = port;\n engine.setUseClientMode(clientMode);\n mSink = new BufferedDataSink(socket);\n mSink.setWriteableCallback(new WritableCallback() {\n @Override\n public void onWriteable() {\n if (mWriteableCallback != null)\n mWriteableCallback.onWriteable();\n }\n });\n\n // on pause, the emitter is paused to prevent the buffered\n // socket and itself from firing.\n // on resume, emitter is resumed, ssl buffer is flushed as well\n mSocket.setEndCallback(new CompletedCallback() {\n @Override\n public void onCompleted(Exception ex) {\n if (mEnded)\n return;\n mEnded = true;\n mEndException = ex;\n if (!pending.hasRemaining() && mEndCallback != null)\n mEndCallback.onCompleted(ex);\n }\n });\n\n mSocket.setDataCallback(dataCallback);\n }\n\n final DataCallback dataCallback = new DataCallback() {\n final Allocator allocator = new Allocator().setMinAlloc(8192);\n final ByteBufferList buffered = new ByteBufferList();\n\n @Override\n public void onDataAvailable(DataEmitter emitter, ByteBufferList bb) {\n if (mUnwrapping)\n return;\n try {\n mUnwrapping = true;\n\n bb.get(buffered);\n\n if (buffered.hasRemaining()) {\n ByteBuffer all = buffered.getAll();\n buffered.add(all);\n }\n\n ByteBuffer b = ByteBufferList.EMPTY_BYTEBUFFER;\n while (true) {\n if (b.remaining() == 0 && buffered.size() > 0) {\n b = buffered.remove();\n }\n int remaining = b.remaining();\n int before = pending.remaining();\n\n SSLEngineResult res;\n {\n // wrap to prevent access to the readBuf\n ByteBuffer readBuf = allocator.allocate();\n res = engine.unwrap(b, readBuf);\n addToPending(pending, readBuf);\n allocator.track(pending.remaining() - before);\n }\n if (res.getStatus() == Status.BUFFER_OVERFLOW) {\n allocator.setMinAlloc(allocator.getMinAlloc() * 2);\n remaining = -1;\n }\n else if (res.getStatus() == Status.BUFFER_UNDERFLOW) {\n buffered.addFirst(b);\n if (buffered.size() <= 1) {\n break;\n }\n // pack it\n remaining = -1;\n b = buffered.getAll();\n buffered.addFirst(b);\n b = ByteBufferList.EMPTY_BYTEBUFFER;\n }\n handleHandshakeStatus(res.getHandshakeStatus());\n if (b.remaining() == remaining && before == pending.remaining()) {\n buffered.addFirst(b);\n break;\n }\n }\n\n AsyncSSLSocketWrapper.this.onDataAvailable();\n }\n catch (SSLException ex) {\n// ex.printStackTrace();\n report(ex);\n }\n finally {\n mUnwrapping = false;\n }\n }\n };\n\n public void onDataAvailable() {\n Util.emitAllData(this, pending);\n\n if (mEnded && !pending.hasRemaining() && mEndCallback != null)\n mEndCallback.onCompleted(mEndException);\n }\n\n\n @Override\n public SSLEngine getSSLEngine() {\n return engine;\n }\n\n void addToPending(ByteBufferList out, ByteBuffer mReadTmp) {\n mReadTmp.flip();\n if (mReadTmp.hasRemaining()) {\n out.add(mReadTmp);\n }\n else {\n ByteBufferList.reclaim(mReadTmp);\n }\n }\n\n\n @Override\n public void end() {\n mSocket.end();\n }\n\n public String getHost() {\n return mHost;\n }\n\n public int getPort() {\n return mPort;\n }\n\n private void handleHandshakeStatus(HandshakeStatus status) {\n if (status == HandshakeStatus.NEED_TASK) {\n final Runnable task = engine.getDelegatedTask();\n task.run();\n }\n\n if (status == HandshakeStatus.NEED_WRAP) {\n write(writeList);\n }\n\n if (status == HandshakeStatus.NEED_UNWRAP) {\n dataCallback.onDataAvailable(this, new ByteBufferList());\n }\n\n try {\n if (!finishedHandshake && (engine.getHandshakeStatus() == HandshakeStatus.NOT_HANDSHAKING || engine.getHandshakeStatus() == HandshakeStatus.FINISHED)) {\n if (clientMode) {\n Exception peerUnverifiedCause = null;\n boolean trusted = false;\n try {\n peerCertificates = (X509Certificate[]) engine.getSession().getPeerCertificates();\n if (mHost != null) {\n if (hostnameVerifier == null) {\n StrictHostnameVerifier verifier = new StrictHostnameVerifier();\n verifier.verify(mHost, StrictHostnameVerifier.getCNs(peerCertificates[0]), StrictHostnameVerifier.getDNSSubjectAlts(peerCertificates[0]));\n }\n else {\n if (!hostnameVerifier.verify(mHost, engine.getSession())) {\n throw new SSLException(\"hostname <\" + mHost + \"> has been denied\");\n }\n }\n }\n\n trusted = true;\n }\n catch (SSLException ex) {\n peerUnverifiedCause = ex;\n }\n\n finishedHandshake = true;\n if (!trusted) {\n AsyncSSLException e = new AsyncSSLException(peerUnverifiedCause);\n report(e);\n if (!e.getIgnore())\n throw e;\n }\n }\n else {\n finishedHandshake = true;\n }\n handshakeCallback.onHandshakeCompleted(null, this);\n handshakeCallback = null;\n\n mSocket.setClosedCallback(null);\n // handshake can complete during a wrap, so make sure that the call\n // stack and wrap flag is cleared before invoking writable\n getServer().post(new Runnable() {\n @Override\n public void run() {\n if (mWriteableCallback != null)\n mWriteableCallback.onWriteable();\n }\n });\n onDataAvailable();\n }\n }\n catch (Exception ex) {\n report(ex);\n }\n }\n\n int calculateAlloc(int remaining) {\n // alloc 50% more than we need for writing\n int alloc = remaining * 3 / 2;\n if (alloc == 0)\n alloc = 8192;\n return alloc;\n }\n\n ByteBufferList writeList = new ByteBufferList();\n @Override\n public void write(ByteBufferList bb) {\n if (mWrapping)\n return;\n if (mSink.remaining() > 0)\n return;\n mWrapping = true;\n int remaining;\n SSLEngineResult res = null;\n ByteBuffer writeBuf = ByteBufferList.obtain(calculateAlloc(bb.remaining()));\n do {\n // if the handshake is finished, don't send\n // 0 bytes of data, since that makes the ssl connection die.\n // it wraps a 0 byte package, and craps out.\n if (finishedHandshake && bb.remaining() == 0)\n break;\n remaining = bb.remaining();\n try {\n ByteBuffer[] arr = bb.getAllArray();\n res = engine.wrap(arr, writeBuf);\n bb.addAll(arr);\n writeBuf.flip();\n writeList.add(writeBuf);\n if (writeList.remaining() > 0)\n mSink.write(writeList);\n int previousCapacity = writeBuf.capacity();\n writeBuf = null;\n if (res.getStatus() == Status.BUFFER_OVERFLOW) {\n writeBuf = ByteBufferList.obtain(previousCapacity * 2);\n remaining = -1;\n }\n else {\n writeBuf = ByteBufferList.obtain(calculateAlloc(bb.remaining()));\n handleHandshakeStatus(res.getHandshakeStatus());\n }\n }\n catch (SSLException e) {\n report(e);\n }\n }\n while ((remaining != bb.remaining() || (res != null && res.getHandshakeStatus() == HandshakeStatus.NEED_WRAP)) && mSink.remaining() == 0);\n mWrapping = false;\n ByteBufferList.reclaim(writeBuf);\n }\n\n @Override\n public void setWriteableCallback(WritableCallback handler) {\n mWriteableCallback = handler;\n }\n\n @Override\n public WritableCallback getWriteableCallback() {\n return mWriteableCallback;\n }\n\n private void report(Exception e) {\n final HandshakeCallback hs = handshakeCallback;\n if (hs != null) {\n handshakeCallback = null;\n mSocket.setDataCallback(new DataCallback.NullDataCallback());\n mSocket.end();\n // handshake sets this callback. unset it.\n mSocket.setClosedCallback(null);\n mSocket.close();\n hs.onHandshakeCompleted(e, null);\n return;\n }\n\n CompletedCallback cb = getEndCallback();\n if (cb != null)\n cb.onCompleted(e);\n }\n\n @Override\n public void setDataCallback(DataCallback callback) {\n mDataCallback = callback;\n }\n\n @Override\n public DataCallback getDataCallback() {\n return mDataCallback;\n }\n\n @Override\n public boolean isChunked() {\n return mSocket.isChunked();\n }\n\n @Override\n public boolean isOpen() {\n return mSocket.isOpen();\n }\n\n @Override\n public void close() {\n mSocket.close();\n }\n\n @Override\n public void setClosedCallback(CompletedCallback handler) {\n mSocket.setClosedCallback(handler);\n }\n\n @Override\n public CompletedCallback getClosedCallback() {\n return mSocket.getClosedCallback();\n }\n\n CompletedCallback mEndCallback;\n @Override\n public void setEndCallback(CompletedCallback callback) {\n mEndCallback = callback;\n }\n\n @Override\n public CompletedCallback getEndCallback() {\n return mEndCallback;\n }\n\n @Override\n public void pause() {\n mSocket.pause();\n }\n\n @Override\n public void resume() {\n mSocket.resume();\n onDataAvailable();\n }\n\n @Override\n public boolean isPaused() {\n return mSocket.isPaused();\n }\n\n @Override\n public AsyncServer getServer() {\n return mSocket.getServer();\n }\n\n @Override\n public AsyncSocket getSocket() {\n return mSocket;\n }\n\n @Override\n public DataEmitter getDataEmitter() {\n return mSocket;\n }\n\n @Override\n public X509Certificate[] getPeerCertificates() {\n return peerCertificates;\n }\n\n @Override\n public String charset() {\n return null;\n }\n\n private static Certificate selfSign(KeyPair keyPair, String subjectDN) throws Exception\n {\n Provider bcProvider = new BouncyCastleProvider();\n Security.addProvider(bcProvider);\n\n long now = System.currentTimeMillis();\n Date startDate = new Date(now);\n\n X500Name dnName = new X500Name(\"CN=\" + subjectDN);\n BigInteger certSerialNumber = new BigInteger(Long.toString(now)); // <-- Using the current timestamp as the certificate serial number\n\n Calendar calendar = Calendar.getInstance();\n calendar.setTime(startDate);\n calendar.add(Calendar.YEAR, 1); // <-- 1 Yr validity\n\n Date endDate = calendar.getTime();\n\n String signatureAlgorithm = \"SHA256WithRSA\"; // <-- Use appropriate signature algorithm based on your keyPair algorithm.\n\n ContentSigner contentSigner = new JcaContentSignerBuilder(signatureAlgorithm).build(keyPair.getPrivate());\n\n JcaX509v3CertificateBuilder certBuilder = new JcaX509v3CertificateBuilder(dnName, certSerialNumber, startDate, endDate, dnName, keyPair.getPublic());\n\n // Extensions --------------------------\n\n // Basic Constraints\n BasicConstraints basicConstraints = new BasicConstraints(true); // <-- true for CA, false for EndEntity\n\n certBuilder.addExtension(new ASN1ObjectIdentifier(\"2.5.29.19\"), true, basicConstraints); // Basic Constraints is usually marked as critical.\n\n // -------------------------------------\n\n return new JcaX509CertificateConverter().setProvider(bcProvider).getCertificate(certBuilder.build(contentSigner));\n }\n\n public static Pair selfSignCertificate(final Context context, String subjectName) throws Exception {\n File keyPath = context.getFileStreamPath(subjectName + \"-key.txt\");\n KeyPair pair;\n Certificate cert;\n try {\n String[] keyParts = StreamUtility.readFile(keyPath).split(\"\\n\");\n X509EncodedKeySpec pub = new X509EncodedKeySpec(Base64.decode(keyParts[0], 0));\n PKCS8EncodedKeySpec priv = new PKCS8EncodedKeySpec(Base64.decode(keyParts[1], 0));\n\n cert = CertificateFactory.getInstance(\"X.509\").generateCertificate(new ByteArrayInputStream(Base64.decode(keyParts[2], 0)));\n\n KeyFactory fact = KeyFactory.getInstance(\"RSA\");\n\n pair = new KeyPair(fact.generatePublic(pub), fact.generatePrivate(priv));\n\n }\n catch (Exception e) {\n KeyPairGenerator keyGen = KeyPairGenerator.getInstance(\"RSA\");\n keyGen.initialize(2048);\n pair = keyGen.generateKeyPair();\n\n cert = selfSign(pair, subjectName);\n\n StreamUtility.writeFile(keyPath,\n Base64.encodeToString(pair.getPublic().getEncoded(), Base64.NO_WRAP)\n + \"\\n\"\n + Base64.encodeToString(pair.getPrivate().getEncoded(), Base64.NO_WRAP)\n + \"\\n\"\n + Base64.encodeToString(cert.getEncoded(), Base64.NO_WRAP));\n }\n\n return new Pair<>(pair, cert);\n }\n\n public static AsyncSSLServerSocket listenSecure(final Context context, final AsyncServer server, final String subjectName, final InetAddress host, final int port, final ListenCallback handler) {\n final ObjectHolder holder = new ObjectHolder<>();\n server.run(() -> {\n try {\n Pair keyCert = selfSignCertificate(context, subjectName);\n KeyPair pair = keyCert.first;\n Certificate cert = keyCert.second;\n\n holder.held = listenSecure(server, pair.getPrivate(), cert, host, port, handler);\n }\n catch (Exception e) {\n handler.onCompleted(e);\n }\n });\n return holder.held;\n }\n\n public static AsyncSSLServerSocket listenSecure(AsyncServer server, String keyDer, String certDer, final InetAddress host, final int port, final ListenCallback handler) {\n return listenSecure(server, Base64.decode(keyDer, Base64.DEFAULT), Base64.decode(certDer, Base64.DEFAULT), host, port, handler);\n }\n\n private static class ObjectHolder {\n T held;\n }\n\n public static AsyncSSLServerSocket listenSecure(final AsyncServer server, final byte[] keyDer, final byte[] certDer, final InetAddress host, final int port, final ListenCallback handler) {\n final ObjectHolder holder = new ObjectHolder<>();\n server.run(() -> {\n try {\n PKCS8EncodedKeySpec key = new PKCS8EncodedKeySpec(keyDer);\n Certificate cert = CertificateFactory.getInstance(\"X.509\").generateCertificate(new ByteArrayInputStream(certDer));\n\n PrivateKey pk = KeyFactory.getInstance(\"RSA\").generatePrivate(key);\n\n holder.held = listenSecure(server, pk, cert, host, port, handler);\n }\n catch (Exception e) {\n handler.onCompleted(e);\n }\n });\n return holder.held;\n }\n\n public static AsyncSSLServerSocket listenSecure(final AsyncServer server, final PrivateKey pk, final Certificate cert, final InetAddress host, final int port, final ListenCallback handler) {\n final ObjectHolder holder = new ObjectHolder<>();\n server.run(() -> {\n try {\n KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());\n ks.load(null);\n\n ks.setKeyEntry(\"key\", pk, null, new Certificate[] { cert });\n\n KeyManagerFactory kmf = KeyManagerFactory.getInstance(\"X509\");\n kmf.init(ks, \"\".toCharArray());\n\n TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());\n tmf.init(ks);\n\n SSLContext sslContext = SSLContext.getInstance(\"TLS\");\n sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);\n\n final AsyncServerSocket socket = listenSecure(server, sslContext, host, port, handler);\n holder.held = new AsyncSSLServerSocket() {\n @Override\n public PrivateKey getPrivateKey() {\n return pk;\n }\n\n @Override\n public Certificate getCertificate() {\n return cert;\n }\n\n @Override\n public void stop() {\n socket.stop();\n }\n\n @Override\n public int getLocalPort() {\n return socket.getLocalPort();\n }\n };\n }\n catch (Exception e) {\n handler.onCompleted(e);\n }\n });\n return holder.held;\n }\n\n public static AsyncServerSocket listenSecure(AsyncServer server, final SSLContext sslContext, final InetAddress host, final int port, final ListenCallback handler) {\n final SSLEngineSNIConfigurator conf = new SSLEngineSNIConfigurator() {\n @Override\n public SSLEngine createEngine(SSLContext sslContext, String peerHost, int peerPort) {\n SSLEngine engine = super.createEngine(sslContext, peerHost, peerPort);\n// String[] ciphers = engine.getEnabledCipherSuites();\n// for (String cipher: ciphers) {\n// Log.i(LOGTAG, cipher);\n// }\n\n // todo: what's this for? some vestigal vysor code i think. required by audio mirroring?\n engine.setEnabledCipherSuites(new String[] { \"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384\" });\n return engine;\n }\n };\n return server.listen(host, port, new ListenCallback() {\n @Override\n public void onAccepted(final AsyncSocket socket) {\n AsyncSSLSocketWrapper.handshake(socket, null, port, conf.createEngine(sslContext, null, port), null, null, false,\n (e, sslSocket) -> {\n if (e != null) {\n // chrome seems to do some sort of SSL probe and cancels handshakes. not sure why.\n // i suspect it is to pick an optimal strong cipher.\n // seeing a lot of the following in the log (but no actual connection errors)\n // javax.net.ssl.SSLHandshakeException: error:10000416:SSL routines:OPENSSL_internal:SSLV3_ALERT_CERTIFICATE_UNKNOWN\n // seen on Shield TV running API 26\n // todo fix: conscrypt ssl context?\n// Log.e(LOGTAG, \"Error while handshaking\", e);\n socket.close();\n return;\n }\n handler.onAccepted(sslSocket);\n });\n }\n\n @Override\n public void onListening(AsyncServerSocket socket) {\n handler.onListening(socket);\n }\n\n @Override\n public void onCompleted(Exception ex) {\n handler.onCompleted(ex);\n }\n });\n }\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/AsyncSemaphore.java",
"content": "package com.koushikdutta.async;\n\nimport java.util.concurrent.Semaphore;\nimport java.util.concurrent.TimeUnit;\n\npublic class AsyncSemaphore {\n\n Semaphore semaphore = new Semaphore(0);\n\n public void acquire() throws InterruptedException {\n ThreadQueue threadQueue = ThreadQueue.getOrCreateThreadQueue(Thread.currentThread());\n AsyncSemaphore last = threadQueue.waiter;\n threadQueue.waiter = this;\n Semaphore queueSemaphore = threadQueue.queueSemaphore;\n try {\n if (semaphore.tryAcquire())\n return;\n\n while (true) {\n // run the queue\n while (true) {\n Runnable run = threadQueue.remove();\n if (run == null)\n break;\n// Log.i(LOGTAG, \"Pumping for AsyncSemaphore\");\n run.run();\n }\n\n int permits = Math.max(1, queueSemaphore.availablePermits());\n queueSemaphore.acquire(permits);\n if (semaphore.tryAcquire())\n break;\n }\n }\n finally {\n threadQueue.waiter = last;\n }\n }\n\n public boolean tryAcquire(long timeout, TimeUnit timeunit) throws InterruptedException {\n long timeoutMs = TimeUnit.MILLISECONDS.convert(timeout, timeunit);\n ThreadQueue threadQueue = ThreadQueue.getOrCreateThreadQueue(Thread.currentThread());\n AsyncSemaphore last = threadQueue.waiter;\n threadQueue.waiter = this;\n Semaphore queueSemaphore = threadQueue.queueSemaphore;\n\n try {\n if (semaphore.tryAcquire())\n return true;\n\n long start = System.currentTimeMillis();\n do {\n // run the queue\n while (true) {\n Runnable run = threadQueue.remove();\n if (run == null)\n break;\n// Log.i(LOGTAG, \"Pumping for AsyncSemaphore\");\n run.run();\n }\n\n int permits = Math.max(1, queueSemaphore.availablePermits());\n if (!queueSemaphore.tryAcquire(permits, timeoutMs, TimeUnit.MILLISECONDS))\n return false;\n if (semaphore.tryAcquire())\n return true;\n }\n while (System.currentTimeMillis() - start < timeoutMs);\n return false;\n }\n finally {\n threadQueue.waiter = last;\n }\n }\n\n public void release() {\n semaphore.release();\n ThreadQueue.release(this);\n }\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/AsyncServer.java",
"content": "package com.koushikdutta.async;\n\nimport android.os.Build;\nimport android.os.Handler;\nimport android.os.SystemClock;\nimport android.util.Log;\n\nimport com.koushikdutta.async.callback.CompletedCallback;\nimport com.koushikdutta.async.callback.ConnectCallback;\nimport com.koushikdutta.async.callback.ListenCallback;\nimport com.koushikdutta.async.callback.SocketCreateCallback;\nimport com.koushikdutta.async.callback.ValueFunction;\nimport com.koushikdutta.async.future.Cancellable;\nimport com.koushikdutta.async.future.Future;\nimport com.koushikdutta.async.future.FutureCallback;\nimport com.koushikdutta.async.future.SimpleCancellable;\nimport com.koushikdutta.async.future.SimpleFuture;\nimport com.koushikdutta.async.util.StreamUtility;\n\nimport java.io.IOException;\nimport java.net.Inet4Address;\nimport java.net.Inet6Address;\nimport java.net.InetAddress;\nimport java.net.InetSocketAddress;\nimport java.net.SocketAddress;\nimport java.nio.channels.CancelledKeyException;\nimport java.nio.channels.ClosedChannelException;\nimport java.nio.channels.ClosedSelectorException;\nimport java.nio.channels.DatagramChannel;\nimport java.nio.channels.SelectionKey;\nimport java.nio.channels.ServerSocketChannel;\nimport java.nio.channels.SocketChannel;\nimport java.nio.channels.spi.SelectorProvider;\nimport java.util.Arrays;\nimport java.util.Comparator;\nimport java.util.PriorityQueue;\nimport java.util.Set;\nimport java.util.concurrent.ExecutorService;\nimport java.util.concurrent.LinkedBlockingQueue;\nimport java.util.concurrent.Semaphore;\nimport java.util.concurrent.ThreadFactory;\nimport java.util.concurrent.ThreadPoolExecutor;\nimport java.util.concurrent.TimeUnit;\nimport java.util.concurrent.atomic.AtomicInteger;\n\npublic class AsyncServer {\n public static final String LOGTAG = \"NIO\";\n\n private static class RunnableWrapper implements Runnable {\n boolean hasRun;\n Runnable runnable;\n ThreadQueue threadQueue;\n Handler handler;\n @Override\n public void run() {\n synchronized (this) {\n if (hasRun)\n return;\n hasRun = true;\n }\n try {\n runnable.run();\n }\n finally {\n threadQueue.remove(this);\n handler.removeCallbacks(this);\n\n threadQueue = null;\n handler = null;\n runnable = null;\n }\n }\n }\n\n public static void post(Handler handler, Runnable runnable) {\n RunnableWrapper wrapper = new RunnableWrapper();\n ThreadQueue threadQueue = ThreadQueue.getOrCreateThreadQueue(handler.getLooper().getThread());\n wrapper.threadQueue = threadQueue;\n wrapper.handler = handler;\n wrapper.runnable = runnable;\n\n // run it in a blocking AsyncSemaphore or a Handler, whichever gets to it first.\n threadQueue.add(wrapper);\n handler.post(wrapper);\n\n // run the queue if the thread is blocking\n threadQueue.queueSemaphore.release();\n }\n\n static {\n try {\n if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.FROYO) {\n java.lang.System.setProperty(\"java.net.preferIPv4Stack\", \"true\");\n java.lang.System.setProperty(\"java.net.preferIPv6Addresses\", \"false\");\n }\n }\n catch (Throwable ex) {\n }\n }\n\n static AsyncServer mInstance = new AsyncServer();\n public static AsyncServer getDefault() {\n return mInstance;\n }\n\n private SelectorWrapper mSelector;\n\n public boolean isRunning() {\n return mSelector != null;\n }\n\n String mName;\n public AsyncServer() {\n this(null);\n }\n\n public AsyncServer(String name) {\n if (name == null)\n name = \"AsyncServer\";\n mName = name;\n }\n\n private static ExecutorService synchronousWorkers = newSynchronousWorkers(\"AsyncServer-worker-\");\n private static void wakeup(final SelectorWrapper selector) {\n synchronousWorkers.execute(() -> {\n try {\n selector.wakeupOnce();\n }\n catch (Exception e) {\n }\n });\n }\n\n boolean killed;\n public void kill() {\n synchronized (this) {\n killed = true;\n }\n stop(false);\n }\n\n int postCounter = 0;\n public Cancellable postDelayed(Runnable runnable, long delay) {\n Scheduled s;\n synchronized (this) {\n if (killed)\n return SimpleCancellable.CANCELLED;\n\n // Calculate when to run this queue item:\n // If there is a delay (non-zero), add it to the current time\n // When delay is zero, ensure that this follows all other\n // zero-delay queue items. This is done by setting the\n // \"time\" to the queue size. This will make sure it is before\n // all time-delayed queue items (for all real world scenarios)\n // as it will always be less than the current time and also remain\n // behind all other immediately run queue items.\n long time;\n if (delay > 0)\n time = SystemClock.elapsedRealtime() + delay;\n else if (delay == 0)\n time = postCounter++;\n else if (mQueue.size() > 0)\n time = Math.min(0, mQueue.peek().time - 1);\n else\n time = 0;\n mQueue.add(s = new Scheduled(this, runnable, time));\n // start the server up if necessary\n if (mSelector == null)\n run();\n if (!isAffinityThread()) {\n wakeup(mSelector);\n }\n }\n return s;\n }\n\n public Cancellable postImmediate(Runnable runnable) {\n if (Thread.currentThread() == getAffinity()) {\n runnable.run();\n return null;\n }\n return postDelayed(runnable, -1);\n }\n\n public Cancellable post(Runnable runnable) {\n return postDelayed(runnable, 0);\n }\n\n public Cancellable post(final CompletedCallback callback, final Exception e) {\n return post(() -> callback.onCompleted(e));\n }\n\n public void run(final Runnable runnable) {\n if (Thread.currentThread() == mAffinity) {\n post(runnable);\n lockAndRunQueue(this, mQueue);\n return;\n }\n\n final Semaphore semaphore;\n synchronized (this) {\n if (killed)\n return;\n semaphore = new Semaphore(0);\n post(() -> {\n runnable.run();\n semaphore.release();\n });\n }\n try {\n semaphore.acquire();\n }\n catch (InterruptedException e) {\n Log.e(LOGTAG, \"run\", e);\n }\n }\n\n private static class Scheduled implements Cancellable, Runnable {\n // this constructor is only called when the async execution should not be preserved\n // ie... AsyncServer.stop.\n public Scheduled(AsyncServer server, Runnable runnable, long time) {\n this.server = server;\n this.runnable = runnable;\n this.time = time;\n }\n public AsyncServer server;\n public Runnable runnable;\n public long time;\n\n @Override\n public void run() {\n this.runnable.run();\n }\n\n @Override\n public boolean isDone() {\n synchronized (server) {\n return !cancelled && !server.mQueue.contains(this);\n }\n }\n\n boolean cancelled;\n @Override\n public boolean isCancelled() {\n return cancelled;\n }\n\n @Override\n public boolean cancel() {\n synchronized (server) {\n return cancelled = server.mQueue.remove(this);\n }\n }\n }\n PriorityQueue mQueue = new PriorityQueue(1, Scheduler.INSTANCE);\n\n static class Scheduler implements Comparator {\n public static Scheduler INSTANCE = new Scheduler();\n private Scheduler() {\n }\n @Override\n public int compare(Scheduled s1, Scheduled s2) {\n // keep the smaller ones at the head, so they get tossed out quicker\n if (s1.time == s2.time)\n return 0;\n if (s1.time > s2.time)\n return 1;\n return -1;\n }\n }\n\n\n public void stop() {\n stop(false);\n }\n\n public void stop(boolean wait) {\n// Log.i(LOGTAG, \"****AsyncServer is shutting down.****\");\n final SelectorWrapper currentSelector;\n final Semaphore semaphore;\n final boolean isAffinityThread;\n synchronized (this) {\n isAffinityThread = isAffinityThread();\n currentSelector = mSelector;\n if (currentSelector == null)\n return;\n semaphore = new Semaphore(0);\n\n // post a shutdown and wait\n mQueue.add(new Scheduled(this, new Runnable() {\n @Override\n public void run() {\n shutdownEverything(currentSelector);\n semaphore.release();\n }\n }, 0));\n synchronousWorkers.execute(() -> {\n try {\n currentSelector.wakeupOnce();\n }\n catch (Exception e) {\n }\n });\n\n // force any existing connections to die\n shutdownKeys(currentSelector);\n\n mQueue = new PriorityQueue<>(1, Scheduler.INSTANCE);\n mSelector = null;\n mAffinity = null;\n }\n try {\n if (!isAffinityThread && wait)\n semaphore.acquire();\n }\n catch (Exception e) {\n }\n }\n\n protected void onDataReceived(int transmitted) {\n }\n\n protected void onDataSent(int transmitted) {\n }\n\n private static class ObjectHolder {\n T held;\n }\n public AsyncServerSocket listen(final InetAddress host, final int port, final ListenCallback handler) {\n final ObjectHolder holder = new ObjectHolder<>();\n run(new Runnable() {\n @Override\n public void run() {\n ServerSocketChannel closeableServer = null;\n ServerSocketChannelWrapper closeableWrapper = null;\n try {\n closeableServer = ServerSocketChannel.open();\n closeableWrapper = new ServerSocketChannelWrapper(\n closeableServer);\n final ServerSocketChannel server = closeableServer;\n final ServerSocketChannelWrapper wrapper = closeableWrapper;\n InetSocketAddress isa;\n if (host == null)\n isa = new InetSocketAddress(port);\n else\n isa = new InetSocketAddress(host, port);\n server.socket().bind(isa);\n final SelectionKey key = wrapper.register(mSelector.getSelector());\n key.attach(handler);\n handler.onListening(holder.held = new AsyncServerSocket() {\n @Override\n public int getLocalPort() {\n return server.socket().getLocalPort();\n }\n\n @Override\n public void stop() {\n StreamUtility.closeQuietly(wrapper);\n try {\n key.cancel();\n }\n catch (Exception e) {\n }\n }\n });\n }\n catch (IOException e) {\n Log.e(LOGTAG, \"wtf\", e);\n StreamUtility.closeQuietly(closeableWrapper, closeableServer);\n handler.onCompleted(e);\n }\n }\n });\n return holder.held;\n }\n\n private class ConnectFuture extends SimpleFuture {\n @Override\n protected void cancelCleanup() {\n super.cancelCleanup();\n try {\n if (socket != null)\n socket.close();\n }\n catch (IOException e) {\n }\n }\n\n SocketChannel socket;\n ConnectCallback callback;\n }\n\n public Cancellable connectResolvedInetSocketAddress(final InetSocketAddress address, final ConnectCallback callback) {\n return connectResolvedInetSocketAddress(address, callback, null);\n }\n\n public ConnectFuture connectResolvedInetSocketAddress(final InetSocketAddress address, final ConnectCallback callback, final SocketCreateCallback createCallback) {\n final ConnectFuture cancel = new ConnectFuture();\n\n post(new Runnable() {\n @Override\n public void run() {\n if (cancel.isCancelled())\n return;\n\n cancel.callback = callback;\n SelectionKey ckey = null;\n SocketChannel socket = null;\n try {\n socket = cancel.socket = SocketChannel.open();\n socket.configureBlocking(false);\n ckey = socket.register(mSelector.getSelector(), SelectionKey.OP_CONNECT);\n ckey.attach(cancel);\n if (createCallback != null)\n createCallback.onSocketCreated(socket.socket().getLocalPort());\n socket.connect(address);\n }\n catch (Throwable e) {\n if (ckey != null)\n ckey.cancel();\n StreamUtility.closeQuietly(socket);\n cancel.setComplete(new RuntimeException(e));\n }\n }\n });\n\n return cancel;\n }\n\n public Cancellable connectSocket(final InetSocketAddress remote, final ConnectCallback callback) {\n if (!remote.isUnresolved())\n return connectResolvedInetSocketAddress(remote, callback);\n\n final SimpleFuture ret = new SimpleFuture();\n\n Future lookup = getByName(remote.getHostName());\n ret.setParent(lookup);\n lookup\n .setCallback(new FutureCallback() {\n @Override\n public void onCompleted(Exception e, InetAddress result) {\n if (e != null) {\n callback.onConnectCompleted(e, null);\n ret.setComplete(e);\n return;\n }\n\n ret.setComplete((ConnectFuture)connectResolvedInetSocketAddress(new InetSocketAddress(result, remote.getPort()), callback));\n }\n });\n return ret;\n }\n\n public Cancellable connectSocket(final String host, final int port, final ConnectCallback callback) {\n return connectSocket(InetSocketAddress.createUnresolved(host, port), callback);\n }\n\n private static ExecutorService newSynchronousWorkers(String prefix) {\n ThreadFactory tf = new NamedThreadFactory(prefix);\n ThreadPoolExecutor tpe = new ThreadPoolExecutor(0, 4, 10L,\n TimeUnit.SECONDS, new LinkedBlockingQueue(), tf);\n return tpe;\n }\n\n private static final Comparator ipSorter = new Comparator() {\n @Override\n public int compare(InetAddress lhs, InetAddress rhs) {\n if (lhs instanceof Inet4Address && rhs instanceof Inet4Address)\n return 0;\n if (lhs instanceof Inet6Address && rhs instanceof Inet6Address)\n return 0;\n if (lhs instanceof Inet4Address && rhs instanceof Inet6Address)\n return -1;\n return 1;\n }\n };\n\n private static ExecutorService synchronousResolverWorkers = newSynchronousWorkers(\"AsyncServer-resolver-\");\n public Future getAllByName(final String host) {\n final SimpleFuture ret = new SimpleFuture();\n synchronousResolverWorkers.execute(new Runnable() {\n @Override\n public void run() {\n try {\n final InetAddress[] result = InetAddress.getAllByName(host);\n Arrays.sort(result, ipSorter);\n if (result == null || result.length == 0)\n throw new HostnameResolutionException(\"no addresses for host\");\n post(new Runnable() {\n @Override\n public void run() {\n ret.setComplete(null, result);\n }\n });\n } catch (final Exception e) {\n post(new Runnable() {\n @Override\n public void run() {\n ret.setComplete(e, null);\n }\n });\n }\n }\n });\n return ret;\n }\n\n public Future getByName(String host) {\n return getAllByName(host).thenConvert(addresses -> addresses[0]);\n }\n\n private void handleSocket(final AsyncNetworkSocket handler) throws ClosedChannelException {\n final ChannelWrapper sc = handler.getChannel();\n SelectionKey ckey = sc.register(mSelector.getSelector());\n ckey.attach(handler);\n handler.setup(this, ckey);\n }\n\n public AsyncDatagramSocket connectDatagram(final String host, final int port) throws IOException {\n final DatagramChannel socket = DatagramChannel.open();\n final AsyncDatagramSocket handler = new AsyncDatagramSocket();\n handler.attach(socket);\n // ugh.. this should really be post to make it nonblocking...\n // but i want datagrams to be immediately writable.\n // they're not really used anyways.\n run(new Runnable() {\n @Override\n public void run() {\n try {\n final SocketAddress remote = new InetSocketAddress(host, port);\n handleSocket(handler);\n socket.connect(remote);\n }\n catch (IOException e) {\n Log.e(LOGTAG, \"Datagram error\", e);\n StreamUtility.closeQuietly(socket);\n }\n }\n });\n return handler;\n }\n\n public AsyncDatagramSocket openDatagram() {\n return openDatagram(null, 0, false);\n }\n\n public Cancellable createDatagram(String address, int port, boolean reuseAddress, FutureCallback callback) {\n return createDatagram(() -> InetAddress.getByName(address), port, reuseAddress, callback);\n }\n\n public Cancellable createDatagram(InetAddress address, int port, boolean reuseAddress, FutureCallback callback) {\n return createDatagram(() -> address, port, reuseAddress, callback);\n }\n\n private Cancellable createDatagram(ValueFunction inetAddressValueFunction, final int port, final boolean reuseAddress, FutureCallback callback) {\n SimpleFuture ret = new SimpleFuture<>();\n ret.setCallback(callback);\n post(() -> {\n DatagramChannel socket = null;\n try {\n socket = DatagramChannel.open();\n\n final AsyncDatagramSocket handler = new AsyncDatagramSocket();\n handler.attach(socket);\n\n InetSocketAddress address;\n if (inetAddressValueFunction == null)\n address = new InetSocketAddress(port);\n else\n address = new InetSocketAddress(inetAddressValueFunction.getValue(), port);\n\n if (reuseAddress)\n socket.socket().setReuseAddress(reuseAddress);\n socket.socket().bind(address);\n handleSocket(handler);\n if (!ret.setComplete(handler))\n socket.close();\n }\n catch (Exception e) {\n StreamUtility.closeQuietly(socket);\n ret.setComplete(e);\n }\n });\n\n return ret;\n }\n\n public AsyncDatagramSocket openDatagram(final InetAddress host, final int port, final boolean reuseAddress) {\n final AsyncDatagramSocket handler = new AsyncDatagramSocket();\n // ugh.. this should really be post to make it nonblocking...\n // but i want datagrams to be immediately writable.\n // they're not really used anyways.\n Runnable runnable = () -> {\n final DatagramChannel socket;\n try {\n socket = DatagramChannel.open();\n }\n catch (Exception e) {\n return;\n }\n try {\n handler.attach(socket);\n\n InetSocketAddress address;\n if (host == null)\n address = new InetSocketAddress(port);\n else\n address = new InetSocketAddress(host, port);\n\n if (reuseAddress)\n socket.socket().setReuseAddress(reuseAddress);\n socket.socket().bind(address);\n handleSocket(handler);\n }\n catch (IOException e) {\n Log.e(LOGTAG, \"Datagram error\", e);\n StreamUtility.closeQuietly(socket);\n }\n };\n\n if (getAffinity() != Thread.currentThread()) {\n run(runnable);\n return handler;\n }\n\n runnable.run();\n return handler;\n }\n\n public AsyncDatagramSocket connectDatagram(final SocketAddress remote) throws IOException {\n final AsyncDatagramSocket handler = new AsyncDatagramSocket();\n final DatagramChannel socket = DatagramChannel.open();\n handler.attach(socket);\n // ugh.. this should really be post to make it nonblocking...\n // but i want datagrams to be immediately writable.\n // they're not really used anyways.\n Runnable runnable = () -> {\n try {\n handleSocket(handler);\n socket.connect(remote);\n }\n catch (IOException e) {\n StreamUtility.closeQuietly(socket);\n }\n };\n\n if (getAffinity() != Thread.currentThread()) {\n run(runnable);\n return handler;\n }\n\n runnable.run();\n return handler;\n }\n\n final private static ThreadLocal threadServer = new ThreadLocal<>();\n\n public static AsyncServer getCurrentThreadServer() {\n return threadServer.get();\n }\n\n Thread mAffinity;\n private void run() {\n final SelectorWrapper selector;\n final PriorityQueue queue;\n synchronized (this) {\n if (mSelector == null) {\n try {\n selector = mSelector = new SelectorWrapper(SelectorProvider.provider().openSelector());\n queue = mQueue;\n }\n catch (IOException e) {\n throw new RuntimeException(\"unable to create selector?\", e);\n }\n\n mAffinity = new Thread(mName) {\n public void run() {\n try {\n threadServer.set(AsyncServer.this);\n AsyncServer.run(AsyncServer.this, selector, queue);\n }\n finally {\n threadServer.remove();\n }\n }\n };\n\n mAffinity.start();\n // kicked off the new thread, let's bail.\n return;\n }\n\n // this is a reentrant call\n selector = mSelector;\n queue = mQueue;\n\n // fall through to outside of the synchronization scope\n // to allow the thread to run without locking.\n }\n\n try {\n runLoop(this, selector, queue);\n }\n catch (AsyncSelectorException e) {\n Log.i(LOGTAG, \"Selector closed\", e);\n try {\n // StreamUtility.closeQuiety is throwing ArrayStoreException?\n selector.getSelector().close();\n }\n catch (Exception ex) {\n }\n }\n }\n\n private static void run(final AsyncServer server, final SelectorWrapper selector, final PriorityQueue queue) {\n// Log.i(LOGTAG, \"****AsyncServer is starting.****\");\n // at this point, this local queue and selector are owned\n // by this thread.\n // if a stop is called, the instance queue and selector\n // will be replaced and nulled respectively.\n // this will allow the old queue and selector to shut down\n // gracefully, while also allowing a new selector thread\n // to start up while the old one is still shutting down.\n while(true) {\n try {\n runLoop(server, selector, queue);\n }\n catch (AsyncSelectorException e) {\n if (!(e.getCause() instanceof ClosedSelectorException))\n Log.i(LOGTAG, \"Selector exception, shutting down\", e);\n StreamUtility.closeQuietly(selector);\n }\n // see if we keep looping, this must be in a synchronized block since the queue is accessed.\n synchronized (server) {\n if (selector.isOpen() && (selector.keys().size() > 0 || queue.size() > 0))\n continue;\n\n shutdownEverything(selector);\n if (server.mSelector == selector) {\n server.mQueue = new PriorityQueue(1, Scheduler.INSTANCE);\n server.mSelector = null;\n server.mAffinity = null;\n }\n break;\n }\n }\n// Log.i(LOGTAG, \"****AsyncServer has shut down.****\");\n }\n\n private static void shutdownKeys(SelectorWrapper selector) {\n try {\n for (SelectionKey key: selector.keys()) {\n StreamUtility.closeQuietly(key.channel());\n try {\n key.cancel();\n }\n catch (Exception e) {\n }\n }\n }\n catch (Exception ex) {\n }\n }\n\n private static void shutdownEverything(SelectorWrapper selector) {\n shutdownKeys(selector);\n // SHUT. DOWN. EVERYTHING.\n StreamUtility.closeQuietly(selector);\n }\n\n private static final long QUEUE_EMPTY = Long.MAX_VALUE;\n private static long lockAndRunQueue(final AsyncServer server, final PriorityQueue queue) {\n long wait = QUEUE_EMPTY;\n\n // find the first item we can actually run\n while (true) {\n Scheduled run = null;\n\n synchronized (server) {\n long now = SystemClock.elapsedRealtime();\n\n if (queue.size() > 0) {\n Scheduled s = queue.remove();\n if (s.time <= now) {\n run = s;\n }\n else {\n wait = s.time - now;\n queue.add(s);\n }\n }\n }\n\n if (run == null)\n break;\n\n run.run();\n }\n\n server.postCounter = 0;\n return wait;\n }\n\n private static class AsyncSelectorException extends IOException {\n public AsyncSelectorException(Exception e) {\n super(e);\n }\n }\n\n private static void runLoop(final AsyncServer server, final SelectorWrapper selector, final PriorityQueue queue) throws AsyncSelectorException {\n// Log.i(LOGTAG, \"Keys: \" + selector.keys().size());\n boolean needsSelect = true;\n\n // run the queue to populate the selector with keys\n long wait = lockAndRunQueue(server, queue);\n try {\n synchronized (server) {\n // select now to see if anything is ready immediately. this\n // also clears the canceled key queue.\n int readyNow = selector.selectNow();\n if (readyNow == 0) {\n // if there is nothing to select now, make sure we don't have an empty key set\n // which means it would be time to turn this thread off.\n if (selector.keys().size() == 0 && wait == QUEUE_EMPTY) {\n// Log.i(LOGTAG, \"Shutting down. keys: \" + selector.keys().size() + \" keepRunning: \" + keepRunning);\n return;\n }\n }\n else {\n needsSelect = false;\n }\n }\n\n if (needsSelect) {\n if (wait == QUEUE_EMPTY) {\n // wait until woken up\n selector.select();\n }\n else {\n // nothing to select immediately but there's something pending so let's block that duration and wait.\n selector.select(wait);\n }\n }\n }\n catch (Exception e) {\n throw new AsyncSelectorException(e);\n }\n\n // process whatever keys are ready\n Set readyKeys = selector.selectedKeys();\n for (SelectionKey key: readyKeys) {\n try {\n if (key.isAcceptable()) {\n ServerSocketChannel nextReady = (ServerSocketChannel) key.channel();\n SocketChannel sc = null;\n SelectionKey ckey = null;\n try {\n sc = nextReady.accept();\n if (sc == null)\n continue;\n sc.configureBlocking(false);\n ckey = sc.register(selector.getSelector(), SelectionKey.OP_READ);\n ListenCallback serverHandler = (ListenCallback) key.attachment();\n AsyncNetworkSocket handler = new AsyncNetworkSocket();\n handler.attach(sc, (InetSocketAddress)sc.socket().getRemoteSocketAddress());\n handler.setup(server, ckey);\n ckey.attach(handler);\n serverHandler.onAccepted(handler);\n }\n catch (IOException e) {\n StreamUtility.closeQuietly(sc);\n if (ckey != null)\n ckey.cancel();\n }\n }\n else if (key.isReadable()) {\n AsyncNetworkSocket handler = (AsyncNetworkSocket) key.attachment();\n int transmitted = handler.onReadable();\n server.onDataReceived(transmitted);\n }\n else if (key.isWritable()) {\n AsyncNetworkSocket handler = (AsyncNetworkSocket) key.attachment();\n handler.onDataWritable();\n }\n else if (key.isConnectable()) {\n ConnectFuture cancel = (ConnectFuture) key.attachment();\n SocketChannel sc = (SocketChannel) key.channel();\n key.interestOps(SelectionKey.OP_READ);\n AsyncNetworkSocket newHandler;\n try {\n sc.finishConnect();\n newHandler = new AsyncNetworkSocket();\n newHandler.setup(server, key);\n newHandler.attach(sc, (InetSocketAddress)sc.socket().getRemoteSocketAddress());\n key.attach(newHandler);\n }\n catch (IOException ex) {\n key.cancel();\n StreamUtility.closeQuietly(sc);\n if (cancel.setComplete(ex))\n cancel.callback.onConnectCompleted(ex, null);\n continue;\n }\n if (cancel.setComplete(newHandler))\n cancel.callback.onConnectCompleted(null, newHandler);\n }\n else {\n Log.i(LOGTAG, \"wtf\");\n throw new RuntimeException(\"Unknown key state.\");\n }\n }\n catch (CancelledKeyException ex) {\n }\n }\n readyKeys.clear();\n }\n\n public void dump() {\n post(new Runnable() {\n @Override\n public void run() {\n if (mSelector == null) {\n Log.i(LOGTAG, \"Server dump not possible. No selector?\");\n return;\n }\n Log.i(LOGTAG, \"Key Count: \" + mSelector.keys().size());\n\n for (SelectionKey key: mSelector.keys()) {\n Log.i(LOGTAG, \"Key: \" + key);\n }\n }\n });\n }\n\n public Thread getAffinity() {\n return mAffinity;\n }\n\n public boolean isAffinityThread() {\n return mAffinity == Thread.currentThread();\n }\n\n public boolean isAffinityThreadOrStopped() {\n Thread affinity = mAffinity;\n return affinity == null || affinity == Thread.currentThread();\n }\n\n private static class NamedThreadFactory implements ThreadFactory {\n private final ThreadGroup group;\n private final AtomicInteger threadNumber = new AtomicInteger(1);\n private final String namePrefix;\n\n NamedThreadFactory(String namePrefix) {\n SecurityManager s = System.getSecurityManager();\n group = (s != null) ? s.getThreadGroup() :\n Thread.currentThread().getThreadGroup();\n this.namePrefix = namePrefix;\n }\n\n public Thread newThread(Runnable r) {\n Thread t = new Thread(group, r,\n namePrefix + threadNumber.getAndIncrement(), 0);\n if (t.isDaemon()) t.setDaemon(false);\n if (t.getPriority() != Thread.NORM_PRIORITY) {\n t.setPriority(Thread.NORM_PRIORITY);\n }\n return t;\n }\n }\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/AsyncServerSocket.java",
"content": "package com.koushikdutta.async;\n\npublic interface AsyncServerSocket {\n public void stop();\n public int getLocalPort();\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/AsyncSocket.java",
"content": "package com.koushikdutta.async;\n\n\npublic interface AsyncSocket extends DataEmitter, DataSink {\n public AsyncServer getServer();\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/BufferedDataSink.java",
"content": "package com.koushikdutta.async;\n\nimport com.koushikdutta.async.callback.CompletedCallback;\nimport com.koushikdutta.async.callback.WritableCallback;\n\npublic class BufferedDataSink implements DataSink {\n DataSink mDataSink;\n public BufferedDataSink(DataSink datasink) {\n setDataSink(datasink);\n }\n\n public boolean isBuffering() {\n return mPendingWrites.hasRemaining() || forceBuffering;\n }\n\n public boolean isWritable() {\n synchronized (mPendingWrites) {\n return mPendingWrites.remaining() < mMaxBuffer;\n }\n }\n\n public DataSink getDataSink() {\n return mDataSink;\n }\n\n boolean forceBuffering;\n public void forceBuffering(boolean forceBuffering) {\n this.forceBuffering = forceBuffering;\n if (!forceBuffering)\n writePending();\n }\n\n public void setDataSink(DataSink datasink) {\n mDataSink = datasink;\n mDataSink.setWriteableCallback(this::writePending);\n }\n\n private void writePending() {\n if (forceBuffering)\n return;\n\n// Log.i(\"NIO\", \"Writing to buffer...\");\n boolean empty;\n synchronized (mPendingWrites) {\n mDataSink.write(mPendingWrites);\n empty = mPendingWrites.isEmpty();\n }\n if (empty) {\n if (endPending)\n mDataSink.end();\n }\n if (empty && mWritable != null)\n mWritable.onWriteable();\n }\n \n final ByteBufferList mPendingWrites = new ByteBufferList();\n\n // before the data is queued, let inheritors know. allows for filters, without\n // issues with having to filter before writing which may fail in the buffer.\n protected void onDataAccepted(ByteBufferList bb) {\n }\n\n @Override\n public void write(final ByteBufferList bb) {\n if (getServer().getAffinity() != Thread.currentThread()) {\n synchronized (mPendingWrites) {\n if (mPendingWrites.remaining() >= mMaxBuffer)\n return;\n onDataAccepted(bb);\n bb.get(mPendingWrites);\n }\n getServer().post(this::writePending);\n return;\n }\n\n onDataAccepted(bb);\n\n if (!isBuffering())\n mDataSink.write(bb);\n\n synchronized (mPendingWrites) {\n bb.get(mPendingWrites);\n }\n }\n\n WritableCallback mWritable;\n @Override\n public void setWriteableCallback(WritableCallback handler) {\n mWritable = handler;\n }\n\n @Override\n public WritableCallback getWriteableCallback() {\n return mWritable;\n }\n \n public int remaining() {\n return mPendingWrites.remaining();\n }\n \n int mMaxBuffer = Integer.MAX_VALUE;\n public int getMaxBuffer() {\n return mMaxBuffer;\n }\n\n public void setMaxBuffer(int maxBuffer) {\n mMaxBuffer = maxBuffer;\n }\n\n @Override\n public boolean isOpen() {\n return mDataSink.isOpen();\n }\n\n boolean endPending;\n @Override\n public void end() {\n if (getServer().getAffinity() != Thread.currentThread()) {\n getServer().post(this::end);\n return;\n }\n\n synchronized (mPendingWrites) {\n if (mPendingWrites.hasRemaining()) {\n endPending = true;\n return;\n }\n }\n mDataSink.end();\n }\n\n @Override\n public void setClosedCallback(CompletedCallback handler) {\n mDataSink.setClosedCallback(handler);\n }\n\n @Override\n public CompletedCallback getClosedCallback() {\n return mDataSink.getClosedCallback();\n }\n\n @Override\n public AsyncServer getServer() {\n return mDataSink.getServer();\n }\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/ByteBufferList.java",
"content": "package com.koushikdutta.async;\n\nimport android.annotation.TargetApi;\nimport android.os.Build;\nimport android.os.Looper;\n\nimport com.koushikdutta.async.util.ArrayDeque;\nimport com.koushikdutta.async.util.Charsets;\n\nimport java.io.IOException;\nimport java.io.OutputStream;\nimport java.nio.ByteBuffer;\nimport java.nio.ByteOrder;\nimport java.nio.charset.Charset;\nimport java.util.Comparator;\nimport java.util.PriorityQueue;\n\n@TargetApi(Build.VERSION_CODES.GINGERBREAD)\npublic class ByteBufferList {\n ArrayDeque mBuffers = new ArrayDeque();\n \n ByteOrder order = ByteOrder.BIG_ENDIAN;\n public ByteOrder order() {\n return order;\n }\n\n public ByteBufferList order(ByteOrder order) {\n this.order = order;\n return this;\n }\n\n public ByteBufferList() {\n }\n\n public ByteBufferList(ByteBuffer... b) {\n addAll(b);\n }\n\n public ByteBufferList(byte[] buf) {\n super();\n ByteBuffer b = ByteBuffer.wrap(buf);\n add(b);\n }\n\n public ByteBufferList addAll(ByteBuffer... bb) {\n for (ByteBuffer b: bb)\n add(b);\n return this;\n }\n\n public ByteBufferList addAll(ByteBufferList... bb) {\n for (ByteBufferList b: bb)\n b.get(this);\n return this;\n }\n\n public byte[] getBytes(int length) {\n byte[] ret = new byte[length];\n get(ret);\n return ret;\n }\n\n public byte[] getAllByteArray() {\n byte[] ret = new byte[remaining()];\n get(ret);\n return ret;\n }\n\n public ByteBuffer[] getAllArray() {\n ByteBuffer[] ret = new ByteBuffer[mBuffers.size()];\n ret = mBuffers.toArray(ret);\n mBuffers.clear();\n remaining = 0;\n return ret;\n }\n\n public boolean isEmpty() {\n return remaining == 0;\n }\n\n private int remaining = 0;\n public int remaining() {\n return remaining;\n }\n\n public boolean hasRemaining() {\n return remaining() > 0;\n }\n\n public short peekShort() {\n return read(2).getShort(mBuffers.peekFirst().position());\n }\n\n public byte peek() {\n return read(1).get(mBuffers.peekFirst().position());\n }\n\n public int peekInt() {\n return read(4).getInt(mBuffers.peekFirst().position());\n }\n\n public long peekLong() {\n return read(8).getLong(mBuffers.peekFirst().position());\n }\n\n public byte[] peekBytes(int size) {\n byte[] ret = new byte[size];\n read(size).get(ret, mBuffers.peekFirst().position(), ret.length);\n return ret;\n }\n\n public ByteBufferList skip(int length) {\n get(null, 0, length);\n return this;\n }\n\n public int getInt() {\n int ret = read(4).getInt();\n remaining -= 4;\n return ret;\n }\n \n public char getByteChar() {\n char ret = (char)read(1).get();\n remaining--;\n return ret;\n }\n \n public short getShort() {\n short ret = read(2).getShort();\n remaining -= 2;\n return ret;\n }\n \n public byte get() {\n byte ret = read(1).get();\n remaining--;\n return ret;\n }\n \n public long getLong() {\n long ret = read(8).getLong();\n remaining -= 8;\n return ret;\n }\n\n public void get(byte[] bytes) {\n get(bytes, 0, bytes.length);\n }\n\n public void get(byte[] bytes, int offset, int length) {\n if (remaining() < length)\n throw new IllegalArgumentException(\"length\");\n\n int need = length;\n while (need > 0) {\n ByteBuffer b = mBuffers.peek();\n int read = Math.min(b.remaining(), need);\n if (bytes != null){\n b.get(bytes, offset, read);\n } else {\n //when bytes is null, just skip data.\n b.position(b.position() + read);\n }\n need -= read;\n offset += read;\n if (b.remaining() == 0) {\n ByteBuffer removed = mBuffers.remove();\n reclaim(b);\n }\n }\n\n remaining -= length;\n }\n\n public void get(ByteBufferList into, int length) {\n if (remaining() < length)\n throw new IllegalArgumentException(\"length\");\n int offset = 0;\n\n while (offset < length) {\n ByteBuffer b = mBuffers.remove();\n int remaining = b.remaining();\n\n if (remaining == 0) {\n reclaim(b);\n continue;\n }\n\n if (offset + remaining > length) {\n int need = length - offset;\n // this is shared between both\n ByteBuffer subset = obtain(need);\n subset.limit(need);\n b.get(subset.array(), 0, need);\n into.add(subset);\n mBuffers.addFirst(b);\n break;\n }\n else {\n // this belongs to the new list\n into.add(b);\n }\n\n offset += remaining;\n }\n\n remaining -= length;\n }\n\n public void get(ByteBufferList into) {\n get(into, remaining());\n }\n\n public ByteBufferList get(int length) {\n ByteBufferList ret = new ByteBufferList();\n get(ret, length);\n return ret.order(order);\n }\n\n public ByteBuffer getAll() {\n if (remaining() == 0)\n return EMPTY_BYTEBUFFER;\n read(remaining());\n return remove();\n }\n\n private ByteBuffer read(int count) {\n if (remaining() < count)\n throw new IllegalArgumentException(\"count : \" + remaining() + \"/\" + count);\n\n ByteBuffer first = mBuffers.peek();\n while (first != null && !first.hasRemaining()) {\n reclaim(mBuffers.remove());\n first = mBuffers.peek();\n }\n \n if (first == null) {\n return EMPTY_BYTEBUFFER;\n }\n\n if (first.remaining() >= count) {\n return first.order(order);\n }\n\n ByteBuffer ret = obtain(count);\n ret.limit(count);\n byte[] bytes = ret.array();\n int offset = 0;\n ByteBuffer bb = null;\n while (offset < count) {\n bb = mBuffers.remove();\n int toRead = Math.min(count - offset, bb.remaining());\n bb.get(bytes, offset, toRead);\n offset += toRead;\n if (bb.remaining() == 0) {\n reclaim(bb);\n bb = null;\n }\n }\n // if there was still data left in the last buffer we popped\n // toss it back into the head\n if (bb != null && bb.remaining() > 0)\n mBuffers.addFirst(bb);\n mBuffers.addFirst(ret);\n return ret.order(order);\n }\n \n public void trim() {\n // this clears out buffers that are empty in the beginning of the list\n read(0);\n }\n\n public ByteBufferList add(ByteBufferList b) {\n b.get(this);\n return this;\n }\n\n public ByteBufferList add(ByteBuffer b) {\n if (b.remaining() <= 0) {\n// System.out.println(\"reclaiming remaining: \" + b.remaining());\n reclaim(b);\n return this;\n }\n addRemaining(b.remaining());\n // see if we can fit the entirety of the buffer into the end\n // of the current last buffer\n if (mBuffers.size() > 0) {\n ByteBuffer last = mBuffers.getLast();\n if (last.capacity() - last.limit() >= b.remaining()) {\n last.mark();\n last.position(last.limit());\n last.limit(last.capacity());\n last.put(b);\n last.limit(last.position());\n last.reset();\n reclaim(b);\n trim();\n return this;\n }\n }\n mBuffers.add(b);\n trim();\n return this;\n }\n\n public void addFirst(ByteBuffer b) {\n if (b.remaining() <= 0) {\n reclaim(b);\n return;\n }\n addRemaining(b.remaining());\n // see if we can fit the entirety of the buffer into the beginning\n // of the current first buffer\n if (mBuffers.size() > 0) {\n ByteBuffer first = mBuffers.getFirst();\n if (first.position() >= b.remaining()) {\n first.position(first.position() - b.remaining());\n first.mark();\n first.put(b);\n first.reset();\n reclaim(b);\n return;\n }\n }\n mBuffers.addFirst(b);\n }\n\n private void addRemaining(int remaining) {\n if (this.remaining() >= 0)\n this.remaining += remaining;\n }\n\n public void recycle() {\n while (mBuffers.size() > 0) {\n reclaim(mBuffers.remove());\n }\n remaining = 0;\n }\n \n public ByteBuffer remove() {\n ByteBuffer ret = mBuffers.remove();\n remaining -= ret.remaining();\n return ret;\n }\n \n public int size() {\n return mBuffers.size();\n }\n\n public void spewString() {\n System.out.println(peekString());\n }\n\n public String peekString() {\n return peekString(null);\n }\n\n // not doing toString as this is really nasty in the debugger...\n public String peekString(Charset charset) {\n if (charset == null)\n charset = Charsets.UTF_8;\n StringBuilder builder = new StringBuilder();\n for (ByteBuffer bb: mBuffers) {\n byte[] bytes;\n int offset;\n int length;\n if (bb.isDirect()) {\n bytes = new byte[bb.remaining()];\n offset = 0;\n length = bb.remaining();\n bb.get(bytes);\n }\n else {\n bytes = bb.array();\n offset = bb.arrayOffset() + bb.position();\n length = bb.remaining();\n }\n builder.append(new String(bytes, offset, length, charset));\n }\n return builder.toString();\n }\n\n public String readString() {\n return readString(null);\n }\n\n public String readString(Charset charset) {\n String ret = peekString(charset);\n recycle();\n return ret;\n }\n\n static class Reclaimer implements Comparator {\n @Override\n public int compare(ByteBuffer byteBuffer, ByteBuffer byteBuffer2) {\n // keep the smaller ones at the head, so they get tossed out quicker\n if (byteBuffer.capacity() == byteBuffer2.capacity())\n return 0;\n if (byteBuffer.capacity() > byteBuffer2.capacity())\n return 1;\n return -1;\n }\n }\n\n static PriorityQueue reclaimed = new PriorityQueue(8, new Reclaimer());\n\n private static PriorityQueue getReclaimed() {\n Looper mainLooper = Looper.getMainLooper();\n if (mainLooper != null) {\n if (Thread.currentThread() == mainLooper.getThread())\n return null;\n }\n return reclaimed;\n }\n\n private static int MAX_SIZE = 1024 * 1024;\n public static int MAX_ITEM_SIZE = 1024 * 256;\n static int currentSize = 0;\n static int maxItem = 0;\n\n public static void setMaxPoolSize(int size) {\n MAX_SIZE = size;\n }\n\n public static void setMaxItemSize(int size) {\n MAX_ITEM_SIZE = size;\n }\n\n private static boolean reclaimedContains(ByteBuffer b) {\n for (ByteBuffer other: reclaimed) {\n if (other == b)\n return true;\n }\n return false;\n }\n\n public static void reclaim(ByteBuffer b) {\n if (b == null || b.isDirect())\n return;\n if (b.arrayOffset() != 0 || b.array().length != b.capacity())\n return;\n if (b.capacity() < 8192)\n return;\n if (b.capacity() > MAX_ITEM_SIZE)\n return;\n\n PriorityQueue r = getReclaimed();\n if (r == null)\n return;\n\n synchronized (LOCK) {\n while (currentSize > MAX_SIZE && r.size() > 0 && r.peek().capacity() < b.capacity()) {\n// System.out.println(\"removing for better: \" + b.capacity());\n ByteBuffer head = r.remove();\n currentSize -= head.capacity();\n }\n\n if (currentSize > MAX_SIZE) {\n// System.out.println(\"too full: \" + b.capacity());\n return;\n }\n\n b.position(0);\n b.limit(b.capacity());\n currentSize += b.capacity();\n\n r.add(b);\n\n maxItem = Math.max(maxItem, b.capacity());\n }\n }\n\n private static final Object LOCK = new Object();\n\n public static ByteBuffer obtain(int size) {\n if (size <= maxItem) {\n PriorityQueue r = getReclaimed();\n if (r != null) {\n synchronized (LOCK) {\n while (r.size() > 0) {\n ByteBuffer ret = r.remove();\n if (r.size() == 0)\n maxItem = 0;\n currentSize -= ret.capacity();\n if (ret.capacity() >= size) {\n// System.out.println(\"using \" + ret.capacity());\n return ret;\n }\n// System.out.println(\"dumping \" + ret.capacity());\n }\n }\n }\n }\n\n// System.out.println(\"alloc for \" + size);\n ByteBuffer ret = ByteBuffer.allocate(Math.max(8192, size));\n return ret;\n }\n\n public static void obtainArray(ByteBuffer[] arr, int size) {\n PriorityQueue r = getReclaimed();\n int index = 0;\n int total = 0;\n\n if (r != null) {\n synchronized (LOCK) {\n while (r.size() > 0 && total < size && index < arr.length - 1) {\n ByteBuffer b = r.remove();\n currentSize -= b.capacity();\n int needed = Math.min(size - total, b.capacity());\n total += needed;\n arr[index++] = b;\n }\n }\n }\n\n if (total < size) {\n ByteBuffer b = ByteBuffer.allocate(Math.max(8192, size - total));\n arr[index++] = b;\n }\n\n for (int i = index; i < arr.length; i++) {\n arr[i] = EMPTY_BYTEBUFFER;\n }\n }\n\n public static ByteBuffer deepCopy(ByteBuffer copyOf) {\n if (copyOf == null)\n return null;\n return (ByteBuffer)obtain(copyOf.remaining()).put(copyOf.duplicate()).flip();\n }\n\n public static final ByteBuffer EMPTY_BYTEBUFFER = ByteBuffer.allocate(0);\n\n public static void writeOutputStream(OutputStream out, ByteBuffer b) throws IOException {\n byte[] bytes;\n int offset;\n int length;\n if (b.isDirect()) {\n bytes = new byte[b.remaining()];\n offset = 0;\n length = b.remaining();\n b.get(bytes);\n }\n else {\n bytes = b.array();\n offset = b.arrayOffset() + b.position();\n length = b.remaining();\n }\n out.write(bytes, offset, length);\n }\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/ChannelWrapper.java",
"content": "package com.koushikdutta.async;\n\nimport java.io.IOException;\nimport java.net.InetAddress;\nimport java.nio.ByteBuffer;\nimport java.nio.channels.ClosedChannelException;\nimport java.nio.channels.ReadableByteChannel;\nimport java.nio.channels.ScatteringByteChannel;\nimport java.nio.channels.SelectionKey;\nimport java.nio.channels.Selector;\nimport java.nio.channels.spi.AbstractSelectableChannel;\n\nabstract class ChannelWrapper implements ReadableByteChannel, ScatteringByteChannel {\n private AbstractSelectableChannel mChannel;\n ChannelWrapper(AbstractSelectableChannel channel) throws IOException {\n channel.configureBlocking(false);\n mChannel = channel;\n }\n\n public abstract void shutdownInput();\n public abstract void shutdownOutput();\n \n public abstract boolean isConnected();\n \n public abstract int write(ByteBuffer src) throws IOException;\n public abstract int write(ByteBuffer[] src) throws IOException;\n\n // register for default events appropriate for this channel\n public abstract SelectionKey register(Selector sel) throws ClosedChannelException;\n\n public SelectionKey register(Selector sel, int ops) throws ClosedChannelException {\n return mChannel.register(sel, ops);\n }\n\n public boolean isChunked() {\n return false;\n }\n \n @Override\n public boolean isOpen() {\n return mChannel.isOpen();\n }\n \n @Override\n public void close() throws IOException {\n mChannel.close();\n }\n \n public abstract int getLocalPort();\n public abstract InetAddress getLocalAddress();\n public abstract Object getSocket();\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/DataEmitter.java",
"content": "package com.koushikdutta.async;\n\nimport com.koushikdutta.async.callback.CompletedCallback;\nimport com.koushikdutta.async.callback.DataCallback;\n\npublic interface DataEmitter {\n void setDataCallback(DataCallback callback);\n DataCallback getDataCallback();\n boolean isChunked();\n void pause();\n void resume();\n void close();\n boolean isPaused();\n void setEndCallback(CompletedCallback callback);\n CompletedCallback getEndCallback();\n AsyncServer getServer();\n String charset();\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/DataEmitterBase.java",
"content": "package com.koushikdutta.async;\n\nimport com.koushikdutta.async.callback.CompletedCallback;\nimport com.koushikdutta.async.callback.DataCallback;\n\n/**\n * Created by koush on 5/27/13.\n */\npublic abstract class DataEmitterBase implements DataEmitter {\n private boolean ended;\n protected void report(Exception e) {\n if (ended)\n return;\n ended = true;\n if (getEndCallback() != null)\n getEndCallback().onCompleted(e);\n }\n\n @Override\n public final void setEndCallback(CompletedCallback callback) {\n endCallback = callback;\n }\n\n CompletedCallback endCallback;\n @Override\n public final CompletedCallback getEndCallback() {\n return endCallback;\n }\n\n\n DataCallback mDataCallback;\n @Override\n public void setDataCallback(DataCallback callback) {\n mDataCallback = callback;\n }\n\n @Override\n public DataCallback getDataCallback() {\n return mDataCallback;\n }\n\n @Override\n public String charset() {\n return null;\n }\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/DataEmitterReader.java",
"content": "package com.koushikdutta.async;\n\nimport com.koushikdutta.async.callback.DataCallback;\n\npublic class DataEmitterReader implements com.koushikdutta.async.callback.DataCallback {\n DataCallback mPendingRead;\n int mPendingReadLength;\n ByteBufferList mPendingData = new ByteBufferList();\n\n public void read(int count, DataCallback callback) {\n mPendingReadLength = count;\n mPendingRead = callback;\n mPendingData.recycle();\n }\n\n private boolean handlePendingData(DataEmitter emitter) {\n if (mPendingReadLength > mPendingData.remaining())\n return false;\n\n DataCallback pendingRead = mPendingRead;\n mPendingRead = null;\n pendingRead.onDataAvailable(emitter, mPendingData);\n\n return true;\n }\n\n public DataEmitterReader() {\n }\n @Override\n public void onDataAvailable(DataEmitter emitter, ByteBufferList bb) {\n // if we're registered for data, we must be waiting for a read\n do {\n int need = Math.min(bb.remaining(), mPendingReadLength - mPendingData.remaining());\n bb.get(mPendingData, need);\n bb.remaining();\n }\n while (handlePendingData(emitter) && mPendingRead != null);\n bb.remaining();\n }\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/DataSink.java",
"content": "package com.koushikdutta.async;\n\nimport com.koushikdutta.async.callback.CompletedCallback;\nimport com.koushikdutta.async.callback.WritableCallback;\n\npublic interface DataSink {\n public void write(ByteBufferList bb);\n public void setWriteableCallback(WritableCallback handler);\n public WritableCallback getWriteableCallback();\n \n public boolean isOpen();\n public void end();\n public void setClosedCallback(CompletedCallback handler);\n public CompletedCallback getClosedCallback();\n public AsyncServer getServer();\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/DataTrackingEmitter.java",
"content": "package com.koushikdutta.async;\n\n/**\n * Created by koush on 5/28/13.\n */\npublic interface DataTrackingEmitter extends DataEmitter {\n interface DataTracker {\n void onData(int totalBytesRead);\n }\n void setDataTracker(DataTracker tracker);\n DataTracker getDataTracker();\n int getBytesRead();\n void setDataEmitter(DataEmitter emitter);\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/DatagramChannelWrapper.java",
"content": "package com.koushikdutta.async;\n\nimport java.io.IOException;\nimport java.net.InetAddress;\nimport java.net.InetSocketAddress;\nimport java.nio.ByteBuffer;\nimport java.nio.channels.ClosedChannelException;\nimport java.nio.channels.DatagramChannel;\nimport java.nio.channels.SelectionKey;\nimport java.nio.channels.Selector;\n\nclass DatagramChannelWrapper extends ChannelWrapper {\n DatagramChannel mChannel;\n\n @Override\n public InetAddress getLocalAddress() {\n return mChannel.socket().getLocalAddress();\n }\n\n @Override\n public int getLocalPort() {\n return mChannel.socket().getLocalPort();\n }\n\n InetSocketAddress address;\n public InetSocketAddress getRemoteAddress() {\n return address;\n }\n \n public void disconnect() throws IOException {\n mChannel.disconnect();\n }\n \n DatagramChannelWrapper(DatagramChannel channel) throws IOException {\n super(channel);\n mChannel = channel;\n }\n @Override\n public int read(ByteBuffer buffer) throws IOException {\n if (!isConnected()) {\n int position = buffer.position();\n address = (InetSocketAddress)mChannel.receive(buffer);\n if (address == null)\n return -1;\n return buffer.position() - position;\n }\n address = null;\n return mChannel.read(buffer);\n }\n @Override\n public boolean isConnected() {\n return mChannel.isConnected();\n }\n @Override\n public int write(ByteBuffer src) throws IOException {\n return mChannel.write(src);\n }\n @Override\n public int write(ByteBuffer[] src) throws IOException {\n return (int)mChannel.write(src);\n }\n @Override\n public SelectionKey register(Selector sel, int ops) throws ClosedChannelException {\n return mChannel.register(sel, ops);\n }\n @Override\n public boolean isChunked() {\n return true;\n }\n @Override\n public SelectionKey register(Selector sel) throws ClosedChannelException {\n return register(sel, SelectionKey.OP_READ);\n }\n\n @Override\n public void shutdownOutput() {\n }\n\n @Override\n public void shutdownInput() {\n }\n\n @Override\n public long read(ByteBuffer[] byteBuffers) throws IOException {\n return mChannel.read(byteBuffers);\n }\n\n @Override\n public long read(ByteBuffer[] byteBuffers, int i, int i2) throws IOException {\n return mChannel.read(byteBuffers, i, i2);\n }\n\n @Override\n public Object getSocket() {\n return mChannel.socket();\n }\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/FileDataEmitter.java",
"content": "package com.koushikdutta.async;\n\nimport com.koushikdutta.async.callback.DataCallback;\nimport com.koushikdutta.async.util.StreamUtility;\n\nimport java.io.File;\nimport java.io.FileInputStream;\nimport java.nio.ByteBuffer;\nimport java.nio.channels.FileChannel;\n\n/**\n * Created by koush on 5/22/13.\n */\npublic class FileDataEmitter extends DataEmitterBase {\n AsyncServer server;\n File file;\n public FileDataEmitter(AsyncServer server, File file) {\n this.server = server;\n this.file = file;\n paused = !server.isAffinityThread();\n if (!paused)\n doResume();\n }\n\n DataCallback callback;\n @Override\n public void setDataCallback(DataCallback callback) {\n this.callback = callback;\n }\n\n @Override\n public DataCallback getDataCallback() {\n return callback;\n }\n\n @Override\n public boolean isChunked() {\n return false;\n }\n\n boolean paused;\n @Override\n public void pause() {\n paused = true;\n }\n\n @Override\n public void resume() {\n paused = false;\n doResume();\n }\n\n @Override\n protected void report(Exception e) {\n StreamUtility.closeQuietly(channel);\n super.report(e);\n }\n\n ByteBufferList pending = new ByteBufferList();\n FileChannel channel;\n Runnable pumper = new Runnable() {\n @Override\n public void run() {\n try {\n if (channel == null)\n channel = new FileInputStream(file).getChannel();\n if (!pending.isEmpty()) {\n Util.emitAllData(FileDataEmitter.this, pending);\n if (!pending.isEmpty())\n return;\n }\n ByteBuffer b;\n do {\n b = ByteBufferList.obtain(8192);\n if (-1 == channel.read(b)) {\n report(null);\n return;\n }\n b.flip();\n pending.add(b);\n Util.emitAllData(FileDataEmitter.this, pending);\n }\n while (pending.remaining() == 0 && !isPaused());\n }\n catch (Exception e) {\n report(e);\n }\n }\n };\n\n private void doResume() {\n server.post(pumper);\n }\n\n @Override\n public boolean isPaused() {\n return paused;\n }\n\n @Override\n public AsyncServer getServer() {\n return server;\n }\n\n @Override\n public void close() {\n try {\n channel.close();\n }\n catch (Exception e) {\n }\n }\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/FilteredDataEmitter.java",
"content": "package com.koushikdutta.async;\n\nimport com.koushikdutta.async.callback.CompletedCallback;\nimport com.koushikdutta.async.callback.DataCallback;\nimport com.koushikdutta.async.wrapper.DataEmitterWrapper;\n\npublic class FilteredDataEmitter extends DataEmitterBase implements DataEmitter, DataCallback, DataEmitterWrapper, DataTrackingEmitter {\n private DataEmitter mEmitter;\n @Override\n public DataEmitter getDataEmitter() {\n return mEmitter;\n }\n\n @Override\n public void setDataEmitter(DataEmitter emitter) {\n if (mEmitter != null) {\n mEmitter.setDataCallback(null);\n }\n mEmitter = emitter;\n mEmitter.setDataCallback(this);\n mEmitter.setEndCallback(new CompletedCallback() {\n @Override\n public void onCompleted(Exception ex) {\n report(ex);\n }\n });\n }\n\n @Override\n public int getBytesRead() {\n return totalRead;\n }\n\n @Override\n public DataTracker getDataTracker() {\n return tracker;\n }\n\n @Override\n public void setDataTracker(DataTracker tracker) {\n this.tracker = tracker;\n }\n\n private DataTracker tracker;\n private int totalRead;\n @Override\n public void onDataAvailable(DataEmitter emitter, ByteBufferList bb) {\n if (closed) {\n // this emitter was closed but for some reason data is still being spewed...\n // eat it, nom nom.\n bb.recycle();\n return;\n }\n if (bb != null)\n totalRead += bb.remaining();\n Util.emitAllData(this, bb);\n if (bb != null)\n totalRead -= bb.remaining();\n if (tracker != null && bb != null)\n tracker.onData(totalRead);\n // if there's data after the emitting, and it is paused... the underlying implementation\n // is obligated to cache the byte buffer list.\n }\n\n @Override\n public boolean isChunked() {\n return mEmitter.isChunked();\n }\n\n @Override\n public void pause() {\n mEmitter.pause();\n }\n\n @Override\n public void resume() {\n mEmitter.resume();\n }\n\n @Override\n public boolean isPaused() {\n return mEmitter.isPaused();\n }\n\n @Override\n public AsyncServer getServer() {\n return mEmitter.getServer();\n }\n\n boolean closed;\n @Override\n public void close() {\n closed = true;\n if (mEmitter != null)\n mEmitter.close();\n }\n\n @Override\n public String charset() {\n if (mEmitter == null)\n return null;\n return mEmitter.charset();\n }\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/FilteredDataSink.java",
"content": "package com.koushikdutta.async;\n\npublic class FilteredDataSink extends BufferedDataSink {\n public FilteredDataSink(DataSink sink) {\n super(sink);\n setMaxBuffer(0);\n }\n \n public ByteBufferList filter(ByteBufferList bb) {\n return bb;\n }\n\n @Override\n protected void onDataAccepted(ByteBufferList bb) {\n ByteBufferList filtered = filter(bb);\n // filtering may return the same byte buffer, so watch for that.\n if (filtered != bb) {\n bb.recycle();\n filtered.get(bb);\n }\n }\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/HostnameResolutionException.java",
"content": "package com.koushikdutta.async;\n\npublic class HostnameResolutionException extends Exception {\n public HostnameResolutionException(String message) {\n super(message);\n }\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/LineEmitter.java",
"content": "package com.koushikdutta.async;\n\nimport com.koushikdutta.async.callback.DataCallback;\n\nimport java.nio.ByteBuffer;\nimport java.nio.charset.Charset;\n\npublic class LineEmitter implements DataCallback {\n public interface StringCallback {\n void onStringAvailable(String s);\n }\n\n public LineEmitter() {\n this(null);\n }\n\n public LineEmitter(Charset charset) {\n this.charset = charset;\n }\n\n Charset charset;\n\n ByteBufferList data = new ByteBufferList();\n\n StringCallback mLineCallback;\n public void setLineCallback(StringCallback callback) {\n mLineCallback = callback;\n }\n\n public StringCallback getLineCallback() {\n return mLineCallback;\n }\n\n @Override\n public void onDataAvailable(DataEmitter emitter, ByteBufferList bb) {\n ByteBuffer buffer = ByteBuffer.allocate(bb.remaining());\n while (bb.remaining() > 0) {\n byte b = bb.get();\n if (b == '\\n') {\n buffer.flip();\n data.add(buffer);\n mLineCallback.onStringAvailable(data.readString(charset));\n data = new ByteBufferList();\n return;\n }\n else {\n buffer.put(b);\n }\n }\n buffer.flip();\n data.add(buffer);\n }\n}\n"
},
{
"path": "AndroidAsync/src/com/koushikdutta/async/PushParser.java",
"content": "package com.koushikdutta.async;\n\nimport android.util.Log;\nimport com.koushikdutta.async.callback.DataCallback;\n\nimport java.lang.reflect.Method;\nimport java.nio.ByteBuffer;\nimport java.nio.ByteOrder;\nimport java.util.ArrayList;\nimport java.util.Hashtable;\nimport java.util.LinkedList;\n\npublic class PushParser implements DataCallback {\n\n public interface ParseCallback {\n public void parsed(T data);\n }\n\n static abstract class Waiter {\n int length;\n public Waiter(int length) {\n this.length = length;\n }\n /**\n * Consumes received data, and/or returns next waiter to continue reading instead of this waiter.\n * @param bb received data, bb.remaining >= length\n * @return - a waiter that should continue reading right away, or null if this waiter is finished\n */\n public abstract Waiter onDataAvailable(DataEmitter emitter, ByteBufferList bb);\n }\n\n static class IntWaiter extends Waiter {\n ParseCallback callback;\n public IntWaiter(ParseCallback callback) {\n super(4);\n this.callback = callback;\n }\n\n @Override\n public Waiter onDataAvailable(DataEmitter emitter, ByteBufferList bb) {\n callback.parsed(bb.getInt());\n return null;\n }\n }\n\n static class ByteArrayWaiter extends Waiter {\n ParseCallback callback;\n public ByteArrayWaiter(int length, ParseCallback callback) {\n super(length);\n if (length <= 0)\n throw new IllegalArgumentException(\"length should be > 0\");\n this.callback = callback;\n }\n\n @Override\n public Waiter onDataAvailable(DataEmitter emitter, ByteBufferList bb) {\n byte[] bytes = new byte[length];\n bb.get(bytes);\n callback.parsed(bytes);\n return null;\n }\n }\n\n static class LenByteArrayWaiter extends Waiter {\n private final ParseCallback callback;\n\n public LenByteArrayWaiter(ParseCallback callback) {\n super(4);\n this.callback = callback;\n }\n\n @Override\n public Waiter onDataAvailable(DataEmitter emitter, ByteBufferList bb) {\n int length = bb.getInt();\n if (length == 0) {\n callback.parsed(new byte[0]);\n return null;\n }\n return new ByteArrayWaiter(length, callback);\n }\n }\n\n\n static class ByteBufferListWaiter extends Waiter {\n ParseCallback callback;\n public ByteBufferListWaiter(int length, ParseCallback callback) {\n super(length);\n if (length <= 0) throw new IllegalArgumentException(\"length should be > 0\");\n this.callback = callback;\n }\n\n @Override\n public Waiter onDataAvailable(DataEmitter emitter, ByteBufferList bb) {\n callback.parsed(bb.get(length));\n return null;\n }\n }\n\n static class LenByteBufferListWaiter extends Waiter {\n private final ParseCallback callback;\n\n public LenByteBufferListWaiter(ParseCallback callback) {\n super(4);\n this.callback = callback;\n }\n\n @Override\n public Waiter onDataAvailable(DataEmitter emitter, ByteBufferList bb) {\n int length = bb.getInt();\n return new ByteBufferListWaiter(length, callback);\n }\n }\n\n static class UntilWaiter extends Waiter {\n\n byte value;\n DataCallback callback;\n public UntilWaiter(byte value, DataCallback callback) {\n super(1);\n this.value = value;\n this.callback = callback;\n }\n\n @Override\n public Waiter onDataAvailable(DataEmitter emitter, ByteBufferList bb) {\n boolean found = true;\n ByteBufferList cb = new ByteBufferList();\n while (bb.size() > 0) {\n ByteBuffer b = bb.remove();\n b.mark();\n int index = 0;\n while (b.remaining() > 0 && !(found = (b.get() == value))) {\n index++;\n }\n b.reset();\n if (found) {\n bb.addFirst(b);\n bb.get(cb, index);\n // eat the one we're waiting on\n bb.get();\n break;\n } else {\n cb.add(b);\n }\n }\n\n callback.onDataAvailable(emitter, cb);\n\n if (found) {\n return null;\n } else {\n return this;\n }\n }\n }\n\n private class TapWaiter extends Waiter {\n private final TapCallback callback;\n\n public TapWaiter(TapCallback callback) {\n super(0);\n this.callback = callback;\n }\n\n @Override\n public Waiter onDataAvailable(DataEmitter emitter, ByteBufferList bb) {\n Method method = getTap(callback);\n method.setAccessible(true);\n try {\n method.invoke(callback, args.toArray());\n } catch (Exception e) {\n Log.e(\"PushParser\", \"Error while invoking tap callback\", e);\n }\n args.clear();\n return null;\n }\n }\n\n private Waiter noopArgWaiter = new Waiter(0) {\n @Override\n public Waiter onDataAvailable(DataEmitter emitter, ByteBufferList bb) {\n args.add(null);\n return null;\n }\n };\n\n private Waiter byteArgWaiter = new Waiter(1) {\n @Override\n public Waiter onDataAvailable(DataEmitter emitter, ByteBufferList bb) {\n args.add(bb.get());\n return null;\n }\n };\n\n private Waiter shortArgWaiter = new Waiter(2) {\n @Override\n public Waiter onDataAvailable(DataEmitter emitter, ByteBufferList bb) {\n args.add(bb.getShort());\n return null;\n }\n };\n\n private Waiter intArgWaiter = new Waiter(4) {\n @Override\n public Waiter onDataAvailable(DataEmitter emitter, ByteBufferList bb) {\n args.add(bb.getInt());\n return null;\n }\n };\n\n private Waiter longArgWaiter = new Waiter(8) {\n @Override\n public Waiter onDataAvailable(DataEmitter emitter, ByteBufferList bb) {\n args.add(bb.getLong());\n return null;\n }\n };\n\n private ParseCallback byteArrayArgCallback = new ParseCallback() {\n @Override\n public void parsed(byte[] data) {\n args.add(data);\n }\n };\n\n private ParseCallback byteBufferListArgCallback = new ParseCallback() {\n @Override\n public void parsed(ByteBufferList data) {\n args.add(data);\n }\n };\n\n private ParseCallback stringArgCallback = new ParseCallback() {\n @Override\n public void parsed(byte[] data) {\n args.add(new String(data));\n }\n };\n\n DataEmitter mEmitter;\n private LinkedList mWaiting = new LinkedList();\n private ArrayList