Examples with Density com.android.resources.Density used on opensource projects

Example 6 with Density

use of com.android.resources.Density in project android_frameworks_base by AOSPA.

the class ResourceHelper method getDrawable.

/**
     * Returns a drawable from the given value.
     * @param value The value that contains a path to a 9 patch, a bitmap or a xml based drawable,
     * or an hexadecimal color
     * @param context the current context
     * @param theme the theme to be used to inflate the drawable.
     */
public static Drawable getDrawable(ResourceValue value, BridgeContext context, Theme theme) {
    if (value == null) {
        return null;
    }
    String stringValue = value.getValue();
    if (RenderResources.REFERENCE_NULL.equals(stringValue)) {
        return null;
    }
    String lowerCaseValue = stringValue.toLowerCase();
    Density density = Density.MEDIUM;
    if (value instanceof DensityBasedResourceValue) {
        density = ((DensityBasedResourceValue) value).getResourceDensity();
    }
    if (lowerCaseValue.endsWith(NinePatch.EXTENSION_9PATCH)) {
        File file = new File(stringValue);
        if (file.isFile()) {
            try {
                return getNinePatchDrawable(new FileInputStream(file), density, value.isFramework(), stringValue, context);
            } catch (IOException e) {
                // failed to read the file, we'll return null below.
                Bridge.getLog().error(LayoutLog.TAG_RESOURCES_READ, "Failed lot load " + file.getAbsolutePath(), e, null);
            }
        }
        return null;
    } else if (lowerCaseValue.endsWith(".xml")) {
        // create a block parser for the file
        File f = new File(stringValue);
        if (f.isFile()) {
            try {
                // let the framework inflate the Drawable from the XML file.
                XmlPullParser parser = ParserFactory.create(f);
                BridgeXmlBlockParser blockParser = new BridgeXmlBlockParser(parser, context, value.isFramework());
                try {
                    return Drawable.createFromXml(context.getResources(), blockParser, theme);
                } finally {
                    blockParser.ensurePopped();
                }
            } catch (Exception e) {
                // this is an error and not warning since the file existence is checked before
                // attempting to parse it.
                Bridge.getLog().error(null, "Failed to parse file " + stringValue, e, null);
            }
        } else {
            Bridge.getLog().error(LayoutLog.TAG_BROKEN, String.format("File %s does not exist (or is not a file)", stringValue), null);
        }
        return null;
    } else {
        File bmpFile = new File(stringValue);
        if (bmpFile.isFile()) {
            try {
                Bitmap bitmap = Bridge.getCachedBitmap(stringValue, value.isFramework() ? null : context.getProjectKey());
                if (bitmap == null) {
                    bitmap = Bitmap_Delegate.createBitmap(bmpFile, false, /*isMutable*/
                    density);
                    Bridge.setCachedBitmap(stringValue, bitmap, value.isFramework() ? null : context.getProjectKey());
                }
                return new BitmapDrawable(context.getResources(), bitmap);
            } catch (IOException e) {
                // we'll return null below
                Bridge.getLog().error(LayoutLog.TAG_RESOURCES_READ, "Failed lot load " + bmpFile.getAbsolutePath(), e, null);
            }
        } else {
            // attempt to get a color from the value
            try {
                int color = getColor(stringValue);
                return new ColorDrawable(color);
            } catch (NumberFormatException e) {
                // we'll return null below.
                Bridge.getLog().error(LayoutLog.TAG_RESOURCES_FORMAT, "Failed to convert " + stringValue + " into a drawable", e, null);
            }
        }
    }
    return null;
}

Example 7 with Density

use of com.android.resources.Density in project android_frameworks_base by ResurrectionRemix.

the class RenderAction method getConfiguration.

