Kotlin Multiplatform Proje Yapısı

Ortak Kod

Bir uygulamanın temel mantığını tek bir yerde tutmanın getirisi nedir? Cevap net: hız, güven ve bakım kolaylığı. Ortak kod, Kotlin Multiplatform ile Tek Kodla Çok Platform vizyonunun kalbinde yer alır. İş mantığı, veri modelleri ve temel util ler ortak modülde toplanır; ekran, girdi ve platforma özgü entegrasyonlar ise bağımsız parçalarda kalır. Bu yaklaşım, Android ve iOS ekiplerinin aynı kuralları paylaşmasına olanak verir; hatalı versiyonların çarpıklığını azaltır, testleri tek bir yerde çalıştırır ve varyasyonlardan doğan maliyeti düşürür. Ancak hangi katmanı paylaşmalı, hangi kuralları platforma özgü tutmalı sorusu hemen karşılaşılan bir dengedir. Düşünün ki sipariş iş akışını temsil eden domain modelleri ortak kalırken, ağ katmanı platforma özgü olgunlukla mı ilerlemeli yoksa evrensel bir serializer mı kullanılmalı? Bu kararlar projenin sağlığı için kritik anlar getirir.

Bu bölümde ortak kod katmanını netleştirecek, hangi sınıfların paylaşılacağını ve hangi sorumlulukların platforma bırakılacağını ele alacağız. Kotlin Multiplatform ile Tek Kodla Çok Platform yaklaşımı nasıl çalışır, hangi alanlar güvenli paylaşım alanı olur, hangi noktalar dikkat ister, ve ne gibi başarı göstergeleriyle ilerlersiniz sorularına yanıt bulacaksınız.

Adımlarınız için kısa bir yol haritası şu şekildedir:

1. Paylaşılabilir iş mantığını belirleyin ve temel domain modelleri ile servisleri ortak modüle taşıyın.
2. Platforma özgü veri dönüşümlerini ve serialization stratejilerini belirleyin.
3. Ortak kodda test kapsamını genişletin ve platformlar arası davranış tutarlılığını hedefleyin.
4. Expect/Actual kavramını kademeli kullanarak kararlı bir paylaşım planı oluşturun.
5. UI katmanı için uygun arayüzleri platforma özgü kalacak şekilde bağlayın.

Hedef Platform Modülleri

Çoğunlukla karşılaşılan konfor, ortak kodu yazarken ölçeklenebilir bir modül yapısı kurmaktır. Her hedef için özel modüller, paylaşılan kodla uç uca değerlendirildiğinde sistemin esnekliğini artırır. Android ve iOS için androidMain ve iosMain gibi kapsayıcı işlevler yerine, platforma özgü davranışların net sınırlarını çizmek işe yarar. Örneğin ağ istekleri için ortak bir ağ katmanı yazılıp, kullanıcı arayüzü ya da platforma özgü güvenlik akışları ayrı modüllerde tutulabilir. Bu yaklaşım, Kotlin Multiplatform ile Tek Kodla Çok Platform ile elde edilen verimliliğin yanında platformlar arası güvenli adaptasyonu mümkün kılar. Ayrıca bağımlılık yönetimini sadeleştirir; platforma özgü bağımlılıklar bağımsız olarak güncellenebilir.

Gerçek dünyadan bir senaryo: bir mobil uygulama hem Android hem iOS tepkisini aynı iş akışıyla sağlar. Ortak ağ katmanı senkronize olarak çalışır; kullanıcı kimlik doğrulaması, hatalar ve veri formatı yönetimi ortak kalır. Ancak iOS tarafında calculateGradient veya UI animasyonları gibi platforma özgü estetiklere ihtiyaç duyabiliriz. Bu durumda ortak kod güvenilir kalırken, platforma özgü modüller performans ve kullanıcı deneyimi için ince ayar yapar.

Uygulama adımları şu şekilde ilerleyin:

1. Modülerleşmeyi hedefleyin; ortak kod, platforma özgü modüller ve arayüz katmanını net çizgilerle ayırın.
2. Bağımlılıkları paylaşırken expect/actual desenini stratejik olarak kullanın.
3. Ağ ve veri katmanını ortak tutarken platforma özgü güvenlik ve kimlik süreçlerini ayrı modülde yönetin.
4. Platforma özel UI bağlamalarını yöneten köprüleri sade tutun.
5. CI/CD ile her platform için ayrı ama uyumlu çalışmayı hedefleyen test akışları kurun.

