React Native’ın Yeni Mimarisi Üretimde: JSI, Fabric ve TurboModüller Neleri Değiştiriyor?
React Native’ın yeni mimarisi JSI, Fabric ve TurboModüller, mobil uygulama performansını kökten değiştiriyor. Eski kısıtlamaları aşan bu yeniliklerin ne olduğunu, üretimde nasıl fark yarattığını ve projelerinize nasıl entegre edeceğinizi bu makalede keşfedin.
Giriş: React Native Gelişiminde Yeni Bir Dönem mi Başlıyor?
Mobil uygulama geliştirme dünyası, kullanıcı beklentilerinin sürekli yükselmesiyle birlikte hızla evriliyor. Kullanıcılar artık yalnızca işlevsel değil, aynı zamanda akıcı, hızlı ve kusursuz bir kullanıcı deneyimi sunan uygulamalar talep ediyorlar. Bu beklentiyi karşılamak, geliştiriciler için önemli bir zorluk teşkil ediyor, özellikle de farklı platformlarda (iOS ve Android) tutarlı bir deneyim sunma hedefiyle çalışırken. React Native gibi çapraz platform (cross-platform) framework’ler, tek bir kod tabanıyla her iki platforma da uygulama geliştirme vaadiyle bu zorluğa bir çözüm sunuyor. Ancak, React Native’ın mevcut (eski) mimarisi, bazı temel performans ve geliştirici deneyimi kısıtlamalarıyla karşı karşıyaydı. Özellikle JavaScript katmanı ile yerel (native) katman arasındaki iletişimde kullanılan “Bridge (Köprü)” mekanizması, seri hale getirme (serialization) ve seri halden çıkarma (deserialization) süreçleri nedeniyle bazen darboğazlara yol açabiliyordu. Bu durum, özellikle yoğun animasyonlar, karmaşık kullanıcı arayüzleri veya yüksek performans gerektiren işlemlerde uygulamanın akıcılığını olumsuz etkileyebiliyordu. Geliştiriciler, bu performans sınırlamalarını aşmak için sıklıkla yaratıcı çözümler bulmaya çalışsalar da, bu durum genellikle ek çaba ve zaman gerektiriyordu.
İşte tam da bu noktada React Native ekibi, framework’ün geleceğini şekillendirecek radikal bir mimari revizyonuna imza attı: Yeni Mimari. Bu yeni mimari, JSI (JavaScript Interface), Fabric (Yeni Render Sistemi) ve TurboModüller gibi üç temel bileşenden oluşuyor. Bu bileşenler, eski mimarinin getirdiği sınırlamaları ortadan kaldırmayı, JavaScript ve yerel kod arasındaki iletişimi doğrudan ve daha verimli hale getirmeyi, kullanıcı arayüzü oluşturma süreçlerini iyileştirmeyi ve yerel modüllerin entegrasyonunu hızlandırmayı hedefliyor. Bu yenilikler, React Native uygulamalarının performansını ve yerel uygulamalara olan yakınlığını önemli ölçüde artırma potansiyeli taşıyor. Ayrıca, geliştiricilere daha tutarlı ve tahmin edilebilir bir geliştirme ortamı sunarak, daha karmaşık ve performans odaklı uygulamalar oluşturmalarına olanak tanıyor. Bu makale boyunca, bu yeni mimarinin her bir bileşenini ayrıntılı olarak inceleyecek, ne gibi değişiklikler getirdiğini, üretim ortamında nasıl bir fark yarattığını ve mevcut React Native projelerinizi bu yeni yapıya nasıl taşıyabileceğinizi adım adım ele alacağız. Amacımız, React Native’ın bu heyecan verici yeni dönemine ışık tutarak, geliştiricilerin bu güçlü araçtan en iyi şekilde faydalanmalarına yardımcı olmaktır.
JavaScript Arayüzü (JSI) Nedir ve Neden Önemli?
React Native’ın eski mimarisinin temelinde, JavaScript katmanı ile yerel (native) katman arasında “Bridge (Köprü)” adı verilen bir iletişim mekanizması bulunuyordu. Bu köprü, JavaScript tarafında bir olay (event) tetiklendiğinde veya bir yerel modül çağrıldığında, bu bilgiyi JSON formatına dönüştürüp (seri hale getirme), köprü üzerinden karşı tarafa gönderir ve orada tekrar orijinal formuna dönüştürürdü (seri halden çıkarma). Bu sürekli seri hale getirme ve seri halden çıkarma süreci, özellikle sık ve yoğun iletişim gerektiren senaryolarda ciddi performans darboğazlarına yol açabiliyordu. Örneğin, kullanıcı arayüzünde hızlı kaydırmalar veya karmaşık animasyonlar sırasında, köprüdeki yoğun trafik nedeniyle uygulamanın akıcılığı düşebilir, “jank” olarak adlandırılan takılmalar meydana gelebilirdi. Ayrıca, bu köprü asenkron (asynchronous) çalıştığı için, bazı durumlarda JavaScript ve yerel katman arasındaki senkronizasyon sorunları da yaşanabiliyordu. Bu durum, özellikle hassas zamanlamalar gerektiren uygulamalarda geliştiriciler için ek zorluklar yaratıyordu.
İşte bu noktada JSI (JavaScript Interface) devreye giriyor ve bu eski köprü modelini kökten değiştiriyor. JSI, JavaScript katmanının doğrudan yerel C++ kodunu çağırmasına olanak tanıyan hafif bir arayüzdür. Artık JSON seri hale getirme/seri halden çıkarma süreçlerine gerek kalmıyor; JavaScript ve yerel kod, birbirlerinin hafızasına doğrudan erişebiliyor ve fonksiyonları birbirlerini doğrudan çağırabiliyor. Bu, iki katman arasındaki iletişimi çok daha hızlı ve verimli hale getiriyor. JSI’ın getirdiği en büyük yeniliklerden biri, senkron (synchronous) iletişim yeteneğidir. Eski köprü asenkron olduğu için, bir işlem başlatıldığında sonucunu beklemek için genellikle bir geri arama (callback) mekanizması kullanılırdı. JSI ile ise, yerel bir fonksiyon doğrudan çağrılabilir ve sonucu anında geri alınabilir. Bu, özellikle performans kritik işlemlerde veya belirli UI güncellemelerinde uygulamanın daha duyarlı ve akıcı olmasını sağlar. Örneğin, bir kullanıcının hızlıca birden fazla butona dokunduğu bir senaryoda, JSI sayesinde her dokunuşun yerel katmanda anında işlenmesi ve geri bildirim verilmesi mümkün hale gelir, bu da kullanıcı deneyimini önemli ölçüde iyileştirir.
JSI’ın bir diğer önemli avantajı, tür güvenliği (type safety) sağlamasıdır. JSI, C++ tabanlı olduğu için, JavaScript’ten çağrılan yerel fonksiyonların beklediği argüman türlerini ve döndüreceği değer türlerini derleme zamanında (compile-time) kontrol etme imkanı sunar. Bu, çalışma zamanında (runtime) oluşabilecek hataları azaltır ve kodun daha sağlam olmasını sağlar. Ayrıca, hata ayıklama (debugging) süreçlerini de basitleştirir, çünkü hatalar daha erken aşamada tespit edilebilir. JSI’ın temel amacı, React Native uygulamalarına gerçek yerel uygulama hissini (native feel) kazandırmaktır. Doğrudan iletişim ve senkronizasyon yeteneği sayesinde, React Native uygulamaları artık yerel uygulamalar kadar hızlı ve tepkisel olabilir. Bu, özellikle mobil oyunlar, yoğun veri işleme uygulamaları veya karmaşık grafiklere sahip uygulamalar gibi performansın kritik olduğu alanlarda React Native’ın kullanım alanını genişletiyor. JSI, sadece bir iletişim katmanı olmaktan öte, React Native’ın gelecekteki gelişiminin temelini oluşturan, framework’ün yerel performans hedeflerine ulaşmasında kilit rol oynayan bir teknolojidir. Bu sayede, geliştiriciler artık performans endişeleri olmadan daha yaratıcı ve iddialı mobil uygulamalar geliştirebilirler.
Yeni Render Sistemi Fabric: UI Deneyimini Nasıl Dönüştürüyor?
React Native’ın eski mimarisinde, kullanıcı arayüzü (UI) oluşturma süreci, JavaScript katmanındaki React bileşenlerinin sanal DOM’u (Virtual DOM) güncellemeleriyle başlardı. Bu güncellemeler, “Bridge” üzerinden yerel katmana gönderilir ve yerel UI yöneticisi (Native UI Manager) tarafından yorumlanarak platforma özgü UI elemanlarına dönüştürülürdü. Ancak bu süreç, özellikle karmaşık veya sık güncellenen kullanıcı arayüzlerinde bazı ciddi performans sorunlarına yol açabiliyordu. En belirgin sorunlardan biri, UI güncellemelerinin tek bir iş parçacığında (thread) işlenmesiydi. JavaScript iş parçacığı ve ana yerel UI iş parçacığı arasındaki bu senkronizasyon, JavaScript tarafında yoğun bir işlem olduğunda yerel UI’ın donmasına (blocking) neden olabiliyordu. Örneğin, bir listede hızlı kaydırma yaparken veya birden fazla animasyon aynı anda çalışırken, JavaScript iş parçacığı meşgul olduğunda UI yanıt vermeyi bırakabilir, bu da kullanıcı deneyimini olumsuz etkileyen “jank”lara yol açabilirdi. Ayrıca, eski sistemde yerel UI elemanlarının yaşam döngüsünü yönetmek ve bunları React bileşenleriyle eşleştirmek karmaşık bir süreçti ve bazen beklenmedik davranışlara neden olabiliyordu.
Fabric, React Native’ın render (oluşturma) sistemini baştan aşağı yeniden tasarlayarak bu sorunlara köklü çözümler getiriyor. Fabric, ana yerel UI iş parçacığını serbest bırakarak ve UI güncellemelerini eşzamanlı (concurrent) olarak işleyerek kullanıcı arayüzü deneyimini kökten dönüştürüyor. Fabric’in temel prensiplerinden biri, “eşzamanlı render” yeteneğidir. Bu, birden fazla UI güncellemesinin aynı anda işlenebilmesi ve önceliklendirilerek, daha kritik güncellemelerin (örneğin, kullanıcının dokunuşlarına yanıt) daha önce ekrana yansıtılabilmesi anlamına gelir. Bu sayede, JavaScript iş parçacığı yoğun olsa bile, ana yerel UI iş parçacığı engellenmez ve kullanıcı arayüzü her zaman duyarlı kalır. Örneğin, bir e-ticaret uygulamasında ürün listesi kaydırılırken, hem yeni ürünlerin yüklenmesi hem de kaydırma animasyonunun akıcı bir şekilde devam etmesi Fabric sayesinde mümkün hale gelir. Eski mimaride bu tür senaryolarda takılmalar yaşanması muhtemelken, Fabric ile kullanıcı, uygulamanın her zaman pürüzsüz ve tepkisel olduğunu hisseder.
Fabric ayrıca, yerel UI elemanlarının yönetimini de basitleştiriyor ve iyileştiriyor. Artık React bileşenleri, doğrudan yerel görünümleri (native views) yönetebilen hafif bir C++ katmanı aracılığıyla yerel UI ağacını oluşturuyor. Bu, JavaScript ile yerel UI arasında daha güçlü bir bağlantı kurarak, daha doğru ve performanslı UI güncellemeleri sağlıyor. Özellikle karmaşık jest yönetimi (gesture handling) ve animasyonlar için bu doğrudan entegrasyon büyük avantajlar sunuyor. Örneğin, kaydırılabilir bir kart destesi veya sürükle-bırak işlevselliği gibi etkileşimler, Fabric ile yerel performansla çok daha kolay ve akıcı bir şekilde geliştirilebilir. Geliştiriciler, daha önce yerel modüller veya karmaşık workarounds (geçici çözümler) gerektiren birçok UI etkileşimini artık doğrudan React Native bileşenleri içinde, daha az çabayla gerçekleştirebilirler. Bu, sadece performansı artırmakla kalmaz, aynı zamanda geliştirici deneyimini de önemli ölçüde iyileştirir. Fabric, React Native’ın “bir kere yaz, her yerde çalıştır” felsefesini, “bir kere yaz, yerel performansla çalıştır” seviyesine taşıyarak, mobil uygulama geliştirme standartlarını yeniden belirliyor.
TurboModüller ile Native Modül Entegrasyonu Nasıl Hızlanıyor?
React Native’ın gücü, yalnızca JavaScript ile UI oluşturmakla kalmaz, aynı zamanda platforma özgü yerel (native) yeteneklere erişim sağlamasından da gelir. Eski mimaride bu erişim, “Native Modüller” aracılığıyla sağlanıyordu. Bir kamera erişimi, konum servisleri veya cihazın sensörleri gibi yerel işlevlere ihtiyaç duyulduğunda, geliştiriciler bu işlevleri yerel kodda (Java/Kotlin for Android, Objective-C/Swift for iOS) yazar ve ardından JavaScript tarafından çağrılabilen bir köprü (Bridge) modülü olarak dışa aktarırlardı. Ancak bu yaklaşımın bazı dezavantajları vardı. En önemlilerinden biri, tüm yerel modüllerin uygulama başlangıcında (startup) yüklenmesiydi. Uygulamanızda onlarca veya yüzlerce yerel modül varsa, bunların hepsi uygulama açılırken belleğe yüklenir ve bu da başlangıç süresini uzatır, bellek tüketimini artırırdı. Özellikle büyük ve özellik açısından zengin uygulamalar için bu durum, kullanıcıların uygulamanın açılmasını beklerken yaşadığı hayal kırıklığına yol açabilirdi.
TurboModüller, bu sorunları çözmek ve yerel modül entegrasyonunu modernize etmek için tasarlandı. TurboModüller’in temel özelliği, “tembel yükleme” (lazy loading) yeteneğidir. Yani, bir yerel modül yalnızca JavaScript tarafından gerçekten ihtiyaç duyulduğunda yüklenir ve başlatılır. Bu, uygulama başlangıç süresini önemli ölçüde kısaltır ve bellek kullanımını optimize eder. Örneğin, bir uygulamanın kamera modülü yalnızca kullanıcı kamera simgesine dokunduğunda yüklenir, uygulamanın açılışında değil. Bu sayede, uygulamanın genel performansında gözle görülür bir iyileşme sağlanır ve kullanıcılar daha hızlı bir başlangıç deneyimi yaşarlar. Tembel yükleme, özellikle modül sayısı fazla olan büyük ölçekli uygulamalar için hayati bir avantajdır.
TurboModüller’in bir diğer kritik yeniliği, “Codegen (Kod Üretimi)” mekanizmasıdır. Codegen, geliştiricilerin JavaScript tarafında yazdığı bir arayüz tanım dosyasından (örneğin, bir TypeScript arayüzü), hem JavaScript hem de yerel (Android için Java/Kotlin, iOS için Objective-C/Swift) taraflar için otomatik olarak tür güvenli (type-safe) kod üretir. Bu, geliştiricilerin yerel modüllerle çalışırken daha az hata yapmasını sağlar, çünkü tür uyumsuzlukları derleme zamanında tespit edilir. Ayrıca, bu otomatik kod üretimi sayesinde, geliştiricilerin yerel modüller için köprü kodunu manuel olarak yazma ihtiyacı ortadan kalkar, bu da geliştirme sürecini hızlandırır ve tekrarlayan işleri azaltır. Codegen, yerel modüllerin daha tutarlı ve sürdürülebilir olmasını sağlar.
TurboModüller ayrıca, JSI’ın doğrudan iletişim yeteneklerinden de faydalanır. Bu sayede, yerel modül çağrıları artık köprü üzerinden JSON seri hale getirme/seri halden çıkarma olmadan doğrudan gerçekleşir. Bu, özellikle sıkça çağrılan veya büyük miktarda veri işleyen yerel modüller için performansı önemli ölçüde artırır. Örneğin, bir resim işleme modülü veya karmaşık bir matematiksel hesaplama yapan bir modül, TurboModüller sayesinde çok daha hızlı çalışabilir. Kısacası, TurboModüller, React Native’ın yerel yeteneklere erişimini daha hızlı, daha güvenilir ve daha geliştirici dostu hale getiriyor. Bu yenilikler, React Native’ın yerel uygulamalarla arasındaki performans farkını kapatma yolunda önemli bir adımı temsil ediyor ve geliştiricilere daha güçlü ve esnek bir araç seti sunuyor.
Yeni Mimariyi Üretimde Kullanmak: Gerçek Dünya Senaryolarında Ne Beklemeliyiz?
React Native’ın yeni mimarisi, JSI, Fabric ve TurboModüller ile birlikte, üretim ortamında uygulamaların performansını ve kullanıcı deneyimini kökten değiştirecek potansiyele sahip. Ancak bu değişim, sadece teknik bir yükseltmeden ibaret değil, aynı zamanda geliştirme süreçlerini ve proje yönetimini de etkileyen bir dizi avantaj ve zorluk getiriyor.
Performans ve Kullanıcı Deneyimi Açısından Ne Gibi İyileşmeler Var?
Yeni mimarinin üretim ortamındaki en belirgin faydası, şüphesiz ki performans artışıdır. JSI sayesinde JavaScript ve yerel kod arasındaki doğrudan iletişim, eski köprünün getirdiği seri hale getirme ve seri halden çıkarma yükünü ortadan kaldırır. Bu, özellikle yoğun etkileşimli uygulamalarda, örneğin bir sosyal medya akışında sürekli kaydırma yaparken veya bir oyun uygulamasında hızlı tepkiler verirken fark edilir derecede daha akıcı bir deneyim sunar. Uygulamanın başlangıç süresi (cold start time) de TurboModüller’in tembel yükleme (lazy loading) yeteneği sayesinde önemli ölçüde kısalır. Artık kullanılmayan modüller uygulama açılışında belleğe yüklenmediği için, kullanıcılar uygulamaların daha hızlı açıldığını ve daha çabuk kullanılabilir hale geldiğini fark ederler. Bu, özellikle mobil veri bağlantılarının yavaş olduğu veya eski cihazlarda çalışan kullanıcılar için kritik bir iyileşmedir.
Fabric render sistemi ise, kullanıcı arayüzünün (UI) genel akıcılığını ve yanıt verebilirliğini artırır. Eşzamanlı render yeteneği sayesinde, JavaScript iş parçacığı yoğun olsa bile ana yerel UI iş parçacığı engellenmez. Bu, animasyonların daha pürüzsüz olmasını, jestlerin (gestures) daha doğru algılanmasını ve UI’ın genel olarak daha “yerel” bir his vermesini sağlar. Örneğin, bir finans uygulamasında karmaşık grafikler veya bir harita uygulamasında yüksek çözünürlüklü harita verileri yüklenirken bile, kullanıcı arayüzü donmadan ve takılmadan akıcı bir şekilde çalışmaya devam edebilir. Bir e-ticaret uygulamasında, ürün detay sayfalarındaki 3D görünümler veya artırılmış gerçeklik (AR) özellikleri gibi performans yoğun bileşenler, Fabric sayesinde çok daha verimli bir şekilde işlenebilir. Bu sayede, kullanıcılar uygulamanın sadece hızlı değil, aynı zamanda güvenilir ve kesintisiz bir deneyim sunduğunu hissederler. Bellek kullanımı açısından da iyileşmeler beklenmektedir, zira eski köprüdeki veri kopyalama ve dönüştürme işlemleri ortadan kalkar. Bu, özellikle bellek kısıtlı cihazlarda veya uzun süreli kullanımlarda uygulamanın daha stabil çalışmasına katkıda bulunur. Kısacası, yeni mimari, React Native uygulamalarını yerel uygulamalara çok daha yakın bir performans ve kullanıcı deneyimi seviyesine taşıyarak, geliştiricilerin daha iddialı ve üst düzey mobil deneyimler sunmasına olanak tanır. Bu iyileşmeler, uygulama mağazalarındaki kullanıcı yorumlarına ve genel uygulama başarısına doğrudan yansıyacaktır.
Eski Mimariden Yeniye Geçişte Karşılaşılabilecek Engeller Nelerdir?
Yeni mimarinin sunduğu tüm bu avantajlara rağmen, mevcut React Native projelerini bu yeni yapıya taşımak belirli zorlukları da beraberinde getirecektir. En büyük zorluklardan biri, mevcut yerel modüllerin ve özel UI bileşenlerinin (custom native UI components) yeni mimariye uyarlanmasıdır. Eski yerel modüller, köprü tabanlı API’leri kullanırken, TurboModüller ve Fabric, JSI tabanlı yeni API’ler gerektirir. Bu da, mevcut yerel kod tabanının gözden geçirilmesi ve büyük ölçüde yeniden yazılması gerektiği anlamına gelebilir. Özellikle üçüncü taraf kütüphaneler (third-party libraries) veya özel olarak geliştirilmiş karmaşık yerel modüller kullanan büyük projeler için bu geçiş süreci zaman alıcı ve maliyetli olabilir. Geliştiricilerin, TurboModüller ve Fabric için Codegen tarafından üretilen arayüzleri nasıl kullanacaklarını öğrenmeleri ve mevcut kodlarını bu yeni yapıya uygun hale getirmeleri gerekecektir.
Bir diğer önemli engel, araçların (tooling) olgunluk seviyesidir. Yeni mimari henüz nispeten yeni olduğu için, hata ayıklama (debugging) araçları, test framework’leri ve geliştirme ortamı entegrasyonları eski mimarideki kadar olgunlaşmamış olabilir. Geliştiriciler, yeni mimariye özgü sorunları teşhis etmek ve çözmek için yeni yaklaşımlar öğrenmek zorunda kalabilirler. Bu durum, özellikle geçişin ilk aşamalarında geliştirme hızını yavaşlatabilir. Ayrıca, topluluk desteği ve dokümantasyon da zamanla gelişecektir. Geliştiriciler, karşılaştıkları sorunlara çözüm bulmak için daha fazla araştırma yapmak veya kendi çözümlerini üretmek zorunda kalabilirler. Bu durum, özellikle küçük ekipler veya bireysel geliştiriciler için ek bir yük oluşturabilir.
Geçiş sürecinde karşılaşılabilecek bir başka zorluk ise, geriye dönük uyumluluk (backward compatibility) sorunlarıdır. Yeni mimariye geçiş, bazı eski React Native API’lerinin veya üçüncü taraf kütüphanelerinin artık desteklenmemesine neden olabilir. Bu durum, projenin bağımlılıklarını güncelleme ve uyumsuzlukları giderme ihtiyacını ortaya çıkarır. Özellikle eski React Native sürümlerinde geliştirilmiş projeler için bu geçiş daha karmaşık olabilir. Bununla birlikte, React Native ekibi, “köprü uyumluluk katmanı” gibi çözümler sunarak kademeli geçişi mümkün kılmayı hedeflemektedir. Bu, geliştiricilerin uygulamalarını tamamen yeni mimariye taşımadan önce, Fabric veya TurboModüller’i parça parça etkinleştirmelerine olanak tanır. Bu kademeli yaklaşım, riskleri azaltır ve geçiş sürecini daha yönetilebilir hale getirir. Sonuç olarak, yeni mimariye geçiş, önemli avantajlar sunsa da, dikkatli bir planlama, yeterli kaynak tahsisi ve geliştirici ekibinin yeni teknolojilere adaptasyonu için zaman ayırmayı gerektiren stratejik bir karardır.
Yeni Mimarinin Uygulanması ve Mevcut Projeler İçin Geçiş Adımları Nelerdir?
React Native’ın yeni mimarisine geçiş, mevcut projeler için kapsamlı bir süreç olabilir ancak sunduğu potansiyel faydalar göz önüne alındığında bu çabaya değer. Bu süreç, genellikle aşamalı bir yaklaşımla ele alınır ve React Native ekibi de bu geçişi kolaylaştırmak için çeşitli araçlar ve yönergeler sunar.
Yeni Mimarinin Projenize Entegrasyonu Nasıl Yapılır?
Yeni mimariyi projenize entegre etmenin ilk adımı, genellikle React Native CLI (Komut Satırı Arayüzü) tarafından sağlanan yükseltme araçlarını kullanmaktır. React Native’ın belirli bir sürümünden (genellikle 0.68 ve sonrası) itibaren yeni mimari deneysel olarak etkinleştirilebilir. Bu, genellikle projenizin android/gradle.properties veya ios/Podfile dosyalarında belirli bayrakları (flags) etkinleştirerek yapılır. Örneğin, Android için newArchEnabled=true gibi bir ayar bulunabilir.
# android/gradle.properties dosyasında
newArchEnabled=true
Bu bayrakları etkinleştirdikten sonra, projenizin bağımlılıklarını güncellemeli ve yerel kodunuzu yeniden derlemelisiniz. iOS tarafında ise pod install komutunu RCT_NEW_ARCH_ENABLED=1 pod install gibi bir ortam değişkeniyle çalıştırmak gerekebilir. Bu adımlar, yeni mimariyle uyumlu yerel bağımlılıkların yüklenmesini ve projenizin yeni render sistemi Fabric ve TurboModüller'i kullanmaya başlamasını sağlar. Ancak, bu sadece başlangıçtır. Yeni mimarinin tam potansiyelinden yararlanmak için mevcut yerel modüllerinizi ve özel UI bileşenlerinizi TurboModüller ve Fabric uyumlu hale getirmeniz gerekecektir.
Mevcut Yerel Modüllerinizi TurboModüllere Dönüştürmek
Mevcut yerel modüllerinizi TurboModüllere dönüştürmek, genellikle en çok çaba gerektiren adımdır. Bu süreç, Codegen tarafından otomatik olarak kod üretilmesi için JavaScript tarafında bir arayüz tanımı (interface definition) oluşturmayı içerir. Bu tanım, modülün hangi fonksiyonları dışa aktaracağını, bu fonksiyonların hangi argümanları alacağını ve hangi türde değerler döndüreceğini belirtir.
Örnek bir TurboModule arayüz tanımı (JavaScript/TypeScript):
// NativeAwesomeModule.ts
import type {