Okio

https://github.com/lysine-dev/okio
Admin
Okio is a modern I/O library for Android, Kotlin, and Java that complements java.io and java.nio to...
Tokens:12,513
Snippets:130
Trust Score:7.3
License:Apache-2.0
Update:1 month ago
Show doc for...
Tokens:
Raw
### Inefficient string concatenation in Java

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

An example of a less efficient approach that creates temporary strings, causing unnecessary garbage collection.

```java
sink.writeUtf8(entry.getKey() + "=" + entry.getValue() + "\n"); // Slower!
```

--------------------------------

### Read and write files with FileSystem.SYSTEM

Source: https://github.com/lysine-dev/okio/blob/main/docs/file_system.md

Demonstrates reading a file, modifying its content, and writing it back using the system file system.

```kotlin
val path = "README.md".toPath()

val readmeContent = FileSystem.SYSTEM.read(path) {
  readUtf8()
}

val updatedContent = readmeContent.replace("red", "blue")

FileSystem.SYSTEM.write(path) {
  writeUtf8(updatedContent)
}
```

--------------------------------

### Initialize Socket Sources and Sinks in Java

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Create buffered sources and sinks from a socket in Java.

```Java
Socket fromSocket = ...
BufferedSource fromSource = Okio.buffer(Okio.source(fromSocket));
BufferedSink fromSink = Okio.buffer(Okio.sink(fromSocket));
```

--------------------------------

### Test with FakeFileSystem

Source: https://github.com/lysine-dev/okio/blob/main/docs/file_system.md

Shows how to use FakeFileSystem to simulate file operations in tests, including creating directories and verifying file content.

```kotlin
val fileSystem = FakeFileSystem()
val userHome = "/Users/sandy".toPath()
val gitConfig = userHome / ".gitconfig"

fileSystem.createDirectories(userHome)
val original = """
    |[user]
    |  email = sandy@example.com
    |""".trimMargin()
fileSystem.write(gitConfig) { writeUtf8(original) }

GitConfigFixer(fileSystem).fix(userHome)

val expected = """
  |[user]
  |  email = sandy@example.com
  |[diff]
  |  renames = true
  |  indentHeuristic = on
  """.trimIndent()
assertEquals(expected, fileSystem.read(gitConfig) { readUtf8() })
```

--------------------------------

### Configure Android SDK and PATH

Source: https://github.com/lysine-dev/okio/blob/main/android-test/README.md

Set the ANDROID_SDK_ROOT environment variable and update the PATH to include Android tools and platform-tools.

```bash
export ANDROID_SDK_ROOT=/Users/$USER/Library/Android/sdk
export PATH=$PATH:$ANDROID_SDK_ROOT/tools/bin:$ANDROID_SDK_ROOT/platform-tools
```

--------------------------------

### Initialize Socket Sources and Sinks in Kotlin

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Create buffered sources and sinks from a socket in Kotlin using extension methods.

```Kotlin
val fromSocket: Socket = ...
val fromSource = fromSocket.source().buffer()
val fromSink = fromSocket.sink().buffer()
```

--------------------------------

### Read a text file line-by-line in Java

Source: https://github.com/lysine-dev/okio/blob/main/docs/java_io_recipes.md

Uses Okio.source and Okio.buffer to read a java.io.File line-by-line.

```java
public void readLines(File file) throws IOException {
  try (Source fileSource = Okio.source(file);
       BufferedSource bufferedFileSource = Okio.buffer(fileSource)) {

    while (true) {
      String line = bufferedFileSource.readUtf8Line();
      if (line == null) break;

      if (line.contains("square")) {
        System.out.println(line);
      }
    }

  }
}
```

--------------------------------

### Write a text file in Java

Source: https://github.com/lysine-dev/okio/blob/main/docs/java_io_recipes.md

Uses Okio.sink and Okio.buffer to write environment variables to a java.io.File.