Proje Organizasyonu

Proje organizasyonu, tek kodla çok platform yaklaşımını sürdürülebilir kılar. Dosya yapısında ortak kod için shared veya common dizinleri, platforma özgü kaynaklar için androidMain, iosMain gibi bölümler öncelik kazanır. Gradle ile çok modüllü yapı kurmak, bağımlılık ağacını sade tutmak ve build cache kullanımıyla geliştirme hızını artırmak için kritiktir. Bu sayede ekipler kendi alanlarında uzmanlaşabilir; ortak paylaşımlar güvenli bir zemin üzerinde büyür. Ancak organizasyonda sık görülen hata, çok sayıda platform bağımlılığını ortak koda çekmektir; bu, bakımı zorlaştırır ve gereksiz karmaşa doğurur. Bu nedenle net sınırlar, otomatik testler ve düzenli refactoring ile disiplinli bir yaklaşım gerekir.

Uygulamaya dönüştürme süreci şu adımlarla ilerletilebilir:

1. Projeyi konuya göre modüllere bölün; ortak, platforma özgü ve UI köprülerini açıkça ayırın.
2. SourceSet ve Gradle konfigürasyonlarını netleştirin; dependency ve test akışlarını her modül için tanımlayın.
3. Expect/Actual kullanımını bir politika olarak benimseyin; aşırı paylaşımı önleyin.
4. CI/CD üzerinde çapraz platform testlerini otomatikleştirin; her platform için simülatör/emülatör entegrasyonunu sağlayın.
5. Refactoring zamanlarında regresyon testlerini önceliklendirin ve paylaşılabilir mantığı sade tutun.

Ortak Kodla Paylaşılan İş Mantığı

Birlikte Başlarken: Ortak Dil ile Korkuları Aşmak

Bir ekip, iOS, Android ve web üzerinde aynı veriyle çalışan bir uygulama geliştirirken boğulmuş hissedebilir. Farklı platformlar, farklı veri modelleri, farklı hata mesajları ve farklı sürüm cikletleriyle birbirinden kopuk çalışır. Bu noktada ortak bir dil kurmak, sadece teknik bir tercih değildir; ekip kültürünün dönüştüğü bir adımdır. Kotlin Multiplatform ile Tek Kodla Çok Platform ile veri modellerini ve iş akışlarını tek kaynakta paylaşmak, iletişimi sadeleştirir, sürüm yönetimini tek elden denetmenize olanak verir. Başlangıçta riskli görünse de, bir kez kurulduğunda değişiklikler parça parça tüm platformlarda aynı hızda ilerler; hata tespitleri erken yapılır ve müşteri tarafında kesinti azaltılır. Bu bölümde, ortak veri modellerinin ve iş akışlarının tek kaynaktan nasıl beslendiğini, neden bu yaklaşımın uzun vadede karlı olduğunun altını çizerek anlatacağım. Gerçek hayattan örnekler ve karşıt görüşlerle ilerleyelim, çünkü inançlarımızı kırmak bazen ilerlemenin en hızlı yoludur.

Veri Modellerini Tek Kaynaktan Paylaşmak: Açıkça Tanımlanan Bir Temel

Bir e-ticaret platformunda kullanıcı profili, sipariş ve ürün stokları gibi temel kavramlar üzerinde çalışırken, veri modellerini tek kaynaktan paylaşmak iş akışlarını da sadeleştirir. Ortak model sınıfları içinde User, Order, Product gibi domain öğeleri tek yerde tanımlanır; platformlar bu modelleri kendi ihtiyaçlarına göre adapt eder. Buradaki kilit fikir Kotlin Multiplatform ile Tek Kodla Çok Platform kapsamında expect ve actual veya paylaşılmış data transfer objeleri (DTO) üzerinden köprülemeyi sağlamaktır. Bu sayede bir değişiklik yapıldığında tüm platformlar aynı şekilde tepki verir; geride kalan platforma özel ayrıntılar için yalnızca adaptörler gerekir. Ancak bu yaklaşım hafife alınmamalıdır; eşitlik isterken platforma özgü semantik farklılıklar ortaya çıkabilir. Doğru tasarlanmış bir sürüm yönetimi, net boundary'ler ve iyi testler olmadan paylaşım işe yaramaz. Gerçek dünyadan bir vaka: bir bankacılık uygulamasındaki hesap ve işlem modelleri ortak tutulduğunda hata mesajları, doğrulama kuralları ve dönüş değerleri tek bir yerde tutularak müşteriye daha güvenilir bir deneyim sunulur.

