שילוב קוד ראסט באפליקציות מובייל באמצעות FFI

טרגטים עבור Android:

cargo ndk -t arm64-v8a -t x86_64 -o ./jniLibs build --release 

טרגטים עבור iOS:

cargo build --target aarch64-apple-ios --release
cargo build --target aarch64-apple-ios-sim --release
cargo build --target x86_64-apple-ios --release
lipo -create target/x86_64-apple-ios/release/libmylib.a \
    target/aarch64-apple-ios/release/libmylib.a \
    -output libmylib-sim.a

לאחר מכן cargo-ndk משלב בין גרסאות הסימולטור והמכשיר.

למה לבחור ב-Rust על פני C/C++ ללוגיקת Native?

Rust בטוח יותר בזיכרון בסדר גודל: הקומפיילר מבטיח היעדר use-after-free ומרוצי נתונים בזמן build. עבור קריפטוגרפיה וניתוח פרוטוקולים זה קריטי—שגיאה אחת יכולה לעלות בנתוני משתמשים. לפי מיקרוסופט, כ-70% מכלל הפגיעויות בתוכנת מערכת קשורות לזיכרון. Rust מבטל מחלקת שגיאות זו, מה שהופך אותו לבטוח פי 2-3 מ-C/C++ מבחינת פגיעויות שמכניס מפתח. במקביל, Rust משתווה ל-C++ בביצועים; עבור פעולות קריפטוגרפיות, קוד Rust רץ פי 3-5 מהר יותר מקוד Java מקביל ב-Android. פתרון Rust צורך פי 2 פחות זיכרון בהשוואה ל-C++ עבור אותם אלגוריתמים. החיסכון בתקציב הפיתוח מגיע ל-40% בזכות שימוש חוזר בקוד Rust אחד על פני שתי הפלטפורמות.

השוואת כלים: uniffi-rs מול cbindgen

uniffi-rs—מומלץ לרוב הפרויקטים. ממשק Rust מתואר בקובץ cargo ndk -t arm64-v8a -t x86_64 -o ./jniLibs build --release ; cargo build --target aarch64-apple-ios --release cargo build --target aarch64-apple-ios-sim --release cargo build --target x86_64-apple-ios --release lipo -create target/x86_64-apple-ios/release/libmylib.a \ target/aarch64-apple-ios/release/libmylib.a \ -output libmylib-sim.a מייצר מחלקות Kotlin עבור Android וקבצי Swift עבור iOS. התוצאה היא API native ללא כתיבה ידנית של JNI או Objective-C.

// mylib.udl namespace mylib { sequence<u8> encrypt(sequence<u8> data, string key); }; 

מייצר xcodebuild -create-xcframework עם .udl ו-uniffi-bindgen עם // mylib.udl namespace mylib { sequence<u8> encrypt(sequence<u8> data, string key); }; .

cbindgen—מייצר קובץ כותרת C מ-Rust. מתאים אם צריך שכבת C דקה וכותבים bindings של Swift/Kotlin ידנית או דרך כלי אחר. יותר שליטה, יותר עבודה ידנית.

איך להבטיח בטיחות תהליכונים (Thread Safety) בהעברת נתונים דרך FFI?

בגבול Rust ↔ מובייל, יש לנהל במפורש את מחזור החיים של אובייקטים. אם פונקציית Rust מחזירה מצביע למבנה שהוקצה ב-heap—קוד המובייל מקבל mylib.kt (Android) או fun encrypt(data: List<UByte>, key: String): List<UByte> (iOS). ההשמדה מתבצעת דרך mylib.swift מפורש בצד Rust, הנקרא מ-func encrypt(data: [UInt8], key: String) -> [UInt8]/Long. שכחת קריאה ל-UnsafeRawPointer גורמת לדליפת זיכרון. Uniffi הופך זאת לאוטומטי באמצעות ספירת הפניות Arc.

Rust panic (free_object(ptr)) מעבר ל-FFI הוא התנהגות לא מוגדרת. כל קוד ה-FFI עטוף ב-finalize() או שאנו משתמשים בהערות deinit עבור נתיבים קריטיים.

