播放视频的时候 没有做 播放一个 解密一个,在加密上一个
进入播放器解密所有视频文件 离开播放器 加密所有视频文件
如果播放失败 可能加密状态错误 调用cleanLock
SPUtils 是一个保存文字到本地 工具类
Application 全局
public static List<String> songLock = new ArrayList<>(); //加密的儿歌
/**
* 视频文件 下载完成时调用
* 加密单个视频
* @param path
*/
public void lock(String path) {
//判断是否重复加密
if (addList(path)) {
System.out.println("-------------加密该视频");
encrypt(path);
} else {
System.out.println("-------------加密重复");
}
}
/***
* 解密单个视频
*
* @param path
*/
public void openLock(String path) {
//判断是否重复解密
if (deleteList(path)) {
System.out.println("-------------解密该视频");
encrypt(path);
} else {
System.out.println("-------------解密视频未加密");
}
}
/***
* 加密所有文件
* 退出视频播放器的 时候 加密所有本地 文件
*/
public void lockAll() {
System.out.println("--------------全部枷锁");
//获取全部本地路径
//遍历加密每一条本地路径
for () {
lock();
}
}
/***
* 进入播放器 调用 解锁所有本地文件
* 视频播放器 播放的是一个列表文件
* 解锁所有本地文件
*/
public void openLockAll() {
System.out.println("--------------全部解锁");
//获取全部本地路径
//遍历加密每一条本地路径
for () {
openLock();
}
}
/***
* 播放器 播放失败时 调用
* 在视频播放器 播放失败
* 可能这首音乐加解密状态错误(加密状态)
* 在调用一边 取消该视频加密
* 暂时 不加密此视频
*
* @param path
*/
public void cleanLock(String path) {
if (SPUtils.contains(MyApplication.getInstance(), "lock") && SPUtils.getAll(MyApplication.getInstance()).get("lock") != null) {
String str = SPUtils.getAll(MyApplication.getInstance()).get("lock").toString();
MyApplication.songLock.clear();
MyApplication.songLock = StringToList(str);
}
if (MyApplication.songLock.contains(path)) {
MyApplication.songLock.remove(path);
}
encrypt(path);
}
/**
* 加解密
*
* @param strFile 源文件绝对路径
* @return
*/
public boolean encrypt(String strFile) {
final int REVERSE_LENGTH = 100;
int len = REVERSE_LENGTH;
try {
File f = new File(strFile);
RandomAccessFile raf = new RandomAccessFile(f, "rw");
long totalLen = raf.length();
if (totalLen < REVERSE_LENGTH)
len = (int) totalLen;
FileChannel channel = raf.getChannel();
MappedByteBuffer buffer = channel.map(
FileChannel.MapMode.READ_WRITE, 0, REVERSE_LENGTH);
byte tmp;
for (int i = 0; i < len; ++i) {
byte rawByte = buffer.get(i);
tmp = (byte) (rawByte ^ i);
buffer.put(i, tmp);
}
buffer.force();
buffer.clear();
channel.close();
raf.close();
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/***
* 判断当前视频 是否重复加密
* 没加密过 true
* 加密过 false
*
* @param path
* @return
*/
private boolean addList(String path) {
boolean b = false;
if (SPUtils.contains(MyApplication.getInstance(), "lock") && SPUtils.getAll(MyApplication.getInstance()).get("lock") != null) {
String str = SPUtils.getAll(MyApplication.getInstance()).get("lock").toString();
MyApplication.songLock.clear();
MyApplication.songLock = StringToList(str);
}
if (!MyApplication.songLock.contains(path)) {
MyApplication.songLock.add(path);
System.out.println("要保存的是" + listToString(MyApplication.songLock));
SPUtils.put(MyApplication.getInstance(), "lock", listToString(MyApplication.songLock));
b = true;
}
System.out.println("已经加密的数据" + listToString(MyApplication.songLock));
return b;
}
/***
* 当前视频 是否被加密
* 加密 true 可以解密
* 未加密 false
*
* @param path
* @return
*/
private boolean deleteList(String path) {
boolean b = true;
if (SPUtils.contains(MyApplication.getInstance(), "lock") && SPUtils.getAll(MyApplication.getInstance()).get("lock") != null) {
String str = SPUtils.getAll(MyApplication.getInstance()).get("lock").toString();
MyApplication.songLock.clear();
MyApplication.songLock = StringToList(str);
}
if (MyApplication.songLock.contains(path)) {
MyApplication.songLock.remove(path);
SPUtils.put(MyApplication.getInstance(), "lock", listToString(MyApplication.songLock));
b = true;
} else {
b = false;
}
return b;
}
/***
* List转String
*
* @param stringList
* @return
*/
public static String listToString(List<String> stringList) {
if (stringList == null) {
return null;
}
StringBuilder result = new StringBuilder();
boolean flag = false;
for (String string : stringList) {
if (flag) {
result.append(",");
} else {
flag = true;
}
result.append(string);
}
return result.toString();
}
/***
* String 转List
*
* @param s
* @return
*/
public static List<String> StringToList(String s) {
List<String> Slist = new ArrayList<>();
String[] ary = s.split(",");//调用API方法按照逗号分隔字符串
for (String ss : ary) {
Slist.add(ss);
}
return Slist;
}
SPUtils 工具类
public class SPUtils {
/**
* 保存在手机里面的文件名
*/
public static final String FILE_NAME = "share_data";
/**
* 保存数据的方法,我们需要拿到保存数据的具体类型,然后根据类型调用不同的保存方法
*
* @param context
* @param key
* @param object
*/
public static void put(Context context, String key, Object object) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
MODE_PRIVATE);
SharedPreferences.Editor editor = sp.edit();
if (object instanceof String) {
editor.putString(key, (String) object);
} else if (object instanceof Integer) {
editor.putInt(key, (Integer) object);
} else if (object instanceof Boolean) {
editor.putBoolean(key, (Boolean) object);
} else if (object instanceof Float) {
editor.putFloat(key, (Float) object);
} else if (object instanceof Long) {
editor.putLong(key, (Long) object);
} else if (object instanceof Set) {
editor.putStringSet(key, (Set<String>) object);
} else {
editor.putString(key, object.toString());
}
SharedPreferencesCompat.apply(editor);
}
/**
* 得到保存数据的方法,我们根据默认值得到保存的数据的具体类型,然后调用相对于的方法获取值
*
* @param context
* @param key
* @param defaultObject
* @return
*/
public static Object get(Context context, String key, Object defaultObject) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
MODE_PRIVATE);
if (defaultObject instanceof String) {
return sp.getString(key, (String) defaultObject);
} else if (defaultObject instanceof Integer) {
return sp.getInt(key, (Integer) defaultObject);
} else if (defaultObject instanceof Boolean) {
return sp.getBoolean(key, (Boolean) defaultObject);
} else if (defaultObject instanceof Float) {
return sp.getFloat(key, (Float) defaultObject);
} else if (defaultObject instanceof Long) {
return sp.getLong(key, (Long) defaultObject);
} else if (defaultObject == null) {
return sp.getStringSet(key, null);
}
return null;
}
/**
* 移除某个key值已经对应的值
*
* @param context
* @param key
*/
public static void remove(Context context, String key) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
MODE_PRIVATE);
SharedPreferences.Editor editor = sp.edit();
editor.remove(key);
SharedPreferencesCompat.apply(editor);
}
/**
* 清除所有数据
*
* @param context
*/
public static void clear(Context context) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
MODE_PRIVATE);
SharedPreferences.Editor editor = sp.edit();
editor.clear();
SharedPreferencesCompat.apply(editor);
}
/**
* 查询某个key是否已经存在
*
* @param context
* @param key
* @return
*/
public static boolean contains(Context context, String key) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
MODE_PRIVATE);
return sp.contains(key);
}
/**
* 返回所有的键值对
*
* @param context
* @return
*/
public static Map<String, ?> getAll(Context context) {
SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
MODE_PRIVATE);
return sp.getAll();
}
/**
* 创建一个解决SharedPreferencesCompat.apply方法的一个兼容类
*
* @author zhy
*/
private static class SharedPreferencesCompat {
private static final Method sApplyMethod = findApplyMethod();
/**
* 反射查找apply的方法
*
* @return
*/
@SuppressWarnings({"unchecked", "rawtypes"})
private static Method findApplyMethod() {
try {
Class clz = SharedPreferences.Editor.class;
return clz.getMethod("apply");
} catch (NoSuchMethodException e) {
}
return null;
}
/**
* 如果找到则使用apply执行,否则使用commit
*
* @param editor
*/
public static void apply(SharedPreferences.Editor editor) {
try {
if (sApplyMethod != null) {
sApplyMethod.invoke(editor);
return;
}
} catch (IllegalArgumentException e) {
} catch (IllegalAccessException e) {
} catch (InvocationTargetException e) {
}
editor.commit();
}
}
}