İş Mantığını Paylaşmanın Gücü: Akışlar Birbirine Bağlı Olarak Nasıl Çalışır

İş mantığı paylaşımı yalnızca modelleri aynılaştırmak değildir; aynı zamanda kullanıcı etkileşimlerinden bağımsız olarak gerçekleşen kararları da tek bir katmanda toplamak anlamına gelir. Örneğin bir sipariş akışını düşünün: sepete eklenen ürünün stok durumuna göre sipariş onayı, ödeme ve bildirim adımları ortak bir iş akışında tanımlanır. Platformlar bu adımları kullanıcı arayüzüne uygun şekilde yönlendirir; ancak kararlar merkezi olarak alınır. Böylece, yeni bir platform çıktığında sadece adaptörler güncellenir; iş mantığı bozulmaz. Konforlu olan bu simetri, aynı zamanda zor bir noktayı da getirir: test kapsamı genişler ve kontrat testleri hayati hale gelir. Bir ekip için en büyük hayal kırıklığı, platformlar arası adımların uyumsuzluğudur; bu yüzden ortak bir iş mantığı katmanı, durum makineleri veya akış tanımlayıcıları ile netleştirilmelidir. İçsel motivasyonunuz yüksekse, paylaşılan iş akışlarının hem hız hem de güvenilirlik getirdiğini deneyimleyeceksiniz, ve bu değişimin ekip ilişkilerini güçlendirdiğini göreceksiniz.

Pratik Uygulama ve Kaçınılması Gereken Tuzaklar

Bu çerçeveyi hayata geçirirken dikkat edeceğiniz bazı pratik noktalar var. Kotlin Multiplatform ile Tek Kodla Çok Platform yaklaşımında veri modelleri ve iş akışlarını paylaşıyorsanız şu adımları izlemek faydalıdır.

1. Amaç ve sınırları netleştirin: hangi alanlar ortak, hangi alanlar platforma özel olacak kararını yazılı ve görsel olarak belirleyin.
2. Ortak veri modellerini tasarlayın: domain odaklı, serializer dostu, versiyonlanabilir modeller oluşturun; platformlar arası uyum için boundary'leri açık tutun.
3. Platform adaptörlerini kurun: mapperlar, serializer konfigürasyonları ve hata yönetimini her platform için bağımsız fakat ortak kurallara bağlayın.
4. Test stratejisi kurun: ortak testler, platforma özgü testler ve kontrat testleri ile kapsama alanını genişletin; hatalar ortak yerde ortaya çıkar.
5. Geri bildirim ve ürüne dönüş: müşteri senaryolarını kapsayacak erken demoslar ve iteratif iyileştirme döngüleri kurun; başarısızlık anında hızlı düzeltme planı olsun.

İçsel çatışmalar, paylaşılan mantığın aşırı genelleştirilmesi veya platforma özgü performans gereksinimlerinin gözden kaçırılması gibi hatalar sık görülebilir. Ancak doğru dengede bu yaklaşım, sürümü hızlandırır, iletişimi sadeleştirir ve ekip psikolojisini güçlendirir. Sonuç olarak tek kaynaklı paylaşım, yalnızca teknik bir tercih değil, organizasyonel verimliliğin anahtarıdır. Başarı için adım adım ilerleyin ve her adımı ölçülebilir hedeflerle izleyin.

Platform Özelleştirme ve Modül Yönetimi

İlk hatıra ve gerçek: Tek kodla çok platform hayaliyle yüzleşme