```java
public void writeEnv(File file) throws IOException {
  try (Sink fileSink = Okio.sink(file);
       BufferedSink bufferedSink = Okio.buffer(fileSink)) {

    for (Map.Entry<String, String> entry : System.getenv().entrySet()) {
      bufferedSink.writeUtf8(entry.getKey());
      bufferedSink.writeUtf8("=");
      bufferedSink.writeUtf8(entry.getValue());
      bufferedSink.writeUtf8("\n");
    }

  }
}
```

--------------------------------

### Set release version environment variables

Source: https://github.com/lysine-dev/okio/blob/main/docs/releasing.md

Define the current release version and the next snapshot version as environment variables.

```bash
export RELEASE_VERSION=X.Y.Z
export NEXT_VERSION=X.Y.Z-SNAPSHOT
```

--------------------------------

### Run project tests with Gradle

Source: https://github.com/lysine-dev/okio/blob/main/CONTRIBUTING.md

Execute this command on a personal branch to ensure all tests pass before submitting a pull request.

```bash
./gradlew clean check
```

--------------------------------

### Read a text file line-by-line compactly in Java

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

A more concise version using a for loop and inlined source initialization.

```java
public void readLines(Path path) throws IOException {
  try (BufferedSource source = Okio.buffer(FileSystem.SYSTEM.source(path))) {
    for (String line; (line = source.readUtf8Line()) != null; ) {
      if (line.contains("square")) {
        System.out.println(line);
      }
    }
  }
}
```

--------------------------------

### Write environment variables to a file in Java

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Demonstrates writing environment variables to a file using a BufferedSink. It manually inserts newline characters as there is no dedicated API for line-based input.

```java
public void writeEnv(Path path) throws IOException {
  try (Sink fileSink = FileSystem.SYSTEM.sink(path);
       BufferedSink bufferedSink = Okio.buffer(fileSink)) {

    for (Map.Entry<String, String> entry : System.getenv().entrySet()) {
      bufferedSink.writeUtf8(entry.getKey());
      bufferedSink.writeUtf8("=");
      bufferedSink.writeUtf8(entry.getValue());
      bufferedSink.writeUtf8("\n");
    }

  }
}
```

--------------------------------

### Add Okio snapshot dependency

Source: https://github.com/lysine-dev/okio/blob/main/docs/index.md

Configure the snapshot repository and add the dependency for development builds.

```kotlin
repositories {
  maven("https://central.sonatype.com/repository/maven-snapshots/")
}

dependencies {
  implementation("com.squareup.okio:okio:3.19.0-SNAPSHOT")
}
```

--------------------------------

### Update versions and tag release

Source: https://github.com/lysine-dev/okio/blob/main/docs/releasing.md

Use sed to update gradle.properties and index.md files, commit the changes, tag the release, and push to the repository.

```bash
sed -i "" \
  "s/VERSION_NAME=.*/VERSION_NAME=$RELEASE_VERSION/g" \
  gradle.properties
sed -i "" \
  "s/\"com.squareup.okio:\([^\:]*\):[0-9.]*\"/\"com.squareup.okio:\1:$RELEASE_VERSION\"/g" \
  `find . -name "index.md"`
sed -i "" \
  "s/\"com.squareup.okio:\([^\:]*\):[0-9.]*-SNAPSHOT\"/\"com.squareup.okio:\1:$NEXT_VERSION\"/g" \
  `find . -name "index.md"`

git commit -am "Prepare for release $RELEASE_VERSION."
git tag -a parent-$RELEASE_VERSION -m "Version $RELEASE_VERSION"

sed -i "" \
  "s/VERSION_NAME=.*/VERSION_NAME=$NEXT_VERSION/g" \
  gradle.properties
git commit -am "Prepare next development version."

git push && git push --tags
```

--------------------------------

### Read a text file line-by-line compactly in Kotlin

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Uses FileSystem.read to automatically buffer the source and close it after the block.