// VisibleForTesting
public static Configuration getConfiguration(RenderParams params) {
    Configuration config = new Configuration();
    HardwareConfig hardwareConfig = params.getHardwareConfig();
    ScreenSize screenSize = hardwareConfig.getScreenSize();
    if (screenSize != null) {
        switch(screenSize) {
            case SMALL:
                config.screenLayout |= Configuration.SCREENLAYOUT_SIZE_SMALL;
                break;
            case NORMAL:
                config.screenLayout |= Configuration.SCREENLAYOUT_SIZE_NORMAL;
                break;
            case LARGE:
                config.screenLayout |= Configuration.SCREENLAYOUT_SIZE_LARGE;
                break;
            case XLARGE:
                config.screenLayout |= Configuration.SCREENLAYOUT_SIZE_XLARGE;
                break;
        }
    }
    Density density = hardwareConfig.getDensity();
    if (density == null) {
        density = Density.MEDIUM;
    }
    config.screenWidthDp = hardwareConfig.getScreenWidth() / density.getDpiValue();
    config.screenHeightDp = hardwareConfig.getScreenHeight() / density.getDpiValue();
    if (config.screenHeightDp < config.screenWidthDp) {
        //noinspection SuspiciousNameCombination
        config.smallestScreenWidthDp = config.screenHeightDp;
    } else {
        config.smallestScreenWidthDp = config.screenWidthDp;
    }
    config.densityDpi = density.getDpiValue();
    // never run in compat mode:
    config.compatScreenWidthDp = config.screenWidthDp;
    config.compatScreenHeightDp = config.screenHeightDp;
    ScreenOrientation orientation = hardwareConfig.getOrientation();
    if (orientation != null) {
        switch(orientation) {
            case PORTRAIT:
                config.orientation = Configuration.ORIENTATION_PORTRAIT;
                break;
            case LANDSCAPE:
                config.orientation = Configuration.ORIENTATION_LANDSCAPE;
                break;
            case SQUARE:
                //noinspection deprecation
                config.orientation = Configuration.ORIENTATION_SQUARE;
                break;
        }
    } else {
        config.orientation = Configuration.ORIENTATION_UNDEFINED;
    }
    ScreenRound roundness = hardwareConfig.getScreenRoundness();
    if (roundness != null) {
        switch(roundness) {
            case ROUND:
                config.screenLayout |= Configuration.SCREENLAYOUT_ROUND_YES;
                break;
            case NOTROUND:
                config.screenLayout |= Configuration.SCREENLAYOUT_ROUND_NO;
        }
    } else {
        config.screenLayout |= Configuration.SCREENLAYOUT_ROUND_UNDEFINED;
    }
    String locale = params.getLocale();
    if (locale != null && !locale.isEmpty())
        config.locale = new Locale(locale);
    return config;
}

Example 8 with Density

use of com.android.resources.Density in project android by JetBrains.

the class PsiResourceItem method getResourceValue.

@Nullable
@Override
public ResourceValue getResourceValue(boolean isFrameworks) {
    if (mResourceValue == null) {
        //noinspection VariableNotUsedInsideIf
        if (myTag == null) {
            // Density based resource value?
            ResourceType type = getType();
            Density density = type == ResourceType.DRAWABLE || type == ResourceType.MIPMAP ? getFolderDensity() : null;
            if (density != null) {
                mResourceValue = new DensityBasedResourceValue(type, getName(), getSource().getFile().getAbsolutePath(), density, isFrameworks, null);
            } else {
                mResourceValue = new ResourceValue(type, getName(), getSource().getFile().getAbsolutePath(), isFrameworks, null);
            }
        } else {
            mResourceValue = parseXmlToResourceValue(isFrameworks);
        }
    }
    return mResourceValue;
}

Example 9 with Density

use of com.android.resources.Density in project android by JetBrains.

the class AvdOptionsModel method calculateInitialVmHeap.

/**
   * Set the initial VM heap size. This is based on the Android CDD minimums for each screen size and density.
   */