Bir proje başlarken aklınızda hep aynı soru vardır: Her platform için ayrı paraşütler mi çekeceğiz yoksa tek bir yama ile her yere inebilir miyiz? Gerçek şu ki Platforma özel davranışlar, kullanıcı arayüzü farklılıkları ve API sürümleri işin içinde kaybolmanıza yol açar. Siz de sık sık ortak kodu paylaşmaya çalışırken platforma özgü eksikliklerle boğuşuyor musunuz? Bu noktada motivasyon düşebilir; sürekli derecede commit çıkarmak, sürüm uyuşmazlıkları ve test kapsamı daralıp genişleyen bir sürpriz kutusu gibi hissedebilirsiniz. Ancak doğru yaklaşım bu ikilemi aşmaktan geçer. Çünkü Kotlin Multiplatform ile Tek Kodla Çok Platform felsefesini gerçek hayata taşıdığınızda, ortak mantığı korurken her platforma özgü davranışı zarifçe izole edebiliyorsunuz. Bu bölümde platforma özel kodları modüller halinde yönetmenin temel faydalarını ve neden bu stratejiyi benimsemeniz gerektiğini hikâye üzerinden göreceğiz.

İlk adım olarak, kendi yolculuğunuzun sıkıntılarını kabul etmek gerekiyor. Sık görülmüş bir yanlış, platforma özgü kodları tek dosyaya sıkıştırmaktır. Oysa gerçek güç, modüller halinde ayrıştırılmış katmanlar yaratmaktır. Bu yaklaşım, uzun vadede bakım maliyetini düşürür, hata izolasyonunu güçlendirir ve yeni platformlar için hızla adaptasyon sağlar. Siz bu yöntemin inceliklerini kavradığınızda, dağıtım süreci hızlanır ve kullanıcı deneyisi tutarlılığı artar. Bu bölümde kurduğunuz alışkanlıklar, sonunda Kotlin Multiplatform ile Tek Kodla Çok Platform vizyonunu somut bir mimariye dönüştürecek. Ancak önce neden bu modülü inşa etmek gerektiğini içselleştirelim.

Modüllerle yönetimin temelleri: hangi katman nerede

Platforma özel kodları modüller halinde yönetmek, iki temel fikri kapsar: ortak iş mantığını paylaşıp platforma özgü davranışları ayrıca tutmak. Bu, paylaşılan API ile platform bağımsız özellikleri ortak modülde, cihaz veya işletim sistemi özel APİ çağrılarını ise ilgili platform modülüne taşımak anlamına gelir. Bu yaklaşım ile şu avantajlar elde edilir:

• Geliştirme hızında artış ve yeniden kullanım oranında yükseliş
• Hata izole edilmesi ve test güvenliğinin artması
• Yeni platform eklemede risklerin azalması
• CI/CD süreçlerinde daha temiz entegrasyon ve bağımlılık yönetimi

Pratik olarak temel yapı şu şekilde kurulur: commonMain ile ortak arayüz ve iş mantığı; androidMain ve iosMain gibi platform modülleri ile özel implementasyonlar. Bu sayede expect/actual desenini kullanarak davranışları platforma göre özelleştirirsiniz. Ayrıca bağımlılıkları net sınırlamak, hangi API’nin hangi katmanda çalışacağını netleştirmek, ileride genişlemeyi kolaylaştırır. Bu bölümde hedefiniz, kod tabanınızın her platformda tek bir düşünceyle ilerlemesini sağlamak ve gereksiz tekrarlardan kaçınmaktır.

Entegrasyon ve uygulama stratejileri ile somut adımlar

Kodlarınız artık modüler olduğunda entegrasyon ve operasyon süreçlerinde de fark yaratan bir avantaj elde edersiniz. Bir proje örneğinde platforma özel modülleri bağımsız olarak test etmek mümkün olur, bu da hata tespitini hızlandırır. Ayrıca tasarım kararlarınızı paylaşan bir davranış sözleşmesi, proje büyüdükçe dengenin korunmasına yardımcı olur. Aşağıdaki adımlar ile pratiğe dökebilirsiniz:

1. Projenizi modüllere bölün ve ortak kodu commonMain altında toplayın; platformlara özgü kodları androidMain, iosMain gibi modüllerde konumlandırın.
2. Gradle yapılandırmasını sadeleştirin; hedeflenen platformlar için bağımlılık sınırlarını net tutun.
3. Expect/Actual kullanarak platforma özgü davranışları soyutlayın; ortak API ile platformlar arası uyumu koruyun.
4. Test stratejisini iki katmana yayılacak şekilde planlayın; ortak mantık için unit tests, platforma özgü özellik için platform testleri yazın.
5. CI/CD akışında modüler yapıyı yansıtarak her platform için ayrı тест akışları kurun; derleme hatalarını hemen yakalayın.