```kotlin
@Throws(IOException::class)
fun readLines(path: Path) {
  FileSystem.SYSTEM.read(path) {
    while (true) {
      val line = readUtf8Line() ?: break
      if ("square" in line) {
        println(line)
      }
    }
  }
}
```

--------------------------------

### Run JMH benchmarks with Gradle

Source: https://github.com/lysine-dev/okio/blob/main/okio/jvm/jmh/README.md

Execute the JMH microbenchmarks locally using the Gradle wrapper.

```bash
$ ./gradlew jmh
```

--------------------------------

### Encrypt and Decrypt with AES in Java

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Uses Okio.cipherSink and Okio.cipherSource to handle AES/CBC/PKCS5Padding encryption and decryption. The key and iv parameters must be 16 bytes long.

```java
void encryptAes(ByteString bytes, Path path, byte[] key, byte[] iv)
    throws GeneralSecurityException, IOException {
  Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
  cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key, "AES"), new IvParameterSpec(iv));
  try (BufferedSink sink = Okio.buffer(
      Okio.cipherSink(FileSystem.SYSTEM.sink(path), cipher))) {
    sink.write(bytes);
  }
}

ByteString decryptAesToByteString(Path path, byte[] key, byte[] iv)
    throws GeneralSecurityException, IOException {
  Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
  cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key, "AES"), new IvParameterSpec(iv));
  try (BufferedSource source = Okio.buffer(
      Okio.cipherSource(FileSystem.SYSTEM.source(path), cipher))) {
    return source.readByteString();
  }
}
```

--------------------------------

### Add Okio dependency

Source: https://github.com/lysine-dev/okio/blob/main/docs/index.md

Include the Okio library in your project using Gradle.

```kotlin
implementation("com.squareup.okio:okio:3.18.1")
```

--------------------------------

### Read a text file line-by-line in Java

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Uses try-with-resources to automatically close the file source and buffered source.

```java
public void readLines(Path path) throws IOException {
  try (Source fileSource = FileSystem.SYSTEM.source(path);
       BufferedSource bufferedFileSource = Okio.buffer(fileSource)) {

    while (true) {
      String line = bufferedFileSource.readUtf8Line();
      if (line == null) break;

      if (line.contains("square")) {
        System.out.println(line);
      }
    }

  }
}
```

--------------------------------

### Read a text file line-by-line in Kotlin

Source: https://github.com/lysine-dev/okio/blob/main/docs/java_io_recipes.md

Uses file.source() extension function to read a java.io.File line-by-line.

```kotlin
@Throws(IOException::class)
fun readLines(file: File) {
  file.source().use { fileSource ->
    fileSource.buffer().use { bufferedFileSource ->
      while (true) {
        val line = bufferedFileSource.readUtf8Line() ?: break
        if ("square" in line) {
          println(line)
        }
      }
    }
  }
}
```

--------------------------------

### Write environment variables in Kotlin

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Uses FileSystem.write to handle buffering and closing automatically. The block provides a BufferedSink as the receiver.

```kotlin
@Throws(IOException::class)
fun writeEnv(path: Path) {
  FileSystem.SYSTEM.write(path) {
    for ((key, value) in System.getenv()) {
      writeUtf8(key)
      writeUtf8("=")
      writeUtf8(value)
      writeUtf8("\n")
    }
  }
}
```

--------------------------------

### Run Android tests

Source: https://github.com/lysine-dev/okio/blob/main/android-test/README.md

Execute the connectedAndroidTest task to run the full test suite on a connected device.

```bash
./gradlew :android-test:connectedAndroidTest
```

--------------------------------

### Write a text file in Kotlin

Source: https://github.com/lysine-dev/okio/blob/main/docs/java_io_recipes.md

Uses file.sink() extension function to write environment variables to a java.io.File.

