[ { "path": ".github/ISSUE_TEMPLATE.md", "content": "Please try to fill all questions below before submitting an issue.\n\n- Android studio version:\n- Android gradle plugin version:\n- Logger version:\n- Emulator/phone information:\n- If possible, please add how did you initialize Logger?\n- Is it flaky or does it happen all the time?\n\n" }, { "path": ".gitignore", "content": "local.properties\n\n# Generated files\nbuild/\n\n# Mac store\n.DS_Store\n\n# Gradle files\n.gradle/\n\n/captures\n\n# Log Files\n*.log\n\n# IDEA/Android Studio\n*.iml\n*.ipr\n*.iws\n**/.idea/shelf\n**/.idea/workspace.xml\n**/.idea/tasks.xml\n**/.idea/datasources.xml\n**/.idea/dataSources.ids\n**/.idea/gradle.xml\n**/.idea/misc.xml\n**/.idea/modules.xml\n**/.idea/libraries\n**/.idea/dictionaries\n**/.idea/runConfigurations.xml\n.idea/caches\n\n# layout inspector view captures\ncaptures\nsample/libs/\n" }, { "path": ".idea/codeStyles/Project.xml", "content": "\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": ".idea/codeStyles/codeStyleConfig.xml", "content": "\n \n \n" }, { "path": ".idea/encodings.xml", "content": "\n\n \n \n \n" }, { "path": ".idea/vcs.xml", "content": "\n\n \n \n \n" }, { "path": ".travis.yml", "content": "language: android\njdk: oraclejdk8\n\nandroid:\n components:\n - tools\n - platform-tools\n - build-tools-27.0.3\n - android-27\n\nbefore_install:\n - yes | sdkmanager \"platforms;android-27\"\n\nscript:\n- ./gradlew check\n" }, { "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 {yyyy} {name of copyright owner}\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n" }, { "path": "README.md", "content": "[![Android Arsenal](https://img.shields.io/badge/Android%20Arsenal-Logger-brightgreen.svg?style=flat)](http://android-arsenal.com/details/1/1658) [![](https://img.shields.io/badge/AndroidWeekly-%23147-blue.svg)](http://androidweekly.net/issues/issue-147)\n[![Join the chat at https://gitter.im/orhanobut/logger](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/orhanobut/logger?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [![Build Status](https://travis-ci.org/orhanobut/logger.svg?branch=master)](https://travis-ci.org/orhanobut/logger)\n\n\n\n### Logger\nSimple, pretty and powerful logger for android\n\n### Setup\nDownload\n```groovy\nimplementation 'com.orhanobut:logger:2.2.0'\n```\n\nInitialize\n```java\nLogger.addLogAdapter(new AndroidLogAdapter());\n```\nAnd use\n```java\nLogger.d(\"hello\");\n```\n\n### Output\n\n\n\n### Options\n```java\nLogger.d(\"debug\");\nLogger.e(\"error\");\nLogger.w(\"warning\");\nLogger.v(\"verbose\");\nLogger.i(\"information\");\nLogger.wtf(\"What a Terrible Failure\");\n```\n\nString format arguments are supported\n```java\nLogger.d(\"hello %s\", \"world\");\n```\n\nCollections are supported (only available for debug logs)\n```java\nLogger.d(MAP);\nLogger.d(SET);\nLogger.d(LIST);\nLogger.d(ARRAY);\n```\n\nJson and Xml support (output will be in debug level)\n```java\nLogger.json(JSON_CONTENT);\nLogger.xml(XML_CONTENT);\n```\n\n### Advanced\n```java\nFormatStrategy formatStrategy = PrettyFormatStrategy.newBuilder()\n .showThreadInfo(false) // (Optional) Whether to show thread info or not. Default true\n .methodCount(0) // (Optional) How many method line to show. Default 2\n .methodOffset(7) // (Optional) Hides internal method calls up to offset. Default 5\n .logStrategy(customLog) // (Optional) Changes the log strategy to print out. Default LogCat\n .tag(\"My custom tag\") // (Optional) Global tag for every log. Default PRETTY_LOGGER\n .build();\n\nLogger.addLogAdapter(new AndroidLogAdapter(formatStrategy));\n```\n\n### Loggable\nLog adapter checks whether the log should be printed or not by checking this function.\nIf you want to disable/hide logs for output, override `isLoggable` method. \n`true` will print the log message, `false` will ignore it.\n```java\nLogger.addLogAdapter(new AndroidLogAdapter() {\n @Override public boolean isLoggable(int priority, String tag) {\n return BuildConfig.DEBUG;\n }\n});\n```\n\n### Save logs to the file\n//TODO: More information will be added later\n```java\nLogger.addLogAdapter(new DiskLogAdapter());\n```\n\nAdd custom tag to Csv format strategy\n```java\nFormatStrategy formatStrategy = CsvFormatStrategy.newBuilder()\n .tag(\"custom\")\n .build();\n \nLogger.addLogAdapter(new DiskLogAdapter(formatStrategy));\n```\n\n### How it works\n\n\n\n### More\n- Use filter for a better result. PRETTY_LOGGER or your custom tag\n- Make sure that wrap option is disabled\n- You can also simplify output by changing settings.\n\n\n\n- Timber Integration\n```java\n// Set methodOffset to 5 in order to hide internal method calls\nTimber.plant(new Timber.DebugTree() {\n @Override protected void log(int priority, String tag, String message, Throwable t) {\n Logger.log(priority, tag, message, t);\n }\n});\n```\n\n### License\n
\nCopyright 2018 Orhan Obut\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n   http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n
\n" }, { "path": "build.gradle", "content": "buildscript {\n ext.kotlinVersion = '1.2.51'\n repositories {\n google()\n jcenter()\n }\n dependencies {\n classpath 'com.android.tools.build:gradle:3.2.0'\n classpath \"org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion\"\n }\n}\n\nallprojects {\n repositories {\n google()\n jcenter()\n }\n}\n\nsubprojects { project ->\n group = GROUP\n version = VERSION_NAME\n\n apply plugin: 'checkstyle'\n\n task checkstyle(type: Checkstyle) {\n configFile rootProject.file('checkstyle.xml')\n source 'src/main/java'\n ignoreFailures false\n showViolations true\n include '**/*.java'\n\n classpath = files()\n }\n\n afterEvaluate {\n if (project.tasks.findByName('check')) {\n check.dependsOn('checkstyle')\n }\n }\n}\n\ntask clean(type: Delete) {\n delete rootProject.buildDir\n}\n\next {\n minSdkVersion = 8\n targetSdkVersion = 28\n compileSdkVersion = 28\n buildToolsVersion = '28.0.2'\n}\n\next.deps = [\n junit : 'junit:junit:4.12',\n truth : 'com.google.truth:truth:0.28',\n robolectric : 'org.robolectric:robolectric:3.3',\n mockito : \"org.mockito:mockito-core:2.8.9\",\n json : \"org.json:json:20160810\",\n supportAnnotations: 'androidx.annotation:annotation:1.0.0',\n kotlin : \"org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlinVersion\"\n]" }, { "path": "checkstyle.xml", "content": "\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 \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": "gradle/maven_push.gradle", "content": "apply plugin: 'maven'\napply plugin: 'signing'\n\nversion = VERSION_NAME\ngroup = GROUP\n\ndef isReleaseBuild() {\n return version.contains(\"SNAPSHOT\") == false\n}\n\ndef sonatypeRepositoryUrl\nif (isReleaseBuild()) {\n println 'RELEASE BUILD'\n sonatypeRepositoryUrl = hasProperty('RELEASE_REPOSITORY_URL') ? RELEASE_REPOSITORY_URL\n : \"https://oss.sonatype.org/service/local/staging/deploy/maven2/\"\n} else {\n println 'DEBUG BUILD'\n sonatypeRepositoryUrl = hasProperty('SNAPSHOT_REPOSITORY_URL') ? SNAPSHOT_REPOSITORY_URL\n : \"https://oss.sonatype.org/content/repositories/snapshots/\"\n}\n\nafterEvaluate { project ->\n uploadArchives {\n repositories {\n mavenDeployer {\n beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }\n pom.artifactId = POM_ARTIFACT_ID\n repository(url: sonatypeRepositoryUrl) {\n try {\n authentication(userName: NEXUS_USERNAME, password: NEXUS_PASSWORD)\n } catch (Exception ignored) {\n println \"mavenUser or mavenPassword is missing\"\n }\n }\n pom.project {\n name POM_NAME\n packaging POM_PACKAGING\n description POM_DESCRIPTION\n url POM_URL\n scm {\n url POM_SCM_URL\n connection POM_SCM_CONNECTION\n developerConnection POM_SCM_DEV_CONNECTION\n }\n licenses {\n license {\n name POM_LICENCE_NAME\n url POM_LICENCE_URL\n distribution POM_LICENCE_DIST\n }\n }\n developers {\n developer {\n id POM_DEVELOPER_ID\n name POM_DEVELOPER_NAME\n }\n }\n }\n }\n }\n }\n signing {\n required { isReleaseBuild() && gradle.taskGraph.hasTask(\"uploadArchives\") }\n sign configurations.archives\n }\n task androidJavadocs(type: Javadoc) {\n source = android.sourceSets.main.java.sourceFiles\n }\n task androidJavadocsJar(type: Jar) {\n classifier = 'javadoc'\n from androidJavadocs.destinationDir\n }\n task androidSourcesJar(type: Jar) {\n classifier = 'sources'\n from android.sourceSets.main.java.sourceFiles\n }\n artifacts {\n archives androidSourcesJar\n archives androidJavadocsJar\n }\n}\n\n// build a jar with source files\ntask sourcesJar(type: Jar) {\n from android.sourceSets.main.java.srcDirs\n classifier = 'sources'\n}\n\ntask javadoc(type: Javadoc) {\n failOnError false\n source = android.sourceSets.main.java.sourceFiles\n classpath += project.files(android.getBootClasspath().join(File.pathSeparator))\n}\n\n// build a jar with javadoc\ntask javadocJar(type: Jar, dependsOn: javadoc) {\n classifier = 'javadoc'\n from javadoc.destinationDir\n}" }, { "path": "gradle/wrapper/gradle-wrapper.properties", "content": "distributionBase=GRADLE_USER_HOME\ndistributionPath=wrapper/dists\ndistributionUrl=https\\://services.gradle.org/distributions/gradle-4.6-all.zip\nzipStoreBase=GRADLE_USER_HOME\nzipStorePath=wrapper/dists\n" }, { "path": "gradle.properties", "content": "VERSION_NAME=2.2.0\nGROUP=com.orhanobut\n\nPOM_DESCRIPTION=Simple, Pretty and Advanced Logger\nPOM_URL=https://github.com/orhanobut/logger\nPOM_SCM_URL=https://github.com/orhanobut/logger\nPOM_SCM_CONNECTION=scm:git@https://github.com/orhanobut/logger.git\nPOM_SCM_DEV_CONNECTION=scm:git@https://github.com/orhanobut/logger.git\nPOM_LICENCE_NAME=The Apache Software License, Version 2.0\nPOM_LICENCE_URL=http://www.apache.org/licenses/LICENSE-2.0.txt\nPOM_LICENCE_DIST=repo\nPOM_DEVELOPER_ID=nr4bt\nPOM_DEVELOPER_NAME=Orhan Obut\nandroid.useAndroidX=true\nandroid.enableJetifier=true" }, { "path": "gradlew", "content": "#!/usr/bin/env sh\n\n##############################################################################\n##\n## Gradle start up script for UN*X\n##\n##############################################################################\n\n# Attempt to set APP_HOME\n# Resolve links: $0 may be a link\nPRG=\"$0\"\n# Need this for relative symlinks.\nwhile [ -h \"$PRG\" ] ; do\n ls=`ls -ld \"$PRG\"`\n link=`expr \"$ls\" : '.*-> \\(.*\\)$'`\n if expr \"$link\" : '/.*' > /dev/null; then\n PRG=\"$link\"\n else\n PRG=`dirname \"$PRG\"`\"/$link\"\n fi\ndone\nSAVED=\"`pwd`\"\ncd \"`dirname \\\"$PRG\\\"`/\" >/dev/null\nAPP_HOME=\"`pwd -P`\"\ncd \"$SAVED\" >/dev/null\n\nAPP_NAME=\"Gradle\"\nAPP_BASE_NAME=`basename \"$0\"`\n\n# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.\nDEFAULT_JVM_OPTS=\"\"\n\n# Use the maximum available, or set MAX_FD != -1 to use that value.\nMAX_FD=\"maximum\"\n\nwarn () {\n echo \"$*\"\n}\n\ndie () {\n echo\n echo \"$*\"\n echo\n exit 1\n}\n\n# OS specific support (must be 'true' or 'false').\ncygwin=false\nmsys=false\ndarwin=false\nnonstop=false\ncase \"`uname`\" in\n CYGWIN* )\n cygwin=true\n ;;\n Darwin* )\n darwin=true\n ;;\n MINGW* )\n msys=true\n ;;\n NONSTOP* )\n nonstop=true\n ;;\nesac\n\nCLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar\n\n# Determine the Java command to use to start the JVM.\nif [ -n \"$JAVA_HOME\" ] ; then\n if [ -x \"$JAVA_HOME/jre/sh/java\" ] ; then\n # IBM's JDK on AIX uses strange locations for the executables\n JAVACMD=\"$JAVA_HOME/jre/sh/java\"\n else\n JAVACMD=\"$JAVA_HOME/bin/java\"\n fi\n if [ ! -x \"$JAVACMD\" ] ; then\n die \"ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME\n\nPlease set the JAVA_HOME variable in your environment to match the\nlocation of your Java installation.\"\n fi\nelse\n JAVACMD=\"java\"\n which java >/dev/null 2>&1 || die \"ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.\n\nPlease set the JAVA_HOME variable in your environment to match the\nlocation of your Java installation.\"\nfi\n\n# Increase the maximum file descriptors if we can.\nif [ \"$cygwin\" = \"false\" -a \"$darwin\" = \"false\" -a \"$nonstop\" = \"false\" ] ; then\n MAX_FD_LIMIT=`ulimit -H -n`\n if [ $? -eq 0 ] ; then\n if [ \"$MAX_FD\" = \"maximum\" -o \"$MAX_FD\" = \"max\" ] ; then\n MAX_FD=\"$MAX_FD_LIMIT\"\n fi\n ulimit -n $MAX_FD\n if [ $? -ne 0 ] ; then\n warn \"Could not set maximum file descriptor limit: $MAX_FD\"\n fi\n else\n warn \"Could not query maximum file descriptor limit: $MAX_FD_LIMIT\"\n fi\nfi\n\n# For Darwin, add options to specify how the application appears in the dock\nif $darwin; then\n GRADLE_OPTS=\"$GRADLE_OPTS \\\"-Xdock:name=$APP_NAME\\\" \\\"-Xdock:icon=$APP_HOME/media/gradle.icns\\\"\"\nfi\n\n# For Cygwin, switch paths to Windows format before running java\nif $cygwin ; then\n APP_HOME=`cygpath --path --mixed \"$APP_HOME\"`\n CLASSPATH=`cygpath --path --mixed \"$CLASSPATH\"`\n JAVACMD=`cygpath --unix \"$JAVACMD\"`\n\n # We build the pattern for arguments to be converted via cygpath\n ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`\n SEP=\"\"\n for dir in $ROOTDIRSRAW ; do\n ROOTDIRS=\"$ROOTDIRS$SEP$dir\"\n SEP=\"|\"\n done\n OURCYGPATTERN=\"(^($ROOTDIRS))\"\n # Add a user-defined pattern to the cygpath arguments\n if [ \"$GRADLE_CYGPATTERN\" != \"\" ] ; then\n OURCYGPATTERN=\"$OURCYGPATTERN|($GRADLE_CYGPATTERN)\"\n fi\n # Now convert the arguments - kludge to limit ourselves to /bin/sh\n i=0\n for arg in \"$@\" ; do\n CHECK=`echo \"$arg\"|egrep -c \"$OURCYGPATTERN\" -`\n CHECK2=`echo \"$arg\"|egrep -c \"^-\"` ### Determine if an option\n\n if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition\n eval `echo args$i`=`cygpath --path --ignore --mixed \"$arg\"`\n else\n eval `echo args$i`=\"\\\"$arg\\\"\"\n fi\n i=$((i+1))\n done\n case $i in\n (0) set -- ;;\n (1) set -- \"$args0\" ;;\n (2) set -- \"$args0\" \"$args1\" ;;\n (3) set -- \"$args0\" \"$args1\" \"$args2\" ;;\n (4) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" ;;\n (5) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" ;;\n (6) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" ;;\n (7) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" ;;\n (8) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" \"$args7\" ;;\n (9) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" \"$args7\" \"$args8\" ;;\n esac\nfi\n\n# Escape application args\nsave () {\n for i do printf %s\\\\n \"$i\" | sed \"s/'/'\\\\\\\\''/g;1s/^/'/;\\$s/\\$/' \\\\\\\\/\" ; done\n echo \" \"\n}\nAPP_ARGS=$(save \"$@\")\n\n# Collect all arguments for the java command, following the shell quoting and substitution rules\neval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS \"\\\"-Dorg.gradle.appname=$APP_BASE_NAME\\\"\" -classpath \"\\\"$CLASSPATH\\\"\" org.gradle.wrapper.GradleWrapperMain \"$APP_ARGS\"\n\n# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong\nif [ \"$(uname)\" = \"Darwin\" ] && [ \"$HOME\" = \"$PWD\" ]; then\n cd \"$(dirname \"$0\")\"\nfi\n\nexec \"$JAVACMD\" \"$@\"\n" }, { "path": "gradlew.bat", "content": "@if \"%DEBUG%\" == \"\" @echo off\n@rem ##########################################################################\n@rem\n@rem Gradle startup script for Windows\n@rem\n@rem ##########################################################################\n\n@rem Set local scope for the variables with windows NT shell\nif \"%OS%\"==\"Windows_NT\" setlocal\n\nset DIRNAME=%~dp0\nif \"%DIRNAME%\" == \"\" set DIRNAME=.\nset APP_BASE_NAME=%~n0\nset APP_HOME=%DIRNAME%\n\n@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.\nset DEFAULT_JVM_OPTS=\n\n@rem Find java.exe\nif defined JAVA_HOME goto findJavaFromJavaHome\n\nset JAVA_EXE=java.exe\n%JAVA_EXE% -version >NUL 2>&1\nif \"%ERRORLEVEL%\" == \"0\" goto init\n\necho.\necho ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.\necho.\necho Please set the JAVA_HOME variable in your environment to match the\necho location of your Java installation.\n\ngoto fail\n\n:findJavaFromJavaHome\nset JAVA_HOME=%JAVA_HOME:\"=%\nset JAVA_EXE=%JAVA_HOME%/bin/java.exe\n\nif exist \"%JAVA_EXE%\" goto init\n\necho.\necho ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%\necho.\necho Please set the JAVA_HOME variable in your environment to match the\necho location of your Java installation.\n\ngoto fail\n\n:init\n@rem Get command-line arguments, handling Windows variants\n\nif not \"%OS%\" == \"Windows_NT\" goto win9xME_args\n\n:win9xME_args\n@rem Slurp the command line arguments.\nset CMD_LINE_ARGS=\nset _SKIP=2\n\n:win9xME_args_slurp\nif \"x%~1\" == \"x\" goto execute\n\nset CMD_LINE_ARGS=%*\n\n:execute\n@rem Setup the command line\n\nset CLASSPATH=%APP_HOME%\\gradle\\wrapper\\gradle-wrapper.jar\n\n@rem Execute Gradle\n\"%JAVA_EXE%\" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% \"-Dorg.gradle.appname=%APP_BASE_NAME%\" -classpath \"%CLASSPATH%\" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%\n\n:end\n@rem End local scope for the variables with windows NT shell\nif \"%ERRORLEVEL%\"==\"0\" goto mainEnd\n\n:fail\nrem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of\nrem the _cmd.exe /c_ return code!\nif not \"\" == \"%GRADLE_EXIT_CONSOLE%\" exit 1\nexit /b 1\n\n:mainEnd\nif \"%OS%\"==\"Windows_NT\" endlocal\n\n:omega\n" }, { "path": "logger/build.gradle", "content": "apply plugin: 'com.android.library'\napply plugin: 'kotlin-android'\n\nandroid {\n compileSdkVersion rootProject.ext.compileSdkVersion\n buildToolsVersion rootProject.ext.buildToolsVersion\n\n defaultConfig {\n minSdkVersion rootProject.ext.minSdkVersion\n }\n\n lintOptions {\n textReport true\n textOutput 'stdout'\n }\n\n testOptions {\n unitTests.returnDefaultValues = true\n }\n}\n\ndependencies {\n implementation deps.supportAnnotations\n\n testImplementation deps.junit\n testImplementation deps.truth\n testImplementation deps.robolectric\n testImplementation deps.mockito\n testImplementation deps.json\n testImplementation deps.kotlin\n}\n\napply from: rootProject.file('gradle/maven_push.gradle')\n" }, { "path": "logger/gradle.properties", "content": "POM_NAME=Logger\nPOM_ARTIFACT_ID=logger\nPOM_PACKAGING=aar" }, { "path": "logger/src/main/AndroidManifest.xml", "content": "" }, { "path": "logger/src/main/java/com/orhanobut/logger/AndroidLogAdapter.java", "content": "package com.orhanobut.logger;\n\nimport androidx.annotation.NonNull;\nimport androidx.annotation.Nullable;\n\nimport static com.orhanobut.logger.Utils.checkNotNull;\n\n/**\n * Android terminal log output implementation for {@link LogAdapter}.\n *\n * Prints output to LogCat with pretty borders.\n *\n * 
\n *  ┌──────────────────────────\n *  │ Method stack history\n *  ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄\n *  │ Log message\n *  └──────────────────────────\n *
\n */\npublic class AndroidLogAdapter implements LogAdapter {\n\n @NonNull private final FormatStrategy formatStrategy;\n\n public AndroidLogAdapter() {\n this.formatStrategy = PrettyFormatStrategy.newBuilder().build();\n }\n\n public AndroidLogAdapter(@NonNull FormatStrategy formatStrategy) {\n this.formatStrategy = checkNotNull(formatStrategy);\n }\n\n @Override public boolean isLoggable(int priority, @Nullable String tag) {\n return true;\n }\n\n @Override public void log(int priority, @Nullable String tag, @NonNull String message) {\n formatStrategy.log(priority, tag, message);\n }\n\n}\n" }, { "path": "logger/src/main/java/com/orhanobut/logger/CsvFormatStrategy.java", "content": "package com.orhanobut.logger;\n\nimport android.os.Environment;\nimport android.os.Handler;\nimport android.os.HandlerThread;\nimport androidx.annotation.NonNull;\nimport androidx.annotation.Nullable;\n\nimport java.io.File;\nimport java.text.SimpleDateFormat;\nimport java.util.Date;\nimport java.util.Locale;\n\nimport static com.orhanobut.logger.Utils.checkNotNull;\n\n/**\n * CSV formatted file logging for Android.\n * Writes to CSV the following data:\n * epoch timestamp, ISO8601 timestamp (human-readable), log level, tag, log message.\n */\npublic class CsvFormatStrategy implements FormatStrategy {\n\n private static final String NEW_LINE = System.getProperty(\"line.separator\");\n private static final String NEW_LINE_REPLACEMENT = \"
\";\n private static final String SEPARATOR = \",\";\n\n @NonNull private final Date date;\n @NonNull private final SimpleDateFormat dateFormat;\n @NonNull private final LogStrategy logStrategy;\n @Nullable private final String tag;\n\n private CsvFormatStrategy(@NonNull Builder builder) {\n checkNotNull(builder);\n\n date = builder.date;\n dateFormat = builder.dateFormat;\n logStrategy = builder.logStrategy;\n tag = builder.tag;\n }\n\n @NonNull public static Builder newBuilder() {\n return new Builder();\n }\n\n @Override public void log(int priority, @Nullable String onceOnlyTag, @NonNull String message) {\n checkNotNull(message);\n\n String tag = formatTag(onceOnlyTag);\n\n date.setTime(System.currentTimeMillis());\n\n StringBuilder builder = new StringBuilder();\n\n // machine-readable date/time\n builder.append(Long.toString(date.getTime()));\n\n // human-readable date/time\n builder.append(SEPARATOR);\n builder.append(dateFormat.format(date));\n\n // level\n builder.append(SEPARATOR);\n builder.append(Utils.logLevel(priority));\n\n // tag\n builder.append(SEPARATOR);\n builder.append(tag);\n\n // message\n if (message.contains(NEW_LINE)) {\n // a new line would break the CSV format, so we replace it here\n message = message.replaceAll(NEW_LINE, NEW_LINE_REPLACEMENT);\n }\n builder.append(SEPARATOR);\n builder.append(message);\n\n // new line\n builder.append(NEW_LINE);\n\n logStrategy.log(priority, tag, builder.toString());\n }\n\n @Nullable private String formatTag(@Nullable String tag) {\n if (!Utils.isEmpty(tag) && !Utils.equals(this.tag, tag)) {\n return this.tag + \"-\" + tag;\n }\n return this.tag;\n }\n\n public static final class Builder {\n private static final int MAX_BYTES = 500 * 1024; // 500K averages to a 4000 lines per file\n\n Date date;\n SimpleDateFormat dateFormat;\n LogStrategy logStrategy;\n String tag = \"PRETTY_LOGGER\";\n\n private Builder() {\n }\n\n @NonNull public Builder date(@Nullable Date val) {\n date = val;\n return this;\n }\n\n @NonNull public Builder dateFormat(@Nullable SimpleDateFormat val) {\n dateFormat = val;\n return this;\n }\n\n @NonNull public Builder logStrategy(@Nullable LogStrategy val) {\n logStrategy = val;\n return this;\n }\n\n @NonNull public Builder tag(@Nullable String tag) {\n this.tag = tag;\n return this;\n }\n\n @NonNull public CsvFormatStrategy build() {\n if (date == null) {\n date = new Date();\n }\n if (dateFormat == null) {\n dateFormat = new SimpleDateFormat(\"yyyy.MM.dd HH:mm:ss.SSS\", Locale.UK);\n }\n if (logStrategy == null) {\n String diskPath = Environment.getExternalStorageDirectory().getAbsolutePath();\n String folder = diskPath + File.separatorChar + \"logger\";\n\n HandlerThread ht = new HandlerThread(\"AndroidFileLogger.\" + folder);\n ht.start();\n Handler handler = new DiskLogStrategy.WriteHandler(ht.getLooper(), folder, MAX_BYTES);\n logStrategy = new DiskLogStrategy(handler);\n }\n return new CsvFormatStrategy(this);\n }\n }\n}\n" }, { "path": "logger/src/main/java/com/orhanobut/logger/DiskLogAdapter.java", "content": "package com.orhanobut.logger;\n\nimport androidx.annotation.NonNull;\nimport androidx.annotation.Nullable;\n\nimport static com.orhanobut.logger.Utils.checkNotNull;\n\n/**\n * This is used to saves log messages to the disk.\n * By default it uses {@link CsvFormatStrategy} to translates text message into CSV format.\n */\npublic class DiskLogAdapter implements LogAdapter {\n\n @NonNull private final FormatStrategy formatStrategy;\n\n public DiskLogAdapter() {\n formatStrategy = CsvFormatStrategy.newBuilder().build();\n }\n\n public DiskLogAdapter(@NonNull FormatStrategy formatStrategy) {\n this.formatStrategy = checkNotNull(formatStrategy);\n }\n\n @Override public boolean isLoggable(int priority, @Nullable String tag) {\n return true;\n }\n\n @Override public void log(int priority, @Nullable String tag, @NonNull String message) {\n formatStrategy.log(priority, tag, message);\n }\n}\n" }, { "path": "logger/src/main/java/com/orhanobut/logger/DiskLogStrategy.java", "content": "package com.orhanobut.logger;\n\nimport android.os.Handler;\nimport android.os.Looper;\nimport android.os.Message;\nimport androidx.annotation.NonNull;\nimport androidx.annotation.Nullable;\n\nimport java.io.File;\nimport java.io.FileWriter;\nimport java.io.IOException;\n\nimport static com.orhanobut.logger.Utils.checkNotNull;\n\n/**\n * Abstract class that takes care of background threading the file log operation on Android.\n * implementing classes are free to directly perform I/O operations there.\n *\n * Writes all logs to the disk with CSV format.\n */\npublic class DiskLogStrategy implements LogStrategy {\n\n @NonNull private final Handler handler;\n\n public DiskLogStrategy(@NonNull Handler handler) {\n this.handler = checkNotNull(handler);\n }\n\n @Override public void log(int level, @Nullable String tag, @NonNull String message) {\n checkNotNull(message);\n\n // do nothing on the calling thread, simply pass the tag/msg to the background thread\n handler.sendMessage(handler.obtainMessage(level, message));\n }\n\n static class WriteHandler extends Handler {\n\n @NonNull private final String folder;\n private final int maxFileSize;\n\n WriteHandler(@NonNull Looper looper, @NonNull String folder, int maxFileSize) {\n super(checkNotNull(looper));\n this.folder = checkNotNull(folder);\n this.maxFileSize = maxFileSize;\n }\n\n @SuppressWarnings(\"checkstyle:emptyblock\")\n @Override public void handleMessage(@NonNull Message msg) {\n String content = (String) msg.obj;\n\n FileWriter fileWriter = null;\n File logFile = getLogFile(folder, \"logs\");\n\n try {\n fileWriter = new FileWriter(logFile, true);\n\n writeLog(fileWriter, content);\n\n fileWriter.flush();\n fileWriter.close();\n } catch (IOException e) {\n if (fileWriter != null) {\n try {\n fileWriter.flush();\n fileWriter.close();\n } catch (IOException e1) { /* fail silently */ }\n }\n }\n }\n\n /**\n * This is always called on a single background thread.\n * Implementing classes must ONLY write to the fileWriter and nothing more.\n * The abstract class takes care of everything else including close the stream and catching IOException\n *\n * @param fileWriter an instance of FileWriter already initialised to the correct file\n */\n private void writeLog(@NonNull FileWriter fileWriter, @NonNull String content) throws IOException {\n checkNotNull(fileWriter);\n checkNotNull(content);\n\n fileWriter.append(content);\n }\n\n private File getLogFile(@NonNull String folderName, @NonNull String fileName) {\n checkNotNull(folderName);\n checkNotNull(fileName);\n\n File folder = new File(folderName);\n if (!folder.exists()) {\n //TODO: What if folder is not created, what happens then?\n folder.mkdirs();\n }\n\n int newFileCount = 0;\n File newFile;\n File existingFile = null;\n\n newFile = new File(folder, String.format(\"%s_%s.csv\", fileName, newFileCount));\n while (newFile.exists()) {\n existingFile = newFile;\n newFileCount++;\n newFile = new File(folder, String.format(\"%s_%s.csv\", fileName, newFileCount));\n }\n\n if (existingFile != null) {\n if (existingFile.length() >= maxFileSize) {\n return newFile;\n }\n return existingFile;\n }\n\n return newFile;\n }\n }\n}\n" }, { "path": "logger/src/main/java/com/orhanobut/logger/FormatStrategy.java", "content": "package com.orhanobut.logger;\n\nimport androidx.annotation.NonNull;\nimport androidx.annotation.Nullable;\n\n/**\n * Used to determine how messages should be printed or saved.\n *\n * @see PrettyFormatStrategy\n * @see CsvFormatStrategy\n */\npublic interface FormatStrategy {\n\n void log(int priority, @Nullable String tag, @NonNull String message);\n}\n" }, { "path": "logger/src/main/java/com/orhanobut/logger/LogAdapter.java", "content": "package com.orhanobut.logger;\n\nimport androidx.annotation.NonNull;\nimport androidx.annotation.Nullable;\n\n/**\n * Provides a common interface to emits logs through. This is a required contract for Logger.\n *\n * @see AndroidLogAdapter\n * @see DiskLogAdapter\n */\npublic interface LogAdapter {\n\n /**\n * Used to determine whether log should be printed out or not.\n *\n * @param priority is the log level e.g. DEBUG, WARNING\n * @param tag is the given tag for the log message\n *\n * @return is used to determine if log should printed.\n * If it is true, it will be printed, otherwise it'll be ignored.\n */\n boolean isLoggable(int priority, @Nullable String tag);\n\n /**\n * Each log will use this pipeline\n *\n * @param priority is the log level e.g. DEBUG, WARNING\n * @param tag is the given tag for the log message.\n * @param message is the given message for the log message.\n */\n void log(int priority, @Nullable String tag, @NonNull String message);\n}" }, { "path": "logger/src/main/java/com/orhanobut/logger/LogStrategy.java", "content": "package com.orhanobut.logger;\n\nimport androidx.annotation.NonNull;\nimport androidx.annotation.Nullable;\n\n/**\n * Determines destination target for the logs such as Disk, Logcat etc.\n *\n * @see LogcatLogStrategy\n * @see DiskLogStrategy\n */\npublic interface LogStrategy {\n\n /**\n * This is invoked by Logger each time a log message is processed.\n * Interpret this method as last destination of the log in whole pipeline.\n *\n * @param priority is the log level e.g. DEBUG, WARNING\n * @param tag is the given tag for the log message.\n * @param message is the given message for the log message.\n */\n void log(int priority, @Nullable String tag, @NonNull String message);\n}\n" }, { "path": "logger/src/main/java/com/orhanobut/logger/LogcatLogStrategy.java", "content": "package com.orhanobut.logger;\n\nimport androidx.annotation.NonNull;\nimport androidx.annotation.Nullable;\nimport android.util.Log;\n\nimport static com.orhanobut.logger.Utils.checkNotNull;\n\n/**\n * LogCat implementation for {@link LogStrategy}\n *\n * This simply prints out all logs to Logcat by using standard {@link Log} class.\n */\npublic class LogcatLogStrategy implements LogStrategy {\n\n static final String DEFAULT_TAG = \"NO_TAG\";\n\n @Override public void log(int priority, @Nullable String tag, @NonNull String message) {\n checkNotNull(message);\n\n if (tag == null) {\n tag = DEFAULT_TAG;\n }\n\n Log.println(priority, tag, message);\n }\n}\n" }, { "path": "logger/src/main/java/com/orhanobut/logger/Logger.java", "content": "package com.orhanobut.logger;\n\nimport androidx.annotation.NonNull;\nimport androidx.annotation.Nullable;\n\nimport static com.orhanobut.logger.Utils.checkNotNull;\n\n/**\n * 
\n *  ┌────────────────────────────────────────────\n *  │ LOGGER\n *  ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄\n *  │ Standard logging mechanism\n *  ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄\n *  │ But more pretty, simple and powerful\n *  └────────────────────────────────────────────\n *
\n *\n *

How to use it

\n * Initialize it first\n * 
\n *   Logger.addLogAdapter(new AndroidLogAdapter());\n *
\n *\n * And use the appropriate static Logger methods.\n *\n * 
\n *   Logger.d(\"debug\");\n *   Logger.e(\"error\");\n *   Logger.w(\"warning\");\n *   Logger.v(\"verbose\");\n *   Logger.i(\"information\");\n *   Logger.wtf(\"What a Terrible Failure\");\n *
\n *\n *

String format arguments are supported

\n * 
\n *   Logger.d(\"hello %s\", \"world\");\n *
\n *\n *

Collections are support ed(only available for debug logs)

\n * 
\n *   Logger.d(MAP);\n *   Logger.d(SET);\n *   Logger.d(LIST);\n *   Logger.d(ARRAY);\n *
\n *\n *

Json and Xml support (output will be in debug level)

\n * 
\n *   Logger.json(JSON_CONTENT);\n *   Logger.xml(XML_CONTENT);\n *
\n *\n *

Customize Logger

\n * Based on your needs, you can change the following settings:\n *
    \n *
  • Different {@link LogAdapter}
    • \n *
  • Different {@link FormatStrategy}
    • \n *
  • Different {@link LogStrategy}
    • \n *
\n *\n * @see LogAdapter\n * @see FormatStrategy\n * @see LogStrategy\n */\npublic final class Logger {\n\n public static final int VERBOSE = 2;\n public static final int DEBUG = 3;\n public static final int INFO = 4;\n public static final int WARN = 5;\n public static final int ERROR = 6;\n public static final int ASSERT = 7;\n\n @NonNull private static Printer printer = new LoggerPrinter();\n\n private Logger() {\n //no instance\n }\n\n public static void printer(@NonNull Printer printer) {\n Logger.printer = checkNotNull(printer);\n }\n\n public static void addLogAdapter(@NonNull LogAdapter adapter) {\n printer.addAdapter(checkNotNull(adapter));\n }\n\n public static void clearLogAdapters() {\n printer.clearLogAdapters();\n }\n\n /**\n * Given tag will be used as tag only once for this method call regardless of the tag that's been\n * set during initialization. After this invocation, the general tag that's been set will\n * be used for the subsequent log calls\n */\n public static Printer t(@Nullable String tag) {\n return printer.t(tag);\n }\n\n /**\n * General log function that accepts all configurations as parameter\n */\n public static void log(int priority, @Nullable String tag, @Nullable String message, @Nullable Throwable throwable) {\n printer.log(priority, tag, message, throwable);\n }\n\n public static void d(@NonNull String message, @Nullable Object... args) {\n printer.d(message, args);\n }\n\n public static void d(@Nullable Object object) {\n printer.d(object);\n }\n\n public static void e(@NonNull String message, @Nullable Object... args) {\n printer.e(null, message, args);\n }\n\n public static void e(@Nullable Throwable throwable, @NonNull String message, @Nullable Object... args) {\n printer.e(throwable, message, args);\n }\n\n public static void i(@NonNull String message, @Nullable Object... args) {\n printer.i(message, args);\n }\n\n public static void v(@NonNull String message, @Nullable Object... args) {\n printer.v(message, args);\n }\n\n public static void w(@NonNull String message, @Nullable Object... args) {\n printer.w(message, args);\n }\n\n /**\n * Tip: Use this for exceptional situations to log\n * ie: Unexpected errors etc\n */\n public static void wtf(@NonNull String message, @Nullable Object... args) {\n printer.wtf(message, args);\n }\n\n /**\n * Formats the given json content and print it\n */\n public static void json(@Nullable String json) {\n printer.json(json);\n }\n\n /**\n * Formats the given xml content and print it\n */\n public static void xml(@Nullable String xml) {\n printer.xml(xml);\n }\n\n}\n" }, { "path": "logger/src/main/java/com/orhanobut/logger/LoggerPrinter.java", "content": "package com.orhanobut.logger;\n\nimport androidx.annotation.NonNull;\nimport androidx.annotation.Nullable;\n\nimport org.json.JSONArray;\nimport org.json.JSONException;\nimport org.json.JSONObject;\n\nimport java.io.StringReader;\nimport java.io.StringWriter;\nimport java.util.ArrayList;\nimport java.util.List;\n\nimport javax.xml.transform.OutputKeys;\nimport javax.xml.transform.Source;\nimport javax.xml.transform.Transformer;\nimport javax.xml.transform.TransformerException;\nimport javax.xml.transform.TransformerFactory;\nimport javax.xml.transform.stream.StreamResult;\nimport javax.xml.transform.stream.StreamSource;\n\nimport static com.orhanobut.logger.Logger.ASSERT;\nimport static com.orhanobut.logger.Logger.DEBUG;\nimport static com.orhanobut.logger.Logger.ERROR;\nimport static com.orhanobut.logger.Logger.INFO;\nimport static com.orhanobut.logger.Logger.VERBOSE;\nimport static com.orhanobut.logger.Logger.WARN;\nimport static com.orhanobut.logger.Utils.checkNotNull;\n\nclass LoggerPrinter implements Printer {\n\n /**\n * It is used for json pretty print\n */\n private static final int JSON_INDENT = 2;\n\n /**\n * Provides one-time used tag for the log message\n */\n private final ThreadLocal localTag = new ThreadLocal<>();\n\n private final List logAdapters = new ArrayList<>();\n\n @Override public Printer t(String tag) {\n if (tag != null) {\n localTag.set(tag);\n }\n return this;\n }\n\n @Override public void d(@NonNull String message, @Nullable Object... args) {\n log(DEBUG, null, message, args);\n }\n\n @Override public void d(@Nullable Object object) {\n log(DEBUG, null, Utils.toString(object));\n }\n\n @Override public void e(@NonNull String message, @Nullable Object... args) {\n e(null, message, args);\n }\n\n @Override public void e(@Nullable Throwable throwable, @NonNull String message, @Nullable Object... args) {\n log(ERROR, throwable, message, args);\n }\n\n @Override public void w(@NonNull String message, @Nullable Object... args) {\n log(WARN, null, message, args);\n }\n\n @Override public void i(@NonNull String message, @Nullable Object... args) {\n log(INFO, null, message, args);\n }\n\n @Override public void v(@NonNull String message, @Nullable Object... args) {\n log(VERBOSE, null, message, args);\n }\n\n @Override public void wtf(@NonNull String message, @Nullable Object... args) {\n log(ASSERT, null, message, args);\n }\n\n @Override public void json(@Nullable String json) {\n if (Utils.isEmpty(json)) {\n d(\"Empty/Null json content\");\n return;\n }\n try {\n json = json.trim();\n if (json.startsWith(\"{\")) {\n JSONObject jsonObject = new JSONObject(json);\n String message = jsonObject.toString(JSON_INDENT);\n d(message);\n return;\n }\n if (json.startsWith(\"[\")) {\n JSONArray jsonArray = new JSONArray(json);\n String message = jsonArray.toString(JSON_INDENT);\n d(message);\n return;\n }\n e(\"Invalid Json\");\n } catch (JSONException e) {\n e(\"Invalid Json\");\n }\n }\n\n @Override public void xml(@Nullable String xml) {\n if (Utils.isEmpty(xml)) {\n d(\"Empty/Null xml content\");\n return;\n }\n try {\n Source xmlInput = new StreamSource(new StringReader(xml));\n StreamResult xmlOutput = new StreamResult(new StringWriter());\n Transformer transformer = TransformerFactory.newInstance().newTransformer();\n transformer.setOutputProperty(OutputKeys.INDENT, \"yes\");\n transformer.setOutputProperty(\"{http://xml.apache.org/xslt}indent-amount\", \"2\");\n transformer.transform(xmlInput, xmlOutput);\n d(xmlOutput.getWriter().toString().replaceFirst(\">\", \">\\n\"));\n } catch (TransformerException e) {\n e(\"Invalid xml\");\n }\n }\n\n @Override public synchronized void log(int priority,\n @Nullable String tag,\n @Nullable String message,\n @Nullable Throwable throwable) {\n if (throwable != null && message != null) {\n message += \" : \" + Utils.getStackTraceString(throwable);\n }\n if (throwable != null && message == null) {\n message = Utils.getStackTraceString(throwable);\n }\n if (Utils.isEmpty(message)) {\n message = \"Empty/NULL log message\";\n }\n\n for (LogAdapter adapter : logAdapters) {\n if (adapter.isLoggable(priority, tag)) {\n adapter.log(priority, tag, message);\n }\n }\n }\n\n @Override public void clearLogAdapters() {\n logAdapters.clear();\n }\n\n @Override public void addAdapter(@NonNull LogAdapter adapter) {\n logAdapters.add(checkNotNull(adapter));\n }\n\n /**\n * This method is synchronized in order to avoid messy of logs' order.\n */\n private synchronized void log(int priority,\n @Nullable Throwable throwable,\n @NonNull String msg,\n @Nullable Object... args) {\n checkNotNull(msg);\n\n String tag = getTag();\n String message = createMessage(msg, args);\n log(priority, tag, message, throwable);\n }\n\n /**\n * @return the appropriate tag based on local or global\n */\n @Nullable private String getTag() {\n String tag = localTag.get();\n if (tag != null) {\n localTag.remove();\n return tag;\n }\n return null;\n }\n\n @NonNull private String createMessage(@NonNull String message, @Nullable Object... args) {\n return args == null || args.length == 0 ? message : String.format(message, args);\n }\n}\n" }, { "path": "logger/src/main/java/com/orhanobut/logger/PrettyFormatStrategy.java", "content": "package com.orhanobut.logger;\n\nimport androidx.annotation.NonNull;\nimport androidx.annotation.Nullable;\n\nimport static com.orhanobut.logger.Utils.checkNotNull;\n\n/**\n * Draws borders around the given log message along with additional information such as :\n *\n *
    \n *
  • Thread information
    • \n *
  • Method stack trace
    • \n *
\n *\n * 
\n *  ┌──────────────────────────\n *  │ Method stack history\n *  ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄\n *  │ Thread information\n *  ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄\n *  │ Log message\n *  └──────────────────────────\n *
\n *\n *

Customize

\n * 
\n *   FormatStrategy formatStrategy = PrettyFormatStrategy.newBuilder()\n *       .showThreadInfo(false)  // (Optional) Whether to show thread info or not. Default true\n *       .methodCount(0)         // (Optional) How many method line to show. Default 2\n *       .methodOffset(7)        // (Optional) Hides internal method calls up to offset. Default 5\n *       .logStrategy(customLog) // (Optional) Changes the log strategy to print out. Default LogCat\n *       .tag(\"My custom tag\")   // (Optional) Global tag for every log. Default PRETTY_LOGGER\n *       .build();\n *
\n */\npublic class PrettyFormatStrategy implements FormatStrategy {\n\n /**\n * Android's max limit for a log entry is ~4076 bytes,\n * so 4000 bytes is used as chunk size since default charset\n * is UTF-8\n */\n private static final int CHUNK_SIZE = 4000;\n\n /**\n * The minimum stack trace index, starts at this class after two native calls.\n */\n private static final int MIN_STACK_OFFSET = 5;\n\n /**\n * Drawing toolbox\n */\n private static final char TOP_LEFT_CORNER = '┌';\n private static final char BOTTOM_LEFT_CORNER = '└';\n private static final char MIDDLE_CORNER = '├';\n private static final char HORIZONTAL_LINE = '│';\n private static final String DOUBLE_DIVIDER = \"────────────────────────────────────────────────────────\";\n private static final String SINGLE_DIVIDER = \"┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄\";\n private static final String TOP_BORDER = TOP_LEFT_CORNER + DOUBLE_DIVIDER + DOUBLE_DIVIDER;\n private static final String BOTTOM_BORDER = BOTTOM_LEFT_CORNER + DOUBLE_DIVIDER + DOUBLE_DIVIDER;\n private static final String MIDDLE_BORDER = MIDDLE_CORNER + SINGLE_DIVIDER + SINGLE_DIVIDER;\n\n private final int methodCount;\n private final int methodOffset;\n private final boolean showThreadInfo;\n @NonNull private final LogStrategy logStrategy;\n @Nullable private final String tag;\n\n private PrettyFormatStrategy(@NonNull Builder builder) {\n checkNotNull(builder);\n\n methodCount = builder.methodCount;\n methodOffset = builder.methodOffset;\n showThreadInfo = builder.showThreadInfo;\n logStrategy = builder.logStrategy;\n tag = builder.tag;\n }\n\n @NonNull public static Builder newBuilder() {\n return new Builder();\n }\n\n @Override public void log(int priority, @Nullable String onceOnlyTag, @NonNull String message) {\n checkNotNull(message);\n\n String tag = formatTag(onceOnlyTag);\n\n logTopBorder(priority, tag);\n logHeaderContent(priority, tag, methodCount);\n\n //get bytes of message with system's default charset (which is UTF-8 for Android)\n byte[] bytes = message.getBytes();\n int length = bytes.length;\n if (length <= CHUNK_SIZE) {\n if (methodCount > 0) {\n logDivider(priority, tag);\n }\n logContent(priority, tag, message);\n logBottomBorder(priority, tag);\n return;\n }\n if (methodCount > 0) {\n logDivider(priority, tag);\n }\n for (int i = 0; i < length; i += CHUNK_SIZE) {\n int count = Math.min(length - i, CHUNK_SIZE);\n //create a new String with system's default charset (which is UTF-8 for Android)\n logContent(priority, tag, new String(bytes, i, count));\n }\n logBottomBorder(priority, tag);\n }\n\n private void logTopBorder(int logType, @Nullable String tag) {\n logChunk(logType, tag, TOP_BORDER);\n }\n\n @SuppressWarnings(\"StringBufferReplaceableByString\")\n private void logHeaderContent(int logType, @Nullable String tag, int methodCount) {\n StackTraceElement[] trace = Thread.currentThread().getStackTrace();\n if (showThreadInfo) {\n logChunk(logType, tag, HORIZONTAL_LINE + \" Thread: \" + Thread.currentThread().getName());\n logDivider(logType, tag);\n }\n String level = \"\";\n\n int stackOffset = getStackOffset(trace) + methodOffset;\n\n //corresponding method count with the current stack may exceeds the stack trace. Trims the count\n if (methodCount + stackOffset > trace.length) {\n methodCount = trace.length - stackOffset - 1;\n }\n\n for (int i = methodCount; i > 0; i--) {\n int stackIndex = i + stackOffset;\n if (stackIndex >= trace.length) {\n continue;\n }\n StringBuilder builder = new StringBuilder();\n builder.append(HORIZONTAL_LINE)\n .append(' ')\n .append(level)\n .append(getSimpleClassName(trace[stackIndex].getClassName()))\n .append(\".\")\n .append(trace[stackIndex].getMethodName())\n .append(\" \")\n .append(\" (\")\n .append(trace[stackIndex].getFileName())\n .append(\":\")\n .append(trace[stackIndex].getLineNumber())\n .append(\")\");\n level += \" \";\n logChunk(logType, tag, builder.toString());\n }\n }\n\n private void logBottomBorder(int logType, @Nullable String tag) {\n logChunk(logType, tag, BOTTOM_BORDER);\n }\n\n private void logDivider(int logType, @Nullable String tag) {\n logChunk(logType, tag, MIDDLE_BORDER);\n }\n\n private void logContent(int logType, @Nullable String tag, @NonNull String chunk) {\n checkNotNull(chunk);\n\n String[] lines = chunk.split(System.getProperty(\"line.separator\"));\n for (String line : lines) {\n logChunk(logType, tag, HORIZONTAL_LINE + \" \" + line);\n }\n }\n\n private void logChunk(int priority, @Nullable String tag, @NonNull String chunk) {\n checkNotNull(chunk);\n\n logStrategy.log(priority, tag, chunk);\n }\n\n private String getSimpleClassName(@NonNull String name) {\n checkNotNull(name);\n\n int lastIndex = name.lastIndexOf(\".\");\n return name.substring(lastIndex + 1);\n }\n\n /**\n * Determines the starting index of the stack trace, after method calls made by this class.\n *\n * @param trace the stack trace\n * @return the stack offset\n */\n private int getStackOffset(@NonNull StackTraceElement[] trace) {\n checkNotNull(trace);\n\n for (int i = MIN_STACK_OFFSET; i < trace.length; i++) {\n StackTraceElement e = trace[i];\n String name = e.getClassName();\n if (!name.equals(LoggerPrinter.class.getName()) && !name.equals(Logger.class.getName())) {\n return --i;\n }\n }\n return -1;\n }\n\n @Nullable private String formatTag(@Nullable String tag) {\n if (!Utils.isEmpty(tag) && !Utils.equals(this.tag, tag)) {\n return this.tag + \"-\" + tag;\n }\n return this.tag;\n }\n\n public static class Builder {\n int methodCount = 2;\n int methodOffset = 0;\n boolean showThreadInfo = true;\n @Nullable LogStrategy logStrategy;\n @Nullable String tag = \"PRETTY_LOGGER\";\n\n private Builder() {\n }\n\n @NonNull public Builder methodCount(int val) {\n methodCount = val;\n return this;\n }\n\n @NonNull public Builder methodOffset(int val) {\n methodOffset = val;\n return this;\n }\n\n @NonNull public Builder showThreadInfo(boolean val) {\n showThreadInfo = val;\n return this;\n }\n\n @NonNull public Builder logStrategy(@Nullable LogStrategy val) {\n logStrategy = val;\n return this;\n }\n\n @NonNull public Builder tag(@Nullable String tag) {\n this.tag = tag;\n return this;\n }\n\n @NonNull public PrettyFormatStrategy build() {\n if (logStrategy == null) {\n logStrategy = new LogcatLogStrategy();\n }\n return new PrettyFormatStrategy(this);\n }\n }\n\n}\n" }, { "path": "logger/src/main/java/com/orhanobut/logger/Printer.java", "content": "package com.orhanobut.logger;\n\nimport androidx.annotation.NonNull;\nimport androidx.annotation.Nullable;\n\n/**\n * A proxy interface to enable additional operations.\n * Contains all possible Log message usages.\n */\npublic interface Printer {\n\n void addAdapter(@NonNull LogAdapter adapter);\n\n Printer t(@Nullable String tag);\n\n void d(@NonNull String message, @Nullable Object... args);\n\n void d(@Nullable Object object);\n\n void e(@NonNull String message, @Nullable Object... args);\n\n void e(@Nullable Throwable throwable, @NonNull String message, @Nullable Object... args);\n\n void w(@NonNull String message, @Nullable Object... args);\n\n void i(@NonNull String message, @Nullable Object... args);\n\n void v(@NonNull String message, @Nullable Object... args);\n\n void wtf(@NonNull String message, @Nullable Object... args);\n\n /**\n * Formats the given json content and print it\n */\n void json(@Nullable String json);\n\n /**\n * Formats the given xml content and print it\n */\n void xml(@Nullable String xml);\n\n void log(int priority, @Nullable String tag, @Nullable String message, @Nullable Throwable throwable);\n\n void clearLogAdapters();\n}\n" }, { "path": "logger/src/main/java/com/orhanobut/logger/Utils.java", "content": "package com.orhanobut.logger;\n\nimport androidx.annotation.NonNull;\nimport androidx.annotation.Nullable;\n\nimport java.io.PrintWriter;\nimport java.io.StringWriter;\nimport java.net.UnknownHostException;\nimport java.util.Arrays;\n\nimport static com.orhanobut.logger.Logger.ASSERT;\nimport static com.orhanobut.logger.Logger.DEBUG;\nimport static com.orhanobut.logger.Logger.ERROR;\nimport static com.orhanobut.logger.Logger.INFO;\nimport static com.orhanobut.logger.Logger.VERBOSE;\nimport static com.orhanobut.logger.Logger.WARN;\n\n/**\n * Provides convenient methods to some common operations\n */\nfinal class Utils {\n\n private Utils() {\n // Hidden constructor.\n }\n\n /**\n * Returns true if the string is null or 0-length.\n *\n * @param str the string to be examined\n * @return true if str is null or zero length\n */\n static boolean isEmpty(CharSequence str) {\n return str == null || str.length() == 0;\n }\n\n /**\n * Returns true if a and b are equal, including if they are both null.\n *

Note: In platform versions 1.1 and earlier, this method only worked well if\n * both the arguments were instances of String.

\n *\n * @param a first CharSequence to check\n * @param b second CharSequence to check\n * @return true if a and b are equal\n *

\n * NOTE: Logic slightly change due to strict policy on CI -\n * \"Inner assignments should be avoided\"\n */\n static boolean equals(CharSequence a, CharSequence b) {\n if (a == b) return true;\n if (a != null && b != null) {\n int length = a.length();\n if (length == b.length()) {\n if (a instanceof String && b instanceof String) {\n return a.equals(b);\n } else {\n for (int i = 0; i < length; i++) {\n if (a.charAt(i) != b.charAt(i)) return false;\n }\n return true;\n }\n }\n }\n return false;\n }\n\n /**\n * Copied from \"android.util.Log.getStackTraceString()\" in order to avoid usage of Android stack\n * in unit tests.\n *\n * @return Stack trace in form of String\n */\n static String getStackTraceString(Throwable tr) {\n if (tr == null) {\n return \"\";\n }\n\n // This is to reduce the amount of log spew that apps do in the non-error\n // condition of the network being unavailable.\n Throwable t = tr;\n while (t != null) {\n if (t instanceof UnknownHostException) {\n return \"\";\n }\n t = t.getCause();\n }\n\n StringWriter sw = new StringWriter();\n PrintWriter pw = new PrintWriter(sw);\n tr.printStackTrace(pw);\n pw.flush();\n return sw.toString();\n }\n\n static String logLevel(int value) {\n switch (value) {\n case VERBOSE:\n return \"VERBOSE\";\n case DEBUG:\n return \"DEBUG\";\n case INFO:\n return \"INFO\";\n case WARN:\n return \"WARN\";\n case ERROR:\n return \"ERROR\";\n case ASSERT:\n return \"ASSERT\";\n default:\n return \"UNKNOWN\";\n }\n }\n\n public static String toString(Object object) {\n if (object == null) {\n return \"null\";\n }\n if (!object.getClass().isArray()) {\n return object.toString();\n }\n if (object instanceof boolean[]) {\n return Arrays.toString((boolean[]) object);\n }\n if (object instanceof byte[]) {\n return Arrays.toString((byte[]) object);\n }\n if (object instanceof char[]) {\n return Arrays.toString((char[]) object);\n }\n if (object instanceof short[]) {\n return Arrays.toString((short[]) object);\n }\n if (object instanceof int[]) {\n return Arrays.toString((int[]) object);\n }\n if (object instanceof long[]) {\n return Arrays.toString((long[]) object);\n }\n if (object instanceof float[]) {\n return Arrays.toString((float[]) object);\n }\n if (object instanceof double[]) {\n return Arrays.toString((double[]) object);\n }\n if (object instanceof Object[]) {\n return Arrays.deepToString((Object[]) object);\n }\n return \"Couldn't find a correct type for the object\";\n }\n\n @NonNull static T checkNotNull(@Nullable final T obj) {\n if (obj == null) {\n throw new NullPointerException();\n }\n return obj;\n }\n}\n" }, { "path": "logger/src/test/java/com.orhanobut.logger/AndroidLogAdapterTest.kt", "content": "package com.orhanobut.logger\n\nimport org.junit.Test\n\nimport com.google.common.truth.Truth.assertThat\nimport com.orhanobut.logger.Logger.DEBUG\nimport org.mockito.Mockito.mock\nimport org.mockito.Mockito.verify\n\nclass AndroidLogAdapterTest {\n\n @Test fun isLoggable() {\n val logAdapter = AndroidLogAdapter()\n\n assertThat(logAdapter.isLoggable(DEBUG, \"tag\")).isTrue()\n }\n\n @Test fun log() {\n val formatStrategy = mock(FormatStrategy::class.java)\n val logAdapter = AndroidLogAdapter(formatStrategy)\n\n logAdapter.log(DEBUG, null, \"message\")\n\n verify(formatStrategy).log(DEBUG, null, \"message\")\n }\n\n}" }, { "path": "logger/src/test/java/com.orhanobut.logger/CsvFormatStrategyTest.kt", "content": "package com.orhanobut.logger\n\nimport org.junit.Test\n\nimport com.google.common.truth.Truth.assertThat\n\nclass CsvFormatStrategyTest {\n\n @Test fun log() {\n val formatStrategy = CsvFormatStrategy.newBuilder()\n .logStrategy { priority, tag, message ->\n assertThat(tag).isEqualTo(\"PRETTY_LOGGER-tag\")\n assertThat(priority).isEqualTo(Logger.VERBOSE)\n assertThat(message).contains(\"VERBOSE,PRETTY_LOGGER-tag,message\")\n }\n .build()\n\n formatStrategy.log(Logger.VERBOSE, \"tag\", \"message\")\n }\n\n @Test fun defaultTag() {\n val formatStrategy = CsvFormatStrategy.newBuilder()\n .logStrategy { priority, tag, message -> assertThat(tag).isEqualTo(\"PRETTY_LOGGER\") }\n .build()\n\n formatStrategy.log(Logger.VERBOSE, null, \"message\")\n }\n\n @Test fun customTag() {\n val formatStrategy = CsvFormatStrategy.newBuilder()\n .tag(\"custom\")\n .logStrategy { priority, tag, message -> assertThat(tag).isEqualTo(\"custom\") }\n .build()\n\n formatStrategy.log(Logger.VERBOSE, null, \"message\")\n }\n}\n" }, { "path": "logger/src/test/java/com.orhanobut.logger/DiskLogAdapterTest.kt", "content": "package com.orhanobut.logger\n\nimport com.google.common.truth.Truth.assertThat\nimport org.junit.Before\nimport org.junit.Test\nimport org.mockito.Mock\nimport org.mockito.Mockito.verify\nimport org.mockito.MockitoAnnotations.initMocks\n\nclass DiskLogAdapterTest {\n\n @Mock private lateinit var formatStrategy: FormatStrategy\n\n @Before fun setup() {\n initMocks(this)\n }\n\n @Test fun isLoggableTrue() {\n val logAdapter = DiskLogAdapter(formatStrategy)\n\n assertThat(logAdapter.isLoggable(Logger.VERBOSE, \"tag\")).isTrue()\n }\n\n @Test fun isLoggableFalse() {\n val logAdapter = object : DiskLogAdapter(formatStrategy) {\n override fun isLoggable(priority: Int, tag: String?): Boolean {\n return false\n }\n }\n\n assertThat(logAdapter.isLoggable(Logger.VERBOSE, \"tag\")).isFalse()\n }\n\n @Test fun log() {\n val logAdapter = DiskLogAdapter(formatStrategy)\n\n logAdapter.log(Logger.VERBOSE, \"tag\", \"message\")\n\n verify(formatStrategy).log(Logger.VERBOSE, \"tag\", \"message\")\n }\n\n}\n" }, { "path": "logger/src/test/java/com.orhanobut.logger/DiskLogStrategyTest.kt", "content": "package com.orhanobut.logger\n\nimport android.os.Handler\n\nimport org.junit.Test\n\nimport com.orhanobut.logger.Logger.DEBUG\nimport org.mockito.Mockito.mock\nimport org.mockito.Mockito.verify\n\nclass DiskLogStrategyTest {\n\n @Test fun log() {\n val handler = mock(Handler::class.java)\n val logStrategy = DiskLogStrategy(handler)\n\n logStrategy.log(DEBUG, \"tag\", \"message\")\n\n verify(handler).sendMessage(handler.obtainMessage(DEBUG, \"message\"))\n }\n\n}" }, { "path": "logger/src/test/java/com.orhanobut.logger/LogAssert.kt", "content": "package com.orhanobut.logger\n\nimport com.google.common.truth.Truth.assertThat\n\ninternal class LogAssert(private val items: MutableList, tag: String?, private val priority: Int) {\n\n private val tag: String\n\n private var index = 0\n\n init {\n this.tag = tag ?: DEFAULT_TAG\n }\n\n fun hasTopBorder(): LogAssert {\n return hasLog(priority, tag, TOP_BORDER)\n }\n\n fun hasBottomBorder(): LogAssert {\n return hasLog(priority, tag, BOTTOM_BORDER)\n }\n\n fun hasMiddleBorder(): LogAssert {\n return hasLog(priority, tag, MIDDLE_BORDER)\n }\n\n fun hasThread(threadName: String): LogAssert {\n return hasLog(priority, tag, \"$HORIZONTAL_LINE Thread: $threadName\")\n }\n\n fun hasMethodInfo(methodInfo: String): LogAssert {\n return hasLog(priority, tag, \"$HORIZONTAL_LINE $methodInfo\")\n }\n\n fun hasMessage(message: String): LogAssert {\n return hasLog(priority, tag, \"$HORIZONTAL_LINE $message\")\n }\n\n private fun hasLog(priority: Int, tag: String, message: String): LogAssert = apply {\n val item = items[index++]\n assertThat(item.priority).isEqualTo(priority)\n assertThat(item.tag).isEqualTo(tag)\n assertThat(item.message).isEqualTo(message)\n }\n\n fun skip(): LogAssert = apply {\n index++\n }\n\n fun hasNoMoreMessages() {\n assertThat(items).hasSize(index)\n items.clear()\n }\n\n internal class LogItem(val priority: Int, val tag: String, val message: String)\n\n companion object {\n private const val DEFAULT_TAG = \"PRETTY_LOGGER\"\n\n private const val TOP_LEFT_CORNER = '┌'\n private const val BOTTOM_LEFT_CORNER = '└'\n private const val MIDDLE_CORNER = '├'\n private const val HORIZONTAL_LINE = '│'\n private const val DOUBLE_DIVIDER = \"────────────────────────────────────────────────────────\"\n private const val SINGLE_DIVIDER = \"┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄\"\n private val TOP_BORDER = TOP_LEFT_CORNER + DOUBLE_DIVIDER + DOUBLE_DIVIDER\n private val BOTTOM_BORDER = BOTTOM_LEFT_CORNER + DOUBLE_DIVIDER + DOUBLE_DIVIDER\n private val MIDDLE_BORDER = MIDDLE_CORNER + SINGLE_DIVIDER + SINGLE_DIVIDER\n }\n}\n" }, { "path": "logger/src/test/java/com.orhanobut.logger/LogcatLogStrategyTest.kt", "content": "package com.orhanobut.logger\n\nimport org.junit.Test\nimport org.junit.runner.RunWith\nimport org.robolectric.RobolectricTestRunner\nimport org.robolectric.annotation.Config\nimport org.robolectric.shadows.ShadowLog\n\nimport com.google.common.truth.Truth.assertThat\nimport com.orhanobut.logger.Logger.DEBUG\n\n@RunWith(RobolectricTestRunner::class)\nclass LogcatLogStrategyTest {\n\n @Test fun log() {\n val logStrategy = LogcatLogStrategy()\n\n logStrategy.log(DEBUG, \"tag\", \"message\")\n\n val logItems = ShadowLog.getLogs()\n assertThat(logItems[0].type).isEqualTo(DEBUG)\n assertThat(logItems[0].msg).isEqualTo(\"message\")\n assertThat(logItems[0].tag).isEqualTo(\"tag\")\n }\n\n @Test fun logWithNullTag() {\n val logStrategy = LogcatLogStrategy()\n\n logStrategy.log(DEBUG, null, \"message\")\n\n val logItems = ShadowLog.getLogs()\n assertThat(logItems[0].tag).isEqualTo(LogcatLogStrategy.DEFAULT_TAG)\n }\n\n}\n" }, { "path": "logger/src/test/java/com.orhanobut.logger/LoggerPrinterTest.kt", "content": "package com.orhanobut.logger\n\nimport com.orhanobut.logger.Logger.*\nimport org.junit.Before\nimport org.junit.Test\nimport org.mockito.Matchers.any\nimport org.mockito.Matchers.contains\nimport org.mockito.Matchers.eq\nimport org.mockito.Matchers.isNull\nimport org.mockito.Mock\nimport org.mockito.Mockito.`when`\nimport org.mockito.Mockito.mock\nimport org.mockito.Mockito.never\nimport org.mockito.Mockito.times\nimport org.mockito.Mockito.verify\nimport org.mockito.Mockito.verifyZeroInteractions\nimport org.mockito.MockitoAnnotations.initMocks\nimport java.util.*\n\nclass LoggerPrinterTest {\n\n private val printer = LoggerPrinter()\n\n @Mock private lateinit var adapter: LogAdapter\n\n @Before fun setup() {\n initMocks(this)\n `when`(adapter!!.isLoggable(any(Int::class.java), any(String::class.java))).thenReturn(true)\n printer.addAdapter(adapter!!)\n }\n\n @Test fun logDebug() {\n printer.d(\"message %s\", \"sent\")\n\n verify(adapter).log(DEBUG, null, \"message sent\")\n }\n\n @Test fun logError() {\n printer.e(\"message %s\", \"sent\")\n\n verify(adapter).log(ERROR, null, \"message sent\")\n }\n\n @Test fun logErrorWithThrowable() {\n val throwable = Throwable(\"exception\")\n\n printer.e(throwable, \"message %s\", \"sent\")\n\n verify(adapter).log(eq(ERROR), isNull(String::class.java), contains(\"message sent : java.lang.Throwable: exception\"))\n }\n\n @Test fun logWarning() {\n printer.w(\"message %s\", \"sent\")\n\n verify(adapter).log(WARN, null, \"message sent\")\n }\n\n @Test fun logInfo() {\n printer.i(\"message %s\", \"sent\")\n\n verify(adapter).log(INFO, null, \"message sent\")\n }\n\n @Test fun logWtf() {\n printer.wtf(\"message %s\", \"sent\")\n\n verify(adapter).log(ASSERT, null, \"message sent\")\n }\n\n @Test fun logVerbose() {\n printer.v(\"message %s\", \"sent\")\n\n verify(adapter).log(VERBOSE, null, \"message sent\")\n }\n\n @Test fun oneTimeTag() {\n printer.t(\"tag\").d(\"message\")\n\n verify(adapter).log(DEBUG, \"tag\", \"message\")\n }\n\n @Test fun logObject() {\n val `object` = \"Test\"\n\n printer.d(`object`)\n\n verify(adapter).log(DEBUG, null, \"Test\")\n }\n\n @Test fun logArray() {\n val `object` = intArrayOf(1, 6, 7, 30, 33)\n\n printer.d(`object`)\n\n verify(adapter).log(DEBUG, null, \"[1, 6, 7, 30, 33]\")\n }\n\n @Test fun logStringArray() {\n val `object` = arrayOf(\"a\", \"b\", \"c\")\n\n printer.d(`object`)\n\n verify(adapter).log(DEBUG, null, \"[a, b, c]\")\n }\n\n @Test fun logMultiDimensionArray() {\n val doubles = arrayOf(doubleArrayOf(1.0, 6.0), doubleArrayOf(1.2, 33.0))\n\n printer.d(doubles)\n\n verify(adapter).log(DEBUG, null, \"[[1.0, 6.0], [1.2, 33.0]]\")\n }\n\n @Test fun logList() {\n val list = Arrays.asList(\"foo\", \"bar\")\n printer.d(list)\n\n verify(adapter).log(DEBUG, null, list.toString())\n }\n\n @Test fun logMap() {\n val map = HashMap()\n map[\"key\"] = \"value\"\n map[\"key2\"] = \"value2\"\n\n printer.d(map)\n\n verify(adapter).log(DEBUG, null, map.toString())\n }\n\n @Test fun logSet() {\n val set = HashSet()\n set.add(\"key\")\n set.add(\"key1\")\n\n printer.d(set)\n\n verify(adapter).log(DEBUG, null, set.toString())\n }\n\n @Test fun logJsonObject() {\n printer.json(\" {\\\"key\\\":3}\")\n\n verify(adapter).log(DEBUG, null, \"{\\\"key\\\": 3}\")\n }\n\n @Test fun logJsonArray() {\n printer.json(\"[{\\\"key\\\":3}]\")\n\n verify(adapter).log(DEBUG, null, \"[{\\\"key\\\": 3}]\")\n }\n\n\n @Test fun logInvalidJsonObject() {\n printer.json(\"no json\")\n printer.json(\"{ missing end\")\n\n verify(adapter, times(2)).log(ERROR, null, \"Invalid Json\")\n }\n\n @Test fun jsonLogEmptyOrNull() {\n printer.json(null)\n printer.json(\"\")\n\n verify(adapter, times(2)).log(DEBUG, null, \"Empty/Null json content\")\n }\n\n @Test fun xmlLog() {\n printer.xml(\"Test\")\n\n verify(adapter).log(DEBUG, null,\n \"\\nTest\\n\")\n }\n\n @Test fun invalidXmlLog() {\n printer.xml(\"xml>Test\")\n\n verify(adapter).log(ERROR, null, \"Invalid xml\")\n }\n\n @Test fun xmlLogNullOrEmpty() {\n printer.xml(null)\n printer.xml(\"\")\n\n verify(adapter, times(2)).log(DEBUG, null, \"Empty/Null xml content\")\n }\n\n @Test fun clearLogAdapters() {\n printer.clearLogAdapters()\n\n printer.d(\"\")\n\n verifyZeroInteractions(adapter)\n }\n\n @Test fun addAdapter() {\n printer.clearLogAdapters()\n val adapter1 = mock(LogAdapter::class.java)\n val adapter2 = mock(LogAdapter::class.java)\n\n printer.addAdapter(adapter1)\n printer.addAdapter(adapter2)\n\n printer.d(\"message\")\n\n verify(adapter1).isLoggable(DEBUG, null)\n verify(adapter2).isLoggable(DEBUG, null)\n }\n\n @Test fun doNotLogIfNotLoggable() {\n printer.clearLogAdapters()\n val adapter1 = mock(LogAdapter::class.java)\n `when`(adapter1.isLoggable(DEBUG, null)).thenReturn(false)\n\n val adapter2 = mock(LogAdapter::class.java)\n `when`(adapter2.isLoggable(DEBUG, null)).thenReturn(true)\n\n printer.addAdapter(adapter1)\n printer.addAdapter(adapter2)\n\n printer.d(\"message\")\n\n verify(adapter1, never()).log(DEBUG, null, \"message\")\n verify(adapter2).log(DEBUG, null, \"message\")\n }\n\n @Test fun logWithoutMessageAndThrowable() {\n printer.log(DEBUG, null, null, null)\n\n verify(adapter).log(DEBUG, null, \"Empty/NULL log message\")\n }\n\n @Test fun logWithOnlyThrowableWithoutMessage() {\n val throwable = Throwable(\"exception\")\n printer.log(DEBUG, null, null, throwable)\n\n verify(adapter).log(eq(DEBUG), isNull(String::class.java), contains(\"java.lang.Throwable: exception\"))\n }\n}" }, { "path": "logger/src/test/java/com.orhanobut.logger/LoggerTest.kt", "content": "package com.orhanobut.logger\n\nimport org.junit.Before\nimport org.junit.Test\nimport org.mockito.Mock\n\nimport org.mockito.Mockito.mock\nimport org.mockito.Mockito.verify\nimport org.mockito.Mockito.`when`\nimport org.mockito.MockitoAnnotations.initMocks\n\nclass LoggerTest {\n\n @Mock private lateinit var printer: Printer\n\n @Before fun setup() {\n initMocks(this)\n\n Logger.printer(printer)\n }\n\n @Test fun log() {\n val throwable = Throwable()\n Logger.log(Logger.VERBOSE, \"tag\", \"message\", throwable)\n\n verify(printer).log(Logger.VERBOSE, \"tag\", \"message\", throwable)\n }\n\n @Test fun debugLog() {\n Logger.d(\"message %s\", \"arg\")\n\n verify(printer).d(\"message %s\", \"arg\")\n }\n\n @Test fun verboseLog() {\n Logger.v(\"message %s\", \"arg\")\n\n verify(printer).v(\"message %s\", \"arg\")\n }\n\n @Test fun warningLog() {\n Logger.w(\"message %s\", \"arg\")\n\n verify(printer).w(\"message %s\", \"arg\")\n }\n\n @Test fun errorLog() {\n Logger.e(\"message %s\", \"arg\")\n\n verify(printer).e(null as Throwable?, \"message %s\", \"arg\")\n }\n\n @Test fun errorLogWithThrowable() {\n val throwable = Throwable(\"throwable\")\n Logger.e(throwable, \"message %s\", \"arg\")\n\n verify(printer).e(throwable, \"message %s\", \"arg\")\n }\n\n @Test fun infoLog() {\n Logger.i(\"message %s\", \"arg\")\n\n verify(printer).i(\"message %s\", \"arg\")\n }\n\n @Test fun wtfLog() {\n Logger.wtf(\"message %s\", \"arg\")\n\n verify(printer).wtf(\"message %s\", \"arg\")\n }\n\n @Test fun logObject() {\n val `object` = Any()\n Logger.d(`object`)\n\n verify(printer).d(`object`)\n }\n\n @Test fun jsonLog() {\n Logger.json(\"json\")\n\n verify(printer).json(\"json\")\n }\n\n @Test fun xmlLog() {\n Logger.xml(\"xml\")\n\n verify(printer).xml(\"xml\")\n }\n\n @Test fun oneTimeTag() {\n `when`(printer.t(\"tag\")).thenReturn(printer)\n\n Logger.t(\"tag\").d(\"message\")\n\n verify(printer).t(\"tag\")\n verify(printer).d(\"message\")\n }\n\n @Test fun addAdapter() {\n val adapter = mock(LogAdapter::class.java)\n Logger.addLogAdapter(adapter)\n\n verify(printer).addAdapter(adapter)\n }\n\n @Test fun clearLogAdapters() {\n Logger.clearLogAdapters()\n\n verify(printer).clearLogAdapters()\n }\n}\n" }, { "path": "logger/src/test/java/com.orhanobut.logger/PrettyFormatStrategyTest.kt", "content": "package com.orhanobut.logger\n\nimport org.junit.Test\n\nimport java.util.ArrayList\n\nimport com.orhanobut.logger.Logger.DEBUG\n\nclass PrettyFormatStrategyTest {\n\n private val threadName = Thread.currentThread().name\n private val logStrategy = MockLogStrategy()\n private val builder = PrettyFormatStrategy.newBuilder().logStrategy(logStrategy)\n\n //TODO: Check the actual method info\n @Test fun defaultLog() {\n val formatStrategy = builder.build()\n\n formatStrategy.log(DEBUG, null, \"message\")\n\n assertLog(DEBUG)\n .hasTopBorder()\n .hasThread(threadName)\n .hasMiddleBorder()\n .skip()\n .skip()\n .hasMiddleBorder()\n .hasMessage(\"message\")\n .hasBottomBorder()\n .hasNoMoreMessages()\n }\n\n @Test fun logWithoutThreadInfo() {\n val formatStrategy = builder.showThreadInfo(false).build()\n\n formatStrategy.log(DEBUG, null, \"message\")\n\n assertLog(DEBUG)\n .hasTopBorder()\n .skip()\n .skip()\n .hasMiddleBorder()\n .hasMessage(\"message\")\n .hasBottomBorder()\n .hasNoMoreMessages()\n }\n\n @Test fun logWithoutMethodInfo() {\n val formatStrategy = builder.methodCount(0).build()\n\n formatStrategy.log(DEBUG, null, \"message\")\n\n assertLog(DEBUG)\n .hasTopBorder()\n .hasThread(threadName)\n .hasMiddleBorder()\n .hasMessage(\"message\")\n .hasBottomBorder()\n .hasNoMoreMessages()\n }\n\n @Test fun logWithOnlyMessage() {\n val formatStrategy = builder\n .methodCount(0)\n .showThreadInfo(false)\n .build()\n\n formatStrategy.log(DEBUG, null, \"message\")\n\n assertLog(DEBUG)\n .hasTopBorder()\n .hasMessage(\"message\")\n .hasBottomBorder()\n .hasNoMoreMessages()\n }\n\n //TODO: Check the actual method info\n @Test fun logWithCustomMethodOffset() {\n val formatStrategy = builder\n .methodOffset(2)\n .showThreadInfo(false)\n .build()\n\n formatStrategy.log(DEBUG, null, \"message\")\n\n assertLog(DEBUG)\n .hasTopBorder()\n .skip()\n .skip()\n .hasMiddleBorder()\n .hasMessage(\"message\")\n .hasBottomBorder()\n .hasNoMoreMessages()\n }\n\n @Test fun logWithCustomTag() {\n val formatStrategy = builder\n .tag(\"custom\")\n .build()\n\n formatStrategy.log(DEBUG, null, \"message\")\n\n assertLog(\"custom\", DEBUG)\n .hasTopBorder()\n .hasThread(threadName)\n .hasMiddleBorder()\n .skip()\n .skip()\n .hasMiddleBorder()\n .hasMessage(\"message\")\n .hasBottomBorder()\n .hasNoMoreMessages()\n }\n\n @Test fun logWithOneTimeTag() {\n val formatStrategy = builder\n .tag(\"custom\")\n .build()\n\n formatStrategy.log(DEBUG, \"tag\", \"message\")\n\n assertLog(\"custom-tag\", DEBUG)\n .hasTopBorder()\n .hasThread(threadName)\n .hasMiddleBorder()\n .skip()\n .skip()\n .hasMiddleBorder()\n .hasMessage(\"message\")\n .hasBottomBorder()\n .hasNoMoreMessages()\n }\n\n // TODO: assert values, for now this checks that Logger doesn't crash\n @Test fun logWithExceedingMethodCount() {\n val formatStrategy = builder\n .methodCount(50)\n .build()\n\n formatStrategy.log(DEBUG, null, \"message\")\n }\n\n @Test fun logWithBigChunk() {\n val formatStrategy = builder.build()\n\n val chunk1 = StringBuilder()\n for (i in 0..399) {\n chunk1.append(\"1234567890\")\n }\n val chunk2 = StringBuilder()\n for (i in 0..9) {\n chunk2.append(\"ABCDEFGD\")\n }\n\n formatStrategy.log(DEBUG, null, chunk1.toString() + chunk2.toString())\n\n assertLog(DEBUG)\n .hasTopBorder()\n .hasThread(threadName)\n .hasMiddleBorder()\n .skip()\n .skip()\n .hasMiddleBorder()\n .hasMessage(chunk1.toString())\n .hasMessage(chunk2.toString())\n .hasBottomBorder()\n .hasNoMoreMessages()\n }\n\n private class MockLogStrategy : LogStrategy {\n internal var logItems: MutableList = ArrayList()\n\n override fun log(priority: Int, tag: String?, message: String) {\n logItems.add(LogAssert.LogItem(priority, tag ?: \"\", message))\n }\n }\n\n private fun assertLog(priority: Int): LogAssert {\n return assertLog(null, priority)\n }\n\n private fun assertLog(tag: String?, priority: Int): LogAssert {\n return LogAssert(logStrategy.logItems, tag, priority)\n }\n}\n" }, { "path": "logger/src/test/java/com.orhanobut.logger/UtilsTest.kt", "content": "package com.orhanobut.logger\n\nimport android.util.Log\n\nimport org.junit.Test\nimport org.junit.runner.RunWith\nimport org.robolectric.RobolectricTestRunner\nimport org.robolectric.annotation.Config\n\nimport java.net.UnknownHostException\n\nimport com.google.common.truth.Truth.assertThat\n\n@RunWith(RobolectricTestRunner::class)\nclass UtilsTest {\n\n @Test fun isEmpty() {\n assertThat(Utils.isEmpty(\"\")).isTrue()\n assertThat(Utils.isEmpty(null)).isTrue()\n }\n\n @Test fun equals() {\n assertThat(Utils.equals(\"a\", \"a\")).isTrue()\n assertThat(Utils.equals(\"as\", \"b\")).isFalse()\n assertThat(Utils.equals(null, \"b\")).isFalse()\n assertThat(Utils.equals(\"a\", null)).isFalse()\n }\n\n @Test fun getStackTraceString() {\n val throwable = Throwable(\"test\")\n val androidTraceString = Log.getStackTraceString(throwable)\n assertThat(Utils.getStackTraceString(throwable)).isEqualTo(androidTraceString)\n }\n\n @Test fun getStackTraceStringReturnsEmptyStringWithNull() {\n assertThat(Utils.getStackTraceString(null)).isEqualTo(\"\")\n }\n\n @Test fun getStackTraceStringReturnEmptyStringWithUnknownHostException() {\n assertThat(Utils.getStackTraceString(UnknownHostException())).isEqualTo(\"\")\n }\n\n @Test fun logLevels() {\n assertThat(Utils.logLevel(Logger.DEBUG)).isEqualTo(\"DEBUG\")\n assertThat(Utils.logLevel(Logger.WARN)).isEqualTo(\"WARN\")\n assertThat(Utils.logLevel(Logger.INFO)).isEqualTo(\"INFO\")\n assertThat(Utils.logLevel(Logger.VERBOSE)).isEqualTo(\"VERBOSE\")\n assertThat(Utils.logLevel(Logger.ASSERT)).isEqualTo(\"ASSERT\")\n assertThat(Utils.logLevel(Logger.ERROR)).isEqualTo(\"ERROR\")\n assertThat(Utils.logLevel(100)).isEqualTo(\"UNKNOWN\")\n }\n\n @Test fun objectToString() {\n val `object` = \"Test\"\n\n assertThat(Utils.toString(`object`)).isEqualTo(\"Test\")\n }\n\n @Test fun toStringWithNull() {\n assertThat(Utils.toString(null)).isEqualTo(\"null\")\n }\n\n @Test fun primitiveArrayToString() {\n val booleanArray = booleanArrayOf(true, false, true)\n assertThat(Utils.toString(booleanArray)).isEqualTo(\"[true, false, true]\")\n\n val byteArray = byteArrayOf(1, 0, 1)\n assertThat(Utils.toString(byteArray)).isEqualTo(\"[1, 0, 1]\")\n\n val charArray = charArrayOf('a', 'b', 'c')\n assertThat(Utils.toString(charArray)).isEqualTo(\"[a, b, c]\")\n\n val shortArray = shortArrayOf(1, 3, 5)\n assertThat(Utils.toString(shortArray)).isEqualTo(\"[1, 3, 5]\")\n\n val intArray = intArrayOf(1, 3, 5)\n assertThat(Utils.toString(intArray)).isEqualTo(\"[1, 3, 5]\")\n\n val longArray = longArrayOf(1, 3, 5)\n assertThat(Utils.toString(longArray)).isEqualTo(\"[1, 3, 5]\")\n\n val floatArray = floatArrayOf(1f, 3f, 5f)\n assertThat(Utils.toString(floatArray)).isEqualTo(\"[1.0, 3.0, 5.0]\")\n\n val doubleArray = doubleArrayOf(1.0, 3.0, 5.0)\n assertThat(Utils.toString(doubleArray)).isEqualTo(\"[1.0, 3.0, 5.0]\")\n }\n\n @Test fun multiDimensionArrayToString() {\n val `object` = arrayOf(intArrayOf(1, 2, 3), intArrayOf(4, 5, 6))\n\n assertThat(Utils.toString(`object`)).isEqualTo(\"[[1, 2, 3], [4, 5, 6]]\")\n }\n}" }, { "path": "sample/build.gradle", "content": "apply plugin: 'com.android.application'\n\nandroid {\n compileSdkVersion rootProject.ext.compileSdkVersion\n buildToolsVersion rootProject.ext.buildToolsVersion\n\n defaultConfig {\n applicationId \"com.orhanobut.sample\"\n minSdkVersion 23\n targetSdkVersion 27\n versionCode 1\n versionName \"1.0\"\n\n testInstrumentationRunner 'androidx.test.runner.AndroidJUnitRunner'\n\n }\n}\n\ndependencies {\n implementation project(\":logger\")\n}\n" }, { "path": "sample/src/main/AndroidManifest.xml", "content": "\n\n\n \n \n \n \n\n \n \n \n \n\n" }, { "path": "sample/src/main/java/com/orhanobut/sample/MainActivity.java", "content": "package com.orhanobut.sample;\n\nimport android.app.Activity;\nimport android.os.Bundle;\nimport android.util.Log;\n\nimport com.orhanobut.logger.AndroidLogAdapter;\nimport com.orhanobut.logger.DiskLogAdapter;\nimport com.orhanobut.logger.FormatStrategy;\nimport com.orhanobut.logger.Logger;\nimport com.orhanobut.logger.PrettyFormatStrategy;\n\nimport java.util.Arrays;\nimport java.util.HashMap;\nimport java.util.Map;\n\npublic class MainActivity extends Activity {\n\n @Override\n protected void onCreate(Bundle savedInstanceState) {\n super.onCreate(savedInstanceState);\n setContentView(R.layout.activity_main);\n\n Log.d(\"Tag\", \"I'm a log which you don't see easily, hehe\");\n Log.d(\"json content\", \"{ \\\"key\\\": 3, \\n \\\"value\\\": something}\");\n Log.d(\"error\", \"There is a crash somewhere or any warning\");\n\n Logger.addLogAdapter(new AndroidLogAdapter());\n Logger.d(\"message\");\n\n Logger.clearLogAdapters();\n\n\n FormatStrategy formatStrategy = PrettyFormatStrategy.newBuilder()\n .showThreadInfo(false) // (Optional) Whether to show thread info or not. Default true\n .methodCount(0) // (Optional) How many method line to show. Default 2\n .methodOffset(3) // (Optional) Skips some method invokes in stack trace. Default 5\n// .logStrategy(customLog) // (Optional) Changes the log strategy to print out. Default LogCat\n .tag(\"My custom tag\") // (Optional) Custom tag for each log. Default PRETTY_LOGGER\n .build();\n\n Logger.addLogAdapter(new AndroidLogAdapter(formatStrategy));\n\n Logger.addLogAdapter(new AndroidLogAdapter() {\n @Override public boolean isLoggable(int priority, String tag) {\n return BuildConfig.DEBUG;\n }\n });\n\n Logger.addLogAdapter(new DiskLogAdapter());\n\n\n Logger.w(\"no thread info and only 1 method\");\n\n Logger.clearLogAdapters();\n formatStrategy = PrettyFormatStrategy.newBuilder()\n .showThreadInfo(false)\n .methodCount(0)\n .build();\n\n Logger.addLogAdapter(new AndroidLogAdapter(formatStrategy));\n Logger.i(\"no thread info and method info\");\n\n Logger.t(\"tag\").e(\"Custom tag for only one use\");\n\n Logger.json(\"{ \\\"key\\\": 3, \\\"value\\\": something}\");\n\n Logger.d(Arrays.asList(\"foo\", \"bar\"));\n\n Map map = new HashMap<>();\n map.put(\"key\", \"value\");\n map.put(\"key1\", \"value2\");\n\n Logger.d(map);\n\n Logger.clearLogAdapters();\n formatStrategy = PrettyFormatStrategy.newBuilder()\n .showThreadInfo(false)\n .methodCount(0)\n .tag(\"MyTag\")\n .build();\n Logger.addLogAdapter(new AndroidLogAdapter(formatStrategy));\n\n Logger.w(\"my log message with my tag\");\n }\n}\n" }, { "path": "sample/src/main/res/layout/activity_main.xml", "content": "\n\n\n \n\n\n" }, { "path": "settings.gradle", "content": "include ':logger', ':sample'" } ]