Example usage for android.support.v4.content ContextCompat getExternalCacheDirs

List of usage examples for android.support.v4.content ContextCompat getExternalCacheDirs

Introduction

In this page you can find the example usage for android.support.v4.content ContextCompat getExternalCacheDirs.

Prototype

public static File[] getExternalCacheDirs(Context context) 

Source Link

Usage

From source file:Main.java

public static File makeTmpFile(Context context, String prefix, String suffix) {
    File tmpOutFile = null;/*from w w  w.  j  a va2 s .  c om*/
    try {
        //            File dir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);
        File dir = ContextCompat.getExternalCacheDirs(context)[0];
        tmpOutFile = File.createTempFile(prefix, suffix, dir);
    } catch (Exception ex) {
        ex.printStackTrace();
    }
    return tmpOutFile;
}

From source file:org.goodev.droidddle.utils.IOUtil.java

public static File getBestAvailableCacheRoot(Context context) {
    File[] roots = ContextCompat.getExternalCacheDirs(context);
    if (roots != null) {
        for (File root : roots) {
            if (root == null) {
                continue;
            }/*from  w ww.  j a va 2 s.  c  o m*/

            if (Environment.MEDIA_MOUNTED.equals(EnvironmentCompat.getStorageState(root))) {
                return root;
            }
        }
    }

    // Worst case, resort to internal storage
    return context.getCacheDir();
}

From source file:com.android.exchange.adapter.ProvisionParser.java

/**
 * In order to determine whether the device has removable storage, we need to use the
 * StorageVolume class, which is hidden (for now) by the framework.  Without this, we'd have
 * to reject all policies that require sd card encryption.
 *
 * TODO: Rewrite this when an appropriate API is available from the framework
 *//*  w ww. ja  v a  2 s .c  o  m*/
private boolean hasRemovableStorage() {
    final File[] cacheDirs = ContextCompat.getExternalCacheDirs(mContext);
    return Environment.isExternalStorageRemovable() || (cacheDirs != null && cacheDirs.length > 1);
}

From source file:com.hippo.content.FileProvider.java

/**
 * Parse and return {@link PathStrategy} for given authority as defined in
 * {@link #META_DATA_FILE_PROVIDER_PATHS} {@code <meta-data>}.
 *
 * @see #getPathStrategy(Context, String)
 *//*from  w  w  w  . java2  s  .c  o m*/
private static PathStrategy parsePathStrategy(Context context, String authority)
        throws IOException, XmlPullParserException {
    final SimplePathStrategy strat = new SimplePathStrategy(authority);

    final ProviderInfo info = context.getPackageManager().resolveContentProvider(authority,
            PackageManager.GET_META_DATA);
    final XmlResourceParser in = info.loadXmlMetaData(context.getPackageManager(),
            META_DATA_FILE_PROVIDER_PATHS);
    if (in == null) {
        throw new IllegalArgumentException("Missing " + META_DATA_FILE_PROVIDER_PATHS + " meta-data");
    }

    int type;
    while ((type = in.next()) != END_DOCUMENT) {
        if (type == START_TAG) {
            final String tag = in.getName();

            final String name = in.getAttributeValue(null, ATTR_NAME);
            String path = in.getAttributeValue(null, ATTR_PATH);

            File target = null;
            if (TAG_ROOT_PATH.equals(tag)) {
                target = DEVICE_ROOT;
            } else if (TAG_FILES_PATH.equals(tag)) {
                target = context.getFilesDir();
            } else if (TAG_CACHE_PATH.equals(tag)) {
                target = context.getCacheDir();
            } else if (TAG_EXTERNAL.equals(tag)) {
                target = Environment.getExternalStorageDirectory();
            } else if (TAG_EXTERNAL_FILES.equals(tag)) {
                File[] externalFilesDirs = ContextCompat.getExternalFilesDirs(context, null);
                if (externalFilesDirs.length > 0) {
                    target = externalFilesDirs[0];
                }
            } else if (TAG_EXTERNAL_CACHE.equals(tag)) {
                File[] externalCacheDirs = ContextCompat.getExternalCacheDirs(context);
                if (externalCacheDirs.length > 0) {
                    target = externalCacheDirs[0];
                }
            }

            if (target != null) {
                strat.addRoot(name, buildPath(target, path));
            }
        }
    }

    return strat;
}

From source file:net.zorgblub.typhon.Configuration.java

public Option<File> getTTSFolder() {
    return firstOption(asList(ContextCompat.getExternalCacheDirs(context)));
}

From source file:de.cachebox_test.splash.java