@NotNull
private static Storage calculateInitialVmHeap(@NotNull AvdDeviceData deviceData) {
    ScreenSize size = AvdScreenData.getScreenSize(deviceData.diagonalScreenSize().get());
    Density density = AvdScreenData.getScreenDensity(deviceData.isTv().get(), deviceData.screenDpi().get(), deviceData.screenResolutionHeight().get());
    int vmHeapSize = 32;
    if (deviceData.isWear().get()) {
        switch(density) {
            case LOW:
            case ANYDPI:
            case NODPI:
            case MEDIUM:
            case TV:
                vmHeapSize = 32;
                break;
            case HIGH:
            case DPI_280:
                vmHeapSize = 36;
                break;
            case XHIGH:
            case DPI_360:
                vmHeapSize = 48;
                break;
            case DPI_400:
                vmHeapSize = 56;
                break;
            case DPI_420:
                vmHeapSize = 64;
                break;
            case XXHIGH:
                vmHeapSize = 88;
                break;
            case DPI_560:
                vmHeapSize = 112;
                break;
            case XXXHIGH:
                vmHeapSize = 154;
                break;
        }
    } else {
        switch(size) {
            case SMALL:
            case NORMAL:
                switch(density) {
                    case LOW:
                    case ANYDPI:
                    case NODPI:
                    case MEDIUM:
                        vmHeapSize = 32;
                        break;
                    case TV:
                    case HIGH:
                    case DPI_280:
                        vmHeapSize = 48;
                        break;
                    case XHIGH:
                    case DPI_360:
                        vmHeapSize = 80;
                        break;
                    case DPI_400:
                        vmHeapSize = 96;
                        break;
                    case DPI_420:
                        vmHeapSize = 112;
                        break;
                    case XXHIGH:
                        vmHeapSize = 128;
                        break;
                    case DPI_560:
                        vmHeapSize = 192;
                        break;
                    case XXXHIGH:
                        vmHeapSize = 256;
                        break;
                }
                break;
            case LARGE:
                switch(density) {
                    case LOW:
                        vmHeapSize = 32;
                        break;
                    case ANYDPI:
                    case NODPI:
                    case MEDIUM:
                        vmHeapSize = 48;
                        break;
                    case TV:
                    case HIGH:
                        vmHeapSize = 80;
                        break;
                    case DPI_280:
                        vmHeapSize = 96;
                        break;
                    case XHIGH:
                        vmHeapSize = 128;
                        break;
                    case DPI_360:
                        vmHeapSize = 160;
                        break;
                    case DPI_400:
                        vmHeapSize = 192;
                        break;
                    case DPI_420:
                        vmHeapSize = 228;
                        break;
                    case XXHIGH:
                        vmHeapSize = 256;
                        break;
                    case DPI_560:
                        vmHeapSize = 384;
                        break;
                    case XXXHIGH:
                        vmHeapSize = 512;
                        break;
                }
                break;
            case XLARGE:
                switch(density) {
                    case LOW:
                        vmHeapSize = 48;
                        break;
                    case ANYDPI:
                    case NODPI:
                    case MEDIUM:
                        vmHeapSize = 80;
                        break;
                    case TV:
                    case HIGH:
                        vmHeapSize = 96;
                        break;
                    case DPI_280:
                        vmHeapSize = 144;
                        break;
                    case XHIGH:
                        vmHeapSize = 192;
                        break;
                    case DPI_360:
                        vmHeapSize = 240;
                        break;
                    case DPI_400:
                        vmHeapSize = 288;
                        break;
                    case DPI_420:
                        vmHeapSize = 336;
                        break;
                    case XXHIGH:
                        vmHeapSize = 384;
                        break;
                    case DPI_560:
                        vmHeapSize = 576;
                        break;
                    case XXXHIGH:
                        vmHeapSize = 768;
                        break;
                }
                break;
        }
    }
    return new Storage(vmHeapSize, Storage.Unit.MiB);
}

Example 10 with Density

use of com.android.resources.Density in project android by JetBrains.

the class MakeBeforeRunTaskProvider method getDeviceSpecificArguments.

@NotNull
public static List<String> getDeviceSpecificArguments(@NotNull List<AndroidDevice> devices) {
    if (devices.isEmpty()) {
        return Collections.emptyList();
    }
    List<String> properties = new ArrayList<>(2);
    // Find the minimum value of the build API level and pass it to Gradle as a property
    AndroidVersion minVersion = devices.get(0).getVersion();
    for (int i = 1; i < devices.size(); i++) {
        AndroidDevice androidDevice = devices.get(i);
        if (androidDevice.getVersion().compareTo(minVersion) < 0) {
            minVersion = androidDevice.getVersion();
        }
    }
    properties.add(AndroidGradleSettings.createProjectProperty(PROPERTY_BUILD_API, Integer.toString(minVersion.getFeatureLevel())));
    // If we are building for only one device, pass the density and the ABI
    if (devices.size() == 1) {
        AndroidDevice device = devices.get(0);
        Density density = Density.getEnum(device.getDensity());
        if (density != null) {
            properties.add(AndroidGradleSettings.createProjectProperty(PROPERTY_BUILD_DENSITY, density.getResourceValue()));
        }
        // Note: the abis are returned in their preferred order which should be maintained while passing it on to Gradle.
        List<String> abis = device.getAbis().stream().map(Abi::toString).collect(Collectors.toList());
        if (!abis.isEmpty()) {
            properties.add(AndroidGradleSettings.createProjectProperty(PROPERTY_BUILD_ABI, Joiner.on(',').join(abis)));
        }
    }
    return properties;
}