```kotlin
@Throws(IOException::class)
fun writeEnv(file: File) {
  file.sink().buffer().use { sink ->
    for ((key, value) in System.getenv()) {
      sink.writeUtf8(key)
      sink.writeUtf8("=")
      sink.writeUtf8(value)
      sink.writeUtf8("\n")
    }
  }
}
```

--------------------------------

### Configure Okio dependencies in build.gradle.kts

Source: https://github.com/lysine-dev/okio/blob/main/docs/multiplatform.md

Add Okio dependencies to common, JS, and test source sets in your Kotlin Multiplatform project.

```kotlin
// build.gradle.kts
kotlin {
    sourceSets {
        val okioVersion = "3.XXX"
        val commonMain by getting {
            dependencies {
                implementation("com.squareup.okio:okio:$okioVersion")
            }
        }
        val jsMain by getting {
            dependencies {
                implementation("com.squareup.okio:okio-nodefilesystem:$okioVersion")
            }
        }
        val commonTest by getting {
            dependencies {
                implementation("com.squareup.okio:okio-fakefilesystem:$okioVersion")
            }
        }
    }
}
```

--------------------------------

### Run a single Android test

Source: https://github.com/lysine-dev/okio/blob/main/android-test/README.md

Execute a specific test class by passing the class name as an argument to the instrumentation runner.

```bash
./gradlew :android-test:connectedAndroidTest -Pandroid.testInstrumentationRunnerArguments.class=okio.SystemFileSystemTest
```

--------------------------------

### Read a text file line-by-line in Kotlin

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Uses the use extension function to ensure streams are closed and prevent resource leaks.

```kotlin
fun readLines(path: Path) {
  FileSystem.SYSTEM.source(path).use { fileSource ->
    fileSource.buffer().use { bufferedFileSource ->
      while (true) {
        val line = bufferedFileSource.readUtf8Line() ?: break
        if ("square" in line) {
          println(line)
        }
      }
    }
  }
}
```

--------------------------------

### Compact environment variable writing in Java

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

A more compact version of the environment variable writer using method chaining and inlining the file sink.

```java
public void writeEnv(Path path) throws IOException {
  try (BufferedSink sink = Okio.buffer(FileSystem.SYSTEM.sink(path))) {
    for (Map.Entry<String, String> entry : System.getenv().entrySet()) {
      sink.writeUtf8(entry.getKey())
        .writeUtf8("=")
        .writeUtf8(entry.getValue())
        .writeUtf8("\n");
    }
  }
}
```

--------------------------------

### Generate hashes while streaming from a source

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Use HashingSink to compute a hash while reading data from a source.

```Java
try (HashingSink hashingSink = HashingSink.sha256(Okio.blackhole());
     BufferedSource source = Okio.buffer(FileSystem.SYSTEM.source(path))) {
  source.readAll(hashingSink);
  System.out.println("sha256: " + hashingSink.hash().hex());
}
```

```Kotlin
sha256(blackholeSink()).use { hashingSink ->
  FileSystem.SYSTEM.source(path).buffer().use { source ->
    source.readAll(hashingSink)
    println("    sha256: " + hashingSink.hash.hex())
  }
}
```

--------------------------------

### Copy Data Between Streams in Java

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

A loop to copy data from a source to a sink, flushing after each read.

```Java
Buffer buffer = new Buffer();
for (long byteCount; (byteCount = source.read(buffer, 8192L)) != -1; ) {
  sink.write(buffer, byteCount);
  sink.flush();
}
```

--------------------------------

### Stream test logs with logcat

Source: https://github.com/lysine-dev/okio/blob/main/android-test/README.md

Use adb logcat to monitor specific tags related to test execution and system state.

```bash
adb logcat '*:E' TestRunner:D TaskRunner:D GnssHAL_GnssInterface:F DeviceStateChecker:F memtrack:F
```

--------------------------------

### Copy Data Between Streams in Kotlin

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

