", "\n");
47 | }
48 |
49 | // convert BR tags to line breaks
50 | if (str.contains("", "\n");
52 | }
53 |
54 | // use regex to strip tags, then convert entities in the result
55 | return trimStart(StringEscapeUtils.unescapeHtml4(str.replaceAll("<(.|\n)*?>", "")));
56 | }
57 |
58 | /*
59 | * Same as apache.commons.lang.StringUtils.stripStart() but also removes non-breaking
60 | * space (160) chars
61 | */
62 | private static String trimStart(final String str) {
63 | int strLen;
64 | if (str == null || (strLen = str.length()) == 0) {
65 | return "";
66 | }
67 | int start = 0;
68 | while (start != strLen && (Character.isWhitespace(str.charAt(start)) || str.charAt(start) == 160)) {
69 | start++;
70 | }
71 | return str.substring(start);
72 | }
73 |
74 | /**
75 | * Converts an R.color.xxx resource to an HTML hex color
76 | * @param context Android Context
77 | * @param resId Android R.color.xxx
78 | * @return A String HTML hex color code
79 | */
80 | public static String colorResToHtmlColor(Context context, int resId) {
81 | try {
82 | return String.format("#%06X", 0xFFFFFF & context.getResources().getColor(resId));
83 | } catch (Resources.NotFoundException e) {
84 | return "#000000";
85 | }
86 | }
87 |
88 | /**
89 | * Remove {@code } blocks from the passed string - added to project after noticing
90 | * comments on posts that use the "Sociable" plugin ( http://wordpress.org/plugins/sociable/ )
91 | * may have a script block which contains {@code } followed by a CDATA section followed by {@code ,}
92 | * all of which will show up if we don't strip it here.
93 | * @see Wordpress Sociable Plugin
94 | * @return String without {@code }, {@code } blocks followed by a CDATA section
95 | * followed by {@code ,}
96 | * @param text String containing script tags
97 | */
98 | public static String stripScript(final String text) {
99 | if (text == null) {
100 | return null;
101 | }
102 |
103 | StringBuilder sb = new StringBuilder(text);
104 | int start = sb.indexOf(" -1) {
107 | int end = sb.indexOf("", start);
108 | if (end == -1) {
109 | return sb.toString();
110 | }
111 | sb.delete(start, end + 9);
112 | start = sb.indexOf("}, {@code }, {@code }
120 | * tags and replacing EmoticonsUtils with Emojis
121 | * @param source
122 | * @param imageGetter
123 | */
124 | public static SpannableStringBuilder fromHtml(String source, ImageGetter imageGetter) {
125 | source = replaceListTagsWithCustomTags(source);
126 | SpannableStringBuilder html;
127 | try {
128 | html = (SpannableStringBuilder) Html.fromHtml(source, imageGetter, new WPHtmlTagHandler());
129 | } catch (RuntimeException runtimeException) {
130 | // In case our tag handler fails
131 | try {
132 | html = (SpannableStringBuilder) Html.fromHtml(source, imageGetter, null);
133 | } catch (IllegalArgumentException illegalArgumentException) {
134 | // In case the html is missing a required parameter (for example: "src" missing from img)
135 | html = new SpannableStringBuilder("");
136 | AppLog.w(UTILS, "Could not parse html");
137 | }
138 | }
139 |
140 | EmoticonsUtils.replaceEmoticonsWithEmoji(html);
141 | QuoteSpan[] spans = html.getSpans(0, html.length(), QuoteSpan.class);
142 | for (QuoteSpan span : spans) {
143 | html.setSpan(new WPQuoteSpan(), html.getSpanStart(span), html.getSpanEnd(span), html.getSpanFlags(span));
144 | html.setSpan(new ForegroundColorSpan(0xFF666666), html.getSpanStart(span), html.getSpanEnd(span),
145 | html.getSpanFlags(span));
146 | html.removeSpan(span);
147 | }
148 | return html;
149 | }
150 |
151 | private static String replaceListTagsWithCustomTags(String source) {
152 | return source.replace("", "")
154 | .replace("", "")
156 | .replace("", "");
158 | }
159 |
160 | public static Spanned fromHtml(String source) {
161 | return fromHtml(source, null);
162 | }
163 | }
164 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/LanguageUtils.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util;
2 |
3 | import android.content.Context;
4 |
5 | import androidx.annotation.Nullable;
6 |
7 | import java.util.Locale;
8 |
9 | /**
10 | * Methods for dealing with i18n messages
11 | */
12 | public class LanguageUtils {
13 | /**
14 | * @deprecated Use {@link #getCurrentDeviceLanguage()}. As of API 25, setting the locale by updating the
15 | * configuration on the resources object was deprecated, so this method stopped working for newer versions
16 | * of Android. The current active locale should always be set in {@link Locale#getDefault()}. When manually
17 | * setting the active locale, the developer should set it in {@link Locale#setDefault(Locale)}.
18 | */
19 | @SuppressWarnings("DeprecatedIsStillUsed")
20 | @Deprecated
21 | public static Locale getCurrentDeviceLanguage(@Nullable Context context) {
22 | return getCurrentDeviceLanguage();
23 | }
24 |
25 | @SuppressWarnings("WeakerAccess")
26 | public static Locale getCurrentDeviceLanguage() {
27 | return Locale.getDefault();
28 | }
29 |
30 | /**
31 | * @deprecated Use {@link #getCurrentDeviceLanguageCode()}.
32 | */
33 | @SuppressWarnings("WeakerAccess,DeprecatedIsStillUsed")
34 | @Deprecated
35 | public static String getCurrentDeviceLanguageCode(@Nullable Context context) {
36 | return getCurrentDeviceLanguageCode();
37 | }
38 |
39 | @SuppressWarnings("WeakerAccess")
40 | public static String getCurrentDeviceLanguageCode() {
41 | return getCurrentDeviceLanguage().toString();
42 | }
43 |
44 | public static String getPatchedCurrentDeviceLanguage(Context context) {
45 | return patchDeviceLanguageCode(getCurrentDeviceLanguageCode(context));
46 | }
47 |
48 | /**
49 | * Patches a deviceLanguageCode if any of deprecated values iw, id, or yi
50 | */
51 | @SuppressWarnings("WeakerAccess")
52 | public static String patchDeviceLanguageCode(String deviceLanguageCode) {
53 | String patchedCode = deviceLanguageCode;
54 | /*
55 | Note that Java uses several deprecated two-letter codes. The Hebrew ("he") language
56 | * code is rewritten as "iw", Indonesian ("id") as "in", and Yiddish ("yi") as "ji". This
57 | * rewriting happens even if you construct your own {@code Locale} object, not just for
58 | * instances returned by the various lookup methods.
59 | */
60 | if (deviceLanguageCode != null) {
61 | if (deviceLanguageCode.startsWith("iw")) {
62 | patchedCode = deviceLanguageCode.replace("iw", "he");
63 | } else if (deviceLanguageCode.startsWith("in")) {
64 | patchedCode = deviceLanguageCode.replace("in", "id");
65 | } else if (deviceLanguageCode.startsWith("ji")) {
66 | patchedCode = deviceLanguageCode.replace("ji", "yi");
67 | }
68 | }
69 |
70 | return patchedCode;
71 | }
72 | }
73 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/ListUtils.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util;
2 |
3 | import androidx.annotation.Nullable;
4 |
5 | import org.apache.commons.lang3.ArrayUtils;
6 |
7 | import java.util.ArrayList;
8 | import java.util.Arrays;
9 | import java.util.List;
10 |
11 | public class ListUtils {
12 | @Nullable
13 | public static ArrayList fromLongArray(long[] array) {
14 | if (array == null) {
15 | return null;
16 | }
17 | Long[] longObjects = ArrayUtils.toObject(array);
18 | return new ArrayList<>(Arrays.asList(longObjects));
19 | }
20 |
21 | @Nullable
22 | public static long[] toLongArray(List list) {
23 | if (list == null) {
24 | return null;
25 | }
26 | Long[] array = list.toArray(new Long[list.size()]);
27 | return ArrayUtils.toPrimitive(array);
28 | }
29 |
30 | @Nullable
31 | public static ArrayList fromIntArray(int[] array) {
32 | if (array == null) {
33 | return null;
34 | }
35 | Integer[] intObjects = ArrayUtils.toObject(array);
36 | return new ArrayList<>(Arrays.asList(intObjects));
37 | }
38 |
39 | @Nullable
40 | public static int[] toIntArray(List list) {
41 | if (list == null) {
42 | return null;
43 | }
44 | Integer[] array = list.toArray(new Integer[list.size()]);
45 | return ArrayUtils.toPrimitive(array);
46 | }
47 | }
48 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/MapUtils.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util;
2 |
3 | import java.util.Date;
4 | import java.util.Map;
5 |
6 | /**
7 | * wrappers for extracting values from a Map object
8 | */
9 | public class MapUtils {
10 | /*
11 | * returns a String value for the passed key in the passed map
12 | * always returns "" instead of null
13 | */
14 | public static String getMapStr(final Map map, final String key) {
15 | if (map == null || key == null || !map.containsKey(key) || map.get(key) == null) {
16 | return "";
17 | }
18 | return map.get(key).toString();
19 | }
20 |
21 | /*
22 | * returns an int value for the passed key in the passed map
23 | * defaultValue is returned if key doesn't exist or isn't a number
24 | */
25 | public static int getMapInt(final Map map, final String key) {
26 | return getMapInt(map, key, 0);
27 | }
28 |
29 | public static int getMapInt(final Map map, final String key, int defaultValue) {
30 | try {
31 | return Integer.parseInt(getMapStr(map, key));
32 | } catch (NumberFormatException e) {
33 | return defaultValue;
34 | }
35 | }
36 |
37 | /*
38 | * long version of above
39 | */
40 | public static long getMapLong(final Map map, final String key) {
41 | return getMapLong(map, key, 0);
42 | }
43 |
44 | public static long getMapLong(final Map map, final String key, long defaultValue) {
45 | try {
46 | return Long.parseLong(getMapStr(map, key));
47 | } catch (NumberFormatException e) {
48 | return defaultValue;
49 | }
50 | }
51 |
52 | /*
53 | * float version of above
54 | */
55 | public static float getMapFloat(final Map map, final String key) {
56 | return getMapFloat(map, key, 0);
57 | }
58 |
59 | public static float getMapFloat(final Map map, final String key, float defaultValue) {
60 | try {
61 | return Float.parseFloat(getMapStr(map, key));
62 | } catch (NumberFormatException e) {
63 | return defaultValue;
64 | }
65 | }
66 |
67 | /*
68 | * double version of above
69 | */
70 | public static double getMapDouble(final Map map, final String key) {
71 | return getMapDouble(map, key, 0);
72 | }
73 |
74 | public static double getMapDouble(final Map map, final String key, double defaultValue) {
75 | try {
76 | return Double.parseDouble(getMapStr(map, key));
77 | } catch (NumberFormatException e) {
78 | return defaultValue;
79 | }
80 | }
81 |
82 | /*
83 | * returns a date object from the passed key in the passed map
84 | * returns null if key doesn't exist or isn't a date
85 | */
86 | public static Date getMapDate(final Map map, final String key) {
87 | if (map == null || key == null || !map.containsKey(key)) {
88 | return null;
89 | }
90 | try {
91 | return (Date) map.get(key);
92 | } catch (ClassCastException e) {
93 | return null;
94 | }
95 | }
96 |
97 | /*
98 | * returns a boolean value from the passed key in the passed map
99 | * returns true unless key doesn't exist, or the value is "0" or "false"
100 | */
101 | public static boolean getMapBool(final Map map, final String key) {
102 | String value = getMapStr(map, key);
103 | if (value.isEmpty()) {
104 | return false;
105 | }
106 | if (value.startsWith("0")) { // handles "0" and "0.0"
107 | return false;
108 | }
109 | if (value.equalsIgnoreCase("false")) {
110 | return false;
111 | }
112 | // all other values are assume to be true
113 | return true;
114 | }
115 | }
116 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/NetworkUtils.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util;
2 |
3 | import android.annotation.SuppressLint;
4 | import android.content.Context;
5 | import android.net.ConnectivityManager;
6 | import android.net.NetworkInfo;
7 | import android.provider.Settings;
8 |
9 | /**
10 | * requires android.permission.ACCESS_NETWORK_STATE
11 | */
12 | @SuppressLint("MissingPermission")
13 | public class NetworkUtils {
14 | public static final int TYPE_UNKNOWN = -1;
15 |
16 | /**
17 | * returns information on the active network connection
18 | */
19 | @SuppressLint("MissingPermission")
20 | public static NetworkInfo getActiveNetworkInfo(Context context) {
21 | if (context == null) {
22 | return null;
23 | }
24 | ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
25 | if (cm == null) {
26 | return null;
27 | }
28 | // note that this may return null if no network is currently active
29 | return cm.getActiveNetworkInfo();
30 | }
31 |
32 | /**
33 | * returns the ConnectivityManager.TYPE_xxx if there's an active connection, otherwise
34 | * returns TYPE_UNKNOWN
35 | */
36 | private static int getActiveNetworkType(Context context) {
37 | NetworkInfo info = getActiveNetworkInfo(context);
38 | if (info == null || !info.isConnected()) {
39 | return TYPE_UNKNOWN;
40 | }
41 | return info.getType();
42 | }
43 |
44 | /**
45 | * returns true if a network connection is available
46 | */
47 | public static boolean isNetworkAvailable(Context context) {
48 | NetworkInfo info = getActiveNetworkInfo(context);
49 | return (info != null && info.isConnected());
50 | }
51 |
52 | /**
53 | * returns true if the user is connected to WiFi
54 | */
55 | public static boolean isWiFiConnected(Context context) {
56 | return (getActiveNetworkType(context) == ConnectivityManager.TYPE_WIFI);
57 | }
58 |
59 | /**
60 | * returns true if the user is connected with the mobile data connection
61 | */
62 | public static boolean isMobileConnected(Context context) {
63 | int networkType = getActiveNetworkType(context);
64 | return (networkType == ConnectivityManager.TYPE_MOBILE
65 | || networkType == ConnectivityManager.TYPE_MOBILE_DUN);
66 | }
67 |
68 | /**
69 | * returns true if airplane mode has been enabled
70 | */
71 | @SuppressWarnings("deprecation")
72 | public static boolean isAirplaneModeOn(Context context) {
73 | // prior to JellyBean 4.2 this was Settings.System.AIRPLANE_MODE_ON, JellyBean 4.2
74 | // moved it to Settings.Global
75 | return Settings.Global.getInt(context.getContentResolver(), Settings.Global.AIRPLANE_MODE_ON, 0) != 0;
76 | }
77 |
78 | /**
79 | * returns true if there's an active network connection, otherwise displays a toast error
80 | * and returns false
81 | */
82 | public static boolean checkConnection(Context context) {
83 | if (context == null) {
84 | return false;
85 | }
86 | if (isNetworkAvailable(context)) {
87 | return true;
88 | }
89 | ToastUtils.showToast(context, R.string.no_network_message);
90 | return false;
91 | }
92 | }
93 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/PackageUtils.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util;
2 |
3 | import android.content.Context;
4 | import android.content.pm.PackageInfo;
5 | import android.content.pm.PackageManager;
6 |
7 | public class PackageUtils {
8 | /**
9 | * Return true if Debug build. false otherwise.
10 | */
11 | public static boolean isDebugBuild() {
12 | return BuildConfig.DEBUG;
13 | }
14 |
15 | public static PackageInfo getPackageInfo(Context context) {
16 | try {
17 | PackageManager manager = context.getPackageManager();
18 | return manager.getPackageInfo(context.getPackageName(), 0);
19 | } catch (PackageManager.NameNotFoundException e) {
20 | return null;
21 | }
22 | }
23 |
24 | /**
25 | * Return version code, or 0 if it can't be read
26 | */
27 | public static int getVersionCode(Context context) {
28 | PackageInfo packageInfo = getPackageInfo(context);
29 | if (packageInfo != null) {
30 | return packageInfo.versionCode;
31 | }
32 | return 0;
33 | }
34 |
35 | /**
36 | * Return version name, or the string "0" if it can't be read
37 | */
38 | public static String getVersionName(Context context) {
39 | PackageInfo packageInfo = getPackageInfo(context);
40 | if (packageInfo != null) {
41 | return packageInfo.versionName;
42 | }
43 | return "0";
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/PermissionUtils.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util;
2 |
3 | import android.Manifest.permission;
4 | import android.app.Activity;
5 | import android.content.Context;
6 | import android.content.pm.PackageManager;
7 | import android.os.Build;
8 |
9 | import androidx.core.app.ActivityCompat;
10 | import androidx.core.content.ContextCompat;
11 | import androidx.fragment.app.Fragment;
12 |
13 | import java.util.ArrayList;
14 | import java.util.List;
15 |
16 | public class PermissionUtils {
17 | /**
18 | * Check for permissions, request them if they're not granted.
19 | *
20 | * @return true if permissions are already granted, else request them and return false.
21 | */
22 | public static boolean checkAndRequestPermissions(Activity activity, int requestCode, String[] permissionList) {
23 | List toRequest = new ArrayList<>();
24 | for (String permission : permissionList) {
25 | if (ContextCompat.checkSelfPermission(activity, permission) != PackageManager.PERMISSION_GRANTED) {
26 | toRequest.add(permission);
27 | }
28 | }
29 | if (toRequest.size() > 0) {
30 | String[] requestedPermissions = toRequest.toArray(new String[toRequest.size()]);
31 | ActivityCompat.requestPermissions(activity, requestedPermissions, requestCode);
32 | return false;
33 | }
34 | return true;
35 | }
36 |
37 | /**
38 | * Check for permissions, request them if they're not granted.
39 | *
40 | * @return true if permissions are already granted, else request them and return false.
41 | */
42 | private static boolean checkAndRequestPermissions(Fragment fragment, int requestCode, String[] permissionList) {
43 | List toRequest = new ArrayList<>();
44 | for (String permission : permissionList) {
45 | Context context = fragment.getActivity();
46 | if (context != null && ContextCompat.checkSelfPermission(context, permission) != PackageManager
47 | .PERMISSION_GRANTED) {
48 | toRequest.add(permission);
49 | }
50 | }
51 | if (toRequest.size() > 0) {
52 | String[] requestedPermissions = toRequest.toArray(new String[toRequest.size()]);
53 | fragment.requestPermissions(requestedPermissions, requestCode);
54 | return false;
55 | }
56 | return true;
57 | }
58 |
59 | /**
60 | * Check for permissions without requesting them
61 | *
62 | * @return true if all permissions are granted
63 | */
64 | public static boolean checkPermissions(Context context, String[] permissionList) {
65 | for (String permission : permissionList) {
66 | if (ContextCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) {
67 | return false;
68 | }
69 | }
70 | return true;
71 | }
72 |
73 | /**
74 | * Check for permissions without requesting them
75 | *
76 | * @return true if all permissions are granted
77 | */
78 | public static boolean checkPermissions(Activity activity, String[] permissionList) {
79 | return checkPermissions((Context) activity, permissionList);
80 | }
81 |
82 | public static boolean checkCameraAndStoragePermissions(Context context) {
83 | return checkPermissions(context, getCameraAndStoragePermissions());
84 | }
85 |
86 | public static boolean checkCameraAndStoragePermissions(Activity activity) {
87 | return checkPermissions(activity, getCameraAndStoragePermissions());
88 | }
89 |
90 | public static boolean checkNotificationsPermission(Activity activity) {
91 | if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
92 | return checkPermissions(activity, new String[]{permission.POST_NOTIFICATIONS});
93 | } else {
94 | return true;
95 | }
96 | }
97 |
98 | public static boolean checkAndRequestCameraAndStoragePermissions(Fragment fragment, int requestCode) {
99 | return checkAndRequestPermissions(fragment, requestCode, getCameraAndStoragePermissions());
100 | }
101 |
102 | public static boolean checkAndRequestCameraAndStoragePermissions(Activity activity, int requestCode) {
103 | return checkAndRequestPermissions(activity, requestCode, getCameraAndStoragePermissions());
104 | }
105 |
106 | public static boolean checkAndRequestFileDownloadPermission(Fragment fragment, int requestCode) {
107 | return checkAndRequestPermissions(fragment, requestCode, getFileDownloadPermission());
108 | }
109 |
110 | public static String[] getCameraAndStoragePermissions() {
111 | if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
112 | return new String[]{permission.CAMERA};
113 | } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
114 | return new String[]{permission.CAMERA, permission.READ_EXTERNAL_STORAGE};
115 | } else {
116 | return new String[]{permission.CAMERA, permission.WRITE_EXTERNAL_STORAGE, permission.READ_EXTERNAL_STORAGE};
117 | }
118 | }
119 |
120 | /**
121 | * Starting from Android Q (SDK 29), the WRITE_EXTERNAL_STORAGE permission is not needed anymore for downloading
122 | * files when using DownloadManager.Request#setDestinationInExternalPublicDir.
123 | */
124 | private static String[] getFileDownloadPermission() {
125 | if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
126 | return new String[]{};
127 | } else {
128 | return new String[]{permission.READ_EXTERNAL_STORAGE, permission.WRITE_EXTERNAL_STORAGE};
129 | }
130 | }
131 | }
132 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/PhotonUtils.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util;
2 |
3 | import android.text.TextUtils;
4 |
5 | import java.net.MalformedURLException;
6 | import java.net.URL;
7 |
8 | /**
9 | * routines related to the Photon API
10 | * http://developer.wordpress.com/docs/photon/
11 | */
12 | public class PhotonUtils {
13 | private PhotonUtils() {
14 | throw new AssertionError();
15 | }
16 |
17 | /*
18 | * returns true if the passed url is an obvious "mshots" url
19 | */
20 | public static boolean isMshotsUrl(final String imageUrl) {
21 | return (imageUrl != null && imageUrl.contains("/mshots/"));
22 | }
23 |
24 | /*
25 | * returns a photon url for the passed image with the resize query set to the passed
26 | * dimensions - note that the passed quality parameter will only affect JPEGs
27 | */
28 | public enum Quality {
29 | HIGH,
30 | MEDIUM,
31 | LOW
32 | }
33 |
34 | public static final String ATOMIC_MEDIA_PROXY_URL_PREFIX = "https://public-api.wordpress.com/wpcom/v2/sites/";
35 | public static final String ATOMIC_MEDIA_PROXY_URL_SUFFIX = "/atomic-auth-proxy/file";
36 |
37 | public static String getPhotonImageUrl(String imageUrl, int width, int height) {
38 | return getPhotonImageUrl(imageUrl, width, height, Quality.MEDIUM);
39 | }
40 |
41 | public static String getPhotonImageUrl(String imageUrl, int width, int height, boolean isPrivateAtomicSite) {
42 | return getPhotonImageUrl(imageUrl, width, height, Quality.MEDIUM, isPrivateAtomicSite);
43 | }
44 |
45 | public static String getPhotonImageUrl(String imageUrl, int width, int height, Quality quality) {
46 | return getPhotonImageUrl(imageUrl, width, height, quality, false);
47 | }
48 |
49 | public static String getPhotonImageUrl(String imageUrl, int width, int height, Quality quality,
50 | boolean isPrivateAtomicSite) {
51 | if (TextUtils.isEmpty(imageUrl)) {
52 | return "";
53 | }
54 |
55 | String originalUrl = imageUrl;
56 |
57 | // make sure it's valid
58 | int schemePos = imageUrl.indexOf("://");
59 | if (schemePos == -1) {
60 | return imageUrl;
61 | }
62 |
63 | // we have encountered some image urls that incorrectly have a # fragment part, which
64 | // must be removed before removing the query string
65 | int fragmentPos = imageUrl.indexOf("#");
66 | if (fragmentPos > 0) {
67 | imageUrl = imageUrl.substring(0, fragmentPos);
68 | }
69 |
70 | String urlCopy = imageUrl;
71 |
72 | // remove existing query string since it may contain params that conflict with the passed ones
73 | imageUrl = UrlUtils.removeQuery(imageUrl);
74 |
75 | // if this is an "mshots" url, skip photon and return it with a query that sets the width/height
76 | if (isMshotsUrl(imageUrl)) {
77 | return imageUrl + "?w=" + width + "&h=" + height;
78 | }
79 |
80 | // strip=info removes Exif, IPTC and comment data from the output image.
81 | String query = "?strip=info";
82 |
83 | switch (quality) {
84 | case HIGH:
85 | query += "&quality=100";
86 | break;
87 | case LOW:
88 | query += "&quality=35";
89 | break;
90 | default: // medium
91 | query += "&quality=65";
92 | break;
93 | }
94 |
95 | // if both width & height are passed use the "resize" param, use only "w" or "h" if just
96 | // one of them is set
97 | if (width > 0 && height > 0) {
98 | query += "&resize=" + width + "," + height;
99 | } else if (width > 0) {
100 | query += "&w=" + width;
101 | } else if (height > 0) {
102 | query += "&h=" + height;
103 | }
104 |
105 | if (isPrivateAtomicSite) {
106 | try {
107 | URL url = new URL(imageUrl);
108 | String slug = url.getHost();
109 | String path = url.getPath();
110 | return ATOMIC_MEDIA_PROXY_URL_PREFIX + slug + ATOMIC_MEDIA_PROXY_URL_SUFFIX
111 | + "?path=" + path + "&" + query;
112 | } catch (MalformedURLException e) {
113 | e.printStackTrace();
114 | return "";
115 | }
116 | }
117 |
118 | // return passed url+query if it's already a photon url
119 | if (imageUrl.contains(".wp.com")) {
120 | if (imageUrl.contains("i0.wp.com") || imageUrl.contains("i1.wp.com") || imageUrl.contains("i2.wp.com")) {
121 | boolean useSsl = urlCopy.indexOf("?") > 0 && urlCopy.contains("ssl=1");
122 |
123 | if (useSsl) {
124 | query += "&ssl=1";
125 | }
126 |
127 | return imageUrl + query;
128 | }
129 | }
130 |
131 | // use wordpress.com as the host if image is on wordpress.com since it supports the same
132 | // query params and, more importantly, can handle images in private blogs
133 | if (imageUrl.contains("wordpress.com") || imageUrl.endsWith(".avif")) {
134 | return imageUrl + query;
135 | }
136 |
137 | // must use ssl=1 parameter for https image urls
138 | boolean useSSl = UrlUtils.isHttps(imageUrl);
139 | if (useSSl) {
140 | query += "&ssl=1";
141 | }
142 |
143 | int beginIndex = schemePos + 3;
144 | if (beginIndex < 0 || beginIndex > imageUrl.length()) {
145 | // Fallback to original URL if the beginIndex is invalid to avoid `StringIndexOutOfBoundsException`
146 | // Ref: https://github.com/wordpress-mobile/WordPress-Android/issues/18626
147 | return originalUrl;
148 | }
149 | return "https://i0.wp.com/" + imageUrl.substring(beginIndex) + query;
150 | }
151 | }
152 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/ProfilingUtils.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util;
2 |
3 | import android.os.SystemClock;
4 |
5 | import org.wordpress.android.util.AppLog.T;
6 |
7 | import java.util.ArrayList;
8 |
9 | /**
10 | * forked from android.util.TimingLogger to use AppLog instead of Log + new static interface.
11 | */
12 | public class ProfilingUtils {
13 | private static ProfilingUtils sInstance;
14 |
15 | private String mLabel;
16 | private ArrayList mSplits;
17 | private ArrayList mSplitLabels;
18 |
19 | public static void start(String label) {
20 | getInstance().reset(label);
21 | }
22 |
23 | public static void split(String splitLabel) {
24 | getInstance().addSplit(splitLabel);
25 | }
26 |
27 | public static void dump() {
28 | getInstance().dumpToLog();
29 | }
30 |
31 | public static void stop() {
32 | getInstance().reset(null);
33 | }
34 |
35 | private static ProfilingUtils getInstance() {
36 | if (sInstance == null) {
37 | sInstance = new ProfilingUtils();
38 | }
39 | return sInstance;
40 | }
41 |
42 | public ProfilingUtils() {
43 | reset("init");
44 | }
45 |
46 | public void reset(String label) {
47 | mLabel = label;
48 | reset();
49 | }
50 |
51 | public void reset() {
52 | if (mSplits == null) {
53 | mSplits = new ArrayList();
54 | mSplitLabels = new ArrayList();
55 | } else {
56 | mSplits.clear();
57 | mSplitLabels.clear();
58 | }
59 | addSplit(null);
60 | }
61 |
62 | public void addSplit(String splitLabel) {
63 | if (mLabel == null) {
64 | return;
65 | }
66 | long now = SystemClock.elapsedRealtime();
67 | mSplits.add(now);
68 | mSplitLabels.add(splitLabel);
69 | }
70 |
71 | public void dumpToLog() {
72 | if (mLabel == null) {
73 | return;
74 | }
75 | AppLog.d(T.PROFILING, mLabel + ": begin");
76 | final long first = mSplits.get(0);
77 | long now = first;
78 | for (int i = 1; i < mSplits.size(); i++) {
79 | now = mSplits.get(i);
80 | final String splitLabel = mSplitLabels.get(i);
81 | final long prev = mSplits.get(i - 1);
82 | AppLog.d(T.PROFILING, mLabel + ": " + (now - prev) + " ms, " + splitLabel);
83 | }
84 | AppLog.d(T.PROFILING, mLabel + ": end, " + (now - first) + " ms");
85 | }
86 | }
87 |
88 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/ServiceUtils.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util;
2 |
3 | import android.app.ActivityManager;
4 | import android.content.Context;
5 |
6 | public class ServiceUtils {
7 | public static boolean isServiceRunning(Context context, Class serviceClass) {
8 | ActivityManager manager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
9 | for (ActivityManager.RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {
10 | if (serviceClass.getName().equals(service.service.getClassName())) {
11 | return true;
12 | }
13 | }
14 | return false;
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/ShortcodeUtils.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util;
2 |
3 | import java.util.regex.Matcher;
4 | import java.util.regex.Pattern;
5 |
6 | public class ShortcodeUtils {
7 | public static String getVideoPressShortcodeFromId(String videoPressId) {
8 | if (videoPressId == null || videoPressId.isEmpty()) {
9 | return "";
10 | }
11 |
12 | return "[wpvideo " + videoPressId + "]";
13 | }
14 |
15 | public static String getVideoPressIdFromShortCode(String shortcode) {
16 | String videoPressId = "";
17 |
18 | if (shortcode != null) {
19 | String videoPressShortcodeRegex = "^\\[wpvideo (.*)]$";
20 |
21 | Pattern pattern = Pattern.compile(videoPressShortcodeRegex);
22 | Matcher matcher = pattern.matcher(shortcode);
23 |
24 | if (matcher.find()) {
25 | videoPressId = matcher.group(1);
26 | }
27 | }
28 |
29 | return videoPressId;
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/SqlUtils.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util;
2 |
3 | import android.database.Cursor;
4 | import android.database.DatabaseUtils;
5 | import android.database.sqlite.SQLiteDatabase;
6 | import android.database.sqlite.SQLiteDoneException;
7 | import android.database.sqlite.SQLiteException;
8 | import android.database.sqlite.SQLiteStatement;
9 |
10 | import org.wordpress.android.util.AppLog.T;
11 |
12 | import java.util.ArrayList;
13 | import java.util.List;
14 |
15 | public class SqlUtils {
16 | private SqlUtils() {
17 | throw new AssertionError();
18 | }
19 |
20 | /*
21 | * SQLite doesn't have a boolean datatype, so booleans are stored as 0=false, 1=true
22 | */
23 | public static long boolToSql(boolean value) {
24 | return (value ? 1 : 0);
25 | }
26 |
27 | public static boolean sqlToBool(int value) {
28 | return (value != 0);
29 | }
30 |
31 | public static void closeStatement(SQLiteStatement stmt) {
32 | if (stmt != null) {
33 | stmt.close();
34 | }
35 | }
36 |
37 | public static void closeCursor(Cursor c) {
38 | if (c != null && !c.isClosed()) {
39 | c.close();
40 | }
41 | }
42 |
43 | /*
44 | * wrapper for DatabaseUtils.longForQuery() which returns 0 if query returns no rows
45 | */
46 | public static long longForQuery(SQLiteDatabase db, String query, String[] selectionArgs) {
47 | try {
48 | return DatabaseUtils.longForQuery(db, query, selectionArgs);
49 | } catch (SQLiteDoneException e) {
50 | return 0;
51 | }
52 | }
53 |
54 | public static int intForQuery(SQLiteDatabase db, String query, String[] selectionArgs) {
55 | long value = longForQuery(db, query, selectionArgs);
56 | return (int) value;
57 | }
58 |
59 | public static boolean boolForQuery(SQLiteDatabase db, String query, String[] selectionArgs) {
60 | long value = longForQuery(db, query, selectionArgs);
61 | return sqlToBool((int) value);
62 | }
63 |
64 | /*
65 | * wrapper for DatabaseUtils.stringForQuery(), returns "" if query returns no rows
66 | */
67 | public static String stringForQuery(SQLiteDatabase db, String query, String[] selectionArgs) {
68 | try {
69 | return DatabaseUtils.stringForQuery(db, query, selectionArgs);
70 | } catch (SQLiteDoneException e) {
71 | return "";
72 | }
73 | }
74 |
75 | /*
76 | * returns the number of rows in the passed table
77 | */
78 | public static long getRowCount(SQLiteDatabase db, String tableName) {
79 | return DatabaseUtils.queryNumEntries(db, tableName);
80 | }
81 |
82 | /*
83 | * removes all rows from the passed table
84 | */
85 | public static void deleteAllRowsInTable(SQLiteDatabase db, String tableName) {
86 | db.delete(tableName, null, null);
87 | }
88 |
89 | /*
90 | * drop all tables from the passed SQLiteDatabase - make sure to pass a
91 | * writable database
92 | */
93 | public static boolean dropAllTables(SQLiteDatabase db) throws SQLiteException {
94 | if (db == null) {
95 | return false;
96 | }
97 |
98 | if (db.isReadOnly()) {
99 | throw new SQLiteException("can't drop tables from a read-only database");
100 | }
101 |
102 | List tableNames = new ArrayList();
103 | Cursor cursor = db.rawQuery("SELECT name FROM sqlite_master WHERE type='table'", null);
104 | if (cursor.moveToFirst()) {
105 | do {
106 | String tableName = cursor.getString(0);
107 | if (!tableName.equals("android_metadata") && !tableName.equals("sqlite_sequence")) {
108 | tableNames.add(tableName);
109 | }
110 | } while (cursor.moveToNext());
111 | }
112 |
113 | db.beginTransaction();
114 | try {
115 | for (String tableName : tableNames) {
116 | db.execSQL("DROP TABLE IF EXISTS " + tableName);
117 | }
118 | db.setTransactionSuccessful();
119 | return true;
120 | } finally {
121 | db.endTransaction();
122 | closeCursor(cursor);
123 | }
124 | }
125 |
126 | /*
127 | * Android's CursorWindow has a max size of 2MB per row which can be exceeded
128 | * with a very large text column, causing an IllegalStateException when the
129 | * row is read - prevent this by limiting the amount of text that's stored in
130 | * the text column.
131 | * https://github.com/android/platform_frameworks_base/blob/b77bc869241644a662f7e615b0b00ecb5aee373d/core/res/res
132 | * /values/config.xml#L1268
133 | * https://github.com/android/platform_frameworks_base/blob/3bdbf644d61f46b531838558fabbd5b990fc4913/core/java
134 | * /android/database/CursorWindow.java#L103
135 | */
136 | // Max 512K characters (a UTF-8 char is 4 bytes max, so a 512K characters string is always < 2Mb)
137 | private static final int MAX_TEXT_LEN = 1024 * 1024 / 2;
138 |
139 | public static String maxSQLiteText(final String text) {
140 | if (text.length() <= MAX_TEXT_LEN) {
141 | return text;
142 | }
143 | AppLog.w(T.UTILS, "sqlite > max text exceeded, storing truncated text");
144 | return text.substring(0, MAX_TEXT_LEN);
145 | }
146 | }
147 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/SystemServiceFactory.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util;
2 |
3 | import android.content.Context;
4 |
5 | public class SystemServiceFactory {
6 | private static SystemServiceFactoryAbstract sFactory;
7 |
8 | public static Object get(Context context, String name) {
9 | if (sFactory == null) {
10 | sFactory = new SystemServiceFactoryDefault();
11 | }
12 | return sFactory.get(context, name);
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/SystemServiceFactoryAbstract.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util;
2 |
3 | import android.content.Context;
4 |
5 | public interface SystemServiceFactoryAbstract {
6 | Object get(Context context, String name);
7 | }
8 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/SystemServiceFactoryDefault.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util;
2 |
3 | import android.content.Context;
4 |
5 | public class SystemServiceFactoryDefault implements SystemServiceFactoryAbstract {
6 | public Object get(Context context, String name) {
7 | return context.getSystemService(name);
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/ToastUtils.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util;
2 |
3 | import android.content.Context;
4 | import android.view.Gravity;
5 | import android.widget.Toast;
6 |
7 | /**
8 | * Provides a simplified way to show toast messages without having to create the toast, set the
9 | * desired gravity, etc.
10 | */
11 | public class ToastUtils {
12 | public enum Duration {
13 | SHORT, LONG
14 | }
15 |
16 | private ToastUtils() {
17 | throw new AssertionError();
18 | }
19 |
20 | public static Toast showToast(Context context, int stringResId) {
21 | return showToast(context, stringResId, Duration.SHORT);
22 | }
23 |
24 | public static Toast showToast(Context context, int stringResId, Duration duration) {
25 | return showToast(context, context.getString(stringResId), duration);
26 | }
27 |
28 | public static Toast showToast(Context context, String text) {
29 | return showToast(context, text, Duration.SHORT);
30 | }
31 |
32 | public static Toast showToast(Context context, String text, Duration duration) {
33 | return showToast(context, text, duration, Gravity.CENTER);
34 | }
35 |
36 | public static Toast showToast(Context context, String text, Duration duration, int gravity) {
37 | return showToast(context, text, duration, gravity, 0, 0);
38 | }
39 |
40 | public static Toast showToast(
41 | Context context,
42 | String text,
43 | Duration duration,
44 | int gravity,
45 | int xOffset,
46 | int yOffset) {
47 | Toast toast = Toast.makeText(context, text,
48 | (duration == Duration.SHORT ? Toast.LENGTH_SHORT : Toast.LENGTH_LONG));
49 | toast.setGravity(gravity, xOffset, yOffset);
50 | toast.show();
51 | return toast;
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/VersionUtils.kt:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util
2 |
3 | import org.wordpress.android.util.AppLog.T.UTILS
4 | import org.wordpress.android.util.helpers.Version
5 |
6 | object VersionUtils {
7 | /**
8 | * Checks if a given version [String] is equal to or higher than another given minimal version [String].
9 | *
10 | * Note: This method ignores "-beta", "-alpha" or "-RC" versions, meaning that this will return `true` for
11 | * a version "5.5-beta1" and `minVersion` "5.5", for example.
12 | *
13 | * @param version The version [String] to check.
14 | * @param minVersion A minimal acceptable version [String].
15 | * @return `true` if the version is equal to or higher than the `minVersion`; `false` otherwise.
16 | */
17 | @JvmStatic fun checkMinimalVersion(version: String?, minVersion: String?) =
18 | if (!version.isNullOrEmpty() && !minVersion.isNullOrEmpty()) {
19 | try {
20 | Version(stripVersionSuffixes(version)) >= Version(stripVersionSuffixes(minVersion))
21 | } catch (e: IllegalArgumentException) {
22 | AppLog.e(UTILS, "Invalid version $version, expected $minVersion", e)
23 | false
24 | }
25 | } else false
26 |
27 | // Strip any trailing "-beta", "-alpha" or "-RC" suffixes from the version
28 | private fun stripVersionSuffixes(version: String) = version.substringBefore("-")
29 | }
30 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/VideoUtils.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util;
2 |
3 |
4 | import android.content.Context;
5 | import android.media.MediaMetadataRetriever;
6 | import android.net.Uri;
7 |
8 | import java.io.File;
9 |
10 | public class VideoUtils {
11 | public static long getVideoDurationMS(Context context, File file) {
12 | if (context == null || file == null) {
13 | AppLog.e(AppLog.T.MEDIA, "context and file can't be null.");
14 | return 0L;
15 | }
16 | return getVideoDurationMS(context, Uri.fromFile(file));
17 | }
18 |
19 | public static long getVideoDurationMS(Context context, Uri videoUri) {
20 | if (context == null || videoUri == null) {
21 | AppLog.e(AppLog.T.MEDIA, "context and videoUri can't be null.");
22 | return 0L;
23 | }
24 | MediaMetadataRetriever retriever = new MediaMetadataRetriever();
25 | try {
26 | retriever.setDataSource(context, videoUri);
27 | } catch (IllegalArgumentException | SecurityException e) {
28 | AppLog.e(AppLog.T.MEDIA, "Can't read duration of the video.", e);
29 | return 0L;
30 | } catch (RuntimeException e) {
31 | // Ref: https://github.com/wordpress-mobile/WordPress-Android/issues/5431
32 | AppLog.e(AppLog.T.MEDIA,
33 | "Can't read duration of the video due to a Runtime Exception happened setting the datasource", e);
34 | return 0L;
35 | }
36 |
37 | String time = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
38 | if (time == null) {
39 | return 0L;
40 | }
41 | return Long.parseLong(time);
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/ViewUtils.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util;
2 |
3 | import android.content.Context;
4 | import android.content.res.ColorStateList;
5 | import android.content.res.TypedArray;
6 | import android.graphics.Outline;
7 | import android.view.View;
8 | import android.view.ViewOutlineProvider;
9 |
10 | import androidx.annotation.AttrRes;
11 | import androidx.annotation.NonNull;
12 | import androidx.annotation.StyleRes;
13 | import androidx.core.view.ViewCompat;
14 |
15 | import java.util.concurrent.atomic.AtomicInteger;
16 |
17 | public class ViewUtils {
18 | /**
19 | * Generate a value suitable for use in {@link View#setId(int)}.
20 | * This value will not collide with ID values generated at build time by aapt for R.id.
21 | *
22 | * @return a generated ID value
23 | */
24 | public static int generateViewId() {
25 | return View.generateViewId();
26 | }
27 |
28 | private static final AtomicInteger NEXT_GENERATED_ID = new AtomicInteger(1);
29 |
30 | /**
31 | * Copied from {@link View#generateViewId()}
32 | * Generate a value suitable for use in {@link View#setId(int)}.
33 | * This value will not collide with ID values generated at build time by aapt for R.id.
34 | *
35 | * @return a generated ID value
36 | */
37 | private static int copiedGenerateViewId() {
38 | for (;;) {
39 | final int result = NEXT_GENERATED_ID.get();
40 | // aapt-generated IDs have the high byte nonzero; clamp to the range under that.
41 | int newValue = result + 1;
42 | if (newValue > 0x00FFFFFF) {
43 | newValue = 1; // Roll over to 1, not 0.
44 | }
45 | if (NEXT_GENERATED_ID.compareAndSet(result, newValue)) {
46 | return result;
47 | }
48 | }
49 | }
50 |
51 | public static void setButtonBackgroundColor(Context context, View button, @StyleRes int styleId,
52 | @AttrRes int colorAttribute) {
53 | TypedArray a = context.obtainStyledAttributes(styleId, new int[]{colorAttribute});
54 | ColorStateList color = a.getColorStateList(0);
55 | a.recycle();
56 | ViewCompat.setBackgroundTintList(button, color);
57 | }
58 |
59 | /**
60 | * adds an inset circular shadow outline the passed view - note that
61 | * the view should have its elevation set prior to calling this
62 | */
63 | public static void addCircularShadowOutline(@NonNull View view) {
64 | view.setOutlineProvider(new ViewOutlineProvider() {
65 | @Override
66 | public void getOutline(View view, Outline outline) {
67 | outline.setOval(0, 0, view.getWidth(), view.getHeight());
68 | }
69 | });
70 | }
71 | }
72 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/WebViewUtils.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util;
2 |
3 | import android.webkit.CookieManager;
4 | import android.webkit.ValueCallback;
5 |
6 | public class WebViewUtils {
7 | public static void clearCookiesAsync() {
8 | clearCookiesAsync(null);
9 | }
10 |
11 | public static void clearCookiesAsync(ValueCallback callback) {
12 | CookieManager cookieManager = CookieManager.getInstance();
13 | cookieManager.removeAllCookies(callback);
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/helpers/Debouncer.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util.helpers;
2 |
3 | import java.util.concurrent.ConcurrentHashMap;
4 | import java.util.concurrent.Executors;
5 | import java.util.concurrent.Future;
6 | import java.util.concurrent.ScheduledExecutorService;
7 | import java.util.concurrent.TimeUnit;
8 |
9 | public class Debouncer {
10 | private final ScheduledExecutorService mScheduler = Executors.newSingleThreadScheduledExecutor();
11 | private final ConcurrentHashMap> mDelayedMap = new ConcurrentHashMap<>();
12 |
13 | /**
14 | * Debounces {@code callable} by {@code delay}, i.e., schedules it to be executed after {@code delay},
15 | * or cancels its execution if the method is called with the same key within the {@code delay} again.
16 | */
17 | public void debounce(final Object key, final Runnable runnable, long delay, TimeUnit unit) {
18 | if (mScheduler.isShutdown()) {
19 | return;
20 | }
21 | final Future prev = mDelayedMap.put(key, mScheduler.schedule(new Runnable() {
22 | @Override
23 | public void run() {
24 | try {
25 | runnable.run();
26 | } finally {
27 | mDelayedMap.remove(key);
28 | }
29 | }
30 | }, delay, unit));
31 | if (prev != null) {
32 | prev.cancel(true);
33 | }
34 | }
35 |
36 | public void shutdown() {
37 | mScheduler.shutdownNow();
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/helpers/ListScrollPositionManager.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util.helpers;
2 |
3 | import android.content.Context;
4 | import android.content.SharedPreferences;
5 | import android.content.SharedPreferences.Editor;
6 | import android.preference.PreferenceManager;
7 | import android.view.View;
8 | import android.widget.ListView;
9 |
10 | public class ListScrollPositionManager {
11 | private int mSelectedPosition;
12 | private int mListViewScrollStateIndex;
13 | private int mListViewScrollStateOffset;
14 | private ListView mListView;
15 | private boolean mSetSelection;
16 |
17 | public ListScrollPositionManager(ListView listView, boolean setSelection) {
18 | mListView = listView;
19 | mSetSelection = setSelection;
20 | }
21 |
22 | public void saveScrollOffset() {
23 | mListViewScrollStateIndex = mListView.getFirstVisiblePosition();
24 | View view = mListView.getChildAt(0);
25 | mListViewScrollStateOffset = 0;
26 | if (view != null) {
27 | mListViewScrollStateOffset = view.getTop();
28 | }
29 | if (mSetSelection) {
30 | mSelectedPosition = mListView.getCheckedItemPosition();
31 | }
32 | }
33 |
34 | public void restoreScrollOffset() {
35 | mListView.setSelectionFromTop(mListViewScrollStateIndex, mListViewScrollStateOffset);
36 | if (mSetSelection) {
37 | mListView.setItemChecked(mSelectedPosition, true);
38 | }
39 | }
40 |
41 | public void saveToPreferences(Context context, String uniqueId) {
42 | saveScrollOffset();
43 | SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(context);
44 | Editor editor = settings.edit();
45 | editor.putInt("scroll-position-manager-index-" + uniqueId, mListViewScrollStateIndex);
46 | editor.putInt("scroll-position-manager-offset-" + uniqueId, mListViewScrollStateOffset);
47 | editor.putInt("scroll-position-manager-selected-position-" + uniqueId, mSelectedPosition);
48 | editor.apply();
49 | }
50 |
51 | public void restoreFromPreferences(Context context, String uniqueId) {
52 | SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(context);
53 | mListViewScrollStateIndex = settings.getInt("scroll-position-manager-index-" + uniqueId, 0);
54 | mListViewScrollStateOffset = settings.getInt("scroll-position-manager-offset-" + uniqueId, 0);
55 | mSelectedPosition = settings.getInt("scroll-position-manager-selected-position-" + uniqueId, 0);
56 | restoreScrollOffset();
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/helpers/MediaGallery.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util.helpers;
2 |
3 | import java.io.Serializable;
4 | import java.util.ArrayList;
5 |
6 | /**
7 | * A model representing a Media Gallery.
8 | * A unique id is not used on the website, but only in this app.
9 | * It is used to uniquely determining the instance of the object, as it is
10 | * passed between post and media gallery editor.
11 | */
12 | public class MediaGallery implements Serializable {
13 | private static final long serialVersionUID = 2359176987182027508L;
14 |
15 | private long mUniqueId;
16 | private boolean mIsRandom;
17 | private String mType;
18 | private int mNumColumns;
19 | private ArrayList mIds;
20 |
21 | public MediaGallery(boolean isRandom, String type, int numColumns, ArrayList ids) {
22 | mIsRandom = isRandom;
23 | mType = type;
24 | mNumColumns = numColumns;
25 | mIds = ids;
26 | mUniqueId = System.currentTimeMillis();
27 | }
28 |
29 | public MediaGallery() {
30 | mIsRandom = false;
31 | mType = "";
32 | mNumColumns = 3;
33 | mIds = new ArrayList<>();
34 | mUniqueId = System.currentTimeMillis();
35 | }
36 |
37 | public boolean isRandom() {
38 | return mIsRandom;
39 | }
40 |
41 | public void setRandom(boolean isRandom) {
42 | this.mIsRandom = isRandom;
43 | }
44 |
45 | public String getType() {
46 | return mType;
47 | }
48 |
49 | public void setType(String type) {
50 | this.mType = type;
51 | }
52 |
53 | public int getNumColumns() {
54 | return mNumColumns;
55 | }
56 |
57 | public void setNumColumns(int numColumns) {
58 | this.mNumColumns = numColumns;
59 | }
60 |
61 | public ArrayList getIds() {
62 | return mIds;
63 | }
64 |
65 | public String getIdsStr() {
66 | String idsStr = "";
67 | if (mIds.size() > 0) {
68 | for (Long id : mIds) {
69 | idsStr += id + ",";
70 | }
71 | idsStr = idsStr.substring(0, idsStr.length() - 1);
72 | }
73 | return idsStr;
74 | }
75 |
76 | public void setIds(ArrayList ids) {
77 | this.mIds = ids;
78 | }
79 |
80 | /**
81 | * An id to uniquely identify a media gallery object, so that the same object can be edited in the post editor
82 | */
83 | public long getUniqueId() {
84 | return mUniqueId;
85 | }
86 | }
87 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/helpers/MediaGalleryImageSpan.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util.helpers;
2 |
3 | import android.content.Context;
4 | import android.text.style.ImageSpan;
5 |
6 | public class MediaGalleryImageSpan extends ImageSpan {
7 | private MediaGallery mMediaGallery;
8 |
9 | public MediaGalleryImageSpan(Context context, MediaGallery mediaGallery, int placeHolder) {
10 | super(context, placeHolder);
11 | setMediaGallery(mediaGallery);
12 | }
13 |
14 | public MediaGallery getMediaGallery() {
15 | return mMediaGallery;
16 | }
17 |
18 | public void setMediaGallery(MediaGallery mediaGallery) {
19 | this.mMediaGallery = mediaGallery;
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/helpers/RecyclerViewScrollPositionManager.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util.helpers;
2 |
3 | import android.os.Bundle;
4 | import android.view.View;
5 |
6 | import androidx.recyclerview.widget.LinearLayoutManager;
7 | import androidx.recyclerview.widget.RecyclerView;
8 |
9 |
10 | public class RecyclerViewScrollPositionManager {
11 | private static final String RV_POSITION = "rv_position";
12 | private static final String RV_OFFSET = "rv_offset";
13 | private int mRVPosition = 0;
14 | private int mRVOffset = 0;
15 |
16 | public void onSaveInstanceState(Bundle outState, RecyclerView recyclerView) {
17 | // make sure the layout manager is assigned to the RecyclerView
18 | // also take into account this needs to be a LinearLayoutManager, otherwise ClassCastException occurs
19 | outState.putInt(RV_POSITION,
20 | ((LinearLayoutManager) recyclerView.getLayoutManager()).findFirstVisibleItemPosition());
21 | View firstItemView = recyclerView.getChildAt(0);
22 | int offset = (firstItemView == null) ? 0 : (firstItemView.getTop() - recyclerView.getPaddingTop());
23 | outState.putInt(RV_OFFSET, offset);
24 | }
25 |
26 | public void onRestoreInstanceState(Bundle savedInstanceState) {
27 | mRVPosition = savedInstanceState.getInt(RV_POSITION);
28 | mRVOffset = savedInstanceState.getInt(RV_OFFSET);
29 | }
30 |
31 | public void restoreScrollOffset(RecyclerView recyclerView) {
32 | if (mRVPosition > 0 || mRVOffset > 0) {
33 | ((LinearLayoutManager) recyclerView.getLayoutManager())
34 | .scrollToPositionWithOffset(mRVPosition, mRVOffset);
35 | }
36 | mRVPosition = 0;
37 | mRVOffset = 0;
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/helpers/SwipeToRefreshHelper.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util.helpers;
2 |
3 | import android.content.Context;
4 |
5 | import androidx.annotation.ColorInt;
6 | import androidx.annotation.ColorRes;
7 | import androidx.core.content.ContextCompat;
8 | import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
9 | import androidx.swiperefreshlayout.widget.SwipeRefreshLayout.OnRefreshListener;
10 |
11 | import org.wordpress.android.util.widgets.CustomSwipeRefreshLayout;
12 |
13 | public class SwipeToRefreshHelper implements OnRefreshListener {
14 | private CustomSwipeRefreshLayout mSwipeRefreshLayout;
15 | private RefreshListener mRefreshListener;
16 | private boolean mRefreshing;
17 |
18 | public interface RefreshListener {
19 | void onRefreshStarted();
20 | }
21 |
22 | /**
23 | * Helps {@link org.wordpress.android.util.widgets.CustomSwipeRefreshLayout} by passing the
24 | * {@link SwipeRefreshLayout}, {@link RefreshListener}, and color.
25 | *
26 | * @param context {@link Context} in which this layout is used.
27 | * @param swipeRefreshLayout {@link CustomSwipeRefreshLayout} for refreshing the contents
28 | * of a view via a vertical swipe gesture.
29 | * @param listener {@link RefreshListener} notified when a refresh is triggered
30 | * via the swipe gesture.
31 | *
32 | * @deprecated Use {@link #SwipeToRefreshHelper(CustomSwipeRefreshLayout, RefreshListener, int, int...)} instead.
33 | */
34 | @Deprecated
35 | public SwipeToRefreshHelper(Context context, CustomSwipeRefreshLayout swipeRefreshLayout,
36 | RefreshListener listener) {
37 | init(swipeRefreshLayout, listener, ContextCompat.getColor(context, android.R.color.white),
38 | android.R.color.holo_blue_dark);
39 | }
40 |
41 | /**
42 | * Helps {@link org.wordpress.android.util.widgets.CustomSwipeRefreshLayout} by passing the
43 | * {@link SwipeRefreshLayout}, {@link RefreshListener}, and color(s).
44 | *
45 | * @param swipeRefreshLayout {@link CustomSwipeRefreshLayout} for refreshing the contents
46 | * of a view via a vertical swipe gesture.
47 | * @param listener {@link RefreshListener} notified when a refresh is triggered
48 | * via the swipe gesture.
49 | * @param progressAnimationColors Comma-separated color resource integers used in the progress
50 | * animation. The first color will also be the color of the bar
51 | * that grows in response to a user swipe gesture.
52 | */
53 | public SwipeToRefreshHelper(CustomSwipeRefreshLayout swipeRefreshLayout, RefreshListener listener,
54 | @ColorInt int backgroundColor,
55 | @ColorRes int... progressAnimationColors) {
56 | init(swipeRefreshLayout, listener, backgroundColor, progressAnimationColors);
57 | }
58 |
59 | /**
60 | * Initializes {@link org.wordpress.android.util.widgets.CustomSwipeRefreshLayout} by assigning
61 | * {@link SwipeRefreshLayout}, {@link RefreshListener}, and color(s).
62 | *
63 | * @param swipeRefreshLayout {@link CustomSwipeRefreshLayout} for refreshing the contents
64 | * of a view via a vertical swipe gesture.
65 | * @param listener {@link RefreshListener} notified when a refresh is triggered
66 | * via the swipe gesture.
67 | * @param progressAnimationColors Comma-separated color resource integers used in the progress
68 | * animation. The first color will also be the color of the bar
69 | * that grows in response to a user swipe gesture.
70 | */
71 | public void init(CustomSwipeRefreshLayout swipeRefreshLayout, RefreshListener listener,
72 | @ColorInt int backgroundColor,
73 | @ColorRes int... progressAnimationColors) {
74 | mRefreshListener = listener;
75 | mSwipeRefreshLayout = swipeRefreshLayout;
76 | mSwipeRefreshLayout.setOnRefreshListener(this);
77 | mSwipeRefreshLayout.setProgressBackgroundColorSchemeColor(backgroundColor);
78 | mSwipeRefreshLayout.setColorSchemeResources(progressAnimationColors);
79 | }
80 |
81 | public void setRefreshing(boolean refreshing) {
82 | mRefreshing = refreshing;
83 | // Delayed refresh, it fixes https://code.google.com/p/android/issues/detail?id=77712
84 | // 50ms seems a good compromise (always worked during tests) and fast enough so user can't notice the delay
85 | if (refreshing) {
86 | mSwipeRefreshLayout.postDelayed(new Runnable() {
87 | @Override
88 | public void run() {
89 | // use mRefreshing so if the refresh takes less than 50ms, loading indicator won't show up.
90 | mSwipeRefreshLayout.setRefreshing(mRefreshing);
91 | }
92 | }, 50);
93 | } else {
94 | mSwipeRefreshLayout.setRefreshing(false);
95 | }
96 | }
97 |
98 | public boolean isRefreshing() {
99 | return mSwipeRefreshLayout.isRefreshing();
100 | }
101 |
102 | @Override
103 | public void onRefresh() {
104 | mRefreshListener.onRefreshStarted();
105 | }
106 |
107 | public void setEnabled(boolean enabled) {
108 | mSwipeRefreshLayout.setEnabled(enabled);
109 | }
110 | }
111 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/helpers/Version.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util.helpers;
2 |
3 | //See: http://stackoverflow.com/a/11024200
4 | public class Version implements Comparable {
5 | private String mVersion;
6 |
7 | public final String get() {
8 | return this.mVersion;
9 | }
10 |
11 | public Version(String version) {
12 | if (version == null) {
13 | throw new IllegalArgumentException("Version can not be null");
14 | }
15 | if (!version.matches("[0-9]+(\\.[0-9]+)*")) {
16 | throw new IllegalArgumentException("Invalid version format");
17 | }
18 | this.mVersion = version;
19 | }
20 |
21 | @Override public int compareTo(Version that) {
22 | if (that == null) {
23 | return 1;
24 | }
25 | String[] thisParts = this.get().split("\\.");
26 | String[] thatParts = that.get().split("\\.");
27 | int length = Math.max(thisParts.length, thatParts.length);
28 | for (int i = 0; i < length; i++) {
29 | int thisPart = i < thisParts.length
30 | ? Integer.parseInt(thisParts[i]) : 0;
31 | int thatPart = i < thatParts.length
32 | ? Integer.parseInt(thatParts[i]) : 0;
33 | if (thisPart < thatPart) {
34 | return -1;
35 | }
36 | if (thisPart > thatPart) {
37 | return 1;
38 | }
39 | }
40 | return 0;
41 | }
42 |
43 | @Override public boolean equals(Object that) {
44 | if (this == that) {
45 | return true;
46 | }
47 | if (that == null) {
48 | return false;
49 | }
50 | if (this.getClass() != that.getClass()) {
51 | return false;
52 | }
53 | return this.compareTo((Version) that) == 0;
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/helpers/WPHtmlTagHandler.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util.helpers;
2 |
3 | import android.text.Editable;
4 | import android.text.Html;
5 | import android.text.style.BulletSpan;
6 | import android.text.style.LeadingMarginSpan;
7 |
8 | import org.xml.sax.XMLReader;
9 |
10 | import java.util.ArrayList;
11 | import java.util.List;
12 |
13 | /**
14 | * Handle tags that the Html class doesn't understand
15 | * Tweaked from source at http://stackoverflow.com/questions/4044509/android-how-to-use-the-html-taghandler
16 | */
17 | public class WPHtmlTagHandler implements Html.TagHandler {
18 | private static final int SPAN_INDENT_WIDTH = 15;
19 |
20 | private int mListItemCount = 0;
21 | private List mListParents = new ArrayList<>();
22 |
23 | @Override
24 | public void handleTag(final boolean opening, final String tag, Editable output,
25 | final XMLReader xmlReader) {
26 | if (tag != null) {
27 | switch (tag) {
28 | case "WPUL":
29 | if (opening) {
30 | mListParents.add("ul");
31 | } else {
32 | mListParents.remove("ul");
33 | }
34 | break;
35 | case "WPOL":
36 | if (opening) {
37 | mListParents.add("ol");
38 | } else {
39 | mListParents.remove("ol");
40 | }
41 | break;
42 | case "WPLI":
43 | if (!opening) {
44 | handleListTag(output);
45 | }
46 | break;
47 | case "dd":
48 | if (opening) {
49 | mListParents.add("dd");
50 | } else {
51 | mListParents.remove("dd");
52 | }
53 | break;
54 | }
55 | }
56 | }
57 |
58 | private void handleListTag(Editable output) {
59 | int size = mListParents.size();
60 | if (size > 0 && output != null) {
61 | if ("ul".equals(mListParents.get(size - 1))) {
62 | output.append("\n");
63 | String[] split = output.toString().split("\n");
64 | int start = 0;
65 | if (split.length != 1) {
66 | int lastIndex = split.length - 1;
67 | start = output.length() - split[lastIndex].length() - 1;
68 | }
69 | output.setSpan(new BulletSpan(SPAN_INDENT_WIDTH * mListParents.size()), start, output.length(), 0);
70 | } else if ("ol".equals(mListParents.get(size - 1))) {
71 | mListItemCount++;
72 | output.append("\n");
73 | String[] split = output.toString().split("\n");
74 | int start = 0;
75 | if (split.length != 1) {
76 | int lastIndex = split.length - 1;
77 | start = output.length() - split[lastIndex].length() - 1;
78 | }
79 | output.insert(start, mListItemCount + ". ");
80 | output.setSpan(new LeadingMarginSpan.Standard(SPAN_INDENT_WIDTH * mListParents.size()), start,
81 | output.length(), 0);
82 | }
83 | }
84 | }
85 | }
86 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/helpers/WPImageSpan.java:
--------------------------------------------------------------------------------
1 | //Add WordPress image fields to ImageSpan object
2 |
3 | package org.wordpress.android.util.helpers;
4 |
5 | import android.content.Context;
6 | import android.graphics.Bitmap;
7 | import android.net.Uri;
8 | import android.os.Parcel;
9 | import android.os.Parcelable;
10 | import android.text.style.ImageSpan;
11 |
12 | public class WPImageSpan extends ImageSpan implements Parcelable {
13 | protected Uri mImageSource = null;
14 | protected boolean mNetworkImageLoaded = false;
15 | protected MediaFile mMediaFile;
16 | protected int mStartPosition, mEndPosition;
17 |
18 | protected WPImageSpan() {
19 | super((Bitmap) null);
20 | }
21 |
22 | public WPImageSpan(Context context, Bitmap b, Uri src) {
23 | super(context, b);
24 | this.mImageSource = src;
25 | mMediaFile = new MediaFile();
26 | }
27 |
28 | public WPImageSpan(Context context, int resId, Uri src) {
29 | super(context, resId);
30 | this.mImageSource = src;
31 | mMediaFile = new MediaFile();
32 | }
33 |
34 | public void setPosition(int start, int end) {
35 | mStartPosition = start;
36 | mEndPosition = end;
37 | }
38 |
39 | public int getStartPosition() {
40 | return mStartPosition >= 0 ? mStartPosition : 0;
41 | }
42 |
43 | public int getEndPosition() {
44 | return mEndPosition < getStartPosition() ? getStartPosition() : mEndPosition;
45 | }
46 |
47 | public MediaFile getMediaFile() {
48 | return mMediaFile;
49 | }
50 |
51 | public void setMediaFile(MediaFile mediaFile) {
52 | this.mMediaFile = mediaFile;
53 | }
54 |
55 | public void setImageSource(Uri imageSource) {
56 | this.mImageSource = imageSource;
57 | }
58 |
59 | public Uri getImageSource() {
60 | return mImageSource;
61 | }
62 |
63 | public boolean isNetworkImageLoaded() {
64 | return mNetworkImageLoaded;
65 | }
66 |
67 | public void setNetworkImageLoaded(boolean networkImageLoaded) {
68 | this.mNetworkImageLoaded = networkImageLoaded;
69 | }
70 |
71 | protected void setupFromParcel(Parcel in) {
72 | MediaFile mediaFile = new MediaFile();
73 |
74 | boolean[] booleans = new boolean[2];
75 | in.readBooleanArray(booleans);
76 | setNetworkImageLoaded(booleans[0]);
77 | mediaFile.setVideo(booleans[1]);
78 |
79 | setImageSource(Uri.parse(in.readString()));
80 | mediaFile.setMediaId(in.readString());
81 | mediaFile.setBlogId(in.readString());
82 | mediaFile.setPostID(in.readLong());
83 | mediaFile.setCaption(in.readString());
84 | mediaFile.setDescription(in.readString());
85 | mediaFile.setAlt(in.readString());
86 | mediaFile.setTitle(in.readString());
87 | mediaFile.setMimeType(in.readString());
88 | mediaFile.setFileName(in.readString());
89 | mediaFile.setThumbnailURL(in.readString());
90 | mediaFile.setVideoPressShortCode(in.readString());
91 | mediaFile.setFileURL(in.readString());
92 | mediaFile.setFilePath(in.readString());
93 | mediaFile.setDateCreatedGMT(in.readLong());
94 | mediaFile.setWidth(in.readInt());
95 | mediaFile.setHeight(in.readInt());
96 | setPosition(in.readInt(), in.readInt());
97 |
98 | setMediaFile(mediaFile);
99 | }
100 |
101 | public static final Parcelable.Creator CREATOR
102 | = new Parcelable.Creator() {
103 | public WPImageSpan createFromParcel(Parcel in) {
104 | WPImageSpan imageSpan = new WPImageSpan();
105 | imageSpan.setupFromParcel(in);
106 | return imageSpan;
107 | }
108 |
109 | public WPImageSpan[] newArray(int size) {
110 | return new WPImageSpan[size];
111 | }
112 | };
113 |
114 | @Override
115 | public int describeContents() {
116 | return 0;
117 | }
118 |
119 | @Override
120 | public void writeToParcel(Parcel parcel, int i) {
121 | parcel.writeBooleanArray(new boolean[]{mNetworkImageLoaded, mMediaFile.isVideo()});
122 | parcel.writeString(mImageSource.toString());
123 | parcel.writeString(mMediaFile.getMediaId());
124 | parcel.writeString(mMediaFile.getBlogId());
125 | parcel.writeLong(mMediaFile.getPostID());
126 | parcel.writeString(mMediaFile.getCaption());
127 | parcel.writeString(mMediaFile.getDescription());
128 | parcel.writeString(mMediaFile.getAlt());
129 | parcel.writeString(mMediaFile.getTitle());
130 | parcel.writeString(mMediaFile.getMimeType());
131 | parcel.writeString(mMediaFile.getFileName());
132 | parcel.writeString(mMediaFile.getThumbnailURL());
133 | parcel.writeString(mMediaFile.getVideoPressShortCode());
134 | parcel.writeString(mMediaFile.getFileURL());
135 | parcel.writeString(mMediaFile.getFilePath());
136 | parcel.writeLong(mMediaFile.getDateCreatedGMT());
137 | parcel.writeInt(mMediaFile.getWidth());
138 | parcel.writeInt(mMediaFile.getHeight());
139 | parcel.writeInt(getStartPosition());
140 | parcel.writeInt(getEndPosition());
141 | }
142 | }
143 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/helpers/WPQuoteSpan.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util.helpers;
2 |
3 | import android.graphics.Canvas;
4 | import android.graphics.Paint;
5 | import android.text.Layout;
6 | import android.text.style.QuoteSpan;
7 |
8 | /**
9 | * Customzed QuoteSpan for use in SpannableString's
10 | */
11 | public class WPQuoteSpan extends QuoteSpan {
12 | public static final int STRIPE_COLOR = 0xFF21759B;
13 | private static final int STRIPE_WIDTH = 5;
14 | private static final int GAP_WIDTH = 20;
15 |
16 | public WPQuoteSpan() {
17 | super(STRIPE_COLOR);
18 | }
19 |
20 | @Override
21 | public int getLeadingMargin(boolean first) {
22 | int margin = GAP_WIDTH * 2 + STRIPE_WIDTH;
23 | return margin;
24 | }
25 |
26 | /**
27 | * Draw a nice thick gray bar if Ice Cream Sandwhich or newer. There's a
28 | * bug on older devices that does not respect the increased margin.
29 | */
30 | @Override
31 | public void drawLeadingMargin(Canvas c, Paint p, int x, int dir, int top, int baseline, int bottom,
32 | CharSequence text, int start, int end, boolean first, Layout layout) {
33 | Paint.Style style = p.getStyle();
34 | int color = p.getColor();
35 |
36 | p.setStyle(Paint.Style.FILL);
37 | p.setColor(STRIPE_COLOR);
38 |
39 | c.drawRect(GAP_WIDTH + x, top, x + dir * STRIPE_WIDTH, bottom, p);
40 |
41 | p.setStyle(style);
42 | p.setColor(color);
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/helpers/WPUnderlineSpan.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2006 The Android Open Source Project
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package org.wordpress.android.util.helpers;
18 |
19 | import android.os.Parcel;
20 | import android.text.style.UnderlineSpan;
21 |
22 | /**
23 | * WPUnderlineSpan is used as an alternative class to UnderlineSpan. UnderlineSpan is used by EditText auto
24 | * correct, so it can get mixed up with our formatting.
25 | */
26 | public class WPUnderlineSpan extends UnderlineSpan {
27 | public WPUnderlineSpan() {
28 | super();
29 | }
30 |
31 | public WPUnderlineSpan(Parcel src) {
32 | super(src);
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/helpers/WPWebChromeClient.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util.helpers;
2 |
3 | import android.app.Activity;
4 | import android.text.TextUtils;
5 | import android.view.View;
6 | import android.webkit.WebView;
7 | import android.widget.ProgressBar;
8 |
9 | import androidx.annotation.DrawableRes;
10 |
11 |
12 | public class WPWebChromeClient extends WebChromeClientWithVideoPoster {
13 | private final ProgressBar mProgressBar;
14 | private final Activity mActivity;
15 | private final boolean mAutoUpdateActivityTitle;
16 |
17 | public WPWebChromeClient(Activity activity, View view, @DrawableRes int defaultPoster, ProgressBar progressBar) {
18 | this(activity, view, defaultPoster, progressBar, true);
19 | }
20 |
21 | public WPWebChromeClient(Activity activity,
22 | View view,
23 | @DrawableRes int defaultPoster,
24 | ProgressBar progressBar,
25 | boolean autoUpdateActivityTitle) {
26 | super(view, defaultPoster);
27 | mActivity = activity;
28 | mProgressBar = progressBar;
29 | mAutoUpdateActivityTitle = autoUpdateActivityTitle;
30 | }
31 |
32 | public void onProgressChanged(WebView webView, int progress) {
33 | if (mActivity != null
34 | && !mActivity.isFinishing()
35 | && mAutoUpdateActivityTitle
36 | && !TextUtils.isEmpty(webView.getTitle())) {
37 | mActivity.setTitle(webView.getTitle());
38 | }
39 | if (mProgressBar != null) {
40 | if (progress == 100) {
41 | mProgressBar.setVisibility(View.GONE);
42 | } else {
43 | mProgressBar.setVisibility(View.VISIBLE);
44 | mProgressBar.setProgress(progress);
45 | }
46 | }
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/helpers/WebChromeClientWithVideoPoster.kt:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util.helpers
2 |
3 | import android.graphics.Bitmap
4 | import android.graphics.BitmapFactory
5 | import android.view.View
6 | import android.webkit.WebChromeClient
7 | import androidx.annotation.DrawableRes
8 |
9 | abstract class WebChromeClientWithVideoPoster(
10 | view: View?,
11 | @DrawableRes defaultVideoPosterRes: Int
12 | ) : WebChromeClient() {
13 | private val defaultPoster: Bitmap? = view?.context?.let {
14 | BitmapFactory.decodeResource(it.resources, defaultVideoPosterRes)
15 | }
16 |
17 | final override fun getDefaultVideoPoster(): Bitmap? {
18 | return super.getDefaultVideoPoster() ?: defaultPoster
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/helpers/logfile/LogFileCleaner.kt:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util.helpers.logfile
2 |
3 | /**
4 | * Prunes the Log File Store by retaining only the last `maxLogFileCount` log files.
5 | *
6 | * The file list is created upon instantiation – any files added
7 | * afterwards won't be modified.
8 | *
9 | * @param logFileProvider: An interface where the log files will be retrieved from
10 | * @param maxLogFileCount: The number of log files to retain
11 | */
12 | class LogFileCleaner(private val logFileProvider: LogFileProviderInterface, private val maxLogFileCount: Int) {
13 | /**
14 | * Immediately removes all log files known to exist by this instance except for
15 | * the most recent `maxLogFileCount` items.
16 | */
17 | fun clean() {
18 | logFileProvider.getLogFiles()
19 | .dropLast(maxLogFileCount)
20 | .forEach { it.delete() }
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/helpers/logfile/LogFileProvider.kt:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util.helpers.logfile
2 |
3 | import android.content.Context
4 | import java.io.File
5 |
6 | private const val LOG_FILE_DIRECTORY = "logs"
7 |
8 | /**
9 | * A collection of helpers for Log Files.
10 | */
11 | class LogFileProvider(private val logFileDirectoryPath: String) : LogFileProviderInterface {
12 | /**
13 | * Provides a {@link java.io.File} directory in which to store log files.
14 | *
15 | * If the directory doesn't already exist, it will be created.
16 | */
17 | override fun getLogFileDirectory(): File {
18 | val logFileDirectory = File(logFileDirectoryPath, LOG_FILE_DIRECTORY)
19 |
20 | if (!logFileDirectory.exists()) {
21 | logFileDirectory.mkdir()
22 | }
23 |
24 | return logFileDirectory
25 | }
26 |
27 | /**
28 | * Provides a list of stored log files, ordered oldest to newest.
29 | */
30 | override fun getLogFiles(): List {
31 | return getLogFileDirectory()
32 | .listFiles()
33 | ?.sortedBy { it.lastModified() } ?: listOf()
34 | }
35 |
36 | companion object {
37 | @JvmStatic
38 | fun fromContext(context: Context): LogFileProvider {
39 | return LogFileProvider(context.applicationInfo.dataDir)
40 | }
41 | }
42 | }
43 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/helpers/logfile/LogFileProviderInterface.kt:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util.helpers.logfile
2 |
3 | import java.io.File
4 |
5 | /**
6 | * An interface to retrieve log files
7 | */
8 | interface LogFileProviderInterface {
9 | fun getLogFiles(): List
10 |
11 | fun getLogFileDirectory(): File
12 | }
13 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/helpers/logfile/LogFileWriter.kt:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util.helpers.logfile
2 |
3 | import android.util.Log
4 | import org.jetbrains.annotations.TestOnly
5 | import java.io.File
6 | import java.io.FileWriter
7 | import java.util.Date
8 | import org.wordpress.android.util.DateTimeUtils
9 | import java.io.IOException
10 | import java.util.concurrent.ExecutorService
11 | import java.util.concurrent.Executors
12 |
13 | /**
14 | * A class that manages writing to a log file.
15 | *
16 | * This class creates and writes to a log file, and will typically persist for the entire lifecycle
17 | * of its host application.
18 | */
19 | class LogFileWriter @JvmOverloads constructor(
20 | logFileProvider: LogFileProviderInterface,
21 | fileId: String = DateTimeUtils.iso8601FromDate(Date())
22 | ) {
23 | private val file = File(logFileProvider.getLogFileDirectory(), "$fileId.log")
24 | private val fileWriter: FileWriter = FileWriter(file)
25 | private var writingFailed = false
26 |
27 | /**
28 | * A serial executor used to write to the file in a background thread
29 | */
30 | private val queue: ExecutorService = Executors.newSingleThreadExecutor()
31 |
32 | /**
33 | * A reference to the underlying {@link Java.IO.File} file.
34 | * Should only be used for testing.
35 | */
36 | @TestOnly
37 | fun getFile(): File = file
38 |
39 | /**
40 | * Writes the provided string to the log file synchronously
41 | */
42 | fun write(data: String) {
43 | if (!writingFailed) {
44 | queue.execute {
45 | try {
46 | if (!writingFailed) {
47 | fileWriter.write(data)
48 | fileWriter.flush()
49 | }
50 | } catch (ioe: IOException) {
51 | writingFailed = true
52 | Log.e("LogFileWriter", "Writing log failed: ${ioe.stackTrace}")
53 | }
54 | }
55 | }
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/widgets/CustomSwipeRefreshLayout.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util.widgets;
2 |
3 | import android.content.Context;
4 | import android.util.AttributeSet;
5 | import android.view.MotionEvent;
6 |
7 | import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
8 |
9 | import org.wordpress.android.util.AppLog;
10 | import org.wordpress.android.util.AppLog.T;
11 |
12 | public class CustomSwipeRefreshLayout extends SwipeRefreshLayout {
13 | public CustomSwipeRefreshLayout(Context context) {
14 | super(context);
15 | }
16 |
17 | public CustomSwipeRefreshLayout(Context context, AttributeSet attrs) {
18 | super(context, attrs);
19 | }
20 |
21 | @Override
22 | public boolean onTouchEvent(MotionEvent event) {
23 | try {
24 | return super.onTouchEvent(event);
25 | } catch (IllegalArgumentException e) {
26 | // Fix for https://github.com/wordpress-mobile/WordPress-Android/issues/2373
27 | // Catch IllegalArgumentException which can be fired by the underlying SwipeRefreshLayout.onTouchEvent()
28 | // method.
29 | // When android support-v4 fixes it, we'll have to remove that custom layout completely.
30 | AppLog.e(T.UTILS, e);
31 | return true;
32 | }
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/java/org/wordpress/android/util/widgets/WPTextInputLayout.java:
--------------------------------------------------------------------------------
1 | package org.wordpress.android.util.widgets;
2 |
3 | import android.content.Context;
4 | import android.util.AttributeSet;
5 | import android.view.View;
6 | import android.widget.EditText;
7 |
8 | import com.google.android.material.textfield.TextInputLayout;
9 |
10 | import org.wordpress.android.util.R;
11 |
12 | /**
13 | * Custom TextInputLayout to provide a usable getBaseline() and error view padding
14 | */
15 | public class WPTextInputLayout extends TextInputLayout {
16 | public WPTextInputLayout(Context context) {
17 | super(context);
18 | }
19 |
20 | public WPTextInputLayout(Context context, AttributeSet attrs) {
21 | super(context, attrs);
22 | }
23 |
24 | public WPTextInputLayout(Context context, AttributeSet attrs, int defStyleAttr) {
25 | super(context, attrs, defStyleAttr);
26 | }
27 |
28 | @Override
29 | public int getBaseline() {
30 | EditText editText = getEditText();
31 | return editText != null ? editText.getBaseline() - editText.getPaddingBottom()
32 | + getResources().getDimensionPixelSize(R.dimen.textinputlayout_baseline_correction)
33 | : 0;
34 | }
35 |
36 | @Override
37 | public void setErrorEnabled(boolean enabled) {
38 | super.setErrorEnabled(enabled);
39 |
40 | // remove hardcoded side padding of the error view
41 | if (enabled) {
42 | View errorView = findViewById(com.google.android.material.R.id.textinput_error);
43 | if (errorView != null && errorView.getParent() != null) {
44 | ((View) errorView.getParent())
45 | .setPadding(0, errorView.getPaddingTop(), 0, errorView.getPaddingBottom());
46 | }
47 | }
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/res/values/dimens.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 | 2dp
4 | 4.3dp
5 | -8.6dp
6 |
7 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 | There is no network available
4 | Now
5 |
6 |
--------------------------------------------------------------------------------
/WordPressUtils/src/main/res/values/tags.xml:
--------------------------------------------------------------------------------
1 |
2 |