/**
* The entire purpose of this function is to recover the issues that were in the old version of
* the library and then to delete the remaining file when we are done with it. A user should never
* need to call this function, this gets automatically run for them in {@link
* Api#init(android.app.Application)}.
*/
public void recoverOldIssues() {
Log.d(TAG, "Attempting to recover old feeback for the benefit of the user.");
FileInputStream oldCacheFile = null;
try {
// Load the old data from a file
oldCacheFile = context.openFileInput(OLD_ISSUES_CACHE_FILE);
final String oldIssuesWithCommentsJSON = IOUtils.toString(oldCacheFile);
// Parse the Data - The old json save contained IssuesWithComments
final IssuesWithComments oldIssues =
new IssueParser(TAG).parseIssues(oldIssuesWithCommentsJSON);
// Save the data in the new database.
for (Issue issue : oldIssues.issues()) {
addCreatedIssue(issue);
}
} catch (FileNotFoundException e) {
Log.i(
TAG,
"There was no old version of the issues cache lying around. Don't need to recover anything.");
} catch (IOException e) {
Log.i(TAG, "Encountered problems handling the old cache file", e);
} finally {
if (oldCacheFile != null) {
try {
oldCacheFile.close();
oldCacheFile = null;
} catch (IOException e) {
Log.wtf(TAG, "Could not close a file that we already had opened.", e);
}
// Remove the file now that we are done with it.
context.deleteFile(OLD_ISSUES_CACHE_FILE);
}
}
}
public void downloadFile() {
try {
// get the URL
URL url = new URL(URL_STRING);
// get the input stream
InputStream in = url.openStream();
context.deleteFile(FILENAME);
// get the output stream
FileOutputStream out = context.openFileOutput(FILENAME, Context.MODE_PRIVATE);
// read input and write output
byte[] buffer = new byte[1024];
int bytesRead = in.read(buffer);
while (bytesRead != -1) {
out.write(buffer, 0, bytesRead);
bytesRead = in.read(buffer);
}
out.close();
in.close();
} catch (IOException e) {
Log.e("News reader", e.toString());
}
}
/**
* Delete the wishlist
*
* @param mCtx A context to open the file wish
*/
public static void ResetCards(Context mCtx) {
String[] files = mCtx.fileList();
for (String fileName : files) {
if (fileName.equals(WISHLIST_NAME)) {
mCtx.deleteFile(fileName);
}
}
}
/**
* Remove a pre-loaded icon from the persistent icon cache.
*
* @param componentName the component that should own the icon
*/
public void deletePreloadedIcon(ComponentName componentName, UserHandleCompat user) {
// We don't keep icons for other profiles in persistent cache.
if (!user.equals(UserHandleCompat.myUserHandle()) || componentName == null) {
return;
}
remove(componentName, user);
boolean success = mContext.deleteFile(getResourceFilename(componentName));
if (DEBUG && success) Log.d(TAG, "removed pre-loaded icon from persistent cache");
}
public void remove() {
String storageMode = getStorageMode();
if (storageMode.equals("internal") || storageMode.equals("")) {
context.deleteFile(this.fileName);
} else if (storageMode.equals("sdcard")) {
File root = Environment.getExternalStorageDirectory();
File morgDir = new File(root, "mobileorg");
File morgFile = new File(morgDir, this.fileName);
morgFile.delete();
}
}
/**
* remove the auth token variables securely
*
* @param context
*/
public static void clear(Context context) {
try {
String filename = getAccessTokenFilename(context.getApplicationContext());
context.deleteFile(filename);
Log.v(
AppBlade.LogTag, String.format("RemoteAuthHelper.clear (delete file) path:%s", filename));
AppBlade.setDeviceId(null);
} catch (Exception ex) {
Log.w(AppBlade.LogTag, "RemoteAuthHelper clear ", ex);
}
}
/**
* Creates a empty database on the system and rewrites it with your own database.
*
* @throws java.io.IOException io exception
*/
private void createDataBase() throws IOException {
try {
if (!isDatabaseUpdated()) {
if (mDataBase != null) close();
context.deleteFile(DB_NAME);
copyDataBase();
}
} catch (Exception e) {
e.printStackTrace();
}
openDataBase();
}
/**
* Remove Firefox account persisted to disk.
*
* @param context Android context.
* @param filename name of persisted pickle file; must not contain path separators.
* @return <code>true</code> if given pickle existed and was successfully deleted.
*/
public static boolean deletePickle(final Context context, final String filename) {
return context.deleteFile(filename);
}
// Do an update from the given repo. All applications found, and their
// APKs, are added to 'apps'. (If 'apps' already contains an app, its
// APKs are merged into the existing one).
// Returns null if successful, otherwise an error message to be displayed
// to the user (if there is an interactive user!)
// 'newetag' should be passed empty. On success, it may contain an etag
// value for the index that was successfully processed, or it may contain
// null if none was available.
public static String doUpdate(
Context ctx,
DB.Repo repo,
List<DB.App> apps,
StringBuilder newetag,
List<Integer> keeprepos,
ProgressListener progressListener) {
try {
int code = 0;
if (repo.pubkey != null) {
// This is a signed repo - we download the jar file,
// check the signature, and extract the index...
Log.d(
"FDroid",
"Getting signed index from "
+ repo.address
+ " at "
+ logDateFormat.format(new Date(System.currentTimeMillis())));
String address = repo.address + "/index.jar";
PackageManager pm = ctx.getPackageManager();
try {
PackageInfo pi = pm.getPackageInfo(ctx.getPackageName(), 0);
address += "?" + pi.versionName;
} catch (Exception e) {
}
Bundle progressData = createProgressData(repo.address);
ProgressListener.Event event =
new ProgressListener.Event(RepoXMLHandler.PROGRESS_TYPE_DOWNLOAD, progressData);
code =
getRemoteFile(
ctx, address, "tempindex.jar", repo.lastetag, newetag, progressListener, event);
if (code == 200) {
String jarpath = ctx.getFilesDir() + "/tempindex.jar";
JarFile jar = null;
JarEntry je;
Certificate[] certs;
try {
jar = new JarFile(jarpath, true);
je = (JarEntry) jar.getEntry("index.xml");
File efile = new File(ctx.getFilesDir(), "/tempindex.xml");
InputStream input = null;
OutputStream output = null;
try {
input = jar.getInputStream(je);
output = new FileOutputStream(efile);
Utils.copy(input, output);
} finally {
Utils.closeQuietly(output);
Utils.closeQuietly(input);
}
certs = je.getCertificates();
} catch (SecurityException e) {
Log.e("FDroid", "Invalid hash for index file");
return "Invalid hash for index file";
} finally {
if (jar != null) {
jar.close();
}
}
if (certs == null) {
Log.d("FDroid", "No signature found in index");
return "No signature found in index";
}
Log.d(
"FDroid",
"Index has " + certs.length + " signature" + (certs.length > 1 ? "s." : "."));
boolean match = false;
for (Certificate cert : certs) {
String certdata = Hasher.hex(cert.getEncoded());
if (repo.pubkey.equals(certdata)) {
match = true;
break;
}
}
if (!match) {
Log.d("FDroid", "Index signature mismatch");
return "Index signature mismatch";
}
}
} else {
// It's an old-fashioned unsigned repo...
Log.d("FDroid", "Getting unsigned index from " + repo.address);
Bundle eventData = createProgressData(repo.address);
ProgressListener.Event event =
new ProgressListener.Event(RepoXMLHandler.PROGRESS_TYPE_DOWNLOAD, eventData);
code =
getRemoteFile(
ctx,
repo.address + "/index.xml",
"tempindex.xml",
repo.lastetag,
newetag,
progressListener,
event);
}
if (code == 200) {
// Process the index...
SAXParserFactory spf = SAXParserFactory.newInstance();
SAXParser sp = spf.newSAXParser();
XMLReader xr = sp.getXMLReader();
RepoXMLHandler handler = new RepoXMLHandler(repo, apps, progressListener);
xr.setContentHandler(handler);
File tempIndex = new File(ctx.getFilesDir() + "/tempindex.xml");
BufferedReader r = new BufferedReader(new FileReader(tempIndex));
// A bit of a hack, this might return false positives if an apps description
// or some other part of the XML file contains this, but it is a pretty good
// estimate and makes the progress counter more informative.
// As with asking the server about the size of the index before downloading,
// this also has a time tradeoff. It takes about three seconds to iterate
// through the file and count 600 apps on a slow emulator (v17), but if it is
// taking two minutes to update, the three second wait may be worth it.
final String APPLICATION = "<application";
handler.setTotalAppCount(Utils.countSubstringOccurrence(tempIndex, APPLICATION));
InputSource is = new InputSource(r);
xr.parse(is);
if (handler.pubkey != null && repo.pubkey == null) {
// We read an unsigned index, but that indicates that
// a signed version is now available...
Log.d("FDroid", "Public key found - switching to signed repo for future updates");
repo.pubkey = handler.pubkey;
try {
DB db = DB.getDB();
db.updateRepoByAddress(repo);
} finally {
DB.releaseDB();
}
}
} else if (code == 304) {
// The index is unchanged since we last read it. We just mark
// everything that came from this repo as being updated.
Log.d("FDroid", "Repo index for " + repo.address + " is up to date (by etag)");
keeprepos.add(repo.id);
// Make sure we give back the same etag. (The 200 route will
// have supplied a new one.
newetag.append(repo.lastetag);
} else {
return "Failed to read index - HTTP response " + Integer.toString(code);
}
} catch (SSLHandshakeException sslex) {
Log.e(
"FDroid",
"SSLHandShakeException updating from "
+ repo.address
+ ":\n"
+ Log.getStackTraceString(sslex));
return "A problem occurred while establishing an SSL connection. If this problem persists, AND you have a very old device, you could try using http instead of https for the repo URL.";
} catch (Exception e) {
Log.e(
"FDroid", "Exception updating from " + repo.address + ":\n" + Log.getStackTraceString(e));
return "Failed to update - " + e.getMessage();
} finally {
ctx.deleteFile("tempindex.xml");
ctx.deleteFile("tempindex.jar");
}
return null;
}
private void removeFileFromDisk(BLASTQuery query) {
if (context.deleteFile(query.getJobIdentifier() + ".xml")) {
Log.i(TAG, "BLAST hits file deleted");
}
}
public void tearDown() {
context.deleteFile(db_file);
}
public void delete() {
mContext.deleteFile(FILE_NAME);
}
/**
* This method can be used to unpack a binary from the raw resources folder and store it in
* /data/data/app.package/files/ This is typically useful if you provide your own C- or C++-based
* binary. This binary can then be executed using sendShell() and its full path.
*
* @param sourceId resource id; typically <code>R.raw.id</code>
* @param destName destination file name; appended to /data/data/app.package/files/
* @param mode chmod value for this file
* @return a <code>boolean</code> which indicates whether or not we were able to create the new
* file.
*/
protected boolean installBinary(int sourceId, String destName, String mode) {
File mf = new File(filesPath + File.separator + destName);
if (!mf.exists()) {
// First, does our files/ directory even exist?
// We cannot wait for android to lazily create it as we will soon
// need it.
try {
FileInputStream fis = context.openFileInput(BOGUS_FILE_NAME);
fis.close();
} catch (FileNotFoundException e) {
FileOutputStream fos = null;
try {
fos = context.openFileOutput("bogus", Context.MODE_PRIVATE);
fos.write("justcreatedfilesdirectory".getBytes());
} catch (Exception ex) {
if (RootTools.debugMode) {
Log.e(LOG_TAG, ex.toString());
}
return false;
} finally {
if (null != fos) {
try {
fos.close();
context.deleteFile(BOGUS_FILE_NAME);
} catch (IOException e1) {
}
}
}
} catch (IOException ex) {
if (RootTools.debugMode) {
Log.e(LOG_TAG, ex.toString());
}
return false;
}
// Only now can we start creating our actual file
InputStream iss = context.getResources().openRawResource(sourceId);
FileOutputStream oss = null;
try {
oss = new FileOutputStream(mf);
byte[] buffer = new byte[4096];
int len;
try {
while (-1 != (len = iss.read(buffer))) {
oss.write(buffer, 0, len);
}
} catch (IOException ex) {
if (RootTools.debugMode) {
Log.e(LOG_TAG, ex.toString());
}
return false;
}
} catch (FileNotFoundException ex) {
if (RootTools.debugMode) {
Log.e(LOG_TAG, ex.toString());
}
return false;
} finally {
if (oss != null) {
try {
oss.close();
} catch (IOException e) {
}
}
}
try {
iss.close();
} catch (IOException ex) {
if (RootTools.debugMode) {
Log.e(LOG_TAG, ex.toString());
}
return false;
}
try {
CommandCapture command =
new CommandCapture(0, "chmod " + mode + " " + filesPath + File.separator + destName);
Shell.startRootShell().add(command);
command.waitForFinish();
} catch (Exception e) {
}
}
return true;
}
public static boolean deletePlan(Context c, String name) {
return c.deleteFile(name);
}
public void clearPersistentCache(Context ctx) {
Log.w(TAG, "Deleting old Breadcrumbs cache files");
synchronized (BREADCRUMSB_BUNDLES_CACHE_FILE) {
ctx.deleteFile(BREADCRUMSB_ACTIVITY_CACHE_FILE);
ctx.deleteFile(BREADCRUMSB_BUNDLES_CACHE_FILE);
}
}