RESTRUCTURING 1

- change formats to have their own folders with mod + include files + anything they want
- change format list to be defined in formats.rs instead of in each format
- move utils to their respective formats
- some minor code changes in some formats

src/formats/android_ota_payload/mod.rs

@@ -0,0 +1,91 @@
+mod include;
+mod android_ota_update_metadata;
+use std::any::Any;
+use crate::AppContext;
+
+use std::fs::{self, OpenOptions};
+use std::path::Path;
+use std::io::Write;
+use binrw::BinReaderExt;
+use prost::Message;
+
+use crate::utils::common;
+use android_ota_update_metadata::{DeltaArchiveManifest, install_operation};
+use crate::utils::compression::{decompress_bzip, decompress_xz};
+use include::*;
+
+pub fn is_android_ota_payload_file(app_ctx: &AppContext) -> Result<Option<Box<dyn Any>>, Box<dyn std::error::Error>> {
+    let file = match app_ctx.file() {Some(f) => f, None => return Ok(None)};
+
+    let header = common::read_file(&file, 0, 4)?;
+    if header == b"CrAU" {
+        Ok(Some(Box::new(())))
+    } else {
+        Ok(None)
+    }
+}
+
+pub fn extract_android_ota_payload(app_ctx: &AppContext, _ctx: Box<dyn Any>) -> Result<(), Box<dyn std::error::Error>> {
+    let mut file = app_ctx.file().ok_or("Extractor expected file")?;
+
+    let header: Header = file.read_be()?;
+    println!("File info:\nFormat version: {}\nManifest size: {}", header.file_format_version, header.manifest_size);
+
+    if header.file_format_version != 2 {
+        println!("\nSorry, this version of the file is not supported!");
+        return Ok(())
+    }
+
+    let base_offset = 24 /* size of header */ + header.manifest_size + header.metadata_signature_size as u64;
+
+    let read_manifest = common::read_exact(&mut file, header.manifest_size as usize)?;
+    let manifest = DeltaArchiveManifest::decode(&*read_manifest)?;
+
+    for (i, partition) in manifest.partitions.into_iter().enumerate() {
+        let operation_count = partition.operations.len();
+        println!("\n#{} - {}, Size: {}, Operations: {}", 
+                i + 1, partition.partition_name, partition.new_partition_info.unwrap().size.unwrap(), operation_count);
+        
+        for (i, operation) in partition.operations.into_iter().enumerate() {
+            let operation_name_str = match install_operation::Type::try_from(operation.r#type) {
+                Ok(t) => t.as_str_name(),
+                Err(_) => "UNKNOWN",
+            };
+
+            let offset = base_offset + operation.data_offset.unwrap();
+            let size = operation.data_length.unwrap();
+
+            //because the amount of operations can reach up to the thousands, i think its best to update the current line
+            //to not clog up the terminal and so you know what the program is actually doing
+            print!("\r- ({}/{}) - {}({}), Offset: {}, Size: {}", 
+                    i + 1, operation_count, operation_name_str, operation.r#type, offset, size);
+            std::io::stdout().flush()?;
+
+            let data = common::read_file(&file, offset, size as usize)?;
+
+            let out_data;
+            if operation.r#type == 0 { //REPLACE - just write the stored data
+                out_data = data;
+            }
+            else if operation.r#type == 1 { //REPLACE_BZ - decompress with bzip and write
+                out_data = decompress_bzip(&data)?;
+            }
+            else if operation.r#type == 8 { //REPLACE_XZ - decompress with xz and write
+                out_data = decompress_xz(&data)?;
+            } else {
+                println!("-- Unsupported operation!");
+                break
+            }
+
+            fs::create_dir_all(&app_ctx.output_dir)?;
+            let output_path = Path::new(&app_ctx.output_dir).join(format!("{}.bin", partition.partition_name));
+            let mut out_file = OpenOptions::new().append(true).create(true).open(output_path)?;
+            out_file.write_all(&out_data)?;
+        }
+        println!("\n-- Saved!");
+    }
+
+    println!("\nExtraction finished!");
+
+    Ok(())
+}