kotlinx.serialization | Kotlin multiplatform / multi-format serialization | Serialization library

Your data models should be like below.

A bearer token is nothing but a header Authorization: Bearer XXX - If you're looking for a tech specific way to handle this (drop in some module, etc) then you may be out-of-luck

However, this problem occurs frequently enough in my life - the solution is to actually dynamically manipulate the headers - Basically, use the strategy pattern. If you can create instances of your client, then each instance would get its own strategy. If you can't, then install a function that gets called with every request to determine the header based on whatever logic you need.

In your case, a custom:

There are multiple reasons for not calling the refreshTokens callback:

• Response status isn't 401 Unauthorized
• Attributes of a request contain circuitBreaker (this means a refresh token is already requested)
• No WWW-Authenticate header is present
• The WWW-Authenticate header value is malformed
• No auth provider is found by an auth scheme and a realm (parsed from the WWW-Authenticate header value)

According to the log in the question's description, the refreshTokens callback should be called because all the above conditions are met.

Not exactly the equivalent, but you can directly use the byte stream from the response. You'll still have to handle the case of a null response/body as the decodeFromInputStream does not take a nullable type :

There is documentation available on how to configure ProGuard, which does not seem to match the configuration you are using.

Use that and you should be good to go.

Purely informational, since the above already answers your question: serializer lookup at runtime for object is different and happens through INSTANCE. The relevant part from the docs.

I would recommend trying out JsonUnit. It will allow you to write assert for json with good messages on failure. An example using AssertJ integration:

What you want is currently not possible. Other people seem to have requested a feature similar to what you need on GitHub: Global Custom Serializers.

Currently, for 3rd party classes, you need to specify the serializer in one of three ways:

• Pass the custom serializer to the encode/decode method in case you are serializing it as the root object.
• Specify the serializer on the property using @Serializable, as you do now.
• Specify the serializer to be used by a full file using @file:UseSerializers.

Note that due to type inference, number will be attempted to be serialized as the return type of mutableStateOf. If you specify the type as an interface instead (does it have a supertype?), using polymorphic serialization, you could try to register the concrete type and pass your custom serializer there for the concrete type. Not really what this feature is designed for, but I believe it may work if you don't want to specify your serializer in multiple places. However, the serialized form will then include a type discriminator everywhere.

I wrote those ProGuard rules. :) The pull request discussion about these changes may provide relevant background.

I understand your confusion, the ProGuard rules documentation is quite sparse.

-if class_specification

Specifies classes and class members that must be present to activate the subsequent keep option (-keep, -keepclassmembers,...). The condition and the subsequent keep option can share wildcards and references to wildcards. For example, you can keep classes on the condition that classes with related names exist in your project, with frameworks like Dagger and Butterknife.

As written in the comments of the rules you copied this from:

tl;dr

Exchange this