responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {
return value -> {
byte[] responseBytes = UTF8BOMFighter.removeUTF8BOM(value.bytes());
if (!TextUtils.isEmpty(encode)) {
try {
return new String((responseBytes), Charset.forName(encode));
} catch (Exception ignored) {
}
}
String charsetStr;
MediaType mediaType = value.contentType();
//根据http头判断
if (mediaType != null) {
Charset charset = mediaType.charset();
if (charset != null) {
return new String((responseBytes), charset);
}
}
//根据内容判断
charsetStr = EncodingDetect.getEncodeInHtml(responseBytes);
return new String(responseBytes, Charset.forName(charsetStr));
};
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/ExoPlayerHelper.kt
================================================
package com.kunfei.bookshelf.help
import android.net.Uri
import com.google.android.exoplayer2.C
import com.google.android.exoplayer2.MediaItem
import com.google.android.exoplayer2.ext.okhttp.OkHttpDataSource
import com.google.android.exoplayer2.source.MediaSource
import com.google.android.exoplayer2.source.ProgressiveMediaSource
import com.google.android.exoplayer2.source.dash.DashMediaSource
import com.google.android.exoplayer2.source.hls.HlsMediaSource
import com.google.android.exoplayer2.source.smoothstreaming.SsMediaSource
import com.google.android.exoplayer2.util.Util.inferContentType
import com.kunfei.bookshelf.base.BaseModelImpl
object ExoPlayerHelper {
fun createMediaSource(uri: Uri, overrideExtension: String?): MediaSource {
val mediaItem = MediaItem.fromUri(uri)
val dataSourceFactory = OkHttpDataSource.Factory(BaseModelImpl.getClient())
val mediaSourceFactory = when (inferContentType(uri, overrideExtension)) {
C.TYPE_SS -> SsMediaSource.Factory(dataSourceFactory)
C.TYPE_DASH -> DashMediaSource.Factory(dataSourceFactory)
C.TYPE_HLS -> HlsMediaSource.Factory(dataSourceFactory)
else -> ProgressiveMediaSource.Factory(dataSourceFactory)
}
return mediaSourceFactory.createMediaSource(mediaItem)
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/FileHelp.java
================================================
package com.kunfei.bookshelf.help;
import android.os.Environment;
import com.kunfei.bookshelf.MApplication;
import com.kunfei.bookshelf.utils.IOUtils;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
import io.reactivex.Single;
/**
* Created by newbiechen on 17-5-11.
*/
@SuppressWarnings("ALL")
public class FileHelp {
public static final byte BLANK = 0x0a;
//采用自己的格式去设置文件，防止文件被系统文件查询到
public static final String SUFFIX_NB = ".nb";
public static final String SUFFIX_TXT = ".txt";
public static final String SUFFIX_EPUB = ".epub";
public static final String SUFFIX_PDF = ".pdf";
//获取文件夹
public static File getFolder(String filePath) {
File file = new File(filePath);
//如果文件夹不存在，就创建它
if (!file.exists()) {
file.mkdirs();
}
return file;
}
//获取文件
public static synchronized File createFileIfNotExist(String filePath) {
File file = new File(filePath);
try {
if (!file.exists()) {
//创建父类文件夹
getFolder(file.getParent());
//创建文件
file.createNewFile();
}
} catch (IOException e) {
}
return file;
}
//获取Cache文件夹
public static String getFilesPath() {
if (isSdCardExist()) {
try {
return MApplication.getInstance()
.getExternalFilesDir(null)
.getAbsolutePath();
} catch (Exception ignored) {
}
}
return MApplication.getInstance()
.getFilesDir()
.getAbsolutePath();
}
//获取Cache文件夹
public static String getCachePath() {
if (isSdCardExist()) {
try {
return MApplication.getInstance()
.getExternalCacheDir()
.getAbsolutePath();
} catch (Exception ignored) {
}
}
return MApplication.getInstance()
.getCacheDir()
.getAbsolutePath();
}
public static long getDirSize(File file) {
//判断文件是否存在
if (file.exists()) {
//如果是目录则递归计算其内容的总大小
if (file.isDirectory()) {
File[] children = file.listFiles();
long size = 0;
for (File f : children)
size += getDirSize(f);
return size;
} else {
return file.length();
}
} else {
return 0;
}
}
public static String getFileSize(long size) {
if (size <= 0) return "0";
final String[] units = new String[]{"b", "kb", "M", "G", "T"};
//计算单位的，原理是利用lg,公式是 lg(1024^n) = nlg(1024)，最后 nlg(1024)/lg(1024) = n。
int digitGroups = (int) (Math.log10(size) / Math.log10(1024));
//计算原理是，size/单位值。单位值指的是:比如说b = 1024,KB = 1024^2
return new DecimalFormat("#,##0.##").format(size / Math.pow(1024, digitGroups)) + " " + units[digitGroups];
}
/**
* 本来是获取File的内容的。但是为了解决文本缩进、换行的问题
* 这个方法就是专门用来获取书籍的...
*
* 应该放在BookRepository中。。。
*
* @param file
* @return
*/
public static String getFileContent(File file) {
Reader reader = null;
String str = null;
StringBuilder sb = new StringBuilder();
try {
reader = new FileReader(file);
BufferedReader br = new BufferedReader(reader);
while ((str = br.readLine()) != null) {
//过滤空语句
if (!str.equals("")) {
//由于sb会自动过滤\n,所以需要加上去
sb.append(" " + str + "\n");
}
}
} catch (FileNotFoundException e) {
} catch (IOException e) {
} finally {
IOUtils.close(reader);
}
return sb.toString();
}
//判断是否挂载了SD卡
public static boolean isSdCardExist() {
if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
return true;
}
return false;
}
//递归删除文件夹下的数据
public static synchronized void deleteFile(String filePath) {
File file = new File(filePath);
if (!file.exists()) return;
if (file.isDirectory()) {
File[] files = file.listFiles();
for (File subFile : files) {
String path = subFile.getPath();
deleteFile(path);
}
}
//删除文件
file.delete();
}
//由于递归的耗时问题，取巧只遍历内部三层
//获取txt文件
public static List getTxtFiles(String filePath, int layer) {
List txtFiles = new ArrayList();
File file = new File(filePath);
//如果层级为 3，则直接返回
if (layer == 3) {
return txtFiles;
}
//获取文件夹
File[] dirs = file.listFiles(
pathname -> {
if (pathname.isDirectory() && !pathname.getName().startsWith(".")) {
return true;
}
//获取txt文件
else if (pathname.getName().endsWith(".txt")) {
txtFiles.add(pathname);
return false;
} else {
return false;
}
}
);
//遍历文件夹
for (File dir : dirs) {
//递归遍历txt文件
txtFiles.addAll(getTxtFiles(dir.getPath(), layer + 1));
}
return txtFiles;
}
//由于遍历比较耗时
public static Single> getSDTxtFile() {
//外部存储卡路径
String rootPath = Environment.getExternalStorageDirectory().getPath();
return Single.create(e -> {
List files = getTxtFiles(rootPath, 0);
e.onSuccess(files);
});
}
public static String getFileSuffix(String filePath) {
File file = new File(filePath);
return getFileSuffix(file);
}
public static String getFileSuffix(File file) {
if (file == null || !file.exists() || file.isDirectory()) {
return "";
}
String fileName = file.getName();
int dotIndex = fileName.lastIndexOf(".");
return dotIndex > 0 ? fileName.substring(dotIndex) : "";
}
public static void createFolderIfNotExists(String path) {
File folder = new File(path);
if (!folder.exists()) {
folder.mkdirs();
}
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/IntentData.kt
================================================
package com.kunfei.bookshelf.help
object IntentData {
private val bigData: MutableMap = mutableMapOf()
@Synchronized
fun put(key: String, data: Any?) {
data?.let {
bigData[key] = data
}
}
@Synchronized
fun put(data: Any?): String {
val key = System.currentTimeMillis().toString()
data?.let {
bigData[key] = data
}
return key
}
@Suppress("UNCHECKED_CAST")
@Synchronized
fun get(key: String?): T? {
if (key == null) return null
val data = bigData[key]
bigData.remove(key)
return data as? T
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/ItemTouchCallback.java
================================================
package com.kunfei.bookshelf.help;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.ItemTouchHelper;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
import androidx.viewpager.widget.ViewPager;
/**
* Created by GKF on 2018/3/16.
*/
public class ItemTouchCallback extends ItemTouchHelper.Callback {
private SwipeRefreshLayout swipeRefreshLayout;
private ViewPager viewPager;
public void setSwipeRefreshLayout(SwipeRefreshLayout swipeRefreshLayout) {
this.swipeRefreshLayout = swipeRefreshLayout;
}
public void setViewPager(ViewPager viewPager) {
this.viewPager = viewPager;
}
/**
* Item操作的回调
*/
private OnItemTouchCallbackListener onItemTouchCallbackListener;
/**
* 是否可以拖拽
*/
private boolean isCanDrag = false;
/**
* 是否可以被滑动
*/
private boolean isCanSwipe = false;
/**
* 设置Item操作的回调，去更新UI和数据源
*/
public void setOnItemTouchCallbackListener(OnItemTouchCallbackListener onItemTouchCallbackListener) {
this.onItemTouchCallbackListener = onItemTouchCallbackListener;
}
/**
* 设置是否可以被拖拽
*
* @param canDrag 是true，否false
*/
public void setDragEnable(boolean canDrag) {
isCanDrag = canDrag;
}
/**
* 设置是否可以被滑动
*
* @param canSwipe 是true，否false
*/
public void setSwipeEnable(boolean canSwipe) {
isCanSwipe = canSwipe;
}
/**
* 当Item被长按的时候是否可以被拖拽
*/
@Override
public boolean isLongPressDragEnabled() {
return isCanDrag;
}
/**
* Item是否可以被滑动(H：左右滑动，V：上下滑动)
*/
@Override
public boolean isItemViewSwipeEnabled() {
return isCanSwipe;
}
/**
* 当用户拖拽或者滑动Item的时候需要我们告诉系统滑动或者拖拽的方向
*/
@Override
public int getMovementFlags(@NonNull RecyclerView recyclerView, @NonNull RecyclerView.ViewHolder viewHolder) {
RecyclerView.LayoutManager layoutManager = recyclerView.getLayoutManager();
if (layoutManager instanceof GridLayoutManager) {// GridLayoutManager
// flag如果值是0，相当于这个功能被关闭
int dragFlag = ItemTouchHelper.LEFT | ItemTouchHelper.RIGHT | ItemTouchHelper.UP | ItemTouchHelper.DOWN;
int swipeFlag = 0;
// create make
return makeMovementFlags(dragFlag, swipeFlag);
} else if (layoutManager instanceof LinearLayoutManager) {// linearLayoutManager
LinearLayoutManager linearLayoutManager = (LinearLayoutManager) layoutManager;
int orientation = linearLayoutManager.getOrientation();
int dragFlag = 0;
int swipeFlag = 0;
// 为了方便理解，相当于分为横着的ListView和竖着的ListView
if (orientation == LinearLayoutManager.HORIZONTAL) {// 如果是横向的布局
swipeFlag = ItemTouchHelper.UP | ItemTouchHelper.DOWN;
dragFlag = ItemTouchHelper.LEFT | ItemTouchHelper.RIGHT;
} else if (orientation == LinearLayoutManager.VERTICAL) {// 如果是竖向的布局，相当于ListView
dragFlag = ItemTouchHelper.UP | ItemTouchHelper.DOWN;
swipeFlag = ItemTouchHelper.LEFT | ItemTouchHelper.RIGHT;
}
return makeMovementFlags(dragFlag, swipeFlag);
}
return 0;
}
/**
* 当Item被拖拽的时候被回调
*
* @param recyclerView recyclerView
* @param srcViewHolder 拖拽的ViewHolder
* @param targetViewHolder 目的地的viewHolder
*/
@Override
public boolean onMove(@NonNull RecyclerView recyclerView, @NonNull RecyclerView.ViewHolder srcViewHolder, @NonNull RecyclerView.ViewHolder targetViewHolder) {
if (onItemTouchCallbackListener != null) {
return onItemTouchCallbackListener.onMove(srcViewHolder.getAdapterPosition(), targetViewHolder.getAdapterPosition());
}
return false;
}
@Override
public void onSwiped(@NonNull RecyclerView.ViewHolder viewHolder, int direction) {
if (onItemTouchCallbackListener != null) {
onItemTouchCallbackListener.onSwiped(viewHolder.getAdapterPosition());
}
}
@Override
public void onSelectedChanged(@Nullable RecyclerView.ViewHolder viewHolder, int actionState) {
super.onSelectedChanged(viewHolder, actionState);
final boolean swiping = actionState == ItemTouchHelper.ACTION_STATE_DRAG;
if (swipeRefreshLayout != null) {
swipeRefreshLayout.setEnabled(!swiping);
}
if (viewPager != null) {
viewPager.requestDisallowInterceptTouchEvent(swiping);
}
}
public interface OnItemTouchCallbackListener {
/**
* 当某个Item被滑动删除的时候
*
* @param adapterPosition item的position
*/
void onSwiped(int adapterPosition);
/**
* 当两个Item位置互换的时候被回调
*
* @param srcPosition 拖拽的item的position
* @param targetPosition 目的地的Item的position
* @return 开发者处理了操作应该返回true，开发者没有处理就返回false
*/
boolean onMove(int srcPosition, int targetPosition);
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/JsExtensions.java
================================================
package com.kunfei.bookshelf.help;
import com.kunfei.bookshelf.DbHelper;
import com.kunfei.bookshelf.base.BaseModelImpl;
import com.kunfei.bookshelf.bean.CookieBean;
import com.kunfei.bookshelf.constant.AppConst;
import com.kunfei.bookshelf.model.analyzeRule.AnalyzeHeaders;
import com.kunfei.bookshelf.model.analyzeRule.AnalyzeUrl;
import com.kunfei.bookshelf.utils.MD5Utils;
import com.kunfei.bookshelf.utils.StringUtils;
import org.jsoup.Connection;
import org.jsoup.Jsoup;
import java.io.IOException;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import retrofit2.Response;
@SuppressWarnings({"unused", "WeakerAccess"})
public interface JsExtensions {
/**
* js实现跨域访问,不能删
*/
default String ajax(String urlStr) {
try {
AnalyzeUrl analyzeUrl = new AnalyzeUrl(urlStr, AnalyzeHeaders.getDefaultHeader());
Response response = BaseModelImpl.getInstance().getResponseO(analyzeUrl)
.blockingFirst();
return response.body();
} catch (Exception e) {
return e.getLocalizedMessage();
}
}
/**
* js实现跨域访问,不能删
*/
default Response getResponse(String urlStr) {
try {
AnalyzeUrl analyzeUrl = new AnalyzeUrl(urlStr, AnalyzeHeaders.getDefaultHeader());
return BaseModelImpl.getInstance().getResponseO(analyzeUrl)
.blockingFirst();
} catch (Exception e) {
return Response.success(e.getLocalizedMessage());
}
}
/**
* js实现解码,不能删
*/
default String base64Decoder(String base64) {
return StringUtils.base64Decode(base64);
}
/**
* 章节数转数字
*/
default String toNumChapter(String s) {
if (s == null) {
return null;
}
Pattern pattern = Pattern.compile("(第)(.+?)(章)");
Matcher matcher = pattern.matcher(s);
if (matcher.find()) {
return matcher.group(1) + StringUtils.stringToInt(matcher.group(2)) + matcher.group(3);
}
return s;
}
/**
* js实现重定向拦截,不能删
*/
default Connection.Response get(String urlStr, Map headers) throws IOException {
return Jsoup.connect(urlStr)
.sslSocketFactory(SSLSocketClient.getSSLSocketFactory())
.ignoreContentType(true)
.followRedirects(false)
.headers(headers)
.method(Connection.Method.GET)
.execute();
}
/**
* js实现重定向拦截,不能删
*/
default Connection.Response post(String urlStr, String body, Map headers) throws IOException {
return Jsoup.connect(urlStr)
.sslSocketFactory(SSLSocketClient.getSSLSocketFactory())
.ignoreContentType(true)
.followRedirects(false)
.requestBody(body)
.headers(headers)
.method(Connection.Method.POST)
.execute();
}
default void putCache(String key, String value) {
CookieBean cookie = new CookieBean(key, value);
DbHelper.getDaoSession().getCookieBeanDao().insertOrReplace(cookie);
}
default String getCache(String key) {
CookieBean cookie = DbHelper.getDaoSession().getCookieBeanDao().load(key);
if (cookie == null) {
return null;
}
return cookie.getCookie();
}
default String md5Encode(String text) {
return MD5Utils.strToMd5By32(text);
}
default String androidId() {
return AppConst.INSTANCE.getAndroidId();
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/LauncherIcon.java
================================================
package com.kunfei.bookshelf.help;
import android.content.ComponentName;
import android.content.pm.PackageManager;
import com.kunfei.bookshelf.MApplication;
import com.kunfei.bookshelf.R;
/**
* Created by GKF on 2018/2/27.
* 更换图标
*/
public class LauncherIcon {
private static PackageManager packageManager = MApplication.getInstance().getPackageManager();
private static ComponentName componentNameMain = new ComponentName(MApplication.getInstance(), "com.kunfei.bookshelf.view.activity.WelcomeActivity");
private static ComponentName componentNameBookMain = new ComponentName(MApplication.getInstance(), "com.kunfei.bookshelf.view.activity.WelcomeBookActivity");
public static void ChangeIcon(String icon) {
if (icon.equals(MApplication.getInstance().getString(R.string.icon_book))) {
if (packageManager.getComponentEnabledSetting(componentNameBookMain) != PackageManager.COMPONENT_ENABLED_STATE_ENABLED) {
//启用
packageManager.setComponentEnabledSetting(componentNameBookMain,
PackageManager.COMPONENT_ENABLED_STATE_ENABLED, PackageManager.DONT_KILL_APP);
//禁用
packageManager.setComponentEnabledSetting(componentNameMain,
PackageManager.COMPONENT_ENABLED_STATE_DISABLED, PackageManager.DONT_KILL_APP);
}
} else {
if (packageManager.getComponentEnabledSetting(componentNameMain) != PackageManager.COMPONENT_ENABLED_STATE_ENABLED) {
//启用
packageManager.setComponentEnabledSetting(componentNameMain,
PackageManager.COMPONENT_ENABLED_STATE_ENABLED, PackageManager.DONT_KILL_APP);
//禁用
packageManager.setComponentEnabledSetting(componentNameBookMain,
PackageManager.COMPONENT_ENABLED_STATE_DISABLED, PackageManager.DONT_KILL_APP);
}
}
}
public static String getInUseIcon() {
if (packageManager.getComponentEnabledSetting(componentNameBookMain) == PackageManager.COMPONENT_ENABLED_STATE_ENABLED) {
return MApplication.getInstance().getString(R.string.icon_book);
}
return MApplication.getInstance().getString(R.string.icon_main);
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/MediaManager.java
================================================
package com.kunfei.bookshelf.help;
import android.content.Context;
import android.media.AudioManager;
import android.media.MediaPlayer;
import com.kunfei.bookshelf.MApplication;
import com.kunfei.bookshelf.R;
/**
* Created by GKF on 2018/1/9.
* 播放音频
*/
public class MediaManager {
private static int VOLUME;
private AudioManager audioManager;
private int stream;
private final int FADE_DURATION = 1000;
private final int FADE_INTERVAL = 100;
private boolean isFading = false;
private boolean cancelFading = false;
public static MediaManager instance;
private MediaManager() {
audioManager = (AudioManager) MApplication.getInstance().getSystemService(Context.AUDIO_SERVICE);
}
public void setStream(int stream) {
this.stream = stream;
getSysVolume();
}
public static synchronized MediaManager getInstance() {
if (instance == null)
instance = new MediaManager();
return instance;
}
public void fadeInVolume() {
if (!isFading) {
getSysVolume();
} else {
cancelFading = true;
}
while (isFading) try {
Thread.sleep(10);
} catch (Exception ignored) {
}
cancelFading = false;
startAudioFade(1, VOLUME);
setSysVolume(VOLUME);
}
public void fadeOutVolume() {
if (!isFading) {
getSysVolume();
} else {
cancelFading = true;
}
while (isFading) try {
Thread.sleep(FADE_INTERVAL);
} catch (Exception ignored) {
}
cancelFading = false;
startAudioFade(VOLUME, 1);
setSysVolume(VOLUME);
}
private void getSysVolume() {
VOLUME = audioManager.getStreamVolume(stream);
}
private void setSysVolume(float vol) {
audioManager.setStreamVolume(stream, (int) vol, AudioManager.FLAG_REMOVE_SOUND_AND_VIBRATE);
}
private void startAudioFade(float from, float to) {
isFading = true;
cancelFading = false;
int numberOfSteps = FADE_DURATION / FADE_INTERVAL;
float deltaVolume = (to - from) / numberOfSteps;
for (float vol = from; (vol - to) * (vol - from) <= 0 && !cancelFading; vol += deltaVolume) {
setSysVolume(vol);
try {
Thread.sleep(FADE_INTERVAL);
} catch (Exception ignored) {
}
}
isFading = false;
cancelFading = false;
}
public static void playSilentSound(Context mContext) {
try {
// Stupid Android 8 "Oreo" hack to make media buttons work
MediaPlayer mMediaPlayer = MediaPlayer.create(mContext, R.raw.silent_sound);
mMediaPlayer.setOnCompletionListener(MediaPlayer::release);
mMediaPlayer.start();
} catch (Exception ignored) {
}
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/ProcessTextHelp.java
================================================
package com.kunfei.bookshelf.help;
import android.content.ComponentName;
import android.content.pm.PackageManager;
import com.kunfei.bookshelf.MApplication;
public class ProcessTextHelp {
private static PackageManager packageManager = MApplication.getInstance().getPackageManager();
private static ComponentName componentName = new ComponentName(MApplication.getInstance(), "com.kunfei.bookshelf.view.activity.ReceivingSharedActivity");
public static boolean isProcessTextEnabled() {
return packageManager.getComponentEnabledSetting(componentName) != PackageManager.COMPONENT_ENABLED_STATE_DISABLED;
}
public static void setProcessTextEnable(boolean enable) {
if (enable) {
packageManager.setComponentEnabledSetting(componentName,
PackageManager.COMPONENT_ENABLED_STATE_ENABLED, PackageManager.DONT_KILL_APP);
} else {
packageManager.setComponentEnabledSetting(componentName,
PackageManager.COMPONENT_ENABLED_STATE_DISABLED, PackageManager.DONT_KILL_APP);
}
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/ReadBookControl.java
================================================
//Copyright (c) 2017. 章钦豪. All rights reserved.
package com.kunfei.bookshelf.help;
import android.content.ContentResolver;
import android.content.Context;
import android.content.SharedPreferences;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.Color;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.ColorDrawable;
import android.graphics.drawable.Drawable;
import android.provider.Settings;
import android.util.DisplayMetrics;
import com.kunfei.bookshelf.MApplication;
import com.kunfei.bookshelf.utils.BitmapUtil;
import com.kunfei.bookshelf.utils.MeUtils;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static com.kunfei.bookshelf.widget.page.PageLoader.DEFAULT_MARGIN_WIDTH;
public class ReadBookControl {
private static final int DEFAULT_BG = 1;
private int textDrawableIndex = DEFAULT_BG;
private List> textDrawable;
private Bitmap bgBitmap;
private int screenDirection;
private int speechRate;
private boolean speechRateFollowSys;
private int textSize;
private int textColor;
private boolean bgIsColor;
private int bgColor;
private float lineMultiplier;
private float paragraphSize;
private int pageMode;
private Boolean lightNovelParagraph;
private Boolean hideStatusBar;
private Boolean hideNavigationBar;
private String fontPath;
private int textConvert;
private int navBarColor;
private Boolean textBold;
private Boolean canClickTurn;
private Boolean canKeyTurn;
private Boolean readAloudCanKeyTurn;
private int CPM;
private Boolean clickAllNext;
private Boolean showTitle;
private Boolean showTimeBattery;
private Boolean showLine;
private Boolean darkStatusIcon;
private int indent;
private int screenTimeOut;
private int paddingLeft;
private int paddingTop;
private int paddingRight;
private int paddingBottom;
private int tipPaddingLeft;
private int tipPaddingTop;
private int tipPaddingRight;
private int tipPaddingBottom;
private float textLetterSpacing;
private boolean canSelectText;
public int minCPM = 200;
public int maxCPM = 2000;
private int defaultCPM = 500;
private SharedPreferences preferences;
private static ReadBookControl readBookControl;
public static ReadBookControl getInstance() {
if (readBookControl == null) {
synchronized (ReadBookControl.class) {
if (readBookControl == null) {
readBookControl = new ReadBookControl();
}
}
}
return readBookControl;
}
private ReadBookControl() {
preferences = MApplication.getConfigPreferences();
initTextDrawable();
updateReaderSettings();
}
public void updateReaderSettings() {
this.lightNovelParagraph = preferences.getBoolean("light_novel_paragraph", false);
this.hideStatusBar = preferences.getBoolean("hide_status_bar", false);
this.hideNavigationBar = preferences.getBoolean("hide_navigation_bar", false);
this.indent = preferences.getInt("indent", 2);
this.textSize = preferences.getInt("textSize", 20);
this.canClickTurn = preferences.getBoolean("canClickTurn", true);
this.canKeyTurn = preferences.getBoolean("canKeyTurn", true);
this.readAloudCanKeyTurn = preferences.getBoolean("readAloudCanKeyTurn", false);
this.lineMultiplier = preferences.getFloat("lineMultiplier", 1);
this.paragraphSize = preferences.getFloat("paragraphSize", 1);
this.CPM = preferences.getInt("CPM", defaultCPM) > maxCPM
? minCPM : preferences.getInt("CPM", defaultCPM);
this.clickAllNext = preferences.getBoolean("clickAllNext", false);
this.fontPath = preferences.getString("fontPath", null);
this.textConvert = preferences.getInt("textConvertInt", 0);
this.textBold = preferences.getBoolean("textBold", false);
this.speechRate = preferences.getInt("speechRate", 10);
this.speechRateFollowSys = preferences.getBoolean("speechRateFollowSys", true);
this.showTitle = preferences.getBoolean("showTitle", true);
this.showTimeBattery = preferences.getBoolean("showTimeBattery", true);
this.showLine = preferences.getBoolean("showLine", true);
this.screenTimeOut = preferences.getInt("screenTimeOut", 0);
this.paddingLeft = preferences.getInt("paddingLeft", DEFAULT_MARGIN_WIDTH);
this.paddingTop = preferences.getInt("paddingTop", 0);
this.paddingRight = preferences.getInt("paddingRight", DEFAULT_MARGIN_WIDTH);
this.paddingBottom = preferences.getInt("paddingBottom", 0);
this.tipPaddingLeft = preferences.getInt("tipPaddingLeft", DEFAULT_MARGIN_WIDTH);
this.tipPaddingTop = preferences.getInt("tipPaddingTop", 0);
this.tipPaddingRight = preferences.getInt("tipPaddingRight", DEFAULT_MARGIN_WIDTH);
this.tipPaddingBottom = preferences.getInt("tipPaddingBottom", 0);
this.pageMode = preferences.getInt("pageMode", 0);
this.screenDirection = preferences.getInt("screenDirection", 0);
this.navBarColor = preferences.getInt("navBarColorInt", 0);
this.textLetterSpacing = preferences.getFloat("textLetterSpacing", 0);
this.canSelectText = preferences.getBoolean("canSelectText", false);
initTextDrawableIndex();
}
//阅读背景
private void initTextDrawable() {
if (null == textDrawable) {
textDrawable = new ArrayList<>();
Map temp1 = new HashMap<>();
temp1.put("textColor", Color.parseColor("#3E3D3B"));
temp1.put("bgIsColor", 1);
temp1.put("textBackground", Color.parseColor("#F3F3F3"));
temp1.put("darkStatusIcon", 1);
textDrawable.add(temp1);
Map temp2 = new HashMap<>();
temp2.put("textColor", Color.parseColor("#5E432E"));
temp2.put("bgIsColor", 1);
temp2.put("textBackground", Color.parseColor("#C6BAA1"));
temp2.put("darkStatusIcon", 1);
textDrawable.add(temp2);
Map temp3 = new HashMap<>();
temp3.put("textColor", Color.parseColor("#22482C"));
temp3.put("bgIsColor", 1);
temp3.put("textBackground", Color.parseColor("#E1F1DA"));
temp3.put("darkStatusIcon", 1);
textDrawable.add(temp3);
Map temp4 = new HashMap<>();
temp4.put("textColor", Color.parseColor("#FFFFFF"));
temp4.put("bgIsColor", 1);
temp4.put("textBackground", Color.parseColor("#015A86"));
temp4.put("darkStatusIcon", 0);
textDrawable.add(temp4);
Map temp5 = new HashMap<>();
temp5.put("textColor", Color.parseColor("#808080"));
temp5.put("bgIsColor", 1);
temp5.put("textBackground", Color.parseColor("#000000"));
temp5.put("darkStatusIcon", 0);
textDrawable.add(temp5);
}
}
public void initTextDrawableIndex() {
if (getIsNightTheme()) {
textDrawableIndex = preferences.getInt("textDrawableIndexNight", 4);
} else {
textDrawableIndex = preferences.getInt("textDrawableIndex", DEFAULT_BG);
}
if (textDrawableIndex == -1) {
textDrawableIndex = DEFAULT_BG;
}
initPageStyle();
setTextDrawable();
}
@SuppressWarnings("ConstantConditions")
private void initPageStyle() {
int bgCustom = getBgCustom(textDrawableIndex);
if ((bgCustom == 2 || bgCustom == 3) && getBgPath(textDrawableIndex) != null) {
bgIsColor = false;
String bgPath = getBgPath(textDrawableIndex);
Resources resources = MApplication.getInstance().getResources();
DisplayMetrics dm = resources.getDisplayMetrics();
int width = dm.widthPixels;
int height = dm.heightPixels;
if (bgCustom == 2) {
bgBitmap = BitmapUtil.getFitSampleBitmap(bgPath, width, height);
} else {
bgBitmap = MeUtils.getFitAssetsSampleBitmap(MApplication.getInstance().getAssets(), bgPath, width, height);
}
if (bgBitmap != null) {
return;
}
} else if (getBgCustom(textDrawableIndex) == 1) {
bgIsColor = true;
bgColor = getBgColor(textDrawableIndex);
return;
}
bgIsColor = true;
bgColor = textDrawable.get(textDrawableIndex).get("textBackground");
}
private void setTextDrawable() {
darkStatusIcon = getDarkStatusIcon(textDrawableIndex);
textColor = getTextColor(textDrawableIndex);
}
public int getTextColor(int textDrawableIndex) {
if (preferences.getInt("textColor" + textDrawableIndex, 0) != 0) {
return preferences.getInt("textColor" + textDrawableIndex, 0);
} else {
return getDefaultTextColor(textDrawableIndex);
}
}
public void setTextColor(int textDrawableIndex, int textColor) {
preferences.edit()
.putInt("textColor" + textDrawableIndex, textColor)
.apply();
}
@SuppressWarnings("ConstantConditions")
public Drawable getBgDrawable(int textDrawableIndex, Context context, int width, int height) {
int color;
try {
Bitmap bitmap = null;
switch (getBgCustom(textDrawableIndex)) {
case 3:
bitmap = MeUtils.getFitAssetsSampleBitmap(context.getAssets(), getBgPath(textDrawableIndex), width, height);
if (bitmap != null) {
return new BitmapDrawable(context.getResources(), bitmap);
}
case 2:
bitmap = BitmapUtil.getFitSampleBitmap(getBgPath(textDrawableIndex), width, height);
if (bitmap != null) {
return new BitmapDrawable(context.getResources(), bitmap);
}
break;
case 1:
color = getBgColor(textDrawableIndex);
return new ColorDrawable(color);
}
if (textDrawable.get(textDrawableIndex).get("bgIsColor") != 0) {
color = textDrawable.get(textDrawableIndex).get("textBackground");
return new ColorDrawable(color);
} else {
return getDefaultBgDrawable(textDrawableIndex, context);
}
} catch (Exception e) {
if (textDrawable.get(textDrawableIndex).get("bgIsColor") != 0) {
color = textDrawable.get(textDrawableIndex).get("textBackground");
return new ColorDrawable(color);
} else {
return getDefaultBgDrawable(textDrawableIndex, context);
}
}
}
@SuppressWarnings("ConstantConditions")
public Drawable getDefaultBgDrawable(int textDrawableIndex, Context context) {
if (textDrawable.get(textDrawableIndex).get("bgIsColor") != 0) {
return new ColorDrawable(textDrawable.get(textDrawableIndex).get("textBackground"));
} else {
return context.getResources().getDrawable(getDefaultBg(textDrawableIndex));
}
}
public int getBgCustom(int textDrawableIndex) {
return preferences.getInt("bgCustom" + textDrawableIndex, 0);
}
public void setBgCustom(int textDrawableIndex, int bgCustom) {
preferences.edit()
.putInt("bgCustom" + textDrawableIndex, bgCustom)
.apply();
}
public String getBgPath(int textDrawableIndex) {
return preferences.getString("bgPath" + textDrawableIndex, null);
}
public void setBgPath(int textDrawableIndex, String bgUri) {
preferences.edit()
.putString("bgPath" + textDrawableIndex, bgUri)
.apply();
}
@SuppressWarnings("ConstantConditions")
public int getDefaultTextColor(int textDrawableIndex) {
return textDrawable.get(textDrawableIndex).get("textColor");
}
@SuppressWarnings("ConstantConditions")
private int getDefaultBg(int textDrawableIndex) {
return textDrawable.get(textDrawableIndex).get("textBackground");
}
public int getBgColor(int index) {
return preferences.getInt("bgColor" + index, Color.parseColor("#1e1e1e"));
}
public void setBgColor(int index, int bgColor) {
preferences.edit()
.putInt("bgColor" + index, bgColor)
.apply();
}
private boolean getIsNightTheme() {
return MApplication.getInstance().isNightTheme();
}
public boolean getImmersionStatusBar() {
return preferences.getBoolean("immersionStatusBar", false);
}
public void setImmersionStatusBar(boolean immersionStatusBar) {
preferences.edit()
.putBoolean("immersionStatusBar", immersionStatusBar)
.apply();
}
public int getTextSize() {
return textSize;
}
public void setTextSize(int textSize) {
this.textSize = textSize;
preferences.edit()
.putInt("textSize", textSize)
.apply();
}
public int getTextColor() {
return textColor;
}
public boolean bgIsColor() {
return bgIsColor;
}
public Drawable getTextBackground(Context context) {
if (bgIsColor) {
return new ColorDrawable(bgColor);
}
return new BitmapDrawable(context.getResources(), bgBitmap);
}
public int getBgColor() {
return bgColor;
}
public boolean bgBitmapIsNull() {
return bgBitmap == null || bgBitmap.isRecycled();
}
public Bitmap getBgBitmap() {
return bgBitmap.copy(Bitmap.Config.ARGB_8888, true);
}
public int getTextDrawableIndex() {
return textDrawableIndex;
}
public void setTextDrawableIndex(int textDrawableIndex) {
this.textDrawableIndex = textDrawableIndex;
if (getIsNightTheme()) {
preferences.edit()
.putInt("textDrawableIndexNight", textDrawableIndex)
.apply();
} else {
preferences.edit()
.putInt("textDrawableIndex", textDrawableIndex)
.apply();
}
setTextDrawable();
}
public void setTextConvert(int textConvert) {
this.textConvert = textConvert;
preferences.edit()
.putInt("textConvertInt", textConvert)
.apply();
}
public void setNavBarColor(int navBarColor) {
this.navBarColor = navBarColor;
preferences.edit()
.putInt("navBarColorInt", navBarColor)
.apply();
}
public int getNavBarColor() {
return navBarColor;
}
public void setTextBold(boolean textBold) {
this.textBold = textBold;
preferences.edit()
.putBoolean("textBold", textBold)
.apply();
}
public void setReadBookFont(String fontPath) {
this.fontPath = fontPath;
preferences.edit()
.putString("fontPath", fontPath)
.apply();
}
public String getFontPath() {
return fontPath;
}
public int getTextConvert() {
return textConvert == -1 ? 2 : textConvert;
}
public Boolean getTextBold() {
return textBold;
}
public Boolean getCanKeyTurn(Boolean isPlay) {
if (!canKeyTurn) {
return false;
} else if (readAloudCanKeyTurn) {
return true;
} else {
return !isPlay;
}
}
public Boolean getCanKeyTurn() {
return canKeyTurn;
}
public void setCanKeyTurn(Boolean canKeyTurn) {
this.canKeyTurn = canKeyTurn;
preferences.edit()
.putBoolean("canKeyTurn", canKeyTurn)
.apply();
}
public Boolean getAloudCanKeyTurn() {
return readAloudCanKeyTurn;
}
public void setAloudCanKeyTurn(Boolean canAloudKeyTurn) {
this.readAloudCanKeyTurn = canAloudKeyTurn;
preferences.edit()
.putBoolean("readAloudCanKeyTurn", canAloudKeyTurn)
.apply();
}
public Boolean getCanClickTurn() {
return canClickTurn;
}
public void setCanClickTurn(Boolean canClickTurn) {
this.canClickTurn = canClickTurn;
preferences.edit()
.putBoolean("canClickTurn", canClickTurn)
.apply();
}
public float getTextLetterSpacing() {
return textLetterSpacing;
}
public void setTextLetterSpacing(float textLetterSpacing) {
this.textLetterSpacing = textLetterSpacing;
preferences.edit()
.putFloat("textLetterSpacing", textLetterSpacing)
.apply();
}
public float getLineMultiplier() {
return lineMultiplier;
}
public void setLineMultiplier(float lineMultiplier) {
this.lineMultiplier = lineMultiplier;
preferences.edit()
.putFloat("lineMultiplier", lineMultiplier)
.apply();
}
public float getParagraphSize() {
return paragraphSize;
}
public void setParagraphSize(float paragraphSize) {
this.paragraphSize = paragraphSize;
preferences.edit()
.putFloat("paragraphSize", paragraphSize)
.apply();
}
public int getCPM() {
return CPM;
}
public void setCPM(int cpm) {
if (cpm < minCPM || cpm > maxCPM) cpm = defaultCPM;
this.CPM = cpm;
preferences.edit()
.putInt("CPM", cpm)
.apply();
}
public Boolean getClickAllNext() {
return clickAllNext;
}
public void setClickAllNext(Boolean clickAllNext) {
this.clickAllNext = clickAllNext;
preferences.edit()
.putBoolean("clickAllNext", clickAllNext)
.apply();
}
public int getSpeechRate() {
return speechRate;
}
public void setSpeechRate(int speechRate) {
this.speechRate = speechRate;
preferences.edit()
.putInt("speechRate", speechRate)
.apply();
}
public boolean isSpeechRateFollowSys() {
return speechRateFollowSys;
}
public void setSpeechRateFollowSys(boolean speechRateFollowSys) {
this.speechRateFollowSys = speechRateFollowSys;
preferences.edit()
.putBoolean("speechRateFollowSys", speechRateFollowSys)
.apply();
}
public Boolean getShowTitle() {
return showTitle;
}
public void setShowTitle(Boolean showTitle) {
this.showTitle = showTitle;
preferences.edit()
.putBoolean("showTitle", showTitle)
.apply();
}
public Boolean getShowTimeBattery() {
return showTimeBattery;
}
public void setShowTimeBattery(Boolean showTimeBattery) {
this.showTimeBattery = showTimeBattery;
preferences.edit()
.putBoolean("showTimeBattery", showTimeBattery)
.apply();
}
public Boolean getLightNovelParagraph(){return lightNovelParagraph;}
public void setLightNovelParagraph(Boolean lightNovelParagraph) {
this.lightNovelParagraph = lightNovelParagraph;
preferences.edit()
.putBoolean("light_novel_paragraph", lightNovelParagraph)
.apply();
}
public Boolean getHideStatusBar() {
return hideStatusBar;
}
public void setHideStatusBar(Boolean hideStatusBar) {
this.hideStatusBar = hideStatusBar;
preferences.edit()
.putBoolean("hide_status_bar", hideStatusBar)
.apply();
}
public Boolean getToLh() {
return preferences.getBoolean("toLh", false);
}
public void setToLh(Boolean toLh) {
preferences.edit()
.putBoolean("toLh", toLh)
.apply();
}
public Boolean getHideNavigationBar() {
return hideNavigationBar;
}
public void setHideNavigationBar(Boolean hideNavigationBar) {
this.hideNavigationBar = hideNavigationBar;
preferences.edit()
.putBoolean("hide_navigation_bar", hideNavigationBar)
.apply();
}
public Boolean getShowLine() {
return showLine;
}
public void setShowLine(Boolean showLine) {
this.showLine = showLine;
preferences.edit()
.putBoolean("showLine", showLine)
.apply();
}
public boolean getDarkStatusIcon() {
return darkStatusIcon;
}
@SuppressWarnings("ConstantConditions")
public boolean getDarkStatusIcon(int textDrawableIndex) {
return preferences.getBoolean("darkStatusIcon" + textDrawableIndex, textDrawable.get(textDrawableIndex).get("darkStatusIcon") != 0);
}
public void setDarkStatusIcon(int textDrawableIndex, Boolean darkStatusIcon) {
preferences.edit()
.putBoolean("darkStatusIcon" + textDrawableIndex, darkStatusIcon)
.apply();
}
public int getScreenTimeOut() {
return screenTimeOut;
}
public void setScreenTimeOut(int screenTimeOut) {
this.screenTimeOut = screenTimeOut;
preferences.edit()
.putInt("screenTimeOut", screenTimeOut)
.apply();
}
public int getPaddingLeft() {
return paddingLeft;
}
public void setPaddingLeft(int paddingLeft) {
this.paddingLeft = paddingLeft;
preferences.edit()
.putInt("paddingLeft", paddingLeft)
.apply();
}
public int getPaddingTop() {
return paddingTop;
}
public void setPaddingTop(int paddingTop) {
this.paddingTop = paddingTop;
preferences.edit()
.putInt("paddingTop", paddingTop)
.apply();
}
public int getPaddingRight() {
return paddingRight;
}
public void setPaddingRight(int paddingRight) {
this.paddingRight = paddingRight;
preferences.edit()
.putInt("paddingRight", paddingRight)
.apply();
}
public int getPaddingBottom() {
return paddingBottom;
}
public void setPaddingBottom(int paddingBottom) {
this.paddingBottom = paddingBottom;
preferences.edit()
.putInt("paddingBottom", paddingBottom)
.apply();
}
public int getTipPaddingLeft() {
return tipPaddingLeft;
}
public void setTipPaddingLeft(int tipPaddingLeft) {
this.tipPaddingLeft = tipPaddingLeft;
preferences.edit()
.putInt("tipPaddingLeft", tipPaddingLeft)
.apply();
}
public boolean isCanSelectText() {
return canSelectText;
}
public void setCanSelectText(boolean canSelectText) {
this.canSelectText = canSelectText;
preferences.edit()
.putBoolean("canSelectText", canSelectText)
.apply();
}
public int getTipPaddingTop() {
return tipPaddingTop;
}
public void setTipPaddingTop(int tipPaddingTop) {
this.tipPaddingTop = tipPaddingTop;
preferences.edit()
.putInt("tipPaddingTop", tipPaddingTop)
.apply();
}
public int getTipPaddingRight() {
return tipPaddingRight;
}
public void setTipPaddingRight(int tipPaddingRight) {
this.tipPaddingRight = tipPaddingRight;
preferences.edit()
.putInt("tipPaddingRight", tipPaddingRight)
.apply();
}
public int getTipPaddingBottom() {
return tipPaddingBottom;
}
public void setTipPaddingBottom(int tipPaddingBottom) {
this.tipPaddingBottom = tipPaddingBottom;
preferences.edit()
.putInt("tipPaddingBottom", tipPaddingBottom)
.apply();
}
public int getPageMode() {
return pageMode;
}
public void setPageMode(int pageMode) {
this.pageMode = pageMode;
preferences.edit()
.putInt("pageMode", pageMode)
.apply();
}
public int getScreenDirection() {
return screenDirection;
}
public void setScreenDirection(int screenDirection) {
this.screenDirection = screenDirection;
preferences.edit()
.putInt("screenDirection", screenDirection)
.apply();
}
public void setIndent(int indent) {
this.indent = indent;
preferences.edit()
.putInt("indent", indent)
.apply();
}
public int getIndent() {
return indent;
}
public int getLight() {
return preferences.getInt("light", getScreenBrightness());
}
public void setLight(int light) {
preferences.edit()
.putInt("light", light)
.apply();
}
public Boolean getLightFollowSys() {
return preferences.getBoolean("lightFollowSys", true);
}
public void setLightFollowSys(boolean isFollowSys) {
preferences.edit()
.putBoolean("lightFollowSys", isFollowSys)
.apply();
}
private int getScreenBrightness() {
int value = 0;
ContentResolver cr = MApplication.getInstance().getContentResolver();
try {
value = Settings.System.getInt(cr, Settings.System.SCREEN_BRIGHTNESS);
} catch (Settings.SettingNotFoundException ignored) {
}
return value;
}
public boolean disableScrollClickTurn() {
return preferences.getBoolean("disableScrollClickTurn", false);
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/SSLSocketClient.java
================================================
package com.kunfei.bookshelf.help;
import android.annotation.SuppressLint;
import java.security.SecureRandom;
import java.security.cert.X509Certificate;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
/**
* Created by GKF on 2018/3/1.
* 忽略证书
*/
public class SSLSocketClient {
//获取这个SSLSocketFactory
public static SSLSocketFactory getSSLSocketFactory() {
try {
SSLContext sslContext = SSLContext.getInstance("SSL");
sslContext.init(null, new TrustManager[]{createTrustAllManager()}, new SecureRandom());
return sslContext.getSocketFactory();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static X509TrustManager createTrustAllManager() {
X509TrustManager tm = null;
try {
tm = new X509TrustManager() {
@SuppressLint("TrustAllX509TrustManager")
public void checkClientTrusted(X509Certificate[] chain, String authType) {
//do nothing，接受任意客户端证书
}
@SuppressLint("TrustAllX509TrustManager")
public void checkServerTrusted(X509Certificate[] chain, String authType) {
//do nothing，接受任意服务端证书
}
public X509Certificate[] getAcceptedIssuers() {
return new X509Certificate[0];
}
};
} catch (Exception ignored) {
}
return tm;
}
//获取HostnameVerifier
public static HostnameVerifier getHostnameVerifier() {
return (s, sslSession) -> true;
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/SourceHelp.kt
================================================
package com.kunfei.bookshelf.help
import android.os.Handler
import android.os.Looper
import com.kunfei.bookshelf.MApplication
import com.kunfei.bookshelf.bean.BookSourceBean
import com.kunfei.bookshelf.model.BookSourceManager
import com.kunfei.bookshelf.utils.EncoderUtils
import com.kunfei.bookshelf.utils.splitNotBlank
import org.jetbrains.anko.toast
object SourceHelp {
private val handler = Handler(Looper.getMainLooper())
private val list18Plus by lazy {
try {
return@lazy String(MApplication.getInstance().assets.open("18PlusList.txt").readBytes())
.splitNotBlank("\n")
} catch (e: Exception) {
return@lazy arrayOf()
}
}
fun insertBookSource(vararg bookSources: BookSourceBean) {
bookSources.forEach { bookSource ->
if (is18Plus(bookSource.bookSourceUrl)) {
handler.post {
MApplication.getInstance().toast("${bookSource.bookSourceName}是18+网址,禁止导入.")
}
} else {
BookSourceManager.addBookSource(bookSource)
}
}
}
private fun is18Plus(url: String?): Boolean {
url ?: return false
val baseUrl = getBaseUrl(url)
baseUrl ?: return false
try {
val host = baseUrl.split("//", ".")
val base64Url = EncoderUtils.base64Encode("${host[host.lastIndex - 1]}.${host.last()}")
list18Plus.forEach {
if (base64Url == it) {
return true
}
}
} catch (e: Exception) {
}
return false
}
fun getBaseUrl(url: String?): String? {
if (url == null || !url.startsWith("http")) return null
val index = url.indexOf("/", 9)
return if (index == -1) {
url
} else url.substring(0, index)
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/UTF8BOMFighter.java
================================================
package com.kunfei.bookshelf.help;
public class UTF8BOMFighter {
private static final byte[] UTF8_BOM_BYTES = new byte[]{(byte) 0xEF, (byte) 0xBB, (byte) 0xBF};
private UTF8BOMFighter() {
}
static public String removeUTF8BOM(String xmlText) {
byte[] bytes = xmlText.getBytes();
boolean containsBOM = bytes.length > 3
&& bytes[0] == UTF8_BOM_BYTES[0]
&& bytes[1] == UTF8_BOM_BYTES[1]
&& bytes[2] == UTF8_BOM_BYTES[2];
if (containsBOM) {
xmlText = new String(bytes, 3, bytes.length - 3);
}
return xmlText;
}
static public byte[] removeUTF8BOM(byte[] bytes) {
boolean containsBOM = bytes.length > 3
&& bytes[0] == UTF8_BOM_BYTES[0]
&& bytes[1] == UTF8_BOM_BYTES[1]
&& bytes[2] == UTF8_BOM_BYTES[2];
if (containsBOM) {
byte[] copy = new byte[bytes.length - 3];
System.arraycopy(bytes, 3, copy, 0, bytes.length - 3);
return copy;
}
return bytes;
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/UpdateManager.java
================================================
package com.kunfei.bookshelf.help;
import static android.content.Context.DOWNLOAD_SERVICE;
import android.app.Activity;
import android.content.Intent;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import android.util.Log;
import android.widget.Toast;
import androidx.core.content.FileProvider;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.kunfei.bookshelf.BuildConfig;
import com.kunfei.bookshelf.MApplication;
import com.kunfei.bookshelf.R;
import com.kunfei.bookshelf.base.BaseModelImpl;
import com.kunfei.bookshelf.base.observer.MyObserver;
import com.kunfei.bookshelf.bean.UpdateInfoBean;
import com.kunfei.bookshelf.model.analyzeRule.AnalyzeHeaders;
import com.kunfei.bookshelf.model.impl.IHttpGetApi;
import java.io.File;
import io.reactivex.Observable;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.schedulers.Schedulers;
public class UpdateManager {
private Activity activity;
public static UpdateManager getInstance(Activity activity) {
return new UpdateManager(activity);
}
private UpdateManager(Activity activity) {
this.activity = activity;
}
public void checkUpdate(boolean showMsg) {
BaseModelImpl.getInstance().getRetrofitString("https://api.github.com")
.create(IHttpGetApi.class)
.get(MApplication.getInstance().getString(R.string.latest_release_api), AnalyzeHeaders.getDefaultHeader())
.flatMap(response -> analyzeLastReleaseApi(response.body()))
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new MyObserver() {
@Override
public void onNext(UpdateInfoBean updateInfo) {
if (updateInfo.getUpDate()) {
} else if (showMsg) {
Toast.makeText(activity, "已是最新版本", Toast.LENGTH_SHORT).show();
}
}
@Override
public void onError(Throwable e) {
if (showMsg) {
Toast.makeText(activity, "检测新版本出错", Toast.LENGTH_SHORT).show();
}
}
});
}
private Observable analyzeLastReleaseApi(String jsonStr) {
return Observable.create(emitter -> {
try {
UpdateInfoBean updateInfo = new UpdateInfoBean();
JsonObject version = new JsonParser().parse(jsonStr).getAsJsonObject();
if (version.get("prerelease").getAsBoolean())
return;
JsonArray assets = version.get("assets").getAsJsonArray();
if (assets.size() > 0) {
String lastVersion = version.get("tag_name").getAsString();
String url = assets.get(0).getAsJsonObject().get("browser_download_url").getAsString();
String detail = version.get("body").getAsString();
String thisVersion = MApplication.getVersionName().split("\\s")[0];
updateInfo.setUrl(url);
updateInfo.setLastVersion(lastVersion);
updateInfo.setDetail("# " + lastVersion + "\n" + detail);
if (Integer.valueOf(lastVersion.split("\\.")[2]) > Integer.valueOf(thisVersion.split("\\.")[2])) {
updateInfo.setUpDate(true);
} else {
updateInfo.setUpDate(false);
}
}
emitter.onNext(updateInfo);
emitter.onComplete();
} catch (Exception e) {
emitter.onError(e);
emitter.onComplete();
}
});
}
/**
* 安装apk
*/
public void installApk(File apkFile) {
if (!apkFile.exists()) {
return;
}
Intent intent = new Intent();
//执行动作
intent.setAction(Intent.ACTION_VIEW);
//判读版本是否在7.0以上
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
Uri apkUri = FileProvider.getUriForFile(activity, BuildConfig.APPLICATION_ID + ".fileProvider", apkFile);
intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
intent.setDataAndType(apkUri, "application/vnd.android.package-archive");
} else {
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
intent.setDataAndType(Uri.fromFile(apkFile), "application/vnd.android.package-archive");
}
try {
activity.startActivity(intent);
} catch (Exception e) {
Log.d("wwd", "Failed to launcher installing activity");
}
}
public static String getSavePath(String fileName) {
return Environment.getExternalStoragePublicDirectory(DOWNLOAD_SERVICE).getPath() + fileName;
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/coroutine/CompositeCoroutine.kt
================================================
package io.legado.app.help.coroutine
@Suppress("unused")
class CompositeCoroutine : CoroutineContainer {
private var resources: HashSet>? = null
val size: Int
get() = resources?.size ?: 0
val isEmpty: Boolean
get() = size == 0
constructor()
constructor(vararg coroutines: Coroutine<*>) {
this.resources = hashSetOf(*coroutines)
}
constructor(coroutines: Iterable>) {
this.resources = hashSetOf()
for (d in coroutines) {
this.resources?.add(d)
}
}
override fun add(coroutine: Coroutine<*>): Boolean {
synchronized(this) {
var set: HashSet>? = resources
if (resources == null) {
set = hashSetOf()
resources = set
}
return set!!.add(coroutine)
}
}
override fun addAll(vararg coroutines: Coroutine<*>): Boolean {
synchronized(this) {
var set: HashSet>? = resources
if (resources == null) {
set = hashSetOf()
resources = set
}
for (coroutine in coroutines) {
val add = set!!.add(coroutine)
if (!add) {
return false
}
}
}
return true
}
override fun remove(coroutine: Coroutine<*>): Boolean {
if (delete(coroutine)) {
coroutine.cancel()
return true
}
return false
}
override fun delete(coroutine: Coroutine<*>): Boolean {
synchronized(this) {
val set = resources
if (set == null || !set.remove(coroutine)) {
return false
}
}
return true
}
override fun clear() {
val set: HashSet>?
synchronized(this) {
set = resources
resources = null
}
set?.forEachIndexed { _, coroutine ->
coroutine.cancel()
}
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/coroutine/Coroutine.kt
================================================
package io.legado.app.help.coroutine
import kotlinx.coroutines.*
import timber.log.Timber
import kotlin.coroutines.CoroutineContext
@Suppress("unused")
class Coroutine(
val scope: CoroutineScope,
context: CoroutineContext = Dispatchers.IO,
block: suspend CoroutineScope.() -> T
) {
companion object {
private val DEFAULT = MainScope()
fun async(
scope: CoroutineScope = DEFAULT,
context: CoroutineContext = Dispatchers.IO,
block: suspend CoroutineScope.() -> T
): Coroutine {
return Coroutine(scope, context, block)
}
}
private val job: Job
private var start: VoidCallback? = null
private var success: Callback? = null
private var error: Callback? = null
private var finally: VoidCallback? = null
private var cancel: VoidCallback? = null
private var timeMillis: Long? = null
private var errorReturn: Result? = null
val isCancelled: Boolean
get() = job.isCancelled
val isActive: Boolean
get() = job.isActive
val isCompleted: Boolean
get() = job.isCompleted
init {
this.job = executeInternal(context, block)
}
fun timeout(timeMillis: () -> Long): Coroutine {
this.timeMillis = timeMillis()
return this@Coroutine
}
fun timeout(timeMillis: Long): Coroutine {
this.timeMillis = timeMillis
return this@Coroutine
}
fun onErrorReturn(value: () -> T?): Coroutine {
this.errorReturn = Result(value())
return this@Coroutine
}
fun onErrorReturn(value: T?): Coroutine {
this.errorReturn = Result(value)
return this@Coroutine
}
fun onStart(
context: CoroutineContext? = null,
block: (suspend CoroutineScope.() -> Unit)
): Coroutine {
this.start = VoidCallback(context, block)
return this@Coroutine
}
fun onSuccess(
context: CoroutineContext? = null,
block: suspend CoroutineScope.(T) -> Unit
): Coroutine {
this.success = Callback(context, block)
return this@Coroutine
}
fun onError(
context: CoroutineContext? = null,
block: suspend CoroutineScope.(Throwable) -> Unit
): Coroutine {
this.error = Callback(context, block)
return this@Coroutine
}
fun onFinally(
context: CoroutineContext? = null,
block: suspend CoroutineScope.() -> Unit
): Coroutine {
this.finally = VoidCallback(context, block)
return this@Coroutine
}
fun onCancel(
context: CoroutineContext? = null,
block: suspend CoroutineScope.() -> Unit
): Coroutine {
this.cancel = VoidCallback(context, block)
return this@Coroutine
}
//取消当前任务
fun cancel(cause: CancellationException? = null) {
job.cancel(cause)
cancel?.let {
MainScope().launch {
if (null == it.context) {
it.block.invoke(scope)
} else {
withContext(scope.coroutineContext.plus(it.context)) {
it.block.invoke(this)
}
}
}
}
}
fun invokeOnCompletion(handler: CompletionHandler): DisposableHandle {
return job.invokeOnCompletion(handler)
}
private fun executeInternal(
context: CoroutineContext,
block: suspend CoroutineScope.() -> T
): Job {
return scope.plus(Dispatchers.Main).launch {
try {
start?.let { dispatchVoidCallback(this, it) }
val value = executeBlock(scope, context, timeMillis ?: 0L, block)
if (isActive) {
success?.let { dispatchCallback(this, value, it) }
}
} catch (e: Throwable) {
Timber.e(e)
val consume: Boolean = errorReturn?.value?.let { value ->
if (isActive) {
success?.let { dispatchCallback(this, value, it) }
}
true
} ?: false
if (!consume && isActive) {
error?.let { dispatchCallback(this, e, it) }
}
} finally {
if (isActive) {
finally?.let { dispatchVoidCallback(this, it) }
}
}
}
}
private suspend inline fun dispatchVoidCallback(scope: CoroutineScope, callback: VoidCallback) {
if (null == callback.context) {
callback.block.invoke(scope)
} else {
withContext(scope.coroutineContext.plus(callback.context)) {
callback.block.invoke(this)
}
}
}
private suspend inline fun dispatchCallback(
scope: CoroutineScope,
value: R,
callback: Callback
) {
if (!scope.isActive) return
if (null == callback.context) {
callback.block.invoke(scope, value)
} else {
withContext(scope.coroutineContext.plus(callback.context)) {
callback.block.invoke(this, value)
}
}
}
private suspend inline fun executeBlock(
scope: CoroutineScope,
context: CoroutineContext,
timeMillis: Long,
noinline block: suspend CoroutineScope.() -> T
): T {
return withContext(scope.coroutineContext.plus(context)) {
if (timeMillis > 0L) withTimeout(timeMillis) {
block()
} else {
block()
}
}
}
private data class Result(val value: T?)
private inner class VoidCallback(
val context: CoroutineContext?,
val block: suspend CoroutineScope.() -> Unit
)
private inner class Callback(
val context: CoroutineContext?,
val block: suspend CoroutineScope.(VALUE) -> Unit
)
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/coroutine/CoroutineContainer.kt
================================================
package io.legado.app.help.coroutine
internal interface CoroutineContainer {
fun add(coroutine: Coroutine<*>): Boolean
fun addAll(vararg coroutines: Coroutine<*>): Boolean
fun remove(coroutine: Coroutine<*>): Boolean
fun delete(coroutine: Coroutine<*>): Boolean
fun clear()
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/glide/ImageLoader.kt
================================================
package com.kunfei.bookshelf.help.glide
import android.content.Context
import android.graphics.Bitmap
import android.graphics.drawable.Drawable
import android.net.Uri
import androidx.annotation.DrawableRes
import com.bumptech.glide.Glide
import com.bumptech.glide.RequestBuilder
import java.io.File
object ImageLoader {
fun load(context: Context, path: String?): RequestBuilder {
return when {
path.isNullOrEmpty() -> Glide.with(context).load(path)
path.startsWith("http", true) -> GlideApp.with(context).load(path)
else -> try {
Glide.with(context).load(File(path))
} catch (e: Exception) {
Glide.with(context).load(path)
}
}
}
fun load(context: Context, @DrawableRes resId: Int?): RequestBuilder {
return Glide.with(context).load(resId)
}
fun load(context: Context, file: File?): RequestBuilder {
return Glide.with(context).load(file)
}
fun load(context: Context, uri: Uri?): RequestBuilder {
return Glide.with(context).load(uri)
}
fun load(context: Context, drawable: Drawable?): RequestBuilder {
return Glide.with(context).load(drawable)
}
fun load(context: Context, bitmap: Bitmap?): RequestBuilder {
return Glide.with(context).load(bitmap)
}
fun load(context: Context, bytes: ByteArray?): RequestBuilder {
return Glide.with(context).load(bytes)
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/glide/OkHttpGlideModule.kt
================================================
package com.kunfei.bookshelf.help.glide
import android.content.Context
import com.bumptech.glide.Glide
import com.bumptech.glide.Registry
import com.bumptech.glide.annotation.GlideModule
import com.bumptech.glide.load.model.GlideUrl
import com.bumptech.glide.module.AppGlideModule
import java.io.InputStream
@GlideModule
class OkHttpGlideModule : AppGlideModule() {
override fun registerComponents(context: Context, glide: Glide, registry: Registry) {
registry.replace(
GlideUrl::class.java,
InputStream::class.java,
OkHttpModeLoaderFactory
)
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/glide/OkHttpModeLoaderFactory.kt
================================================
package com.kunfei.bookshelf.help.glide
import com.bumptech.glide.load.model.GlideUrl
import com.bumptech.glide.load.model.ModelLoader
import com.bumptech.glide.load.model.ModelLoaderFactory
import com.bumptech.glide.load.model.MultiModelLoaderFactory
import java.io.InputStream
object OkHttpModeLoaderFactory : ModelLoaderFactory {
override fun build(multiFactory: MultiModelLoaderFactory): ModelLoader {
return OkHttpModelLoader
}
override fun teardown() {
// Do nothing, this instance doesn't own the client.
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/glide/OkHttpModelLoader.kt
================================================
package com.kunfei.bookshelf.help.glide
import com.bumptech.glide.load.Options
import com.bumptech.glide.load.model.GlideUrl
import com.bumptech.glide.load.model.ModelLoader
import java.io.InputStream
object OkHttpModelLoader : ModelLoader {
override fun buildLoadData(
model: GlideUrl,
width: Int,
height: Int,
options: Options
): ModelLoader.LoadData {
return ModelLoader.LoadData(model, OkHttpStreamFetcher(model))
}
override fun handles(model: GlideUrl): Boolean {
return true
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/glide/OkHttpStreamFetcher.kt
================================================
package com.kunfei.bookshelf.help.glide
import com.bumptech.glide.Priority
import com.bumptech.glide.load.DataSource
import com.bumptech.glide.load.HttpException
import com.bumptech.glide.load.data.DataFetcher
import com.bumptech.glide.load.model.GlideUrl
import com.bumptech.glide.util.ContentLengthInputStream
import com.bumptech.glide.util.Preconditions
import com.kunfei.bookshelf.base.BaseModelImpl
import okhttp3.Call
import okhttp3.Request
import okhttp3.Response
import okhttp3.ResponseBody
import java.io.IOException
import java.io.InputStream
class OkHttpStreamFetcher(private val url: GlideUrl) :
DataFetcher, okhttp3.Callback {
private var stream: InputStream? = null
private var responseBody: ResponseBody? = null
private var callback: DataFetcher.DataCallback? = null
private var call: Call? = null
override fun loadData(priority: Priority, callback: DataFetcher.DataCallback) {
val requestBuilder: Request.Builder = Request.Builder().url(url.toStringUrl())
for ((key, value) in url.headers.entries) {
requestBuilder.addHeader(key, value)
}
val request: Request = requestBuilder.build()
this.callback = callback
call = BaseModelImpl.getClient().newCall(request)
call?.enqueue(this)
}
override fun cleanup() {
try {
stream?.close()
} catch (e: IOException) {
// Ignored
}
responseBody?.close()
callback = null
}
override fun cancel() {
call?.cancel()
}
override fun getDataClass(): Class {
return InputStream::class.java
}
override fun getDataSource(): DataSource {
return DataSource.REMOTE
}
override fun onFailure(call: Call, e: IOException) {
callback?.onLoadFailed(e)
}
override fun onResponse(call: Call, response: Response) {
responseBody = response.body
if (response.isSuccessful) {
val contentLength: Long = Preconditions.checkNotNull(responseBody).contentLength()
stream = ContentLengthInputStream.obtain(responseBody!!.byteStream(), contentLength)
callback!!.onDataReady(stream)
} else {
callback!!.onLoadFailed(HttpException(response.message, response.code))
}
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/media/LoaderCreator.java
================================================
package com.kunfei.bookshelf.help.media;
import android.content.Context;
import android.os.Bundle;
import androidx.loader.content.CursorLoader;
/**
* Created by newbiechen on 2018/1/14.
*/
public class LoaderCreator {
public static final int ALL_BOOK_FILE = 1;
public static CursorLoader create(Context context, int id, Bundle bundle) {
LocalFileLoader loader = null;
if (id == ALL_BOOK_FILE) {
loader = new LocalFileLoader(context);
} else {
loader = null;
}
if (loader != null) {
return loader;
}
throw new IllegalArgumentException("The id of Loader is invalid!");
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/media/LocalFileLoader.java
================================================
package com.kunfei.bookshelf.help.media;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.provider.MediaStore;
import android.text.TextUtils;
import androidx.annotation.NonNull;
import androidx.loader.content.CursorLoader;
import java.io.File;
import java.sql.Blob;
import java.util.ArrayList;
import java.util.List;
/**
* Created by newbiechen on 2018/1/14.
*/
public class LocalFileLoader extends CursorLoader {
private static final String TAG = "LocalFileLoader";
private static final Uri FILE_URI = Uri.parse("content://media/external/file");
private static final String SELECTION = MediaStore.Files.FileColumns.DATA + " like ? or " + MediaStore.Files.FileColumns.DATA + " like ?";
private static final String[] SEARCH_TYPE = new String[]{"%.txt", "%.epub"};
private static final String SORT_ORDER = MediaStore.Files.FileColumns.DISPLAY_NAME + " DESC";
private static final String[] FILE_PROJECTION = {
MediaStore.Files.FileColumns.DATA,
MediaStore.Files.FileColumns.DISPLAY_NAME
};
public LocalFileLoader(Context context) {
super(context);
initLoader();
}
/**
* 为 Cursor 设置默认参数
*/
private void initLoader() {
setUri(FILE_URI);
setProjection(FILE_PROJECTION);
setSelection(SELECTION);
setSelectionArgs(SEARCH_TYPE);
setSortOrder(SORT_ORDER);
}
public void parseData(Cursor cursor, final MediaStoreHelper.MediaResultCallback resultCallback) {
List files = new ArrayList<>();
// 判断是否存在数据
if (cursor == null) {
// 暂时直接返回空数据
resultCallback.onResultCallback(files);
return;
}
// 重复使用Loader时，需要重置cursor的position；
cursor.moveToPosition(-1);
while (cursor.moveToNext()) {
String path;
path = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns.DATA));
// 路径无效
if (!TextUtils.isEmpty(path)) {
File file = new File(path);
if (!file.isDirectory() && file.exists() && file.length() > 1024) {
files.add(file);
}
}
}
if (resultCallback != null) {
resultCallback.onResultCallback(files);
}
}
/**
* 从Cursor中读取对应columnName的值
*
* @param cursor
* @param columnName
* @param defaultValue
* @return 当columnName无效时返回默认值；
*/
protected Object getValueFromCursor(@NonNull Cursor cursor, String columnName, Object defaultValue) {
try {
int index = cursor.getColumnIndexOrThrow(columnName);
int type = cursor.getType(index);
switch (type) {
case Cursor.FIELD_TYPE_STRING:
// TO SOLVE:某些手机的数据库将数值类型存为String类型
String value = cursor.getString(index);
try {
if (defaultValue instanceof String) {
return value;
} else if (defaultValue instanceof Long) {
return Long.valueOf(value);
} else if (defaultValue instanceof Integer) {
return Integer.valueOf(value);
} else if (defaultValue instanceof Double) {
return Double.valueOf(value);
} else if (defaultValue instanceof Float) {
return Float.valueOf(value);
}
} catch (NumberFormatException e) {
return defaultValue;
}
case Cursor.FIELD_TYPE_INTEGER:
if (defaultValue instanceof Long) {
return cursor.getLong(index);
} else if (defaultValue instanceof Integer) {
return cursor.getInt(index);
}
case Cursor.FIELD_TYPE_FLOAT:
if (defaultValue instanceof Float) {
return cursor.getFloat(index);
} else if (defaultValue instanceof Double) {
return cursor.getDouble(index);
}
case Cursor.FIELD_TYPE_BLOB:
if (defaultValue instanceof Blob) {
return cursor.getBlob(index);
}
case Cursor.FIELD_TYPE_NULL:
default:
return defaultValue;
}
} catch (IllegalArgumentException e) {
return defaultValue;
}
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/media/MediaStoreHelper.java
================================================
package com.kunfei.bookshelf.help.media;
import android.content.Context;
import android.database.Cursor;
import android.os.Bundle;
import androidx.annotation.NonNull;
import androidx.fragment.app.FragmentActivity;
import androidx.loader.app.LoaderManager;
import androidx.loader.content.Loader;
import java.io.File;
import java.lang.ref.WeakReference;
import java.util.List;
/**
* Created by newbiechen on 2018/1/14.
* 获取媒体库的数据。
*/
public class MediaStoreHelper {
/**
* 获取媒体库中所有的书籍文件
*
* 暂时只支持 TXT
*
* @param activity
* @param resultCallback
*/
public static void getAllBookFile(FragmentActivity activity, MediaResultCallback resultCallback) {
// 将文件的获取处理交给 LoaderManager。
activity.getSupportLoaderManager()
.initLoader(LoaderCreator.ALL_BOOK_FILE, null, new MediaLoaderCallbacks(activity, resultCallback));
}
public interface MediaResultCallback {
void onResultCallback(List files);
}
/**
* Loader 回调处理
*/
static class MediaLoaderCallbacks implements LoaderManager.LoaderCallbacks {
protected WeakReference mContext;
protected MediaResultCallback mResultCallback;
public MediaLoaderCallbacks(Context context, MediaResultCallback resultCallback) {
mContext = new WeakReference<>(context);
mResultCallback = resultCallback;
}
@NonNull
@Override
public Loader onCreateLoader(int id, Bundle args) {
return LoaderCreator.create(mContext.get(), id, args);
}
@Override
public void onLoadFinished(@NonNull Loader loader, Cursor data) {
LocalFileLoader localFileLoader = (LocalFileLoader) loader;
localFileLoader.parseData(data, mResultCallback);
}
@Override
public void onLoaderReset(@NonNull Loader loader) {
}
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/permission/ActivitySource.kt
================================================
package com.kunfei.bookshelf.help.permission
import android.app.Activity
import android.content.Context
import android.content.Intent
import java.lang.ref.WeakReference
internal class ActivitySource(activity: Activity) : RequestSource {
private val actRef: WeakReference = WeakReference(activity)
override val context: Context?
get() = actRef.get()
override fun startActivity(intent: Intent) {
actRef.get()?.startActivity(intent)
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/permission/FragmentSource.kt
================================================
package com.kunfei.bookshelf.help.permission
import android.content.Context
import android.content.Intent
import androidx.fragment.app.Fragment
import java.lang.ref.WeakReference
internal class FragmentSource(fragment: Fragment) : RequestSource {
private val fragRef: WeakReference = WeakReference(fragment)
override val context: Context?
get() = fragRef.get()?.requireContext()
override fun startActivity(intent: Intent) {
fragRef.get()?.startActivity(intent)
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/permission/OnPermissionsDeniedCallback.kt
================================================
package com.kunfei.bookshelf.help.permission
interface OnPermissionsDeniedCallback {
fun onPermissionsDenied(requestCode: Int, deniedPermissions: Array)
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/permission/OnPermissionsGrantedCallback.kt
================================================
package com.kunfei.bookshelf.help.permission
interface OnPermissionsGrantedCallback {
fun onPermissionsGranted(requestCode: Int)
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/permission/OnPermissionsResultCallback.kt
================================================
package com.kunfei.bookshelf.help.permission
interface OnPermissionsResultCallback {
fun onPermissionsGranted(requestCode: Int)
fun onPermissionsDenied(requestCode: Int, deniedPermissions: Array)
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/permission/OnRequestPermissionsResultCallback.kt
================================================
package com.kunfei.bookshelf.help.permission
import android.content.Intent
interface OnRequestPermissionsResultCallback {
fun onRequestPermissionsResult(requestCode: Int, permissions: Array, grantResults: IntArray)
fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?)
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/permission/PermissionActivity.kt
================================================
package com.kunfei.bookshelf.help.permission
import android.app.Activity
import android.content.Intent
import android.net.Uri
import android.os.Bundle
import android.provider.Settings
import android.view.KeyEvent
import android.widget.Toast
import androidx.core.app.ActivityCompat
import com.kunfei.bookshelf.R
class PermissionActivity : Activity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
when (intent.getIntExtra(KEY_INPUT_REQUEST_TYPE, Request.TYPE_REQUEST_PERMISSION)) {
Request.TYPE_REQUEST_PERMISSION//权限请求
-> {
val requestCode = intent.getIntExtra(KEY_INPUT_PERMISSIONS_CODE, 1000)
val permissions = intent.getStringArrayExtra(KEY_INPUT_PERMISSIONS)
if (permissions != null) {
ActivityCompat.requestPermissions(this, permissions, requestCode)
} else {
finish()
}
}
Request.TYPE_REQUEST_SETTING//跳转到设置界面
-> try {
val settingIntent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
settingIntent.data = Uri.fromParts("package", packageName, null)
startActivityForResult(settingIntent, Request.TYPE_REQUEST_SETTING)
} catch (e: Exception) {
Toast.makeText(this, R.string.tip_cannot_jump_setting_page, Toast.LENGTH_SHORT).show()
finish()
}
}
}
override fun onRequestPermissionsResult(requestCode: Int, permissions: Array, grantResults: IntArray) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults)
RequestPlugins.sRequestCallback?.onRequestPermissionsResult(requestCode, permissions, grantResults)
finish()
}
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
super.onActivityResult(requestCode, resultCode, data)
RequestPlugins.sRequestCallback?.onActivityResult(requestCode, resultCode, data)
finish()
}
override fun startActivity(intent: Intent) {
super.startActivity(intent)
overridePendingTransition(0, 0)
}
override fun finish() {
super.finish()
overridePendingTransition(0, 0)
}
override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
return if (keyCode == KeyEvent.KEYCODE_BACK) {
true
} else super.onKeyDown(keyCode, event)
}
companion object {
const val KEY_INPUT_REQUEST_TYPE = "KEY_INPUT_REQUEST_TYPE"
const val KEY_INPUT_PERMISSIONS_CODE = "KEY_INPUT_PERMISSIONS_CODE"
const val KEY_INPUT_PERMISSIONS = "KEY_INPUT_PERMISSIONS"
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/permission/Permissions.kt
================================================
package com.kunfei.bookshelf.help.permission
object Permissions {
const val READ_CALENDAR = "android.permission.READ_CALENDAR"
const val WRITE_CALENDAR = "android.permission.WRITE_CALENDAR"
const val CAMERA = "android.permission.CAMERA"
const val READ_CONTACTS = "android.permission.READ_CONTACTS"
const val WRITE_CONTACTS = "android.permission.WRITE_CONTACTS"
const val GET_ACCOUNTS = "android.permission.GET_ACCOUNTS"
const val ACCESS_FINE_LOCATION = "android.permission.ACCESS_FINE_LOCATION"
const val ACCESS_COARSE_LOCATION = "android.permission.ACCESS_COARSE_LOCATION"
const val RECORD_AUDIO = "android.permission.RECORD_AUDIO"
const val READ_PHONE_STATE = "android.permission.READ_PHONE_STATE"
const val CALL_PHONE = "android.permission.CALL_PHONE"
const val READ_CALL_LOG = "android.permission.READ_CALL_LOG"
const val WRITE_CALL_LOG = "android.permission.WRITE_CALL_LOG"
const val ADD_VOICEMAIL = "com.android.voicemail.permission.ADD_VOICEMAIL"
const val USE_SIP = "android.permission.USE_SIP"
const val PROCESS_OUTGOING_CALLS = "android.permission.PROCESS_OUTGOING_CALLS"
const val BODY_SENSORS = "android.permission.BODY_SENSORS"
const val SEND_SMS = "android.permission.SEND_SMS"
const val RECEIVE_SMS = "android.permission.RECEIVE_SMS"
const val READ_SMS = "android.permission.READ_SMS"
const val RECEIVE_WAP_PUSH = "android.permission.RECEIVE_WAP_PUSH"
const val RECEIVE_MMS = "android.permission.RECEIVE_MMS"
const val READ_EXTERNAL_STORAGE = "android.permission.READ_EXTERNAL_STORAGE"
const val WRITE_EXTERNAL_STORAGE = "android.permission.WRITE_EXTERNAL_STORAGE"
object Group {
val CALENDAR = arrayOf(READ_CALENDAR, WRITE_CALENDAR)
val CAMERA = arrayOf(Permissions.CAMERA)
val CONTACTS = arrayOf(READ_CONTACTS, WRITE_CONTACTS, GET_ACCOUNTS)
val LOCATION = arrayOf(ACCESS_FINE_LOCATION, ACCESS_COARSE_LOCATION)
val MICROPHONE = arrayOf(RECORD_AUDIO)
val PHONE = arrayOf(
READ_PHONE_STATE,
CALL_PHONE,
READ_CALL_LOG,
WRITE_CALL_LOG,
ADD_VOICEMAIL,
USE_SIP,
PROCESS_OUTGOING_CALLS
)
val SENSORS = arrayOf(BODY_SENSORS)
val SMS = arrayOf(
SEND_SMS,
RECEIVE_SMS,
READ_SMS,
RECEIVE_WAP_PUSH,
RECEIVE_MMS
)
val STORAGE = arrayOf(READ_EXTERNAL_STORAGE, WRITE_EXTERNAL_STORAGE)
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/permission/PermissionsCompat.kt
================================================
package com.kunfei.bookshelf.help.permission
import android.app.Activity
import androidx.annotation.StringRes
import androidx.fragment.app.Fragment
class PermissionsCompat private constructor() {
private var request: Request? = null
fun request() {
RequestManager.pushRequest(request)
}
class Builder {
private val request: Request
constructor(activity: Activity) {
request = Request(activity)
}
constructor(fragment: Fragment) {
request = Request(fragment)
}
fun addPermissions(vararg permissions: String): Builder {
request.addPermissions(*permissions)
return this
}
fun requestCode(requestCode: Int): Builder {
request.setRequestCode(requestCode)
return this
}
fun onGranted(callback: (requestCode: Int) -> Unit): Builder {
request.setOnGrantedCallback(object : OnPermissionsGrantedCallback {
override fun onPermissionsGranted(requestCode: Int) {
callback(requestCode)
}
})
return this
}
fun onDenied(callback: (requestCode: Int, deniedPermissions: Array) -> Unit): Builder {
request.setOnDeniedCallback(object : OnPermissionsDeniedCallback {
override fun onPermissionsDenied(requestCode: Int, deniedPermissions: Array) {
callback(requestCode, deniedPermissions)
}
})
return this
}
fun rationale(rationale: CharSequence): Builder {
request.setRationale(rationale)
return this
}
fun rationale(@StringRes resId: Int): Builder {
request.setRationale(resId)
return this
}
fun build(): PermissionsCompat {
val compat = PermissionsCompat()
compat.request = request
return compat
}
fun request(): PermissionsCompat {
val compat = build()
compat.request = request
compat.request()
return compat
}
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/permission/Request.kt
================================================
package com.kunfei.bookshelf.help.permission
import android.app.Activity
import android.content.Intent
import android.content.pm.PackageManager
import android.os.Build
import androidx.annotation.StringRes
import androidx.appcompat.app.AlertDialog
import androidx.core.content.ContextCompat
import androidx.fragment.app.Fragment
import com.kunfei.bookshelf.R
import org.jetbrains.anko.startActivity
import java.util.*
internal class Request : OnRequestPermissionsResultCallback {
internal val requestTime: Long
private var requestCode: Int = TYPE_REQUEST_PERMISSION
private var source: RequestSource? = null
private var permissions: ArrayList? = null
private var grantedCallback: OnPermissionsGrantedCallback? = null
private var deniedCallback: OnPermissionsDeniedCallback? = null
private var rationaleResId: Int = 0
private var rationale: CharSequence? = null
private var rationaleDialog: AlertDialog? = null
private val deniedPermissions: Array?
get() {
return getDeniedPermissions(this.permissions?.toTypedArray())
}
constructor(activity: Activity) {
source = ActivitySource(activity)
permissions = ArrayList()
requestTime = System.currentTimeMillis()
}
constructor(fragment: Fragment) {
source = FragmentSource(fragment)
permissions = ArrayList()
requestTime = System.currentTimeMillis()
}
fun addPermissions(vararg permissions: String) {
this.permissions?.addAll(Arrays.asList(*permissions))
}
fun setRequestCode(requestCode: Int) {
this.requestCode = requestCode
}
fun setOnGrantedCallback(callback: OnPermissionsGrantedCallback) {
grantedCallback = callback
}
fun setOnDeniedCallback(callback: OnPermissionsDeniedCallback) {
deniedCallback = callback
}
fun setRationale(@StringRes resId: Int) {
rationaleResId = resId
rationale = null
}
fun setRationale(rationale: CharSequence) {
this.rationale = rationale
rationaleResId = 0
}
fun start() {
RequestPlugins.setOnRequestPermissionsCallback(this)
val deniedPermissions = deniedPermissions
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
if (deniedPermissions == null) {
onPermissionsGranted(requestCode)
} else {
val rationale = if (rationaleResId != 0) source?.context?.getText(rationaleResId) else rationale
if (rationale != null) {
showSettingDialog(rationale) { onPermissionsDenied(requestCode, deniedPermissions) }
} else {
onPermissionsDenied(requestCode, deniedPermissions)
}
}
} else {
if (deniedPermissions != null) {
source?.context?.startActivity(
Pair(PermissionActivity.KEY_INPUT_REQUEST_TYPE, TYPE_REQUEST_PERMISSION),
Pair(PermissionActivity.KEY_INPUT_PERMISSIONS_CODE, requestCode),
Pair(PermissionActivity.KEY_INPUT_PERMISSIONS, deniedPermissions)
)
} else {
onPermissionsGranted(requestCode)
}
}
}
fun clear() {
grantedCallback = null
deniedCallback = null
}
private fun getDeniedPermissions(permissions: Array?): Array? {
if (permissions != null) {
val deniedPermissionList = ArrayList()
for (permission in permissions) {
if (source?.context?.let {
ContextCompat.checkSelfPermission(
it,
permission
)
} != PackageManager.PERMISSION_GRANTED
) {
deniedPermissionList.add(permission)
}
}
val size = deniedPermissionList.size
if (size > 0) {
return deniedPermissionList.toTypedArray()
}
}
return null
}
private fun showSettingDialog(rationale: CharSequence, cancel: () -> Unit) {
rationaleDialog?.dismiss()
source?.context?.let {
runCatching {
rationaleDialog = AlertDialog.Builder(it)
.setTitle(R.string.dialog_title)
.setMessage(rationale)
.setPositiveButton(R.string.dialog_setting) { _, _ ->
it.startActivity(
Pair(
PermissionActivity.KEY_INPUT_REQUEST_TYPE,
TYPE_REQUEST_SETTING
)
)
}
.setNegativeButton(R.string.dialog_cancel) { _, _ -> cancel() }
.show()
}
}
}
private fun onPermissionsGranted(requestCode: Int) {
try {
grantedCallback?.onPermissionsGranted(requestCode)
} catch (ignore: Exception) {
}
RequestPlugins.sResultCallback?.onPermissionsGranted(requestCode)
}
private fun onPermissionsDenied(requestCode: Int, deniedPermissions: Array) {
try {
deniedCallback?.onPermissionsDenied(requestCode, deniedPermissions)
} catch (ignore: Exception) {
}
RequestPlugins.sResultCallback?.onPermissionsDenied(requestCode, deniedPermissions)
}
override fun onRequestPermissionsResult(requestCode: Int, permissions: Array, grantResults: IntArray) {
val deniedPermissions = getDeniedPermissions(permissions)
if (deniedPermissions != null) {
val rationale = if (rationaleResId != 0) source?.context?.getText(rationaleResId) else rationale
if (rationale != null) {
showSettingDialog(rationale) { onPermissionsDenied(requestCode, deniedPermissions) }
} else {
onPermissionsDenied(requestCode, deniedPermissions)
}
} else {
onPermissionsGranted(requestCode)
}
}
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
val deniedPermissions = deniedPermissions
if (deniedPermissions == null) {
onPermissionsGranted(this.requestCode)
} else {
onPermissionsDenied(this.requestCode, deniedPermissions)
}
}
companion object {
const val TYPE_REQUEST_PERMISSION = 1
const val TYPE_REQUEST_SETTING = 2
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/permission/RequestManager.kt
================================================
package com.kunfei.bookshelf.help.permission
import android.os.Handler
import android.os.Looper
import java.util.*
internal object RequestManager : OnPermissionsResultCallback {
private var requests: Stack? = null
private var request: Request? = null
private val handler = Handler(Looper.getMainLooper())
private val requestRunnable = Runnable {
request?.start()
}
private val isCurrentRequestInvalid: Boolean
get() = request?.let { System.currentTimeMillis() - it.requestTime > 5 * 1000L } ?: true
init {
RequestPlugins.setOnPermissionsResultCallback(this)
}
fun pushRequest(request: Request?) {
if (request == null) return
if (requests == null) {
requests = Stack()
}
requests?.let {
val index = it.indexOf(request)
if (index >= 0) {
val to = it.size - 1
if (index != to) {
Collections.swap(requests, index, to)
}
} else {
it.push(request)
}
if (!it.empty() && isCurrentRequestInvalid) {
this.request = it.pop()
handler.post(requestRunnable)
}
}
}
private fun startNextRequest() {
request?.clear()
request = null
requests?.let {
request = if (it.empty()) null else it.pop()
request?.let { handler.post(requestRunnable) }
}
}
override fun onPermissionsGranted(requestCode: Int) {
startNextRequest()
}
override fun onPermissionsDenied(requestCode: Int, deniedPermissions: Array) {
startNextRequest()
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/permission/RequestPlugins.kt
================================================
package com.kunfei.bookshelf.help.permission
internal object RequestPlugins {
@Volatile
var sRequestCallback: OnRequestPermissionsResultCallback? = null
@Volatile
var sResultCallback: OnPermissionsResultCallback? = null
fun setOnRequestPermissionsCallback(callback: OnRequestPermissionsResultCallback) {
sRequestCallback = callback
}
fun setOnPermissionsResultCallback(callback: OnPermissionsResultCallback) {
sResultCallback = callback
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/permission/RequestSource.kt
================================================
package com.kunfei.bookshelf.help.permission
import android.content.Context
import android.content.Intent
interface RequestSource {
val context: Context?
fun startActivity(intent: Intent)
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/storage/Backup.kt
================================================
package com.kunfei.bookshelf.help.storage
import android.content.Context
import android.net.Uri
import androidx.documentfile.provider.DocumentFile
import com.kunfei.bookshelf.DbHelper
import com.kunfei.bookshelf.MApplication
import com.kunfei.bookshelf.base.observer.MySingleObserver
import com.kunfei.bookshelf.help.BookshelfHelp
import com.kunfei.bookshelf.help.FileHelp
import com.kunfei.bookshelf.model.BookSourceManager
import com.kunfei.bookshelf.model.ReplaceRuleManager
import com.kunfei.bookshelf.model.TxtChapterRuleManager
import com.kunfei.bookshelf.utils.DocumentUtil
import com.kunfei.bookshelf.utils.FileUtils
import com.kunfei.bookshelf.utils.GSON
import io.reactivex.Single
import io.reactivex.SingleOnSubscribe
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.schedulers.Schedulers
import java.io.File
import java.util.concurrent.TimeUnit
object Backup {
val backupPath = MApplication.getInstance().filesDir.absolutePath + File.separator + "backup"
val defaultPath by lazy {
FileUtils.getSdCardPath() + File.separator + "YueDu"
}
val backupFileNames by lazy {
arrayOf(
"myBookShelf.json",
"myBookSource.json",
"myBookSearchHistory.json",
"myBookReplaceRule.json",
"myTxtChapterRule.json",
"config.xml"
)
}
fun autoBack() {
val lastBackup = MApplication.getConfigPreferences().getLong("lastBackup", 0)
if (System.currentTimeMillis() - lastBackup < TimeUnit.DAYS.toMillis(1)) {
return
}
val path = MApplication.getConfigPreferences().getString("backupPath", defaultPath)
if (path == null) {
backup(MApplication.getInstance(), defaultPath, null, true)
} else {
backup(MApplication.getInstance(), path, null, true)
}
}
fun backup(context: Context, path: String, callBack: CallBack?, isAuto: Boolean = false) {
MApplication.getConfigPreferences().edit().putLong("lastBackup", System.currentTimeMillis()).apply()
Single.create(SingleOnSubscribe { e ->
BookshelfHelp.getAllBook().let {
if (it.isNotEmpty()) {
val json = GSON.toJson(it)
FileHelp.createFileIfNotExist(backupPath + File.separator + "myBookShelf.json").writeText(json)
}
}
BookSourceManager.getAllBookSource().let {
if (it.isNotEmpty()) {
val json = GSON.toJson(it)
FileHelp.createFileIfNotExist(backupPath + File.separator + "myBookSource.json").writeText(json)
}
}
DbHelper.getDaoSession().searchHistoryBeanDao.queryBuilder().list().let {
if (it.isNotEmpty()) {
val json = GSON.toJson(it)
FileHelp.createFileIfNotExist(backupPath + File.separator + "myBookSearchHistory.json")
.writeText(json)
}
}
ReplaceRuleManager.getAll().blockingGet().let {
if (it.isNotEmpty()) {
val json = GSON.toJson(it)
FileHelp.createFileIfNotExist(backupPath + File.separator + "myBookReplaceRule.json").writeText(json)
}
}
TxtChapterRuleManager.getAll().let {
if (it.isNotEmpty()) {
val json = GSON.toJson(it)
FileHelp.createFileIfNotExist(backupPath + File.separator + "myTxtChapterRule.json")
.writeText(json)
}
}
Preferences.getSharedPreferences(context, backupPath, "config")?.let { sp ->
val edit = sp.edit()
MApplication.getConfigPreferences().all.map {
when (val value = it.value) {
is Int -> edit.putInt(it.key, value)
is Boolean -> edit.putBoolean(it.key, value)
is Long -> edit.putLong(it.key, value)
is Float -> edit.putFloat(it.key, value)
is String -> edit.putString(it.key, value)
else -> Unit
}
}
edit.commit()
}
WebDavHelp.backUpWebDav(backupPath)
if (path.isContentPath()) {
copyBackup(context, Uri.parse(path), isAuto)
} else {
copyBackup(path, isAuto)
}
e.onSuccess(true)
}).subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(object : MySingleObserver() {
override fun onSuccess(t: Boolean) {
callBack?.backupSuccess()
}
override fun onError(e: Throwable) {
e.printStackTrace()
callBack?.backupError(e.localizedMessage ?: "ERROR")
}
})
}
@Throws(Exception::class)
private fun copyBackup(context: Context, uri: Uri, isAuto: Boolean) {
synchronized(this) {
DocumentFile.fromTreeUri(context, uri)?.let { treeDoc ->
for (fileName in backupFileNames) {
val file = File(backupPath + File.separator + fileName)
if (file.exists()) {
if (isAuto) {
treeDoc.findFile("auto")?.findFile(fileName)?.delete()
var autoDoc = treeDoc.findFile("auto")
if (autoDoc == null) {
autoDoc = treeDoc.createDirectory("auto")
}
autoDoc?.createFile("", fileName)?.let {
DocumentUtil.writeBytes(context, file.readBytes(), it)
}
} else {
treeDoc.findFile(fileName)?.delete()
treeDoc.createFile("", fileName)?.let {
DocumentUtil.writeBytes(context, file.readBytes(), it)
}
}
}
}
}
}
}
@Throws(java.lang.Exception::class)
private fun copyBackup(path: String, isAuto: Boolean) {
synchronized(this) {
for (fileName in backupFileNames) {
if (isAuto) {
val file = File(backupPath + File.separator + fileName)
if (file.exists()) {
file.copyTo(FileHelp.createFileIfNotExist(path + File.separator + "auto" + File.separator + fileName), true)
}
} else {
val file = File(backupPath + File.separator + fileName)
if (file.exists()) {
file.copyTo(FileHelp.createFileIfNotExist(path + File.separator + fileName), true)
}
}
}
}
}
interface CallBack {
fun backupSuccess()
fun backupError(msg: String)
}
}
================================================
FILE: app/src/main/java/com/kunfei/bookshelf/help/storage/BackupRestoreUi.kt
================================================
package com.kunfei.bookshelf.help.storage
import android.app.Activity
import android.app.Activity.RESULT_OK
import android.content.Intent
import android.net.Uri
import android.os.Build
import android.text.TextUtils
import androidx.core.content.ContextCompat
import androidx.documentfile.provider.DocumentFile
import com.hwangjr.rxbus.RxBus
import com.kunfei.bookshelf.MApplication
import com.kunfei.bookshelf.R
import com.kunfei.bookshelf.base.observer.MySingleObserver
import com.kunfei.bookshelf.constant.RxBusTag
import com.kunfei.bookshelf.help.permission.Permissions
import com.kunfei.bookshelf.help.permission.PermissionsCompat
import com.kunfei.bookshelf.help.storage.WebDavHelp.getWebDavFileNames
import com.kunfei.bookshelf.help.storage.WebDavHelp.showRestoreDialog
import com.kunfei.bookshelf.widget.filepicker.picker.FilePicker
import io.reactivex.Single
import io.reactivex.SingleEmitter
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.schedulers.Schedulers
import org.jetbrains.anko.alert
import org.jetbrains.anko.toast
import java.util.*
object BackupRestoreUi : Backup.CallBack, Restore.CallBack {
private const val backupSelectRequestCode = 22
private const val restoreSelectRequestCode = 33
private fun getBackupPath(): String? {
return MApplication.getConfigPreferences().getString("backupPath", null)
}
private fun setBackupPath(path: String?) {
if (path.isNullOrEmpty()) {
MApplication.getConfigPreferences().edit().remove("backupPath").apply()
} else {
MApplication.getConfigPreferences().edit().putString("backupPath", path).apply()
}
}
override fun backupSuccess() {
MApplication.getInstance().toast(R.string.backup_success)
}
override fun backupError(msg: String) {
MApplication.getInstance().toast(msg)
}
override fun restoreSuccess() {
MApplication.getInstance().toast(R.string.restore_success)
RxBus.get().post(RxBusTag.RECREATE, true)
}
override fun restoreError(msg: String) {
MApplication.getInstance().toast(msg)
}
fun backup(activity: Activity) {
val backupPath = getBackupPath()
if (backupPath.isNullOrEmpty()) {
selectBackupFolder(activity)
} else if (backupPath.isContentPath()) {
val uri = Uri.parse(backupPath)
val doc = DocumentFile.fromTreeUri(activity, uri)
if (doc?.canWrite() == true) {
Backup.backup(activity, backupPath, this)
} else {
selectBackupFolder(activity)
}
} else if (Build.VERSION.SDK_INT > Build.VERSION_CODES.Q) {
selectBackupFolder(activity)
} else {
backupUsePermission(activity)
}
}
private fun backupUsePermission(activity: Activity, path: String = Backup.defaultPath) {
PermissionsCompat.Builder(activity)
.addPermissions(*Permissions.Group.STORAGE)
.rationale(R.string.get_storage_per)
.onGranted {
setBackupPath(path)
Backup.backup(activity, path, this)
}
.request()
}
fun selectBackupFolder(activity: Activity) {
if (Build.VERSION.SDK_INT > Build.VERSION_CODES.Q) {
try {
val intent = Intent(Intent.ACTION_OPEN_DOCUMENT_TREE)
intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
activity.startActivityForResult(intent, backupSelectRequestCode)
} catch (e: java.lang.Exception) {
e.printStackTrace()
activity.toast(e.localizedMessage ?: "ERROR")
}
return
}
activity.alert {
titleResource = R.string.select_folder
items(activity.resources.getStringArray(R.array.select_folder).toList()) { _, index ->
when (index) {
0 -> {
try {
val intent = Intent(Intent.ACTION_OPEN_DOCUMENT_TREE)
intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
activity.startActivityForResult(intent, backupSelectRequestCode)
} catch (e: java.lang.Exception) {
e.printStackTrace()
activity.toast(e.localizedMessage ?: "ERROR")
}
}
1 -> {
PermissionsCompat.Builder(activity)
.addPermissions(*Permissions.Group.STORAGE)
.rationale(R.string.get_storage_per)
.onGranted {
selectBackupFolderApp(activity, false)
}
.request()
}
2 -> {
setBackupPath(Backup.defaultPath)
backupUsePermission(activity)
}
}
}
}.show()
}
private fun selectBackupFolderApp(activity: Activity, isRestore: Boolean) {
val picker = FilePicker(activity, FilePicker.DIRECTORY)
picker.setBackgroundColor(ContextCompat.getColor(activity, R.color.background))
picker.setTopBackgroundColor(ContextCompat.getColor(activity, R.color.background))
picker.setItemHeight(30)
picker.setOnFilePickListener { currentPath: String ->
setBackupPath(currentPath)
if (isRestore) {
Restore.restore(currentPath, this)
} else {
Backup.backup(activity, currentPath, this)
}
}
picker.show()
}
fun restore(activity: Activity) {
Single.create { emitter: SingleEmitter