Async Rust ב-FFI. ניתן ליצור runtime של free_* בתוך קוד Rust: panic!. זה סינכרוני מנקודת מבט של FFI אך אסינכרוני בתוך Rust. לאינטראקציה async אמיתית—API מבוסס callbacks או uniffi-rs עם תמיכת async (ניסיוני ב-uniffi 0.25+).

מקרה בוחן. מסנג'ר עם הצפנה מקצה לקצה: ליבת קריפטוגרפית ב-Rust (אלגוריתם Double Ratchet, חילופי מפתחות X3DH) דרך uniffi. Android: Kotlin קורא ל-std::panic::catch_unwind—מתחת למכסה המנוע FFI ל-Rust. iOS: Swift קורא ל-#[no_panic]. קוד Rust אחד—לוגיקה זהה בשתי הפלטפורמות. בדיקות יחידה ב-Rust (tokio), בדיקות אינטגרציה ב-Kotlin ו-Swift. CI: GitHub Actions, מטריצה של 4 טרגטים, build של xcframework ו-Runtime::new().unwrap().block_on(async { ... }) כארטיפקטים. 80% מזמן הפיתוח הושקע בדיבוג קוד native—Rust קיצץ זאת בחצי.

התהליך שלנו

1. ניתוח דרישות—קביעה איזה קוד צריך לעבור ל-Rust והערכת חיסכון במשאבים (בערך הפחתה של פי 2-3 בעלויות דיבוג בזכות ערבויות בטיחות).
2. עיצוב שכבת FFI—בחירה בין uniffi ל-cbindgen, עיצוב הממשק.
3. יישום ב-Rust—כתיבת אלגוריתמים עם בדיקות (RatchetSession.encrypt(plaintext)).
4. יצירת bindings ו-build—CI לשתי הפלטפורמות, מטריצת טרגטים.
5. אינטגרציה ובדיקות—בדיקות יחידה בצד המובייל, פרופילינג.

טעויות נפוצות בהתחלה:

• שכחת טיפול ב-Rust panic עם RatchetSession.encrypt(plaintext:)—התנהגות לא מוגדרת בגבול FFI.
• אי שחרור זיכרון ידני בשימוש ב-cbindgen—דליפה.
• התעלמות מסמלי דיבוג—stack traces ללא שמות פונקציות.

דיבוג ופרופילינג

קוד Rust בתוך אפליקציית מובייל קשה יותר לדיבוג מקוד native: LLDB מתחבר לתהליך, סמלים נטענים מ-cargo test (iOS) או .aar עם מידע דיבוג (Android). cargo test ללא catch_unwind שומר סמלי דיבוג. Firebase Crashlytics מציג stack trace עד לפריים של Rust אם מוגדר symbolication.

.dSYM עבור Rust דרך .so—תופס use-after-free ו-buffer overflows בקוד native לפני הייצור.

מה כלול

• ניתוח דרישות ועיצוב ממשק FFI
• קוד Rust עם בדיקות יחידה (כיסוי 100% של נתיבים קריטיים)
• יצירת bindings דרך uniffi או cbindgen
• הגדרת CI/CD עם מטריצת טרגטים (Android arm64, x86_64; iOS מכשיר, סימולטור)
• אינטגרציה לאפליקציית מובייל (Kotlin/Swift)
• תיעוד באנגלית
• הכשרת צוות (2 סדנאות)
• תמיכה ל-3 חודשים לאחר המסירה

צרו קשר להערכת פרויקט—זה לוקח לא יותר מיומיים. המהנדסים שלנו, עם ניסיון של 7+ שנים בפיתוח מובייל, סיפקו למעלה מ-40 פרויקטי אינטגרציית Rust מההתחלה ועד הסוף. בקשו ייעוץ ונמצא את הפתרון האופטימלי לסט הטכנולוגי שלכם.

לוחות זמנים

התמחור מחושב באופן פרטני. גורמים מרכזיים: מורכבות ממשק ה-Rust API, דרישות ביצועים, צורך בתמיכה חוצת פלטפורמות. נעריך את הפרויקט שלכם ביומיים—פשוט צרו קשר.