A loop to copy data from a source to a sink, flushing after each read in Kotlin.

```Kotlin
val buffer = Buffer()
var byteCount: Long
while (source.read(buffer, 8192L).also { byteCount = it } != -1L) {
  sink.write(buffer, byteCount)
  sink.flush()
}
```

--------------------------------

### Read a text file with readUtf8LineStrict in Java

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Uses readUtf8LineStrict to enforce line termination and a byte limit.

```java
public void readLines(Path path) throws IOException {
  try (BufferedSource source = Okio.buffer(FileSystem.SYSTEM.source(path))) {
    while (!source.exhausted()) {
      String line = source.readUtf8LineStrict(1024L);
      if (line.contains("square")) {
        System.out.println(line);
      }
    }
  }
}
```

--------------------------------

### Verify test run completion in logcat

Source: https://github.com/lysine-dev/okio/blob/main/android-test/README.md

Check the logcat output for the 'run finished' line to confirm that all tests executed successfully.

```text
01-01 00:00:00.000 12345 23456 I TestRunner: run finished: 2976 tests, 0 failed, 3 ignored
```

--------------------------------

### Encrypt and Decrypt with AES in Kotlin

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Uses extension functions on Cipher to perform AES/CBC/PKCS5Padding encryption and decryption. The key and iv parameters must be 16 bytes long.

```kotlin
fun encryptAes(bytes: ByteString, path: Path, key: ByteArray, iv: ByteArray) {
  val cipher = Cipher.getInstance("AES/CBC/PKCS5Padding")
  cipher.init(Cipher.ENCRYPT_MODE, SecretKeySpec(key, "AES"), IvParameterSpec(iv))
  val cipherSink = FileSystem.SYSTEM.sink(path).cipherSink(cipher)
  cipherSink.buffer().use {
    it.write(bytes)
  }
}

fun decryptAesToByteString(path: Path, key: ByteArray, iv: ByteArray): ByteString {
  val cipher = Cipher.getInstance("AES/CBC/PKCS5Padding")
  cipher.init(Cipher.DECRYPT_MODE, SecretKeySpec(key, "AES"), IvParameterSpec(iv))
  val cipherSource = FileSystem.SYSTEM.source(path).cipherSource(cipher)
  return cipherSource.buffer().use {
    it.readByteString()
  }
}
```

--------------------------------

### Generate hashes from Buffer

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Compute cryptographic hashes from a Buffer and display them in hexadecimal format.

```Java
Buffer buffer = readBuffer(Path.get("README.md"));
System.out.println("   md5: " + buffer.md5().hex());
System.out.println("  sha1: " + buffer.sha1().hex());
System.out.println("sha256: " + buffer.sha256().hex());
System.out.println("sha512: " + buffer.sha512().hex());
```

```Kotlin
val buffer = readBuffer("README.md".toPath())
println("       md5: " + buffer.md5().hex())
println("      sha1: " + buffer.sha1().hex())
println("    sha256: " + buffer.sha256().hex())
println("    sha512: " + buffer.sha512().hex())
```

--------------------------------

### Encode BMP Image in Java

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

This snippet demonstrates writing BMP headers and pixel data to a BufferedSink, including necessary 4-byte row alignment padding.

```Java
// DIB Header
sink.writeIntLe(dibHeaderSize);
sink.writeIntLe(width);
sink.writeIntLe(height);
sink.writeShortLe(1);  // Color plane count.
sink.writeShortLe(bytesPerPixel * Byte.SIZE);
sink.writeIntLe(0);    // No compression.
sink.writeIntLe(16);   // Size of bitmap data including padding.
sink.writeIntLe(2835); // Horizontal print resolution in pixels/meter. (72 dpi).
sink.writeIntLe(2835); // Vertical print resolution in pixels/meter. (72 dpi).
sink.writeIntLe(0);    // Palette color count.
sink.writeIntLe(0);    // 0 important colors.

// Pixel data.
for (int y = height - 1; y >= 0; y--) {
  for (int x = 0; x < width; x++) {
    sink.writeByte(bitmap.blue(x, y));
    sink.writeByte(bitmap.green(x, y));
    sink.writeByte(bitmap.red(x, y));
  }

  // Padding for 4-byte alignment.
  for (int p = rowByteCountWithoutPadding; p < rowByteCount; p++) {
    sink.writeByte(0);
  }
}
}
```

