text stringlengths 9 39.2M | dir stringlengths 25 226 | lang stringclasses 163 values | created_date timestamp[s] | updated_date timestamp[s] | repo_name stringclasses 751 values | repo_full_name stringclasses 752 values | star int64 1.01k 183k | len_tokens int64 1 18.5M |
|---|---|---|---|---|---|---|---|---|
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.content.Context;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import androidx.annotation.Nullable;
import android.view.View;
import android.widget.ImageView;
import com.bumptech.glide.load.DataSource;
import com.bumptech.glide.load.engine.DiskCacheStrategy;
import com.bumptech.glide.load.engine.GlideException;
import com.bumptech.glide.load.resource.drawable.DrawableTransitionOptions;
import com.bumptech.glide.request.RequestListener;
import com.bumptech.glide.request.RequestOptions;
import com.bumptech.glide.request.target.Target;
import java.io.File;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.glide.GlideApp;
import me.zhanghai.android.douya.network.api.info.frodo.Photo;
import me.zhanghai.android.douya.ui.ImageItem;
import me.zhanghai.android.douya.ui.SizedImageItem;
import me.zhanghai.android.douya.ui.RatioImageView;
public class ImageUtils {
private static final RequestOptions REQUEST_OPTIONS_LOAD_AVATAR = new RequestOptions()
.placeholder(R.drawable.avatar_icon_40dp)
.dontTransform();
public static void loadAvatar(ImageView view, String url) {
GlideApp.with(view.getContext())
.load(url)
.apply(REQUEST_OPTIONS_LOAD_AVATAR)
.into(view);
}
private static final RequestOptions REQUEST_OPTIONS_LOAD_ITEM_BACKDROP =
new RequestOptions()
.dontTransform();
public static void loadItemBackdropAndFadeIn(ImageView backdropView, String url,
View playView) {
GlideApp.with(backdropView.getContext())
.load(url)
.apply(REQUEST_OPTIONS_LOAD_ITEM_BACKDROP)
.listener(new RequestListener<Drawable>() {
@Override
public boolean onLoadFailed(@Nullable GlideException e, Object model,
Target<Drawable> target, boolean isFirstResource) {
(e != null ? e : new NullPointerException()).printStackTrace();
return false;
}
@Override
public boolean onResourceReady(Drawable resource, Object model,
Target<Drawable> target, DataSource dataSource,
boolean isFirstResource) {
ViewUtils.fadeIn(backdropView);
if (playView != null) {
ViewUtils.fadeIn(playView);
}
return false;
}
})
.into(backdropView);
}
private static final RequestOptions REQUEST_OPTIONS_LOAD_NAVIGATION_HEADER_AVATAR =
new RequestOptions()
.placeholder(R.drawable.avatar_icon_white_inactive_64dp)
.diskCacheStrategy(DiskCacheStrategy.ALL)
.dontTransform();
public static void loadNavigationHeaderAvatar(final ImageView view, final String url) {
Context context = view.getContext();
int size = context.getResources().getDimensionPixelSize(
R.dimen.navigation_header_avatar_size);
GlideApp.with(context)
.load(url)
.apply(REQUEST_OPTIONS_LOAD_NAVIGATION_HEADER_AVATAR
.override(size, size))
.listener(new RequestListener<Drawable>() {
@Override
public boolean onLoadFailed(@Nullable GlideException e, Object model,
Target<Drawable> target, boolean isFirstResource) {
(e != null ? e : new NullPointerException()).printStackTrace();
return false;
}
@Override
public boolean onResourceReady(Drawable resource, Object model,
Target<Drawable> target, DataSource dataSource,
boolean isFirstResource) {
view.setTag(url);
return false;
}
})
.into(view);
}
private static final RequestOptions REQUEST_OPTIONS_LOAD_NAVIGATION_ACCOUNT_LIST_AVATAR =
new RequestOptions()
.placeholder(R.drawable.avatar_icon_40dp)
.diskCacheStrategy(DiskCacheStrategy.ALL)
.dontTransform();
public static void loadNavigationAccountListAvatar(ImageView view, String url) {
Context context = view.getContext();
int size = context.getResources().getDimensionPixelSize(
R.dimen.navigation_header_avatar_size);
GlideApp.with(context)
.load(url)
.apply(REQUEST_OPTIONS_LOAD_NAVIGATION_ACCOUNT_LIST_AVATAR
.override(size, size))
.into(view);
}
private static final RequestOptions REQUEST_OPTIONS_LOAD_PROFILE_AVATAR =
new RequestOptions()
.dontTransform();
public static void loadProfileAvatarAndFadeIn(final ImageView view, String url) {
GlideApp.with(view.getContext())
.load(url)
.apply(REQUEST_OPTIONS_LOAD_PROFILE_AVATAR)
.listener(new RequestListener<Drawable>() {
@Override
public boolean onLoadFailed(@Nullable GlideException e, Object model,
Target<Drawable> target, boolean isFirstResource) {
(e != null ? e : new NullPointerException()).printStackTrace();
return false;
}
@Override
public boolean onResourceReady(Drawable resource, Object model,
Target<Drawable> target, DataSource dataSource,
boolean isFirstResource) {
ViewUtils.fadeIn(view);
return false;
}
})
.into(view);
}
private static final RequestOptions REQUEST_OPTIONS_LOAD_IMAGE = new RequestOptions()
.dontTransform()
.placeholder(android.R.color.transparent);
public static void loadImage(ImageView view, Uri uri) {
GlideApp.with(view.getContext())
.load(uri)
.apply(REQUEST_OPTIONS_LOAD_IMAGE)
.transition(DrawableTransitionOptions.withCrossFade(ViewUtils.getShortAnimTime(
view)))
.into(view);
}
public static void loadImage(ImageView view, String url, RequestListener<Drawable> listener) {
GlideApp.with(view.getContext())
.load(url)
.apply(REQUEST_OPTIONS_LOAD_IMAGE)
.transition(DrawableTransitionOptions.withCrossFade(ViewUtils.getShortAnimTime(
view)))
.listener(listener)
.into(view);
}
public static void loadImage(ImageView view, String url) {
loadImage(view, url, null);
}
public static void loadImage(ImageView view, ImageItem image) {
loadImage(view, image.getMediumUrl());
}
public static void loadImageFile(ImageView view, File file,
RequestListener<Drawable> listener) {
GlideApp.with(view.getContext())
.load(file)
.apply(REQUEST_OPTIONS_LOAD_IMAGE)
.transition(DrawableTransitionOptions.withCrossFade(ViewUtils.getShortAnimTime(
view)))
.listener(listener)
.into(view);
}
private static final RequestOptions REQUEST_OPTIONS_LOAD_IMAGE_WITH_RATIO = new RequestOptions()
// dontTransform() is required for our RatioImageView to work correctly.
.dontTransform()
.placeholder(android.R.color.transparent);
public static void loadImageWithRatio(RatioImageView view,
SizedImageItem image) {
view.setRatio(image.getMediumWidth(), image.getMediumHeight());
GlideApp.with(view.getContext())
.load(image.getMediumUrl())
.apply(REQUEST_OPTIONS_LOAD_IMAGE_WITH_RATIO)
.transition(DrawableTransitionOptions.withCrossFade(ViewUtils.getShortAnimTime(
view)))
.into(view);
}
public static void loadImageWithRatio(RatioImageView view, Photo photo) {
loadImageWithRatio(view, photo.image);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/ImageUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 1,476 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.annotation.TargetApi;
import android.app.Activity;
import android.os.Build;
import android.os.Bundle;
import androidx.core.app.ActivityCompat;
import androidx.core.app.ActivityOptionsCompat;
import androidx.fragment.app.Fragment;
import androidx.core.util.Pair;
import android.transition.Explode;
import android.transition.Transition;
import android.view.View;
import android.view.Window;
import java.util.ArrayList;
import me.zhanghai.android.douya.R;
/**
* Facts:
* - System window must be shared elements if fullscreen, otherwise overlap occurs.
* - Shared element transition overlaps old and new elements for a period of time.
* - Translucent element overlap is unacceptable.
*/
public class TransitionUtils {
private static final String TRANSITION_NAME_APPBAR = "appbar";
private TransitionUtils() {}
public static boolean shouldEnableTransition() {
// I hprof-ed the app, and found that bitmaps are kept by
// ExitTransitionCoordinator.mSharedElementsBundle, which is in turn kept by
// ResultReceiver$MyResultReceiver, which is kept by a FinalizerReference.
// But this fix (
// path_to_url
// ) should have been incorporated into android-5.0.0_r1. So I really don't know the root
// cause now.
// New finding at 2015-12-06: OOM even happens on Android 5.1 (CM).
// TODO: Allow disabling transition on some pre-marshmallow devices for OOM.
return Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP;
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static void setupTransitionBeforeDecorate(Activity activity) {
if (!shouldEnableTransition()) {
return;
}
Window window = activity.getWindow();
window.requestFeature(Window.FEATURE_CONTENT_TRANSITIONS);
window.setSharedElementsUseOverlay(false);
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static void postponeTransition(Activity activity) {
if (!shouldEnableTransition()) {
return;
}
ActivityCompat.postponeEnterTransition(activity);
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static void setupTransitionOnActivityCreated(Fragment fragment) {
if (!shouldEnableTransition()) {
return;
}
setupTransitionForAppBar(fragment);
ActivityCompat.startPostponedEnterTransition(fragment.getActivity());
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static void setupTransitionForAppBar(Fragment fragment) {
if (!shouldEnableTransition()) {
return;
}
View appbar = fragment.getView().findViewById(R.id.appBarWrapper);
if (appbar != null) {
appbar.setTransitionName(TRANSITION_NAME_APPBAR);
}
}
// AppCompatDelegateImplV7.setContentView() removes all views under android.R.id.content, so we
// have to do this after it.
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static void setupTransitionAfterSetContentView(Activity activity) {
if (!shouldEnableTransition()) {
return;
}
setupTransitionForAppBar(activity);
postponeTransitionUntilDecorViewPreDraw(activity);
}
// FIXME: Duplicate code.
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static void setupTransitionForAppBar(Activity activity) {
if (!shouldEnableTransition()) {
return;
}
View appbar = activity.findViewById(R.id.appBarWrapper);
if (appbar != null) {
appbar.setTransitionName(TRANSITION_NAME_APPBAR);
}
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
private static void postponeTransitionUntilDecorViewPreDraw(final Activity activity) {
if (!shouldEnableTransition()) {
return;
}
activity.postponeEnterTransition();
ViewUtils.postOnPreDraw(activity.getWindow().getDecorView(), new Runnable() {
@Override
public void run() {
activity.startPostponedEnterTransition();
}
});
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static void setEnterReturnExplode(Fragment fragment) {
if (!shouldEnableTransition()) {
return;
}
Window window = fragment.getActivity().getWindow();
Transition explode = new Explode()
.excludeTarget(android.R.id.statusBarBackground, true)
.excludeTarget(android.R.id.navigationBarBackground, true);
window.setEnterTransition(explode);
window.setReturnTransition(explode);
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static void postAfterTransition(Fragment fragment, Runnable runnable) {
if (!shouldEnableTransition()) {
runnable.run();
return;
}
// HACK: Horrible hack, because we have no good way of being notified at the end of
// transition.
Activity activity = fragment.getActivity();
activity.getWindow().getDecorView().postDelayed(runnable,
ViewUtils.getMediumAnimTime(activity));
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static Bundle makeActivityOptionsBundle(Activity activity, View... sharedViews) {
if (!shouldEnableTransition()) {
return null;
}
ArrayList<Pair<View, String>> sharedElementList = new ArrayList<>();
for (View sharedView : sharedViews) {
sharedElementList.add(Pair.create(sharedView, sharedView.getTransitionName()));
}
View appbar = activity.findViewById(R.id.appBarWrapper);
if (appbar != null) {
sharedElementList.add(Pair.create(appbar, appbar.getTransitionName()));
}
//noinspection unchecked
Pair<View, String>[] sharedElements =
sharedElementList.toArray(new Pair[sharedElementList.size()]);
//noinspection unchecked
return ActivityOptionsCompat.makeSceneTransitionAnimation(activity, sharedElements)
.toBundle();
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/TransitionUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 1,238 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.webkit.MimeTypeMap;
import com.bumptech.glide.load.ImageHeaderParser;
import com.bumptech.glide.load.resource.bitmap.DefaultImageHeaderParser;
import java.io.IOException;
import java.io.InputStream;
public class FileTypeUtils {
private static final ImageHeaderParser sImageHeaderParser = new DefaultImageHeaderParser();
private FileTypeUtils() {}
public static String getImageMimeType(InputStream inputStream, String defaultMimeType)
throws IOException {
ImageHeaderParser.ImageType imageType = sImageHeaderParser.getType(inputStream);
String extension;
switch (imageType) {
case GIF:
extension = "gif";
break;
case JPEG:
extension = "jpg";
break;
case PNG_A:
case PNG:
extension = "png";
break;
case WEBP_A:
case WEBP:
extension = "webp";
break;
default:
return defaultMimeType;
}
// See FileProvider.getType(Uri)
return MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
}
public static String getImageMimeType(InputStream inputStream) throws IOException {
return getImageMimeType(inputStream, null);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/FileTypeUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 252 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
public interface Callback<T> {
void onValue(T value);
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/Callback.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 33 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.annotation.SuppressLint;
import android.content.res.Resources;
import android.os.Build;
import android.os.Build.VERSION;
import androidx.annotation.MainThread;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.RequiresApi;
import android.util.ArrayMap;
import android.util.LongSparseArray;
import java.lang.reflect.Field;
import java.util.Map;
/**
* This class flushes all the entries of ThemedResourceCache, instead of only mUnthemedEntries as in
* AppCompat.
*
* @see androidx.appcompat.app.ResourcesFlusher
*/
public class ResourcesFlusher {
private ResourcesFlusher() {}
@Nullable
private static Field sDrawableCacheField;
private static boolean sDrawableCacheFieldInitialized;
@Nullable
private static Class sThemedResourceCacheClass;
private static boolean sThemedResourceCacheClassInitialized;
@Nullable
private static Field sThemedResourceCacheMThemedEntriesField;
private static boolean sThemedResourceCacheMThemedEntriesFieldInitialized;
@Nullable
private static Field sThemedResourceCacheMUnthemedEntriesField;
private static boolean sThemedResourceCacheMUnthemedEntriesFieldInitialized;
@Nullable
private static Field sThemedResourceCacheMNullThemedEntriesField;
private static boolean sThemedResourceCacheMNullThemedEntriesFieldInitialized;
@Nullable
private static Field sResourcesImplField;
private static boolean sResourcesImplFieldInitialized;
@MainThread
public static void flush(@NonNull Resources resources) {
if (VERSION.SDK_INT >= Build.VERSION_CODES.P) {
// Do nothing.
} else if (VERSION.SDK_INT >= Build.VERSION_CODES.N) {
flushNougat(resources);
} else if (VERSION.SDK_INT >= Build.VERSION_CODES.M) {
flushMarshmallow(resources);
} else if (VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
flushLollipop(resources);
}
}
@MainThread
@RequiresApi(Build.VERSION_CODES.LOLLIPOP)
private static void flushLollipop(@NonNull Resources resources) {
if (!sDrawableCacheFieldInitialized) {
try {
//noinspection JavaReflectionMemberAccess
sDrawableCacheField = Resources.class.getDeclaredField("mDrawableCache");
sDrawableCacheField.setAccessible(true);
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
sDrawableCacheFieldInitialized = true;
}
if (sDrawableCacheField == null) {
return;
}
Map drawableCache = null;
try {
drawableCache = (Map)sDrawableCacheField.get(resources);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
if (drawableCache == null) {
return;
}
drawableCache.clear();
}
@MainThread
@RequiresApi(Build.VERSION_CODES.M)
private static void flushMarshmallow(@NonNull Resources resources) {
if (!sDrawableCacheFieldInitialized) {
try {
//noinspection JavaReflectionMemberAccess
sDrawableCacheField = Resources.class.getDeclaredField("mDrawableCache");
sDrawableCacheField.setAccessible(true);
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
sDrawableCacheFieldInitialized = true;
}
if (sDrawableCacheField == null) {
return;
}
Object drawableCache = null;
try {
drawableCache = sDrawableCacheField.get(resources);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
if (drawableCache == null) {
return;
}
flushThemedResourceCache(drawableCache);
}
@MainThread
@RequiresApi(Build.VERSION_CODES.N)
private static void flushNougat(@NonNull Resources resources) {
if (!sResourcesImplFieldInitialized) {
try {
//noinspection JavaReflectionMemberAccess
sResourcesImplField = Resources.class.getDeclaredField("mResourcesImpl");
sResourcesImplField.setAccessible(true);
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
sResourcesImplFieldInitialized = true;
}
if (sResourcesImplField == null) {
return;
}
Object resourcesImpl = null;
try {
resourcesImpl = sResourcesImplField.get(resources);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
if (resourcesImpl == null) {
return;
}
if (!sDrawableCacheFieldInitialized) {
try {
sDrawableCacheField = resourcesImpl.getClass().getDeclaredField("mDrawableCache");
sDrawableCacheField.setAccessible(true);
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
sDrawableCacheFieldInitialized = true;
}
if (sDrawableCacheField == null) {
return;
}
Object drawableCache = null;
try {
drawableCache = sDrawableCacheField.get(resourcesImpl);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
if (drawableCache == null) {
return;
}
flushThemedResourceCache(drawableCache);
}
@MainThread
@RequiresApi(Build.VERSION_CODES.M)
@SuppressLint("PrivateApi")
private static void flushThemedResourceCache(@NonNull Object themedResourceCache) {
if (!sThemedResourceCacheClassInitialized) {
try {
sThemedResourceCacheClass = Class.forName(
"android.content.res.ThemedResourceCache");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
sThemedResourceCacheClassInitialized = true;
}
if (sThemedResourceCacheClass == null) {
return;
}
if (!sThemedResourceCacheMThemedEntriesFieldInitialized) {
try {
sThemedResourceCacheMThemedEntriesField =
sThemedResourceCacheClass.getDeclaredField("mThemedEntries");
sThemedResourceCacheMThemedEntriesField.setAccessible(true);
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
sThemedResourceCacheMThemedEntriesFieldInitialized = true;
}
if (sThemedResourceCacheMThemedEntriesField != null) {
ArrayMap themedEntries = null;
try {
themedEntries = (ArrayMap) sThemedResourceCacheMThemedEntriesField.get(
themedResourceCache);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
if (themedEntries != null) {
themedEntries.clear();
}
}
if (!sThemedResourceCacheMUnthemedEntriesFieldInitialized) {
try {
sThemedResourceCacheMUnthemedEntriesField =
sThemedResourceCacheClass.getDeclaredField("mUnthemedEntries");
sThemedResourceCacheMUnthemedEntriesField.setAccessible(true);
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
sThemedResourceCacheMUnthemedEntriesFieldInitialized = true;
}
if (sThemedResourceCacheMUnthemedEntriesField != null) {
LongSparseArray unthemedEntries = null;
try {
unthemedEntries = (LongSparseArray) sThemedResourceCacheMUnthemedEntriesField.get(
themedResourceCache);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
if (unthemedEntries != null) {
unthemedEntries.clear();
}
}
if (!sThemedResourceCacheMNullThemedEntriesFieldInitialized) {
try {
sThemedResourceCacheMNullThemedEntriesField =
sThemedResourceCacheClass.getDeclaredField("mNullThemedEntries");
sThemedResourceCacheMNullThemedEntriesField.setAccessible(true);
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
sThemedResourceCacheMNullThemedEntriesFieldInitialized = true;
}
if (sThemedResourceCacheMNullThemedEntriesField != null) {
LongSparseArray nullThemedEntries = null;
try {
nullThemedEntries = (LongSparseArray)
sThemedResourceCacheMNullThemedEntriesField.get(themedResourceCache);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
if (nullThemedEntries != null) {
nullThemedEntries.clear();
}
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/ResourcesFlusher.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 1,780 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.os.Bundle;
import android.os.Parcelable;
import android.util.Pair;
import com.google.gson.Gson;
import com.google.gson.TypeAdapter;
import com.google.gson.TypeAdapterFactory;
import com.google.gson.reflect.TypeToken;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
/**
* Type adapter for Android Bundle. It only stores the actual properties set in the bundle
*
* @author Inderjeet Singh
* @author Zhang Hai
*/
public class BundleTypeAdapterFactory implements TypeAdapterFactory {
@SuppressWarnings("unchecked")
@Override
public <T> TypeAdapter<T> create(final Gson gson, TypeToken<T> type) {
if (!Bundle.class.isAssignableFrom(type.getRawType())) {
return null;
}
return (TypeAdapter<T>) new TypeAdapter<Bundle>() {
@Override
public void write(JsonWriter out, Bundle bundle) throws IOException {
if (bundle == null) {
out.nullValue();
return;
}
out.beginObject();
for (String key : bundle.keySet()) {
out.name(key);
Object value = bundle.get(key);
if (value == null) {
out.nullValue();
} else {
gson.toJson(value, value.getClass(), out);
}
}
out.endObject();
}
@Override
public Bundle read(JsonReader in) throws IOException {
switch (in.peek()) {
case NULL:
in.nextNull();
return null;
case BEGIN_OBJECT:
return toBundle(readObject(in));
default:
throw new IOException("Expecting object: " + in.getPath());
}
}
private Bundle toBundle(List<Pair<String, Object>> values) throws IOException {
Bundle bundle = new Bundle();
for (Pair<String, Object> entry : values) {
String key = entry.first;
Object value = entry.second;
if (value instanceof String) {
bundle.putString(key, (String) value);
} else if (value instanceof Boolean) {
bundle.putBoolean(key, (Boolean) value);
} else if (value instanceof Integer) {
bundle.putInt(key, (Integer) value);
} else if (value instanceof Long) {
bundle.putLong(key, (Long) value);
} else if (value instanceof Double) {
bundle.putDouble(key, (Double) value);
} else if (value instanceof Parcelable) {
bundle.putParcelable(key, (Parcelable) value);
} else if (value instanceof List) {
List<Pair<String, Object>> objectValues =
(List<Pair<String, Object>>) value;
Bundle subBundle = toBundle(objectValues);
bundle.putParcelable(key, subBundle);
} else {
throw new IOException("Unparcelable key, value: " + key + ", "+ value);
}
}
return bundle;
}
private List<Pair<String, Object>> readObject(JsonReader in) throws IOException {
List<Pair<String, Object>> object = new ArrayList<>();
in.beginObject();
while (in.peek() != JsonToken.END_OBJECT) {
switch (in.peek()) {
case NAME:
String name = in.nextName();
Object value = readValue(in);
object.add(new Pair<>(name, value));
break;
case END_OBJECT:
break;
default:
throw new IOException("Expecting object: " + in.getPath());
}
}
in.endObject();
return object;
}
private Object readValue(JsonReader in) throws IOException {
switch (in.peek()) {
case BEGIN_ARRAY:
return readArray(in);
case BEGIN_OBJECT:
return readObject(in);
case BOOLEAN:
return in.nextBoolean();
case NULL:
in.nextNull();
return null;
case NUMBER:
return readNumber(in);
case STRING:
return in.nextString();
default:
throw new IOException("Expecting value: " + in.getPath());
}
}
private Object readNumber(JsonReader in) throws IOException {
double doubleValue = in.nextDouble();
if (doubleValue - Math.ceil(doubleValue) == 0) {
long longValue = (long) doubleValue;
if (longValue >= Integer.MIN_VALUE && longValue <= Integer.MAX_VALUE) {
return (int) longValue;
}
return longValue;
}
return doubleValue;
}
private List<Object> readArray(JsonReader in) throws IOException {
List<Object> list = new ArrayList<>();
in.beginArray();
while (in.peek() != JsonToken.END_ARRAY) {
Object element = readValue(in);
list.add(element);
}
in.endArray();
return list;
}
};
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/BundleTypeAdapterFactory.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 1,028 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.content.ClipData;
import android.content.ClipboardManager;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.core.content.ContextCompat;
import android.text.TextUtils;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.network.api.info.ClipboardCopyable;
public class ClipboardUtils {
private static final int TOAST_COPIED_TEXT_MAX_LENGTH = 40;
private ClipboardUtils() {}
@NonNull
private static ClipboardManager getClipboardManager(@NonNull Context context) {
return ContextCompat.getSystemService(context, ClipboardManager.class);
}
@Nullable
public static CharSequence readText(@NonNull Context context) {
ClipData clipData = getClipboardManager(context).getPrimaryClip();
if (clipData == null || clipData.getItemCount() == 0) {
return null;
}
return clipData.getItemAt(0).coerceToText(context);
}
public static void copyText(@Nullable CharSequence label, @NonNull CharSequence text,
@NonNull Context context) {
ClipData clipData = ClipData.newPlainText(label, text);
getClipboardManager(context).setPrimaryClip(clipData);
showToast(text, context);
}
public static void copyText(@Nullable CharSequence text, @NonNull Context context) {
copyText(null, text, context);
}
public static void copy(ClipboardCopyable copyable, Context context) {
copyText(copyable.getClipboardLabel(context), copyable.getClipboardText(context), context);
}
private static void showToast(@NonNull CharSequence copiedText, @NonNull Context context) {
boolean ellipsized = false;
if (copiedText.length() > TOAST_COPIED_TEXT_MAX_LENGTH) {
copiedText = copiedText.subSequence(0, TOAST_COPIED_TEXT_MAX_LENGTH);
ellipsized = true;
}
int indexOfFirstNewline = TextUtils.indexOf(copiedText, '\n');
if (indexOfFirstNewline != -1) {
int indexOfSecondNewline = TextUtils.indexOf(copiedText, '\n', indexOfFirstNewline + 1);
if (indexOfSecondNewline != -1) {
copiedText = copiedText.subSequence(0, indexOfSecondNewline);
ellipsized = true;
}
}
if (ellipsized) {
copiedText = copiedText.toString() + '\u2026';
}
ToastUtils.show(context.getString(R.string.copied_to_clipboard_format, copiedText),
context);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/ClipboardUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 561 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.content.Context;
import android.net.Uri;
import android.os.Environment;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import me.zhanghai.android.douya.BuildConfig;
import me.zhanghai.android.douya.app.ImageTypeFileProvider;
public class FileUtils {
// Should be kept in sync with file_provider_paths.xml .
private static final String SUB_DIRECTORY_NAME = "Douya";
private FileUtils() {}
public static void copy(File input, File output) throws IOException {
try (InputStream inputStream = new FileInputStream(input);
OutputStream outputStream = new FileOutputStream(output)) {
IoUtils.inputStreamToOutputStream(inputStream, outputStream);
}
}
public static File makeCaptureImageOutputFile() {
String timestamp = new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(new Date());
String fileName = "IMG_" + timestamp + ".jpg";
return makeSaveImageOutputFile(fileName);
}
public static File makeSaveImageOutputFile(String fileName) {
File directory = new File(Environment.getExternalStoragePublicDirectory(
Environment.DIRECTORY_PICTURES), SUB_DIRECTORY_NAME);
//noinspection ResultOfMethodCallIgnored
directory.mkdirs();
return new File(directory, fileName);
}
public static Uri getContentUri(File file, Context context) {
return ImageTypeFileProvider.getUriForFile(context, BuildConfig.FILE_PROVIDIER_AUTHORITY,
file);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/FileUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 348 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.os.ParcelFileDescriptor;
import androidx.annotation.NonNull;
import android.util.Base64;
import org.json.JSONArray;
import org.json.JSONException;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.Reader;
import java.nio.charset.Charset;
import java.util.Collection;
public class IoUtils {
private static final int BUFFER_SIZE = 4 * 1024;
private static final char[] HEX_DIGITS_LOWER_CASED = "0123456789abcdef".toCharArray();
private static final char[] HEX_DIGITS_UPPER_CASED = "0123456789ABCDEF".toCharArray();
private static final String STRING_DELIMITER = "|";
private static final String STRING_DELIMITER_REGEX = "\\|";
private IoUtils() {}
public static void close(Closeable closeable) {
try {
closeable.close();
} catch (IOException e) {
e.printStackTrace();
}
}
// ParcelFileDescriptor did not implement Closable before API level 16.
public static void close(ParcelFileDescriptor parcelFileDescriptor) {
try {
parcelFileDescriptor.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static String fileToString(File file, Charset charset) throws IOException {
try (InputStream inputStream = new FileInputStream(file)) {
return inputStreamToString(inputStream, charset);
}
}
public static long inputStreamToOutputStream(@NonNull InputStream inputStream,
@NonNull OutputStream outputStream)
throws IOException {
long count = 0;
byte[] buffer = new byte[BUFFER_SIZE];
int length;
while ((length = inputStream.read(buffer)) != -1) {
outputStream.write(buffer, 0, length);
count += length;
}
return count;
}
@NonNull
public static String inputStreamToString(@NonNull InputStream inputStream,
@NonNull Charset charset) throws IOException {
return readerToString(new InputStreamReader(inputStream, charset));
}
@NonNull
public static String readerToString(@NonNull Reader reader) throws IOException {
StringBuilder builder = new StringBuilder();
char[] buffer = new char[BUFFER_SIZE];
int length;
while ((length = reader.read(buffer)) != -1) {
builder.append(buffer, 0, length);
}
return builder.toString();
}
public static void stringToFile(String string, File file, Charset charset) throws IOException {
try (OutputStream outputStream = new FileOutputStream(file)) {
stringToOutputStream(string, outputStream, charset);
}
}
public static void stringToOutputStream(String string, OutputStream outputStream,
Charset charset) throws IOException {
outputStream.write(string.getBytes(charset));
}
@NonNull
public static String byteArrayToBase64(@NonNull byte[] bytes) {
// We are using Base64 in Json so we don't want newlines here.
return Base64.encodeToString(bytes, Base64.NO_WRAP);
}
@NonNull
public static byte[] base64ToByteArray(@NonNull String base64) {
return Base64.decode(base64, Base64.DEFAULT);
}
private static String byteArrayToHexString(byte[] bytes, char[] digits) {
char[] chars = new char[bytes.length * 2];
for (int i = 0, j = 0; i < bytes.length; ++i) {
chars[j++] = digits[(0xF0 & bytes[i]) >>> 4];
chars[j++] = digits[0x0F & bytes[i]];
}
return new String(chars);
}
public static String byteArrayToHexString(byte[] bytes, boolean lowerCased) {
return byteArrayToHexString(bytes, lowerCased ? HEX_DIGITS_LOWER_CASED
: HEX_DIGITS_UPPER_CASED);
}
public static String byteArrayToHexString(byte[] bytes) {
return byteArrayToHexString(bytes, false);
}
// NOTE: This function is null-tolerant, nulls will be printed as "null" (so it will stay "null"
// instead of null)
public static String stringArrayToString(String[] strings, String delimiter) {
StringBuilder builder = new StringBuilder();
boolean first = true;
for (String string : strings) {
if (first) {
first = false;
} else {
builder.append(delimiter);
}
builder.append(string);
}
return builder.toString();
}
public static String stringArrayToString(String[] strings) {
return stringArrayToString(strings, STRING_DELIMITER);
}
public static String jsonStringArrayToString(JSONArray jsonArray, String delimiter)
throws JSONException {
StringBuilder builder = new StringBuilder();
int numStrings = jsonArray.length();
for (int i = 0; i < numStrings; ++i) {
if (i != 0) {
builder.append(delimiter);
}
builder.append(jsonArray.getString(i));
}
return builder.toString();
}
public static String jsonStringArrayToString(JSONArray jsonArray) throws JSONException {
return jsonStringArrayToString(jsonArray, STRING_DELIMITER);
}
public static <T> String arrayToString(T[] array, Stringifier<T> stringifier,
String delimiter) {
StringBuilder builder = new StringBuilder();
boolean first = true;
for (T object : array) {
if (first) {
first = false;
} else {
builder.append(delimiter);
}
builder.append(stringifier.stringify(object));
}
return builder.toString();
}
public static <T> String arrayToString(T[] array, Stringifier<T> stringifier) {
return arrayToString(array, stringifier, STRING_DELIMITER);
}
public static <T> String collectionToString(Collection<T> collection,
Stringifier<T> stringifier, String delimiter) {
StringBuilder builder = new StringBuilder();
boolean first = true;
for (T object : collection) {
if (first) {
first = false;
} else {
builder.append(delimiter);
}
builder.append(stringifier.stringify(object));
}
return builder.toString();
}
public static <T> String collectionToString(Collection<T> collection,
Stringifier<T> stringifier) {
return collectionToString(collection, stringifier, STRING_DELIMITER);
}
public static <T> String collectionToString(Collection<T> collection) {
return collectionToString(collection, new Stringifier<T>() {
@Override
public String stringify(T object) {
return object.toString();
}
}, STRING_DELIMITER);
}
// Consecutive tokens make an empty string; if you want to avoid this, use regex like "\\|+".
public static String[] stringToStringArray(String string) {
return stringToStringArray(string, STRING_DELIMITER_REGEX);
}
public static String[] stringToStringArray(String string, String delimiterRegex) {
// String.split() returns the original String if pattern is not found, but we need to return
// an empty array when the string is empty, instead an array containing the original empty
// string.
if (string.isEmpty()) {
return new String[0];
} else {
return string.split(delimiterRegex);
}
}
public interface Stringifier<T> {
String stringify(T object);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/IoUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 1,552 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.os.Parcel;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import android.text.TextUtils;
public class ParcelCompat {
private ParcelCompat() {}
/**
* @see androidx.core.os.ParcelCompat#readBoolean(Parcel)
*/
public static boolean readBoolean(@NonNull Parcel in) {
return androidx.core.os.ParcelCompat.readBoolean(in);
}
/**
* @see androidx.core.os.ParcelCompat#writeBoolean(Parcel, boolean)
*/
public static void writeBoolean(@NonNull Parcel out, boolean value) {
androidx.core.os.ParcelCompat.writeBoolean(out, value);
}
/*
* @see android.os.Parcel#readCharSequence()
*/
public static CharSequence readCharSequence(@NonNull Parcel in) {
return TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in);
}
/*
* @see android.os.Parcel#writeCharSequence(CharSequence)
*/
public static void writeCharSequence(@NonNull Parcel out, @Nullable CharSequence value) {
TextUtils.writeToParcel(value, out, 0);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/ParcelCompat.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 237 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.annotation.SuppressLint;
import android.content.Context;
import android.os.Build;
import android.os.storage.StorageVolume;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.RequiresApi;
import java.io.File;
import me.zhanghai.android.douya.reflected.ReflectedMethod;
/**
* @see StorageVolume
* @see <a href="path_to_url">
* ics-mr0-release/StorageVolume.java</a>
* @see <a href="path_to_url">
* hiddenapi-light-greylist.txt</a>
*/
public class StorageVolumeCompat {
@NonNull
@SuppressLint("NewApi")
private static final ReflectedMethod sGetPathMethod = new ReflectedMethod(StorageVolume.class,
"getPath");
@NonNull
@RequiresApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
@SuppressLint("NewApi")
private static final ReflectedMethod sGetPathFileMethod = new ReflectedMethod(
StorageVolume.class, "getPathFile");
@NonNull
@SuppressLint("NewApi")
private static final ReflectedMethod sGetDescriptionMethod = new ReflectedMethod(
StorageVolume.class, "getDescription");
private StorageVolumeCompat() {}
/*
* @see StorageVolume#getPath()
*/
@NonNull
public static String getPath(@NonNull StorageVolume storageVolume) {
return sGetPathMethod.invoke(storageVolume);
}
/*
* @see StorageVolume#getPathFile()
*/
@NonNull
public static File getPathFile(@NonNull StorageVolume storageVolume) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
return sGetPathFileMethod.invoke(storageVolume);
} else {
String path = getPath(storageVolume);
return new File(path);
}
}
/**
* @see StorageVolume#getDescription(Context)
*/
@NonNull
@SuppressLint("NewApi")
public static String getDescription(@NonNull StorageVolume storageVolume,
@NonNull Context context) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
return storageVolume.getDescription(context);
} else {
return sGetDescriptionMethod.invoke(storageVolume);
}
}
/**
* @see StorageVolume#isPrimary()
*/
@RequiresApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
@SuppressLint("NewApi")
public static boolean isPrimary(@NonNull StorageVolume storageVolume) {
return storageVolume.isPrimary();
}
/**
* @see StorageVolume#isRemovable()
*/
@SuppressLint("NewApi")
public static boolean isRemovable(@NonNull StorageVolume storageVolume) {
return storageVolume.isRemovable();
}
/**
* @see StorageVolume#isEmulated()
*/
@SuppressLint("NewApi")
public static boolean isEmulated(@NonNull StorageVolume storageVolume) {
return storageVolume.isEmulated();
}
/**
* @see StorageVolume#getUuid()
*/
@Nullable
@RequiresApi(Build.VERSION_CODES.KITKAT_WATCH)
@SuppressLint("NewApi")
public static String getUuid(@NonNull StorageVolume storageVolume) {
return storageVolume.getUuid();
}
/**
* @see StorageVolume#getState()
*/
@NonNull
@RequiresApi(Build.VERSION_CODES.KITKAT_WATCH)
@SuppressLint("NewApi")
public static String getState(@NonNull StorageVolume storageVolume) {
return storageVolume.getState();
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/StorageVolumeCompat.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 757 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.graphics.Bitmap;
import android.graphics.BitmapShader;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.Shader;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Build;
public class BitmapUtils {
private BitmapUtils() {}
public static Bitmap cropBitmapToOval(Bitmap bitmap) {
int width = bitmap.getWidth();
int height = bitmap.getHeight();
Bitmap ovalBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(ovalBitmap);
Paint paint = new Paint();
paint.setAntiAlias(true);
paint.setShader(new BitmapShader(bitmap, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP));
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
canvas.drawRoundRect(0, 0, width, height, width / 2, height / 2, paint);
} else {
RectF rect = new RectF(0, 0, width, height);
canvas.drawRoundRect(rect, width / 2, height / 2, paint);
}
return ovalBitmap;
}
// Will change bounds of the drawable, but in most cases we don't care.
public static Bitmap drawableToBitmap(Drawable drawable) {
if (drawable instanceof BitmapDrawable) {
return ((BitmapDrawable) drawable).getBitmap();
}
int width = drawable.getIntrinsicWidth();
int height = drawable.getIntrinsicHeight();
Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(bitmap);
drawable.setBounds(0, 0, width, height);
drawable.draw(canvas);
return bitmap;
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/BitmapUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 395 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.app.Activity;
import android.content.Context;
import android.content.res.ColorStateList;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.graphics.Typeface;
import android.graphics.drawable.Drawable;
import android.os.Build;
import androidx.annotation.AnyRes;
import androidx.annotation.AttrRes;
import androidx.annotation.Dimension;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.Px;
import androidx.annotation.StyleRes;
import com.google.android.material.textfield.TextInputLayout;
import androidx.core.util.ObjectsCompat;
import androidx.core.view.MarginLayoutParamsCompat;
import androidx.core.view.ViewCompat;
import androidx.interpolator.view.animation.FastOutLinearInInterpolator;
import androidx.interpolator.view.animation.FastOutSlowInInterpolator;
import androidx.drawerlayout.widget.DrawerLayout;
import androidx.appcompat.content.res.AppCompatResources;
import androidx.appcompat.view.ContextThemeWrapper;
import android.text.Editable;
import android.text.TextWatcher;
import android.util.DisplayMetrics;
import android.util.TypedValue;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewTreeObserver;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.TextView;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.functional.compat.BooleanSupplier;
import me.zhanghai.android.douya.ui.ClickableMovementMethod;
import me.zhanghai.android.douya.ui.LinkArrowKeyMovementMethod;
public class ViewUtils {
private ViewUtils() {}
public static void fadeOut(@NonNull View view, int duration, boolean gone,
@Nullable Runnable nextRunnable) {
if (view.getVisibility() != View.VISIBLE || view.getAlpha() == 0) {
// Cancel any starting animation.
view.animate()
.alpha(0)
.setDuration(0)
.start();
view.setVisibility(gone ? View.GONE : View.INVISIBLE);
if (nextRunnable != null) {
nextRunnable.run();
}
return;
}
view.animate()
.alpha(0)
.setDuration(duration)
.setInterpolator(new FastOutLinearInInterpolator())
.setListener(new AnimatorListenerAdapter() {
private boolean mCanceled = false;
@Override
public void onAnimationCancel(@NonNull Animator animator) {
mCanceled = true;
}
@Override
public void onAnimationEnd(@NonNull Animator animator) {
if (!mCanceled) {
view.setVisibility(gone ? View.GONE : View.INVISIBLE);
if (nextRunnable != null) {
nextRunnable.run();
}
}
}
})
.start();
}
public static void fadeOut(@NonNull View view, int duration, boolean gone) {
fadeOut(view, duration, gone, null);
}
public static void fadeOut(@NonNull View view, boolean gone) {
fadeOut(view, getShortAnimTime(view), gone);
}
public static void fadeOut(@NonNull View view) {
fadeOut(view, true);
}
public static void fadeIn(@NonNull View view, int duration) {
if (view.getVisibility() == View.VISIBLE && view.getAlpha() == 1) {
// Cancel any starting animation.
view.animate()
.alpha(1)
.setDuration(0)
.start();
return;
}
view.setAlpha(isVisible(view) ? view.getAlpha() : 0);
view.setVisibility(View.VISIBLE);
view.animate()
.alpha(1)
.setDuration(duration)
.setInterpolator(new FastOutSlowInInterpolator())
// NOTE: We need to remove any previously set listener or Android will reuse it.
.setListener(null)
.start();
}
public static void fadeIn(@NonNull View view) {
fadeIn(view, getShortAnimTime(view));
}
public static void fadeToVisibility(@NonNull View view, boolean visible, boolean gone) {
if (visible) {
fadeIn(view);
} else {
fadeOut(view, gone);
}
}
public static void fadeToVisibility(@NonNull View view, boolean visible) {
fadeToVisibility(view, visible, true);
}
public static void crossfade(@NonNull View fromView, @NonNull View toView, int duration,
boolean gone) {
fadeOut(fromView, duration, gone);
fadeIn(toView, duration);
}
public static void crossfade(@NonNull View fromView, @NonNull View toView, boolean gone) {
crossfade(fromView, toView, getShortAnimTime(fromView), gone);
}
public static void crossfade(@NonNull View fromView, @NonNull View toView) {
crossfade(fromView, toView, true);
}
public static void fadeOutThenFadeIn(@NonNull View fromView, @NonNull View toView, int duration,
boolean gone) {
fadeOut(fromView, duration, gone, () -> fadeIn(toView, duration));
}
public static void fadeOutThenFadeIn(@NonNull View fromView, @NonNull View toView,
boolean gone) {
fadeOutThenFadeIn(fromView, toView, getShortAnimTime(fromView), gone);
}
public static void fadeOutThenFadeIn(@NonNull View fromView, @NonNull View toView) {
fadeOutThenFadeIn(fromView, toView, true);
}
@Dimension
public static float dpToPx(@Dimension(unit = Dimension.DP) float dp, @NonNull Context context) {
DisplayMetrics metrics = context.getResources().getDisplayMetrics();
return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, metrics);
}
@Px
public static int dpToPxOffset(@Dimension(unit = Dimension.DP) float dp,
@NonNull Context context) {
return (int) dpToPx(dp, context);
}
@Px
public static int dpToPxSize(@Dimension(unit = Dimension.DP) float dp,
@NonNull Context context) {
float value = dpToPx(dp, context);
int size = (int) (value >= 0 ? value + 0.5f : value - 0.5f);
if (size != 0) {
return size;
} else if (value == 0) {
return 0;
} else if (value > 0) {
return 1;
} else {
return -1;
}
}
public static boolean getBooleanFromAttrRes(@AttrRes int attrRes, boolean defaultValue,
@NonNull Context context) {
TypedArray a = context.obtainStyledAttributes(new int[] { attrRes });
try {
return a.getBoolean(0, defaultValue);
} finally {
a.recycle();
}
}
public static int getColorFromAttrRes(@AttrRes int attrRes, int defaultValue,
@NonNull Context context) {
// If attrRes points to a color state list, we need to use the compat parsing.
ColorStateList colorStateList = getColorStateListFromAttrRes(attrRes, context);
if (colorStateList == null) {
return defaultValue;
}
return colorStateList.getDefaultColor();
}
@Nullable
public static ColorStateList getColorStateListFromAttrRes(@AttrRes int attrRes,
@NonNull Context context) {
// TODO: Switch to TintTypedArray when they added this overload.
TypedArray a = context.obtainStyledAttributes(new int[] { attrRes });
try {
// 0 is an invalid identifier according to the docs of {@link Resources}.
int resId = a.getResourceId(0, 0);
if (resId != 0) {
return AppCompatResources.getColorStateList(context, resId);
}
return a.getColorStateList(0);
} finally {
a.recycle();
}
}
@Dimension
public static float getDimensionFromAttrRes(@AttrRes int attrRes, float defaultValue,
@NonNull Context context) {
TypedArray a = context.obtainStyledAttributes(new int[] { attrRes });
try {
return a.getDimension(0, defaultValue);
} finally {
a.recycle();
}
}
@Px
public static int getDimensionPixelOffsetFromAttrRes(@AttrRes int attrRes, int defaultValue,
@NonNull Context context) {
TypedArray a = context.obtainStyledAttributes(new int[] { attrRes });
try {
return a.getDimensionPixelOffset(0, defaultValue);
} finally {
a.recycle();
}
}
@Px
public static int getDimensionPixelSizeFromAttrRes(@AttrRes int attrRes, int defaultValue,
@NonNull Context context) {
TypedArray a = context.obtainStyledAttributes(new int[] { attrRes });
try {
return a.getDimensionPixelSize(0, defaultValue);
} finally {
a.recycle();
}
}
@Nullable
public static Drawable getDrawableFromAttrRes(@AttrRes int attrRes, @NonNull Context context) {
// TODO: Switch to TintTypedArray when they added this overload.
TypedArray a = context.obtainStyledAttributes(new int[] { attrRes });
try {
// 0 is an invalid identifier according to the docs of {@link Resources}.
int resId = a.getResourceId(0, 0);
if (resId != 0) {
return AppCompatResources.getDrawable(context, resId);
}
return null;
} finally {
a.recycle();
}
}
public static float getFloatFromAttrRes(@AttrRes int attrRes, float defaultValue,
@NonNull Context context) {
TypedArray a = context.obtainStyledAttributes(new int[] { attrRes });
try {
return a.getFloat(0, defaultValue);
} finally {
a.recycle();
}
}
@AnyRes
public static int getResIdFromAttrRes(@AttrRes int attrRes, int defaultValue,
@NonNull Context context) {
// TODO: Switch to TintTypedArray when they added this overload.
TypedArray a = context.obtainStyledAttributes(new int[] { attrRes });
try {
return a.getResourceId(0, defaultValue);
} finally {
a.recycle();
}
}
public static int getShortAnimTime(@NonNull Resources resources) {
return resources.getInteger(android.R.integer.config_shortAnimTime);
}
public static int getShortAnimTime(@NonNull View view) {
return getShortAnimTime(view.getResources());
}
public static int getShortAnimTime(@NonNull Context context) {
return getShortAnimTime(context.getResources());
}
public static int getMediumAnimTime(@NonNull Resources resources) {
return resources.getInteger(android.R.integer.config_mediumAnimTime);
}
public static int getMediumAnimTime(@NonNull View view) {
return getMediumAnimTime(view.getResources());
}
public static int getMediumAnimTime(@NonNull Context context) {
return getMediumAnimTime(context.getResources());
}
public static int getLongAnimTime(@NonNull Resources resources) {
return resources.getInteger(android.R.integer.config_longAnimTime);
}
public static int getLongAnimTime(@NonNull View view) {
return getLongAnimTime(view.getResources());
}
public static int getLongAnimTime(@NonNull Context context) {
return getLongAnimTime(context.getResources());
}
public static int getDisplayWidth(@NonNull Context context) {
return context.getResources().getDisplayMetrics().widthPixels;
}
public static int getDisplayHeight(@NonNull Context context) {
return context.getResources().getDisplayMetrics().heightPixels;
}
public static int getMarginStart(@NonNull View view) {
return MarginLayoutParamsCompat.getMarginStart(
(ViewGroup.MarginLayoutParams) view.getLayoutParams());
}
public static int getMarginEnd(@NonNull View view) {
return MarginLayoutParamsCompat.getMarginEnd(
(ViewGroup.MarginLayoutParams) view.getLayoutParams());
}
public static int getMarginLeft(@NonNull View view) {
return ((ViewGroup.MarginLayoutParams) view.getLayoutParams()).leftMargin;
}
public static int getMarginRight(@NonNull View view) {
return ((ViewGroup.MarginLayoutParams) view.getLayoutParams()).rightMargin;
}
public static int getMarginTop(@NonNull View view) {
return ((ViewGroup.MarginLayoutParams) view.getLayoutParams()).topMargin;
}
public static int getMarginBottom(@NonNull View view) {
return ((ViewGroup.MarginLayoutParams) view.getLayoutParams()).bottomMargin;
}
public static int getWidthExcludingPadding(@NonNull View view) {
return Math.max(0, view.getWidth() - view.getPaddingLeft() - view.getPaddingRight());
}
public static int getHeightExcludingPadding(@NonNull View view) {
return Math.max(0, view.getHeight() - view.getPaddingTop() - view.getPaddingBottom());
}
private static boolean hasSwDp(@Dimension(unit = Dimension.DP) int dp, @NonNull Context context) {
return context.getResources().getConfiguration().smallestScreenWidthDp >= dp;
}
public static boolean hasSw600Dp(@NonNull Context context) {
return hasSwDp(600, context);
}
private static boolean hasWDp(@Dimension(unit = Dimension.DP) int dp, @NonNull Context context) {
return context.getResources().getConfiguration().screenWidthDp >= dp;
}
public static boolean hasW600Dp(@NonNull Context context) {
return hasWDp(600, context);
}
public static boolean hasW960Dp(@NonNull Context context) {
return hasWDp(960, context);
}
public static void hideTextInputLayoutErrorOnTextChange(
@NonNull EditText editText, @NonNull TextInputLayout textInputLayout) {
editText.addTextChangedListener(new TextWatcher() {
@Override
public void beforeTextChanged(@NonNull CharSequence s, int start, int count,
int after) {}
@Override
public void onTextChanged(@NonNull CharSequence s, int start, int before, int count) {}
@Override
public void afterTextChanged(@NonNull Editable s) {
textInputLayout.setError(null);
}
});
}
@NonNull
public static View inflate(int resource, @NonNull Context context) {
return inflate(resource, null, false, context);
}
@NonNull
public static View inflate(int resource, @NonNull ViewGroup parent) {
return inflate(resource, parent, false, parent.getContext());
}
@NonNull
public static View inflateWithTheme(int resource, @NonNull Context context,
@StyleRes int themeRes) {
if (themeRes != 0) {
context = new ContextThemeWrapper(context, themeRes);
}
return inflate(resource, null, false, context);
}
@NonNull
public static View inflateWithTheme(int resource, @NonNull ViewGroup parent,
@StyleRes int themeRes) {
Context context = parent.getContext();
if (themeRes != 0) {
context = new ContextThemeWrapper(context, themeRes);
}
return inflate(resource, parent, false, context);
}
@NonNull
public static View inflateInto(int resource, @NonNull ViewGroup parent) {
return inflate(resource, parent, true, parent.getContext());
}
@NonNull
public static View inflateIntoWithTheme(int resource, @NonNull ViewGroup parent,
@StyleRes int themeRes) {
return inflate(resource, parent, true, new ContextThemeWrapper(parent.getContext(),
themeRes));
}
@NonNull
private static View inflate(int resource, @Nullable ViewGroup parent, boolean attachToRoot,
@NonNull Context context) {
return LayoutInflater.from(context).inflate(resource, parent, attachToRoot);
}
public static boolean isLightTheme(@NonNull Context context) {
return getBooleanFromAttrRes(R.attr.isLightTheme, false, context);
}
public static boolean isInPortait(@NonNull Context context) {
return context.getResources().getConfiguration().orientation
== Configuration.ORIENTATION_PORTRAIT;
}
public static boolean isInLandscape(@NonNull Context context) {
return context.getResources().getConfiguration().orientation
== Configuration.ORIENTATION_LANDSCAPE;
}
public static boolean isVisible(@NonNull View view) {
return view.getVisibility() == View.VISIBLE;
}
public static void postOnDrawerClosed(@NonNull DrawerLayout drawerLayout,
@NonNull Runnable runnable) {
drawerLayout.addDrawerListener(new DrawerLayout.SimpleDrawerListener() {
@Override
public void onDrawerClosed(View drawerView) {
drawerLayout.removeDrawerListener(this);
runnable.run();
}
});
}
public static void postOnPreDraw(@NonNull View view, @NonNull Runnable runnable) {
view.getViewTreeObserver().addOnPreDrawListener(new OnPreDrawListenerRunnableWrapper(
view, runnable));
}
public static void removeOnPreDraw(@NonNull View view, @NonNull Runnable runnable) {
view.getViewTreeObserver().removeOnPreDrawListener(new OnPreDrawListenerRunnableWrapper(
view, runnable));
}
private static class OnPreDrawListenerRunnableWrapper
implements ViewTreeObserver.OnPreDrawListener {
@NonNull
private final View mView;
@NonNull
private final Runnable mRunnable;
public OnPreDrawListenerRunnableWrapper(@NonNull View view, @NonNull Runnable runnable) {
mView = view;
mRunnable = runnable;
}
@Override
public boolean onPreDraw() {
mView.getViewTreeObserver().removeOnPreDrawListener(this);
mRunnable.run();
return true;
}
@Override
public boolean equals(@Nullable Object object) {
if (this == object) {
return true;
}
if (object == null || getClass() != object.getClass()) {
return false;
}
OnPreDrawListenerRunnableWrapper that = (OnPreDrawListenerRunnableWrapper) object;
return ObjectsCompat.equals(mRunnable, that.mRunnable);
}
@Override
public int hashCode() {
return mRunnable.hashCode();
}
}
public static void postOnPreDraw(@NonNull View view, @NonNull BooleanSupplier runnable) {
view.getViewTreeObserver().addOnPreDrawListener(new OnPreDrawListenerBooleanSupplierWrapper(
view, runnable));
}
public static void removeOnPreDraw(@NonNull View view, @NonNull BooleanSupplier runnable) {
view.getViewTreeObserver().removeOnPreDrawListener(
new OnPreDrawListenerBooleanSupplierWrapper(view, runnable));
}
private static class OnPreDrawListenerBooleanSupplierWrapper
implements ViewTreeObserver.OnPreDrawListener {
@NonNull
private final View mView;
@NonNull
private final BooleanSupplier mRunnable;
public OnPreDrawListenerBooleanSupplierWrapper(@NonNull View view,
@NonNull BooleanSupplier runnable) {
mView = view;
mRunnable = runnable;
}
@Override
public boolean onPreDraw() {
mView.getViewTreeObserver().removeOnPreDrawListener(this);
return mRunnable.getAsBoolean();
}
@Override
public boolean equals(@Nullable Object object) {
if (this == object) {
return true;
}
if (object == null || getClass() != object.getClass()) {
return false;
}
OnPreDrawListenerRunnableWrapper that = (OnPreDrawListenerRunnableWrapper) object;
return ObjectsCompat.equals(mRunnable, that.mRunnable);
}
@Override
public int hashCode() {
return mRunnable.hashCode();
}
}
@Dimension(unit = Dimension.DP)
public static float pxToDp(@Dimension float px, @NonNull Context context) {
DisplayMetrics metrics = context.getResources().getDisplayMetrics();
return px / metrics.density;
}
@Dimension(unit = Dimension.DP)
public static int pxToDpInt(@Dimension float px, @NonNull Context context) {
return Math.round(pxToDp(px, context));
}
public static void replaceChild(@NonNull ViewGroup viewGroup, @NonNull View oldChild,
@NonNull View newChild) {
int index = viewGroup.indexOfChild(oldChild);
viewGroup.removeViewAt(index);
viewGroup.addView(newChild, index);
}
public static void setBackgroundPreservingPadding(@NonNull View view,
@Nullable Drawable background) {
int savedPaddingStart = ViewCompat.getPaddingStart(view);
int savedPaddingEnd = ViewCompat.getPaddingEnd(view);
int savedPaddingTop = view.getPaddingTop();
int savedPaddingBottom = view.getPaddingBottom();
view.setBackground(background);
ViewCompat.setPaddingRelative(view, savedPaddingStart, savedPaddingTop, savedPaddingEnd,
savedPaddingBottom);
}
public static void setMargin(@NonNull View view, int left, int top, int right, int bottom) {
ViewGroup.MarginLayoutParams layoutParams =
(ViewGroup.MarginLayoutParams) view.getLayoutParams();
layoutParams.leftMargin = left;
layoutParams.topMargin = top;
layoutParams.rightMargin = right;
layoutParams.bottomMargin = bottom;
}
public static void setMarginRelative(@NonNull View view, int start, int top, int end,
int bottom) {
ViewGroup.MarginLayoutParams layoutParams =
(ViewGroup.MarginLayoutParams) view.getLayoutParams();
MarginLayoutParamsCompat.setMarginStart(layoutParams, start);
layoutParams.topMargin = top;
MarginLayoutParamsCompat.setMarginEnd(layoutParams, end);
layoutParams.bottomMargin = bottom;
}
public static void setMarginStart(@NonNull View view, int marginStart) {
MarginLayoutParamsCompat.setMarginStart(
(ViewGroup.MarginLayoutParams) view.getLayoutParams(), marginStart);
}
public static void setMarginEnd(@NonNull View view, int marginEnd) {
MarginLayoutParamsCompat.setMarginEnd((ViewGroup.MarginLayoutParams) view.getLayoutParams(),
marginEnd);
}
public static void setMarginLeft(@NonNull View view, int marginLeft) {
((ViewGroup.MarginLayoutParams) view.getLayoutParams()).leftMargin = marginLeft;
}
public static void setMarginRight(@NonNull View view, int marginRight) {
((ViewGroup.MarginLayoutParams) view.getLayoutParams()).rightMargin = marginRight;
}
public static void setMarginTop(@NonNull View view, int marginTop) {
((ViewGroup.MarginLayoutParams) view.getLayoutParams()).topMargin = marginTop;
}
public static void setMarginBottom(@NonNull View view, int marginBottom) {
((ViewGroup.MarginLayoutParams) view.getLayoutParams()).bottomMargin = marginBottom;
}
public static void setWidth(@NonNull View view, int width) {
ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
if (layoutParams.width == width) {
return;
}
layoutParams.width = width;
view.setLayoutParams(layoutParams);
}
public static void setHeight(@NonNull View view, int height) {
ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
if (layoutParams.height == height) {
return;
}
layoutParams.height = height;
view.setLayoutParams(layoutParams);
}
public static void setSize(@NonNull View view, int size) {
ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
if (layoutParams.width == size && layoutParams.height == size) {
return;
}
layoutParams.width = size;
layoutParams.height = size;
view.setLayoutParams(layoutParams);
}
public static void setWeight(@NonNull View view, float weight) {
LinearLayout.LayoutParams layoutParams = (LinearLayout.LayoutParams) view.getLayoutParams();
layoutParams.weight = weight;
view.setLayoutParams(layoutParams);
}
public static void setPaddingStart(@NonNull View view, int paddingStart) {
ViewCompat.setPaddingRelative(view, paddingStart, view.getPaddingTop(),
ViewCompat.getPaddingEnd(view), view.getPaddingBottom());
}
public static void setPaddingEnd(@NonNull View view, int paddingEnd) {
ViewCompat.setPaddingRelative(view, ViewCompat.getPaddingStart(view), view.getPaddingTop(),
paddingEnd, view.getPaddingBottom());
}
public static void setPaddingLeft(@NonNull View view, int paddingLeft) {
view.setPadding(paddingLeft, view.getPaddingTop(), view.getPaddingRight(),
view.getPaddingBottom());
}
public static void setPaddingRight(@NonNull View view, int paddingRight) {
view.setPadding(view.getPaddingLeft(), view.getPaddingTop(), paddingRight,
view.getPaddingBottom());
}
public static void setPaddingTop(@NonNull View view, int paddingTop) {
view.setPadding(view.getPaddingLeft(), paddingTop, view.getPaddingRight(),
view.getPaddingBottom());
}
public static void setPaddingBottom(@NonNull View view, int paddingBottom) {
view.setPadding(view.getPaddingLeft(), view.getPaddingTop(), view.getPaddingRight(),
paddingBottom);
}
public static void setLayoutFullscreen(@NonNull View view) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
view.setSystemUiVisibility(view.getSystemUiVisibility()
| View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
}
}
public static void setLayoutFullscreen(@NonNull Activity activity) {
setLayoutFullscreen(activity.getWindow().getDecorView());
}
public static void setLayoutHideNavigation(@NonNull View view) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
view.setSystemUiVisibility(view.getSystemUiVisibility()
| View.SYSTEM_UI_FLAG_LAYOUT_STABLE
| View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION);
}
}
public static void setLayoutHideNavigation(@NonNull Activity activity) {
setLayoutHideNavigation(activity.getWindow().getDecorView());
}
public static void setTextViewBold(@NonNull TextView textView, boolean bold) {
Typeface typeface = textView.getTypeface();
if (typeface.isBold() == bold) {
return;
}
int style = textView.getTypeface().getStyle();
if (bold) {
style |= Typeface.BOLD;
} else {
style &= ~Typeface.BOLD;
}
// Workaround insane behavior in TextView#setTypeface(Typeface, int).
if (style > 0) {
textView.setTypeface(typeface, style);
} else {
textView.setTypeface(Typeface.create(typeface, style), style);
}
}
public static void setTextViewItalic(@NonNull TextView textView, boolean italic) {
Typeface typeface = textView.getTypeface();
if (typeface.isItalic() == italic) {
return;
}
int style = textView.getTypeface().getStyle();
if (italic) {
style |= Typeface.ITALIC;
} else {
style &= ~Typeface.ITALIC;
}
// Workaround insane behavior in TextView#setTypeface(Typeface, int).
if (style > 0) {
textView.setTypeface(typeface, style);
} else {
textView.setTypeface(Typeface.create(typeface, style), style);
}
}
public static void setTextViewLinkClickable(TextView textView) {
boolean wasClickable = textView.isClickable();
boolean wasLongClickable = textView.isLongClickable();
textView.setMovementMethod(ClickableMovementMethod.getInstance());
// Reset for TextView.fixFocusableAndClickableSettings(). We don't want View.onTouchEvent()
// to consume touch events.
textView.setClickable(wasClickable);
textView.setLongClickable(wasLongClickable);
}
public static void setTextViewLinkClickableAndTextSelectable(TextView textView) {
textView.setTextIsSelectable(true);
textView.setMovementMethod(LinkArrowKeyMovementMethod.getInstance());
}
public static void setVisibleOrGone(@NonNull View view, boolean visible) {
view.setVisibility(visible ? View.VISIBLE : View.GONE);
}
public static void setVisibleOrInvisible(@NonNull View view, boolean visible) {
view.setVisibility(visible ? View.VISIBLE : View.INVISIBLE);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/ViewUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 5,887 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.content.Context;
import android.net.Uri;
import android.text.Editable;
import android.text.TextUtils;
import android.widget.EditText;
import java.util.HashMap;
import java.util.Map;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleUser;
public class DoubanUtils {
private static final Map<String, String> INTEREST_TYPE_URL_MAP;
static {
INTEREST_TYPE_URL_MAP = new HashMap<>();
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
INTEREST_TYPE_URL_MAP.put("", "path_to_url");
}
private static final String INTEREST_URL_DEFAULT = "path_to_url";
private DoubanUtils() {}
public static void addMentionString(EditText editText) {
Editable editable = editText.getText();
int selectionStart = editText.getSelectionStart();
int selectionEnd = editText.getSelectionEnd();
int mentionStart;
int mentionEnd;
if (selectionStart > 0 && editable.charAt(selectionStart - 1) == '@') {
mentionStart = selectionStart - 1;
mentionEnd = selectionEnd;
padSpaceAround(editText, mentionStart, mentionEnd);
} else {
editable.insert(selectionStart, "@");
mentionStart = selectionStart;
mentionEnd = selectionEnd + 1;
if (selectionStart != selectionEnd) {
int paddedMentionEnd = padSpaceAround(editText, mentionStart, mentionEnd);
editText.setSelection(paddedMentionEnd);
} else {
editText.setSelection(mentionEnd);
padSpaceAround(editText, mentionStart, mentionEnd);
}
}
}
public static void addTopicString(EditText editText) {
Editable editable = editText.getText();
int selectionStart = editText.getSelectionStart();
int selectionEnd = editText.getSelectionEnd();
int topicStart;
int topicEnd;
if (selectionStart != selectionEnd) {
if (selectionStart > 0 && editable.charAt(selectionStart - 1) == '#'
&& selectionEnd < editable.length() && editable.charAt(selectionEnd) == '#') {
topicStart = selectionStart - 1;
topicEnd = selectionEnd + 1;
padSpaceAround(editText, topicStart, topicEnd);
} else {
editable.insert(selectionStart, "#");
editable.insert(selectionEnd + 1, "#");
topicStart = selectionStart;
topicEnd = selectionEnd + 2;
int paddedTopicEnd = padSpaceAround(editText, topicStart, topicEnd);
editText.setSelection(paddedTopicEnd);
}
} else {
int length = editable.length();
editable.insert(length, "##");
topicStart = length;
topicEnd = length + 6;
editText.setSelection(topicStart + 1, topicEnd - 1);
padSpaceAround(editText, topicStart, topicEnd);
}
}
private static int padSpaceAround(EditText editText, int start, int end) {
Editable editable = editText.getText();
if (start > 0) {
char c = editable.charAt(start - 1);
if (c == '\n') {
// Do nothing.
} else if (c == ' ') {
--start;
} else {
insertPreservingSelection(editText, start, " ");
++end;
}
}
if (end < editable.length()) {
char c = editable.charAt(end);
if (c == '\n') {
// Do nothing.
} else if (c == ' ') {
++end;
} else {
insertPreservingSelection(editText, end, " ");
++end;
}
}
return end;
}
private static void insertPreservingSelection(EditText editText, int position,
CharSequence text) {
int selectionStart = editText.getSelectionStart();
int selectionEnd = editText.getSelectionEnd();
Editable editable = editText.getText();
editable.insert(position, text);
boolean needPreserve = false;
if (selectionStart == position) {
needPreserve = true;
} else {
selectionStart = editText.getSelectionStart();
}
if (selectionEnd == position) {
needPreserve = true;
} else {
selectionEnd = editText.getSelectionEnd();
}
if (needPreserve) {
editText.setSelection(selectionStart, selectionEnd);
}
}
public static String makeMentionString(String userIdOrUid) {
return '@' + userIdOrUid + ' ';
}
public static String makeMentionString(SimpleUser user) {
//noinspection deprecation
return makeMentionString(user.uid);
}
public static String makeTopicString(String topic) {
return '#' + topic + '#';
}
public static String makeTopicBroadcastText(String topic) {
return ' ' + makeTopicString(topic);
}
public static String makeBroadcastUri(long broadcastId) {
return "douban://douban.com/status/" + broadcastId;
}
/**
* @deprecated Use {@link #makeBroadcastUrl(String, long)} instead.
*/
public static String makeBroadcastUrl(long broadcastId) {
return "path_to_url" + broadcastId + "/";
}
public static String makeBroadcastUrl(String userIdOrUid, long broadcastId) {
return "path_to_url" + userIdOrUid + "/status/" + broadcastId + "/";
}
public static String makeBroadcastListUrl(String uidOrUserId, String topic) {
if (!TextUtils.isEmpty(uidOrUserId)) {
return "path_to_url" + uidOrUserId + "/statuses/";
} else {
return "path_to_url" + Uri.encode(topic) + "/";
}
}
public static String makeBookUrl(long itemId) {
return "path_to_url" + itemId + "/";
}
public static String makeMovieUrl(long itemId) {
return "path_to_url" + itemId + "/";
}
public static String makeMusicUrl(long itemId) {
return "path_to_url" + itemId + "/";
}
public static String makeGameUrl(long itemId) {
return "path_to_url" + itemId + "/";
}
public static String makePhotoAlbumUri(long photoAlbumId) {
return "douban://douban.com/photo_album/" + photoAlbumId;
}
public static String makeUserUri(long userId) {
return "douban://douban.com/user/" + userId;
}
public static String makeUserUrl(String uidOrUserId) {
return "path_to_url" + uidOrUserId + "/";
}
public static String getInterestTypeUrl(String type) {
String url = null;
if (!TextUtils.isEmpty(type)) {
url = INTEREST_TYPE_URL_MAP.get(type);
}
if (TextUtils.isEmpty(url)) {
LogUtils.w("Unknown interest type: " + type);
url = INTEREST_URL_DEFAULT;
}
return url;
}
public static String getRatingHint(int rating, Context context) {
String[] ratingHints = context.getResources().getStringArray(R.array.item_rating_hints);
if (rating == 0) {
return "";
} else if (rating > 0 && rating <= ratingHints.length) {
return ratingHints[rating - 1];
} else {
return context.getString(R.string.item_rating_hint_unknown);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/DoubanUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 2,102 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.os.Build;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.RequiresApi;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;
@SuppressWarnings("unused")
public class ListBuilder<E, L extends List<E>> {
@NonNull
private L mList;
private ListBuilder(@NonNull L list) {
mList = list;
}
@NonNull
public static <E> ListBuilder<E, ArrayList<E>> newArrayList() {
return new ListBuilder<>(new ArrayList<>());
}
@NonNull
public static <E, L extends List<E>> ListBuilder<E, L> buildUpon(@NonNull L List) {
return new ListBuilder<>(List);
}
@NonNull
public L build() {
L list = mList;
mList = null;
return list;
}
@NonNull
public List<E> buildUnmodifiable() {
List<E> List = Collections.unmodifiableList(mList);
mList = null;
return List;
}
@NonNull
public ListBuilder<E, L> add(@Nullable E element) {
mList.add(element);
return this;
}
@NonNull
public ListBuilder<E, L> remove(@Nullable Object element) {
mList.remove(element);
return this;
}
@NonNull
public ListBuilder<E, L> addAll(@NonNull Collection<? extends E> collection) {
mList.addAll(collection);
return this;
}
@NonNull
public ListBuilder<E, L> addAll(int index, @NonNull Collection<? extends E> collection) {
mList.addAll(index, collection);
return this;
}
@NonNull
public ListBuilder<E, L> removeAll(@NonNull Collection<?> collection) {
mList.removeAll(collection);
return this;
}
@NonNull
public ListBuilder<E, L> retainAll(@NonNull Collection<?> collection) {
mList.retainAll(collection);
return this;
}
@NonNull
@RequiresApi(Build.VERSION_CODES.N)
public ListBuilder<E, L> replaceAll(@NonNull UnaryOperator<E> operator) {
mList.replaceAll(operator);
return this;
}
@NonNull
@RequiresApi(Build.VERSION_CODES.N)
public ListBuilder<E, L> sort(@Nullable Comparator<? super E> comparator) {
mList.sort(comparator);
return this;
}
@NonNull
public ListBuilder<E, L> clear() {
mList.clear();
return this;
}
@NonNull
public ListBuilder<E, L> set(int index, @Nullable E element) {
mList.set(index, element);
return this;
}
@NonNull
public ListBuilder<E, L> add(int index, @Nullable E element) {
mList.add(index, element);
return this;
}
@NonNull
public ListBuilder<E, L> remove(int index) {
mList.remove(index);
return this;
}
@NonNull
@RequiresApi(Build.VERSION_CODES.N)
public ListBuilder<E, L> removeIf(@NonNull Predicate<? super E> filter) {
mList.removeIf(filter);
return this;
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/ListBuilder.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 714 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.content.Context;
import android.os.Handler;
import com.google.gson.reflect.TypeToken;
import java.io.File;
import java.lang.reflect.Type;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionException;
import me.zhanghai.android.douya.BuildConfig;
public class DiskCacheHelper {
// 2M
private static final int MAX_DISK_CACHE_BYTES = 2 * 1024 * 1024;
private static final Object DISK_CACHE_LOCK = new Object();
private static volatile DiskCache sDiskCache;
private static final ExecutorService sExecutorService = Executors.newSingleThreadExecutor();
private DiskCacheHelper() {}
public static DiskCache get(Context context) {
if (sDiskCache == null) {
synchronized (DISK_CACHE_LOCK) {
if (sDiskCache == null) {
sDiskCache = DiskCache.open(new File(context.getCacheDir(),
BuildConfig.APPLICATION_ID), 0, MAX_DISK_CACHE_BYTES);
}
}
}
return sDiskCache;
}
private static void executeAsync(Runnable runnable) {
try {
sExecutorService.execute(runnable);
} catch (RejectedExecutionException e) {
e.printStackTrace();
}
}
private static <T> void deliverValue(Handler handler, final Callback<T> callback,
final T value) {
handler.post(new Runnable() {
@Override
public void run() {
callback.onValue(value);
}
});
}
public static void getString(final String key, final Handler handler,
final Callback<String> callback, final Context context) {
executeAsync(new Runnable() {
@Override
public void run() {
DiskCache diskCache = get(context);
deliverValue(handler, callback, diskCache != null ? diskCache.getString(key)
: null);
}
});
}
public static <T> void getGson(final String key, final Type type, final Handler handler,
final Callback<T> callback, final Context context) {
executeAsync(new Runnable() {
@Override
public void run() {
DiskCache diskCache = get(context);
deliverValue(handler, callback, diskCache != null ? diskCache.<T>getGson(key, type)
: null);
}
});
}
public static <T> void getGson(String key, TypeToken<T> typeToken, Handler handler,
Callback<T> callback, Context context) {
getGson(key, typeToken.getType(), handler, callback, context);
}
public static void putBytes(final String key, final byte[] value, final Context context) {
executeAsync(new Runnable() {
@Override
public void run() {
DiskCache diskCache = get(context);
if (diskCache != null) {
diskCache.putBytes(key, value);
}
}
});
}
public static void putString(final String key, final String value, final Context context) {
executeAsync(new Runnable() {
@Override
public void run() {
DiskCache diskCache = get(context);
if (diskCache != null) {
diskCache.putString(key, value);
}
}
});
}
public static <T> void putGson(final String key, final T value, final Type type,
final Context context) {
executeAsync(new Runnable() {
@Override
public void run() {
DiskCache diskCache = get(context);
if (diskCache != null) {
diskCache.putGson(key, value, type);
}
}
});
}
public static <T> void putGson(String key, T value, TypeToken<T> typeToken, Context context) {
putGson(key, value, typeToken.getType(), context);
}
public static void remove(final String key, final Handler handler,
final Callback<Boolean> callback, final Context context) {
executeAsync(new Runnable() {
@Override
public void run() {
DiskCache diskCache = get(context);
if (diskCache != null) {
deliverValue(handler, callback, diskCache.remove(key));
}
}
});
}
public static void remove(final String key, final Context context) {
executeAsync(new Runnable() {
@Override
public void run() {
DiskCache diskCache = get(context);
if (diskCache != null) {
diskCache.remove(key);
}
}
});
}
public static void delete(final Context context) {
executeAsync(new Runnable() {
@Override
public void run() {
DiskCache diskCache = get(context);
if (diskCache != null) {
diskCache.delete();
}
}
});
}
public static void close(final Context context) {
executeAsync(new Runnable() {
@Override
public void run() {
DiskCache diskCache = get(context);
if (diskCache != null) {
diskCache.close();
}
}
});
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/DiskCacheHelper.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 1,089 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.app.Activity;
import android.app.Application;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.os.Bundle;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.StyleRes;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.app.AppCompatDelegate;
import androidx.appcompat.app.NightModeAccessor;
import java.util.HashMap;
import java.util.Map;
import me.zhanghai.android.douya.functional.extension.TriConsumer;
import me.zhanghai.android.douya.settings.info.Settings;
public class NightModeHelper {
@NonNull
private static final ActivityHelper sActivityHelper = new ActivityHelper();
private NightModeHelper() {}
public static void setup(@NonNull Application application) {
syncDefaultNightMode();
application.registerActivityLifecycleCallbacks(sActivityHelper);
}
private static void syncDefaultNightMode() {
setDefaultNightMode(Settings.NIGHT_MODE.getEnumValue());
}
private static int getDefaultNightMode() {
return AppCompatDelegate.getDefaultNightMode();
}
private static void setDefaultNightMode(@NonNull Settings.NightMode nightMode) {
int nightModeValue = nightMode.getValue();
if (getDefaultNightMode() == nightModeValue) {
return;
}
AppCompatDelegate.setDefaultNightMode(nightModeValue);
}
public static void updateNightMode(@NonNull Activity activity) {
syncDefaultNightMode();
sActivityHelper.onActivityStarted(activity);
}
/**
* Should be called before super.onConfigurationChanged() to avoid activity recreation by
* AppCompat.
*
* @see androidx.appcompat.app.AppCompatDelegateImpl#updateForNightMode(int)
*/
public static void onConfigurationChanged(
@NonNull Activity activity,
@NonNull TriConsumer<Resources.Theme, Integer, Boolean> onApplyThemeResource,
@StyleRes int themeRes) {
boolean isInNightMode = sActivityHelper.isActivityInNightMode(activity);
int uiModeNight = isInNightMode ? Configuration.UI_MODE_NIGHT_YES
: Configuration.UI_MODE_NIGHT_NO;
Resources resources = activity.getResources();
Configuration newConfiguration = new Configuration(resources.getConfiguration());
newConfiguration.uiMode = (newConfiguration.uiMode & ~Configuration.UI_MODE_NIGHT_MASK)
| uiModeNight;
//noinspection deprecation
resources.updateConfiguration(newConfiguration, resources.getDisplayMetrics());
ResourcesFlusher.flush(resources);
onApplyThemeResource.accept(activity.getTheme(), themeRes, true);
sActivityHelper.onActivityCreated(activity, null);
}
/**
* AppCompatDelegateImplV14.updateForNightMode() won't update when multiple Activities share a
* Resources and a Configuration instance. We do this ourselves.
*/
private static class ActivityHelper implements Application.ActivityLifecycleCallbacks {
@NonNull
private final Map<Activity, Boolean> mActivityIsInNightModeMap = new HashMap<>();
@Override
public void onActivityCreated(@NonNull Activity activity,
@Nullable Bundle savedInstanceState) {
// This runs after AppCompatActivity calls AppCompatDelegate.applyDayNight().
int uiModeNight = activity.getResources().getConfiguration().uiMode
& Configuration.UI_MODE_NIGHT_MASK;
boolean isInNightMode = uiModeNight == Configuration.UI_MODE_NIGHT_YES;
// Night mode normally won't change once an Activity is created.
mActivityIsInNightModeMap.put(activity, isInNightMode);
}
@Override
public void onActivityStarted(@NonNull Activity activity) {
if (!(activity instanceof AppCompatActivity)) {
return;
}
AppCompatActivity appCompatActivity = (AppCompatActivity) activity;
// This runs before AppCompatDelegateImplV14.onStart() calls
// AppCompatDelegate.applyDayNight().
// And we don't care about things below V14 where this is a no-op returning false.
if (appCompatActivity.getDelegate().applyDayNight()) {
return;
}
boolean isInNightMode = mActivityIsInNightModeMap.get(activity);
int nightMode = NightModeAccessor.mapNightMode(appCompatActivity.getDelegate(),
// We don't use local night mode.
getDefaultNightMode());
if (nightMode == AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM) {
// Let our future system handle it.
return;
}
boolean shouldBeInNightMode = nightMode == AppCompatDelegate.MODE_NIGHT_YES;
if (isInNightMode != shouldBeInNightMode) {
// Need this for certain drawables to be updated correctly.
ResourcesFlusher.flush(activity.getResources());
activity.recreate();
}
}
@Override
public void onActivityResumed(@NonNull Activity activity) {}
@Override
public void onActivityPaused(@NonNull Activity activity) {}
@Override
public void onActivityStopped(@NonNull Activity activity) {}
@Override
public void onActivitySaveInstanceState(@NonNull Activity activity,
@NonNull Bundle outState) {}
@Override
public void onActivityDestroyed(@NonNull Activity activity) {
mActivityIsInNightModeMap.remove(activity);
}
public boolean isActivityInNightMode(@NonNull Activity activity) {
return mActivityIsInNightModeMap.get(activity);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/NightModeHelper.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 1,095 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.app.Activity;
import android.app.DownloadManager;
import android.content.ClipData;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import androidx.annotation.RequiresApi;
import android.text.TextUtils;
import android.webkit.CookieManager;
import android.webkit.URLUtil;
import android.webkit.WebChromeClient;
import java.io.File;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.network.Http;
public class WebViewUtils {
private WebViewUtils() {}
public static String getDatabasePath(Context context) {
File webViewDirectory = context.getDir("webview", Context.MODE_PRIVATE);
File databasesDirectory = new File(webViewDirectory, "databases");
if (!databasesDirectory.exists()) {
// Return valued wasn't checked in {@link ContextImpl#getDir(String, int)}.
//noinspection ResultOfMethodCallIgnored
databasesDirectory.mkdir();
}
return databasesDirectory.getPath();
}
/*
* @see com.android.webview.chromium.FileChooserParamsAdapter#createFileChooserIntent()
* @see org.chromium.android_webview.AwContentsClient.FileChooserParamsImpl
* #createFileChooserIntent()
*/
public static Intent createFileChooserIntent(String acceptType) {
if (acceptType != null) {
acceptType = acceptType.trim();
}
String[] acceptTypes = !TextUtils.isEmpty(acceptType) ? acceptType.split(",") : null;
return IntentUtils.makePickFile(acceptTypes, false);
}
@RequiresApi(Build.VERSION_CODES.LOLLIPOP)
public static Intent createFileChooserIntent(
WebChromeClient.FileChooserParams fileChooserParams) {
boolean allowMultiple = fileChooserParams.getMode()
== WebChromeClient.FileChooserParams.MODE_OPEN_MULTIPLE;
String[] acceptTypes = fileChooserParams.getAcceptTypes();
// Work around for WebView accept types bug.
if (acceptTypes != null && acceptTypes.length == 1 && acceptTypes[0].indexOf(',') != -1) {
acceptTypes = acceptTypes[0].split(",");
}
return IntentUtils.makePickFile(acceptTypes, allowMultiple);
}
/*
* @see com.android.webview.chromium.FileChooserParamsAdapter#parseFileChooserResult(int,
* Intent)
* @see org.chromium.android_webview.AwContentsClient.#parseFileChooserResult(int, Intent)
*/
public static Uri[] parseFileChooserResult(int resultCode, Intent data) {
if (resultCode != Activity.RESULT_OK || data == null) {
return null;
}
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN) {
ClipData clipData = data.getClipData();
if (clipData != null) {
int itemCount = clipData.getItemCount();
if (itemCount > 0) {
Uri[] uris = new Uri[itemCount];
for (int i = 0; i < itemCount; ++i) {
uris[i] = clipData.getItemAt(i).getUri();
}
return uris;
}
}
}
Uri uri = data.getData();
if (uri != null) {
return new Uri[] { uri };
}
return null;
}
/*
* @see com.android.browser.DownloadHandler#onDownloadStartNoStream(Activity, String, String,
* String, String, String, boolean)
*/
public static void download(String url, String userAgent, String contentDisposition,
String mimeType, Context context) {
DownloadManager.Request request = new DownloadManager.Request(Uri.parse(url));
if (!TextUtils.isEmpty(userAgent)) {
request.addRequestHeader(Http.Headers.USER_AGENT, userAgent);
}
String cookies = CookieManager.getInstance().getCookie(url);
request.addRequestHeader(Http.Headers.Cookie, cookies);
String fileName = URLUtil.guessFileName(url, contentDisposition, mimeType);
request.setDestinationInExternalPublicDir(Environment.DIRECTORY_DOWNLOADS, fileName);
request.allowScanningByMediaScanner();
request.setNotificationVisibility(
DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED);
DownloadManager downloadManager = (DownloadManager) context.getSystemService(
Context.DOWNLOAD_SERVICE);
downloadManager.enqueue(request);
ToastUtils.show(R.string.webview_downloading, context);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/WebViewUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 931 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import androidx.browser.customtabs.CustomTabsIntent;
import androidx.core.util.PatternsCompat;
import android.text.TextUtils;
import org.chromium.customtabsclient.CustomTabsActivityHelper;
import me.zhanghai.android.customtabshelper.CustomTabsHelperFragment;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.ui.WebViewActivity;
public class UrlUtils {
private UrlUtils() {}
public static boolean isValidUrl(String text) {
return !TextUtils.isEmpty(text) && PatternsCompat.WEB_URL.matcher(text).matches();
}
public static void openWithWebViewActivity(Uri uri, Context context) {
context.startActivity(WebViewActivity.makeIntent(uri, context));
}
public static void openWithIntent(Uri uri, Context context) {
Intent intent = IntentUtils.makeView(uri);
AppUtils.startActivity(intent, context);
}
public static void openWithIntent(String url, Context context) {
openWithIntent(Uri.parse(url), context);
}
public static void openWithCustomTabs(Uri uri,
CustomTabsActivityHelper.CustomTabsFallback fallback,
Activity activity) {
CustomTabsHelperFragment.open(activity, makeCustomTabsIntent(activity), uri, fallback);
}
private static CustomTabsIntent makeCustomTabsIntent(Context context) {
return new CustomTabsIntent.Builder()
.addDefaultShareMenuItem()
.enableUrlBarHiding()
.setToolbarColor(ViewUtils.getColorFromAttrRes(R.attr.colorPrimary, 0, context))
.setShowTitle(true)
.build();
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/UrlUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 361 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.os.Build;
import androidx.annotation.NonNull;
public class StringCompat {
private StringCompat() {}
@NonNull
public static String join(@NonNull CharSequence delimiter, @NonNull CharSequence... elements) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
return String.join(delimiter, elements);
} else {
// TextUtils.join() can throw NullPointerException, so we cannot use it.
StringBuilder builder = new StringBuilder();
boolean first = true;
for (CharSequence element : elements) {
if (first) {
first = false;
} else {
builder.append(delimiter);
}
builder.append(element);
}
return builder.toString();
}
}
@NonNull
public static String join(@NonNull CharSequence delimiter,
@NonNull Iterable<? extends CharSequence> elements) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
return String.join(delimiter, elements);
} else {
// TextUtils.join() can throw NullPointerException, so we cannot use it.
StringBuilder builder = new StringBuilder();
boolean first = true;
for (CharSequence element : elements) {
if (first) {
first = false;
} else {
builder.append(delimiter);
}
builder.append(element);
}
return builder.toString();
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/StringCompat.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 297 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.content.Context;
import androidx.recyclerview.widget.RecyclerView;
import android.view.View;
public class RecyclerViewUtils {
private RecyclerViewUtils() {}
public static Context getContext(RecyclerView.ViewHolder holder) {
return holder.itemView.getContext();
}
public static boolean hasFirstChildReachedTop(RecyclerView recyclerView, int top) {
RecyclerView.LayoutManager layoutManager = recyclerView.getLayoutManager();
View firstChild = layoutManager.findViewByPosition(0);
if (firstChild != null) {
return firstChild.getTop() <= top;
} else {
return layoutManager.getChildCount() > 0;
}
}
public static boolean hasFirstChildReachedTop(RecyclerView recyclerView) {
return hasFirstChildReachedTop(recyclerView, 0);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/RecyclerViewUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 169 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import androidx.appcompat.widget.TooltipCompat;
import android.view.View;
public class TooltipUtils {
private TooltipUtils() {}
public static void setup(View view) {
TooltipCompat.setTooltipText(view, view.getContentDescription());
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/TooltipUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 67 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.os.Build;
import android.os.storage.StorageManager;
import android.os.storage.StorageVolume;
import androidx.annotation.NonNull;
import java.util.Arrays;
import java.util.List;
import me.zhanghai.android.douya.reflected.ReflectedMethod;
/**
* @see StorageManager
* @see <a href="path_to_url">
* ics-mr0-release/StorageManager.java</a>
*/
public class StorageManagerCompat {
@NonNull
private static final ReflectedMethod sGetVolumeListMethod = new ReflectedMethod(
StorageManager.class, "getVolumeList");
private StorageManagerCompat() {}
/**
* @see StorageManager#getStorageVolumes()
*/
@NonNull
public static List<StorageVolume> getStorageVolumes(@NonNull StorageManager storageManager) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
return storageManager.getStorageVolumes();
} else {
StorageVolume[] storageVolumes = sGetVolumeListMethod.invoke(storageManager);
return Arrays.asList(storageVolumes);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/StorageManagerCompat.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 238 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.content.Context;
import android.content.res.ColorStateList;
import android.graphics.drawable.Drawable;
import com.google.android.material.navigation.NavigationView;
import androidx.core.content.ContextCompat;
import androidx.core.graphics.drawable.DrawableCompat;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import android.view.ContextThemeWrapper;
import android.view.Menu;
import android.view.MenuItem;
import android.view.SubMenu;
import android.view.Window;
import android.widget.ImageView;
import me.zhanghai.android.douya.R;
public class TintHelper {
private static final int[] CHECKED_STATE_SET = { android.R.attr.state_checked };
private static final int[] DISABLED_STATE_SET = { -android.R.attr.state_enabled };
private static final int[] EMPTY_STATE_SET = {};
private TintHelper() {}
public static void onPanelMenuCreated(int featureId, Menu menu, AppCompatActivity activity) {
if (featureId == Window.FEATURE_OPTIONS_PANEL) {
Context context = activity.getSupportActionBar().getThemedContext();
ColorStateList menuTintList = ViewUtils.getColorStateListFromAttrRes(
R.attr.colorControlNormal, context);
int popupThemeResId = ViewUtils.getResIdFromAttrRes(R.attr.popupTheme, 0, context);
ColorStateList subMenuTintList;
if (popupThemeResId != 0) {
Context popupContext = new ContextThemeWrapper(context, popupThemeResId);
subMenuTintList = ViewUtils.getColorStateListFromAttrRes(R.attr.colorControlNormal,
popupContext);
} else {
subMenuTintList = menuTintList;
}
tintMenuItemIcon(menu, menuTintList, subMenuTintList);
}
}
private static void tintMenuItemIcon(Menu menu, ColorStateList menuTintList,
ColorStateList subMenuTintList) {
for (int i = 0, size = menu.size(); i < size; ++i) {
MenuItem menuItem = menu.getItem(i);
Drawable icon = menuItem.getIcon();
if (icon != null) {
icon = tintDrawable(icon, menuTintList);
menuItem.setIcon(icon);
}
SubMenu subMenu = menuItem.getSubMenu();
if (subMenu != null) {
tintMenuItemIcon(subMenu, subMenuTintList, subMenuTintList);
}
}
}
public static void onSetSupportActionBar(Toolbar toolbar) {
Drawable icon = toolbar.getNavigationIcon();
ColorStateList tintList = ViewUtils.getColorStateListFromAttrRes(R.attr.colorControlNormal,
toolbar.getContext());
icon = tintDrawable(icon, tintList);
toolbar.setNavigationIcon(icon);
}
public static Drawable tintDrawable(Drawable drawable, ColorStateList tintList) {
drawable = DrawableCompat.wrap(drawable);
drawable.mutate();
DrawableCompat.setTintList(drawable, tintList);
return drawable;
}
public static Drawable tintIcon(Drawable icon, Context context) {
ColorStateList iconTintList = ViewUtils.getColorStateListFromAttrRes(
R.attr.colorControlNormal, context);
return tintDrawable(icon, iconTintList);
}
public static void tintImageViewIcon(ImageView imageView) {
imageView.setImageDrawable(tintIcon(imageView.getDrawable(), imageView.getContext()));
}
public static void setNavigationItemTint(NavigationView navigationView, int color) {
Context context = navigationView.getContext();
navigationView.setItemIconTintList(createNavigationItemTintList(
android.R.attr.textColorSecondary, color, context));
navigationView.setItemTextColor(createNavigationItemTintList(
android.R.attr.textColorPrimary, color, context));
}
private static ColorStateList createNavigationItemTintList(int baseColorAttrRes,
int primaryColor, Context context) {
ColorStateList baseColor = ViewUtils.getColorStateListFromAttrRes(baseColorAttrRes,
context);
int defaultColor = baseColor.getDefaultColor();
return new ColorStateList(new int[][] {
DISABLED_STATE_SET,
CHECKED_STATE_SET,
EMPTY_STATE_SET
}, new int[] {
baseColor.getColorForState(DISABLED_STATE_SET, defaultColor),
primaryColor,
defaultColor
});
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/TintHelper.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 914 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.graphics.Color;
import androidx.annotation.ColorInt;
import androidx.annotation.IntRange;
public class ColorUtils {
private ColorUtils() {}
@ColorInt
public static int blendAlphaComponent(@ColorInt int color,
@IntRange(from = 0x0, to = 0xFF) int alpha) {
return androidx.core.graphics.ColorUtils.setAlphaComponent(color,
Color.alpha(color) * alpha / 0xFF);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/ColorUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 113 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
public class MathUtils {
private MathUtils() {}
public static int constrain(int value, int min, int max) {
return value < min ? min : value > max ? max : value;
}
public static float constrain(float value, float min, float max) {
return value < min ? min : value > max ? max : value;
}
public static int lerpInt(int start, int end, float fraction) {
return (int) (start + (end - start) * fraction);
}
public static float lerp(float start, float end, float fraction) {
return start + (end - start) * fraction;
}
public static float unlerp(int start, int end, int value) {
int domainSize = end - start;
if (domainSize == 0) {
throw new IllegalArgumentException("Can't reverse interpolate with domain size of 0");
}
return (float) (value - start) / domainSize;
}
public static float unlerp(float start, float end, float value) {
float domainSize = end - start;
if (domainSize == 0) {
throw new IllegalArgumentException("Can't reverse interpolate with domain size of 0");
}
return (value - start) / domainSize;
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/MathUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 299 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import androidx.annotation.Nullable;
public class Holder<T> {
@Nullable
public T value;
public Holder() {}
public Holder(@Nullable T value) {
this.value = value;
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/Holder.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 62 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.view.MotionEvent;
import android.view.ViewConfiguration;
/**
* In fact a {@code MultipleClickDetector}.
*/
public class MultipleTapDetector {
private int mTapCount;
private Listener mListener;
private long mLastDownMillis;
private long mLastTapUpMillis;
private int mCurrentTapCount;
public MultipleTapDetector(int tapCount, Listener listener) {
mTapCount = tapCount;
mListener = listener;
}
public void onTouchEvent(MotionEvent event) {
switch (event.getActionMasked()) {
case MotionEvent.ACTION_DOWN:
mLastDownMillis = event.getEventTime();
break;
case MotionEvent.ACTION_UP: {
long eventTime = event.getEventTime();
if (eventTime - mLastDownMillis < ViewConfiguration.getTapTimeout()) {
// This is a tap.
if (mCurrentTapCount == 0 || (eventTime - mLastTapUpMillis
< ViewConfiguration.getDoubleTapTimeout())) {
// This is a multiple tap.
mLastTapUpMillis = eventTime;
++mCurrentTapCount;
if (mCurrentTapCount == mTapCount) {
mListener.onMultipleTapDetected();
} else {
// Wait for more multiple taps.
return;
}
}
}
mLastTapUpMillis = 0;
mCurrentTapCount = 0;
break;
}
}
}
public interface Listener {
void onMultipleTapDetected();
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/MultipleTapDetector.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 334 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.os.Bundle;
import androidx.annotation.IdRes;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentActivity;
import androidx.fragment.app.FragmentManager;
public class FragmentUtils {
private FragmentUtils() {}
@NonNull
public static BundleBuilder getArgumentsBuilder(@NonNull Fragment fragment) {
Bundle arguments = fragment.getArguments();
if (arguments == null) {
arguments = new Bundle();
fragment.setArguments(arguments);
}
return BundleBuilder.buildUpon(arguments);
}
@Deprecated
@Nullable
public static <T> T findById(@NonNull FragmentManager fragmentManager, @IdRes int id) {
//noinspection unchecked
return (T) fragmentManager.findFragmentById(id);
}
@Nullable
public static <T> T findById(@NonNull FragmentActivity activity, @IdRes int id) {
//noinspection deprecation
return findById(activity.getSupportFragmentManager(), id);
}
@Nullable
public static <T> T findById(@NonNull Fragment parentFragment, @IdRes int id) {
//noinspection deprecation
return findById(parentFragment.getChildFragmentManager(), id);
}
@Deprecated
@Nullable
public static <T> T findByTag(@NonNull FragmentManager fragmentManager, @NonNull String tag) {
//noinspection unchecked
return (T) fragmentManager.findFragmentByTag(tag);
}
@Nullable
public static <T> T findByTag(@NonNull FragmentActivity activity, @NonNull String tag) {
//noinspection deprecation
return findByTag(activity.getSupportFragmentManager(), tag);
}
@Nullable
public static <T> T findByTag(@NonNull Fragment parentFragment, @NonNull String tag) {
//noinspection deprecation
return findByTag(parentFragment.getChildFragmentManager(), tag);
}
@Deprecated
public static void add(@NonNull Fragment fragment, @NonNull FragmentManager fragmentManager,
@IdRes int containerViewId, @Nullable String tag) {
fragmentManager.beginTransaction()
.add(containerViewId, fragment, tag)
.commit();
}
@Deprecated
public static void add(@NonNull Fragment fragment, @NonNull FragmentManager fragmentManager,
@IdRes int containerViewId) {
//noinspection deprecation
add(fragment, fragmentManager, containerViewId, null);
}
public static void add(@NonNull Fragment fragment, @NonNull FragmentActivity activity,
@IdRes int containerViewId) {
//noinspection deprecation
add(fragment, activity.getSupportFragmentManager(), containerViewId);
}
public static void add(@NonNull Fragment fragment, @NonNull Fragment parentFragment,
@IdRes int containerViewId) {
//noinspection deprecation
add(fragment, parentFragment.getChildFragmentManager(), containerViewId);
}
@Deprecated
public static void add(@NonNull Fragment fragment, @NonNull FragmentManager fragmentManager,
@NonNull String tag) {
// Pass 0 as in {@link android.support.v4.app.BackStackRecord#add(Fragment, String)}.
//noinspection deprecation
add(fragment, fragmentManager, 0, tag);
}
public static void add(@NonNull Fragment fragment, @NonNull FragmentActivity activity,
@NonNull String tag) {
//noinspection deprecation
add(fragment, activity.getSupportFragmentManager(), tag);
}
public static void add(@NonNull Fragment fragment, @NonNull Fragment parentFragment,
@NonNull String tag) {
//noinspection deprecation
add(fragment, parentFragment.getChildFragmentManager(), tag);
}
/**
* @deprecated Always use an id or tag for restoration.
*/
public static void add(@NonNull Fragment fragment, @NonNull FragmentActivity activity) {
//noinspection deprecation
add(fragment, activity.getSupportFragmentManager(), 0, null);
}
/**
* @deprecated Always use an id or tag for restoration.
*/
public static void add(@NonNull Fragment fragment, @NonNull Fragment parentFragment) {
//noinspection deprecation
add(fragment, parentFragment.getChildFragmentManager(), 0, null);
}
public static void remove(@NonNull Fragment fragment) {
if (fragment.isRemoving()) {
return;
}
fragment.getFragmentManager().beginTransaction()
.remove(fragment)
.commit();
}
@Deprecated
public static void replace(@NonNull Fragment fragment, @NonNull FragmentManager fragmentManager,
@IdRes int containerViewId, @Nullable String tag) {
fragmentManager.beginTransaction()
.replace(containerViewId, fragment, tag)
.commit();
}
@Deprecated
public static void replace(@NonNull Fragment fragment, @NonNull FragmentManager fragmentManager,
@IdRes int containerViewId) {
//noinspection deprecation
replace(fragment, fragmentManager, containerViewId, null);
}
public static void replace(@NonNull Fragment fragment, @NonNull FragmentActivity activity,
@IdRes int containerViewId) {
//noinspection deprecation
replace(fragment, activity.getSupportFragmentManager(), containerViewId);
}
public static void replace(@NonNull Fragment fragment, @NonNull Fragment parentFragment,
@IdRes int containerViewId) {
//noinspection deprecation
replace(fragment, parentFragment.getChildFragmentManager(), containerViewId);
}
@Deprecated
public static void replace(@NonNull Fragment fragment, @NonNull FragmentManager fragmentManager,
@NonNull String tag) {
// Pass 0 as in {@link android.support.v4.app.BackStackRecord#replace(Fragment, String)}.
//noinspection deprecation
replace(fragment, fragmentManager, 0, tag);
}
public static void replace(@NonNull Fragment fragment, @NonNull FragmentActivity activity,
@NonNull String tag) {
//noinspection deprecation
replace(fragment, activity.getSupportFragmentManager(), tag);
}
public static void replace(@NonNull Fragment fragment, @NonNull Fragment parentFragment,
@NonNull String tag) {
//noinspection deprecation
replace(fragment, parentFragment.getChildFragmentManager(), tag);
}
public static void replace(@NonNull Fragment fragment, @NonNull FragmentActivity activity) {
//noinspection deprecation
replace(fragment, activity.getSupportFragmentManager(), 0, null);
}
public static void replace(@NonNull Fragment fragment, @NonNull Fragment parentFragment) {
//noinspection deprecation
replace(fragment, parentFragment.getChildFragmentManager(), 0, null);
}
public static void executePendingTransactions(@NonNull FragmentActivity activity) {
activity.getSupportFragmentManager().executePendingTransactions();
}
public static void executePendingTransactions(@NonNull Fragment fragment) {
fragment.getFragmentManager().executePendingTransactions();
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/FragmentUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 1,366 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.os.Build;
import android.os.Parcelable;
import android.provider.MediaStore;
import android.provider.Settings;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.core.content.IntentCompat;
import java.io.File;
public class IntentUtils {
private static final String ACTION_INSTALL_SHORTCUT =
"com.android.launcher.action.INSTALL_SHORTCUT";
private static final String MIME_TYPE_TEXT_PLAIN = "text/plain";
private static final String MIME_TYPE_IMAGE_ANY = "image/*";
private static final String MIME_TYPE_ANY = "*/*";
private IntentUtils() {}
@NonNull
public static Intent withChooser(@Nullable Intent intent) {
return Intent.createChooser(intent, null);
}
@NonNull
public static Intent makeCaptureImage(@NonNull Uri outputUri) {
return new Intent(MediaStore.ACTION_IMAGE_CAPTURE)
.putExtra(MediaStore.EXTRA_OUTPUT, outputUri);
}
@NonNull
public static Intent makeCaptureImage(@NonNull File outputFile, @NonNull Context context) {
return new Intent(MediaStore.ACTION_IMAGE_CAPTURE)
.putExtra(MediaStore.EXTRA_OUTPUT, FileUtils.getContentUri(outputFile, context));
}
@NonNull
public static Intent makeInstallShortcut(int iconRes, int nameRes,
@NonNull Class<?> intentClass,
@NonNull Context context) {
return new Intent()
.setAction(ACTION_INSTALL_SHORTCUT)
.putExtra(Intent.EXTRA_SHORTCUT_INTENT, new Intent(context.getApplicationContext(),
intentClass))
.putExtra(Intent.EXTRA_SHORTCUT_NAME, context.getString(nameRes))
.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE,
Intent.ShortcutIconResource.fromContext(context, iconRes));
}
@Nullable
public static Intent makeLaunchApp(@NonNull String packageName, @NonNull Context context) {
return context.getPackageManager().getLaunchIntentForPackage(packageName);
}
@NonNull
public static Intent makeMediaScan(@NonNull Uri uri) {
return new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE)
.setData(uri);
}
@NonNull
public static Intent makeMediaScan(@NonNull File file) {
return makeMediaScan(Uri.fromFile(file));
}
@NonNull
public static Intent makePickFile(boolean allowMultiple) {
return makePickFile(MIME_TYPE_ANY, null, allowMultiple);
}
@NonNull
public static Intent makePickFile(@NonNull String mimeType, boolean allowMultiple) {
return makePickFile(mimeType, new String[] { mimeType }, allowMultiple);
}
@NonNull
public static Intent makePickFile(@Nullable String[] mimeTypes, boolean allowMultiple) {
String mimeType = mimeTypes != null && mimeTypes.length == 1 ? mimeTypes[0] : MIME_TYPE_ANY;
return makePickFile(mimeType, mimeTypes, allowMultiple);
}
@NonNull
private static Intent makePickFile(@NonNull String mimeType, @Nullable String[] mimeTypes,
boolean allowMultiple) {
// If not using ACTION_OPEN_DOCUMENT, URI permission can be lost after ~10 seconds.
String action = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT ?
Intent.ACTION_OPEN_DOCUMENT : Intent.ACTION_GET_CONTENT;
Intent intent = new Intent(action)
.addCategory(Intent.CATEGORY_OPENABLE)
.setType(mimeType);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
if (mimeTypes != null && mimeTypes.length > 0) {
intent.putExtra(Intent.EXTRA_MIME_TYPES, mimeTypes);
}
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
if (allowMultiple) {
intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true);
}
}
return intent;
}
@NonNull
public static Intent makePickImage(boolean allowMultiple) {
return makePickFile(MIME_TYPE_IMAGE_ANY, allowMultiple);
}
@NonNull
public static Intent makePickOrCaptureImageWithChooser(boolean allowPickMultiple,
@NonNull Uri captureOutputUri) {
return withChooser(makePickImage(allowPickMultiple))
.putExtra(Intent.EXTRA_INITIAL_INTENTS, new Parcelable[] {
makeCaptureImage(captureOutputUri)
});
}
@NonNull
public static Intent makePickOrCaptureImageWithChooser(boolean allowPickMultiple,
@NonNull File captureOutputFile,
@NonNull Context context) {
return makePickOrCaptureImageWithChooser(allowPickMultiple, FileUtils.getContentUri(
captureOutputFile, context));
}
// TODO: Use android.support.v4.app.ShareCompat ?
@NonNull
public static Intent makeSendText(@NonNull CharSequence text, @Nullable String htmlText) {
Intent intent = new Intent()
.setAction(Intent.ACTION_SEND)
.putExtra(Intent.EXTRA_TEXT, text);
if (htmlText != null) {
intent.putExtra(IntentCompat.EXTRA_HTML_TEXT, htmlText);
}
return intent.setType(MIME_TYPE_TEXT_PLAIN);
}
@NonNull
public static Intent makeSendText(@NonNull CharSequence text) {
return makeSendText(text, null);
}
@NonNull
public static Intent makeSendImage(@NonNull Uri uri, @Nullable CharSequence text) {
Intent intent = makeSendStream(uri, MIME_TYPE_IMAGE_ANY);
if (text != null) {
intent
// For maximum compatibility.
.putExtra(Intent.EXTRA_TEXT, text)
.putExtra(Intent.EXTRA_TITLE, text)
.putExtra(Intent.EXTRA_SUBJECT, text)
// HACK: WeChat moments respects this extra only.
.putExtra("Kdescription", text);
}
return intent;
}
@NonNull
public static Intent makeSendImage(@NonNull Uri uri) {
return makeSendImage(uri, null);
}
@NonNull
public static Intent makeSendStream(@NonNull Uri stream, @NonNull String type) {
return new Intent(Intent.ACTION_SEND)
.putExtra(Intent.EXTRA_STREAM, stream)
.setType(type);
}
@NonNull
public static Intent makeSyncSettings(@Nullable String[] authorities,
@Nullable String[] accountTypes) {
Intent intent = new Intent(Settings.ACTION_SYNC_SETTINGS);
if (!ArrayUtils.isEmpty(authorities)) {
intent.putExtra(Settings.EXTRA_AUTHORITIES, authorities);
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
if (!ArrayUtils.isEmpty(accountTypes)) {
intent.putExtra(Settings.EXTRA_ACCOUNT_TYPES, accountTypes);
}
}
return intent;
}
@NonNull
public static Intent makeSyncSettingsWithAuthority(@Nullable String authority) {
return makeSyncSettings(authority != null ? new String[] { authority } : null, null);
}
@NonNull
public static Intent makeSyncSettingsWithAccountType(@Nullable String accountType) {
return makeSyncSettings(null, accountType != null ? new String[] { accountType } : null);
}
@NonNull
public static Intent makeSyncSettings() {
return makeSyncSettings(null, null);
}
@NonNull
public static Intent makeView(@NonNull Uri uri) {
return new Intent(Intent.ACTION_VIEW, uri);
}
@NonNull
public static Intent makeView(@NonNull Uri uri, @NonNull String type) {
return new Intent(Intent.ACTION_VIEW)
// Calling setType() will clear data.
.setDataAndType(uri, type)
.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
}
@NonNull
public static Intent makeViewAppInMarket(@NonNull String packageName) {
return makeView(Uri.parse("market://details?id=" + packageName));
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/IntentUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 1,649 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.content.SharedPreferences;
import android.preference.PreferenceManager;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import java.util.Set;
import me.zhanghai.android.douya.DouyaApplication;
public class SharedPrefsUtils {
private SharedPrefsUtils() {}
@NonNull
public static SharedPreferences getSharedPrefs() {
return PreferenceManager.getDefaultSharedPreferences(DouyaApplication.getInstance());
}
@Nullable
public static String getString(@NonNull Entry<String> entry) {
return getSharedPrefs().getString(entry.getKey(), entry.getDefaultValue());
}
@Nullable
public static Set<String> getStringSet(@NonNull Entry<Set<String>> entry) {
return getSharedPrefs().getStringSet(entry.getKey(), entry.getDefaultValue());
}
public static int getInt(@NonNull Entry<Integer> entry) {
return getSharedPrefs().getInt(entry.getKey(), entry.getDefaultValue());
}
public static long getLong(@NonNull Entry<Long> entry) {
return getSharedPrefs().getLong(entry.getKey(), entry.getDefaultValue());
}
public static float getFloat(@NonNull Entry<Float> entry) {
return getSharedPrefs().getFloat(entry.getKey(), entry.getDefaultValue());
}
public static boolean getBoolean(@NonNull Entry<Boolean> entry) {
return getSharedPrefs().getBoolean(entry.getKey(), entry.getDefaultValue());
}
@NonNull
public static SharedPreferences.Editor getEditor() {
return getSharedPrefs().edit();
}
public static void putString(@NonNull Entry<String> entry, @Nullable String value) {
getEditor().putString(entry.getKey(), value).apply();
}
public static void putStringSet(@NonNull Entry<Set<String>> entry, @Nullable Set<String> value) {
getEditor().putStringSet(entry.getKey(), value).apply();
}
public static void putInt(@NonNull Entry<Integer> entry, int value) {
getEditor().putInt(entry.getKey(), value).apply();
}
public static void putLong(@NonNull Entry<Long> entry, long value) {
getEditor().putLong(entry.getKey(), value).apply();
}
public static void putFloat(@NonNull Entry<Float> entry, float value) {
getEditor().putFloat(entry.getKey(), value).apply();
}
public static void putBoolean(@NonNull Entry<Boolean> entry, boolean value) {
getEditor().putBoolean(entry.getKey(), value).apply();
}
public static void remove(@NonNull Entry<?> entry) {
getEditor().remove(entry.getKey()).apply();
}
public static void clear() {
getEditor().clear().apply();
}
public interface Entry<T> {
@NonNull
String getKey();
@NonNull
T getDefaultValue();
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/SharedPrefsUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 586 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
public class ObjectUtils {
private ObjectUtils() {}
public static final Object EMPTY_OBJECT = new Object();
/**
* @deprecated Should never be used.
*/
@Nullable
public static <T> T firstNonNull(@Nullable T first) {
return first;
}
@Nullable
public static <T> T firstNonNull(@Nullable T first, @Nullable T second) {
return first != null ? first : second;
}
@Nullable
public static <T> T firstNonNull(@Nullable T first, @Nullable T second, @Nullable T third) {
return first != null ? first
: second != null ? second
: third;
}
/**
* @deprecated Do you really need this?
*/
@Nullable
@SafeVarargs
public static <T> T firstNonNull(@NonNull T... values) {
for (T value : values) {
if (value != null) {
return value;
}
}
return null;
}
@Nullable
public static String toString(@Nullable Object object) {
return object != null ? object.toString() : null;
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/ObjectUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 277 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.media.AudioAttributes;
import android.media.AudioFocusRequest;
import android.media.AudioManager;
import android.os.Build;
import androidx.media.AudioAttributesCompat;
import java.util.WeakHashMap;
public class AudioManagerCompat {
private static final WeakHashMap<AudioManager.OnAudioFocusChangeListener, Object>
sListenerRequestMap = new WeakHashMap<>();
private AudioManagerCompat() {}
public static int requestAudioFocus(AudioManager audioManager,
int focusGain, AudioAttributesCompat attributes,
AudioManager.OnAudioFocusChangeListener listener) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
AudioFocusRequest request = new AudioFocusRequest.Builder(focusGain)
.setAudioAttributes((AudioAttributes) attributes.unwrap())
.setOnAudioFocusChangeListener(listener)
.build();
sListenerRequestMap.put(listener, request);
return audioManager.requestAudioFocus(request);
} else {
//noinspection deprecation
return audioManager.requestAudioFocus(listener, attributes.getLegacyStreamType(),
focusGain);
}
}
public static int abandonAudioFocus(AudioManager audioManager,
AudioManager.OnAudioFocusChangeListener listener) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
AudioFocusRequest request = (AudioFocusRequest) sListenerRequestMap.remove(listener);
if (listener != null && request == null) {
// The same behavior as abandoning a never requested or already abandoned request.
return AudioManager.AUDIOFOCUS_REQUEST_GRANTED;
}
return audioManager.abandonAudioFocusRequest(request);
} else {
//noinspection deprecation
return audioManager.abandonAudioFocus(listener);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/AudioManagerCompat.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 358 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
public class SystemProperties {
public static final String FILE_SEPARATOR = "file.separator";
public static final String JAVA_CLASS_PATH = "java.class.path";
public static final String JAVA_CLASS_VERSION = "java.class.version";
public static final String JAVA_COMPILER = "java.compiler";
public static final String JAVA_EXT_DIRS = "java.ext.dirs";
public static final String JAVA_HOME = "java.home";
public static final String JAVA_IO_TMPDIR = "java.io.tmpdir";
public static final String JAVA_LIBRARY_PATH = "java.library.path";
public static final String JAVA_VENDOR = "java.vendor";
public static final String JAVA_VENDOR_URL = "java.vendor.url";
public static final String JAVA_VERSION = "java.version";
public static final String JAVA_SPECIFICATION_VERSION = "java.specification.version";
public static final String JAVA_SPECIFICATION_VENDOR = "java.specification.vendor";
public static final String JAVA_SPECIFICATION_NAME = "java.specification.name";
public static final String JAVA_VM_VERSION = "java.vm.version";
public static final String JAVA_VM_VENDOR = "java.vm.vendor";
public static final String JAVA_VM_NAME = "java.vm.name";
public static final String JAVA_VM_SPECIFICATION_VERSION = "java.vm.specification.version";
public static final String JAVA_VM_SPECIFICATION_VENDOR = "java.vm.specification.vendor";
public static final String JAVA_VM_SPECIFICATION_NAME = "java.vm.specification.name";
public static final String LINE_SEPARATOR = "line.separator";
public static final String OS_ARCH = "os.arch";
public static final String OS_NAME = "os.name";
public static final String OS_VERSION = "os.version";
public static final String PATH_SEPARATOR = "path.separator";
public static final String USER_DIR = "user.dir";
public static final String USER_HOME = "user.home";
public static final String USER_NAME = "user.name";
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/SystemProperties.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 412 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.os.Environment;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;
public class BuildUtils {
private static final File BUILD_PROP_FILE = new File(Environment.getRootDirectory(),
"build.prop");
private static Properties sBuildProperties;
private static final Object sBuildPropertiesLock = new Object();
private BuildUtils() {}
public static Properties getBuildProperties() {
synchronized (sBuildPropertiesLock) {
if (sBuildProperties == null) {
sBuildProperties = new Properties();
try {
sBuildProperties.load(new FileInputStream(BUILD_PROP_FILE));
} catch (IOException e) {
e.printStackTrace();
}
}
}
return sBuildProperties;
}
public static boolean isEmotionUi() {
return getBuildProperties().containsKey("ro.build.version.emui");
}
public static String getEmotionUiVersion() {
return getBuildProperties().getProperty("ro.build.version.emui");
}
public static boolean isSamsung() {
return getBuildProperties().containsKey("ro.build.PDA");
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/BuildUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 252 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.os.Build;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.RequiresApi;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiFunction;
@SuppressWarnings("unused")
public class MapBuilder<K, V, M extends Map<K, V>> {
@NonNull
private M mMap;
private MapBuilder(@NonNull M map) {
mMap = map;
}
@NonNull
public static <K, V> MapBuilder<K, V, HashMap<K, V>> newHashMap() {
return new MapBuilder<>(new HashMap<>());
}
@NonNull
public static <K, V, M extends Map<K, V>> MapBuilder<K, V, M> buildUpon(@NonNull M map) {
return new MapBuilder<>(map);
}
@NonNull
public M build() {
M map = mMap;
mMap = null;
return map;
}
@NonNull
public Map<K, V> buildUnmodifiable() {
Map<K, V> map = Collections.unmodifiableMap(mMap);
mMap = null;
return map;
}
@NonNull
public MapBuilder<K, V, M> put(@Nullable K key, @Nullable V value) {
mMap.put(key, value);
return this;
}
@NonNull
public MapBuilder<K, V, M> remove(@Nullable K key) {
mMap.remove(key);
return this;
}
@NonNull
public MapBuilder<K, V, M> putAll(@NonNull Map<? extends K, ? extends V> m) {
mMap.putAll(m);
return this;
}
@NonNull
public MapBuilder<K, V, M> clear() {
mMap.clear();
return this;
}
@NonNull
@RequiresApi(Build.VERSION_CODES.N)
public MapBuilder<K, V, M> replaceAll(
@NonNull BiFunction<? super K, ? super V, ? extends V> function) {
mMap.replaceAll(function);
return this;
}
@NonNull
@RequiresApi(Build.VERSION_CODES.N)
public MapBuilder<K, V, M> putIfAbsent(@Nullable K key, @Nullable V value) {
mMap.putIfAbsent(key, value);
return this;
}
@NonNull
@RequiresApi(Build.VERSION_CODES.N)
public MapBuilder<K, V, M> remove(@Nullable K key, @Nullable V value) {
mMap.remove(key, value);
return this;
}
@NonNull
@RequiresApi(Build.VERSION_CODES.N)
public MapBuilder<K, V, M> replace(@Nullable K key, @Nullable V oldValue,
@Nullable V newValue) {
mMap.replace(key, oldValue, newValue);
return this;
}
@NonNull
@RequiresApi(Build.VERSION_CODES.N)
public MapBuilder<K, V, M> replace(@Nullable K key, @Nullable V value) {
mMap.replace(key, value);
return this;
}
@NonNull
@RequiresApi(Build.VERSION_CODES.N)
public MapBuilder<K, V, M> merge(
@Nullable K key, @NonNull V value,
@NonNull BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
mMap.merge(key, value, remappingFunction);
return this;
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/MapBuilder.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 739 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.content.ContentResolver;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.provider.OpenableColumns;
import android.text.TextUtils;
import android.webkit.MimeTypeMap;
public class UriUtils {
public static boolean isWebScheme(Uri uri) {
String scheme = uri.getScheme();
if (TextUtils.isEmpty(scheme)) {
return false;
}
switch (uri.getScheme()) {
case "http":
case "https":
return true;
default:
return false;
}
}
public static String getDisplayName(Uri uri, ContentResolver contentResolver) {
String displayName = null;
try (Cursor cursor = contentResolver.query(uri, null, null, null, null)) {
if (cursor != null && cursor.getCount() > 0) {
int columnIndex = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME);
if (columnIndex != -1) {
cursor.moveToFirst();
if (!cursor.isNull(columnIndex)) {
displayName = cursor.getString(columnIndex);
}
}
}
}
if (TextUtils.isEmpty(displayName)) {
displayName = uri.getLastPathSegment();
}
return displayName;
}
public static String getDisplayName(Uri uri, Context context) {
return getDisplayName(uri, context.getContentResolver());
}
public static long getSize(Uri uri, ContentResolver contentResolver) {
try (Cursor cursor = contentResolver.query(uri, null, null, null, null)) {
if (cursor != null && cursor.getCount() > 0) {
int columnIndex = cursor.getColumnIndex(OpenableColumns.SIZE);
if (columnIndex != -1) {
cursor.moveToFirst();
if (!cursor.isNull(columnIndex)) {
return cursor.getLong(columnIndex);
}
}
}
}
return -1;
}
public static long getSize(Uri uri, Context context) {
return getSize(uri, context.getContentResolver());
}
public static String getType(Uri uri, ContentResolver contentResolver) {
String type = contentResolver.getType(uri);
if (TextUtils.isEmpty(type)) {
String extension = FileNameUtils.getExtension(uri.getLastPathSegment());
if (!TextUtils.isEmpty(extension)) {
type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
}
}
if (TextUtils.isEmpty(type)) {
String displayName = getDisplayName(uri, contentResolver);
String extension = FileNameUtils.getExtension(displayName);
if (!TextUtils.isEmpty(extension)) {
type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
}
}
return !TextUtils.isEmpty(type) ? type : null;
}
public static String getType(Uri uri, Context context) {
return getType(uri, context.getContentResolver());
}
public static long parseId(Uri uri) {
String last = uri.getLastPathSegment();
return last == null ? -1 : Long.parseLong(last);
}
public static Uri.Builder appendId(Uri.Builder builder, long id) {
return builder.appendEncodedPath(String.valueOf(id));
}
public static Uri withAppendedId(Uri contentUri, long id) {
return appendId(contentUri.buildUpon(), id).build();
}
public static Uri withoutQueryAndFragment(Uri uri) {
return uri.buildUpon()
.clearQuery()
.fragment(null)
.build();
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/UriUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 711 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.text.TextUtils;
import java.util.Locale;
public class StringUtils {
private StringUtils() {}
public static boolean equalsIgnoreCase(String s1, String s2) {
//noinspection StringEquality
if (s1 == s2) {
return true;
} else if (s1 != null) {
return s1.equalsIgnoreCase(s2);
} else {
return false;
}
}
public static String formatUs(String format, Object... args) {
return String.format(Locale.US, format, args);
}
public static String joinNonEmpty(CharSequence delimiter, CharSequence... elements) {
StringBuilder builder = new StringBuilder();
boolean first = true;
for (CharSequence element : elements) {
if (TextUtils.isEmpty(element)) {
continue;
}
if (first) {
first = false;
} else {
builder.append(delimiter);
}
builder.append(element);
}
return builder.toString();
}
public static String joinNonEmpty(CharSequence delimiter,
Iterable<? extends CharSequence> elements) {
StringBuilder builder = new StringBuilder();
boolean first = true;
for (CharSequence element : elements) {
if (TextUtils.isEmpty(element)) {
continue;
}
if (first) {
first = false;
} else {
builder.append(delimiter);
}
builder.append(element);
}
return builder.toString();
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/StringUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 312 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import androidx.annotation.NonNull;
import android.text.TextUtils;
/**
* This class assumes the only separator to be '/'.
*
* Terminology:
* <ul>
* <li>file = path + SEPARATOR + fileName</li>
* <li>fileName = baseName + EXTENSION_SEPARATOR + extension</li>
* </ul>
*/
public class FileNameUtils {
private static final char EXTENSION_SEPARATOR = '.';
// Not using File.separatorChar so that behavior is consistent and always ready for URIs.
// Anyway we are on Android. If one day we were moved to Windows, fail-fast is also good.
private static final char SEPARATOR = '/';
private FileNameUtils() {}
@NonNull
public static String getBaseName(@NonNull String path) {
return removeExtension(getFileName(path));
}
@NonNull
public static String getExtension(@NonNull String path) {
int index = indexOfExtensionSeparator(path);
return index != -1 ? path.substring(index + 1) : "";
}
@NonNull
public static String getFileName(@NonNull String path) {
int index = indexOfLastSeparator(path);
return path.substring(index + 1);
}
@NonNull
public static String getDirectory(@NonNull String path) {
int index = indexOfLastSeparator(path);
return index != -1 ? path.substring(0, index) : ".";
}
@NonNull
public static String getDirectoryWithEndSeparator(@NonNull String path) {
// We assume the only separator is '/'.
return getDirectory(path) + SEPARATOR;
}
public static int indexOfExtensionSeparator(@NonNull String path) {
int lastSeparatorIndex = indexOfLastSeparator(path);
int lastExtensionSeparatorIndex = path.lastIndexOf(EXTENSION_SEPARATOR);
return lastSeparatorIndex > lastExtensionSeparatorIndex ? -1 : lastExtensionSeparatorIndex;
}
public static int indexOfLastSeparator(@NonNull String path) {
return path.lastIndexOf(SEPARATOR);
}
@NonNull
public static String removeExtension(@NonNull String path) {
int index = indexOfExtensionSeparator(path);
return index != -1 ? path.substring(0, index) : path;
}
@NonNull
public static String replaceExtension(@NonNull String path, @NonNull String extension) {
path = removeExtension(path);
if (!TextUtils.isEmpty(extension)) {
path += EXTENSION_SEPARATOR + extension;
}
return path;
}
public static boolean isValidFileName(@NonNull String fileName) {
return !TextUtils.isEmpty(fileName) && fileName.indexOf('/') == -1
&& fileName.indexOf('\0') == -1;
}
public static boolean isValidPath(@NonNull String path) {
return !TextUtils.isEmpty(path) && path.indexOf('\0') == -1;
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/FileNameUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 600 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.annotation.StringRes;
import android.widget.Toast;
public class ToastUtils {
private ToastUtils() {}
public static void show(@NonNull CharSequence text, int duration, @NonNull Context context) {
Toast.makeText(context, text, duration).show();
}
public static void show(@StringRes int textRes, int duration, @NonNull Context context) {
show(context.getText(textRes), duration, context);
}
public static void show(@NonNull CharSequence text, @NonNull Context context) {
show(text, Toast.LENGTH_SHORT, context);
}
public static void show(@StringRes int textRes, @NonNull Context context) {
show(context.getText(textRes), context);
}
public static void showLong(@NonNull CharSequence text, @NonNull Context context) {
show(text, Toast.LENGTH_LONG, context);
}
public static void showLong(@StringRes int textRes, @NonNull Context context) {
showLong(context.getText(textRes), context);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/ToastUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 235 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.annotation.SuppressLint;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import me.zhanghai.android.douya.DouyaApplication;
public class ConnectivityUtils {
private ConnectivityUtils() {}
public static boolean isConnected() {
return isConnected(getActiveNetworkInfo());
}
private static boolean isConnected(NetworkInfo networkInfo) {
return networkInfo != null && networkInfo.isConnected();
}
public static boolean isNonMobileConnected() {
return isNonMobileConnected(getActiveNetworkInfo());
}
private static boolean isNonMobileConnected(NetworkInfo networkInfo) {
return isConnected(networkInfo) && !isMobileNetwork(networkInfo);
}
private static boolean isMobileNetwork(@NonNull NetworkInfo networkInfo) {
return isNetworkTypeMobile(networkInfo.getType());
}
/*
* @see ConnectivityManager#isNetworkTypeMobile(int)
*/
private static boolean isNetworkTypeMobile(int networkType) {
switch (networkType) {
case ConnectivityManager.TYPE_MOBILE:
//noinspection deprecation
case ConnectivityManager.TYPE_MOBILE_MMS:
//noinspection deprecation
case ConnectivityManager.TYPE_MOBILE_SUPL:
case ConnectivityManager.TYPE_MOBILE_DUN:
//noinspection deprecation
case ConnectivityManager.TYPE_MOBILE_HIPRI:
//case ConnectivityManager.TYPE_MOBILE_FOTA:
//case ConnectivityManager.TYPE_MOBILE_IMS:
//case ConnectivityManager.TYPE_MOBILE_CBS:
//case ConnectivityManager.TYPE_MOBILE_IA:
//case ConnectivityManager.TYPE_MOBILE_EMERGENCY:
return true;
default:
return false;
}
}
/**
* @deprecated Remove @SuppressLint("MissingPermission") and add permission to use.
*/
@SuppressLint("MissingPermission")
@Nullable
private static NetworkInfo getActiveNetworkInfo() {
return getConnectivityManager().getActiveNetworkInfo();
}
private static ConnectivityManager getConnectivityManager() {
return (ConnectivityManager) DouyaApplication.getInstance().getSystemService(
Context.CONNECTIVITY_SERVICE);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/ConnectivityUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 450 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import java.util.Map;
import java.util.Objects;
import me.zhanghai.android.douya.functional.compat.BiFunction;
import me.zhanghai.android.douya.functional.compat.Function;
@SuppressWarnings("unused")
public class MapCompat {
private MapCompat() {
}
@Nullable
public static <K, V> V getOrDefault(@NonNull Map<K, V> map, @Nullable K key,
@Nullable V defaultValue) {
V value = map.get(key);
if (value != null || map.containsKey(key)) {
return value;
}
return defaultValue;
}
@Nullable
public static <K, V> V putIfAbsent(@NonNull Map<K, V> map, @Nullable K key,
@Nullable V value) {
V oldValue = map.get(key);
if (oldValue == null) {
oldValue = map.put(key, value);
}
return oldValue;
}
@Nullable
public static <K, V> V computeIfAbsent(
@NonNull Map<K, V> map, @Nullable K key,
@NonNull Function<? super K, ? extends V> mappingFunction) {
Objects.requireNonNull(mappingFunction);
V value = map.get(key);
if (value == null) {
V newValue = mappingFunction.apply(key);
if (newValue != null) {
map.put(key, newValue);
return newValue;
}
}
return value;
}
@Nullable
public static <K, V> V computeIfPresent(
@NonNull Map<K, V> map, @Nullable K key,
@NonNull BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
Objects.requireNonNull(remappingFunction);
V oldValue = map.get(key);
if (oldValue != null) {
V newValue = remappingFunction.apply(key, oldValue);
if (newValue != null) {
map.put(key, newValue);
return newValue;
} else {
map.remove(key);
return null;
}
} else {
return null;
}
}
@Nullable
public static <K, V> V compute(
@NonNull Map<K, V> map, @Nullable K key,
@NonNull BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
Objects.requireNonNull(remappingFunction);
V oldValue = map.get(key);
V newValue = remappingFunction.apply(key, oldValue);
if (newValue != null) {
map.put(key, newValue);
return newValue;
} else {
if (oldValue != null || map.containsKey(key)) {
map.remove(key);
}
return null;
}
}
@Nullable
public static <K, V> V merge(
@NonNull Map<K, V> map, @Nullable K key, @NonNull V value,
@NonNull BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
Objects.requireNonNull(remappingFunction);
Objects.requireNonNull(value);
V oldValue = map.get(key);
V newValue = oldValue != null ? remappingFunction.apply(oldValue, value) : value;
if (newValue != null) {
map.put(key, newValue);
} else {
map.remove(key);
}
return newValue;
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/MapCompat.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 730 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import androidx.annotation.NonNull;
import android.text.Spannable;
import android.text.SpannableString;
import android.text.Spanned;
import android.text.util.Linkify;
import android.util.Patterns;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import me.zhanghai.android.douya.ui.UriSpan;
public class SpanUtils {
/**
* Modified from {@link Patterns#WEB_URL}, with ftp scheme added and an optional trailing slash.
*/
@SuppressWarnings("deprecation")
public static final Pattern WEB_URL_PATTERN = Pattern.compile(
"((?:(http|https|Http|Https|ftp|Ftp|rtsp|Rtsp):\\/\\/(?:(?:[a-zA-Z0-9\\$\\-\\_\\.\\+\\!\\*\\'\\(\\)"
+ "\\,\\;\\?\\&\\=]|(?:\\%[a-fA-F0-9]{2})){1,64}(?:\\:(?:[a-zA-Z0-9\\$\\-\\_"
+ "\\.\\+\\!\\*\\'\\(\\)\\,\\;\\?\\&\\=]|(?:\\%[a-fA-F0-9]{2})){1,25})?\\@)?)?"
+ "(?:" + Patterns.DOMAIN_NAME + ")"
+ "(?:\\:\\d{1,5})?)"
+ "(\\/(?:(?:[" + Patterns.GOOD_IRI_CHAR + "\\;\\/\\?\\:\\@\\&\\=\\#\\~"
+ "\\-\\.\\+\\!\\*\\'\\(\\)\\,\\_])|(?:\\%[a-fA-F0-9]{2}))*)?"
+ "(?=\\W|$)");
private static final String[] WEB_URL_SCHEMES = { "http://", "https://", "ftp://", "rtsp://" };
/**
* Filters out web URL matches that occur after an at-sign (@). This is
* to prevent turning the domain name in an email address into a web link.
*/
private static final MatchFilter WEB_URL_MATCH_FILTER = new MatchFilter() {
public final boolean acceptMatch(CharSequence s, int start, int end) {
if (start == 0) {
return true;
}
if (s.charAt(start - 1) == '@') {
return false;
}
return true;
}
};
/**
* Modified from {@link Patterns#EMAIL_ADDRESS}, with optional mailto scheme added.
*/
public static final Pattern EMAIL_PATTERN = Pattern.compile(
"(mailto:)?"
+ "[a-zA-Z0-9\\+\\.\\_\\%\\-\\+]{1,256}"
+ "\\@"
+ "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,64}"
+ "("
+ "\\."
+ "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,25}"
+ ")+"
);
private static final String[] EMAIL_SCHEMES = { "mailto:" };
/**
* Modified from {@link Patterns#PHONE}, with required tel/sms/smsto scheme added.
*/
public static final Pattern PHONE_URI_PATTERN = Pattern.compile(
"(tel|sms|smsto):"
+ "(\\+[0-9]+[\\- \\.]*)?"
+ "(\\([0-9]+\\)[\\- \\.]*)?"
+ "([0-9][0-9\\- \\.]+[0-9])");
/**
* Modified from {@link Linkify#addLinks(Spannable, int)}.
*/
public static Spannable addLinks(Spannable spannable) {
List<Link> links = new ArrayList<>();
gatherLinks(links, spannable, WEB_URL_PATTERN, WEB_URL_SCHEMES, WEB_URL_MATCH_FILTER);
gatherLinks(links, spannable, EMAIL_PATTERN, EMAIL_SCHEMES, null);
gatherLinks(links, spannable, PHONE_URI_PATTERN, null, null);
pruneOverlaps(links);
if (links.size() == 0) {
return spannable;
}
for (Link link: links) {
applyLink(link, spannable);
}
return spannable;
}
public static Spannable addLinks(CharSequence text) {
return addLinks(new SpannableString(text));
}
private static void gatherLinks(List<Link> links, CharSequence text, Pattern pattern,
String[] schemes, MatchFilter matchFilter) {
Matcher matcher = pattern.matcher(text);
while (matcher.find()) {
int start = matcher.start();
int end = matcher.end();
if (matchFilter == null || matchFilter.acceptMatch(text, start, end)) {
links.add(new Link(start, end, makeUrl(matcher.group(0), schemes)));
}
}
}
private static String makeUrl(String url, String[] prefixes) {
if (ArrayUtils.isEmpty(prefixes)) {
return url;
}
boolean hasPrefix = false;
for (String prefix : prefixes) {
if (url.regionMatches(true, 0, prefix, 0, prefix.length())) {
hasPrefix = true;
// Fix capitalization if necessary
if (!url.regionMatches(false, 0, prefix, 0, prefix.length())) {
url = prefix + url.substring(prefix.length());
}
break;
}
}
if (!hasPrefix) {
url = prefixes[0] + url;
}
return url;
}
private static void pruneOverlaps(List<Link> links) {
Collections.sort(links);
int i = 0;
int last = links.size() - 1;
while (i < last) {
Link a = links.get(i);
Link b = links.get(i + 1);
int remove = -1;
if ((a.start <= b.start) && (a.end > b.start)) {
if (b.end <= a.end) {
remove = i + 1;
} else if ((a.end - a.start) > (b.end - b.start)) {
remove = i + 1;
} else if ((a.end - a.start) < (b.end - b.start)) {
remove = i;
}
if (remove != -1) {
links.remove(remove);
--last;
continue;
}
}
++i;
}
}
private static void applyLink(Link link, Spannable spannable) {
spannable.setSpan(new UriSpan(link.url), link.start, link.end,
Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
}
private interface MatchFilter {
boolean acceptMatch(CharSequence s, int start, int end);
}
private static class Link implements Comparable<Link> {
public int start;
public int end;
public String url;
public Link(int start, int end, String url) {
this.start = start;
this.end = end;
this.url = url;
}
@Override
public int compareTo(@NonNull Link that) {
if (start < that.start) {
return -1;
}
if (start > that.start) {
return 1;
}
if (end < that.end) {
return 1;
}
if (end > that.end) {
return -1;
}
return 0;
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/SpanUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 1,626 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonParseException;
import com.google.gson.JsonPrimitive;
import java.lang.reflect.Type;
import me.zhanghai.android.douya.network.api.info.frodo.TimelineItem;
import me.zhanghai.android.douya.network.api.info.frodo.Broadcast;
import me.zhanghai.android.douya.network.api.info.frodo.CollectableItem;
import me.zhanghai.android.douya.network.api.info.frodo.CompleteCollectableItem;
import me.zhanghai.android.douya.network.api.info.frodo.Notification;
public class GsonHelper {
public static final Gson GSON;
public static final Gson GSON_NETWORK;
static {
GsonBuilder builder = new GsonBuilder()
.serializeNulls()
.registerTypeAdapter(int.class, new IntegerDeserializer())
.registerTypeAdapter(Integer.class, new IntegerDeserializer())
.registerTypeAdapter(long.class, new LongDeserializer())
.registerTypeAdapter(Long.class, new LongDeserializer())
.registerTypeAdapter(float.class, new FloatDeserializer())
.registerTypeAdapter(Float.class, new FloatDeserializer())
.registerTypeAdapter(double.class, new DoubleDeserializer())
.registerTypeAdapter(Double.class, new DoubleDeserializer())
.registerTypeAdapter(CollectableItem.class, new CollectableItem.Deserializer())
.registerTypeAdapter(CompleteCollectableItem.class,
new CompleteCollectableItem.Deserializer());
GSON = builder.create();
builder
.registerTypeAdapter(Notification.class, new Notification.Deserializer())
.registerTypeAdapter(Broadcast.class, new Broadcast.Deserializer());
GSON_NETWORK = builder.create();
}
private GsonHelper() {}
private static class IntegerDeserializer implements JsonDeserializer<Integer> {
@Override
public Integer deserialize(JsonElement json, Type typeOfT,
JsonDeserializationContext context) throws JsonParseException {
if (json.isJsonNull()) {
return null;
} else if (json.isJsonPrimitive()) {
JsonPrimitive jsonPrimitive = (JsonPrimitive) json;
if (jsonPrimitive.isString() && jsonPrimitive.getAsString().isEmpty()) {
return null;
}
}
return json.getAsInt();
}
}
private static class LongDeserializer implements JsonDeserializer<Long> {
@Override
public Long deserialize(JsonElement json, Type typeOfT,
JsonDeserializationContext context) throws JsonParseException {
if (json.isJsonNull()) {
return null;
} else if (json.isJsonPrimitive()) {
JsonPrimitive jsonPrimitive = (JsonPrimitive) json;
if (jsonPrimitive.isString() && jsonPrimitive.getAsString().isEmpty()) {
return null;
}
}
return json.getAsLong();
}
}
private static class FloatDeserializer implements JsonDeserializer<Float> {
@Override
public Float deserialize(JsonElement json, Type typeOfT,
JsonDeserializationContext context) throws JsonParseException {
if (json.isJsonNull()) {
return null;
} else if (json.isJsonPrimitive()) {
JsonPrimitive jsonPrimitive = (JsonPrimitive) json;
if (jsonPrimitive.isString() && jsonPrimitive.getAsString().isEmpty()) {
return null;
}
}
return json.getAsFloat();
}
}
private static class DoubleDeserializer implements JsonDeserializer<Double> {
@Override
public Double deserialize(JsonElement json, Type typeOfT,
JsonDeserializationContext context) throws JsonParseException {
if (json.isJsonNull()) {
return null;
} else if (json.isJsonPrimitive()) {
JsonPrimitive jsonPrimitive = (JsonPrimitive) json;
if (jsonPrimitive.isString() && jsonPrimitive.getAsString().isEmpty()) {
return null;
}
}
return json.getAsDouble();
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/GsonHelper.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 841 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.animation.ArgbEvaluator;
import android.animation.ObjectAnimator;
import android.app.Activity;
import android.view.Window;
public class StatusBarColorUtils {
private static final ArgbEvaluator sArgbEvaluator = new ArgbEvaluator();
public static void animateTo(Window window, int color, int duration) {
if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.LOLLIPOP) {
return;
}
ObjectAnimator animator = ObjectAnimator.ofInt(window, "statusBarColor",
window.getStatusBarColor(), color);
animator.setEvaluator(sArgbEvaluator);
animator.setDuration(duration);
animator.setAutoCancel(true);
animator.start();
}
public static void animateTo(int color, Activity activity) {
animateTo(activity.getWindow(), color, ViewUtils.getShortAnimTime(activity));
}
public static void set(Window window, int color) {
if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.LOLLIPOP) {
return;
}
window.setStatusBarColor(color);
}
public static void set(int color, Activity activity) {
set(activity.getWindow(), color);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/StatusBarColorUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 256 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import android.text.TextUtils;
public class MoreTextUtils {
private MoreTextUtils() {}
/**
* @deprecated Use {@link TextUtils#equals(CharSequence, CharSequence)} instead.
*/
public static boolean equalsAny(@Nullable CharSequence text, @Nullable CharSequence text1) {
return TextUtils.equals(text, text1);
}
public static boolean equalsAny(@Nullable CharSequence text, @Nullable CharSequence text1,
@Nullable CharSequence text2) {
return TextUtils.equals(text, text1) || TextUtils.equals(text, text2);
}
public static boolean equalsAny(@Nullable CharSequence text, @Nullable CharSequence text1,
@Nullable CharSequence text2, @Nullable CharSequence text3) {
return TextUtils.equals(text, text1) || TextUtils.equals(text, text2)
|| TextUtils.equals(text, text3);
}
public static boolean equalsAny(@Nullable CharSequence text, CharSequence... array) {
for (CharSequence element : array) {
if (TextUtils.equals(text, element)) {
return true;
}
}
return false;
}
public static boolean contains(@Nullable String text, @NonNull CharSequence text1) {
return text != null && text.contains(text1);
}
/**
* @deprecated Use {@link #contains(String, CharSequence)} instead.
*/
public static boolean containsAny(@Nullable String text, @NonNull CharSequence text1) {
return contains(text, text1);
}
public static boolean containsAny(@Nullable String text, @NonNull CharSequence text1,
@NonNull CharSequence text2) {
return contains(text, text1) || contains(text, text2);
}
public static boolean containsAny(@Nullable String text, @NonNull CharSequence text1,
@NonNull CharSequence text2, @NonNull CharSequence text3) {
return contains(text, text1) || contains(text, text2) || contains(text, text3);
}
public static boolean containsAny(@Nullable String text, CharSequence... array) {
for (CharSequence element : array) {
if (contains(text, element)) {
return true;
}
}
return false;
}
public static boolean startsWith(@Nullable String text, @NonNull String prefix) {
return text != null && text.startsWith(prefix);
}
public static boolean endsWith(@Nullable String text, @NonNull String prefix) {
return text != null && text.endsWith(prefix);
}
@Nullable
public static CharSequence emptyToNull(@Nullable CharSequence text) {
return text != null && text.length() == 0 ? null : text;
}
@NonNull
public static CharSequence nullToEmpty(@Nullable CharSequence text) {
return text == null ? "" : text;
}
@Nullable
public static String emptyToNull(@Nullable String text) {
return text != null && text.isEmpty() ? null : text;
}
@NonNull
public static String nullToEmpty(@Nullable String text) {
return text == null ? "" : text;
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/MoreTextUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 663 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.util.LruCache;
import com.google.gson.JsonParseException;
import com.google.gson.reflect.TypeToken;
import com.jakewharton.disklrucache.DiskLruCache;
import java.io.BufferedWriter;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
import java.lang.reflect.Type;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
public class DiskCache {
private DiskLruCache mCache;
private SafeKeyGenerator mSafeKeyGenerator = new SafeKeyGenerator();
private DiskCache(DiskLruCache cache) {
mCache = cache;
}
public static DiskCache openOrThrow(File directory, int version, long maxSize)
throws IOException {
return new DiskCache(DiskLruCache.open(directory, version, 1, maxSize));
}
public static DiskCache open(File directory, int version, long maxSize) {
try {
return openOrThrow(directory, version, maxSize);
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
private DiskLruCache.Snapshot getOrThrow(String key) throws IOException, NullPointerException {
DiskLruCache.Snapshot snapshot = mCache.get(mSafeKeyGenerator.getSafeKey(key));
if (snapshot == null) {
throw new NullPointerException("DiskLruCache.get() returned null");
}
return snapshot;
}
public InputStream getInputStreamOrThrow(String key) throws IOException, NullPointerException {
return getOrThrow(key).getInputStream(0);
}
public InputStream getInputStream(String key) {
try {
return getInputStreamOrThrow(key);
} catch (IOException | NullPointerException e) {
e.printStackTrace();
return null;
}
}
public String getStringOrThrow(String key) throws IOException {
return getOrThrow(key).getString(0);
}
public String getString(String key) {
try {
return getStringOrThrow(key);
} catch (IOException | NullPointerException e) {
e.printStackTrace();
return null;
}
}
public <T> T getGsonOrThrow(String key, Type type) throws IOException, JsonParseException {
// Gson.fromJson() creates a JsonReader which does its own buffering.
Reader reader = new InputStreamReader(getInputStreamOrThrow(key));
try {
return GsonHelper.GSON.fromJson(reader, type);
} finally {
reader.close();
}
}
public <T> T getGson(String key, Type type) {
try {
return getGsonOrThrow(key, type);
} catch (IOException | NullPointerException e) {
e.printStackTrace();
return null;
}
}
public <T> T getGson(String key, TypeToken<T> typeToken) {
return getGson(key, typeToken.getType());
}
private DiskLruCache.Editor editOrThrow(String key) throws IOException, NullPointerException {
DiskLruCache.Editor editor = mCache.edit(mSafeKeyGenerator.getSafeKey(key));
if (editor == null) {
throw new NullPointerException("DiskLruCache.edit() returned null");
}
return editor;
}
public void putBytesOrThrow(String key, byte[] value) throws IOException, NullPointerException {
DiskLruCache.Editor editor = editOrThrow(key);
try {
editor.newOutputStream(0).write(value);
editor.commit();
} finally {
editor.abortUnlessCommitted();
}
}
public void putBytes(String key, byte[] value) {
try {
putBytesOrThrow(key, value);
} catch (IOException | NullPointerException e) {
e.printStackTrace();
}
}
public void putStringOrThrow(String key, String value)
throws IOException, NullPointerException {
putBytesOrThrow(key, value.getBytes(StandardCharsetsCompat.UTF_8));
}
public void putString(String key, String value) {
try {
putStringOrThrow(key, value);
} catch (IOException | NullPointerException e) {
e.printStackTrace();
}
}
public <T> void putGsonOrThrow(String key, T value, Type type)
throws IOException, NullPointerException {
DiskLruCache.Editor editor = editOrThrow(key);
try {
Writer writer = new BufferedWriter(new OutputStreamWriter(editor.newOutputStream(0)));
try {
GsonHelper.GSON.toJson(value, type, writer);
} finally {
writer.close();
}
editor.commit();
} finally {
editor.abortUnlessCommitted();
}
}
public <T> void putGson(String key, T value, Type type) {
try {
putGsonOrThrow(key, value, type);
} catch (IOException | NullPointerException e) {
e.printStackTrace();
}
}
public <T> void putGson(String key, T value, TypeToken<T> typeToken) {
putGson(key, value, typeToken.getType());
}
public boolean removeOrThrow(String key) throws IOException {
return mCache.remove(key);
}
public boolean remove(String key) {
try {
return removeOrThrow(key);
} catch (IOException e) {
e.printStackTrace();
return false;
}
}
public void deleteOrThrow() throws IOException {
mCache.delete();
mCache = null;
}
public void delete() {
try {
deleteOrThrow();
} catch (IOException e) {
e.printStackTrace();
}
}
public void closeOrThrow() throws IOException {
mCache.close();
}
public void close() {
try {
closeOrThrow();
} catch (IOException e) {
e.printStackTrace();
}
}
private static class SafeKeyGenerator {
private final LruCache<String, String> loadIdToSafeHash = new LruCache<>(100);
public String getSafeKey(String key) {
String safeKey;
synchronized (loadIdToSafeHash) {
safeKey = loadIdToSafeHash.get(key);
}
if (safeKey == null) {
try {
MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
messageDigest.update(key.getBytes(StandardCharsetsCompat.UTF_8));
safeKey = IoUtils.byteArrayToHexString(messageDigest.digest(), true);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
synchronized (loadIdToSafeHash) {
loadIdToSafeHash.put(key, safeKey);
}
}
return safeKey;
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/DiskCache.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 1,408 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import androidx.annotation.NonNull;
import java.util.Comparator;
public class NaturalOrderComparator implements Comparator<String> {
private static final int DIGIT_RADIX = 10;
@Override
public int compare(@NonNull String string1, @NonNull String string2) {
int start1 = 0;
int start2 = 0;
int leadingZeroCompareResult = 0;
while (start1 < string1.length() && start2 < string2.length()) {
int codePoint1 = string1.codePointAt(start1);
int codePoint2 = string2.codePointAt(start2);
if (!Character.isDigit(codePoint1) || !Character.isDigit(codePoint2)) {
if (!codePointEqualsIgnoreCase(codePoint1, codePoint2)) {
return codePointCompareToIgnoreCase(codePoint1, codePoint2);
}
start1 = string1.offsetByCodePoints(start1, 1);
start2 = string2.offsetByCodePoints(start2, 1);
continue;
}
int end1 = start1;
do {
end1 = string1.offsetByCodePoints(end1, 1);
} while (end1 < string1.length() && Character.isDigit(string1.codePointAt(end1)));
int end2 = start2;
do {
end2 = string2.offsetByCodePoints(end2, 1);
} while (end2 < string2.length() && Character.isDigit(string2.codePointAt(end2)));
int noLeadingZeroStart1 = start1;
while (noLeadingZeroStart1 < end1 && Character.digit(string1.codePointAt(
noLeadingZeroStart1), DIGIT_RADIX) == 0) {
noLeadingZeroStart1 = string1.offsetByCodePoints(noLeadingZeroStart1, 1);
}
int noLeadingZeroStart2 = start2;
while (noLeadingZeroStart2 < end2 && Character.digit(string2.codePointAt(
noLeadingZeroStart2), DIGIT_RADIX) == 0) {
noLeadingZeroStart2 = string2.offsetByCodePoints(noLeadingZeroStart2, 1);
}
int noLeadingZeroLength1 = string1.codePointCount(noLeadingZeroStart1, end1);
int noLeadingZeroLength2 = string2.codePointCount(noLeadingZeroStart2, end2);
if (noLeadingZeroLength1 != noLeadingZeroLength2) {
return noLeadingZeroLength1 - noLeadingZeroLength2;
}
for (int digitIndex1 = noLeadingZeroStart1, digitIndex2 = noLeadingZeroStart2;
digitIndex1 < end1; digitIndex1 = string1.offsetByCodePoints(digitIndex1, 1),
digitIndex2 = string2.offsetByCodePoints(digitIndex2, 1)) {
int digit1 = Character.digit(string1.codePointAt(digitIndex1), DIGIT_RADIX);
int digit2 = Character.digit(string2.codePointAt(digitIndex2), DIGIT_RADIX);
if (digit1 != digit2) {
return digit1 - digit2;
}
}
int leadingZeroLength1 = string1.codePointCount(start1, noLeadingZeroStart1);
int leadingZeroLength2 = string2.codePointCount(start2, noLeadingZeroStart2);
if (leadingZeroLength1 != leadingZeroLength2) {
if (leadingZeroCompareResult == 0) {
leadingZeroCompareResult = leadingZeroLength1 - leadingZeroLength2;
}
}
start1 = end1;
start2 = end2;
}
int remainingLength1 = string1.codePointCount(start1, string1.length());
int remainingLength2 = string2.codePointCount(start2, string2.length());
if (remainingLength1 != remainingLength2) {
return remainingLength1 - remainingLength2;
}
if (leadingZeroCompareResult != 0) {
return leadingZeroCompareResult;
}
return string1.compareTo(string2);
}
// @see String#regionMatches(boolean, int, String, int, int)
private static boolean codePointEqualsIgnoreCase(int codePoint1, int codePoint2) {
codePoint1 = Character.toUpperCase(codePoint1);
codePoint2 = Character.toUpperCase(codePoint2);
if (codePoint1 == codePoint2) {
return true;
}
codePoint1 = Character.toLowerCase(codePoint1);
codePoint2 = Character.toLowerCase(codePoint2);
return codePoint1 == codePoint2;
}
// @see String.CaseInsensitiveComparator#compare(String, String)
private static int codePointCompareToIgnoreCase(int codePoint1, int codePoint2) {
if (codePoint1 != codePoint2) {
codePoint1 = Character.toUpperCase(codePoint1);
codePoint2 = Character.toUpperCase(codePoint2);
if (codePoint1 != codePoint2) {
codePoint1 = Character.toUpperCase(codePoint1);
codePoint2 = Character.toUpperCase(codePoint2);
if (codePoint1 != codePoint2) {
return codePoint1 - codePoint2;
}
}
}
return 0;
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/NaturalOrderComparator.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 1,140 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import java.util.Objects;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
public class ArrayUtils {
public static int indexOf(@NonNull byte[] array, byte value) {
for (int i = 0; i < array.length; ++i) {
if (array[i] == value) {
return i;
}
}
return -1;
}
public static int indexOf(@NonNull char[] array, char value) {
for (int i = 0; i < array.length; ++i) {
if (array[i] == value) {
return i;
}
}
return -1;
}
public static int indexOf(@NonNull short[] array, short value) {
for (int i = 0; i < array.length; ++i) {
if (array[i] == value) {
return i;
}
}
return -1;
}
public static int indexOf(@NonNull int[] array, int value) {
for (int i = 0; i < array.length; ++i) {
if (array[i] == value) {
return i;
}
}
return -1;
}
public static int indexOf(@NonNull long[] array, long value) {
for (int i = 0; i < array.length; ++i) {
if (array[i] == value) {
return i;
}
}
return -1;
}
public static int indexOf(@NonNull float[] array, float value) {
for (int i = 0; i < array.length; ++i) {
if (array[i] == value) {
return i;
}
}
return -1;
}
public static int indexOf(@NonNull double[] array, double value) {
for (int i = 0; i < array.length; ++i) {
if (array[i] == value) {
return i;
}
}
return -1;
}
public static <T> int indexOf(@NonNull T[] array, T value) {
for (int i = 0; i < array.length; ++i) {
if (Objects.equals(array[i], value)) {
return i;
}
}
return -1;
}
public static boolean isEmpty(@Nullable byte[] array) {
return array == null || array.length == 0;
}
public static boolean isEmpty(@Nullable char[] array) {
return array == null || array.length == 0;
}
public static boolean isEmpty(@Nullable short[] array) {
return array == null || array.length == 0;
}
public static boolean isEmpty(@Nullable int[] array) {
return array == null || array.length == 0;
}
public static boolean isEmpty(@Nullable long[] array) {
return array == null || array.length == 0;
}
public static boolean isEmpty(@Nullable float[] array) {
return array == null || array.length == 0;
}
public static boolean isEmpty(@Nullable double[] array) {
return array == null || array.length == 0;
}
public static <T> boolean isEmpty(@Nullable T[] array) {
return array == null || array.length == 0;
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/ArrayUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 719 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.os.Build;
public class LongCompat {
private LongCompat() {}
public static int hashCode(long value) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
return Long.hashCode(value);
} else {
return Long.valueOf(value).hashCode();
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/LongCompat.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 81 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.app.Activity;
import com.google.android.material.snackbar.Snackbar;
import android.view.View;
public class SnackbarUtils {
public static void show(View view, CharSequence text) {
Snackbar.make(view, text, Snackbar.LENGTH_SHORT).show();
}
public static void show(View view, int textRes) {
show(view, view.getResources().getText(textRes));
}
public static void show(CharSequence text, Activity activity) {
show(activity.findViewById(android.R.id.content), text);
}
public static void show(int textRes, Activity activity) {
show(activity.getText(textRes), activity);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/SnackbarUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 147 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.content.Context;
import me.zhanghai.android.douya.network.api.info.UrlGettable;
public class ShareUtils {
private ShareUtils() {}
public static void shareText(String text, Context context) {
AppUtils.startActivityWithChooser(IntentUtils.makeSendText(text), context);
}
public static void shareUrl(UrlGettable urlGettable, Context context) {
shareText(urlGettable.getUrl(), context);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/ShareUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 112 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import java.nio.charset.Charset;
public class StandardCharsetsCompat {
private StandardCharsetsCompat() {}
/**
* The ISO-8859-1 charset.
*/
public static final Charset ISO_8859_1 = Charset.forName("ISO-8859-1");
/**
* The US-ASCII charset.
*/
public static final Charset US_ASCII = Charset.forName("US-ASCII");
/**
* The UTF-8 charset.
*/
public static final Charset UTF_8 = Charset.forName("UTF-8");
/**
* The UTF-16 charset.
*/
public static final Charset UTF_16 = Charset.forName("UTF-16");
/**
* The UTF-16BE (big-endian) charset.
*/
public static final Charset UTF_16BE = Charset.forName("UTF-16BE");
/**
* The UTF-16LE (little-endian) charset.
*/
public static final Charset UTF_16LE = Charset.forName("UTF-16LE");
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/StandardCharsetsCompat.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 232 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.core.util.ObjectsCompat;
import java.util.AbstractList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.RandomAccess;
import java.util.Set;
import me.zhanghai.android.douya.functional.Functional;
import me.zhanghai.android.douya.functional.FunctionalIterator;
public class CollectionUtils {
private CollectionUtils() {}
@Nullable
public static <E> E first(@NonNull List<? extends E> list) {
return list.get(0);
}
@Nullable
public static <E> E last(@NonNull List<? extends E> list) {
return list.get(list.size() - 1);
}
@Nullable
public static <E> E firstOrNull(@NonNull List<? extends E> list) {
return getOrNull(list, 0);
}
@Nullable
public static <E> E lastOrNull(@NonNull List<? extends E> list) {
return getOrNull(list, list.size() - 1);
}
@Nullable
public static <E> E getOrNull(@NonNull List<? extends E> list, int index) {
return index >= 0 && index < list.size() ? list.get(index) : null;
}
@Nullable
public static <E> E first(@NonNull Collection<? extends E> collection) {
return collection.iterator().next();
}
@Nullable
public static <E> E firstOrNull(@NonNull Collection<? extends E> collection) {
return collection.size() > 0 ? first(collection) : null;
}
@Nullable
public static <E> E peek(@NonNull List<? extends E> list) {
return lastOrNull(list);
}
public static <E> void push(@NonNull List<? super E> list, E item) {
list.add(item);
}
@Nullable
public static <E> E pop(@NonNull List<? extends E> list) {
return list.remove(list.size() - 1);
}
@Nullable
public static <E> E popOrNull(@NonNull List<? extends E> list) {
return !list.isEmpty() ? pop(list) : null;
}
public static boolean isEmpty(@Nullable Collection<?> collection) {
return collection == null || collection.isEmpty();
}
public static int size(@Nullable Collection<?> collection) {
return collection != null ? collection.size() : 0;
}
public static <E> boolean startsWith(@NonNull List<? extends E> list1,
@NonNull List<? extends E> list2) {
return list1.size() >= list2.size() && Functional.every(list2, (element, index) ->
ObjectsCompat.equals(list1.get(index), element));
}
public static <E> boolean endsWith(@NonNull List<? extends E> list1,
@NonNull List<? extends E> list2) {
int list1Size = list1.size();
return list1Size >= list2.size() && FunctionalIterator.everyRemaining(
new FunctionalIterator.ReverseIterator<>(list2), (element, index) ->
ObjectsCompat.equals(list1.get(list1Size - 1 - index), element));
}
@Nullable
public static <E> Set<E> singletonOrNull(@Nullable E element) {
return element != null ? Collections.singleton(element) : null;
}
@Nullable
public static <E> List<E> singletonListOrNull(@Nullable E element) {
return element != null ? Collections.singletonList(element) : null;
}
@NonNull
public static <E> Set<E> singletonOrEmpty(@Nullable E element) {
return element != null ? Collections.singleton(element) : Collections.emptySet();
}
@NonNull
public static <E> List<E> singletonListOrEmpty(@Nullable E element) {
return element != null ? Collections.singletonList(element) : Collections.emptyList();
}
@NonNull
public static <E> Set<E> difference(@NonNull Set<? extends E> set1,
@NonNull Set<? extends E> set2) {
Set<E> result = new HashSet<>();
difference(set1, set2, result);
return result;
}
@NonNull
public static <E> Set<E> symmetricDifference(@NonNull Set<? extends E> set1,
@NonNull Set<? extends E> set2) {
Set<E> result = new HashSet<>();
difference(set1, set2, result);
difference(set2, set1, result);
return result;
}
private static <E> void difference(@NonNull Set<? extends E> set1,
@NonNull Set<? extends E> set2, @NonNull Set<E> result) {
for (E element : set1) {
if (!set2.contains(element)) {
result.add(element);
}
}
}
@NonNull
public static <E> List<E> join(@NonNull List<? extends E> list1,
@NonNull List<? extends E> list2) {
if (list1 instanceof RandomAccess && list2 instanceof RandomAccess) {
return new RandomAccessJoinedList<>(list1, list2);
} else {
return new JoinedList<>(list1, list2);
}
}
private static class JoinedList<E> extends AbstractList<E> {
@NonNull
private final List<? extends E> mList1;
@NonNull
private final List<? extends E> mList2;
public JoinedList(@NonNull List<? extends E> list1, @NonNull List<? extends E> list2) {
mList1 = list1;
mList2 = list2;
}
@Nullable
@Override
public E get(int location) {
int list1Size = mList1.size();
return location < list1Size ? mList1.get(location) : mList2.get(location - list1Size);
}
@Override
public int size() {
return mList1.size() + mList2.size();
}
}
private static class RandomAccessJoinedList<E> extends JoinedList<E> implements RandomAccess {
public RandomAccessJoinedList(@NonNull List<? extends E> list1,
@NonNull List<? extends E> list2) {
super(list1, list2);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/CollectionUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 1,367 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.os.Build;
public class AlarmManagerCompat {
private AlarmManagerCompat() {}
public static void setExact(AlarmManager alarmManager, int type, long triggerAtMillis,
PendingIntent operation) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
alarmManager.setExact(type, triggerAtMillis, operation);
} else {
alarmManager.set(type, triggerAtMillis, operation);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/AlarmManagerCompat.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 126 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.util;
import androidx.annotation.NonNull;
import android.util.Log;
import me.zhanghai.android.douya.BuildConfig;
public class LogUtils {
private static final String TAG = BuildConfig.APPLICATION_ID.substring(
BuildConfig.APPLICATION_ID.lastIndexOf('.') + 1);
private LogUtils() {}
public static void d(@NonNull String message) {
Log.d(TAG, buildMessage(message));
}
public static void e(@NonNull String message) {
Log.e(TAG, buildMessage(message));
}
public static void i(@NonNull String message) {
Log.i(TAG, buildMessage(message));
}
public static void v(@NonNull String message) {
Log.v(TAG, buildMessage(message));
}
public static void w(@NonNull String message) {
Log.w(TAG, buildMessage(message));
}
public static void wtf(@NonNull String message) {
Log.wtf(TAG, buildMessage(message));
}
public static void println(@NonNull String message) {
Log.println(Log.INFO, TAG, message);
}
@NonNull
private static String buildMessage(@NonNull String rawMessage) {
StackTraceElement caller = new Throwable().getStackTrace()[2];
String fullClassName = caller.getClassName();
String className = fullClassName.substring(fullClassName.lastIndexOf(".") + 1);
return className + "." + caller.getMethodName() + "(): " + rawMessage;
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/util/LogUtils.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 308 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.gallery.ui;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import me.zhanghai.android.douya.ui.ImageItem;
import me.zhanghai.android.douya.util.FragmentUtils;
public class GalleryActivity extends AppCompatActivity {
private static final String KEY_PREFIX = GalleryActivity.class.getName() + '.';
private static final String EXTRA_IMAGE_LIST = KEY_PREFIX + "image_list";
private static final String EXTRA_POSITION = KEY_PREFIX + "position";
private static Intent makeIntent(ArrayList<Uri> imageList, int position, Context context) {
return new Intent(context, GalleryActivity.class)
.putParcelableArrayListExtra(EXTRA_IMAGE_LIST, imageList)
.putExtra(EXTRA_POSITION, position);
}
public static Intent makeIntent(List<Uri> imageList, int position, Context context) {
return makeIntent(new ArrayList<>(imageList), position, context);
}
public static Intent makeUrlListIntent(List<String> imageUrlList, int position,
Context context) {
ArrayList<Uri> imageUriList = new ArrayList<>();
for (String imageUrl: imageUrlList) {
imageUriList.add(Uri.parse(imageUrl));
}
return makeIntent(imageUriList, position, context);
}
public static Intent makeImageListIntent(List<? extends ImageItem> imageList, int position,
Context context) {
ArrayList<Uri> imageUriList = new ArrayList<>();
for (ImageItem image : imageList) {
imageUriList.add(Uri.parse(image.getLargeUrl()));
}
return makeIntent(imageUriList, position, context);
}
public static Intent makeIntent(Uri imageUri, Context context) {
return makeIntent(Collections.singletonList(imageUri), 0, context);
}
public static Intent makeIntent(String imageUrl, Context context) {
return makeIntent(Uri.parse(imageUrl), context);
}
public static Intent makeIntent(ImageItem image, Context context) {
return makeIntent(image.getLargeUrl(), context);
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Calls ensureSubDecor().
findViewById(android.R.id.content);
if (savedInstanceState == null) {
Intent intent = getIntent();
ArrayList<Uri> imageList = intent.getParcelableArrayListExtra(EXTRA_IMAGE_LIST);
int position = intent.getIntExtra(EXTRA_POSITION, 0);
FragmentUtils.add(GalleryFragment.newInstance(imageList, position), this,
android.R.id.content);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/gallery/ui/GalleryActivity.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 565 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.gallery.ui;
import android.Manifest;
import android.app.Activity;
import android.net.Uri;
import android.os.Bundle;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.viewpager.widget.ViewPager;
import androidx.interpolator.view.animation.FastOutSlowInInterpolator;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import java.io.File;
import java.util.ArrayList;
import butterknife.BindInt;
import butterknife.BindView;
import butterknife.ButterKnife;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.gallery.app.SaveImageService;
import me.zhanghai.android.douya.ui.ViewPagerTransformers;
import me.zhanghai.android.douya.util.AppUtils;
import me.zhanghai.android.douya.util.FileUtils;
import me.zhanghai.android.douya.util.FragmentUtils;
import me.zhanghai.android.douya.util.IntentUtils;
import me.zhanghai.android.douya.util.ToastUtils;
import me.zhanghai.android.effortlesspermissions.AfterPermissionDenied;
import me.zhanghai.android.effortlesspermissions.EffortlessPermissions;
import me.zhanghai.android.effortlesspermissions.OpenAppDetailsDialogFragment;
import me.zhanghai.android.systemuihelper.SystemUiHelper;
import pub.devrel.easypermissions.AfterPermissionGranted;
public class GalleryFragment extends Fragment {
private static final String KEY_PREFIX = GalleryFragment.class.getName() + '.';
private static final String EXTRA_IMAGE_LIST = KEY_PREFIX + "image_list";
private static final String EXTRA_POSITION = KEY_PREFIX + "position";
private static final int REQUEST_CODE_SAVE_IMAGE_PERMISSION = 1;
private static final String[] PERMISSIONS_SAVE_IMAGE = {
Manifest.permission.WRITE_EXTERNAL_STORAGE
};
@BindInt(android.R.integer.config_mediumAnimTime)
int mToolbarHideDuration;
@BindView(R.id.toolbar)
Toolbar mToolbar;
@BindView(R.id.viewPager)
ViewPager mViewPager;
private MenuItem mSaveMenuItem;
private MenuItem mShareMenuItem;
private ArrayList<Uri> mImageList;
private int mInitialPosition;
private SystemUiHelper mSystemUiHelper;
private GalleryAdapter mAdapter;
public static GalleryFragment newInstance(ArrayList<Uri> imageList, int position) {
//noinspection deprecation
GalleryFragment fragment = new GalleryFragment();
FragmentUtils.getArgumentsBuilder(fragment)
.putParcelableArrayList(EXTRA_IMAGE_LIST, imageList)
.putInt(EXTRA_POSITION, position);
return fragment;
}
/**
* @deprecated Use {@link #newInstance(ArrayList, int)} instead.
*/
public GalleryFragment() {}
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Bundle arguments = getArguments();
mImageList = arguments.getParcelableArrayList(EXTRA_IMAGE_LIST);
mInitialPosition = arguments.getInt(EXTRA_POSITION);
setHasOptionsMenu(true);
}
@Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container,
@Nullable Bundle savedInstanceState) {
return inflater.inflate(R.layout.gallery_fragment, container, false);
}
@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
ButterKnife.bind(this, view);
}
@Override
public void onActivityCreated(@Nullable Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
AppCompatActivity activity = (AppCompatActivity) getActivity();
activity.setSupportActionBar(mToolbar);
mSystemUiHelper = new SystemUiHelper(activity, SystemUiHelper.LEVEL_IMMERSIVE,
SystemUiHelper.FLAG_IMMERSIVE_STICKY,
visible -> {
if (visible) {
mToolbar.animate()
.alpha(1)
.translationY(0)
.setDuration(mToolbarHideDuration)
.setInterpolator(new FastOutSlowInInterpolator())
.start();
} else {
mToolbar.animate()
.alpha(0)
.translationY(-mToolbar.getBottom())
.setDuration(mToolbarHideDuration)
.setInterpolator(new FastOutSlowInInterpolator())
.start();
}
});
// This will set up window flags.
mSystemUiHelper.show();
mAdapter = new GalleryAdapter(mImageList, new GalleryAdapter.Listener() {
@Override
public void onTap() {
mSystemUiHelper.toggle();
}
@Override
public void onFileDownloaded(int position) {
if (position == mViewPager.getCurrentItem()) {
updateOptionsMenu();
}
}
});
mViewPager.setAdapter(mAdapter);
mViewPager.setCurrentItem(mInitialPosition);
mViewPager.setPageTransformer(true, ViewPagerTransformers.DEPTH);
mViewPager.addOnPageChangeListener(new ViewPager.SimpleOnPageChangeListener() {
@Override
public void onPageSelected(int position) {
updateTitle();
updateOptionsMenu();
}
});
updateTitle();
}
private void updateTitle() {
int size = mImageList.size();
if (size <= 1) {
return;
}
getActivity().setTitle(getString(R.string.gallery_title_multiple_format,
mViewPager.getCurrentItem() + 1, size));
}
@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
super.onCreateOptionsMenu(menu, inflater);
inflater.inflate(R.menu.gallery, menu);
mSaveMenuItem = menu.findItem(R.id.action_save);
mShareMenuItem = menu.findItem(R.id.action_share);
updateOptionsMenu();
}
private void updateOptionsMenu() {
if (mSaveMenuItem == null || mShareMenuItem == null) {
return;
}
boolean hasFile = mAdapter.getFile(mViewPager.getCurrentItem()) != null;
mSaveMenuItem.setEnabled(hasFile);
mShareMenuItem.setEnabled(hasFile);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case android.R.id.home:
getActivity().finish();
return true;
case R.id.action_save:
saveImage();
return true;
case R.id.action_share:
shareImage();
return true;
default:
return super.onOptionsItemSelected(item);
}
}
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
@NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
EffortlessPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults,
this);
}
@AfterPermissionGranted(REQUEST_CODE_SAVE_IMAGE_PERMISSION)
private void saveImage() {
if (EffortlessPermissions.hasPermissions(this, PERMISSIONS_SAVE_IMAGE)) {
saveImageWithPermission();
} else {
EffortlessPermissions.requestPermissions(this,
R.string.gallery_save_permission_request_message,
REQUEST_CODE_SAVE_IMAGE_PERMISSION, PERMISSIONS_SAVE_IMAGE);
}
}
@AfterPermissionDenied(REQUEST_CODE_SAVE_IMAGE_PERMISSION)
private void onSaveImagePermissionDenied() {
if (EffortlessPermissions.somePermissionPermanentlyDenied(this, PERMISSIONS_SAVE_IMAGE)) {
OpenAppDetailsDialogFragment.show(
R.string.gallery_save_permission_permanently_denied_message,
R.string.open_settings, this);
} else {
ToastUtils.show(R.string.gallery_save_permission_denied, getActivity());
}
}
private void saveImageWithPermission() {
int position = mViewPager.getCurrentItem();
File file = mAdapter.getFile(position);
if (file == null) {
return;
}
Uri uri = mImageList.get(position);
SaveImageService.start(uri, file, getActivity());
}
private void shareImage() {
File file = mAdapter.getFile(mViewPager.getCurrentItem());
if (file == null) {
return;
}
Activity activity = getActivity();
Uri uri = FileUtils.getContentUri(file, activity);
AppUtils.startActivityWithChooser(IntentUtils.makeSendImage(uri, null), activity);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/gallery/ui/GalleryFragment.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 1,689 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.gallery.app;
import android.app.IntentService;
import android.content.Context;
import android.content.Intent;
import android.media.MediaScannerConnection;
import android.net.Uri;
import android.os.Handler;
import android.provider.MediaStore;
import android.text.TextUtils;
import android.webkit.MimeTypeMap;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.util.FileNameUtils;
import me.zhanghai.android.douya.util.FileTypeUtils;
import me.zhanghai.android.douya.util.FileUtils;
import me.zhanghai.android.douya.util.ToastUtils;
public class SaveImageService extends IntentService {
private static final String KEY_PREFIX = SaveImageService.class.getName() + '.';
private static final String EXTRA_URI = KEY_PREFIX + "uri";
private static final String EXTRA_FILE = KEY_PREFIX + "file";
private Handler mServiceHandler;
public static void start(Uri uri, File file, Context context) {
Intent intent = new Intent(context, SaveImageService.class)
.putExtra(EXTRA_URI, uri)
.putExtra(EXTRA_FILE, file);
context.startService(intent);
}
public SaveImageService() {
super(SaveImageService.class.getSimpleName());
}
@Override
public void onCreate() {
super.onCreate();
mServiceHandler = new Handler();
}
@Override
protected void onHandleIntent(Intent intent) {
if (intent == null) {
return;
}
Uri uri = intent.getParcelableExtra(EXTRA_URI);
File file = (File) intent.getSerializableExtra(EXTRA_FILE);
saveImage(uri, file);
}
private void saveImage(Uri uri, File file) {
try {
String outputFileName = uri.getLastPathSegment();
if (TextUtils.isEmpty(outputFileName)) {
outputFileName = file.getName();
}
// Douban stores GIF images with .jpg extension, so we need to correct this.
String mimeType;
try (InputStream inputStream = new FileInputStream(file)) {
mimeType = FileTypeUtils.getImageMimeType(inputStream);
} catch (IOException e) {
e.printStackTrace();
mimeType = null;
}
if (!TextUtils.isEmpty(mimeType)) {
String extension = MimeTypeMap.getSingleton().getExtensionFromMimeType(mimeType);
outputFileName = FileNameUtils.replaceExtension(outputFileName, extension);
}
File outputFile = FileUtils.makeSaveImageOutputFile(outputFileName);
FileUtils.copy(file, outputFile);
MediaScannerConnection.scanFile(this, new String[] { outputFile.getPath() }, null,
null);
postToast(R.string.gallery_save_successful);
} catch (Exception e) {
e.printStackTrace();
postToast(R.string.gallery_save_failed);
}
}
private void postToast(final int resId) {
mServiceHandler.post(new Runnable() {
@Override
public void run() {
ToastUtils.show(resId, SaveImageService.this);
}
});
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/gallery/app/SaveImageService.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 646 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.gallery.ui;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.collection.SparseArrayCompat;
import android.text.TextUtils;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ProgressBar;
import android.widget.TextView;
import com.bumptech.glide.load.DataSource;
import com.bumptech.glide.load.engine.GlideException;
import com.bumptech.glide.request.RequestListener;
import com.bumptech.glide.request.target.SimpleTarget;
import com.bumptech.glide.request.target.Target;
import com.bumptech.glide.request.transition.Transition;
import com.davemorrissey.labs.subscaleview.ImageSource;
import com.davemorrissey.labs.subscaleview.SubsamplingScaleImageView;
import com.github.chrisbanes.photoview.PhotoView;
import java.io.File;
import java.util.List;
import butterknife.BindView;
import butterknife.ButterKnife;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.glide.GlideApp;
import me.zhanghai.android.douya.glide.info.ImageInfo;
import me.zhanghai.android.douya.glide.progress.ProgressListener;
import me.zhanghai.android.douya.ui.ProgressBarCompat;
import me.zhanghai.android.douya.ui.SaveStateSubsamplingScaleImageView;
import me.zhanghai.android.douya.ui.ViewStatePagerAdapter;
import me.zhanghai.android.douya.util.ImageUtils;
import me.zhanghai.android.douya.util.ViewUtils;
public class GalleryAdapter extends ViewStatePagerAdapter {
private List<Uri> mImageList;
private Listener mListener;
private SparseArrayCompat<File> mFileMap = new SparseArrayCompat<>();
public GalleryAdapter(List<Uri> imageList, Listener listener) {
mImageList = imageList;
mListener = listener;
}
@Override
public int getCount() {
return mImageList.size();
}
@NonNull
@Override
public View onCreateView(@NonNull ViewGroup container, int position) {
final View layout = ViewUtils.inflate(R.layout.gallery_item, container);
final ViewHolder holder = new ViewHolder(layout);
layout.setTag(holder);
holder.image.setOnPhotoTapListener((view, x, y) -> {
if (mListener != null) {
mListener.onTap();
}
});
holder.largeImage.setOnClickListener(view -> {
if (mListener != null) {
mListener.onTap();
}
});
loadImageForPosition(position, holder);
container.addView(layout);
return layout;
}
private void loadImageForPosition(int position, ViewHolder holder) {
ViewUtils.fadeIn(holder.progress);
GlideApp.with(holder.progress.getContext())
.downloadOnlyDefaultPriority()
.load(mImageList.get(position))
.progressListener(new ProgressListener() {
@Override
public void onProgress(long bytesRead, long contentLength, boolean done) {
int progress = Math.round((float) bytesRead / contentLength
* holder.progress.getMax());
ProgressBarCompat.setProgress(holder.progress, progress, true);
}
})
.listener(new RequestListener<File>() {
@Override
public boolean onResourceReady(File resource, Object model, Target<File> target,
DataSource dataSource, boolean isFirstResource) {
return false;
}
@Override
public boolean onLoadFailed(@Nullable GlideException e, Object model,
Target<File> target, boolean isFirstResource) {
showError(e, R.string.gallery_network_error, holder);
return false;
}
})
.into(new SimpleTarget<File>() {
@Override
public void onResourceReady(File file,
Transition<? super File> transition) {
mFileMap.put(position, file);
if (mListener != null) {
mListener.onFileDownloaded(position);
}
holder.progress.setIndeterminate(true);
loadImageFromFile(file, holder);
}
});
}
private void loadImageFromFile(final File file, final ViewHolder holder) {
GlideApp
.with(holder.progress.getContext())
.asInfo()
.load(file)
.listener(new RequestListener<ImageInfo>() {
@Override
public boolean onResourceReady(ImageInfo resource, Object model,
Target<ImageInfo> target, DataSource dataSource,
boolean isFirstResource) {
return false;
}
@Override
public boolean onLoadFailed(@Nullable GlideException e, Object model,
Target<ImageInfo> target, boolean isFirstResource) {
showError(e, R.string.gallery_load_error, holder);
return false;
}
})
.into(new SimpleTarget<ImageInfo>() {
@Override
public void onResourceReady(ImageInfo imageInfo,
Transition<? super ImageInfo> transition) {
loadImageIntoView(file, imageInfo, holder);
}
});
}
private void loadImageIntoView(File file, ImageInfo imageInfo, final ViewHolder holder) {
if (!shouldUseLargeImageView(imageInfo)) {
// Otherwise SizeReadyCallback.onSizeReady() is never called.
ViewUtils.setVisibleOrGone(holder.image, true);
ImageUtils.loadImageFile(holder.image, file, new RequestListener<Drawable>() {
@Override
public boolean onResourceReady(Drawable drawable, Object model,
Target<Drawable> target, DataSource dataSource,
boolean isFirstResource) {
ViewUtils.fadeOut(holder.progress);
ViewUtils.setVisibleOrGone(holder.image, true);
return false;
}
@Override
public boolean onLoadFailed(@Nullable GlideException e, Object model,
Target<Drawable> target, boolean isFirstResource) {
showError(e, R.string.gallery_load_error, holder);
return false;
}
});
} else {
holder.largeImage.setDoubleTapZoomDuration(300);
holder.largeImage.setOrientation(SubsamplingScaleImageView.ORIENTATION_USE_EXIF);
// Otherwise OnImageEventListener.onReady() is never called.
ViewUtils.setVisibleOrGone(holder.largeImage, true);
holder.largeImage.setAlpha(0);
holder.largeImage.setOnImageEventListener(
new SubsamplingScaleImageView.DefaultOnImageEventListener() {
@Override
public void onReady() {
int viewWidth = holder.largeImage.getWidth()
- holder.largeImage.getPaddingLeft()
- holder.largeImage.getPaddingRight();
int viewHeight = holder.largeImage.getHeight()
- holder.largeImage.getPaddingTop()
- holder.largeImage.getPaddingBottom();
int orientation = holder.largeImage.getAppliedOrientation();
boolean rotated90Or270 =
orientation == SubsamplingScaleImageView.ORIENTATION_90
|| orientation
== SubsamplingScaleImageView.ORIENTATION_270;
int imageWidth = rotated90Or270 ? holder.largeImage.getSHeight()
: holder.largeImage.getSWidth();
int imageHeight = rotated90Or270 ? holder.largeImage.getSWidth()
: holder.largeImage.getSHeight();
float cropScale = Math.max((float) viewWidth / imageWidth,
(float) viewHeight / imageHeight);
holder.largeImage.setDoubleTapZoomScale(cropScale);
ViewUtils.crossfade(holder.progress, holder.largeImage);
}
@Override
public void onImageLoadError(Exception e) {
e.printStackTrace();
showError(e, R.string.gallery_load_error, holder);
}
});
holder.largeImage.setImageRestoringSavedState(ImageSource.uri(Uri.fromFile(file)));
}
}
private boolean shouldUseLargeImageView(ImageInfo imageInfo) {
// See BitmapFactory.cpp encodedFormatToString()
if (TextUtils.equals(imageInfo.mimeType, "image/gif")) {
return false;
}
if (imageInfo.width <= 0 || imageInfo.height <= 0) {
return false;
}
if (imageInfo.width > 2048 || imageInfo.height > 2048) {
float ratio = (float) imageInfo.width / imageInfo.height;
if (ratio < 0.5 || ratio > 2) {
return true;
}
}
return false;
}
private void showError(@Nullable Exception e, int resId, ViewHolder holder) {
(e != null ? e : new NullPointerException()).printStackTrace();
holder.errorText.setText(resId);
ViewUtils.crossfade(holder.progress, holder.errorText);
}
@Override
public void onDestroyView(@NonNull ViewGroup container, int position, @NonNull View view) {
ViewHolder holder = (ViewHolder) view.getTag();
GlideApp.with(holder.image).clear(holder.image);
container.removeView(view);
}
public File getFile(int position) {
return mFileMap.get(position);
}
public interface Listener {
void onTap();
void onFileDownloaded(int position);
}
static class ViewHolder {
@BindView(R.id.image)
public PhotoView image;
@BindView(R.id.largeImage)
public SaveStateSubsamplingScaleImageView largeImage;
@BindView(R.id.error)
public TextView errorText;
@BindView(R.id.progress)
public ProgressBar progress;
public ViewHolder(View view) {
ButterKnife.bind(this, view);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/gallery/ui/GalleryAdapter.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 1,893 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.doulist.content;
import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;
import java.util.Collections;
import java.util.List;
import me.zhanghai.android.douya.content.MoreBaseListResourceFragment;
import me.zhanghai.android.douya.eventbus.DoulistDeletedEvent;
import me.zhanghai.android.douya.eventbus.DoulistUpdatedEvent;
import me.zhanghai.android.douya.eventbus.EventBusUtils;
import me.zhanghai.android.douya.network.api.ApiError;
import me.zhanghai.android.douya.network.api.info.frodo.Doulist;
import me.zhanghai.android.douya.network.api.info.frodo.DoulistList;
public abstract class BaseDoulistResource
extends MoreBaseListResourceFragment<DoulistList, Doulist> {
@Override
protected void onLoadStarted() {
getListener().onLoadDoulistListStarted(getRequestCode());
}
@Override
protected void onLoadFinished(boolean more, int count, boolean successful,
List<Doulist> response, ApiError error) {
if (successful) {
if (more) {
append(response);
getListener().onLoadDoulistListFinished(getRequestCode());
getListener().onDoulistListAppended(getRequestCode(),
Collections.unmodifiableList(response));
} else {
set(response);
getListener().onLoadDoulistListFinished(getRequestCode());
getListener().onDoulistListChanged(getRequestCode(),
Collections.unmodifiableList(get()));
}
for (Doulist doulist : response) {
EventBusUtils.postAsync(new DoulistUpdatedEvent(doulist, this));
}
} else {
getListener().onLoadDoulistListFinished(getRequestCode());
getListener().onLoadDoulistListError(getRequestCode(), error);
}
}
@Subscribe(threadMode = ThreadMode.POSTING)
public void onDoulistUpdated(DoulistUpdatedEvent event) {
if (event.isFromMyself(this) || isEmpty()) {
return;
}
List<Doulist> doulistList = get();
for (int i = 0, size = doulistList.size(); i < size; ++i) {
Doulist doulist = doulistList.get(i);
if (doulist.id == event.doulist.id) {
doulistList.set(i, event.doulist);
getListener().onDoulistChanged(getRequestCode(), i, doulistList.get(i));
}
}
}
@Subscribe(threadMode = ThreadMode.POSTING)
public void onDoulistDeleted(DoulistDeletedEvent event) {
if (event.isFromMyself(this) || isEmpty()) {
return;
}
List<Doulist> doulistList = get();
for (int i = 0, size = doulistList.size(); i < size; ) {
Doulist doulist = doulistList.get(i);
if (doulist.id == event.doulistId) {
doulistList.remove(i);
getListener().onDoulistRemoved(getRequestCode(), i);
--size;
} else {
++i;
}
}
}
private Listener getListener() {
return (Listener) getTarget();
}
public interface Listener {
void onLoadDoulistListStarted(int requestCode);
void onLoadDoulistListFinished(int requestCode);
void onLoadDoulistListError(int requestCode, ApiError error);
/**
* @param newDoulistList Unmodifiable.
*/
void onDoulistListChanged(int requestCode, List<Doulist> newDoulistList);
/**
* @param appendedDoulistList Unmodifiable.
*/
void onDoulistListAppended(int requestCode, List<Doulist> appendedDoulistList);
void onDoulistChanged(int requestCode, int position, Doulist newDoulist);
void onDoulistRemoved(int requestCode, int position);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/doulist/content/BaseDoulistResource.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 860 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.content;
import java.util.List;
public abstract class RawListResourceFragment<ResponseType, ResourceType>
extends ListResourceFragment<ResponseType, List<ResourceType>> {
@Override
protected int getSize(List<ResourceType> resource) {
return resource.size();
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/content/RawListResourceFragment.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 72 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.doulist.content;
import android.os.Bundle;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentActivity;
import me.zhanghai.android.douya.network.api.ApiRequest;
import me.zhanghai.android.douya.network.api.ApiService;
import me.zhanghai.android.douya.network.api.info.frodo.CollectableItem;
import me.zhanghai.android.douya.network.api.info.frodo.DoulistList;
import me.zhanghai.android.douya.util.FragmentUtils;
public class ItemRelatedDoulistListResource extends BaseDoulistResource {
private static final String KEY_PREFIX = ItemRelatedDoulistListResource.class.getName() + '.';
private static final String EXTRA_ITEM_TYPE = KEY_PREFIX + "item_type";
private static final String EXTRA_ITEM_ID = KEY_PREFIX + "item_id";
private CollectableItem.Type mItemType;
private long mItemId;
private static final String FRAGMENT_TAG_DEFAULT =
ItemRelatedDoulistListResource.class.getName();
private static ItemRelatedDoulistListResource newInstance(CollectableItem.Type itemType,
long itemId) {
//noinspection deprecation
return new ItemRelatedDoulistListResource().setArguments(itemType, itemId);
}
public static ItemRelatedDoulistListResource attachTo(CollectableItem.Type itemType,
long itemId, Fragment fragment,
String tag, int requestCode) {
FragmentActivity activity = fragment.getActivity();
ItemRelatedDoulistListResource instance = FragmentUtils.findByTag(activity, tag);
if (instance == null) {
instance = newInstance(itemType, itemId);
FragmentUtils.add(instance, activity, tag);
}
instance.setTarget(fragment, requestCode);
return instance;
}
public static ItemRelatedDoulistListResource attachTo(CollectableItem.Type itemType,
long itemId, Fragment fragment) {
return attachTo(itemType, itemId, fragment, FRAGMENT_TAG_DEFAULT, REQUEST_CODE_INVALID);
}
/**
* @deprecated Use {@code attachTo()} instead.
*/
public ItemRelatedDoulistListResource() {}
protected ItemRelatedDoulistListResource setArguments(CollectableItem.Type itemType,
long itemId) {
FragmentUtils.getArgumentsBuilder(this)
.putSerializable(EXTRA_ITEM_TYPE, itemType)
.putLong(EXTRA_ITEM_ID, itemId);
return this;
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mItemType = (CollectableItem.Type) getArguments().getSerializable(EXTRA_ITEM_TYPE);
mItemId = getArguments().getLong(EXTRA_ITEM_ID);
}
@Override
protected ApiRequest<DoulistList> onCreateRequest(Integer start, Integer count) {
return ApiService.getInstance().getItemRelatedDoulistList(mItemType, mItemId, start, count);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/doulist/content/ItemRelatedDoulistListResource.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 598 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.content;
import me.zhanghai.android.douya.network.api.ApiRequest;
public abstract class RequestResourceWriter<W extends RequestResourceWriter, T>
extends ResourceWriter<W> implements ApiRequest.Callback<T> {
private ApiRequest<T> mRequest;
public RequestResourceWriter(ResourceWriterManager<W> manager) {
super(manager);
}
@Override
public void onStart() {
mRequest = onCreateRequest();
mRequest.enqueue(this);
}
protected abstract ApiRequest<T> onCreateRequest();
public void onDestroy() {
mRequest.cancel();
mRequest = null;
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/content/RequestResourceWriter.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 143 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.content;
import android.app.Service;
import android.content.Context;
public abstract class ResourceWriter<W extends ResourceWriter> {
protected ResourceWriterManager<W> mManager;
public ResourceWriter(ResourceWriterManager<W> manager) {
mManager = manager;
}
public abstract void onStart();
public abstract void onDestroy();
protected Context getContext() {
return mManager.getContext();
}
protected Service getService() {
return mManager.getService();
}
protected void stopSelf() {
//noinspection unchecked
mManager.stop((W) this);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/content/ResourceWriter.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 134 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.content;
import me.zhanghai.android.douya.network.api.ApiError;
import me.zhanghai.android.douya.network.api.ApiRequest;
public abstract class MoreListResourceFragment<ResponseType, ResourceListType>
extends ListResourceFragment<ResponseType, ResourceListType> {
private static final int DEFAULT_LOAD_COUNT = 20;
private boolean mLoadingMore;
private boolean mCanLoadMore = true;
private int mLoadCount;
protected abstract ResourceListType addAll(ResourceListType resource, ResourceListType more);
@Override
protected void set(ResourceListType resource) {
super.set(resource);
mCanLoadMore = getSize(resource) == mLoadCount;
}
protected void append(ResourceListType more) {
super.set(addAll(get(), more));
mCanLoadMore = getSize(more) == mLoadCount;
}
protected void setCanLoadMore(boolean canLoadMore) {
mCanLoadMore = canLoadMore;
}
public boolean isLoadingMore() {
return mLoadingMore;
}
@Override
protected void onLoadOnStart() {
load(false);
}
@Override
public final void load() {
throw new UnsupportedOperationException("Use load(boolean, int) instead");
}
public void load(boolean more, int count) {
if (isLoading() || (more && !mCanLoadMore)) {
return;
}
mLoadingMore = more;
mLoadCount = count;
super.load();
}
public void load(boolean loadMore) {
load(loadMore, getDefaultLoadCount());
}
protected int getDefaultLoadCount() {
return DEFAULT_LOAD_COUNT;
}
@Override
protected final ApiRequest<ResponseType> onCreateRequest() {
return onCreateRequest(mLoadingMore, mLoadCount);
}
protected ApiRequest<ResponseType> onCreateRequest(boolean more, int count) {
return onCreateRequest(more && has() ? getSize(get()) : null, count);
}
protected abstract ApiRequest<ResponseType> onCreateRequest(Integer start, Integer count);
@Override
protected final void onLoadFinished(boolean successful, ResponseType response,
ApiError error) {
onLoadFinished(mLoadingMore, mLoadCount, successful, response, error);
mLoadingMore = false;
}
protected abstract void onLoadFinished(boolean more, int count, boolean successful,
ResponseType response, ApiError error);
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/content/MoreListResourceFragment.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 527 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.content;
public abstract class ListResourceFragment<ResponseType, ResourceListType>
extends ResourceFragment<ResponseType, ResourceListType> {
protected abstract int getSize(ResourceListType resource);
public boolean isEmpty() {
return !has() || getSize(get()) == 0;
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/content/ListResourceFragment.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 76 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.content;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.os.IBinder;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import me.zhanghai.android.douya.broadcast.content.DeleteBroadcastCommentManager;
import me.zhanghai.android.douya.broadcast.content.DeleteBroadcastManager;
import me.zhanghai.android.douya.broadcast.content.LikeBroadcastManager;
import me.zhanghai.android.douya.broadcast.content.RebroadcastBroadcastManager;
import me.zhanghai.android.douya.broadcast.content.SendBroadcastCommentManager;
import me.zhanghai.android.douya.broadcast.content.SendBroadcastManager;
import me.zhanghai.android.douya.followship.content.FollowUserManager;
import me.zhanghai.android.douya.item.content.CollectItemManager;
import me.zhanghai.android.douya.item.content.UncollectItemManager;
import me.zhanghai.android.douya.item.content.VoteItemCollectionManager;
public class ResourceWriterService extends Service {
private List<ResourceWriterManager> mWriterManagers = new ArrayList<>();
public static void start(Context context) {
context.startService(new Intent(context, ResourceWriterService.class));
}
@Override
public void onCreate() {
super.onCreate();
addWriterManager(FollowUserManager.getInstance());
addWriterManager(SendBroadcastManager.getInstance());
addWriterManager(LikeBroadcastManager.getInstance());
addWriterManager(RebroadcastBroadcastManager.getInstance());
addWriterManager(DeleteBroadcastManager.getInstance());
addWriterManager(DeleteBroadcastCommentManager.getInstance());
addWriterManager(SendBroadcastCommentManager.getInstance());
addWriterManager(CollectItemManager.getInstance());
addWriterManager(UncollectItemManager.getInstance());
addWriterManager(VoteItemCollectionManager.getInstance());
}
private void addWriterManager(ResourceWriterManager writerManager) {
mWriterManagers.add(writerManager);
writerManager.onBind(this);
}
@Override
public IBinder onBind(Intent intent) {
return null;
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
return START_STICKY;
}
@Override
public void onDestroy() {
super.onDestroy();
removeWriterManagers();
}
private void removeWriterManagers() {
Iterator<ResourceWriterManager> iterator = mWriterManagers.iterator();
while (iterator.hasNext()) {
ResourceWriterManager writerManager = iterator.next();
writerManager.onUnbind();
iterator.remove();
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/content/ResourceWriterService.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 541 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.content;
import android.app.Service;
import android.content.Context;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import me.zhanghai.android.douya.util.CollectionUtils;
public class ResourceWriterManager<T extends ResourceWriter> {
private ResourceWriterService mService;
private List<T> mPendingWriters = new ArrayList<>();
private List<T> mRunningWriters = new ArrayList<>();
private List<T> mUnmodifiableWriters = Collections.unmodifiableList(
CollectionUtils.join(mRunningWriters, mPendingWriters));
public void onBind(ResourceWriterService service) {
mService = service;
movePendingWritersToRunning();
}
private void movePendingWritersToRunning() {
Iterator<T> iterator = mPendingWriters.iterator();
while (iterator.hasNext()) {
T writer = iterator.next();
iterator.remove();
mRunningWriters.add(writer);
writer.onStart();
}
}
public void onUnbind() {
removeRunningWriters();
mService = null;
}
private void removeRunningWriters() {
Iterator<T> iterator = mRunningWriters.iterator();
while (iterator.hasNext()) {
T writer = iterator.next();
writer.onDestroy();
iterator.remove();
}
}
protected boolean isBound() {
return mService != null;
}
public Context getContext() {
return mService;
}
public Service getService() {
return mService;
}
protected void add(T writer, Context context) {
if (isBound()) {
mRunningWriters.add(writer);
writer.onStart();
} else {
mPendingWriters.add(writer);
ResourceWriterService.start(context);
}
}
protected boolean remove(T writer) {
if (mRunningWriters.contains(writer)) {
writer.onDestroy();
return mRunningWriters.remove(writer);
} else {
return mPendingWriters.remove(writer);
}
}
public void stop(T writer) {
if (!remove(writer)) {
throw new IllegalStateException("stop() called with unknown writer");
}
}
protected List<T> getWriters() {
return mUnmodifiableWriters;
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/content/ResourceWriterManager.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 485 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.content;
import java.util.List;
public abstract class MoreRawListResourceFragment<ResponseType, ResourceType>
extends MoreListResourceFragment<ResponseType, List<ResourceType>> {
@Override
protected int getSize(List<ResourceType> resource) {
return resource.size();
}
@Override
protected List<ResourceType> addAll(List<ResourceType> resource, List<ResourceType> more) {
resource.addAll(more);
return resource;
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/content/MoreRawListResourceFragment.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 111 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.content;
import java.util.List;
import me.zhanghai.android.douya.network.api.ApiError;
import me.zhanghai.android.douya.network.api.info.frodo.BaseList;
public abstract class MoreBaseListResourceFragment<ResponseType extends BaseList, ResourceType>
extends MoreRawListResourceFragment<ResponseType, ResourceType> {
private int mTotalSize = -1;
public int getTotalSize() {
return mTotalSize;
}
@Override
protected final void onLoadFinished(boolean more, int count, boolean successful,
ResponseType response, ApiError error) {
if (successful) {
mTotalSize = response.total;
}
onLoadFinished(more, count, successful, successful ? response.getList() : null, error);
}
protected abstract void onLoadFinished(boolean more, int count, boolean successful,
List<ResourceType> response, ApiError error);
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/content/MoreBaseListResourceFragment.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 204 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.content;
import android.os.Bundle;
import org.greenrobot.eventbus.Subscribe;
import me.zhanghai.android.douya.eventbus.EventBusUtils;
import me.zhanghai.android.douya.eventbus.PreventNoSubscriptionExceptionEvent;
import me.zhanghai.android.douya.network.RequestFragment;
import me.zhanghai.android.douya.network.api.ApiRequest;
import me.zhanghai.android.douya.network.api.ApiError;
public abstract class ResourceFragment<ResponseType, ResourceType>
extends RequestFragment<Void, ResponseType> {
ResourceType mResource;
public boolean has() {
return get() != null;
}
public ResourceType get() {
return mResource;
}
protected void set(ResourceType resource) {
mResource = resource;
}
@Override
public final boolean isRequesting() {
throw new UnsupportedOperationException("Use isLoading() instead");
}
public boolean isLoading() {
return super.isRequesting();
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
EventBusUtils.register(this);
}
@Override
public void onDestroy() {
super.onDestroy();
EventBusUtils.unregister(this);
}
@Override
public void onStart() {
super.onStart();
loadOnStart();
}
protected void loadOnStart() {
if (!has()) {
onLoadOnStart();
}
}
protected void onLoadOnStart() {
load();
}
public void load() {
start(null);
}
@Override
protected final ApiRequest<ResponseType> onCreateRequest(Void requestState) {
return onCreateRequest();
}
protected abstract ApiRequest<ResponseType> onCreateRequest();
@Override
protected final void onRequestStarted() {
onLoadStarted();
}
protected abstract void onLoadStarted();
@Override
protected void onRequestFinished(boolean successful, Void requestState, ResponseType response,
ApiError error) {
onLoadFinished(successful, response, error);
}
protected abstract void onLoadFinished(boolean successful, ResponseType response,
ApiError error);
@Subscribe
public final void onPreventNoSubscriptionException(PreventNoSubscriptionExceptionEvent event) {}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/content/ResourceFragment.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 475 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import android.content.Context;
import android.content.Intent;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import java.util.List;
import butterknife.BindView;
import butterknife.ButterKnife;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.gallery.ui.GalleryActivity;
import me.zhanghai.android.douya.network.api.info.frodo.CollectableItem;
import me.zhanghai.android.douya.network.api.info.frodo.Doulist;
import me.zhanghai.android.douya.network.api.info.frodo.Honor;
import me.zhanghai.android.douya.network.api.info.frodo.ItemAwardItem;
import me.zhanghai.android.douya.network.api.info.frodo.Movie;
import me.zhanghai.android.douya.network.api.info.frodo.Photo;
import me.zhanghai.android.douya.network.api.info.frodo.Rating;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleCelebrity;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleItemCollection;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleItemForumTopic;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleReview;
import me.zhanghai.android.douya.ui.RatioImageView;
import me.zhanghai.android.douya.util.CollectionUtils;
import me.zhanghai.android.douya.util.ImageUtils;
import me.zhanghai.android.douya.util.RecyclerViewUtils;
import me.zhanghai.android.douya.util.StringCompat;
import me.zhanghai.android.douya.util.StringUtils;
import me.zhanghai.android.douya.util.ViewUtils;
public class MovieDataAdapter extends BaseItemDataAdapter<Movie> {
private enum Items {
HEADER,
ITEM_COLLECTION,
BADGE_LIST,
INTRODUCTION,
PHOTO_LIST,
CELEBRITY_LIST,
AWARD_LIST,
RATING,
ITEM_COLLECTION_LIST,
REVIEW_LIST,
FORUM_TOPIC_LIST,
RECOMMENDATION_LIST,
RELATED_DOULIST_LIST
}
private Data mData;
public MovieDataAdapter(Listener listener) {
super(listener);
}
public void setData(Data data) {
mData = data;
notifyDataChanged();
}
public void notifyItemCollectionChanged() {
int position = Items.ITEM_COLLECTION.ordinal();
if (position < getItemCount()) {
notifyItemChanged(position);
}
}
public void notifyItemCollectionListItemChanged(int position,
SimpleItemCollection newItemCollection) {
notifyItemCollectionListItemChanged(Items.ITEM_COLLECTION_LIST.ordinal(), position,
newItemCollection);
}
@Override
public int getTotalItemCount() {
return Items.values().length;
}
@Override
protected boolean isItemLoaded(int position) {
if (mData == null) {
return false;
}
if (mData.movie == null) {
return false;
}
switch (Items.values()[position]) {
case HEADER:
return true;
case ITEM_COLLECTION:
return true;
case BADGE_LIST:
return mData.rating != null;
case INTRODUCTION:
return true;
case PHOTO_LIST:
return mData.photoList != null;
case CELEBRITY_LIST:
return mData.celebrityList != null;
case AWARD_LIST:
return mData.awardList != null;
case RATING:
return mData.rating != null;
case ITEM_COLLECTION_LIST:
return mData.itemCollectionList != null;
case REVIEW_LIST:
return mData.reviewList != null;
case FORUM_TOPIC_LIST:
return mData.forumTopicList != null;
case RECOMMENDATION_LIST:
return mData.recommendationList != null;
case RELATED_DOULIST_LIST:
return mData.relatedDoulistList != null;
default:
throw new IllegalArgumentException();
}
}
@NonNull
@Override
public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
switch (Items.values()[viewType]) {
case HEADER:
return createHeaderHolder(parent);
case ITEM_COLLECTION:
return createItemCollectionHolder(parent);
case BADGE_LIST:
return createBadgeListHolder(parent);
case INTRODUCTION:
return createIntroductionHolder(parent);
case PHOTO_LIST:
return createPhotoListHolder(parent);
case CELEBRITY_LIST:
return createCelebrityListHolder(parent);
case AWARD_LIST:
return createAwardListHolder(parent);
case RATING:
return createRatingHolder(parent);
case ITEM_COLLECTION_LIST:
return createItemCollectionListHolder(parent);
case REVIEW_LIST:
return createReviewListHolder(parent);
case FORUM_TOPIC_LIST:
return createForumTopicListHolder(parent);
case RECOMMENDATION_LIST:
return createRecommendationListHolder(parent);
case RELATED_DOULIST_LIST:
return createRelatedDoulistListHolder(parent);
default:
throw new IllegalArgumentException();
}
}
private HeaderHolder createHeaderHolder(ViewGroup parent) {
return new HeaderHolder(ViewUtils.inflate(R.layout.item_fragment_movie_header, parent));
}
@Override
public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position,
@NonNull List<Object> payloads) {
super.onBindViewHolder(holder, position, payloads);
switch (Items.values()[position]) {
case HEADER:
bindHeaderHolder(holder, mData.movie);
break;
case ITEM_COLLECTION:
bindItemCollectionHolder(holder, mData.movie);
break;
case BADGE_LIST:
bindBadgeListHolder(holder, mData.movie, mData.rating);
break;
case INTRODUCTION:
bindIntroductionHolder(holder, mData.movie);
break;
case PHOTO_LIST:
bindPhotoListHolder(holder, mData.movie, mData.photoList, mData.excludeFirstPhoto);
break;
case CELEBRITY_LIST:
bindCelebrityListHolder(holder, mData.movie, mData.celebrityList);
break;
case AWARD_LIST:
bindAwardListHolder(holder, mData.movie, mData.awardList);
break;
case RATING:
bindRatingHolder(holder, mData.movie, mData.rating);
break;
case ITEM_COLLECTION_LIST:
bindItemCollectionListHolder(holder, mData.movie, mData.itemCollectionList,
payloads);
break;
case REVIEW_LIST:
bindReviewListHolder(holder, mData.movie, mData.reviewList);
break;
case FORUM_TOPIC_LIST:
bindForumTopicListHolder(holder, mData.movie, mData.forumTopicList);
break;
case RECOMMENDATION_LIST:
bindRecommendationListHolder(holder, mData.movie, mData.recommendationList);
break;
case RELATED_DOULIST_LIST:
bindRelatedDoulistListHolder(holder, mData.movie, mData.relatedDoulistList);
break;
default:
throw new IllegalArgumentException();
}
}
private void bindHeaderHolder(RecyclerView.ViewHolder holder, Movie movie) {
HeaderHolder headerHolder = (HeaderHolder) holder;
headerHolder.posterImage.setRatio(27, 40);
// Image from movie.poster is cropped except large.
ImageUtils.loadImage(headerHolder.posterImage, movie.cover);
headerHolder.posterImage.setOnClickListener(view -> {
Context context = view.getContext();
Intent intent;
if (movie.poster != null) {
intent = GalleryActivity.makeIntent(movie.poster.image, context);
} else {
intent = GalleryActivity.makeIntent(movie.cover, context);
}
context.startActivity(intent);
});
headerHolder.titleText.setText(movie.title);
headerHolder.originalTitleText.setText(movie.originalTitle);
Context context = RecyclerViewUtils.getContext(holder);
String spaceDelimiter = context.getString(R.string.item_information_delimiter_space);
String detail = StringUtils.joinNonEmpty(spaceDelimiter, movie.getYearMonth(context),
movie.getEpisodeCountString(), movie.getDurationString());
headerHolder.detailText.setText(detail);
String slashDelimiter = context.getString(R.string.item_information_delimiter_slash);
headerHolder.genresText.setText(StringCompat.join(slashDelimiter, movie.genres));
}
private void bindBadgeListHolder(RecyclerView.ViewHolder holder, Movie movie, Rating rating) {
BadgeListHolder badgeListHolder = (BadgeListHolder) holder;
Honor top250Honor = null;
for (Honor honor : movie.honors) {
if (honor.getType() == Honor.Type.TOP_250) {
top250Honor = honor;
break;
}
}
badgeListHolder.badgeListLayout.setTop250(top250Honor);
badgeListHolder.badgeListLayout.setRating(rating, movie);
badgeListHolder.badgeListLayout.setGenre(R.drawable.movie_badge_white_40dp,
CollectionUtils.firstOrNull(movie.genres), CollectableItem.Type.MOVIE);
}
@Override
protected void bindIntroductionHolder(RecyclerView.ViewHolder holder, Movie movie) {
super.bindIntroductionHolder(holder, movie);
IntroductionHolder introductionHolder = (IntroductionHolder) holder;
introductionHolder.introductionLayout.setOnClickListener(view -> {
Context context = view.getContext();
context.startActivity(ItemIntroductionActivity.makeIntent(movie, context));
});
}
@Override
public void onAttachedToRecyclerView(@NonNull RecyclerView recyclerView) {
recyclerView.setClipChildren(false);
}
public interface Listener extends BaseItemDataAdapter.Listener<Movie> {}
public static class Data {
public Movie movie;
public Rating rating;
public List<Photo> photoList;
public boolean excludeFirstPhoto;
public List<SimpleCelebrity> celebrityList;
public List<ItemAwardItem> awardList;
public List<SimpleItemCollection> itemCollectionList;
public List<SimpleReview> reviewList;
public List<SimpleItemForumTopic> forumTopicList;
public List<CollectableItem> recommendationList;
public List<Doulist> relatedDoulistList;
public Data(Movie movie, Rating rating, List<Photo> photoList, boolean excludeFirstPhoto,
List<SimpleCelebrity> celebrityList, List<ItemAwardItem> awardList,
List<SimpleItemCollection> itemCollectionList, List<SimpleReview> reviewList,
List<SimpleItemForumTopic> forumTopicList,
List<CollectableItem> recommendationList, List<Doulist> relatedDoulistList) {
this.movie = movie;
this.rating = rating;
this.photoList = photoList;
this.excludeFirstPhoto = excludeFirstPhoto;
this.celebrityList = celebrityList;
this.awardList = awardList;
this.itemCollectionList = itemCollectionList;
this.reviewList = reviewList;
this.forumTopicList = forumTopicList;
this.recommendationList = recommendationList;
this.relatedDoulistList = relatedDoulistList;
}
}
static class HeaderHolder extends RecyclerView.ViewHolder {
@BindView(R.id.poster)
public RatioImageView posterImage;
@BindView(R.id.title)
public TextView titleText;
@BindView(R.id.original_title)
public TextView originalTitleText;
@BindView(R.id.detail)
public TextView detailText;
@BindView(R.id.genres)
public TextView genresText;
public HeaderHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/MovieDataAdapter.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 2,404 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.TextView;
import java.util.List;
import butterknife.BindView;
import butterknife.ButterKnife;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.gallery.ui.GalleryActivity;
import me.zhanghai.android.douya.media.PlayMusicService;
import me.zhanghai.android.douya.network.api.info.frodo.CollectableItem;
import me.zhanghai.android.douya.network.api.info.frodo.Doulist;
import me.zhanghai.android.douya.network.api.info.frodo.Music;
import me.zhanghai.android.douya.network.api.info.frodo.Rating;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleItemCollection;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleItemForumTopic;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleReview;
import me.zhanghai.android.douya.ui.AdapterLinearLayout;
import me.zhanghai.android.douya.ui.RatioImageView;
import me.zhanghai.android.douya.util.CollectionUtils;
import me.zhanghai.android.douya.util.ImageUtils;
import me.zhanghai.android.douya.util.ObjectUtils;
import me.zhanghai.android.douya.util.RecyclerViewUtils;
import me.zhanghai.android.douya.util.StringCompat;
import me.zhanghai.android.douya.util.StringUtils;
import me.zhanghai.android.douya.util.ViewUtils;
public class MusicDataAdapter extends BaseItemDataAdapter<Music> {
private enum Items {
HEADER,
ITEM_COLLECTION,
BADGE_LIST,
INTRODUCTION,
TRACK_LIST,
RATING,
ITEM_COLLECTION_LIST,
REVIEW_LIST,
FORUM_TOPIC_LIST,
RECOMMENDATION_LIST,
RELATED_DOULIST_LIST
}
private Data mData;
public MusicDataAdapter(Listener listener) {
super(listener);
}
@Override
protected Listener getListener() {
return (Listener) super.getListener();
}
public void setData(Data data) {
mData = data;
notifyDataChanged();
}
public void notifyItemCollectionChanged() {
int position = Items.ITEM_COLLECTION.ordinal();
if (position < getItemCount()) {
notifyItemChanged(position);
}
}
public void notifyItemCollectionListItemChanged(int position,
SimpleItemCollection newItemCollection) {
notifyItemCollectionListItemChanged(Items.ITEM_COLLECTION_LIST.ordinal(), position,
newItemCollection);
}
@Override
public int getTotalItemCount() {
return Items.values().length;
}
@Override
protected boolean isItemLoaded(int position) {
if (mData == null) {
return false;
}
if (mData.music == null) {
return false;
}
switch (Items.values()[position]) {
case HEADER:
return true;
case ITEM_COLLECTION:
return true;
case BADGE_LIST:
return mData.rating != null;
case INTRODUCTION:
return true;
case TRACK_LIST:
return true;
case RATING:
return mData.rating != null;
case ITEM_COLLECTION_LIST:
return mData.itemCollectionList != null;
case REVIEW_LIST:
return mData.reviewList != null;
case FORUM_TOPIC_LIST:
return mData.forumTopicList != null;
case RECOMMENDATION_LIST:
return mData.recommendationList != null;
case RELATED_DOULIST_LIST:
return mData.relatedDoulistList != null;
default:
throw new IllegalArgumentException();
}
}
@NonNull
@Override
public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
switch (Items.values()[viewType]) {
case HEADER:
return createHeaderHolder(parent);
case ITEM_COLLECTION:
return createItemCollectionHolder(parent);
case BADGE_LIST:
return createBadgeListHolder(parent);
case INTRODUCTION:
return createIntroductionHolder(parent);
case TRACK_LIST:
return createTrackListHolder(parent);
case RATING:
return createRatingHolder(parent);
case ITEM_COLLECTION_LIST:
return createItemCollectionListHolder(parent);
case REVIEW_LIST:
return createReviewListHolder(parent);
case FORUM_TOPIC_LIST:
return createForumTopicListHolder(parent);
case RECOMMENDATION_LIST:
return createRecommendationListHolder(parent);
case RELATED_DOULIST_LIST:
return createRelatedDoulistListHolder(parent);
default:
throw new IllegalArgumentException();
}
}
private HeaderHolder createHeaderHolder(ViewGroup parent) {
return new HeaderHolder(ViewUtils.inflate(R.layout.item_fragment_music_header, parent));
}
private TrackListHolder createTrackListHolder(ViewGroup parent) {
TrackListHolder holder = new TrackListHolder(ViewUtils.inflate(
R.layout.item_fragment_track_list, parent));
holder.trackList.setAdapter(new TrackListAdapter(getListener()));
return holder;
}
@Override
public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position,
@NonNull List<Object> payloads) {
super.onBindViewHolder(holder, position, payloads);
switch (Items.values()[position]) {
case HEADER:
bindHeaderHolder(holder, mData.music);
break;
case ITEM_COLLECTION:
bindItemCollectionHolder(holder, mData.music);
break;
case BADGE_LIST:
bindBadgeListHolder(holder, mData.music, mData.rating);
break;
case INTRODUCTION:
bindIntroductionHolder(holder, mData.music);
break;
case TRACK_LIST:
bindTrackListHolder(holder, mData.music, payloads);
break;
case RATING:
bindRatingHolder(holder, mData.music, mData.rating);
break;
case ITEM_COLLECTION_LIST:
bindItemCollectionListHolder(holder, mData.music, mData.itemCollectionList,
payloads);
break;
case REVIEW_LIST:
bindReviewListHolder(holder, mData.music, mData.reviewList);
break;
case FORUM_TOPIC_LIST:
bindForumTopicListHolder(holder, mData.music, mData.forumTopicList);
break;
case RECOMMENDATION_LIST:
bindRecommendationListHolder(holder, mData.music, mData.recommendationList);
break;
case RELATED_DOULIST_LIST:
bindRelatedDoulistListHolder(holder, mData.music, mData.relatedDoulistList);
break;
default:
throw new IllegalArgumentException();
}
}
private void bindHeaderHolder(RecyclerView.ViewHolder holder, Music music) {
HeaderHolder headerHolder = (HeaderHolder) holder;
boolean coverVisible = ViewUtils.isInLandscape(headerHolder.coverImage.getContext());
ViewUtils.setVisibleOrGone(headerHolder.coverImage, coverVisible);
if (coverVisible) {
headerHolder.coverImage.setRatio(1, 1);
ImageUtils.loadImage(headerHolder.coverImage, music.cover);
headerHolder.coverImage.setOnClickListener(view -> {
Context context = view.getContext();
context.startActivity(GalleryActivity.makeIntent(music.cover, context));
});
}
headerHolder.titleText.setText(music.title);
Context context = RecyclerViewUtils.getContext(holder);
String slashDelimiter = context.getString(R.string.item_information_delimiter_slash);
headerHolder.artistsText.setText(StringCompat.join(slashDelimiter, music.getArtistNames()));
String spaceDelimiter = context.getString(R.string.item_information_delimiter_space);
String detail = StringUtils.joinNonEmpty(spaceDelimiter, music.getYearMonth(context),
StringCompat.join(slashDelimiter, music.publishers));
headerHolder.detailText.setText(detail);
headerHolder.genresText.setText(StringCompat.join(slashDelimiter, music.genres));
}
private void bindBadgeListHolder(RecyclerView.ViewHolder holder, Music music, Rating rating) {
BadgeListHolder badgeListHolder = (BadgeListHolder) holder;
badgeListHolder.badgeListLayout.setTop250(null);
badgeListHolder.badgeListLayout.setRating(rating, music);
badgeListHolder.badgeListLayout.setGenre(R.drawable.music_badge_white_40dp,
CollectionUtils.firstOrNull(music.genres), CollectableItem.Type.MUSIC);
}
@Override
protected void bindIntroductionHolder(RecyclerView.ViewHolder holder, Music music) {
super.bindIntroductionHolder(holder, music);
IntroductionHolder introductionHolder = (IntroductionHolder) holder;
introductionHolder.introductionLayout.setOnClickListener(view -> {
Context context = view.getContext();
context.startActivity(ItemIntroductionActivity.makeIntent(music, context));
});
}
private void bindTrackListHolder(RecyclerView.ViewHolder holder, Music music,
@NonNull List<Object> payloads) {
if (payloads.isEmpty()) {
//noinspection deprecation
bindTrackListHolder(holder, music);
} else {
//noinspection deprecation
bindTrackListHolder(holder);
}
}
/**
* @deprecated Use {@link #onBindViewHolder(RecyclerView.ViewHolder, int, List)} instead.
*/
private void bindTrackListHolder(RecyclerView.ViewHolder holder, Music music) {
TrackListHolder trackListHolder = (TrackListHolder) holder;
boolean playable = music.vendorCount > 0;
ViewUtils.setVisibleOrGone(trackListHolder.playAllButton, playable);
if (playable) {
trackListHolder.playAllButton.setOnClickListener(view -> PlayMusicService.start(
music, view.getContext()));
}
ViewUtils.setVisibleOrGone(trackListHolder.trackList, !music.tracks.isEmpty());
TrackListAdapter adapter = (TrackListAdapter) trackListHolder.trackList.getAdapter();
adapter.setMusic(music);
}
/**
* @deprecated Use {@link #onBindViewHolder(RecyclerView.ViewHolder, int, List)} instead.
*/
private void bindTrackListHolder(RecyclerView.ViewHolder holder) {
TrackListHolder trackListHolder = (TrackListHolder) holder;
TrackListAdapter adapter = (TrackListAdapter) trackListHolder.trackList.getAdapter();
adapter.notifyItemRangeChanged(0, adapter.getItemCount());
}
public void notifyTrackListChanged() {
int position = Items.TRACK_LIST.ordinal();
if (position < getItemCount()) {
notifyItemChanged(position, ObjectUtils.EMPTY_OBJECT);
}
}
public interface Listener extends BaseItemDataAdapter.Listener<Music>,
TrackListAdapter.Listener {}
public static class Data {
public Music music;
public Rating rating;
public List<SimpleItemCollection> itemCollectionList;
public List<SimpleReview> reviewList;
public List<SimpleItemForumTopic> forumTopicList;
public List<CollectableItem> recommendationList;
public List<Doulist> relatedDoulistList;
public Data(Music music, Rating rating, List<SimpleItemCollection> itemCollectionList,
List<SimpleReview> reviewList, List<SimpleItemForumTopic> forumTopicList,
List<CollectableItem> recommendationList, List<Doulist> relatedDoulistList) {
this.music = music;
this.rating = rating;
this.itemCollectionList = itemCollectionList;
this.reviewList = reviewList;
this.forumTopicList = forumTopicList;
this.recommendationList = recommendationList;
this.relatedDoulistList = relatedDoulistList;
}
}
static class HeaderHolder extends RecyclerView.ViewHolder {
@BindView(R.id.cover)
public RatioImageView coverImage;
@BindView(R.id.title)
public TextView titleText;
@BindView(R.id.artists)
public TextView artistsText;
@BindView(R.id.detail)
public TextView detailText;
@BindView(R.id.genres)
public TextView genresText;
public HeaderHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
static class TrackListHolder extends RecyclerView.ViewHolder {
@BindView(R.id.play_all)
public Button playAllButton;
@BindView(R.id.track_list)
public AdapterLinearLayout trackList;
public TrackListHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/MusicDataAdapter.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 2,546 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import androidx.fragment.app.Fragment;
import androidx.appcompat.app.AppCompatActivity;
import me.zhanghai.android.douya.network.api.info.frodo.Book;
import me.zhanghai.android.douya.network.api.info.frodo.CollectableItem;
import me.zhanghai.android.douya.network.api.info.frodo.Game;
import me.zhanghai.android.douya.network.api.info.frodo.Movie;
import me.zhanghai.android.douya.network.api.info.frodo.Music;
import me.zhanghai.android.douya.util.FragmentUtils;
public class ItemIntroductionActivity extends AppCompatActivity {
private static final String KEY_PREFIX = ItemIntroductionActivity.class.getName() + '.';
private static final String EXTRA_ITEM = KEY_PREFIX + "item";
public static Intent makeIntent(CollectableItem item, Context context) {
return new Intent(context, ItemIntroductionActivity.class)
.putExtra(EXTRA_ITEM, item);
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Calls ensureSubDecor().
findViewById(android.R.id.content);
if (savedInstanceState == null) {
Intent intent = getIntent();
CollectableItem item = intent.getParcelableExtra(EXTRA_ITEM);
Fragment fragment;
switch (item.getType()) {
case APP:
// TODO
throw new UnsupportedOperationException();
case BOOK:
fragment = BookIntroductionFragment.newInstance((Book) item);
break;
case EVENT:
// TODO
throw new UnsupportedOperationException();
case GAME:
fragment = GameIntroductionFragment.newInstance((Game) item);
break;
case MOVIE:
case TV:
fragment = MovieIntroductionFragment.newInstance((Movie) item);
break;
case MUSIC:
fragment = MusicIntroductionFragment.newInstance((Music) item);
break;
default:
throw new IllegalArgumentException();
}
FragmentUtils.add(fragment, this, android.R.id.content);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/ItemIntroductionActivity.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 433 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import androidx.recyclerview.widget.RecyclerView;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import butterknife.BindView;
import butterknife.ButterKnife;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.link.UriHandler;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleCelebrity;
import me.zhanghai.android.douya.ui.RatioImageView;
import me.zhanghai.android.douya.ui.SimpleAdapter;
import me.zhanghai.android.douya.util.ImageUtils;
import me.zhanghai.android.douya.util.ViewUtils;
public class CelebrityListAdapter
extends SimpleAdapter<SimpleCelebrity, CelebrityListAdapter.ViewHolder> {
public CelebrityListAdapter() {
setHasStableIds(true);
}
@Override
public long getItemId(int position) {
return getItem(position).id;
}
@Override
public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
ViewHolder holder = new ViewHolder(ViewUtils.inflate(R.layout.item_celebrity_item, parent));
holder.avatarImage.setRatio(2, 3);
return holder;
}
@Override
public void onBindViewHolder(ViewHolder holder, int position) {
SimpleCelebrity celebrity = getItem(position);
ImageUtils.loadImage(holder.avatarImage, celebrity.avatar);
holder.nameText.setText(celebrity.name);
if (celebrity.isDirector) {
holder.descriptionText.setText(R.string.item_celebrity_director);
} else {
holder.descriptionText.setText(celebrity.character);
}
holder.itemView.setOnClickListener(view -> {
// TODO
UriHandler.open(celebrity.url, view.getContext());
});
}
static class ViewHolder extends RecyclerView.ViewHolder {
@BindView(R.id.avatar)
public RatioImageView avatarImage;
@BindView(R.id.name)
public TextView nameText;
@BindView(R.id.description)
public TextView descriptionText;
public ViewHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/CelebrityListAdapter.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 445 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import androidx.core.util.Pair;
import java.util.ArrayList;
import java.util.List;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.network.api.info.frodo.Book;
public class BookIntroductionFragment extends BaseItemIntroductionFragment<Book> {
public static BookIntroductionFragment newInstance(Book book) {
//noinspection deprecation
BookIntroductionFragment fragment = new BookIntroductionFragment();
fragment.setArguments(book);
return fragment;
}
/**
* @deprecated Use {@link #newInstance(Book)} instead.
*/
public BookIntroductionFragment() {}
@Override
protected List<Pair<String, String>> makeInformationData() {
List<Pair<String, String>> data = new ArrayList<>();
addTextListToData(R.string.item_introduction_book_authors, mItem.authors, data);
addTextListToData(R.string.item_introduction_book_presses, mItem.presses, data);
addTextListToData(R.string.item_introduction_book_subtitles, mItem.subtitles, data);
addTextListToData(R.string.item_introduction_book_translators, mItem.translators, data);
addTextListToData(R.string.item_introduction_book_release_dates, mItem.releaseDates, data);
addTextListToData(R.string.item_introduction_book_page_counts, mItem.pageCounts, data);
addTextListToData(R.string.item_introduction_book_prices, mItem.prices, data);
return data;
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/BookIntroductionFragment.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 333 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import android.annotation.TargetApi;
import android.content.Context;
import android.os.Build;
import androidx.annotation.Nullable;
import android.util.AttributeSet;
import android.widget.LinearLayout;
import android.widget.RatingBar;
import android.widget.TextView;
import butterknife.BindView;
import butterknife.ButterKnife;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleRating;
import me.zhanghai.android.douya.util.ViewUtils;
public class RatingLayout extends LinearLayout {
@BindView(R.id.rating_text)
TextView mRatingText;
@BindView(R.id.rating_bar)
RatingBar mRatingBar;
@BindView(R.id.rating_count)
TextView mRatingCountText;
public RatingLayout(Context context) {
super(context);
init();
}
public RatingLayout(Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
init();
}
public RatingLayout(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init();
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public RatingLayout(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
init();
}
private void init() {
ViewUtils.inflateInto(R.layout.item_rating_layout, this);
ButterKnife.bind(this);
}
public void setRating(SimpleRating rating) {
Context context = getContext();
mRatingText.setText(rating.getRatingString(context));
mRatingBar.setRating(rating.getRatingBarRating());
mRatingCountText.setText(rating.getRatingCountString(context));
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/RatingLayout.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 366 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageButton;
import android.widget.ImageView;
import android.widget.RatingBar;
import android.widget.TextView;
import butterknife.BindView;
import butterknife.ButterKnife;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.item.content.VoteItemCollectionManager;
import me.zhanghai.android.douya.network.api.info.frodo.CollectableItem;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleItemCollection;
import me.zhanghai.android.douya.profile.ui.ProfileActivity;
import me.zhanghai.android.douya.ui.SimpleAdapter;
import me.zhanghai.android.douya.util.ImageUtils;
import me.zhanghai.android.douya.util.TimeUtils;
import me.zhanghai.android.douya.util.ViewUtils;
public class ItemCollectionListAdapter
extends SimpleAdapter<SimpleItemCollection, ItemCollectionListAdapter.ViewHolder> {
private Listener mListener;
private CollectableItem.Type mItemType;
private long mItemId;
public ItemCollectionListAdapter(Listener listener) {
mListener = listener;
setHasStableIds(true);
}
public void setItem(CollectableItem item) {
mItemType = item.getType();
mItemId = item.id;
}
@Override
public long getItemId(int position) {
return getItem(position).id;
}
@NonNull
@Override
public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
return new ViewHolder(ViewUtils.inflate(R.layout.item_collection_item, parent));
}
@Override
public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
SimpleItemCollection itemCollection = getItem(position);
ImageUtils.loadAvatar(holder.avatarImage, itemCollection.user.avatar);
holder.avatarImage.setOnClickListener(view -> {
Context context = view.getContext();
context.startActivity(ProfileActivity.makeIntent(itemCollection.user, context));
});
holder.nameText.setText(itemCollection.user.name);
boolean hasRating = itemCollection.rating != null;
ViewUtils.setVisibleOrGone(holder.ratingBar, hasRating);
if (hasRating) {
holder.ratingBar.setRating(itemCollection.rating.getRatingBarRating());
}
holder.dateText.setText(TimeUtils.formatDate(TimeUtils.parseDoubanDateTime(
itemCollection.createTime), holder.dateText.getContext()));
String voteCount = itemCollection.voteCount > 0 ?
holder.voteCountText.getContext().getString(
R.string.item_collection_vote_count_format, itemCollection.voteCount)
: null;
holder.voteCountText.setText(voteCount);
holder.voteLayout.setActivated(itemCollection.isVoted);
holder.voteLayout.setEnabled(!VoteItemCollectionManager.getInstance().isWriting(
itemCollection.id));
holder.voteLayout.setOnClickListener(view -> VoteItemCollectionManager.getInstance().write(
mItemType, mItemId, itemCollection, view.getContext()));
holder.commentText.setText(itemCollection.comment);
holder.itemView.setOnLongClickListener(view -> {
mListener.copyText(itemCollection.comment);
return true;
});
}
public interface Listener {
void copyText(String text);
}
static class ViewHolder extends RecyclerView.ViewHolder {
@BindView(R.id.avatar)
public ImageView avatarImage;
@BindView(R.id.name)
public TextView nameText;
@BindView(R.id.rating)
public RatingBar ratingBar;
@BindView(R.id.date)
public TextView dateText;
@BindView(R.id.vote_layout)
public ViewGroup voteLayout;
@BindView(R.id.vote_count)
public TextView voteCountText;
@BindView(R.id.menu)
public ImageButton menuButton;
@BindView(R.id.comment)
public TextView commentText;
public ViewHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/ItemCollectionListAdapter.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 819 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import android.content.Context;
import android.graphics.Paint;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.LayerDrawable;
import android.graphics.drawable.ShapeDrawable;
import android.graphics.drawable.shapes.Shape;
import android.net.Uri;
import android.os.Build;
import androidx.annotation.RequiresApi;
import androidx.core.graphics.drawable.DrawableCompat;
import androidx.core.view.ViewCompat;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.view.ViewGroup;
import android.widget.HorizontalScrollView;
import android.widget.ImageView;
import android.widget.RatingBar;
import android.widget.TextView;
import butterknife.BindView;
import butterknife.ButterKnife;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.link.UriHandler;
import me.zhanghai.android.douya.network.api.info.frodo.CollectableItem;
import me.zhanghai.android.douya.network.api.info.frodo.Honor;
import me.zhanghai.android.douya.network.api.info.frodo.Rating;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleRating;
import me.zhanghai.android.douya.ui.CircleRectShape;
import me.zhanghai.android.douya.ui.PolygonShape;
import me.zhanghai.android.douya.ui.StarShape;
import me.zhanghai.android.douya.util.ViewUtils;
public class BadgeListLayout extends HorizontalScrollView {
@BindView(R.id.badge_list)
ViewGroup mBadgeListLayout;
@BindView(R.id.top_250_layout)
ViewGroup mTop250Layout;
@BindView(R.id.top_250_rank)
TextView mTop250RankText;
@BindView(R.id.top_250_badge)
TextView mTop250Badge;
@BindView(R.id.rating_layout)
ViewGroup mRatingLayout;
@BindView(R.id.rating_badge)
ViewGroup mRatingBadgeLayout;
@BindView(R.id.rating_text)
TextView mRatingText;
@BindView(R.id.rating_bar)
RatingBar mRatingBar;
@BindView(R.id.rating_count)
TextView mRatingCountText;
@BindView(R.id.rating_count_icon)
ImageView mRatingCountIconImage;
@BindView(R.id.followings_rating_layout)
ViewGroup mFollowingsRatingLayout;
@BindView(R.id.followings_rating_badge)
ViewGroup mFollowingsRatingBadgeLayout;
@BindView(R.id.followings_rating_text)
TextView mFollowingsRatingText;
@BindView(R.id.followings_rating_count_icon)
ImageView mFollowingsRatingCountIconImage;
@BindView(R.id.followings_rating_bar)
RatingBar mFollowingsRatingBar;
@BindView(R.id.followings_rating_count)
TextView mFollowingsRatingCountText;
@BindView(R.id.genre_layout)
ViewGroup mGenreLayout;
@BindView(R.id.genre_badge)
ImageView mGenreBadgeImage;
@BindView(R.id.genre_text)
TextView mGenreText;
@BindView(R.id.similar_items_layout)
ViewGroup mSimilarItemsLayout;
public BadgeListLayout(Context context) {
super(context);
init();
}
public BadgeListLayout(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
public BadgeListLayout(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init();
}
@RequiresApi(Build.VERSION_CODES.LOLLIPOP)
public BadgeListLayout(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
init();
}
private void init() {
setFillViewport(true);
// Scroll bar looks ugly here, and Google Play also hid it.
setHorizontalScrollBarEnabled(false);
ViewUtils.inflateInto(R.layout.item_badge_list_layout, this);
ButterKnife.bind(this);
ViewCompat.setBackground(mTop250Badge, new ShapeDrawable(new CircleRectShape()));
ViewCompat.setBackground(mRatingBadgeLayout, new RatingBadgeDrawable(
mRatingBadgeLayout.getContext()));
ViewCompat.setBackground(mFollowingsRatingBadgeLayout, new FollowingsRatingBadgeDrawable(
mFollowingsRatingBadgeLayout.getContext()));
mSimilarItemsLayout.setOnClickListener(view -> {
// TODO
});
}
@Override
protected void onFinishInflate() {
super.onFinishInflate();
// HorizontalScrollView's edge effect and scroll bar has an incorrect offset if padding is
// set.
getChildAt(0).setPadding(getPaddingLeft(), getPaddingTop(), getPaddingRight(),
getPaddingBottom());
setPadding(0, 0, 0, 0);
}
public void setTop250(Honor honor) {
boolean isTop250 = honor != null;
ViewUtils.setVisibleOrGone(mTop250Layout, isTop250);
if (!isTop250) {
return;
}
final Context context = getContext();
mTop250RankText.setText(context.getString(R.string.item_top_250_rank_format, honor.rank));
mTop250Layout.setOnClickListener(view -> {
//UriHandler.open(honor.uri, context);
// HACK
// TODO
UriHandler.open("path_to_url", context);
});
}
public void setRating(Rating rating, CollectableItem item) {
if (rating.hasRating()) {
setRating(rating.rating, mRatingText, mRatingBar, mRatingCountText,
mRatingCountIconImage);
} else {
setRatingUnavailable(rating.getRatingUnavailableReason(getContext()));
}
mRatingLayout.setOnClickListener(view -> {
// TODO
UriHandler.open(item.url + "collections", view.getContext());
});
boolean hasFollowingsRating = rating.followingsRating != null;
ViewUtils.setVisibleOrGone(mFollowingsRatingLayout, hasFollowingsRating);
if (hasFollowingsRating) {
setRating(rating.followingsRating, mFollowingsRatingText, mFollowingsRatingBar,
mFollowingsRatingCountText, mFollowingsRatingCountIconImage);
mFollowingsRatingLayout.setOnClickListener(view -> {
// TODO
UriHandler.open(item.url + "collections?show_followings=on", view.getContext());
});
}
}
private void setRating(SimpleRating rating, TextView ratingText, RatingBar ratingBar,
TextView ratingCountText, ImageView ratingCountIconImage) {
Context context = getContext();
ratingText.setText(rating.getRatingString(context));
float ratingBarRating = rating.getRatingBarRating();
ratingBar.setNumStars(Math.round(ratingBarRating));
ratingBar.setRating(ratingBarRating);
ratingCountText.setText(rating.getRatingCountString(context));
ViewUtils.setVisibleOrGone(ratingCountIconImage, true);
}
private void setRatingUnavailable(String ratingUnavailableReason) {
mRatingText.setText(R.string.item_rating_unavailable);
mRatingBar.setNumStars(5);
mRatingBar.setRating(mRatingBar.getNumStars());
mRatingCountText.setText(ratingUnavailableReason);
ViewUtils.setVisibleOrGone(mRatingCountIconImage, false);
}
public void setGenre(int genreBadgeResId, String genre, CollectableItem.Type itemType) {
boolean hasGenre = !TextUtils.isEmpty(genre);
ViewUtils.setVisibleOrGone(mGenreLayout, hasGenre);
if (hasGenre) {
mGenreBadgeImage.setImageResource(genreBadgeResId);
mGenreText.setText(genre);
mGenreLayout.setOnClickListener(view -> {
// TODO
String url = null;
switch (itemType) {
case MOVIE:
case TV:
url = "path_to_url#/?tags=" + Uri.encode(genre);
break;
case MUSIC:
url = "path_to_url" + Uri.encode(genre);
break;
}
if (!TextUtils.isEmpty(url)) {
UriHandler.open(url, view.getContext());
}
});
}
}
private static abstract class BaseRatingBadgeDrawable extends LayerDrawable {
private static final float STROKE_WIDTH_DP = 1.5f;
private static final float FILL_INSET_DP = 3.5f;
public BaseRatingBadgeDrawable(Shape shape, Context context) {
super(new Drawable[] {
DrawableCompat.wrap(new ShapeDrawable(shape)),
DrawableCompat.wrap(new ShapeDrawable(cloneShape(shape)))
});
// If the outer accent color stroke is not drawn by a stroke paint, it becomes too
// narrow.
Drawable strokeDrawable = getDrawable(0);
int colorAccent = ViewUtils.getColorFromAttrRes(R.attr.colorAccent, 0, context);
DrawableCompat.setTint(strokeDrawable, colorAccent);
// Not using ViewUtils.dpToPxOffset() because it causes truncation.
int strokeInset = ViewUtils.dpToPxSize(STROKE_WIDTH_DP / 2, context);
setLayerInset(0, strokeInset, strokeInset, strokeInset, strokeInset);
Paint strokePaint = ((ShapeDrawable) DrawableCompat.unwrap(strokeDrawable)).getPaint();
strokePaint.setStyle(Paint.Style.STROKE);
int strokeWidth = ViewUtils.dpToPxSize(STROKE_WIDTH_DP, context);
strokePaint.setStrokeWidth(strokeWidth);
Drawable fillDrawable = getDrawable(1);
DrawableCompat.setTint(fillDrawable, colorAccent);
// Not using ViewUtils.dpToPxOffset() for better visual effect.
int fillInset = ViewUtils.dpToPxSize(FILL_INSET_DP, context);
setLayerInset(1, fillInset, fillInset, fillInset, fillInset);
}
private static Shape cloneShape(Shape shape) {
try {
return shape.clone();
} catch (CloneNotSupportedException e) {
throw new IllegalArgumentException(e);
}
}
}
private static class RatingBadgeDrawable extends BaseRatingBadgeDrawable {
public RatingBadgeDrawable(Context context) {
super(new PolygonShape(8), context);
}
}
private static class FollowingsRatingBadgeDrawable extends BaseRatingBadgeDrawable {
public FollowingsRatingBadgeDrawable(Context context) {
super(new StarShape(10, 0.85f), context);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/BadgeListLayout.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 2,132 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import android.text.TextUtils;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import butterknife.BindView;
import butterknife.ButterKnife;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.media.PlayMusicService;
import me.zhanghai.android.douya.network.api.info.frodo.Music;
import me.zhanghai.android.douya.ui.SimpleAdapter;
import me.zhanghai.android.douya.util.TimeUtils;
import me.zhanghai.android.douya.util.ViewUtils;
import me.zhanghai.android.materialplaypausedrawable.MaterialPlayPauseDrawable;
import me.zhanghai.android.materialplaypausedrawable.MaterialPlayPauseView;
public class TrackListAdapter extends SimpleAdapter<Music.Track, TrackListAdapter.ViewHolder> {
private Listener mListener;
private Music mMusic;
public TrackListAdapter(Listener listener) {
mListener = listener;
setHasStableIds(true);
}
public void setMusic(Music music) {
mMusic = music;
replace(music.tracks);
}
@Override
public long getItemId(int position) {
return position;
}
@NonNull
@Override
public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
return new ViewHolder(ViewUtils.inflate(R.layout.item_track_item, parent));
}
@Override
public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
Music.Track track = getItem(position);
PlayMusicService service = PlayMusicService.getInstance();
boolean isTrackActive = service != null && service.getMusicId() == mMusic.id
&& service.getActiveTrackIndex() == position;
ViewUtils.setVisibleOrGone(holder.numberText, !isTrackActive);
if (!isTrackActive) {
holder.numberText.setText(String.valueOf(position + 1));
}
boolean isTrackPlaying = isTrackActive && service.isPlaying();
if (isTrackActive) {
holder.playPauseImage.setState(isTrackPlaying ? MaterialPlayPauseDrawable.State.Pause
: MaterialPlayPauseDrawable.State.Play);
}
ViewUtils.setVisibleOrGone(holder.playPauseImage, isTrackActive);
holder.titleText.setText(track.title);
holder.titleText.setTextColor(ViewUtils.getColorStateListFromAttrRes(isTrackActive ?
R.attr.colorControlActivated : android.R.attr.textColorPrimary,
holder.titleText.getContext()));
holder.durationText.setText(track.duration > 0 ? TimeUtils.formatDuration(track.duration,
holder.durationText.getContext()) : null);
holder.durationText.setTextColor(ViewUtils.getColorStateListFromAttrRes(isTrackActive ?
R.attr.colorControlActivated : android.R.attr.textColorSecondary,
holder.durationText.getContext()));
if (!TextUtils.isEmpty(track.previewUrl)) {
holder.itemView.setOnClickListener(view ->
PlayMusicService.start(mMusic, position, !isTrackPlaying, view.getContext()));
}
holder.itemView.setOnLongClickListener(view -> {
mListener.copyText(track.title);
return true;
});
}
public interface Listener {
void copyText(String text);
}
static class ViewHolder extends RecyclerView.ViewHolder {
@BindView(R.id.number)
public TextView numberText;
@BindView(R.id.play_pause)
public MaterialPlayPauseView playPauseImage;
@BindView(R.id.title)
public TextView titleText;
@BindView(R.id.duration)
public TextView durationText;
public ViewHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/TrackListAdapter.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 745 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import me.zhanghai.android.douya.network.api.info.frodo.Movie;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleMovie;
import me.zhanghai.android.douya.util.FragmentUtils;
public class MovieActivity extends AppCompatActivity {
private static final String KEY_PREFIX = MovieActivity.class.getName() + '.';
private static final String EXTRA_MOVIE_ID = KEY_PREFIX + "movie_id";
private static final String EXTRA_SIMPLE_MOVIE = KEY_PREFIX + "simple_movie";
private static final String EXTRA_MOVIE = KEY_PREFIX + "movie";
public static Intent makeIntent(long movieId, Context context) {
return new Intent(context, MovieActivity.class)
.putExtra(EXTRA_MOVIE_ID, movieId);
}
public static Intent makeIntent(SimpleMovie simpleMovie, Context context) {
return makeIntent(simpleMovie.id, context)
.putExtra(EXTRA_SIMPLE_MOVIE, simpleMovie);
}
public static Intent makeIntent(Movie movie, Context context) {
return makeIntent((SimpleMovie) movie, context)
.putExtra(EXTRA_MOVIE, movie);
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Calls ensureSubDecor().
findViewById(android.R.id.content);
if (savedInstanceState == null) {
Intent intent = getIntent();
long movieId = intent.getLongExtra(EXTRA_MOVIE_ID, -1);
SimpleMovie simpleMovie = intent.getParcelableExtra(EXTRA_SIMPLE_MOVIE);
Movie movie = intent.getParcelableExtra(EXTRA_MOVIE);
FragmentUtils.add(MovieFragment.newInstance(movieId, simpleMovie, movie), this,
android.R.id.content);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/MovieActivity.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 402 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import androidx.recyclerview.widget.RecyclerView;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import butterknife.BindView;
import butterknife.ButterKnife;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.link.UriHandler;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleItemForumTopic;
import me.zhanghai.android.douya.ui.SimpleAdapter;
import me.zhanghai.android.douya.ui.TimeTextView;
import me.zhanghai.android.douya.util.ImageUtils;
import me.zhanghai.android.douya.util.ViewUtils;
public class ItemForumTopicListAdapter
extends SimpleAdapter<SimpleItemForumTopic, ItemForumTopicListAdapter.ViewHolder> {
public ItemForumTopicListAdapter() {
setHasStableIds(true);
}
@Override
public long getItemId(int position) {
return getItem(position).id;
}
@Override
public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
return new ViewHolder(ViewUtils.inflate(R.layout.item_forum_topic_item, parent));
}
@Override
public void onBindViewHolder(ViewHolder holder, int position) {
SimpleItemForumTopic itemForumTopic = getItem(position);
ImageUtils.loadAvatar(holder.avatarImage, itemForumTopic.author.avatar);
holder.titleText.setText(itemForumTopic.title);
holder.nameText.setText(itemForumTopic.author.name);
holder.likeCountText.setText(holder.likeCountText.getContext().getString(
R.string.item_forum_topic_like_count_format, itemForumTopic.likeCount));
holder.commentCountText.setText(holder.commentCountText.getContext().getString(
R.string.item_forum_topic_comment_count_format, itemForumTopic.commentCount));
holder.updateTimeText.setDoubanTime(itemForumTopic.updateTime);
holder.itemView.setOnClickListener(view -> {
// TODO
UriHandler.open(itemForumTopic.url, view.getContext());
});
}
static class ViewHolder extends RecyclerView.ViewHolder {
@BindView(R.id.avatar)
public ImageView avatarImage;
@BindView(R.id.title)
public TextView titleText;
@BindView(R.id.name)
public TextView nameText;
@BindView(R.id.like_count)
public TextView likeCountText;
@BindView(R.id.comment_count)
public TextView commentCountText;
@BindView(R.id.update_time)
public TimeTextView updateTimeText;
public ViewHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/ItemForumTopicListAdapter.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 530 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import me.zhanghai.android.douya.network.api.info.frodo.Music;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleMusic;
import me.zhanghai.android.douya.util.FragmentUtils;
public class MusicActivity extends AppCompatActivity {
private static final String KEY_PREFIX = MusicActivity.class.getName() + '.';
private static final String EXTRA_MUSIC_ID = KEY_PREFIX + "music_id";
private static final String EXTRA_SIMPLE_MUSIC = KEY_PREFIX + "simple_music";
private static final String EXTRA_MUSIC = KEY_PREFIX + "music";
public static Intent makeIntent(long musicId, Context context) {
return new Intent(context, MusicActivity.class)
.putExtra(EXTRA_MUSIC_ID, musicId);
}
public static Intent makeIntent(SimpleMusic simpleMusic, Context context) {
return makeIntent(simpleMusic.id, context)
.putExtra(EXTRA_SIMPLE_MUSIC, simpleMusic);
}
public static Intent makeIntent(Music music, Context context) {
return makeIntent((SimpleMusic) music, context)
.putExtra(EXTRA_MUSIC, music);
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Calls ensureSubDecor().
findViewById(android.R.id.content);
if (savedInstanceState == null) {
Intent intent = getIntent();
long musicId = intent.getLongExtra(EXTRA_MUSIC_ID, -1);
SimpleMusic simpleMusic = intent.getParcelableExtra(EXTRA_SIMPLE_MUSIC);
Music music = intent.getParcelableExtra(EXTRA_MUSIC);
FragmentUtils.add(MusicFragment.newInstance(musicId, simpleMusic, music), this,
android.R.id.content);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/MusicActivity.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 404 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import android.os.Bundle;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.core.util.Pair;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import java.util.ArrayList;
import java.util.List;
import butterknife.BindView;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.network.api.info.frodo.Movie;
import me.zhanghai.android.douya.ui.AdapterLinearLayout;
import me.zhanghai.android.douya.util.ViewUtils;
public class MovieIntroductionFragment extends BaseItemIntroductionFragment<Movie> {
@BindView(R.id.cast_and_credits_wrapper)
ViewGroup mCastAndCreditsWrapperLayout;
@BindView(R.id.cast_and_credits)
AdapterLinearLayout mCastAndCreditsLayout;
public static MovieIntroductionFragment newInstance(Movie movie) {
//noinspection deprecation
MovieIntroductionFragment fragment = new MovieIntroductionFragment();
fragment.setArguments(movie);
return fragment;
}
/**
* @deprecated Use {@link #newInstance(Movie)} instead.
*/
public MovieIntroductionFragment() {}
@Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container,
@Nullable Bundle savedInstanceState) {
View view = super.onCreateView(inflater, container, savedInstanceState);
ViewGroup contentLayout = view.findViewById(R.id.content);
View castAndCreditsView = inflater.inflate(
R.layout.item_introduction_fragment_movie_cast_and_credits, contentLayout, false);
contentLayout.addView(castAndCreditsView, 1);
return view;
}
@Override
public void onActivityCreated(@Nullable Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
List<Pair<String, String>> castAndCreditsData = makeCastAndCreditsData();
boolean hasCastAndCreditsData = !castAndCreditsData.isEmpty();
ViewUtils.setVisibleOrGone(mCastAndCreditsWrapperLayout, hasCastAndCreditsData);
if (hasCastAndCreditsData) {
ItemIntroductionPairListAdapter castAndCreditsAdapter =
new ItemIntroductionPairListAdapter();
castAndCreditsAdapter.replace(castAndCreditsData);
mCastAndCreditsLayout.setAdapter(castAndCreditsAdapter);
}
}
@Override
protected List<Pair<String, String>> makeInformationData() {
List<Pair<String, String>> data = new ArrayList<>();
addTextToData(R.string.item_introduction_movie_original_title, mItem.originalTitle, data);
addTextListToData(R.string.item_introduction_movie_genres, mItem.genres, data);
addTextListToData(R.string.item_introduction_movie_countries, mItem.countries, data);
addTextListToData(R.string.item_introduction_movie_languages, mItem.languages, data);
addTextListToData(R.string.item_introduction_movie_release_dates, mItem.releaseDates, data);
addTextToData(R.string.item_introduction_movie_episode_count, mItem.getEpisodeCountString(),
data);
addTextListToData(R.string.item_introduction_movie_durations, mItem.durations, data);
addTextListToData(R.string.item_introduction_movie_alternative_titles,
mItem.alternativeTitles, data);
return data;
}
private List<Pair<String, String>> makeCastAndCreditsData() {
List<Pair<String, String>> data = new ArrayList<>();
addCelebrityListToData(R.string.item_introduction_movie_directors, mItem.directors, data);
addCelebrityListToData(R.string.item_introduction_movie_actors, mItem.actors, data);
return data;
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/MovieIntroductionFragment.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 767 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import java.util.List;
import butterknife.BindDimen;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.item.content.BaseItemFragmentResource;
import me.zhanghai.android.douya.item.content.BookFragmentResource;
import me.zhanghai.android.douya.item.content.ConfirmUncollectItemDialogFragment;
import me.zhanghai.android.douya.item.content.UncollectItemManager;
import me.zhanghai.android.douya.network.api.info.frodo.Book;
import me.zhanghai.android.douya.network.api.info.frodo.CollectableItem;
import me.zhanghai.android.douya.network.api.info.frodo.Doulist;
import me.zhanghai.android.douya.network.api.info.frodo.Rating;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleBook;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleItemCollection;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleItemForumTopic;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleReview;
import me.zhanghai.android.douya.ui.BarrierAdapter;
import me.zhanghai.android.douya.ui.CopyTextDialogFragment;
import me.zhanghai.android.douya.util.DoubanUtils;
import me.zhanghai.android.douya.util.ViewUtils;
public class BookFragment extends BaseItemFragment<SimpleBook, Book>
implements BookFragmentResource.Listener, BookDataAdapter.Listener,
ConfirmUncollectItemDialogFragment.Listener {
@BindDimen(R.dimen.toolbar_height)
int mContentPaddingTopExtra;
private BookAdapter mAdapter;
private boolean mBackdropBound;
public static BookFragment newInstance(long bookId, SimpleBook simpleBook, Book book) {
//noinspection deprecation
BookFragment fragment = new BookFragment();
fragment.setArguments(bookId, simpleBook, book);
return fragment;
}
/**
* @deprecated Use {@link #newInstance(long, SimpleBook, Book)} instead.
*/
public BookFragment() {}
@Override
protected BaseItemFragmentResource<SimpleBook, Book> onAttachResource(long itemId,
SimpleBook simpleItem,
Book item) {
return BookFragmentResource.attachTo(itemId, simpleItem, item, this);
}
@Override
protected float getBackdropRatio() {
return ViewUtils.isInPortait(getContext()) ? 0 : 2;
}
@Override
protected BarrierAdapter onCreateAdapter() {
mAdapter = new BookAdapter(this);
return mAdapter;
}
@Override
protected int getContentListPaddingTopExtra() {
return mContentPaddingTopExtra;
}
@Override
protected int getContentStateViewsPaddingTopExtra() {
return mContentPaddingTopExtra;
}
@Override
public void onChanged(int requestCode, Book newBook, Rating newRating,
List<SimpleItemCollection> newItemCollectionList,
List<SimpleReview> newReviewList,
List<SimpleItemForumTopic> newForumTopicList,
List<CollectableItem> newRecommendationList,
List<Doulist> newRelatedDoulistList) {
update(newBook, newRating, newItemCollectionList, newReviewList, newForumTopicList,
newRecommendationList, newRelatedDoulistList);
}
private void update(Book book, Rating rating, List<SimpleItemCollection> itemCollectionList,
List<SimpleReview> reviewList, List<SimpleItemForumTopic> forumTopicList,
List<CollectableItem> recommendationList,
List<Doulist> relatedDoulistList) {
if (book != null) {
super.updateWithSimpleItem(book);
}
if (book == null) {
return;
}
if (!mBackdropBound) {
if (!ViewUtils.isInPortait(getActivity())) {
mBackdropImage.setBackgroundColor(book.getThemeColor());
ViewUtils.fadeIn(mBackdropImage);
}
mBackdropBound = true;
}
mAdapter.setData(new BookDataAdapter.Data(book, rating, itemCollectionList, reviewList,
forumTopicList, recommendationList, relatedDoulistList));
if (mAdapter.getItemCount() > 0) {
mContentStateLayout.setLoaded(true);
}
}
@Override
protected String makeItemUrl(long itemId) {
return DoubanUtils.makeBookUrl(itemId);
}
@Override
public void onItemCollectionChanged(int requestCode) {
mAdapter.notifyItemCollectionChanged();
}
@Override
public void onItemCollectionListItemChanged(int requestCode, int position,
SimpleItemCollection newItemCollection) {
mAdapter.setItemCollectionListItem(position, newItemCollection);
}
@Override
public void onItemCollectionListItemWriteStarted(int requestCode, int position) {
mAdapter.notifyItemCollectionListItemChanged(position);
}
@Override
public void onItemCollectionListItemWriteFinished(int requestCode, int position) {
mAdapter.notifyItemCollectionListItemChanged(position);
}
@Override
public void onUncollectItem(Book book) {
ConfirmUncollectItemDialogFragment.show(this);
}
@Override
public void uncollect() {
if (!mResource.hasItem()) {
return;
}
Book book = mResource.getItem();
UncollectItemManager.getInstance().write(book.getType(), book.id, getActivity());
}
@Override
public void copyText(String text) {
CopyTextDialogFragment.show(text, this);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/BookFragment.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 1,185 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import android.content.Context;
import android.content.Intent;
import me.zhanghai.android.douya.network.api.info.frodo.Book;
import me.zhanghai.android.douya.network.api.info.frodo.CollectableItem;
import me.zhanghai.android.douya.network.api.info.frodo.Game;
import me.zhanghai.android.douya.network.api.info.frodo.Movie;
import me.zhanghai.android.douya.network.api.info.frodo.Music;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleBook;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleGame;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleMovie;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleMusic;
public class ItemActivities {
private ItemActivities() {}
public static Intent makeIntent(CollectableItem item, Context context) {
if (item instanceof Book) {
return BookActivity.makeIntent((Book) item, context);
} else if (item instanceof SimpleBook) {
return BookActivity.makeIntent((SimpleBook) item, context);
} else if (item instanceof Movie) {
return MovieActivity.makeIntent((Movie) item, context);
} else if (item instanceof SimpleMovie) {
return MovieActivity.makeIntent((SimpleMovie) item, context);
} else if (item instanceof Music) {
return MusicActivity.makeIntent((Music) item, context);
} else if (item instanceof SimpleMusic) {
return MusicActivity.makeIntent((SimpleMusic) item, context);
} else if (item instanceof Game) {
return GameActivity.makeIntent((Game) item, context);
} else if (item instanceof SimpleGame) {
return GameActivity.makeIntent((SimpleGame) item, context);
} else {
switch (item.getType()) {
case BOOK:
return BookActivity.makeIntent(item.id,context);
case GAME:
return GameActivity.makeIntent(item.id, context);
case MOVIE:
case TV:
return MovieActivity.makeIntent(item.id, context);
case MUSIC:
return MusicActivity.makeIntent(item.id, context);
default:
return null;
}
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/ItemActivities.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 498 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import android.os.Bundle;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.core.util.Pair;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import android.text.TextUtils;
import android.view.LayoutInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import java.util.ArrayList;
import java.util.List;
import butterknife.BindView;
import butterknife.ButterKnife;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.network.api.info.frodo.CollectableItem;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleCelebrity;
import me.zhanghai.android.douya.ui.AdapterGridLinearLayout;
import me.zhanghai.android.douya.util.CollectionUtils;
import me.zhanghai.android.douya.util.FragmentUtils;
import me.zhanghai.android.douya.util.StringCompat;
import me.zhanghai.android.douya.util.TintHelper;
import me.zhanghai.android.douya.util.ViewUtils;
public abstract class BaseItemIntroductionFragment<T extends CollectableItem> extends Fragment {
private static final String KEY_PREFIX = BaseItemIntroductionFragment.class.getName() + '.';
private static final String EXTRA_ITEM = KEY_PREFIX + "item";
@BindView(R.id.toolbar)
Toolbar mToolbar;
@BindView(R.id.introduction)
TextView mIntroductionText;
@BindView(R.id.information)
AdapterGridLinearLayout mInformationLayout;
protected T mItem;
protected void setArguments(T item) {
FragmentUtils.getArgumentsBuilder(this)
.putParcelable(EXTRA_ITEM, item);
}
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Bundle arguments = getArguments();
mItem = arguments.getParcelable(EXTRA_ITEM);
setHasOptionsMenu(true);
}
@Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container,
@Nullable Bundle savedInstanceState) {
return inflater.inflate(R.layout.item_introduction_fragment, container, false);
}
@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
ButterKnife.bind(this, view);
}
@Override
public void onActivityCreated(@Nullable Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
AppCompatActivity activity = (AppCompatActivity) getActivity();
activity.setSupportActionBar(mToolbar);
TintHelper.onSetSupportActionBar(mToolbar);
activity.setTitle(mItem.title);
mIntroductionText.setText(!TextUtils.isEmpty(mItem.introduction) ?
mItem.getPrettyIntroduction() : activity.getString(
R.string.item_introduction_empty));
List<Pair<String, String>> informationData = makeInformationData();
boolean hasInformationData = !informationData.isEmpty();
ViewUtils.setVisibleOrGone(mInformationLayout, hasInformationData);
if (hasInformationData) {
ItemIntroductionPairListAdapter informationAdapter =
new ItemIntroductionPairListAdapter();
informationAdapter.replace(informationData);
mInformationLayout.setColumnCount(2);
// HACK: Disabled for looking weird; anyway we always have the space from word break.
//mInformationLayout.setHorizontalDivider(R.drawable.transparent_divider_vertical_16dp);
mInformationLayout.setAdapter(informationAdapter);
}
}
protected abstract List<Pair<String, String>> makeInformationData();
protected void addTextToData(int titleRes, String text, List<Pair<String, String>> data) {
if (!TextUtils.isEmpty(text)) {
String title = getString(titleRes);
data.add(new Pair<>(title, text));
}
}
private void addTextListToData(int titleRes, List<String> textList, String delimiter,
List<Pair<String, String>> data) {
if (!CollectionUtils.isEmpty(textList)) {
String title = getString(titleRes);
String text = StringCompat.join(delimiter, textList);
data.add(new Pair<>(title, text));
}
}
protected void addTextListToData(int titleRes, List<String> textList,
List<Pair<String, String>> data) {
addTextListToData(titleRes, textList, getString(R.string.item_information_delimiter_slash),
data);
}
protected void addCelebrityListToData(int titleRes, List<SimpleCelebrity> celebrityList,
List<Pair<String, String>> data) {
if (!CollectionUtils.isEmpty(celebrityList)) {
List<String> celebrityNameList = new ArrayList<>();
for (SimpleCelebrity director : celebrityList) {
celebrityNameList.add(director.name);
}
addTextListToData(titleRes, celebrityNameList, getString(
R.string.item_introduction_celebrity_delimiter), data);
}
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case android.R.id.home:
getActivity().finish();
return true;
default:
return super.onOptionsItemSelected(item);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/BaseItemIntroductionFragment.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 1,065 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import androidx.recyclerview.widget.RecyclerView;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleItemCollection;
import me.zhanghai.android.douya.ui.BarrierAdapter;
public class BookAdapter extends BarrierAdapter {
private BookDataAdapter mDataAdapter;
public BookAdapter(BookDataAdapter.Listener listener) {
super(new BookDataAdapter(listener));
RecyclerView.Adapter<?>[] adapters = getAdapters();
mDataAdapter = (BookDataAdapter) adapters[0];
}
public void setData(BookDataAdapter.Data data) {
mDataAdapter.setData(data);
}
public void notifyItemCollectionChanged() {
mDataAdapter.notifyItemCollectionChanged();
}
public void setItemCollectionListItem(int position, SimpleItemCollection newItemCollection) {
mDataAdapter.notifyItemCollectionListItemChanged(position, newItemCollection);
}
public void notifyItemCollectionListItemChanged(int position) {
mDataAdapter.notifyItemCollectionListItemChanged(position, null);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/BookAdapter.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 212 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import android.content.Context;
import java.util.List;
import butterknife.BindDimen;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.gallery.ui.GalleryActivity;
import me.zhanghai.android.douya.item.content.BaseItemFragmentResource;
import me.zhanghai.android.douya.item.content.ConfirmUncollectItemDialogFragment;
import me.zhanghai.android.douya.item.content.MovieFragmentResource;
import me.zhanghai.android.douya.item.content.UncollectItemManager;
import me.zhanghai.android.douya.link.UriHandler;
import me.zhanghai.android.douya.network.api.info.frodo.CollectableItem;
import me.zhanghai.android.douya.network.api.info.frodo.Doulist;
import me.zhanghai.android.douya.network.api.info.frodo.ItemAwardItem;
import me.zhanghai.android.douya.network.api.info.frodo.Movie;
import me.zhanghai.android.douya.network.api.info.frodo.Photo;
import me.zhanghai.android.douya.network.api.info.frodo.Rating;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleCelebrity;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleItemCollection;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleItemForumTopic;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleMovie;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleReview;
import me.zhanghai.android.douya.ui.BarrierAdapter;
import me.zhanghai.android.douya.ui.CopyTextDialogFragment;
import me.zhanghai.android.douya.util.DoubanUtils;
import me.zhanghai.android.douya.util.ImageUtils;
import me.zhanghai.android.douya.util.ViewUtils;
public class MovieFragment extends BaseItemFragment<SimpleMovie, Movie>
implements MovieFragmentResource.Listener, MovieDataAdapter.Listener,
ConfirmUncollectItemDialogFragment.Listener {
@BindDimen(R.dimen.item_cover_vertical_margin_negative)
int mContentListPaddingTopExtra;
private MovieAdapter mAdapter;
private boolean mBackdropBound;
private boolean mExcludeFirstPhoto;
public static MovieFragment newInstance(long movieId, SimpleMovie simpleMovie, Movie movie) {
//noinspection deprecation
MovieFragment fragment = new MovieFragment();
fragment.setArguments(movieId, simpleMovie, movie);
return fragment;
}
/**
* @deprecated Use {@link #newInstance(long, SimpleMovie, Movie)} instead.
*/
public MovieFragment() {}
@Override
protected BaseItemFragmentResource<SimpleMovie, Movie> onAttachResource(long itemId,
SimpleMovie simpleItem,
Movie item) {
return MovieFragmentResource.attachTo(itemId, simpleItem, item, this);
}
@Override
protected BarrierAdapter onCreateAdapter() {
mAdapter = new MovieAdapter(this);
return mAdapter;
}
@Override
protected int getContentListPaddingTopExtra() {
return mContentListPaddingTopExtra;
}
@Override
public void onChanged(int requestCode, Movie newMovie, Rating newRating,
List<Photo> newPhotoList, List<SimpleCelebrity> newCelebrityList,
List<ItemAwardItem> newAwardList,
List<SimpleItemCollection> newItemCollectionList,
List<SimpleReview> newReviewList,
List<SimpleItemForumTopic> newForumTopicList,
List<CollectableItem> newRecommendationList,
List<Doulist> newRelatedDoulistList) {
update(newMovie, newRating, newPhotoList, newCelebrityList, newAwardList,
newItemCollectionList, newReviewList, newForumTopicList, newRecommendationList,
newRelatedDoulistList);
}
private void update(Movie movie, Rating rating, List<Photo> photoList,
List<SimpleCelebrity> celebrityList, List<ItemAwardItem> awardList,
List<SimpleItemCollection> itemCollectionList,
List<SimpleReview> reviewList, List<SimpleItemForumTopic> forumTopicList,
List<CollectableItem> recommendationList,
List<Doulist> relatedDoulistList) {
if (movie != null) {
super.updateWithSimpleItem(movie);
}
if (movie == null || photoList == null) {
return;
}
if (!mBackdropBound) {
boolean hasTrailer = movie.trailer != null;
mExcludeFirstPhoto = false;
String backdropUrl = null;
if (hasTrailer) {
backdropUrl = movie.trailer.coverUrl;
mBackdropLayout.setOnClickListener(view -> {
// TODO
UriHandler.open(movie.trailer.videoUrl, view.getContext());
});
} else if (!photoList.isEmpty()) {
backdropUrl = photoList.get(0).getLargeUrl();
mExcludeFirstPhoto = true;
mBackdropLayout.setOnClickListener(view -> {
// TODO
Context context = view.getContext();
context.startActivity(GalleryActivity.makeImageListIntent(photoList, 0, context));
});
} else if (movie.poster != null) {
backdropUrl = movie.poster.getLargeUrl();
mBackdropLayout.setOnClickListener(view -> {
// TODO
Context context = view.getContext();
context.startActivity(GalleryActivity.makeIntent(movie.poster, context));
});
} else if (movie.cover != null) {
backdropUrl = movie.cover.getLargeUrl();
mBackdropLayout.setOnClickListener(view -> {
// TODO
Context context = view.getContext();
context.startActivity(GalleryActivity.makeIntent(movie.cover, context));
});
}
if (backdropUrl != null) {
ImageUtils.loadItemBackdropAndFadeIn(mBackdropImage, backdropUrl,
hasTrailer ? mBackdropPlayImage : null);
} else {
mBackdropImage.setBackgroundColor(movie.getThemeColor());
ViewUtils.fadeIn(mBackdropImage);
}
mBackdropBound = true;
}
mAdapter.setData(new MovieDataAdapter.Data(movie, rating, photoList, mExcludeFirstPhoto,
celebrityList, awardList, itemCollectionList, reviewList, forumTopicList,
recommendationList, relatedDoulistList));
if (mAdapter.getItemCount() > 0) {
mContentStateLayout.setLoaded(true);
}
}
@Override
protected String makeItemUrl(long itemId) {
return DoubanUtils.makeMovieUrl(itemId);
}
@Override
public void onItemCollectionChanged(int requestCode) {
mAdapter.notifyItemCollectionChanged();
}
@Override
public void onItemCollectionListItemChanged(int requestCode, int position,
SimpleItemCollection newItemCollection) {
mAdapter.setItemCollectionListItem(position, newItemCollection);
}
@Override
public void onItemCollectionListItemWriteStarted(int requestCode, int position) {
mAdapter.notifyItemCollectionListItemChanged(position);
}
@Override
public void onItemCollectionListItemWriteFinished(int requestCode, int position) {
mAdapter.notifyItemCollectionListItemChanged(position);
}
@Override
public void onUncollectItem(Movie movie) {
ConfirmUncollectItemDialogFragment.show(this);
}
@Override
public void uncollect() {
if (!mResource.hasItem()) {
return;
}
Movie movie = mResource.getItem();
UncollectItemManager.getInstance().write(movie.getType(), movie.id, getActivity());
}
@Override
public void copyText(String text) {
CopyTextDialogFragment.show(text, this);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/MovieFragment.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 1,620 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import android.content.Context;
import androidx.annotation.NonNull;
import java.util.Arrays;
import java.util.List;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.functional.Functional;
import me.zhanghai.android.douya.network.api.info.frodo.CollectableItem;
import me.zhanghai.android.douya.network.api.info.frodo.ItemCollectionState;
import me.zhanghai.android.douya.ui.ArrayAdapterCompat;
public class ItemCollectionStateSpinnerAdapter extends ArrayAdapterCompat<String> {
private List<ItemCollectionState> mStates;
public ItemCollectionStateSpinnerAdapter(CollectableItem.Type type, @NonNull Context context) {
super(context, R.layout.simple_spinner_item, getStateNames(type, context));
mStates = getStates(type);
setDropDownViewResource(R.layout.simple_spinner_dropdown_item);
}
private static List<ItemCollectionState> getStates(CollectableItem.Type type) {
List<ItemCollectionState> states = Arrays.asList(ItemCollectionState.values());
if (!type.hasDoingState()) {
states = Functional.filter(states, state -> state != ItemCollectionState.DOING);
}
return states;
}
private static List<String> getStateNames(CollectableItem.Type type, Context context) {
return Functional.map(getStates(type), state -> state.getString(type, context));
}
public int getPositionForState(ItemCollectionState state) {
return mStates.indexOf(state);
}
public ItemCollectionState getStateAtPosition(int position) {
return mStates.get(position);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/ItemCollectionStateSpinnerAdapter.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 344 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.network.api.info.frodo.CollectableItem;
import me.zhanghai.android.douya.network.api.info.frodo.ItemCollectionState;
import me.zhanghai.android.douya.ui.FragmentFinishable;
import me.zhanghai.android.douya.util.AppUtils;
import me.zhanghai.android.douya.util.FragmentUtils;
import me.zhanghai.android.douya.util.ViewUtils;
public class ItemCollectionActivity extends AppCompatActivity implements FragmentFinishable {
private static final String KEY_PREFIX = ItemCollectionActivity.class.getName() + '.';
private static final String EXTRA_ITEM = KEY_PREFIX + "item";
private static final String EXTRA_STATE = KEY_PREFIX + "state";
private ItemCollectionFragment mFragment;
private boolean mShouldFinish;
public static Intent makeIntent(CollectableItem item, Context context) {
return new Intent(context, ItemCollectionActivity.class)
.putExtra(EXTRA_ITEM, item);
}
public static Intent makeIntent(CollectableItem item, ItemCollectionState state,
Context context) {
return makeIntent(item, context)
.putExtra(EXTRA_STATE, state);
}
@Override
protected void onCreate(Bundle savedInstanceState) {
Intent intent = getIntent();
CollectableItem item = intent.getParcelableExtra(EXTRA_ITEM);
int themeRes = 0;
switch (item.getType()) {
case APP:
break;
case BOOK:
themeRes = R.style.Theme_Douya_Book_DialogWhenLarge;
break;
case EVENT:
break;
case GAME:
break;
case MOVIE:
case TV:
themeRes = R.style.Theme_Douya_Movie_DialogWhenLarge;
break;
case MUSIC:
themeRes = R.style.Theme_Douya_Music_DialogWhenLarge;
break;
}
if (themeRes != 0) {
setTheme(themeRes);
// @see Activity#onApplyThemeResource(Resources.Theme, int, boolean)
int primaryColor = ViewUtils.getColorFromAttrRes(R.attr.colorPrimary, 0, this);
AppUtils.setTaskDescriptionPrimaryColor(this, primaryColor);
}
super.onCreate(savedInstanceState);
// Calls ensureSubDecor().
findViewById(android.R.id.content);
if (savedInstanceState == null) {
ItemCollectionState state = (ItemCollectionState) intent.getSerializableExtra(
EXTRA_STATE);
mFragment = ItemCollectionFragment.newInstance(item, state);
FragmentUtils.add(mFragment, this, android.R.id.content);
} else {
mFragment = FragmentUtils.findById(this, android.R.id.content);
}
}
@Override
public void finish() {
if (!mShouldFinish) {
mFragment.onFinish();
return;
}
super.finish();
}
@Override
public void finishAfterTransition() {
if (!mShouldFinish) {
mFragment.onFinish();
return;
}
super.finishAfterTransition();
}
@Override
public void finishFromFragment() {
mShouldFinish = true;
super.finish();
}
@Override
public void finishAfterTransitionFromFragment() {
mShouldFinish = true;
super.supportFinishAfterTransition();
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/ItemCollectionActivity.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 739 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import android.content.Context;
import androidx.annotation.CallSuper;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.appcompat.widget.PopupMenu;
import androidx.recyclerview.widget.RecyclerView;
import android.text.TextUtils;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.ImageButton;
import android.widget.RatingBar;
import android.widget.Space;
import android.widget.TextView;
import java.util.Arrays;
import java.util.List;
import butterknife.BindView;
import butterknife.ButterKnife;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.gallery.ui.GalleryActivity;
import me.zhanghai.android.douya.link.UriHandler;
import me.zhanghai.android.douya.network.api.info.frodo.CollectableItem;
import me.zhanghai.android.douya.network.api.info.frodo.Doulist;
import me.zhanghai.android.douya.network.api.info.frodo.ItemAwardItem;
import me.zhanghai.android.douya.network.api.info.frodo.ItemCollectionState;
import me.zhanghai.android.douya.network.api.info.frodo.Photo;
import me.zhanghai.android.douya.network.api.info.frodo.Rating;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleCelebrity;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleItemCollection;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleItemForumTopic;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleReview;
import me.zhanghai.android.douya.ui.AdapterLinearLayout;
import me.zhanghai.android.douya.ui.BarrierDataAdapter;
import me.zhanghai.android.douya.ui.DividerItemDecoration;
import me.zhanghai.android.douya.ui.HorizontalImageAdapter;
import me.zhanghai.android.douya.util.CollectionUtils;
import me.zhanghai.android.douya.util.RecyclerViewUtils;
import me.zhanghai.android.douya.util.TimeUtils;
import me.zhanghai.android.douya.util.ViewUtils;
public abstract class BaseItemDataAdapter<T extends CollectableItem>
extends BarrierDataAdapter<RecyclerView.ViewHolder> {
private static final int ITEM_COLLECTION_LIST_MAX_SIZE = 5;
private static final int ITEM_REVIEW_LIST_MAX_SIZE = 5;
private static final int ITEM_FORUM_TOPIC_LIST_MAX_SIZE = 5;
private static final int ITEM_RELATED_DOULIST_LIST_MAX_SIZE = 5;
private Listener<T> mListener;
public BaseItemDataAdapter(Listener<T> listener) {
mListener = listener;
}
protected Listener<T> getListener() {
return mListener;
}
protected ItemCollectionHolder createItemCollectionHolder(ViewGroup parent) {
ItemCollectionHolder holder = new ItemCollectionHolder(ViewUtils.inflate(
R.layout.item_fragment_collection, parent));
holder.menu = new PopupMenu(RecyclerViewUtils.getContext(holder), holder.menuButton);
holder.menu.inflate(R.menu.item_collection_actions);
holder.menuButton.setOnClickListener(view -> holder.menu.show());
holder.menuButton.setOnTouchListener(holder.menu.getDragToOpenListener());
return holder;
}
protected BadgeListHolder createBadgeListHolder(ViewGroup parent) {
return new BadgeListHolder(ViewUtils.inflate(R.layout.item_fragment_badge_list, parent));
}
protected IntroductionHolder createIntroductionHolder(ViewGroup parent) {
return new IntroductionHolder(ViewUtils.inflate(R.layout.item_fragment_introduction,
parent));
}
protected PhotoListHolder createPhotoListHolder(ViewGroup parent) {
PhotoListHolder holder = new PhotoListHolder(ViewUtils.inflate(
R.layout.item_fragment_photo_list, parent));
holder.photoList.setHasFixedSize(true);
holder.photoList.setLayoutManager(new LinearLayoutManager(parent.getContext(),
LinearLayoutManager.HORIZONTAL, false));
holder.photoList.addItemDecoration(new DividerItemDecoration(
DividerItemDecoration.HORIZONTAL, R.drawable.transparent_divider_vertical_4dp,
holder.photoList.getContext()));
holder.photoList.setAdapter(new HorizontalImageAdapter());
return holder;
}
protected CelebrityListHolder createCelebrityListHolder(ViewGroup parent) {
CelebrityListHolder holder = new CelebrityListHolder(ViewUtils.inflate(
R.layout.item_fragment_celebrity_list, parent));
holder.celebrityList.setHasFixedSize(true);
holder.celebrityList.setLayoutManager(new LinearLayoutManager(parent.getContext(),
LinearLayoutManager.HORIZONTAL, false));
holder.celebrityList.addItemDecoration(new DividerItemDecoration(
DividerItemDecoration.HORIZONTAL, R.drawable.transparent_divider_vertical_16dp,
holder.celebrityList.getContext()));
holder.celebrityList.setAdapter(new CelebrityListAdapter());
return holder;
}
protected AwardListHolder createAwardListHolder(ViewGroup parent) {
AwardListHolder holder = new AwardListHolder(ViewUtils.inflate(
R.layout.item_fragment_award_list, parent));
holder.awardList.setHasFixedSize(true);
holder.awardList.setLayoutManager(new LinearLayoutManager(parent.getContext(),
LinearLayoutManager.HORIZONTAL, false));
holder.awardList.addItemDecoration(new DividerItemDecoration(
DividerItemDecoration.HORIZONTAL, R.drawable.transparent_divider_vertical_16dp,
holder.awardList.getContext()));
holder.awardList.setAdapter(new ItemAwardListAdapter());
return holder;
}
protected RatingHolder createRatingHolder(ViewGroup parent) {
RatingHolder holder = new RatingHolder(ViewUtils.inflate(R.layout.item_fragment_rating,
parent));
holder.ratingDistributionLayout.setCompact(true);
return holder;
}
protected ItemCollectionListHolder createItemCollectionListHolder(ViewGroup parent) {
ItemCollectionListHolder holder = new ItemCollectionListHolder(ViewUtils.inflate(
R.layout.item_fragment_collection_list, parent));
holder.itemCollectionList.setAdapter(new ItemCollectionListAdapter(mListener));
return holder;
}
protected ReviewListHolder createReviewListHolder(ViewGroup parent) {
ReviewListHolder holder = new ReviewListHolder(ViewUtils.inflate(
R.layout.item_fragment_review_list, parent));
holder.reviewList.setAdapter(new ReviewListAdapter());
return holder;
}
protected ForumTopicListHolder createForumTopicListHolder(ViewGroup parent) {
ForumTopicListHolder holder = new ForumTopicListHolder(ViewUtils.inflate(
R.layout.item_fragment_forum_topic_list, parent));
holder.forumTopicList.setAdapter(new ItemForumTopicListAdapter());
return holder;
}
protected RecommendationListHolder createRecommendationListHolder(ViewGroup parent) {
RecommendationListHolder holder = new RecommendationListHolder(ViewUtils.inflate(
R.layout.item_fragment_recommendation_list, parent));
holder.recommendationList.setHasFixedSize(true);
holder.recommendationList.setLayoutManager(new LinearLayoutManager(
parent.getContext(), LinearLayoutManager.HORIZONTAL, false));
holder.recommendationList.addItemDecoration(new DividerItemDecoration(
DividerItemDecoration.HORIZONTAL, R.drawable.transparent_divider_vertical_16dp,
holder.recommendationList.getContext()));
holder.recommendationList.setAdapter(new RecommendationListAdapter());
return holder;
}
protected RelatedDoulistListHolder createRelatedDoulistListHolder(ViewGroup parent) {
RelatedDoulistListHolder holder = new RelatedDoulistListHolder(ViewUtils.inflate(
R.layout.item_fragment_related_doulist_list, parent));
holder.relatedDoulistList.setAdapter(new ItemRelatedDoulistListAdapter());
return holder;
}
/**
* @deprecated Use {@link #onBindViewHolder(RecyclerView.ViewHolder, int, List)} instead.
*/
@CallSuper
@Override
public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
throw new UnsupportedOperationException();
}
@CallSuper
@Override
public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position,
@NonNull List<Object> payloads) {
// HACK: Make sure we don't click through any view to our backdrop.
holder.itemView.setClickable(true);
}
protected void bindItemCollectionHolder(RecyclerView.ViewHolder holder, T item) {
ItemCollectionHolder itemCollectionHolder = (ItemCollectionHolder) holder;
CollectableItem.Type type = item.getType();
itemCollectionHolder.todoButton.setText(ItemCollectionState.TODO.getString(type,
itemCollectionHolder.todoButton.getContext()));
itemCollectionHolder.doingButton.setText(ItemCollectionState.DOING.getString(type,
itemCollectionHolder.doingButton.getContext()));
itemCollectionHolder.doneButton.setText(ItemCollectionState.DONE.getString(type,
itemCollectionHolder.doneButton.getContext()));
SimpleItemCollection itemCollection = item.collection;
ItemCollectionState state = itemCollection != null ? itemCollection.getState() : null;
boolean todoVisible = itemCollection == null;
ViewUtils.setVisibleOrGone(itemCollectionHolder.todoButton, todoVisible);
itemCollectionHolder.todoButton.setOnClickListener(view -> {
Context context = view.getContext();
context.startActivity(ItemCollectionActivity.makeIntent(item, ItemCollectionState.TODO,
context));
});
boolean doingVisible = item.getType().hasDoingState() && (itemCollection == null
|| state == ItemCollectionState.TODO);
ViewUtils.setVisibleOrGone(itemCollectionHolder.doingButton, doingVisible);
itemCollectionHolder.doingButton.setOnClickListener(view -> {
Context context = view.getContext();
context.startActivity(ItemCollectionActivity.makeIntent(item, ItemCollectionState.DOING,
context));
});
boolean doneVisible = itemCollection == null || state == ItemCollectionState.TODO
|| state == ItemCollectionState.DOING;
ViewUtils.setVisibleOrGone(itemCollectionHolder.doneButton, doneVisible);
itemCollectionHolder.doneButton.setOnClickListener(view -> {
Context context = view.getContext();
context.startActivity(ItemCollectionActivity.makeIntent(item, ItemCollectionState.DONE,
context));
});
boolean buttonBarVisible = todoVisible || doingVisible || doneVisible;
ViewUtils.setVisibleOrGone(itemCollectionHolder.buttonBar, buttonBarVisible);
ViewUtils.setVisibleOrGone(itemCollectionHolder.buttonBarSpace, !buttonBarVisible);
boolean hasItemCollection = itemCollection != null;
ViewUtils.setVisibleOrGone(itemCollectionHolder.itemCollectionLayout, hasItemCollection);
if (hasItemCollection) {
itemCollectionHolder.stateText.setText(state.getString(item.getType(),
itemCollectionHolder.stateText.getContext()));
boolean hasRating = itemCollection.rating != null;
ViewUtils.setVisibleOrGone(itemCollectionHolder.ratingBar, hasRating);
if (hasRating) {
itemCollectionHolder.ratingBar.setRating(
itemCollection.rating.getRatingBarRating());
}
itemCollectionHolder.dateText.setText(TimeUtils.formatDate(
TimeUtils.parseDoubanDateTime(itemCollection.createTime),
itemCollectionHolder.dateText.getContext()));
itemCollectionHolder.commentText.setText(itemCollection.comment);
itemCollectionHolder.itemCollectionLayout.setOnClickListener(view -> {
Context context = view.getContext();
context.startActivity(ItemCollectionActivity.makeIntent(item, context));
});
itemCollectionHolder.menu.setOnMenuItemClickListener(menuItem -> {
switch (menuItem.getItemId()) {
case R.id.action_edit: {
Context context = RecyclerViewUtils.getContext(holder);
context.startActivity(ItemCollectionActivity.makeIntent(item, context));
return true;
}
case R.id.action_uncollect:
mListener.onUncollectItem(item);
return true;
default:
return false;
}
});
}
ViewUtils.setVisibleOrGone(itemCollectionHolder.dividerView, !hasItemCollection);
}
protected void bindIntroductionHolder(RecyclerView.ViewHolder holder, T item) {
IntroductionHolder introductionHolder = (IntroductionHolder) holder;
introductionHolder.introductionText.setText(!TextUtils.isEmpty(item.introduction) ?
item.introduction : introductionHolder.introductionText.getContext().getString(
R.string.item_introduction_empty));
}
protected void bindPhotoListHolder(RecyclerView.ViewHolder holder, T item,
List<Photo> photoList, boolean excludeFirstPhoto) {
PhotoListHolder photoListHolder = (PhotoListHolder) holder;
List<Photo> originalPhotoList = photoList;
if (excludeFirstPhoto) {
photoList = photoList.subList(1, photoList.size());
}
ViewUtils.setVisibleOrGone(photoListHolder.photoList, !photoList.isEmpty());
HorizontalImageAdapter adapter = (HorizontalImageAdapter)
photoListHolder.photoList.getAdapter();
adapter.replace(photoList);
Context context = RecyclerViewUtils.getContext(holder);
adapter.setOnItemClickListener((parent, itemView, item_, photoPosition) -> {
if (excludeFirstPhoto) {
++photoPosition;
}
// TODO: Use PhotoAlbumGalleryActivity instead.
context.startActivity(GalleryActivity.makeImageListIntent(originalPhotoList,
photoPosition, context));
});
photoListHolder.viewMoreButton.setOnClickListener(view -> {
// TODO
UriHandler.open(item.url + "photos", context);
});
}
protected void bindCelebrityListHolder(RecyclerView.ViewHolder holder, T item,
List<SimpleCelebrity> celebrityList) {
CelebrityListHolder celebrityListHolder = (CelebrityListHolder) holder;
CelebrityListAdapter adapter = (CelebrityListAdapter)
celebrityListHolder.celebrityList.getAdapter();
adapter.replace(celebrityList);
}
protected void bindAwardListHolder(RecyclerView.ViewHolder holder, T item,
List<ItemAwardItem> awardList) {
AwardListHolder awardListHolder = (AwardListHolder) holder;
ViewUtils.setVisibleOrGone(awardListHolder.awardList, !awardList.isEmpty());
ItemAwardListAdapter adapter = (ItemAwardListAdapter)
awardListHolder.awardList.getAdapter();
adapter.replace(awardList);
awardListHolder.itemView.setOnClickListener(view -> {
// TODO
UriHandler.open(item.url + "awards/", view.getContext());
});
}
protected void bindRatingHolder(RecyclerView.ViewHolder holder, T item, Rating rating) {
RatingHolder ratingHolder = (RatingHolder) holder;
boolean hasRating = rating.hasRating();
ViewUtils.setVisibleOrGone(ratingHolder.ratingWrapperLayout, hasRating);
if (hasRating) {
ratingHolder.ratingLayout.setRating(rating.rating);
ratingHolder.ratingDistributionLayout.setRating(rating);
ratingHolder.itemView.setOnClickListener(view -> {
UriHandler.open(item.url + "collections", view.getContext());
});
}
}
protected void bindItemCollectionListHolder(RecyclerView.ViewHolder holder, T item,
List<SimpleItemCollection> itemCollectionList,
@NonNull List<Object> payloads) {
if (payloads.isEmpty()) {
bindItemCollectionListHolder(holder, item, itemCollectionList);
} else {
//noinspection unchecked
for (List<Object> payload : (List<List<Object>>) (Object) payloads) {
int position = (int) payload.get(0);
SimpleItemCollection newItemCollection = (SimpleItemCollection)
CollectionUtils.getOrNull(payload, 1);
bindItemCollectionListHolder(holder, position, newItemCollection);
}
}
}
private void bindItemCollectionListHolder(RecyclerView.ViewHolder holder, T item,
List<SimpleItemCollection> itemCollectionList) {
ItemCollectionListHolder itemCollectionListHolder = (ItemCollectionListHolder) holder;
itemCollectionListHolder.createButton.setOnClickListener(view -> {
Context context = view.getContext();
context.startActivity(ItemCollectionActivity.makeIntent(item, context));
});
itemCollectionList = itemCollectionList.subList(0, Math.min(ITEM_COLLECTION_LIST_MAX_SIZE,
itemCollectionList.size()));
ViewUtils.setVisibleOrGone(itemCollectionListHolder.itemCollectionList,
!itemCollectionList.isEmpty());
ItemCollectionListAdapter adapter = (ItemCollectionListAdapter)
itemCollectionListHolder.itemCollectionList.getAdapter();
adapter.setItem(item);
adapter.replace(itemCollectionList);
itemCollectionListHolder.viewMoreButton.setOnClickListener(view -> {
// TODO
UriHandler.open(item.url + "collections", view.getContext());
});
}
private void bindItemCollectionListHolder(RecyclerView.ViewHolder holder, int position,
SimpleItemCollection newItemCollection) {
ItemCollectionListHolder itemCollectionListHolder = (ItemCollectionListHolder) holder;
ItemCollectionListAdapter adapter = (ItemCollectionListAdapter)
itemCollectionListHolder.itemCollectionList.getAdapter();
if (newItemCollection != null) {
adapter.set(position, newItemCollection);
} else {
adapter.notifyItemChanged(position);
}
}
protected void notifyItemCollectionListItemChanged(int position, int itemCollectionPosition,
SimpleItemCollection newItemCollection) {
if (position < getItemCount()) {
notifyItemChanged(position, Arrays.asList(itemCollectionPosition, newItemCollection));
}
}
private void bindReviewListHolder(RecyclerView.ViewHolder holder, T item,
List<SimpleReview> reviewList,
View.OnClickListener onCreateListener,
View.OnClickListener onViewMoreListener) {
ReviewListHolder reviewListHolder = (ReviewListHolder) holder;
reviewListHolder.createButton.setOnClickListener(onCreateListener);
reviewList = reviewList.subList(0, Math.min(ITEM_REVIEW_LIST_MAX_SIZE, reviewList.size()));
ViewUtils.setVisibleOrGone(reviewListHolder.reviewList, !reviewList.isEmpty());
ReviewListAdapter adapter = (ReviewListAdapter)
reviewListHolder.reviewList.getAdapter();
adapter.replace(reviewList);
reviewListHolder.viewMoreButton.setOnClickListener(onViewMoreListener);
}
protected void bindReviewListHolder(RecyclerView.ViewHolder holder, T item,
List<SimpleReview> reviewList) {
bindReviewListHolder(holder, item, reviewList, view -> {
// TODO
UriHandler.open(item.url + "new_review", view.getContext());
}, view -> {
// TODO
UriHandler.open(item.url + "reviews", view.getContext());
});
}
protected void bindReviewListHolder(RecyclerView.ViewHolder holder, T item,
List<SimpleReview> reviewList, int titleRes, int createRes,
int viewMoreRes, View.OnClickListener onCreateListener,
View.OnClickListener onViewMoreListener) {
ReviewListHolder reviewListHolder = (ReviewListHolder) holder;
reviewListHolder.titleText.setText(titleRes);
reviewListHolder.createButton.setText(createRes);
reviewListHolder.viewMoreButton.setText(viewMoreRes);
bindReviewListHolder(holder, item, reviewList, onCreateListener, onViewMoreListener);
}
protected void bindForumTopicListHolder(RecyclerView.ViewHolder holder, T item,
List<SimpleItemForumTopic> forumTopicList) {
ForumTopicListHolder forumTopicListHolder = (ForumTopicListHolder) holder;
forumTopicListHolder.createButton.setOnClickListener(view -> {
// TODO
UriHandler.open(item.url + "discussion/create", view.getContext());
});
forumTopicList = forumTopicList.subList(0, Math.min(ITEM_FORUM_TOPIC_LIST_MAX_SIZE,
forumTopicList.size()));
ViewUtils.setVisibleOrGone(forumTopicListHolder.forumTopicList,
!forumTopicList.isEmpty());
ItemForumTopicListAdapter adapter = (ItemForumTopicListAdapter)
forumTopicListHolder.forumTopicList.getAdapter();
adapter.replace(forumTopicList);
forumTopicListHolder.viewMoreButton.setOnClickListener(view -> {
// TODO
UriHandler.open(item.url + "discussion", view.getContext());
});
}
protected void bindRecommendationListHolder(RecyclerView.ViewHolder holder, T item,
List<CollectableItem> recommendationList) {
RecommendationListHolder recommendationListHolder = (RecommendationListHolder) holder;
recommendationListHolder.titleLayout.setOnClickListener(view -> {
// TODO
});
RecommendationListAdapter adapter = (RecommendationListAdapter)
recommendationListHolder.recommendationList.getAdapter();
adapter.replace(recommendationList);
}
protected void bindRelatedDoulistListHolder(RecyclerView.ViewHolder holder, T item,
List<Doulist> relatedDoulistList) {
RelatedDoulistListHolder relatedDoulistListHolder =
(RelatedDoulistListHolder) holder;
relatedDoulistListHolder.titleLayout.setOnClickListener(view -> {
// TODO
UriHandler.open(item.url + "doulists", view.getContext());
});
ViewUtils.setVisibleOrGone(relatedDoulistListHolder.relatedDoulistList,
!relatedDoulistList.isEmpty());
ItemRelatedDoulistListAdapter adapter = (ItemRelatedDoulistListAdapter)
relatedDoulistListHolder.relatedDoulistList.getAdapter();
relatedDoulistList = relatedDoulistList.subList(0, Math.min(
ITEM_RELATED_DOULIST_LIST_MAX_SIZE, relatedDoulistList.size()));
adapter.replace(relatedDoulistList);
}
public interface Listener<T> extends ItemCollectionListAdapter.Listener {
void onUncollectItem(T item);
void copyText(String text);
}
protected static class ItemCollectionHolder extends RecyclerView.ViewHolder {
@BindView(R.id.button_bar)
public ViewGroup buttonBar;
@BindView(R.id.todo)
public Button todoButton;
@BindView(R.id.doing)
public Button doingButton;
@BindView(R.id.done)
public Button doneButton;
@BindView(R.id.button_bar_space)
public Space buttonBarSpace;
@BindView(R.id.item_collection_layout)
public ViewGroup itemCollectionLayout;
@BindView(R.id.state)
public TextView stateText;
@BindView(R.id.date)
public TextView dateText;
@BindView(R.id.rating)
public RatingBar ratingBar;
@BindView(R.id.comment)
public TextView commentText;
@BindView(R.id.menu)
public ImageButton menuButton;
@BindView(R.id.divider)
public View dividerView;
public PopupMenu menu;
public ItemCollectionHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
protected static class BadgeListHolder extends RecyclerView.ViewHolder {
@BindView(R.id.badge_list_layout)
public BadgeListLayout badgeListLayout;
public BadgeListHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
protected static class IntroductionHolder extends RecyclerView.ViewHolder {
@BindView(R.id.introduction_layout)
public ViewGroup introductionLayout;
@BindView(R.id.introduction)
public TextView introductionText;
public IntroductionHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
protected static class CelebrityListHolder extends RecyclerView.ViewHolder {
@BindView(R.id.celebrity_list)
public RecyclerView celebrityList;
public CelebrityListHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
protected static class PhotoListHolder extends RecyclerView.ViewHolder {
@BindView(R.id.photo_list)
public RecyclerView photoList;
@BindView(R.id.view_more)
public Button viewMoreButton;
public PhotoListHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
protected static class AwardListHolder extends RecyclerView.ViewHolder {
@BindView(R.id.award_list)
public RecyclerView awardList;
public AwardListHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
protected static class RatingHolder extends RecyclerView.ViewHolder {
@BindView(R.id.rating_wrapper)
public ViewGroup ratingWrapperLayout;
@BindView(R.id.rating_layout)
public RatingLayout ratingLayout;
@BindView(R.id.rating_distribution_layout)
public RatingDistributionLayout ratingDistributionLayout;
public RatingHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
protected static class ItemCollectionListHolder extends RecyclerView.ViewHolder {
@BindView(R.id.create)
public Button createButton;
@BindView(R.id.item_collection_list)
public AdapterLinearLayout itemCollectionList;
@BindView(R.id.view_more)
public Button viewMoreButton;
public ItemCollectionListHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
protected static class ReviewListHolder extends RecyclerView.ViewHolder {
@BindView(R.id.title)
public TextView titleText;
@BindView(R.id.create)
public Button createButton;
@BindView(R.id.review_list)
public AdapterLinearLayout reviewList;
@BindView(R.id.view_more)
public Button viewMoreButton;
public ReviewListHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
protected static class ForumTopicListHolder extends RecyclerView.ViewHolder {
@BindView(R.id.create)
public Button createButton;
@BindView(R.id.forum_topic_list)
public AdapterLinearLayout forumTopicList;
@BindView(R.id.view_more)
public Button viewMoreButton;
public ForumTopicListHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
protected static class RecommendationListHolder extends RecyclerView.ViewHolder {
@BindView(R.id.title_layout)
public ViewGroup titleLayout;
@BindView(R.id.recommendation_list)
public RecyclerView recommendationList;
public RecommendationListHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
protected static class RelatedDoulistListHolder extends RecyclerView.ViewHolder {
@BindView(R.id.title_layout)
public ViewGroup titleLayout;
@BindView(R.id.related_doulist_list)
public AdapterLinearLayout relatedDoulistList;
public RelatedDoulistListHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/BaseItemDataAdapter.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 5,226 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import android.content.Context;
import androidx.annotation.Nullable;
import androidx.recyclerview.widget.RecyclerView;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import butterknife.BindDimen;
import butterknife.ButterKnife;
import me.zhanghai.android.douya.R;
public class ItemContentRecyclerView extends RecyclerView {
@BindDimen(R.dimen.item_content_padding_top_max)
int mPaddingTopMax;
private float mBackdropRatio;
private int mPaddingTopPaddingExtra;
private View mBackdropWrapper;
public ItemContentRecyclerView(Context context) {
super(context);
init();
}
public ItemContentRecyclerView(Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
init();
}
public ItemContentRecyclerView(Context context, @Nullable AttributeSet attrs,
int defStyle) {
super(context, attrs, defStyle);
init();
}
private void init() {
ButterKnife.bind(this);
}
public float getBackdropRatio() {
return mBackdropRatio;
}
public void setBackdropRatio(float ratio) {
if (mBackdropRatio != ratio) {
mBackdropRatio = ratio;
requestLayout();
invalidate();
}
}
public void setBackdropRatio(float width, float height) {
setBackdropRatio(width / height);
}
public int getPaddingTopPaddingExtra() {
return mPaddingTopPaddingExtra;
}
public void setPaddingTopPaddingExtra(int paddingTopPaddingExtra) {
if (mPaddingTopPaddingExtra != paddingTopPaddingExtra) {
mPaddingTopPaddingExtra = paddingTopPaddingExtra;
requestLayout();
invalidate();
}
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int paddingTop = 0;
if (mBackdropRatio > 0) {
int width = MeasureSpec.getSize(widthMeasureSpec);
// Should fix off-by-one-pixel visual glitch.
paddingTop += (int) (width / mBackdropRatio);
}
paddingTop += mPaddingTopPaddingExtra;
if (mPaddingTopMax > 0) {
paddingTop = Math.min(paddingTop, mPaddingTopMax);
}
setPadding(getPaddingLeft(), paddingTop, getPaddingRight(), getPaddingBottom());
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}
public View getBackdropWrapper() {
return mBackdropWrapper;
}
public void setBackdropWrapper(View backdropWrapper) {
mBackdropWrapper = backdropWrapper;
}
@Override
public boolean onTouchEvent(MotionEvent event) {
boolean superResult = super.onTouchEvent(event);
if (mBackdropWrapper == null) {
return superResult;
}
if (getScrollState() != SCROLL_STATE_DRAGGING) {
mBackdropWrapper.dispatchTouchEvent(event);
} else {
int oldAction = event.getAction();
event.setAction(MotionEvent.ACTION_CANCEL | (oldAction & ~MotionEvent.ACTION_MASK));
mBackdropWrapper.dispatchTouchEvent(event);
event.setAction(oldAction);
}
return true;
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/ItemContentRecyclerView.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 652 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import androidx.recyclerview.widget.RecyclerView;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleItemCollection;
import me.zhanghai.android.douya.ui.BarrierAdapter;
public class MusicAdapter extends BarrierAdapter {
private MusicDataAdapter mDataAdapter;
public MusicAdapter(MusicDataAdapter.Listener listener) {
super(new MusicDataAdapter(listener));
RecyclerView.Adapter<?>[] adapters = getAdapters();
mDataAdapter = (MusicDataAdapter) adapters[0];
}
public void setData(MusicDataAdapter.Data data) {
mDataAdapter.setData(data);
}
public void notifyItemCollectionChanged() {
mDataAdapter.notifyItemCollectionChanged();
}
public void notifyTrackListChanged() {
mDataAdapter.notifyTrackListChanged();
}
public void setItemCollectionListItem(int position, SimpleItemCollection newItemCollection) {
mDataAdapter.notifyItemCollectionListItemChanged(position, newItemCollection);
}
public void notifyItemCollectionListItemChanged(int position) {
mDataAdapter.notifyItemCollectionListItemChanged(position, null);
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/MusicAdapter.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 233 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import android.content.Context;
import androidx.appcompat.content.res.AppCompatResources;
import android.util.AttributeSet;
import android.view.View;
import android.widget.TableLayout;
import android.widget.TextView;
import java.util.Collections;
import butterknife.BindView;
import butterknife.ButterKnife;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.network.api.info.frodo.Rating;
import me.zhanghai.android.douya.ui.PercentageWidthView;
import me.zhanghai.android.douya.util.ViewUtils;
public class RatingDistributionLayout extends TableLayout {
private static final int[] COLORS = new int[] {
0xFF57BB8A,
0xFF9ACE6A,
0xFFFFEB3B,
0xFFFFBB50,
0xFFFF8A65,
};
private RowHolder[] mRowHolders = new RowHolder[5];
public RatingDistributionLayout(Context context) {
super(context);
init();
}
public RatingDistributionLayout(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
private void init() {
setDividerDrawable(AppCompatResources.getDrawable(getContext(),
R.drawable.transparent_divider_horizontal_2dp));
setShowDividers(SHOW_DIVIDER_MIDDLE);
setColumnShrinkable(1, true);
setColumnStretchable(1, true);
for (int i = 0; i < mRowHolders.length; ++i) {
View rowView = ViewUtils.inflate(R.layout.item_rating_distribution_layout_row, this);
RowHolder rowHolder = new RowHolder(rowView);
rowHolder.mStarsText.setText(makeStars(mRowHolders.length - i));
rowHolder.mBarView.setBackgroundColor(COLORS[i]);
mRowHolders[i] = rowHolder;
addView(rowView);
}
}
private static String makeStars(int count) {
StringBuilder builder = new StringBuilder();
boolean first = true;
for (int i = 0; i < count; ++i) {
if (first) {
first = false;
} else {
builder.append(' ');
}
builder.append('');
}
return builder.toString();
}
public void setCompact(boolean compact) {
setShowDividers(compact ? SHOW_DIVIDER_NONE : SHOW_DIVIDER_MIDDLE);
setColumnCollapsed(0, compact);
for (RowHolder row : mRowHolders) {
row.mBarView.setMaxWidthEnabled(!compact);
ViewUtils.setVisibleOrGone(row.mCountText, !compact);
}
}
public void setRating(Rating rating) {
float maxPercentage = Collections.max(rating.distribution);
for (int i = 0; i < mRowHolders.length; ++i) {
RowHolder rowHolder = mRowHolders[i];
float percentage = rating.distribution.get(mRowHolders.length - 1 - i);
rowHolder.mBarView.setWidthPercentage(percentage / maxPercentage);
}
}
static class RowHolder {
@BindView(R.id.rating_distribution_stars)
public TextView mStarsText;
@BindView(R.id.rating_distribution_bar)
public PercentageWidthView mBarView;
@BindView(R.id.rating_distribution_count)
public TextView mCountText;
public RowHolder(View rowView) {
ButterKnife.bind(this, rowView);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/RatingDistributionLayout.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 728 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import me.zhanghai.android.douya.network.api.info.frodo.Book;
import me.zhanghai.android.douya.network.api.info.frodo.SimpleBook;
import me.zhanghai.android.douya.util.FragmentUtils;
public class BookActivity extends AppCompatActivity {
private static final String KEY_PREFIX = BookActivity.class.getName() + '.';
private static final String EXTRA_BOOK_ID = KEY_PREFIX + "book_id";
private static final String EXTRA_SIMPLE_BOOK = KEY_PREFIX + "simple_book";
private static final String EXTRA_BOOK = KEY_PREFIX + "book";
public static Intent makeIntent(long bookId, Context context) {
return new Intent(context, BookActivity.class)
.putExtra(EXTRA_BOOK_ID, bookId);
}
public static Intent makeIntent(SimpleBook simpleBook, Context context) {
return makeIntent(simpleBook.id, context)
.putExtra(EXTRA_SIMPLE_BOOK, simpleBook);
}
public static Intent makeIntent(Book book, Context context) {
return makeIntent((SimpleBook) book, context)
.putExtra(EXTRA_BOOK, book);
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Calls ensureSubDecor().
findViewById(android.R.id.content);
if (savedInstanceState == null) {
Intent intent = getIntent();
long bookId = intent.getLongExtra(EXTRA_BOOK_ID, -1);
SimpleBook simpleBook = intent.getParcelableExtra(EXTRA_SIMPLE_BOOK);
Book book = intent.getParcelableExtra(EXTRA_BOOK);
FragmentUtils.add(BookFragment.newInstance(bookId, simpleBook, book), this,
android.R.id.content);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/BookActivity.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 391 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import androidx.recyclerview.widget.RecyclerView;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import butterknife.BindView;
import butterknife.ButterKnife;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.link.UriHandler;
import me.zhanghai.android.douya.network.api.info.frodo.Doulist;
import me.zhanghai.android.douya.ui.SimpleAdapter;
import me.zhanghai.android.douya.util.ViewUtils;
public class ItemRelatedDoulistListAdapter
extends SimpleAdapter<Doulist, ItemRelatedDoulistListAdapter.ViewHolder> {
public ItemRelatedDoulistListAdapter() {
setHasStableIds(true);
}
@Override
public long getItemId(int position) {
return getItem(position).id;
}
@Override
public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
return new ViewHolder(ViewUtils.inflate(R.layout.item_related_doulist_item, parent));
}
@Override
public void onBindViewHolder(ViewHolder holder, int position) {
Doulist doulist = getItem(position);
holder.titleText.setText(doulist.title);
holder.followerCountText.setText(holder.followerCountText.getContext().getString(
R.string.item_related_doulist_follower_count_format, doulist.followerCount));
holder.itemView.setOnClickListener(view -> {
// TODO
UriHandler.open(doulist.url, view.getContext());
});
}
static class ViewHolder extends RecyclerView.ViewHolder {
@BindView(R.id.title)
public TextView titleText;
@BindView(R.id.follower_count)
public TextView followerCountText;
public ViewHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/ItemRelatedDoulistListAdapter.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 376 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import androidx.core.util.Pair;
import java.util.ArrayList;
import java.util.List;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.network.api.info.frodo.Music;
public class MusicIntroductionFragment extends BaseItemIntroductionFragment<Music> {
public static MusicIntroductionFragment newInstance(Music music) {
//noinspection deprecation
MusicIntroductionFragment fragment = new MusicIntroductionFragment();
fragment.setArguments(music);
return fragment;
}
/**
* @deprecated Use {@link #newInstance(Music)} instead.
*/
public MusicIntroductionFragment() {}
@Override
protected List<Pair<String, String>> makeInformationData() {
List<Pair<String, String>> data = new ArrayList<>();
addTextListToData(R.string.item_introduction_music_artists, mItem.getArtistNames(), data);
addTextListToData(R.string.item_introduction_music_genres, mItem.genres, data);
addTextListToData(R.string.item_introduction_music_types, mItem.types, data);
addTextListToData(R.string.item_introduction_music_media, mItem.media, data);
addTextListToData(R.string.item_introduction_music_release_dates, mItem.releaseDates, data);
addTextListToData(R.string.item_introduction_music_publishers, mItem.publishers, data);
addTextListToData(R.string.item_introduction_music_disc_counts, mItem.discCounts, data);
return data;
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/MusicIntroductionFragment.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 334 |
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.item.ui;
import androidx.annotation.NonNull;
import androidx.core.util.Pair;
import androidx.recyclerview.widget.RecyclerView;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import butterknife.BindView;
import butterknife.ButterKnife;
import me.zhanghai.android.douya.R;
import me.zhanghai.android.douya.ui.SimpleAdapter;
import me.zhanghai.android.douya.util.ViewUtils;
public class ItemIntroductionPairListAdapter
extends SimpleAdapter<Pair<String, String>, ItemIntroductionPairListAdapter.ViewHolder> {
@NonNull
@Override
public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
return new ViewHolder(ViewUtils.inflate(R.layout.item_introduction_pair_item, parent));
}
@Override
public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
Pair<String, String> roleNames = getItem(position);
holder.titleText.setText(roleNames.first);
holder.textText.setText(roleNames.second);
}
static class ViewHolder extends RecyclerView.ViewHolder {
@BindView(R.id.title)
public TextView titleText;
@BindView(R.id.text)
public TextView textText;
public ViewHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
}
}
``` | /content/code_sandbox/app/src/main/java/me/zhanghai/android/douya/item/ui/ItemIntroductionPairListAdapter.java | java | 2016-02-01T13:44:19 | 2024-08-15T05:23:34 | Douya | zhanghai/Douya | 4,549 | 268 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.