private String getExternalSdPath(String Folder) {

    // check if Layout forced from User
    workPath = Environment.getExternalStorageDirectory() + Folder;

    // extract first part of path ("/mnt/" or "/storage/" ...)
    int pos = workPath.indexOf("/", 2); // search for the second /
    String prev = "/mnt";
    if (pos > 0) {
        prev = workPath.substring(0, pos);
    }//  www. jav a2s .c  om
    // search for an external SD-Card
    String externalSd = "";

    // search for an external sd card on different devices

    if ((externalSd = testExtSdPath(prev + "/extSdCard")) != null) {
        externalSd += Folder;
    } else if ((externalSd = testExtSdPath(prev + "/MicroSD")) != null) {
        externalSd += Folder;
    } else if ((externalSd = testExtSdPath(prev + "/ext_sdcard")) != null) {
        externalSd += Folder;
    } else if ((externalSd = testExtSdPath(prev + "/sdcard/ext_sd")) != null) {
        externalSd += Folder;
    } else if ((externalSd = testExtSdPath(prev + "/ext_card")) != null) {
        // Sony Xperia sola
        externalSd += Folder;
    } else if ((externalSd = testExtSdPath(prev + "/external")) != null) {
        externalSd += Folder;
    } else if ((externalSd = testExtSdPath(prev + "/sdcard2")) != null) {
        externalSd += Folder;
    } else if ((externalSd = testExtSdPath(prev + "/sdcard1")) != null) {
        externalSd += Folder;
    } else if ((externalSd = testExtSdPath(prev + "/sdcard/_ExternalSD")) != null) {
        externalSd += Folder;
    } else if ((externalSd = testExtSdPath(prev + "/sdcard-ext")) != null) {
        externalSd += Folder;
    } else if ((externalSd = testExtSdPath(prev + "/external1")) != null) {
        externalSd += Folder;
    } else if ((externalSd = testExtSdPath(prev + "/sdcard/external_sd")) != null) {
        externalSd += Folder;
    } else if ((externalSd = testExtSdPath(prev + "/emmc")) != null) {
        // for CM9
        externalSd += Folder;
    } else if ((externalSd = testExtSdPath("/Removable/MicroSD")) != null) {
        // Asus Transformer
        externalSd += Folder;
    } else if ((externalSd = testExtSdPath("/mnt/ext_sd")) != null) {
        // ODYS Motion
        externalSd += Folder;
    } else if ((externalSd = testExtSdPath("/sdcard/tflash")) != null) {
        // Car Radio
        externalSd += Folder;
    } else if ((externalSd = testExtSdPath(prev + "/sdcard")) != null) {
        // on some devices it is possible that the SD-Card reported by getExternalStorageDirectory() is the extSd and the real
        // external SD is /mnt/sdcard (Faktor2 Tablet!!!)
        externalSd += Folder;
    } else if ((externalSd = testExtSdPath("/mnt/shared/ExtSD")) != null) {
        // GinyMotion Emulator
        externalSd += Folder;
    }

    final java.io.File[] externalCacheDirs = ContextCompat.getExternalCacheDirs(context);
    final List<String> result = new ArrayList<String>();

    for (int i = 1; i < externalCacheDirs.length; ++i) {
        final java.io.File file = externalCacheDirs[i];
        if (file == null)
            continue;
        final String storageState = EnvironmentCompat.getStorageState(file);
        if (Environment.MEDIA_MOUNTED.equals(storageState))
            result.add(getRootOfInnerSdCardFolder(externalCacheDirs[i]));
    }
    if (!result.isEmpty()) {
        externalSd = result.get(0) + Folder;
    }

    if (android.os.Build.VERSION.SDK_INT >= 19) {
        // check for Root permission

        File sandboxPath = null;
        String sandboxParentPath = "";
        try {
            String testFolderName = externalSd + "/Test";

            File testFolder = FileFactory.createFile(testFolderName);

            sandboxParentPath = FileFactory.createFile(externalSd).getParent() + "/Android/data/"
                    + getPackageName();

            sandboxPath = FileFactory.createFile(sandboxParentPath + "/files");

            File test = FileFactory.createFile(testFolder + "/Test.txt");
            testFolder.mkdirs();
            test.createNewFile();
            if (!test.exists()) {
                externalSd = null;
            }
            test.delete();
            testFolder.delete();
        } catch (Exception e) {
            externalSd = null;
        }

        if (externalSd == null && sandboxPath != null) {
            // Check Sandbox Path
            try {
                // create Sandbox folder with getExternalFilesDir(null);
                getExternalFilesDir(null); // FileFactory.createFile(sandboxParentPath).mkdirs(); dosen't work

                String testFolderName = sandboxPath.getAbsolutePath() + File.separator + "Test";

                File testFolder = FileFactory.createFile(testFolderName);
                File test = FileFactory.createFile(testFolderName + File.separator + "Test.txt");
                testFolder.mkdirs();
                test.createNewFile();
                if (!test.exists()) {
                    externalSd = null;
                }
                test.delete();
                testFolder.delete();
                externalSd = sandboxPath.getAbsolutePath();
            } catch (Exception e) {
                e.printStackTrace();
                externalSd = null;
            }
        }
    }

    return externalSd;
}

From source file:com.androzic.Androzic.java

@Override
public File getCacheDir() {
    if (cacheDir != null)
        return cacheDir;

    File[] caches = ContextCompat.getExternalCacheDirs(this);
    cacheDir = caches[0];//from   w w w .ja  v  a  2  s. c  o m
    // Select the first really external (removable) storage if present
    for (int i = 1; i < caches.length; i++) {
        if (caches[i] != null) {
            cacheDir = caches[i];
            break;
        }
    }
    if (cacheDir != null)
        Log.i(TAG, "External cache: " + cacheDir.getAbsolutePath());
    return cacheDir;
}