bsdiff-android 0.0.2

BSDIFF / BSDF2 implementation compatible with Android OTA payloads
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

# bsdiff-android

[![GitHub](https://img.shields.io/badge/github-bsdiff--android-8da0cb?logo=github)](https://github.com/YOUR_USERNAME/bsdiff-android)
[![crates.io version](https://img.shields.io/crates/v/bsdiff-android.svg)](https://crates.io/crates/bsdiff-android)
[![docs.rs docs](https://docs.rs/bsdiff-android/badge.svg)](https://docs.rs/bsdiff-android)
[![CI build](https://github.com/YOUR_USERNAME/bsdiff-android/actions/workflows/rust.yml/badge.svg)](https://github.com/YOUR_USERNAME/bsdiff-android/actions)

Bsdiff/bspatch implementation with Android BSDF2 format support. Compatible with Android OTA payloads.

## Features

-  Classic bsdiff/bspatch (raw format)
-  BSDIFF40 format (BZ2 compressed, compatible with original tools)
-  Android BSDF2 format (Brotli/BZ2/None compression)
-  Fast suffix array construction


## Usage Examples

```rust,ignore
use bsdiff_android as bsdiff;

fn main() {
    let old = vec![1, 2, 3, 4, 5];
    let new = vec![1, 2, 4, 6];
    let mut patch = Vec::new();

    // Generate and apply patch
    bsdiff::diff(&old, &new, &mut patch).unwrap();
    
    let mut patched = Vec::new();
    bsdiff::patch(&old, &mut patch.as_slice(), &mut patched).unwrap();
    assert_eq!(patched, new);
}
```


### Classic BSDIFF40 Format

```rust,ignore
use bsdiff_android::{diff_bsdiff40, patch};

// Generate BSDIFF40 patch (compatible with original bsdiff tools)
let mut patch = Vec::new();
diff_bsdiff40(&old, &new, &mut patch)?;

// Apply patch
let mut result = Vec::new();
patch(&old, &mut patch.as_slice(), &mut result)?;
```

### Android BSDF2 Format (OTA Updates)

```rust,ignore
use bsdiff_android::{diff_bsdf2_uniform, patch_bsdf2, CompressionAlgorithm};

// Generate BSDF2 patch with Brotli compression (Android standard)
let mut patch = Vec::new();
diff_bsdf2_uniform(&old, &new, &mut patch, CompressionAlgorithm::Brotli)?;

// Apply BSDF2 patch
let mut result = Vec::new();
patch_bsdf2(&old, &patch, &mut result)?;
```

### File Operations

```rust,ignore
use bsdiff_android::{diff_bsdf2_uniform, patch_bsdf2, CompressionAlgorithm};
use std::fs;

fn create_update_package() -> std::io::Result<()> {
    // Read old and new versions
    let old = fs::read("app-v1.apk")?;
    let new = fs::read("app-v2.apk")?;
    
    // Generate Android OTA patch
    let mut patch = Vec::new();
    diff_bsdf2_uniform(&old, &new, &mut patch, CompressionAlgorithm::Brotli)?;
    fs::write("update.bsdf2", &patch)?;
    
    println!("Patch size: {} bytes", patch.len());
    Ok(())
}

fn apply_update() -> std::io::Result<()> {
    let old = fs::read("app-v1.apk")?;
    let patch = fs::read("update.bsdf2")?;
    
    let mut new = Vec::new();
    patch_bsdf2(&old, &patch, &mut new)?;
    fs::write("app-v2.apk", &new)?;
    
    Ok(())
}
```

### Mixed Compression (Advanced)

```rust,ignore
use bsdiff_android::{diff_bsdf2, CompressionAlgorithm};

// Use different compression for each stream
let mut patch = Vec::new();
diff_bsdf2(
    &old,
    &new,
    &mut patch,
    CompressionAlgorithm::Brotli,  // Control stream
    CompressionAlgorithm::Brotli,  // Diff stream  
    CompressionAlgorithm::Bz2,     // Extra stream
)?;
```

## API Summary

| Use Case | Generation | Application |
|----------|-----------|-------------|
| Raw format | `diff()` | `patch()` |
| Classic BSDIFF40 | `diff_bsdiff40()` | `patch()` |
| Android BSDF2 | `diff_bsdf2_uniform()` | `patch_bsdf2()` |

## Compression Types

```rust,ignore
CompressionAlgorithm::None    // No compression
CompressionAlgorithm::Bz2     // BZ2 compression
CompressionAlgorithm::Brotli  // Brotli (recommended for Android)
```

## License

BSD-2-Clause

Based on Colin Percival's bsdiff/bspatch algorithm with Android BSDF2 extensions.