getInstalledIconPacksMap() {
74 | if (!mInstalledPacksLoaded) {
75 |
76 | throw new IconPacksNotLoadedException();
77 | }
78 | return mInstalledIconPacks;
79 | }
80 |
81 |
82 | /**
83 | * Load the currently installed @{@link IconPack}s asynchronously.
84 | *
85 | * This does not load the XML files.
86 | * you must do this manually for each @{@link IconPack} before trying to get an icon.
87 | *
88 | * @param context
89 | * @param listener - Attach a @{@link Listener} so you know when the installed packs were loaded
90 | */
91 | @MainThread
92 | public void loadInstalledIconPacksAsync(final Context context, final Listener listener) {
93 |
94 | final Handler handler = new Handler();
95 |
96 | RoundsExecutor.execute(new Runnable() {
97 | @Override
98 | public void run() {
99 |
100 | queryInstalledIconPacks(context, handler);
101 |
102 |
103 | handler.post(new Runnable() {
104 | @Override
105 | public void run() {
106 | if (listener != null)
107 | listener.onIconPacksLoaded();
108 | }
109 | });
110 | }
111 | });
112 |
113 | }
114 |
115 |
116 | /**
117 | * This privately queries the @{@link PackageManager} for apps that are icon packs.
118 | *
119 | * @param context
120 | * @param handler
121 | */
122 | private void queryInstalledIconPacks(Context context, Handler handler) {
123 |
124 | mInstalledPacksLoaded = false;
125 | PackageManager pm = context.getPackageManager();
126 |
127 |
128 | // merge those lists
129 | HashSet rinfo = IntentHelper.getResolveInfos(pm);
130 |
131 |
132 | mInstalledIconPacks = new HashMap<>();
133 |
134 | for (ResolveInfo ri : rinfo) {
135 |
136 | try {
137 | IconPack pack = new IconPack(context, ri.activityInfo.packageName, handler);
138 |
139 | mInstalledIconPacks.put(pack.getPackageName(), pack);
140 |
141 | } catch (PackageManager.NameNotFoundException e) {
142 | e.printStackTrace();
143 | }
144 |
145 |
146 | }
147 |
148 | mInstalledPacksLoaded = true;
149 | }
150 |
151 | public interface Listener {
152 |
153 | void onIconPacksLoaded();
154 | }
155 | }
156 |
--------------------------------------------------------------------------------
/iconpack/build.gradle:
--------------------------------------------------------------------------------
1 | apply plugin: 'com.android.library'
2 | apply plugin: 'com.jfrog.bintray'
3 | apply plugin: 'com.github.dcendents.android-maven'
4 | apply plugin: 'maven-publish'
5 |
6 | android {
7 | compileSdkVersion rootProject.ext.compileSdkVersion
8 | buildToolsVersion rootProject.ext.buildToolsVersion
9 |
10 |
11 | defaultConfig {
12 | minSdkVersion 9
13 | targetSdkVersion 25
14 | versionCode 1
15 | versionName "1.0"
16 |
17 | testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
18 |
19 | }
20 | buildTypes {
21 | release {
22 | minifyEnabled false
23 | proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
24 | }
25 | }
26 |
27 | defaultPublishConfig "release"
28 |
29 | }
30 |
31 |
32 |
33 | dependencies {
34 | compile fileTree(dir: 'libs', include: ['*.jar'])
35 | compile 'com.android.support:support-annotations:25.3.1'
36 | // javadocDeps 'com.android.support:support-annotations:25.3.1'
37 | androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
38 | exclude group: 'com.android.support', module: 'support-annotations'
39 | })
40 | compile 'com.android.support:appcompat-v7:25.3.1'
41 | testCompile 'junit:junit:4.12'
42 |
43 | }
44 |
45 |
46 | task sourcesJar(type: Jar) {
47 | from android.sourceSets.main.java.srcDirs
48 | classifier = 'sources'
49 | }
50 |
51 | task javadoc(type: Javadoc) {
52 | source = android.sourceSets.main.java.srcDirs
53 | classpath += project.files(android.getBootClasspath().join(File.pathSeparator))
54 | }
55 |
56 | task javadocJar(type: Jar, dependsOn: javadoc) {
57 | classifier = 'javadoc'
58 | from javadoc.destinationDir
59 | }
60 |
61 | artifacts {
62 | archives javadocJar
63 | archives sourcesJar
64 | }
65 |
66 | group = 'com.sofakingforever.libraries' // Change this to match your package name
67 | version = '0.0.7' // Change this to match your version number
68 |
69 |
70 | install {
71 | repositories.mavenInstaller {
72 | pom.project {
73 | name 'IconPackParser'
74 | description 'A library for finding out whether someone is on the naughty list or the nice list'
75 | url 'https://github.com/sofakingforever/IconPackParser-Android'
76 | inceptionYear '2017'
77 |
78 | packaging 'aar'
79 | groupId 'com.sofakingforever.libraries'
80 | artifactId 'iconpack'
81 | version '0.0.7'
82 |
83 | licenses {
84 | license {
85 | name 'Apache 2.0'
86 | url 'http://www.apache.org/licenses/LICENSE-2.0'
87 | }
88 | }
89 | scm {
90 | connection 'https://github.com/northpolecoder/elf.git'
91 | url 'https://github.com/northpolecoder/elf'
92 |
93 | }
94 | developers {
95 | developer {
96 | id = 'sofakingforever'
97 | // name 'Nick'
98 | }
99 | }
100 | }
101 | }
102 | }
103 |
104 | Properties bintrayProperties = new Properties()
105 | bintrayProperties.load(project.rootProject.file('bintray.properties').newDataInputStream())
106 |
107 | bintray {
108 | user = bintrayProperties.getProperty('user')
109 | key = bintrayProperties.get('key')
110 | publications = ['MyPublication']
111 | configurations = ['archives']
112 | pkg {
113 | repo = 'libraries'
114 | name = 'IconPackParser-Android'
115 | userOrg = 'sofakingforever'
116 | licenses = ['MIT']
117 | vcsUrl = 'https://github.com/sofakingforever/IconPackParser-Android.git'
118 | publish = true
119 | version {
120 | name = '0.0.7'
121 | desc = 'IconPackParser-Android 0.0.7'
122 | released = new Date()
123 | vcsTag = 'v0.0.7'
124 | }
125 | }
126 | }
127 |
128 | // Create the pom configuration:
129 | def pomConfig = {
130 | licenses {
131 | license {
132 | name "The Apache Software License, Version 2.0"
133 | url "http://www.apache.org/licenses/LICENSE-2.0.txt"
134 | distribution "repo"
135 | }
136 | }
137 | developers {
138 | developer {
139 | id "developer-id"
140 | name "developer-name"
141 | email "dev@d.com"
142 | }
143 | }
144 |
145 | scm {
146 | url "https://github.com/sofakingforever/IconPackParser-Android"
147 | }
148 | }
149 |
150 | publishing {
151 | publications {
152 | MyPublication(MavenPublication) {
153 | // from android.sourceSets.main.java.srcDirs
154 | artifact sourcesJar
155 | artifact javadocJar
156 | groupId 'com.sofakingforever.libraries'
157 | artifactId 'iconpack'
158 | version '0.0.7'
159 | pom.withXml {
160 | def root = asNode()
161 | root.appendNode('description', 'Your description of the lib')
162 | root.appendNode('name', 'Your name of the lib')
163 | root.appendNode('url', 'https://site_for_lib.tld')
164 | root.children().last() + pomConfig
165 | }
166 | }
167 | }
168 | }
--------------------------------------------------------------------------------
/gradlew:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 |
3 | ##############################################################################
4 | ##
5 | ## Gradle start up script for UN*X
6 | ##
7 | ##############################################################################
8 |
9 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
10 | DEFAULT_JVM_OPTS=""
11 |
12 | APP_NAME="Gradle"
13 | APP_BASE_NAME=`basename "$0"`
14 |
15 | # Use the maximum available, or set MAX_FD != -1 to use that value.
16 | MAX_FD="maximum"
17 |
18 | warn ( ) {
19 | echo "$*"
20 | }
21 |
22 | die ( ) {
23 | echo
24 | echo "$*"
25 | echo
26 | exit 1
27 | }
28 |
29 | # OS specific support (must be 'true' or 'false').
30 | cygwin=false
31 | msys=false
32 | darwin=false
33 | case "`uname`" in
34 | CYGWIN* )
35 | cygwin=true
36 | ;;
37 | Darwin* )
38 | darwin=true
39 | ;;
40 | MINGW* )
41 | msys=true
42 | ;;
43 | esac
44 |
45 | # Attempt to set APP_HOME
46 | # Resolve links: $0 may be a link
47 | PRG="$0"
48 | # Need this for relative symlinks.
49 | while [ -h "$PRG" ] ; do
50 | ls=`ls -ld "$PRG"`
51 | link=`expr "$ls" : '.*-> \(.*\)$'`
52 | if expr "$link" : '/.*' > /dev/null; then
53 | PRG="$link"
54 | else
55 | PRG=`dirname "$PRG"`"/$link"
56 | fi
57 | done
58 | SAVED="`pwd`"
59 | cd "`dirname \"$PRG\"`/" >/dev/null
60 | APP_HOME="`pwd -P`"
61 | cd "$SAVED" >/dev/null
62 |
63 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
64 |
65 | # Determine the Java command to use to start the JVM.
66 | if [ -n "$JAVA_HOME" ] ; then
67 | if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
68 | # IBM's JDK on AIX uses strange locations for the executables
69 | JAVACMD="$JAVA_HOME/jre/sh/java"
70 | else
71 | JAVACMD="$JAVA_HOME/bin/java"
72 | fi
73 | if [ ! -x "$JAVACMD" ] ; then
74 | die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
75 |
76 | Please set the JAVA_HOME variable in your environment to match the
77 | location of your Java installation."
78 | fi
79 | else
80 | JAVACMD="java"
81 | which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
82 |
83 | Please set the JAVA_HOME variable in your environment to match the
84 | location of your Java installation."
85 | fi
86 |
87 | # Increase the maximum file descriptors if we can.
88 | if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
89 | MAX_FD_LIMIT=`ulimit -H -n`
90 | if [ $? -eq 0 ] ; then
91 | if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
92 | MAX_FD="$MAX_FD_LIMIT"
93 | fi
94 | ulimit -n $MAX_FD
95 | if [ $? -ne 0 ] ; then
96 | warn "Could not set maximum file descriptor limit: $MAX_FD"
97 | fi
98 | else
99 | warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
100 | fi
101 | fi
102 |
103 | # For Darwin, add options to specify how the application appears in the dock
104 | if $darwin; then
105 | GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
106 | fi
107 |
108 | # For Cygwin, switch paths to Windows format before running java
109 | if $cygwin ; then
110 | APP_HOME=`cygpath --path --mixed "$APP_HOME"`
111 | CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
112 | JAVACMD=`cygpath --unix "$JAVACMD"`
113 |
114 | # We build the pattern for arguments to be converted via cygpath
115 | ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
116 | SEP=""
117 | for dir in $ROOTDIRSRAW ; do
118 | ROOTDIRS="$ROOTDIRS$SEP$dir"
119 | SEP="|"
120 | done
121 | OURCYGPATTERN="(^($ROOTDIRS))"
122 | # Add a user-defined pattern to the cygpath arguments
123 | if [ "$GRADLE_CYGPATTERN" != "" ] ; then
124 | OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
125 | fi
126 | # Now convert the arguments - kludge to limit ourselves to /bin/sh
127 | i=0
128 | for arg in "$@" ; do
129 | CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
130 | CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
131 |
132 | if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
133 | eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
134 | else
135 | eval `echo args$i`="\"$arg\""
136 | fi
137 | i=$((i+1))
138 | done
139 | case $i in
140 | (0) set -- ;;
141 | (1) set -- "$args0" ;;
142 | (2) set -- "$args0" "$args1" ;;
143 | (3) set -- "$args0" "$args1" "$args2" ;;
144 | (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
145 | (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
146 | (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
147 | (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
148 | (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
149 | (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
150 | esac
151 | fi
152 |
153 | # Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
154 | function splitJvmOpts() {
155 | JVM_OPTS=("$@")
156 | }
157 | eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
158 | JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
159 |
160 | exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
161 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | Apache License
2 | Version 2.0, January 2004
3 | http://www.apache.org/licenses/
4 |
5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
6 |
7 | 1. Definitions.
8 |
9 | "License" shall mean the terms and conditions for use, reproduction,
10 | and distribution as defined by Sections 1 through 9 of this document.
11 |
12 | "Licensor" shall mean the copyright owner or entity authorized by
13 | the copyright owner that is granting the License.
14 |
15 | "Legal Entity" shall mean the union of the acting entity and all
16 | other entities that control, are controlled by, or are under common
17 | control with that entity. For the purposes of this definition,
18 | "control" means (i) the power, direct or indirect, to cause the
19 | direction or management of such entity, whether by contract or
20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the
21 | outstanding shares, or (iii) beneficial ownership of such entity.
22 |
23 | "You" (or "Your") shall mean an individual or Legal Entity
24 | exercising permissions granted by this License.
25 |
26 | "Source" form shall mean the preferred form for making modifications,
27 | including but not limited to software source code, documentation
28 | source, and configuration files.
29 |
30 | "Object" form shall mean any form resulting from mechanical
31 | transformation or translation of a Source form, including but
32 | not limited to compiled object code, generated documentation,
33 | and conversions to other media types.
34 |
35 | "Work" shall mean the work of authorship, whether in Source or
36 | Object form, made available under the License, as indicated by a
37 | copyright notice that is included in or attached to the work
38 | (an example is provided in the Appendix below).
39 |
40 | "Derivative Works" shall mean any work, whether in Source or Object
41 | form, that is based on (or derived from) the Work and for which the
42 | editorial revisions, annotations, elaborations, or other modifications
43 | represent, as a whole, an original work of authorship. For the purposes
44 | of this License, Derivative Works shall not include works that remain
45 | separable from, or merely link (or bind by name) to the interfaces of,
46 | the Work and Derivative Works thereof.
47 |
48 | "Contribution" shall mean any work of authorship, including
49 | the original version of the Work and any modifications or additions
50 | to that Work or Derivative Works thereof, that is intentionally
51 | submitted to Licensor for inclusion in the Work by the copyright owner
52 | or by an individual or Legal Entity authorized to submit on behalf of
53 | the copyright owner. For the purposes of this definition, "submitted"
54 | means any form of electronic, verbal, or written communication sent
55 | to the Licensor or its representatives, including but not limited to
56 | communication on electronic mailing lists, source code control systems,
57 | and issue tracking systems that are managed by, or on behalf of, the
58 | Licensor for the purpose of discussing and improving the Work, but
59 | excluding communication that is conspicuously marked or otherwise
60 | designated in writing by the copyright owner as "Not a Contribution."
61 |
62 | "Contributor" shall mean Licensor and any individual or Legal Entity
63 | on behalf of whom a Contribution has been received by Licensor and
64 | subsequently incorporated within the Work.
65 |
66 | 2. Grant of Copyright License. Subject to the terms and conditions of
67 | this License, each Contributor hereby grants to You a perpetual,
68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
69 | copyright license to reproduce, prepare Derivative Works of,
70 | publicly display, publicly perform, sublicense, and distribute the
71 | Work and such Derivative Works in Source or Object form.
72 |
73 | 3. Grant of Patent License. Subject to the terms and conditions of
74 | this License, each Contributor hereby grants to You a perpetual,
75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
76 | (except as stated in this section) patent license to make, have made,
77 | use, offer to sell, sell, import, and otherwise transfer the Work,
78 | where such license applies only to those patent claims licensable
79 | by such Contributor that are necessarily infringed by their
80 | Contribution(s) alone or by combination of their Contribution(s)
81 | with the Work to which such Contribution(s) was submitted. If You
82 | institute patent litigation against any entity (including a
83 | cross-claim or counterclaim in a lawsuit) alleging that the Work
84 | or a Contribution incorporated within the Work constitutes direct
85 | or contributory patent infringement, then any patent licenses
86 | granted to You under this License for that Work shall terminate
87 | as of the date such litigation is filed.
88 |
89 | 4. Redistribution. You may reproduce and distribute copies of the
90 | Work or Derivative Works thereof in any medium, with or without
91 | modifications, and in Source or Object form, provided that You
92 | meet the following conditions:
93 |
94 | (a) You must give any other recipients of the Work or
95 | Derivative Works a copy of this License; and
96 |
97 | (b) You must cause any modified files to carry prominent notices
98 | stating that You changed the files; and
99 |
100 | (c) You must retain, in the Source form of any Derivative Works
101 | that You distribute, all copyright, patent, trademark, and
102 | attribution notices from the Source form of the Work,
103 | excluding those notices that do not pertain to any part of
104 | the Derivative Works; and
105 |
106 | (d) If the Work includes a "NOTICE" text file as part of its
107 | distribution, then any Derivative Works that You distribute must
108 | include a readable copy of the attribution notices contained
109 | within such NOTICE file, excluding those notices that do not
110 | pertain to any part of the Derivative Works, in at least one
111 | of the following places: within a NOTICE text file distributed
112 | as part of the Derivative Works; within the Source form or
113 | documentation, if provided along with the Derivative Works; or,
114 | within a display generated by the Derivative Works, if and
115 | wherever such third-party notices normally appear. The contents
116 | of the NOTICE file are for informational purposes only and
117 | do not modify the License. You may add Your own attribution
118 | notices within Derivative Works that You distribute, alongside
119 | or as an addendum to the NOTICE text from the Work, provided
120 | that such additional attribution notices cannot be construed
121 | as modifying the License.
122 |
123 | You may add Your own copyright statement to Your modifications and
124 | may provide additional or different license terms and conditions
125 | for use, reproduction, or distribution of Your modifications, or
126 | for any such Derivative Works as a whole, provided Your use,
127 | reproduction, and distribution of the Work otherwise complies with
128 | the conditions stated in this License.
129 |
130 | 5. Submission of Contributions. Unless You explicitly state otherwise,
131 | any Contribution intentionally submitted for inclusion in the Work
132 | by You to the Licensor shall be under the terms and conditions of
133 | this License, without any additional terms or conditions.
134 | Notwithstanding the above, nothing herein shall supersede or modify
135 | the terms of any separate license agreement you may have executed
136 | with Licensor regarding such Contributions.
137 |
138 | 6. Trademarks. This License does not grant permission to use the trade
139 | names, trademarks, service marks, or product names of the Licensor,
140 | except as required for reasonable and customary use in describing the
141 | origin of the Work and reproducing the content of the NOTICE file.
142 |
143 | 7. Disclaimer of Warranty. Unless required by applicable law or
144 | agreed to in writing, Licensor provides the Work (and each
145 | Contributor provides its Contributions) on an "AS IS" BASIS,
146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 | implied, including, without limitation, any warranties or conditions
148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 | PARTICULAR PURPOSE. You are solely responsible for determining the
150 | appropriateness of using or redistributing the Work and assume any
151 | risks associated with Your exercise of permissions under this License.
152 |
153 | 8. Limitation of Liability. In no event and under no legal theory,
154 | whether in tort (including negligence), contract, or otherwise,
155 | unless required by applicable law (such as deliberate and grossly
156 | negligent acts) or agreed to in writing, shall any Contributor be
157 | liable to You for damages, including any direct, indirect, special,
158 | incidental, or consequential damages of any character arising as a
159 | result of this License or out of the use or inability to use the
160 | Work (including but not limited to damages for loss of goodwill,
161 | work stoppage, computer failure or malfunction, or any and all
162 | other commercial damages or losses), even if such Contributor
163 | has been advised of the possibility of such damages.
164 |
165 | 9. Accepting Warranty or Additional Liability. While redistributing
166 | the Work or Derivative Works thereof, You may choose to offer,
167 | and charge a fee for, acceptance of support, warranty, indemnity,
168 | or other liability obligations and/or rights consistent with this
169 | License. However, in accepting such obligations, You may act only
170 | on Your own behalf and on Your sole responsibility, not on behalf
171 | of any other Contributor, and only if You agree to indemnify,
172 | defend, and hold each Contributor harmless for any liability
173 | incurred by, or claims asserted against, such Contributor by reason
174 | of your accepting any such warranty or additional liability.
175 |
176 | END OF TERMS AND CONDITIONS
177 |
178 | APPENDIX: How to apply the Apache License to your work.
179 |
180 | To apply the Apache License to your work, attach the following
181 | boilerplate notice, with the fields enclosed by brackets "{}"
182 | replaced with your own identifying information. (Don't include
183 | the brackets!) The text should be enclosed in the appropriate
184 | comment syntax for the file format. We also recommend that a
185 | file or class name and description of purpose be included on the
186 | same "printed page" as the copyright notice for easier
187 | identification within third-party archives.
188 |
189 | Copyright {yyyy} {name of copyright owner}
190 |
191 | Licensed under the Apache License, Version 2.0 (the "License");
192 | you may not use this file except in compliance with the License.
193 | You may obtain a copy of the License at
194 |
195 | http://www.apache.org/licenses/LICENSE-2.0
196 |
197 | Unless required by applicable law or agreed to in writing, software
198 | distributed under the License is distributed on an "AS IS" BASIS,
199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 | See the License for the specific language governing permissions and
201 | limitations under the License.
202 |
--------------------------------------------------------------------------------
/iconpack/src/main/java/com/sofaking/iconpack/IconPack.java:
--------------------------------------------------------------------------------
1 | package com.sofaking.iconpack;
2 |
3 | import android.content.ComponentName;
4 | import android.content.Context;
5 | import android.content.Intent;
6 | import android.content.pm.ApplicationInfo;
7 | import android.content.pm.PackageManager;
8 | import android.content.pm.ResolveInfo;
9 | import android.content.res.Resources;
10 | import android.graphics.Bitmap;
11 | import android.graphics.Canvas;
12 | import android.graphics.Paint;
13 | import android.graphics.PorterDuff;
14 | import android.graphics.PorterDuffXfermode;
15 | import android.graphics.drawable.BitmapDrawable;
16 | import android.graphics.drawable.Drawable;
17 | import android.os.Handler;
18 | import android.support.annotation.MainThread;
19 | import android.support.annotation.Nullable;
20 | import android.support.annotation.WorkerThread;
21 |
22 | import com.sofaking.iconpack.exceptions.AppFilterNotLoadedException;
23 | import com.sofaking.iconpack.exceptions.XMLNotFoundException;
24 | import com.sofaking.iconpack.utils.ResourceHelper;
25 | import com.sofaking.iconpack.utils.RoundsExecutor;
26 | import com.sofaking.iconpack.utils.XmlPullParserGenerator;
27 |
28 | import org.xmlpull.v1.XmlPullParser;
29 | import org.xmlpull.v1.XmlPullParserException;
30 |
31 | import java.io.IOException;
32 | import java.lang.ref.WeakReference;
33 | import java.util.ArrayList;
34 | import java.util.HashMap;
35 | import java.util.LinkedHashMap;
36 | import java.util.List;
37 | import java.util.Locale;
38 | import java.util.Random;
39 |
40 | /**
41 | * Created by nadavfima on 14/05/2017.
42 | */
43 |
44 | public class IconPack {
45 |
46 |
47 | private final Handler mHandler;
48 | private final String mPackageName;
49 | private final WeakReference mContextReference;
50 | private final PackageManager mPackageManager;
51 |
52 | private String mTitle;
53 | private Resources mPackResources;
54 | private IconMasking mIconMasking;
55 |
56 |
57 | private HashMap mAppFilterMap = new HashMap();
58 | private LinkedHashMap> mDrawableMap = new LinkedHashMap>();
59 |
60 | private boolean mAppFilterLoaded;
61 | private boolean mAppFilterLoading;
62 | private boolean mDrawableMapLoaded;
63 | private BitmapDrawable mTemporaryDrawable;
64 |
65 |
66 | public IconPack(Context context, String packageName, Handler handler) throws PackageManager.NameNotFoundException {
67 | super();
68 | mContextReference = new WeakReference(context);
69 | mPackageName = packageName;
70 | mPackageManager = context.getPackageManager();
71 | mHandler = handler;
72 |
73 |
74 | initIconPack();
75 |
76 | }
77 |
78 | /**
79 | * @return Icon Pack's title as a @{@link String}
80 | */
81 | public String getTitle() {
82 | return mTitle;
83 | }
84 |
85 | /**
86 | * Returns a @{@link Resources} object that contains the Icon Pack's resources (drawables and everything)
87 | *
88 | * You basically don't really need that.
89 | *
90 | * @return
91 | */
92 | public Resources getResources() {
93 | return mPackResources;
94 | }
95 |
96 |
97 | /**
98 | * Start parsing the AppFilter.XML file asynchronously.
99 | *
100 | * @param listener
101 | * @param initMasking
102 | */
103 | @MainThread
104 | public void initAppFilterAsync(final boolean initMasking, final AppFilterListener listener) {
105 |
106 |
107 | RoundsExecutor.execute(new Runnable() {
108 | @Override
109 | public void run() {
110 |
111 |
112 | initAppFilter(initMasking, listener);
113 |
114 |
115 | }
116 | });
117 |
118 |
119 | }
120 |
121 | /**
122 | * Start parsing the AppFilter.XML file synchronously.
123 | *
124 | * @param initMasking
125 | * @param listener
126 | */
127 | public void initAppFilter(boolean initMasking, final AppFilterListener listener) {
128 | mAppFilterLoading = true;
129 | try {
130 | final XmlPullParser parser = XmlPullParserGenerator.getXmlPullParser(mPackResources, mPackageName, Constants.FILE_APPFILTER);
131 |
132 | onLoadAppFilter(parser, initMasking);
133 |
134 | mAppFilterLoaded = true;
135 |
136 | mHandler.post(new Runnable() {
137 | @Override
138 | public void run() {
139 |
140 | if (listener != null)
141 | listener.onAppFilterLoaded();
142 | }
143 | });
144 | } catch (final Exception e) {
145 |
146 | e.printStackTrace();
147 |
148 | mHandler.post(new Runnable() {
149 | @Override
150 | public void run() {
151 | if (listener != null)
152 | listener.onLoadingFailed(e);
153 |
154 | }
155 | });
156 | }
157 |
158 | mAppFilterLoading = false;
159 | }
160 |
161 | /**
162 | * Start parsing the Drawable.XML file asynchronously.
163 | *
164 | * @param listener
165 | */
166 | @MainThread
167 | public void initDrawableMapAsync(final DrawableMapListener listener) {
168 |
169 |
170 | RoundsExecutor.execute(new Runnable() {
171 | @Override
172 | public void run() {
173 |
174 | initDrawableMap(listener);
175 |
176 | }
177 |
178 | });
179 |
180 |
181 | }
182 |
183 | private void initDrawableMap(final DrawableMapListener listener) {
184 | try {
185 | final XmlPullParser parser = getDrawableXmlPullParser();
186 |
187 | onLoadDrawableMap(parser);
188 |
189 | mDrawableMapLoaded = true;
190 |
191 | mHandler.post(new Runnable() {
192 | @Override
193 | public void run() {
194 |
195 |
196 | listener.onDrawableMapLoaded();
197 |
198 | }
199 | });
200 | } catch (final Exception e) {
201 |
202 | e.printStackTrace();
203 |
204 | mHandler.post(new Runnable() {
205 | @Override
206 | public void run() {
207 |
208 | listener.onLoadingFailed(e);
209 |
210 | }
211 | });
212 | }
213 | }
214 |
215 | /**
216 | * @return - @{@link XmlPullParser} of the drawable.xml from the icon pack
217 | * @throws XMLNotFoundException
218 | * @throws XmlPullParserException
219 | * @deprecated - This method is deprecated and will be removed soon
220 | */
221 | public XmlPullParser getDrawableXmlPullParser() throws XMLNotFoundException, XmlPullParserException {
222 | return XmlPullParserGenerator.getXmlPullParser(mPackResources, mPackageName, Constants.FILE_DRAWABLE);
223 | }
224 |
225 | /**
226 | * @param drawableName
227 | * @return - specific Drawable Icon, not necessarily found in the appfilter.xml
228 | */
229 | @WorkerThread
230 | public Drawable getDrawableIconForName(String drawableName) {
231 | return loadDrawable(drawableName);
232 | }
233 |
234 |
235 | /**
236 | * This method will first try to look up the icon in the AppFilterMap.
237 | * If no icon is found in the AppFilter, a masked icon will be generated for this app.
238 | *
239 | * @param context
240 | * @param componentName
241 | * @param maskFallback
242 | * @return
243 | */
244 | @Nullable
245 | @WorkerThread
246 | public Drawable getDefaultIconForPackage(Context context, ComponentName componentName, boolean maskFallback) {
247 |
248 | Intent intent = new Intent();
249 | intent.setComponent(componentName);
250 | List activites = context.getPackageManager().queryIntentActivities(intent, PackageManager.GET_META_DATA);
251 |
252 | if (activites.size() > 0) {
253 | return getDefaultIconForPackage(activites.get(0), maskFallback);
254 | } else {
255 | return null;
256 | }
257 |
258 | }
259 |
260 | /**
261 | * This method will first try to look up the icon in the AppFilterMap.
262 | * If no icon is found in the AppFilter, a masked icon will be generated for this app.
263 | *
264 | * @param info
265 | * @param maskFallback
266 | * @return
267 | */
268 | @WorkerThread
269 | public Drawable getDefaultIconForPackage(ResolveInfo info, boolean maskFallback) {
270 |
271 | if (!mAppFilterLoaded) {
272 | throw new AppFilterNotLoadedException();
273 | }
274 |
275 | String appPackageName = info.activityInfo.packageName;
276 |
277 | PackageManager pm = mContextReference.get().getPackageManager();
278 |
279 | Drawable defaultIcon = info.loadIcon(pm);
280 |
281 | Intent launchIntent = pm.getLaunchIntentForPackage(appPackageName);
282 |
283 | String componentName = null;
284 |
285 | if (launchIntent != null) {
286 | componentName = pm.getLaunchIntentForPackage(appPackageName).getComponent().toString();
287 | }
288 |
289 | String drawableName = mAppFilterMap.get(componentName);
290 |
291 | if (drawableName != null) {
292 |
293 | // found in app filter
294 |
295 | Drawable drawable = loadDrawable(drawableName);
296 |
297 | if (drawable == null) {
298 | return maskFallback ? generateMaskedIcon(defaultIcon) : defaultIcon;
299 | } else {
300 | return drawable;
301 | }
302 |
303 | } else {
304 |
305 | // not found
306 |
307 | // try to get a resource with the component filename
308 | if (componentName != null) {
309 | int start = componentName.indexOf("{") + 1;
310 | int end = componentName.indexOf("}", start);
311 | if (end > start) {
312 | drawableName = componentName.substring(start, end).toLowerCase(Locale.getDefault()).replace(".", "_").replace("/", "_");
313 |
314 | if (ResourceHelper.getDrawableResourceId(mPackResources, drawableName, mPackageName) > 0)
315 | return loadDrawable(drawableName);
316 | }
317 | }
318 | }
319 |
320 | return (maskFallback && mIconMasking != null) ? generateMaskedIcon(defaultIcon) : defaultIcon;
321 | }
322 |
323 |
324 | @MainThread
325 | private void initIconPack() throws PackageManager.NameNotFoundException {
326 |
327 |
328 | ApplicationInfo ai = mPackageManager.getApplicationInfo(mPackageName, PackageManager.GET_META_DATA);
329 |
330 | mTitle = mPackageManager.getApplicationLabel(ai).toString();
331 |
332 | mPackResources = mPackageManager.getResourcesForApplication(mPackageName);
333 |
334 |
335 | }
336 |
337 | @WorkerThread
338 | private void onLoadDrawableMap(XmlPullParser parser) {
339 |
340 | try {
341 |
342 | int eventType = parser.getEventType();
343 | String currentTitle = "";
344 |
345 | while (eventType != XmlPullParser.END_DOCUMENT) {
346 | if (eventType == XmlPullParser.START_TAG) {
347 | if (parser.getName().equals("category")) {
348 |
349 | currentTitle = onAddCategoryToMap(parser.getAttributeValue(null, "title"));
350 |
351 | } else if (parser.getName().equals("item")) {
352 |
353 | String name = parser.getAttributeValue(null, Constants.DRAWABLE);
354 |
355 | onAddIconToCategory(currentTitle, name);
356 | }
357 | }
358 |
359 | eventType = parser.next();
360 | }
361 | } catch (XmlPullParserException e) {
362 | e.printStackTrace();
363 | } catch (IOException e) {
364 | e.printStackTrace();
365 | }
366 |
367 |
368 | }
369 |
370 | @WorkerThread
371 | private void onAddIconToCategory(String currentTitle, String name) {
372 | int id = ResourceHelper.getDrawableResourceId(mPackResources, name, mPackageName);
373 |
374 | if (id > 0) {
375 |
376 | IconDrawable icon = new IconDrawable(name, id);
377 | icon.setTitle(IconDrawable.replaceName(mContextReference.get(), true, icon.getDrawableName()));
378 | mDrawableMap.get(currentTitle).add(icon);
379 |
380 | }
381 | }
382 |
383 | @WorkerThread
384 | private String onAddCategoryToMap(String title) {
385 |
386 | if (title != null && title.length() > 0) {
387 |
388 | mDrawableMap.put(title, new ArrayList());
389 | return title;
390 |
391 | }
392 | return "";
393 | }
394 |
395 | @WorkerThread
396 | private void onLoadAppFilter(XmlPullParser parser, boolean initMasking) {
397 | try {
398 | if (parser != null) {
399 | int eventType = parser.getEventType();
400 | while (eventType != XmlPullParser.END_DOCUMENT) {
401 | if (eventType == XmlPullParser.START_TAG) {
402 |
403 | if (initMasking) {
404 | onLoadMask(parser);
405 | }
406 |
407 | if (parser.getName().equals(Constants.ITEM)) {
408 | onLoadAppFilter(parser);
409 | }
410 | }
411 | eventType = parser.next();
412 | }
413 | }
414 | } catch (XmlPullParserException e) {
415 | e.printStackTrace();
416 | } catch (IOException e) {
417 | e.printStackTrace();
418 | }
419 | }
420 |
421 | @WorkerThread
422 | private void onLoadAppFilter(XmlPullParser parser) {
423 | String componentName = null;
424 | String drawableName = null;
425 |
426 | for (int i = 0; i < parser.getAttributeCount(); i++) {
427 | if (parser.getAttributeName(i).equals(Constants.COMPONENT)) {
428 | componentName = parser.getAttributeValue(i);
429 | } else if (parser.getAttributeName(i).equals(Constants.DRAWABLE)) {
430 | drawableName = parser.getAttributeValue(i);
431 | }
432 | }
433 | if (!mAppFilterMap.containsKey(componentName)) {
434 | mAppFilterMap.put(componentName, drawableName);
435 | }
436 | }
437 |
438 | @WorkerThread
439 | private void onLoadMask(XmlPullParser parser) {
440 | if (parser.getName().equals(Constants.BACKGROUND)) {
441 |
442 |
443 | for (int i = 0; i < parser.getAttributeCount(); i++) {
444 | if (parser.getAttributeName(i).startsWith(Constants.BACKGROUND_IMG)) {
445 | String drawableName = parser.getAttributeValue(i);
446 | mTemporaryDrawable = loadDrawable(drawableName);
447 | if (mTemporaryDrawable != null) {
448 | Bitmap iconback = mTemporaryDrawable.getBitmap();
449 | if (iconback != null) {
450 |
451 | if (mIconMasking == null) {
452 | mIconMasking = new IconMasking();
453 | }
454 |
455 | mIconMasking.addBackgroundBitmap(iconback);
456 | }
457 | }
458 |
459 | }
460 | }
461 | } else if (parser.getName().equals(Constants.MASK)) {
462 | if (parser.getAttributeCount() > 0 && parser.getAttributeName(0).equals(Constants.IMG_1_VALUE)) {
463 | String drawableName = parser.getAttributeValue(0);
464 |
465 | if (mIconMasking == null) {
466 | mIconMasking = new IconMasking();
467 | }
468 | mTemporaryDrawable = loadDrawable(drawableName);
469 | if (mTemporaryDrawable != null) {
470 | mIconMasking.setMaskBitmap(mTemporaryDrawable.getBitmap());
471 | }
472 |
473 | }
474 | } else if (parser.getName().equals(Constants.FRONT)) {
475 | if (parser.getAttributeCount() > 0 && parser.getAttributeName(0).equals(Constants.IMG_1_VALUE)) {
476 | String drawableName = parser.getAttributeValue(0);
477 |
478 | if (mIconMasking == null) {
479 | mIconMasking = new IconMasking();
480 | }
481 |
482 | mTemporaryDrawable = loadDrawable(drawableName);
483 |
484 | if (mTemporaryDrawable != null) {
485 | mIconMasking.setFrontBitmap(mTemporaryDrawable.getBitmap());
486 | }
487 | }
488 | } else if (parser.getName().equals(Constants.SCALE)) {
489 | // mFactor
490 | if (parser.getAttributeCount() > 0 && parser.getAttributeName(0).equals(Constants.FACTOR)) {
491 |
492 | if (mIconMasking == null) {
493 | mIconMasking = new IconMasking();
494 | }
495 |
496 | float factor = IconMasking.DEFAULT_FACTOR;
497 |
498 | try {
499 | factor = Float.parseFloat(parser.getAttributeValue(0));
500 | } catch (NumberFormatException e) {
501 | e.printStackTrace();
502 | }
503 |
504 | mIconMasking.setFactor(factor);
505 |
506 | }
507 | }
508 | }
509 |
510 | @WorkerThread
511 | private BitmapDrawable loadDrawable(String drawableName) {
512 | try {
513 |
514 | int id = ResourceHelper.getDrawableResourceId(mPackResources, drawableName, mPackageName);
515 |
516 | if (id > 0) {
517 | Drawable drawable = null;
518 | if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
519 | drawable = mPackResources.getDrawable(id, mContextReference.get().getTheme());
520 | } else {
521 | drawable = mPackResources.getDrawable(id);
522 | }
523 |
524 | return (BitmapDrawable) drawable;
525 | }
526 | } catch (Exception e) {
527 | e.printStackTrace();
528 | }
529 | return null;
530 | }
531 |
532 |
533 | @WorkerThread
534 | private Drawable generateMaskedIcon(Drawable defaultIcon) {
535 |
536 | Bitmap defaultBitmap = ((BitmapDrawable) defaultIcon).getBitmap();
537 |
538 | // if no support images in the icon pack return the bitmap itself
539 | List backgroundImages = mIconMasking.getBackgroundImages();
540 |
541 | if (backgroundImages.size() == 0) return defaultIcon;
542 |
543 | Random r = new Random();
544 | int backImageInd = r.nextInt(backgroundImages.size());
545 | Bitmap backImage = backgroundImages.get(backImageInd);
546 | int w = backImage.getWidth();
547 | int h = backImage.getHeight();
548 |
549 | // create a bitmap for the result
550 | Bitmap result = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
551 | Canvas canvas = new Canvas(result);
552 |
553 | // draw the background first
554 | canvas.drawBitmap(backImage, 0, 0, null);
555 |
556 | // create a mutable mask bitmap with the same mask
557 | Bitmap scaledBitmap;
558 | if (defaultBitmap.getWidth() > w || defaultBitmap.getHeight() > h) {
559 |
560 | float factor = mIconMasking.getFactor();
561 |
562 | scaledBitmap = Bitmap.createScaledBitmap(defaultBitmap, (int) (w * factor), (int) (h * factor), false);
563 | } else {
564 | scaledBitmap = Bitmap.createBitmap(defaultBitmap);
565 | }
566 |
567 | if (mIconMasking.mMaskImage != null) {
568 | // draw the scaled bitmap with mask
569 | Bitmap mutableMask = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
570 | Canvas maskCanvas = new Canvas(mutableMask);
571 | maskCanvas.drawBitmap(mIconMasking.mMaskImage, 0, 0, new Paint());
572 |
573 | // paint the bitmap with mask into the result
574 | Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
575 | paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_OUT));
576 | canvas.drawBitmap(scaledBitmap, (w - scaledBitmap.getWidth()) / 2, (h - scaledBitmap.getHeight()) / 2, null);
577 | canvas.drawBitmap(mutableMask, 0, 0, paint);
578 | paint.setXfermode(null);
579 | } else {
580 | // draw the scaled bitmap with the back image as mask
581 | Bitmap mutableMask = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
582 | Canvas maskCanvas = new Canvas(mutableMask);
583 | maskCanvas.drawBitmap(backImage, 0, 0, new Paint());
584 |
585 | // paint the bitmap with mask into the result
586 | Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
587 | paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
588 | canvas.drawBitmap(scaledBitmap, (w - scaledBitmap.getWidth()) / 2, (h - scaledBitmap.getHeight()) / 2, null);
589 | canvas.drawBitmap(mutableMask, 0, 0, paint);
590 | paint.setXfermode(null);
591 |
592 | }
593 |
594 | if (mIconMasking.mFrontImage != null) {
595 | // paint the front
596 | canvas.drawBitmap(mIconMasking.mFrontImage, 0, 0, null);
597 | }
598 |
599 |
600 | return new BitmapDrawable(mPackResources, result);
601 | }
602 |
603 | public String getPackageName() {
604 | return mPackageName;
605 | }
606 |
607 | public boolean isAppFilterLoaded() {
608 | return mAppFilterLoaded;
609 | }
610 |
611 | public boolean isLoadingAppFilter() {
612 | return mAppFilterLoading;
613 | }
614 |
615 |
616 | public interface AppFilterListener {
617 |
618 | void onAppFilterLoaded();
619 |
620 | void onLoadingFailed(Exception e);
621 | }
622 |
623 | public interface DrawableMapListener {
624 |
625 | void onDrawableMapLoaded();
626 |
627 | void onLoadingFailed(Exception e);
628 | }
629 | }
630 |
--------------------------------------------------------------------------------