Düşünce kırılması olarak şu noktayı paylaşmak isterim: bazı geliştiriciler her platform için “sanal bir köprü” kurmaya çalışır; oysa Kotlin Multiplatform ile Tek Kodla Çok Platform yaklaşımıyla önce köprüyü mantıksal olarak kurup sonra fiziksel olarak konumlandırırsınız. Böylece entegrasyonlar daha temiz, hatalar daha hızlı izole edilir ve ileride ekleyeceğiniz yeni platformlar için temel çok daha sağlam olur. Şimdi adım adım uygulanabilir bir planla ilerleyelim ve kendi projenizi bu modellere göre dönüştürün.

Özetle, Platforma özel kodları modüller halinde yönetme ve entegrasyon stratejisi ile ne elde edersiniz: bakım maliyeti düşer, geliştirme verimliliği artar, güvenilirlik yükselir. Bu yaklaşım ile siz de kendi başarı öykünüzü yazabilirsiniz. Bir sonraki adımda kendi projelerinize özgü modüler mimariyi hayata geçirmek için uygulanabilir bir yol haritası sunacağım.

Test ve Dağıtım için KMP İpuçları

Bir proje düşünün ki Android, iOS ve masaüstü hedefleri tek bir kod tabanından besleniyor. CI/CD hattınız hızla büyüyor, testler bazen gecikiyor ve her platform için ayrı sürümler mi üretiyorsunuz? Böyle bir anda Kotlin Multiplatform ile Tek Kodla Çok Platform yaklaşımı gerçek gücünü gösterir. Burada amacınız yalnızca çalıştırmak değil, güvenilirliği artırmak, hataları erken yakalamak ve dağıtımı sorunsuz kılmak. Özellikle CI/CD tarafında akıllı adımlar ile zaman kaybını azaltır, ekipler arası uyumu güçlendirirsiniz. Bu bölümde, otomatik testler ve dağıtım stratejileriyle birleşen sağlam bir KMP iş akışını hayata geçirmenin yollarını paylaşacağım.

CI CD ile KMP için Entegre İş Akışları

İlk adımın dizel gibi çalışması için güvenli bir CI/CD hattı gerekir. Kotlin Multiplatform ile Tek Kodla Çok Platform yaklaşımını benimsemiş bir proje için Gradle ile çok platformlu hedefler üzerinde paralel inşa ve test akışları kurmak kritik. Örnek olarak GitHub Actions veya Jenkins üzerinde bir matrix kurulumu düşünün. MacOS üzerinde iOS hedeflerini, Linux ve Windows üzerinde ise Android ve paylaşılan kodu derlemek, test etmek mümkün olsun. Önceliklerden biri önbellekleme; Gradle ve Kotlin derleyici sonuçlarını saklayarak sonraki çalışmaları hızlandırırsınız. Ayrıca her hedef için ayrı test adımları tanımlayın ve ortak kodun testlerini commonMain altında koşturun. Yapılandırmada güvenli sürüm yönetimi ve artifact publishing planı da önemli; her sürümde hangi platformlarda hangi sürümlerin üretildiğini net tutun. Bu sayede herkes hangi adımda neyin hedeflendiğini bilir ve hattaki belirsizlik azalır.

• Kapsamlı bir matrix iş akışı kurun ve macOS runner gereksinimini unutmayın
• Önbellekleri etkin kullanarak inşa sürelerini düşürün
• Ortak kodun testlerini ortak bir test çerçevesinde koşturun
• Platforma özgü derleyici ve bağımlılık sürümlerini sürüm yönetimi ile sabitleyin
• Artifacts ve yayımlama adımlarını otomatikleştirerek her platform için consistent paketler üretin

Olası engeller arasında uzun yürüyen testler ve hataların platformlar arası uyumsuzlukları olabilir. Bu durumu engellemenin yolu ise testleri hızlı ve güvenilir parçalara ayırmak, flaky testleri izole etmek ve mümkünse platforma özgü testleri minimumda tutmaktır. Ayrıca dağıtım sürecinde dış bağımlılıkları minimize edin; etkili bir rollback mekanizması ile hatalı bir sürümde hızlı toparlanma sağlayın. Böylece Kotlin Multiplatform ile Tek Kodla Çok Platform hedefi sadece yazılımı değil hataları da birleştiren bir hat hızına dönüşür.