--------------------------------

### Dump String Data

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Inspects string properties and UTF-8 encoding details.

```java
public void dumpStringData(String s) throws IOException {
  System.out.println("                       " + s);
  System.out.println("        String.length: " + s.length());
  System.out.println("String.codePointCount: " + s.codePointCount(0, s.length()));
  System.out.println("            Utf8.size: " + Utf8.size(s));
  System.out.println("          UTF-8 bytes: " + ByteString.encodeUtf8(s).hex());
  System.out.println();
}
```

```kotlin
fun dumpStringData(s: String) {
  println("                       " + s)
  println("        String.length: " + s.length)
  println("String.codePointCount: " + s.codePointCount(0, s.length))
  println("            Utf8.size: " + s.utf8Size())
  println("          UTF-8 bytes: " + s.encodeUtf8().hex())
  println()
}
```

--------------------------------

### Encode Bitmap to BMP Format (Java)

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Encodes a bitmap into the BMP file format using BufferedSink. Demonstrates writing headers and pixel data with little-endian methods.

```Java
void encode(Bitmap bitmap, BufferedSink sink) throws IOException {
  int height = bitmap.height();
  int width = bitmap.width();

  int bytesPerPixel = 3;
  int rowByteCountWithoutPadding = (bytesPerPixel * width);
  int rowByteCount = ((rowByteCountWithoutPadding + 3) / 4) * 4;
  int pixelDataSize = rowByteCount * height;
  int bmpHeaderSize = 14;
  int dibHeaderSize = 40;

  // BMP Header
  sink.writeUtf8("BM"); // ID.
  sink.writeIntLe(bmpHeaderSize + dibHeaderSize + pixelDataSize); // File size.
  sink.writeShortLe(0); // Unused.
  sink.writeShortLe(0); // Unused.
  sink.writeIntLe(bmpHeaderSize + dibHeaderSize); // Offset of pixel data.
```

--------------------------------

### Read a text file with readUtf8LineStrict in Kotlin

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Uses readUtf8LineStrict within a FileSystem.read block to enforce strict line termination.

```kotlin
@Throws(IOException::class)
fun readLines(path: Path) {
  FileSystem.SYSTEM.read(path) {
    while (!source.exhausted()) {
      val line = source.readUtf8LineStrict(1024)
      if ("square" in line) {
        println(line)
      }
    }
  }
}
```

--------------------------------

### Encode BMP Image in Kotlin

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

A complete Kotlin implementation for encoding a Bitmap to a BufferedSink, handling BMP headers and row padding.

