Text

implementation(compose.web.core)
implementation(compose.runtime)
implementation(compose.material)
implementation(compose.materialIconsExtended)

SKIKO_RENDER_API

Failed to create DirectX12 device.
Graphics card NVIDIA GeForce GTX 960M is not supported.
Graphics card Intel(R) HD Graphics 530 is not supported.
Graphics card Intel(R) HD Graphics 530 is not supported.
Graphics card NVIDIA GeForce GTX 960M is not supported.
Graphics card Intel(R) HD Graphics 530 is not supported.
Graphics card Intel(R) HD Graphics 530 is not supported.

SKIKO_RENDER_API

SOFTWARE

gradle createDistributable

SKIKO_RENDER_API = "SOFTWARE"

For testing and benchmarking purposes, you can also explicitly force your application to use the specific renderer of your choice by setting the corresponding environment variable: 

SKIKO_RENDER_API="SOFTWARE"

 or 

"OPENGL"

. However, please keep in mind that this fallback renderer is significantly slower than its hardware-accelerated counterpart (up to 4 times slower).

./gradlew package

Exception in thread "AWT-EventQueue-0" java.lang.ClassCastException: class foo.bar.MyClass cannot be cast to class ....

interface Animal { fun foo() }
interface Mammal : Animal
class Tiger : Mammal { ... }

foo()

is

Tiger is Animal

Tiger is NOT Animal

val skijaArtifact = "skija-linux"
val skijaVersion = "0.93.1"

dependencies {
    implementation(compose.desktop.currentOs)
    api ("org.jetbrains.skija:${skijaArtifact}:${skijaVersion}")
}

plugins {
    kotlin("jvm") version "1.6.10"
    id("org.jetbrains.compose") version "1.0.1-rc2"
}

TextStyle

fontFamily

fontStyle

fontWeight

fontSize

Typeface

Font

@Composable
fun App() {
    val videoUrl by remember { mutableStateOf("<videoUrl>") }
    var imageBitmap by remember { mutableStateOf<ImageBitmap?>(null) }

    LaunchedEffect(Unit) {
        val pFormatContext = avformat_alloc_context()

        avformat_open_input(pFormatContext, videoUrl, null, null)
        avformat_find_stream_info(pFormatContext, null as PointerPointer<*>?)


        var pCodecParameters = AVCodecParameters(null)
        for (i in 0 until pFormatContext.nb_streams()) {
            val pLocalCodecParameters = pFormatContext.streams(i).codecpar()

            if(pLocalCodecParameters.codec_type() == avutil.AVMEDIA_TYPE_VIDEO) {
                pCodecParameters = pLocalCodecParameters
            }
        }

        val pCodec = avcodec_find_decoder(pCodecParameters.codec_id())
        val pCodecContext = avcodec_alloc_context3(pCodec)
        avcodec_parameters_to_context(pCodecContext, pCodecParameters)
        avcodec_open2(pCodecContext, pCodec, null as PointerPointer<*>?)

        val pPacket = av_packet_alloc()
        val pFrame = avutil.av_frame_alloc()

        while(av_read_frame(pFormatContext, pPacket) >= 0) {
            avcodec_send_packet(pCodecContext, pPacket)
            avcodec_receive_frame(pCodecContext, pFrame)

            val buff = pPacket.data().position(0).capacity(pPacket.size().toLong()).asByteBuffer()
            val arr = byteArrayOf(buff.remaining().toByte())
            buff.get(arr)
            imageBitmap = Image.makeFromEncoded(arr).toComposeImageBitmap()
            delay(500)
        }
    }

    MaterialTheme {
        imageBitmap?.let {
            Image(
                bitmap = it,
                contentDescription = "Video"
            )
        }
    }
}

// don't inline, surface controls canvas life time

private val surface = Surface.makeRasterN32Premul(100, 100)

private val canvas = surface.canvas

application {
    Window(
        onCloseRequest = ::exitApplication,
        title = "App",
        onKeyEvent = {
            println("keyTyped: ${it.key.nativeKeyCode}:${it.key.nativeKeyCode.toChar()}")
            false
        }
    ) {
        // Window stuff
    }
}

keyTyped: 65:A
keyTyped: 0: 
keyTyped: 65:A

keyCode

keyTyped: 279709745152: 
keyTyped: 536870912: 
keyTyped: 279709745152:

val doneSteps by remember { mutableStateOf(/* my logic for boolean value */ }

doneSteps.forEach {
    // If i try to put AnimatedVisibility here I get the error
}

animate

window size

skew direction

z-index

val densityDpi = LocalContext.current.resources.displayMetrics.densityDpi