Otomatik Testler için Stratejiler

Otomatik testler, dağıtım güvenliğinin kalbidir. KMP ile test mimarisi kurarken ortak kodun testleri test sınıfı olarak commonTest içinde yazılırken platforma özgü davranışlar için expect ve actual yapıları kullanılır. Gerçekçi bir senaryo: Android tarafında kullanıcı arayüzü davranışlarının bazıları iOS veya masaüstü platformlarında farklılık gösterebilir; bu durumlar için platform özel testler kullanırsınız. Test piramidine sadık kalarak birimler, entegrasyonlar ve end-to-end testlerini dengeli şekilde dağıtın. Paralel çalışabilecek testleri paralel olarak koşturarak zaman kazanın. Ayrıca test sonuçlarını CI tarafında görsel olarak raporlayın ve hatalı geçişleri hızlıca karara bağlayın. KMP ile Tek Kodla Çok Platform yaklaşımında test kapsamını geniş tutmak, ilerideki dağıtımlarda sürpriz hataların önüne geçer ve güvenilirliğin temel taşını oluşturur.

• Ortak kodu olan commonTest ile temel güvenliği sağlayın
• Platforma özgü davranışlar için ayrı testler ekleyin
• Test piramidine sadık kalın ve testleri hızla çalıştırın
• Flaky testleri izole edin ve stabilizasyon adımlarını otomatikleştirin

Çok Platformlu Dağıtım Stratejileri ve Dağıtım Otomasyonu

Dağıtım stratejileri, geliştirilen çözüme dair güveni müşteri deneyimine dönüştürür. Kotlin Multiplatform ile Tek Kodla Çok Platform ile üretilen kütüphane veya uygulama paketlerini platformlar arasında sorunsuz iletmek için dağıtım otomasyonuna odaklanın. iOS için bir dinamik ya da statik çerçeve üretmek gerektiğinde Gradle ile üretim adımlarını yapılandırın; Android için AAR paketleri, masaüstü için native kütüphane veya ortak paylaşılan bir kaptır. Dağıtım için bir sürümleme stratejisi belirleyin ve her sürümde hangi hedeflerin güncellendiğini not edin. Maven Central veya özel bir depo üzerinden publish işlerini CI üzerinde çalıştırın; ayrıca iOS tarafında Cocoapods veya Swift Package Manager ile entegrasyonu düşünün. Böylece kullanıcılar veya ekipler hangi platformda hangi sürümü alacağını net olarak bilir. Dağıtımı test etmek için staging ortamları kurun ve beta kanallarını kullanın. Bu yaklaşım ile sürümlerin hızlı, güvenli ve izlenebilir şekilde ilerlemesini sağlarsınız.

• Dağıtım çıktılarınızı platforma özel paketlere dönüştürün
• Bir sürümleme ve yayımlama politikası oluşturun
• Staging ve beta kanalları ile gerçek kullanım senaryolarını test edin
• Otomatik yayın akışını CI ile kurun

Güçlü Sonuçlar İçin Son Adımlar ve Uygulama Planı

Yalnızca kurmak yetmez, düzenli iyileştirme süreci gerekir. İlk olarak bir önceki haftanın hatalarını ve başarısını analiz edin. Ardından CI kurulumunu sadeleştirin; en az iki platform için temel bir inşa ve test adımı kurun, ardından gerektiğinde genişletin. Uygulamanın hangi bölümlerinin hangi platformlarda daha çok değiştiğini belirleyin ve bu alanlarda kapsayıcı testler artırın. Belirsizlikleri azaltmak için belgeleri güncel tutun ve ekipler arası iletişimi güçlendirin. Kotlin Multiplatform ile Tek Kodla Çok Platform vizyonuna ulaşmak için her adımı ölçümleyin ve hızlı geri dönüşlerle iyileştirin.

1. Bir CI hattı kurun ve temel multi target inşayı otomatikleştirin
2. Ortak ve platforma özgü testleri yapılandırın ve otomatikleştirin
3. Dağıtım için paketleme, sürümleme ve yayımlama adımlarını otomatikleştirin
4. İlerideki iyileştirme için performans ve güvenlik göstergelerini izleyin