```Kotlin
@Throws(IOException::class)
fun encode(bitmap: Bitmap, sink: BufferedSink) {
  val height = bitmap.height
  val width = bitmap.width
  val bytesPerPixel = 3
  val rowByteCountWithoutPadding = bytesPerPixel * width
  val rowByteCount = (rowByteCountWithoutPadding + 3) / 4 * 4
  val pixelDataSize = rowByteCount * height
  val bmpHeaderSize = 14
  val dibHeaderSize = 40

  // BMP Header
  sink.writeUtf8("BM") // ID.
  sink.writeIntLe(bmpHeaderSize + dibHeaderSize + pixelDataSize) // File size.
  sink.writeShortLe(0) // Unused.
  sink.writeShortLe(0) // Unused.
  sink.writeIntLe(bmpHeaderSize + dibHeaderSize) // Offset of pixel data.

  // DIB Header
  sink.writeIntLe(dibHeaderSize)
  sink.writeIntLe(width)
  sink.writeIntLe(height)
  sink.writeShortLe(1) // Color plane count.
  sink.writeShortLe(bytesPerPixel * Byte.SIZE_BITS)
  sink.writeIntLe(0) // No compression.
  sink.writeIntLe(16) // Size of bitmap data including padding.
  sink.writeIntLe(2835) // Horizontal print resolution in pixels/meter. (72 dpi).
  sink.writeIntLe(2835) // Vertical print resolution in pixels/meter. (72 dpi).
  sink.writeIntLe(0) // Palette color count.
  sink.writeIntLe(0) // 0 important colors.

  // Pixel data.
  for (y in height - 1 downTo 0) {
    for (x in 0 until width) {
      sink.writeByte(bitmap.blue(x, y))
      sink.writeByte(bitmap.green(x, y))
      sink.writeByte(bitmap.red(x, y))
    }

    // Padding for 4-byte alignment.
    for (p in rowByteCountWithoutPadding until rowByteCount) {
      sink.writeByte(0)
    }
  }
}
```

--------------------------------

### Test Decoder with Golden Value (Kotlin)

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Tests the deserialization logic using a base64 encoded golden value in Kotlin.

```Kotlin
val goldenBytes = ("rO0ABXNyACRva2lvLnNhbXBsZXMuS290bGluR29sZGVuVmFsdWUkUG9pbnRF9yaY7cJ9EwIAA" + 
  "kQAAXhEAAF5eHBAIAAAAAAAAEAuAAAAAAAA").decodeBase64()!!
val decoded = deserialize(goldenBytes) as Point
assertEquals(point, decoded)
```

--------------------------------

### Read Unsigned Values in Java

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Convert signed bytes and shorts to unsigned values using bitwise operators.

```Java
int addressType = fromSource.readByte() & 0xff;
int port = fromSource.readShort() & 0xffff;
```

--------------------------------

### Test Decoder with Golden Value (Java)

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Tests the deserialization logic using a base64 encoded golden value in Java.

```Java
ByteString goldenBytes = ByteString.decodeBase64("rO0ABXNyAB5va2lvLnNhbXBsZ"
    + "XMuR29sZGVuVmFsdWUkUG9pbnTdUW8rMji1IwIAAkQAAXhEAAF5eHBAIAAAAAAAAEAuA"
    + "AAAAAAA");
Point decoded = (Point) deserialize(goldenBytes);
assertEquals(new Point(8.0, 15.0), decoded);
```

--------------------------------

### Read Unsigned Values in Kotlin

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Convert signed bytes and shorts to unsigned values using bitwise operators in Kotlin.

```Kotlin
val addressType = fromSource.readByte().toInt() and 0xff
val port = fromSource.readShort().toInt() and 0xffff
```

--------------------------------

### Serialize Object to ByteString

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Serializes an object using Java Serialization into an Okio ByteString.

```java
private ByteString serialize(Object o) throws IOException {
  Buffer buffer = new Buffer();
  try (ObjectOutputStream objectOut = new ObjectOutputStream(buffer.outputStream())) {
    objectOut.writeObject(o);
  }
  return buffer.readByteString();
}
```

```kotlin
@Throws(IOException::class)
private fun serialize(o: Any?): ByteString {
  val buffer = Buffer()
  ObjectOutputStream(buffer.outputStream()).use { objectOut ->
    objectOut.writeObject(o)
  }
  return buffer.readByteString()
}
```

--------------------------------

### Compute and Print Golden Value

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Computes a golden value for a Point object and prints it as a base64 string.

```java
Point point = new Point(8.0, 15.0);
ByteString pointBytes = serialize(point);
System.out.println(pointBytes.base64());
```

