[
{
"path": ".gitignore",
"content": "build\n.gradle\n.idea\nlocal.properties\napp/app.iml\nplayerlib/playerlib.iml\nexoplayerlib/exoplayerlib.iml\nijkplayerlib/ijkplayerlib.iml\nmediaproxylib/mediaproxylib.iml\nmediaproxylib/build\nmediaproxylib/build/*\n/MediaSDK.iml"
},
{
"path": "LICENSE",
"content": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright 2014-2016 Alexey Danilov\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."
},
{
"path": "README.md",
"content": "# MediaSDK\n\nThe library is working for downloading video while playing the video, the video contains M3U8/MP4 \n\nDeveloper documentation is here, [Click it](./README_cn.md) \n\nYou can refer to the technical documentation：https://www.jianshu.com/p/27085da32a35 \n\nUse the library: \n```\nallprojects {\n repositories {\n ...\n maven { url 'https://jitpack.io' }\n }\n}\n\ndependencies {\n implementation 'com.github.JeffMony:MediaSDK:2.0.0'\n}\n```\n\n#### The Core functions of the project\n> * Cache management, LRU\n> * Video downloading management\n> * Local proxy management\n> * Display downloading speed\n> * Display the video cache's size\n> * Support the video's downloading while playing the video, M3U8/MP4 video\n\nThe project's architecture is as follows：\n\n\n\n### Developer documentation\n#### 1.Application->onCreate(...)\n```\nFile file = LocalProxyUtils.getVideoCacheDir(this);\nif (!file.exists()) {\n file.mkdir();\n}\nLocalProxyConfig config = new VideoDownloadManager.Build(this)\n .setCacheRoot(file)\n .setUrlRedirect(false)\n .setTimeOut(DownloadConstants.READ_TIMEOUT, DownloadConstants.CONN_TIMEOUT, DownloadConstants.SOCKET_TIMEOUT)\n .setConcurrentCount(DownloadConstants.CONCURRENT_COUNT)\n .setIgnoreAllCertErrors(true)\n .buildConfig();\nVideoDownloadManager.getInstance().initConfig(config);\n```\n1.setCacheRoot The cache path；\n2.setUrlRedirect Support request's redirect；\n3.setCacheSize Set cache size；\n4.setTimeOut Set request's timeout；\n5.setPort Set the local proxy server's port；\n6.setIgnoreAllCertErrors Support the certificate；\n#### 2.The local proxy server's switch\n```\nPlayerAttributes attributes = new PlayerAttributes();\nattributes.setUseLocalProxy(mUseLocalProxy);\n```\n#### 3.Set the listener\n```\nmPlayer.setOnLocalProxyCacheListener(mOnLocalProxyCacheListener);\nmPlayer.startLocalProxy(mUrl, null);\n\nprivate IPlayer.OnLocalProxyCacheListener mOnLocalProxyCacheListener = new IPlayer.OnLocalProxyCacheListener() {\n @Override\n public void onCacheReady(IPlayer mp, String proxyUrl) {\n LogUtils.w(\"onCacheReady proxyUrl = \" + proxyUrl);\n Uri uri = Uri.parse(proxyUrl);\n try {\n mPlayer.setDataSource(PlayerActivity.this, uri);\n } catch (IOException e) {\n e.printStackTrace();\n return;\n }\n mPlayer.setSurface(mSurface);\n mPlayer.setOnPreparedListener(mPreparedListener);\n mPlayer.setOnVideoSizeChangedListener(mVideoSizeChangeListener);\n mPlayer.prepareAsync();\n }\n\n @Override\n public void onCacheProgressChanged(IPlayer mp, int percent, long cachedSize) {\n LogUtils.w(\"onCacheProgressChanged percent = \" + percent);\n mPercent = percent;\n }\n\n @Override\n public void onCacheSpeedChanged(String url, float cacheSpeed) {\n if (mPlayer != null && mPlayer.get() != null) {\n mPlayer.get().notifyProxyCacheSpeed(cacheSpeed);\n }\n }\n\n @Override\n public void onCacheFinished(String url) {\n LogUtils.i(\"onCacheFinished url=\"+url + \", player=\"+this);\n mIsCompleteCached = true;\n }\n\n @Override\n public void onCacheForbidden(String url) {\n LogUtils.w(\"onCacheForbidden url=\"+url+\", player=\"+this);\n mUseLocalProxy = false;\n if (mPlayer != null && mPlayer.get() != null) {\n mPlayer.get().notifyProxyCacheForbidden(url);\n }\n }\n\n @Override\n public void onCacheFailed(String url, Exception e) {\n LogUtils.w(\"onCacheFailed , player=\"+this);\n pauseProxyCacheTask(PROXY_CACHE_EXCEPTION);\n }\n};\n```\n\ndemo： \n\n\n\n\n\n"
},
{
"path": "README_cn.md",
"content": "# MediaSDK\n\n关注一下分析文章：https://www.jianshu.com/p/27085da32a35\n\n```\nallprojects {\n repositories {\n ...\n maven { url 'https://jitpack.io' }\n }\n}\n\ndependencies {\n implementation 'com.github.JeffMony:MediaSDK:2.0.0'\n}\n```\n\n最近这个项目有新的维护计划：\n> * 1.本地代理的控制逻辑移到server端\n> * 2.增加mp4 moov端的识别规则\n> * 3.将本地代理库和播放器解耦\n\n### 版本LOG\n2.0.0\n> * 1.使用androidasync替换proxyserver\n> * 2.优化MediaSDK接口\n\nt1.5.0\n> * 1.视频下载队列，可以设置视频并发下载的个数\n> * 2.视频播放缓存和下载缓存的数据合并，但是逻辑分离\n\nt1.4.0\n> * 1.增加视频下载模块;\n> * 2.重构本地代理模块代码;\n> * 3.视频下载和本地代理模块代码复用;\n> * 4.还有一些bug待处理,很快更新\n> * 5.后续版本更新计划: 下载队列；初始化本地已下载的视频；下载和播放缓存隔离；\n\nt1.3.0\n> * 1.封装好边下边播模块\n> * 2.可以直接商用\n\nv1.1.0\n> * 1.解决https 证书出错的视频url请求，信任证书；\n> * 2.解决播放过程中息屏的问题，保持屏幕常亮；\n> * 3.增加 isPlaying 接口，表示当前是否正在播放视频；\n> * 4.解决Cleartext HTTP traffic to 127.0.0.1 not permitted 问题，Android P版本不允许未加密请求；\n\nv1.0.0\n> * 1.支持MediaPlayer/IjkPlayer/ExoPlayer 三种播放器播放视频；\n> * 2.支持M3U8/MP4视频的边下边播功能；\n> * 3.本地代理实现边下边播功能；\n> * 4.提供当前下载速度和下载进度的回调；\n\n\n#### 封装了一个播放器功能库\n> * 实现ijkplayer exoplayer mediaplayer 3种播放器类型；可以任意切换；\n> * ijkplayer 是从 k0.8.8分支上拉出来的；\n> * exoplayer 是 2.11.1版本\n#### 实现视频边下边播的功能\n> * 缓存管理\n> * 下载管理\n> * 本地代理管理模块(使用androidasync管理本地代理)\n> * 回调播放下载实时速度\n> * 显示缓存大小\n\n本项目的架构如下：\n\n从上面的架构可以看出来，本项目的重点在本地代理层，这是实现边下边播的核心逻辑；\n\n\n### 接入库须知\n#### 1.在Application->onCreate(...) 中初始化\n```\nFile file = LocalProxyUtils.getVideoCacheDir(this);\nif (!file.exists()) {\n file.mkdir();\n}\nLocalProxyConfig config = new VideoDownloadManager.Build(this)\n .setCacheRoot(file)\n .setUrlRedirect(false)\n .setTimeOut(DownloadConstants.READ_TIMEOUT, DownloadConstants.CONN_TIMEOUT, DownloadConstants.SOCKET_TIMEOUT)\n .setConcurrentCount(DownloadConstants.CONCURRENT_COUNT)\n .setIgnoreAllCertErrors(true)\n .buildConfig();\nVideoDownloadManager.getInstance().initConfig(config);\n```\n这儿可以设置一些属性：\n1.setCacheRoot 设置缓存的路径；\n2.setUrlRedirect 是否需要重定向请求；\n3.setCacheSize 设置缓存的大小限制；\n4.setTimeOut 设置连接和读超时时间；\n5.setPort 设置本地代理的端口；\n6.setIgnoreAllCertErrors 是否需要信任证书；\n#### 2.打开本地代理开关\n```\nPlayerAttributes attributes = new PlayerAttributes();\nattributes.setUseLocalProxy(mUseLocalProxy);\n```\n#### 3.设置本地代理模块监听\n```\nmPlayer.setOnLocalProxyCacheListener(mOnLocalProxyCacheListener);\nmPlayer.startLocalProxy(mUrl, null);\n\nprivate IPlayer.OnLocalProxyCacheListener mOnLocalProxyCacheListener = new IPlayer.OnLocalProxyCacheListener() {\n @Override\n public void onCacheReady(IPlayer mp, String proxyUrl) {\n LogUtils.w(\"onCacheReady proxyUrl = \" + proxyUrl);\n Uri uri = Uri.parse(proxyUrl);\n try {\n mPlayer.setDataSource(PlayerActivity.this, uri);\n } catch (IOException e) {\n e.printStackTrace();\n return;\n }\n mPlayer.setSurface(mSurface);\n mPlayer.setOnPreparedListener(mPreparedListener);\n mPlayer.setOnVideoSizeChangedListener(mVideoSizeChangeListener);\n mPlayer.prepareAsync();\n }\n\n @Override\n public void onCacheProgressChanged(IPlayer mp, int percent, long cachedSize) {\n LogUtils.w(\"onCacheProgressChanged percent = \" + percent);\n mPercent = percent;\n }\n\n @Override\n public void onCacheSpeedChanged(String url, float cacheSpeed) {\n if (mPlayer != null && mPlayer.get() != null) {\n mPlayer.get().notifyProxyCacheSpeed(cacheSpeed);\n }\n }\n\n @Override\n public void onCacheFinished(String url) {\n LogUtils.i(\"onCacheFinished url=\"+url + \", player=\"+this);\n mIsCompleteCached = true;\n }\n\n @Override\n public void onCacheForbidden(String url) {\n LogUtils.w(\"onCacheForbidden url=\"+url+\", player=\"+this);\n mUseLocalProxy = false;\n if (mPlayer != null && mPlayer.get() != null) {\n mPlayer.get().notifyProxyCacheForbidden(url);\n }\n }\n\n @Override\n public void onCacheFailed(String url, Exception e) {\n LogUtils.w(\"onCacheFailed , player=\"+this);\n pauseProxyCacheTask(PROXY_CACHE_EXCEPTION);\n }\n};\n```\n#### 4.本地代理的生命周期跟着播放器的生命周期一起\n#### 5.下载接入函数\n\n```\npublic interface IDownloadListener {\n\n void onDownloadPrepare(VideoTaskItem item);\n\n void onDownloadPending(VideoTaskItem item);\n\n void onDownloadStart(VideoTaskItem item);\n\n void onDownloadProxyReady(VideoTaskItem item);\n\n void onDownloadProgress(VideoTaskItem item);\n\n void onDownloadSpeed(VideoTaskItem item);\n\n void onDownloadPause(VideoTaskItem item);\n\n void onDownloadError(VideoTaskItem item);\n\n void onDownloadProxyForbidden(VideoTaskItem item);\n\n void onDownloadSuccess(VideoTaskItem item);\n}\n```\n\n\n### 功能概要\n#### 1.封装了一个player sdk层\n> * 1.1 接入Android 原生的 MediaPlayer 播放器\n> * 1.2 接入google的EXO player 播放器\n> * 1.3 接入开源的 ijk player 播放器\n#### 2.实现整视频的边下边播\n> * 2.1 实现整视频的分片下载\n> * 2.2 实现整视频的断点下载\n#### 3.实现HLS分片视频的边下边播\n> * 3.1 实现HLS视频源的解析工作\n> * 3.2 实现HLS的边下边播\n> * 3.3 实现HLS的断点下载功能\n#### 4.线程池控制下载功能\n#### 5.提供视频下载的额外功能\n> * 5.1 可以提供播放视频或者下载视频的实时网速\n> * 5.2 可以提供已缓存视频的大小\n\ndemo示意图： \n\n\n欢迎关注我的公众号JeffMony，我会持续为你带来音视频---算法---Android---python 方面的知识分享 \n\n\n如果你觉得这个库有用,请鼓励一下吧; \n\n"
},
{
"path": "androidasync/.gitignore",
"content": "/build\n"
},
{
"path": "androidasync/androidasync.iml",
"content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n generateDebugSources\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n"
},
{
"path": "androidasync/build.gradle",
"content": "apply plugin: 'com.android.library'\n\nandroid {\n compileSdkVersion 29\n buildToolsVersion \"29.0.3\"\n\n defaultConfig {\n minSdkVersion 19\n targetSdkVersion 29\n versionCode 1\n versionName \"1.0\"\n\n consumerProguardFiles 'consumer-rules.pro'\n }\n\n compileOptions {\n sourceCompatibility JavaVersion.VERSION_1_8\n targetCompatibility JavaVersion.VERSION_1_8\n }\n\n buildTypes {\n release {\n minifyEnabled false\n proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'\n }\n }\n\n}\n\ndependencies {\n implementation fileTree(dir: 'libs', include: ['*.jar'])\n compileOnly group: 'org.bouncycastle', name: 'bcprov-jdk15on', version: '1.60'\n compileOnly group: 'org.bouncycastle', name: 'bcpkix-jdk15on', version: '1.60'\n implementation 'androidx.appcompat:appcompat:1.1.0'\n}\n"
},
{
"path": "androidasync/consumer-rules.pro",
"content": ""
},
{
"path": "androidasync/proguard-rules.pro",
"content": "# Add project specific ProGuard rules here.\n# You can control the set of applied configuration files using the\n# proguardFiles setting in build.gradle.\n#\n# For more details, see\n# http://developer.android.com/guide/developing/tools/proguard.html\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# Uncomment this to preserve the line number information for\n# debugging stack traces.\n#-keepattributes SourceFile,LineNumberTable\n\n# If you keep the line number information, uncomment this to\n# hide the original source file name.\n#-renamesourcefileattribute SourceFile\n"
},
{
"path": "androidasync/src/main/AndroidManifest.xml",
"content": "\n"
},
{
"path": "androidasync/src/main/java/com/jeffmony/async/AsyncDatagramSocket.java",
"content": "package com.jeffmony.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/main/java/com/jeffmony/async/AsyncNetworkSocket.java",
"content": "package com.jeffmony.async;\n\nimport android.util.Log;\n\n\nimport com.jeffmony.async.callback.CompletedCallback;\nimport com.jeffmony.async.callback.DataCallback;\nimport com.jeffmony.async.callback.WritableCallback;\nimport com.jeffmony.async.util.Allocator;\n\nimport java.io.IOException;\nimport java.net.InetAddress;\nimport java.net.InetSocketAddress;\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// assert mWriteableHandler != null;\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 assert !mChannel.isChunked();\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 assert !mChannel.isChunked();\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/main/java/com/jeffmony/async/AsyncSSLException.java",
"content": "package com.jeffmony.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/main/java/com/jeffmony/async/AsyncSSLServerSocket.java",
"content": "package com.jeffmony.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/main/java/com/jeffmony/async/AsyncSSLSocket.java",
"content": "package com.jeffmony.async;\n\nimport java.security.cert.X509Certificate;\n\nimport javax.net.ssl.SSLEngine;\n\npublic interface AsyncSSLSocket extends AsyncSocket {\n X509Certificate[] getPeerCertificates();\n SSLEngine getSSLEngine();\n}\n"
},
{
"path": "androidasync/src/main/java/com/jeffmony/async/AsyncSSLSocketWrapper.java",
"content": "package com.jeffmony.async;\n\nimport android.content.Context;\nimport android.os.Build;\nimport android.util.Base64;\nimport android.util.Pair;\n\nimport com.jeffmony.async.callback.CompletedCallback;\nimport com.jeffmony.async.callback.ConnectCallback;\nimport com.jeffmony.async.callback.DataCallback;\nimport com.jeffmony.async.callback.ListenCallback;\nimport com.jeffmony.async.callback.WritableCallback;\nimport com.jeffmony.async.future.Cancellable;\nimport com.jeffmony.async.future.SimpleCancellable;\nimport com.jeffmony.async.http.SSLEngineSNIConfigurator;\nimport com.jeffmony.async.util.Allocator;\nimport com.jeffmony.async.util.StreamUtility;\nimport com.jeffmony.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.jcajce.JcaContentSignerBuilder;\n\nimport java.io.ByteArrayInputStream;\nimport java.io.File;\nimport java.math.BigInteger;\nimport java.net.InetAddress;\nimport java.nio.ByteBuffer;\nimport java.security.KeyFactory;\nimport java.security.KeyPair;\nimport java.security.KeyPairGenerator;\nimport java.security.KeyStore;\nimport java.security.PrivateKey;\nimport java.security.Provider;\nimport java.security.Security;\nimport java.security.cert.Certificate;\nimport java.security.cert.CertificateFactory;\nimport java.security.cert.X509Certificate;\nimport java.security.spec.PKCS8EncodedKeySpec;\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.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 assert !writeList.hasRemaining();\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/main/java/com/jeffmony/async/AsyncSemaphore.java",
"content": "package com.jeffmony.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/main/java/com/jeffmony/async/AsyncServer.java",
"content": "package com.jeffmony.async;\n\nimport android.os.Build;\nimport android.os.Handler;\nimport android.os.SystemClock;\nimport android.util.Log;\n\nimport com.jeffmony.async.callback.CompletedCallback;\nimport com.jeffmony.async.callback.ConnectCallback;\nimport com.jeffmony.async.callback.ListenCallback;\nimport com.jeffmony.async.callback.SocketCreateCallback;\nimport com.jeffmony.async.callback.ValueFunction;\nimport com.jeffmony.async.future.Cancellable;\nimport com.jeffmony.async.future.Future;\nimport com.jeffmony.async.future.FutureCallback;\nimport com.jeffmony.async.future.SimpleCancellable;\nimport com.jeffmony.async.future.SimpleFuture;\nimport com.jeffmony.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 assert !address.isUnresolved();\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(1, 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/main/java/com/jeffmony/async/AsyncServerSocket.java",
"content": "package com.jeffmony.async;\n\npublic interface AsyncServerSocket {\n void stop();\n int getLocalPort();\n}\n"
},
{
"path": "androidasync/src/main/java/com/jeffmony/async/AsyncSocket.java",
"content": "package com.jeffmony.async;\n\npublic interface AsyncSocket extends DataEmitter, DataSink {\n AsyncServer getServer();\n}\n"
},
{
"path": "androidasync/src/main/java/com/jeffmony/async/BufferedDataSink.java",
"content": "package com.jeffmony.async;\n\nimport com.jeffmony.async.callback.CompletedCallback;\nimport com.jeffmony.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 assert maxBuffer >= 0;\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/main/java/com/jeffmony/async/ByteBufferList.java",
"content": "package com.jeffmony.async;\n\nimport android.annotation.TargetApi;\nimport android.os.Build;\nimport android.os.Looper;\n\nimport com.jeffmony.async.util.ArrayDeque;\nimport com.jeffmony.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 assert b == removed;\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 assert subset.capacity() >= need;\n assert subset.position() == 0;\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 assert mBuffers.size() == 0;\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 assert !reclaimedContains(b);\n\n b.position(0);\n b.limit(b.capacity());\n currentSize += b.capacity();\n\n r.add(b);\n assert r.size() != 0 ^ currentSize == 0;\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 assert r.size() != 0 ^ currentSize == 0;\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 assert r.size() != 0 ^ currentSize == 0;\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/main/java/com/jeffmony/async/ChannelWrapper.java",
"content": "package com.jeffmony.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/main/java/com/jeffmony/async/DataEmitter.java",
"content": "package com.jeffmony.async;\n\nimport com.jeffmony.async.callback.CompletedCallback;\nimport com.jeffmony.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/main/java/com/jeffmony/async/DataEmitterBase.java",
"content": "package com.jeffmony.async;\n\nimport com.jeffmony.async.callback.CompletedCallback;\nimport com.jeffmony.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/main/java/com/jeffmony/async/DataEmitterReader.java",
"content": "package com.jeffmony.async;\n\nimport com.jeffmony.async.callback.DataCallback;\n\npublic class DataEmitterReader implements DataCallback {\n DataCallback mPendingRead;\n int mPendingReadLength;\n ByteBufferList mPendingData = new ByteBufferList();\n\n public void read(int count, DataCallback callback) {\n assert mPendingRead == null;\n mPendingReadLength = count;\n mPendingRead = callback;\n assert !mPendingData.hasRemaining();\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 assert !mPendingData.hasRemaining();\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 assert mPendingRead != null;\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/main/java/com/jeffmony/async/DataSink.java",
"content": "package com.jeffmony.async;\n\nimport com.jeffmony.async.callback.CompletedCallback;\nimport com.jeffmony.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/main/java/com/jeffmony/async/DataTrackingEmitter.java",
"content": "package com.jeffmony.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/main/java/com/jeffmony/async/DatagramChannelWrapper.java",
"content": "package com.jeffmony.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/main/java/com/jeffmony/async/FileDataEmitter.java",
"content": "package com.jeffmony.async;\n\nimport com.jeffmony.async.callback.DataCallback;\nimport com.jeffmony.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/main/java/com/jeffmony/async/FilteredDataEmitter.java",
"content": "package com.jeffmony.async;\n\nimport com.jeffmony.async.callback.CompletedCallback;\nimport com.jeffmony.async.callback.DataCallback;\nimport com.jeffmony.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/main/java/com/jeffmony/async/FilteredDataSink.java",
"content": "package com.jeffmony.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/main/java/com/jeffmony/async/HostnameResolutionException.java",
"content": "package com.jeffmony.async;\n\npublic class HostnameResolutionException extends Exception {\n public HostnameResolutionException(String message) {\n super(message);\n }\n}\n"
},
{
"path": "androidasync/src/main/java/com/jeffmony/async/LineEmitter.java",
"content": "package com.jeffmony.async;\n\nimport com.jeffmony.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 assert mLineCallback != null;\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/main/java/com/jeffmony/async/PushParser.java",
"content": "package com.jeffmony.async;\n\nimport android.util.Log;\n\nimport com.jeffmony.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