Understanding and Adapting Android Q Force Dark Mode: Issues and Solutions

Android Q introduced the Force Dark feature, which can automatically generate a dark theme for apps that only provide a light theme. By setting android:forceDarkAllowed="true" in the manifest, the system applies a hardware‑accelerated dark mode without requiring separate dark resources.

Problems encountered during adaptation

Image corner brightening : When a custom ImageView draws rounded corners in onDraw() using canvas.drawPath , the Force Dark processing treats the drawn white corners as foreground and lightens them, making them appear white on a dark background.

Text brightening : If the same ImageView also draws text, both the rounded corners and the text are lightened under Force Dark.

RecyclerView ItemDecoration brightening : Decorations drawn in onDrawOver() (e.g., alphabet headers) are recorded in the RecyclerView’s DisplayList and become over‑brightened, while the underlying item views are darkened, causing a visual clash.

Below are the key code snippets that illustrate these issues.

private void initPaint() {
    paint = new Paint();
    paint.setAntiAlias(true);
    paint.setStyle(Paint.Style.FILL);
    paint.setColor(Color.WHITE);
}

public void initRightDownPath() {
    rightDownPath = new Path();
    rightDownPath.moveTo(width, height);
    rightDownPath.lineTo(width, height - radius);
    RectF rectF = new RectF(width - 2 * radius, height - 2 * radius, width, height);
    rightDownPath.arcTo(rectF, 0, 90, true);
    rightDownPath.lineTo(width, height);
    rightDownPath.close();
}

@Override
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    canvas.drawPath(leftDownPath, paint);
    canvas.drawPath(leftUpPath, paint);
    canvas.drawPath(rightUpPath, paint);
    canvas.drawPath(rightDownPath, paint);
}

@Override
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    // draw rounded corners
    canvas.drawPath(leftDownPath, paint);
    canvas.drawPath(leftUpPath, paint);
    canvas.drawPath(rightUpPath, paint);
    canvas.drawPath(rightDownPath, paint);
    // draw text
    mTextPaint.setTextSize(typeIconTextSize);
    Paint.FontMetrics fontMetrics = mTextPaint.getFontMetrics();
    float baseline = getHeight() - typeIconMargin - (typeIconHeight + fontMetrics.bottom + fontMetrics.top) / 2;
    float textWidth = mTextPaint.measureText("长图");
    canvas.drawText("长图", getWidth() - typeIconMargin - typeIconWidth / 2 - textWidth / 2, baseline, mTextPaint);
}

@Override
public void onDrawOver(Canvas c, RecyclerView parent, RecyclerView.State state) {
    final int count = parent.getChildCount();
    for (int layoutPos = 0; layoutPos < count; layoutPos++) {
        final View child = parent.getChildAt(layoutPos);
        View header = getHeader(parent, adapterPos).itemView;
        final int left = child.getLeft();
        int top = getHeaderTop(parent, child, header, adapterPos, layoutPos);
        c.save();
        c.translate(left, top);
        header.draw(c);
        c.restore();
    }
}

RenderNode and DisplayList fundamentals

Force Dark works on the hardware‑accelerated rendering pipeline. Each View is represented by a RenderNode that records drawing commands into a DisplayList . The system determines whether a node is foreground (needs to be lightened) or background (needs to be darkened) based on the presence of text and the hierarchy of child nodes.

void RenderNode::handleForceDark(TreeInfo *info) {
    if (!info || info->disableForceDark) return;
    auto usage = usageHint();
    const auto &children = mDisplayList->mChildNodes;
    if (mDisplayList->hasText()) {
        usage = UsageHint::Foreground; // light
    }
    if (usage == UsageHint::Unknown) {
        if (children.size() > 1) {
            usage = UsageHint::Background;
        } else if (children.size() == 1 && children.front().getRenderNode()->usageHint() != UsageHint::Background) {
            usage = UsageHint::Background;
        }
    }
    // ... overlap checks omitted for brevity ...
    mDisplayList->mDisplayList.applyColorTransform(
        usage == UsageHint::Background ? ColorTransform::Dark : ColorTransform::Light);
}

The actual color transformation converts colors to the Lab color space and inverts the L (lightness) component. For normal drawing:

static SkColor makeLight(SkColor color) {
    Lab lab = sRGBToLab(color);
    float invertedL = std::min(110 - lab.L, 100.0f);
    if (invertedL > lab.L) {
        lab.L = invertedL;
        return LabToSRGB(lab, SkColorGetA(color));
    } else {
        return color;
    }
}

static SkColor makeDark(SkColor color) {
    Lab lab = sRGBToLab(color);
    float invertedL = std::min(110 - lab.L, 100.0f);
    if (invertedL < lab.L) {
        lab.L = invertedL;
        return LabToSRGB(lab, SkColorGetA(color));
    } else {
        return color;
    }
}

For images, a high‑contrast filter is applied based on the image’s palette (light or dark) to achieve the same effect.

bool transformPaint(ColorTransform transform, SkPaint* paint, BitmapPalette palette) {
    palette = filterPalette(paint, palette);
    bool shouldInvert = false;
    if (palette == BitmapPalette::Light && transform == ColorTransform::Dark) {
        shouldInvert = true;
    }
    if (palette == BitmapPalette::Dark && transform == ColorTransform::Light) {
        shouldInvert = true;
    }
    if (shouldInvert) {
        SkHighContrastConfig config;
        config.fInvertStyle = SkHighContrastConfig::InvertStyle::kInvertLightness;
        paint->setColorFilter(SkHighContrastFilter::Make(config)->makeComposed(paint->refColorFilter()));
    }
    return shouldInvert;
}

Solutions

Image corner brightening : Insert an empty RenderNode in onDraw() (by calling canvas.drawRenderNode() with a dummy node) so that the system treats the view as background and darkens it.

Text brightening : Separate text drawing into its own RenderNode . The view’s background will be darkened while the text node remains foreground and is lightened, achieving the desired contrast.

RecyclerView ItemDecoration brightening : Add a background RenderNode (drawing a dark rectangle) before drawing the header view, ensuring the overall item decoration has both a dark background and a lightened foreground.

Example of adding a dummy RenderNode for the corner issue:

@Override
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    drawRoundCorner(canvas);
    if (Build.VERSION.SDK_INT > Build.VERSION_CODES.P) {
        if (mRenderNode == null) {
            mRenderNode = new RenderNode("");
        }
        mRenderNode.beginRecording(1, 1);
        mRenderNode.endRecording();
        if (canvas.isHardwareAccelerated() && mRenderNode.hasDisplayList()) {
            canvas.drawRenderNode(mRenderNode);
        }
    }
}

By understanding the rendering pipeline and explicitly controlling RenderNode usage, developers can reliably adapt custom UI components to Android Q’s Force Dark mode.

In summary, the article walks through the Force Dark mechanism, identifies why custom drawing becomes over‑brightened, and provides practical code‑level fixes using RenderNode, DisplayList, and color‑transform APIs.