```kotlin
val point = Point(8.0, 15.0)
val pointBytes = serialize(point)
println(pointBytes.base64())
```

--------------------------------

### Generate hashes while streaming to a sink

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Use HashingSink to compute a hash while writing data to a sink.

```Java
try (HashingSink hashingSink = HashingSink.sha256(Okio.blackhole());
     BufferedSink sink = Okio.buffer(hashingSink);
     Source source = FileSystem.SYSTEM.source(path)) {
  sink.writeAll(source);
  sink.close(); // Emit anything buffered.
  System.out.println("sha256: " + hashingSink.hash().hex());
}
```

```Kotlin
sha256(blackholeSink()).use { hashingSink ->
  hashingSink.buffer().use { sink ->
    FileSystem.SYSTEM.source(path).use { source ->
      sink.writeAll(source)
      sink.close() // Emit anything buffered.
      println("    sha256: " + hashingSink.hash.hex())
    }
  }
}
```

--------------------------------

### Deserialize ByteString to Object

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Uses ObjectInputStream to deserialize a ByteString into an object. Requires IOException and ClassNotFoundException handling.

```Kotlin
@Throws(IOException::class, ClassNotFoundException::class)
private fun deserialize(byteString: ByteString): Any? {
  val buffer = Buffer()
  buffer.write(byteString)
  ObjectInputStream(buffer.inputStream()).use { objectIn ->
    return objectIn.readObject()
  }
}
```

--------------------------------

### Generate hashes from ByteString

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Compute cryptographic hashes from a ByteString and display them in hexadecimal format.

```Java
ByteString byteString = readByteString(Path.get("README.md"));
System.out.println("   md5: " + byteString.md5().hex());
System.out.println("  sha1: " + byteString.sha1().hex());
System.out.println("sha256: " + byteString.sha256().hex());
System.out.println("sha512: " + byteString.sha512().hex());
```

```Kotlin
val byteString = readByteString("README.md".toPath())
println("       md5: " + byteString.md5().hex())
println("      sha1: " + byteString.sha1().hex())
println("    sha256: " + byteString.sha256().hex())
println("    sha512: " + byteString.sha512().hex())
```

--------------------------------

### Deserialize ByteString to Object

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Reverses the serialization process by consuming a ByteString from a buffer.

```java
private Object deserialize(ByteString byteString) throws IOException, ClassNotFoundException {
  Buffer buffer = new Buffer();
  buffer.write(byteString);
  try (ObjectInputStream objectIn = new ObjectInputStream(buffer.inputStream())) {
    return objectIn.readObject();
  }
}
```

--------------------------------

### Generate HMAC SHA-256

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Compute an HMAC using a secret key and a ByteString.

```Java
ByteString secret = ByteString.decodeHex("7065616e7574627574746572");
System.out.println("hmacSha256: " + byteString.hmacSha256(secret).hex());
```

```Kotlin
val secret = "7065616e7574627574746572".decodeHex()
println("hmacSha256: " + byteString.hmacSha256(secret).hex())
```

--------------------------------

### Embed Golden Value in Test

Source: https://github.com/lysine-dev/okio/blob/main/docs/recipes.md

Converts a base64 string back into a ByteString for use in test cases.

```java
ByteString goldenBytes = ByteString.decodeBase64("rO0ABXNyAB5va2lvLnNhbXBsZ"
    + "XMuR29sZGVuVmFsdWUkUG9pbnTdUW8rMji1IwIAAkQAAXhEAAF5eHBAIAAAAAAAAEAuA"
    + "AAAAAAA");
```

```kotlin
val goldenBytes = ("rO0ABXNyACRva2lvLnNhbXBsZXMuS290bGluR29sZGVuVmFsdWUkUG9pbnRF9yaY7cJ9EwIAA" +
  "kQAAXhEAAF5eHBAIAAAAAAAAEAuAAAAAAAA").decodeBase64()
```
Tokens:
Raw