453 lines
17 KiB
Java
453 lines
17 KiB
Java
package com.cradle.iitc_mobile;
|
|
|
|
import android.annotation.TargetApi;
|
|
import android.app.Activity;
|
|
import android.app.AlertDialog;
|
|
import android.content.ActivityNotFoundException;
|
|
import android.content.DialogInterface;
|
|
import android.content.Intent;
|
|
import android.content.SharedPreferences;
|
|
import android.content.res.AssetManager;
|
|
import android.net.Uri;
|
|
import android.os.Environment;
|
|
import android.os.ParcelFileDescriptor;
|
|
import android.preference.PreferenceManager;
|
|
import android.text.Html;
|
|
import android.util.Base64;
|
|
import android.util.Base64OutputStream;
|
|
import android.webkit.WebResourceResponse;
|
|
import android.widget.Toast;
|
|
|
|
import com.cradle.iitc_mobile.IITC_Mobile.ResponseHandler;
|
|
|
|
import org.json.JSONObject;
|
|
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.OutputStream;
|
|
import java.io.PipedInputStream;
|
|
import java.io.PipedOutputStream;
|
|
import java.net.URL;
|
|
import java.net.URLConnection;
|
|
import java.net.URLEncoder;
|
|
import java.util.HashMap;
|
|
|
|
public class IITC_FileManager {
|
|
private static final WebResourceResponse EMPTY =
|
|
new WebResourceResponse("text/plain", "UTF-8", new ByteArrayInputStream("".getBytes()));
|
|
private static final String WRAPPER_NEW = "wrapper(info);";
|
|
private static final String WRAPPER_OLD =
|
|
"script.appendChild(document.createTextNode('('+ wrapper +')('+JSON.stringify(info)+');'));\n"
|
|
+ "(document.body || document.head || document.documentElement).appendChild(script);";
|
|
|
|
public static final String DOMAIN = ".iitcm.localhost";
|
|
|
|
/**
|
|
* copies the contents of a stream into another stream and (optionally) closes the output stream afterwards
|
|
*
|
|
* @param inStream
|
|
* the stream to read from
|
|
* @param outStream
|
|
* the stream to write to
|
|
* @param closeOutput
|
|
* whether to close the output stream when finished
|
|
*
|
|
* @throws IOException
|
|
*/
|
|
public static void copyStream(final InputStream inStream, final OutputStream outStream, final boolean closeOutput)
|
|
throws IOException
|
|
{
|
|
// in case Android includes Apache commons IO in the future, this function should be replaced by IOUtils.copy
|
|
final int bufferSize = 4096;
|
|
final byte[] buffer = new byte[bufferSize];
|
|
int len = 0;
|
|
|
|
try {
|
|
while ((len = inStream.read(buffer)) != -1) {
|
|
outStream.write(buffer, 0, len);
|
|
}
|
|
} finally {
|
|
if (outStream != null && closeOutput)
|
|
outStream.close();
|
|
}
|
|
}
|
|
|
|
public static HashMap<String, String> getScriptInfo(final String js) {
|
|
final HashMap<String, String> map = new HashMap<String, String>();
|
|
String header = "";
|
|
if (js != null && js.contains("==UserScript==") && js.contains("==/UserScript==")) {
|
|
header = js.substring(js.indexOf("==UserScript=="),
|
|
js.indexOf("==/UserScript=="));
|
|
}
|
|
// remove new line comments
|
|
header = header.replace("\n//", " ");
|
|
// get a list of key-value
|
|
final String[] attributes = header.split(" +");
|
|
// add default values
|
|
map.put("id", "unknown");
|
|
map.put("version", "not found");
|
|
map.put("name", "unknown");
|
|
map.put("description", "");
|
|
map.put("category", "Misc");
|
|
// add parsed values
|
|
for (int i = 0; i < attributes.length; i++) {
|
|
// search for attributes and use the value
|
|
if (attributes[i].equals("@id")) {
|
|
map.put("id", attributes[i + 1]);
|
|
}
|
|
if (attributes[i].equals("@version")) {
|
|
map.put("version", attributes[i + 1]);
|
|
}
|
|
if (attributes[i].equals("@name")) {
|
|
map.put("name", attributes[i + 1]);
|
|
}
|
|
if (attributes[i].equals("@description")) {
|
|
map.put("description", attributes[i + 1]);
|
|
}
|
|
if (attributes[i].equals("@category")) {
|
|
map.put("category", attributes[i + 1]);
|
|
}
|
|
}
|
|
return map;
|
|
}
|
|
|
|
public static String readStream(final InputStream stream) {
|
|
final ByteArrayOutputStream os = new ByteArrayOutputStream();
|
|
|
|
try {
|
|
copyStream(stream, os, true);
|
|
} catch (final IOException e) {
|
|
Log.w(e);
|
|
return "";
|
|
}
|
|
return os.toString();
|
|
}
|
|
|
|
private final AssetManager mAssetManager;
|
|
private final Activity mActivity;
|
|
private final String mIitcPath;
|
|
private final SharedPreferences mPrefs;
|
|
public static final String PLUGINS_PATH = Environment.getExternalStorageDirectory().getPath()
|
|
+ "/IITC_Mobile/plugins/";
|
|
|
|
public IITC_FileManager(final Activity activity) {
|
|
mActivity = activity;
|
|
mIitcPath = Environment.getExternalStorageDirectory().getPath() + "/Activity/";
|
|
mPrefs = PreferenceManager.getDefaultSharedPreferences(activity);
|
|
mAssetManager = mActivity.getAssets();
|
|
}
|
|
|
|
private InputStream getAssetFile(final String filename) throws IOException {
|
|
if (mPrefs.getBoolean("pref_dev_checkbox", false)) {
|
|
final File file = new File(mIitcPath + "dev/" + filename);
|
|
try {
|
|
return new FileInputStream(file);
|
|
} catch (final FileNotFoundException e) {
|
|
mActivity.runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
Toast.makeText(mActivity, "File " + mIitcPath +
|
|
"dev/" + filename + " not found. " +
|
|
"Disable developer mode or add iitc files to the dev folder.",
|
|
Toast.LENGTH_SHORT).show();
|
|
}
|
|
});
|
|
Log.w(e);
|
|
}
|
|
}
|
|
|
|
// load plugins from asset folder
|
|
return mAssetManager.open(filename);
|
|
}
|
|
|
|
private WebResourceResponse getFileRequest(final Uri uri) {
|
|
return new FileRequest(uri);
|
|
}
|
|
|
|
private WebResourceResponse getScript(final Uri uri) {
|
|
InputStream stream;
|
|
try {
|
|
stream = getAssetFile(uri.getPath().substring(1));
|
|
} catch (final IOException e) {
|
|
Log.w(e);
|
|
return EMPTY;
|
|
}
|
|
|
|
final InputStream data = prepareUserScript(stream);
|
|
|
|
return new WebResourceResponse("application/x-javascript", "UTF-8", data);
|
|
}
|
|
|
|
private HashMap<String, String> getScriptInfo(final InputStream stream) {
|
|
return getScriptInfo(readStream(stream));
|
|
}
|
|
|
|
private WebResourceResponse getUserPlugin(final Uri uri) {
|
|
if (!mPrefs.getBoolean(uri.getPath(), false)) {
|
|
Log.e("Attempted to inject user script that is not enabled by user: " + uri.getPath());
|
|
return EMPTY;
|
|
}
|
|
|
|
InputStream stream;
|
|
try {
|
|
stream = new FileInputStream(new File(uri.getPath()));
|
|
} catch (final IOException e) {
|
|
Log.w(e);
|
|
return EMPTY;
|
|
}
|
|
|
|
final InputStream data = prepareUserScript(stream);
|
|
|
|
return new WebResourceResponse("application/x-javascript", "UTF-8", data);
|
|
}
|
|
|
|
private InputStream prepareUserScript(final InputStream stream) {
|
|
String content = readStream(stream);
|
|
final HashMap<String, String> info = getScriptInfo(content);
|
|
|
|
final JSONObject jObject = new JSONObject(info);
|
|
final String gmInfo = "var GM_info={\"script\":" + jObject.toString() + "}";
|
|
|
|
content = content.replace(WRAPPER_OLD, WRAPPER_NEW);
|
|
|
|
return new ByteArrayInputStream((gmInfo + content).getBytes());
|
|
}
|
|
|
|
public String getFileRequestPrefix() {
|
|
return "//file-request" + DOMAIN + "/";
|
|
}
|
|
|
|
public String getIITCVersion() throws IOException {
|
|
final InputStream stream = getAssetFile("total-conversion-build.user.js");
|
|
|
|
return getScriptInfo(stream).get("version");
|
|
}
|
|
|
|
public WebResourceResponse getResponse(final Uri uri) {
|
|
String host = uri.getHost();
|
|
if (!host.endsWith(DOMAIN))
|
|
return EMPTY;
|
|
|
|
host = host.substring(0, host.length() - DOMAIN.length());
|
|
|
|
if ("script".equals(host))
|
|
return getScript(uri);
|
|
if ("user-plugin".equals(host))
|
|
return getUserPlugin(uri);
|
|
if ("file-request".equals(host))
|
|
return getFileRequest(uri);
|
|
|
|
Log.e("could not generate response for url: " + uri);
|
|
return EMPTY;
|
|
}
|
|
|
|
public void installPlugin(final Uri uri, final boolean invalidateHeaders) {
|
|
if (uri != null) {
|
|
String text = mActivity.getString(R.string.install_dialog_msg);
|
|
text = String.format(text, uri);
|
|
|
|
// create alert dialog
|
|
new AlertDialog.Builder(mActivity)
|
|
.setTitle(mActivity.getString(R.string.install_dialog_top))
|
|
.setMessage(Html.fromHtml(text))
|
|
.setCancelable(true)
|
|
.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
|
|
@Override
|
|
public void onClick(final DialogInterface dialog, final int which) {
|
|
copyPlugin(uri, invalidateHeaders);
|
|
}
|
|
})
|
|
.setNegativeButton("No", new DialogInterface.OnClickListener() {
|
|
@Override
|
|
public void onClick(final DialogInterface dialog, final int which) {
|
|
dialog.cancel();
|
|
}
|
|
})
|
|
.create()
|
|
.show();
|
|
}
|
|
}
|
|
|
|
private void copyPlugin(final Uri uri, final boolean invalidateHeaders) {
|
|
final Thread thread = new Thread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
try {
|
|
final String url = uri.toString();
|
|
InputStream is;
|
|
String fileName;
|
|
if (uri.getScheme().contains("http")) {
|
|
URLConnection conn = new URL(url).openConnection();
|
|
is = conn.getInputStream();
|
|
fileName = uri.getLastPathSegment();
|
|
} else {
|
|
// we need 2 streams since an inputStream is useless after read once
|
|
// we read it twice because we first need the script ID for the fileName and
|
|
// afterwards reading it again while copying
|
|
is = mActivity.getContentResolver().openInputStream(uri);
|
|
final InputStream isCopy = mActivity.getContentResolver().openInputStream(uri);
|
|
fileName = getScriptInfo(isCopy).get("id") + ".user.js";
|
|
}
|
|
// create IITCm external plugins directory if it doesn't already exist
|
|
final File pluginsDirectory = new File(PLUGINS_PATH);
|
|
pluginsDirectory.mkdirs();
|
|
|
|
// create in and out streams and copy plugin
|
|
final File outFile = new File(pluginsDirectory, fileName);
|
|
final OutputStream os = new FileOutputStream(outFile);
|
|
IITC_FileManager.copyStream(is, os, true);
|
|
} catch (final IOException e) {
|
|
Log.w(e);
|
|
}
|
|
}
|
|
});
|
|
thread.start();
|
|
if (invalidateHeaders) {
|
|
try {
|
|
thread.join();
|
|
((IITC_PluginPreferenceActivity) mActivity).invalidateHeaders();
|
|
} catch (final InterruptedException e) {
|
|
Log.w(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
private class FileRequest extends WebResourceResponse implements ResponseHandler, Runnable {
|
|
private Intent mData;
|
|
private final String mFunctionName;
|
|
private int mResultCode;
|
|
private PipedOutputStream mStreamOut;
|
|
|
|
private FileRequest(final Uri uri) {
|
|
// create two connected streams we can write to after the file has been read
|
|
super("application/x-javascript", "UTF-8", new PipedInputStream());
|
|
|
|
try {
|
|
mStreamOut = new PipedOutputStream((PipedInputStream) getData());
|
|
} catch (final IOException e) {
|
|
Log.w(e);
|
|
}
|
|
|
|
// the function to call
|
|
mFunctionName = uri.getPathSegments().get(0);
|
|
|
|
// create the chooser Intent
|
|
final Intent target = new Intent(Intent.ACTION_GET_CONTENT)
|
|
.setType("*/*")
|
|
.addCategory(Intent.CATEGORY_OPENABLE);
|
|
final IITC_Mobile iitc = (IITC_Mobile) mActivity;
|
|
|
|
try {
|
|
iitc.startActivityForResult(Intent.createChooser(target, "Choose file"), this);
|
|
} catch (final ActivityNotFoundException e) {
|
|
Toast.makeText(mActivity, "No activity to select a file found." +
|
|
"Please install a file browser of your choice!", Toast.LENGTH_LONG).show();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onActivityResult(final int resultCode, final Intent data) {
|
|
final IITC_Mobile iitc = (IITC_Mobile) mActivity;
|
|
iitc.deleteResponseHandler(this); // to enable garbage collection
|
|
|
|
mResultCode = resultCode;
|
|
mData = data;
|
|
|
|
// read file in new thread using Runnable interface, see run()
|
|
new Thread(this, "FileRequestReader").start();
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
try {
|
|
if (mResultCode == Activity.RESULT_OK && mData != null) {
|
|
final Uri uri = mData.getData();
|
|
|
|
// now create a resource that basically looks like:
|
|
// someFunctionName('<url encoded filename>', '<base64 encoded content>');
|
|
|
|
final String filename = uri.getLastPathSegment();
|
|
final String call = mFunctionName + "('" + URLEncoder.encode(filename, "UTF-8") + "', '";
|
|
mStreamOut.write(call.getBytes());
|
|
|
|
final Base64OutputStream encoder =
|
|
new Base64OutputStream(mStreamOut, Base64.NO_CLOSE | Base64.NO_WRAP | Base64.DEFAULT);
|
|
|
|
final InputStream fileinput = mActivity.getContentResolver().openInputStream(uri);
|
|
|
|
copyStream(fileinput, encoder, true);
|
|
|
|
mStreamOut.write("');".getBytes());
|
|
}
|
|
|
|
} catch (final IOException e) {
|
|
Log.w(e);
|
|
} finally {
|
|
// try to close stream, but ignore errors
|
|
try {
|
|
mStreamOut.close();
|
|
} catch (final IOException e1) {
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@TargetApi(19)
|
|
public class FileSaveRequest implements ResponseHandler, Runnable {
|
|
private Intent mData;
|
|
private final IITC_Mobile mIitc;
|
|
private final String mContent;
|
|
|
|
public FileSaveRequest(final String filename, final String type, final String content) {
|
|
final Intent intent = new Intent(Intent.ACTION_CREATE_DOCUMENT)
|
|
.setType(type)
|
|
.addCategory(Intent.CATEGORY_OPENABLE)
|
|
.putExtra(Intent.EXTRA_TITLE, filename);
|
|
|
|
mContent = content;
|
|
mIitc = (IITC_Mobile) mActivity;
|
|
mIitc.startActivityForResult(intent, this);
|
|
}
|
|
|
|
@Override
|
|
public void onActivityResult(final int resultCode, final Intent data) {
|
|
mIitc.deleteResponseHandler(this);
|
|
|
|
if (resultCode != Activity.RESULT_OK) return;
|
|
|
|
mData = data;
|
|
|
|
new Thread(this, "FileSaveRequest").start();
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
if (mData == null) return;
|
|
|
|
final Uri uri = mData.getData();
|
|
OutputStream os = null;
|
|
|
|
try {
|
|
final ParcelFileDescriptor fd = mIitc.getContentResolver().openFileDescriptor(uri, "w");
|
|
|
|
try {
|
|
os = new FileOutputStream(fd.getFileDescriptor());
|
|
os.write(mContent.getBytes());
|
|
os.close();
|
|
} catch (final IOException e) {
|
|
Log.w("Could not save file!", e);
|
|
}
|
|
fd.close();
|
|
} catch (final IOException e) {
|
|
Log.w("Could not save file!", e);
|
|
}
|
|
}
|
|
}
|
|
}
|