SDK: Önceden compile edilmiş bir Android Library (.aar dosyası) olarak sağlanır. Bunu projenize bir dependency olarak ekleyeceksiniz.

Demo Uygulama: SDK feature'larının nasıl kullanılacağını gösteren bir tanıtım uygulamasının (ecv175_android) tam kaynak kodu. Bu demo, production'a hazır bir UI kodu değil, bir referans ve örnek olarak tasarlanmıştır.

Gerekli AAR Dosyaları:

• ECV SDK: (örn. ECV-175-SDK-vX.Y.Z.aar) - Gerçek SDK dosya adınızla değiştirin.

• WebRTC: M134-libwebrtc.aar

• Autobahn: autobahn-android-legacy-20.2.1.aar

Üç .aar dosyasını da projenizin libs dizinine kopyalayın (app modülü altında yoksa oluşturun).

Uygulama düzeyindeki build.gradle (veya build.gradle.kts) dosyanızı açın.

libs dizinini, eğer zaten ekli değilse, repositories kısmına ekleyin:

// build.gradle (Groovy)
repositories {
    google()
    mavenCentral()
    flatDir {
        dirs 'libs' // Bu satırı ekleyin
    }
    // Gerekirse diğer özel repoları ekleyin
}

// build.gradle.kts (Kotlin)
repositories {
    google()
    mavenCentral()
    flatDir {
        dirs("libs") // Bu satırı ekleyin
    }
    // Gerekirse diğer özel repoları ekleyin
}

AAR dosyalarını dependency olarak ekleyin:

// build.gradle (Groovy)
dependencies {
    // ... diğer dependency'ler

    // --- ECV SDK ve Dependency'leri ---
    implementation(name: 'ECV-175-SDK-vX.Y.Z', ext: 'aar') // SDK dosya adınızla değiştirin
    implementation(name: 'M134-libwebrtc', ext: 'aar')
    implementation(name: 'autobahn-android-legacy-20.2.1', ext: 'aar')

    // android 21 uyumluluk için
    implementation 'net.sourceforge.streamsupport:streamsupport-cfuture:1.7.4'
    // eğer streamsupport-cfuture kullanılamaz ise onun yerine 
    // compileOptions içerisinde `coreLibraryDesugaringEnabled true` yapılıp
    // aşağıdaki satır açılmalıdır
    // coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:2.0.4'
    
    // --- ECV SDK Dependency'leri Sonu ---

    // Ayrıca lifecycle-runtime-ktx'e de ihtiyacınız olabilir (aşağıya bakın)
}

// build.gradle.kts (Kotlin)
dependencies {
    // ... diğer dependency'ler

    // --- ECV SDK ve Dependency'leri ---
    implementation(name = "ECV-175-SDK-vX.Y.Z", ext = "aar") // SDK dosya adınızla değiştirin
    implementation(name = "M134-libwebrtc", ext = "aar")
    implementation(name = "autobahn-android-legacy-20.2.1", ext = "aar")

    // android 21 uyumluluk için
    implementation("net.sourceforge.streamsupport:streamsupport-cfuture:1.7.4")
    // eğer streamsupport-cfuture kullanılamaz ise onun yerine 
    // compileOptions içerisinde `coreLibraryDesugaringEnabled(true)` eklenip
    // aşağıdaki satır açılmalıdır
    // coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:2.0.4")

    
    // --- ECV SDK Dependency'leri Sonu ---

     // Ayrıca lifecycle-runtime-ktx'e de ihtiyacınız olabilir (aşağıya bakın)
}

Lifecycle Runtime Dependency Ekleme (Gerekirse):
ECV SDK, dahili olarak androidx.lifecycle:lifecycle-runtime-ktx library'sini (implementation dependency) kullanır. Bu bir api dependency olmadığından, kullandığınız diğer library'ler (Compose, Navigation vb.) tarafından zaten dolaylı olarak dahil edilmiyorsa uygulamanızın bunu sağlaması gerekir.

Bu dependency'nin uygulama düzeyindeki build.gradle/build.gradle.kts dosyanızda bulunduğundan emin olun:

Not: Version catalog (libs.) kullanmıyorsanız, libs.androidx.lifecycle.runtime.ktx ifadesini "androidx.lifecycle:lifecycle-runtime-ktx:2.7.0" gibi açık coordinate string'iyle değiştirin (projenizle uyumlu en son kararlı version'u kullanın).

Gradle projenizi senkronize edin (File > Sync Project with Gradle Files).

ecv175_android projesini Android Studio'da açın.

Demo uygulamayı bir emulator'de veya fiziksel cihazda build edip çalıştırın.

SDK component'lerinin nasıl initialize edildiğini ve kullanıldığını anlamak için kaynak kodunu, özellikle ui package'ındaki dosyaları (EnvironmentSelectorScreen.kt, MainScreen.kt, QueueScreen.kt, CallScreen.kt) ve AppState.kt (veya eşdeğeri) object'ini inceleyin.

EnvironmentSelectorScreen: Backend bağlantı configurations (Service URL'si vb.) seçmeye veya tanımlamaya olanak tanır. Bu öncelikle tanıtım amaçlıdır; uygulamanız muhtemelen sabit bir configuration sahip olacak veya dinamik olarak alacaktır.

MainScreen: Gerekli çağrı bilgilerini (örn. arayan adı, attributes) toplar, permissions (Kamera, Mikrofon) ister ve sdk.createCall() ve call.start() kullanarak çağrıyı başlatır.

QueueScreen: Çağrı bir agent'a bağlanırken bekleme durumunu gösterir. AgentConnected veya Error/Hangup Events dinler.

CallScreen: Ana görüntülü görüşme interface'i. Yerel ve uzak video için SurfaceViewRenderer'ları yönetir, çağrı kontrollerini (sessize alma, kamera değiştirme, kapatma) gösterir ve UI'yi güncellemek için SDK Events tepki verir.

Initialization: createCall() çağrıldığında, SDK backend'den eşzamansız olarak bir rtcId alır. GotRtcId event'ini dinlemelisiniz. rtcId, çağrıyı tanımlamak için gereklidir.

• videoCall.rtcId: Benzersiz ID'ye erişin (GotRtcId event'inden sonra kullanılabilir).

Dialing (start): Çağrı parameters ile backend'le iletişim kurarak çağrı process'ini başlatır. Bu genellikle arayanı bir queue'ya koyar.

• videoCall.start(dialParameters: DialCallParameters): DialCallParameters için Yapilandirma.mdye bakın.

• DialSuccess veya Error events dinleyin.

• OnQueue event'i, çağrının bir agent beklediğini gösterir.

Agent Bağlantısı:

• AgentConnected event'i, bir agent çağrıyı kabul ettiğinde tetiklenir.

• videoCall.agentConnectedState: Agent'ın bağlı olup olmadığını gösteren Boolean flag'i.

WebRTC Bağlantısı (connect): AgentConnected sonrasında, peer-to-peer media bağlantısını kurarsınız.

• videoCall.connect(parameters: ConnectParameters? = null): WebRtcConnection: WebRtcConnection object'ini oluşturur veya alır. ConnectParameters için Yapilandirma.mdye bakın.

Medyayı Başlatma (startRoom): WebRtcConnection'a sahip olduğunuzda, WebRTC setup process'ini başlatmanız gerekir.

• webRtcConnection.startRoom(context: Context): PeerConnection'ı başlatır, media tracks ayarlar ve signaling process'ini başlatır.

Medya Kontrolü: WebRtcConnection instance'ındaki method'ları kullanın (sonraki bölüme bakın).

Çağrıyı Sonlandırma (hangup): Çağrı session'ını sonlandırır ve resources temizler.

• videoCall.hangup(): Kapatma process'ini başlatır. Bu, user kapattığında veya çağrı başka nedenlerle (örn. uzaktan kapatma, error) sona erdiğinde çağrılmalıdır.

• Hangup event'ini ( hangup() çağrıldığında tetiklenir) veya CallEnded event'ini (genellikle uzak taraf veya errors tarafından tetiklenir) dinleyin.

Initialization: AndroidView'ın factory lambda'sı çalıştığında, SurfaceViewRenderer'ı oluşturun ve webRtcConnection.eglBase.eglBaseContext kullanarak initialize edin.

Attachment: Renderer'ı factory veya update lambda'sı içinde webRtcConnection.attachLocalView() veya webRtcConnection.attachRemoteView() kullanarak yerel veya uzak stream'e attach edin.

Detachment: Hedef stream değişirse (örn. PiP'de yerel/uzak arasında geçiş yaparken) update lambda'sında renderer'ı detach edin.

Release: Kritik olarak, resources serbest bırakmak ve leak'leri önlemek için AndroidView'ın onRelease lambda'sında renderer'ı detach edin (detachLocalView/detachRemoteView) ve surfaceViewRenderer.release() çağırın.

Sabit bir ECVSdkConfiguration'a sahip olacaksınız,

Veya, ECVSdk'yı initialize etmeden önce kendi backend service'inizden configuration ayrıntılarını dinamik olarak alacaksınız.

customerId veya hedef queue gibi çağrıya özgü data'yı, demonun environment attribute sistemi yerine uygulamanızın context'ine göre doğrudan DialCallParameters'a ileteceksiniz.

Global State Management (AppState.kt)

Environment Seçimi (EnvironmentSelectorScreen.kt)

Çağrı Başlatma (MainScreen.kt)

Bekleme Queue (QueueScreen.kt)

Aktif Çağrı (CallScreen.kt)

Permissions:

• requiredPermissions tanımlar (Kamera, Mikrofon, S+ üzerinde Bluetooth Connect).

• Permissions istemek için rememberLauncherForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) kullanır.

• Durumu doğrulamak için checkAllPermissions() kullanır.

• "START" butonu yalnızca allPermissionsGranted true olduğunda etkindir.

val requiredPermissions = remember { /* ... kamera, mic, bluetooth ... */ }
var allPermissionsGranted by remember { mutableStateOf(checkAllPermissions(context, requiredPermissions)) }
val multiplePermissionsLauncher = rememberLauncherForActivityResult(...) { /* ... allPermissionsGranted'ı güncelle ... */ }

LaunchedEffect(Unit) {
    if (!allPermissionsGranted) {
        multiplePermissionsLauncher.launch(requiredPermissions.toTypedArray())
    }
}
// ... Buton allPermissionsGranted'a göre etkinleştirilir ...

Data Toplama:

• callerName için OutlinedTextField.

• AppState.currentConfig?.callerAttributeSelections boş değilse SimpleSelectDropdown (bir demo helper) kullanılır, callerAttributes map'ini doldurur.

Çağrıyı Başlatma: ("START" butonunun onClick'i içinde)

• Çağrı Oluşturma: SDK'dan bir VideoCall instance'ı alın.

  val call = AppState.sdkInstance?.createCall()
  if (call == null) {
      // SDK'nın initialize edilmediği durumu ele alın
      Toast.makeText(context, "SDK not initialized", Toast.LENGTH_SHORT).show()
      return@Button // veya return@launch if in coroutine scope
  }
  

• (Önerilen) GotRtcId Bekleme: Demo, createCall'dan kısa süre sonra rtcId'nin hazır olacağına örtük olarak güvense de, sağlam kod genellikle event'i bekler.

  // onClick'ten coroutine scope kullanarak
  scope.launch {
      var rtcId: String? = null
      try {
           // Event'i VEYA bir error bekleyin
           val initEvent = call.eventFlow.first {
               it.type == CallEventTypes.GotRtcId || it.type == CallEventTypes.Error
           }
           if (initEvent.type == CallEventTypes.GotRtcId) {
               rtcId = initEvent.detail
               Log.d("MainScreen", "Got rtcId: $rtcId")
           } else {
               throw Exception("Error getting rtcId: ${initEvent.error?.message ?: initEvent.detail}")
           }
      } catch (e: Exception) {
           Log.e("MainScreen", "Failed to get rtcId", e)
           Toast.makeText(context, "Error initializing call: ${e.message}", Toast.LENGTH_LONG).show()
           return@launch // rtcId başarısız olursa dur
      }
  
      if (rtcId == null) return@launch // Exception handling doğruysa olmamalı
  
      // --- Dialing ile devam edin ---
      val dialParams = DialCallParameters(
          callerName = callerName, // UI State'inden
          attributes = callerAttributes // UI State'inden (Map<String, String>)
          // queue = "OptionalQueueName" // Gerekirse
      )
  
      call.start(dialParams) // Dialing process'ini başlatın
  
      // Dial process'ini başlattıktan sonra navigate edin
      // QueueScreen AgentConnected'ı beklemeyi ele alacaktır
      navController.navigate("queue/$rtcId")
      Log.d("MainScreen", "Navigated to queue for rtcId: $rtcId")
  }
  

• DialCallParameters Oluşturma: UI state'inden data toplayın (callerName, callerAttributes).

• start() Çağırma: call.start(dialParams) request'i backend'e gönderir.

• Navigate: Başarılı başlatma üzerine ( AgentConnected öncesi), rtcId'yi ileterek queue ekranına gidin. navController.navigate("queue/${call.rtcId}").

Java Eşdeğeri (örn. bir Activity onClick'inde):

// SDK instance'ını alın (örn. Application class'ından)
ECVSdk sdk = MyApp.getSdkInstance();
if (sdk == null) {
    Toast.makeText(this, "SDK not initialized", Toast.LENGTH_SHORT).show();
    return;
}

// Çağrıyı oluşturun
VideoCall videoCall = sdk.createCall();

// UI data'sını alın
String callerName = editTextCallerName.getText().toString();
Map<String, String> callerAttributes = getAttributesFromUI(); // Sizin mantığınız burada

// Not: Java'da GotRtcId beklemek, Kotlin'deki gibi bir flow'u doğrudan 'await' edemediğiniz için
// bir callback mekanizması veya dikkatli state management gerektirir.
// Basitleştirilmiş bir yaklaşım (daha az sağlam) delay kabul edilebilirse açık beklemeyi atlayabilir.
// Daha sağlam bir yol, subscribe mekanizmasını kullanmayı içerir (aşağıda event handling bölümünde gösterilmiştir)

// --- Daha iyi yaklaşım: Events'e Abone Olun ---
// Activity'nin lifecycle scope'u içinde abone olun
// (Subscribe pattern'i için aşağıdaki event handling bölümüne bakın)
// GotRtcId için onEvent callback'inde:
//   String rtcId = event.getDetail();
//   DialCallParameters dialParams = new DialCallParameters(callerName, callerAttributes, ...);
//   videoCall.start(dialParams);
//   // Queue Activity/Fragment'a gidin
//   Intent intent = new Intent(this, QueueActivity.class);
//   intent.putExtra("RTC_ID", rtcId);
//   startActivity(intent);

// --- Bu kavramsal örnek için, GotRtcId'nin bir şekilde gerçekleştiğini varsayalım ---
// --- ve sonra dial edip navigate edersiniz ---
// DialCallParameters dialParams = new DialCallParameters(callerName, callerAttributes, ...);
// videoCall.start(dialParams);
// // rtcId'nin şimdi mevcut olduğunu varsayarsak (doğru event handling olmadan bu doğru olmayabilir)
// Intent intent = new Intent(this, QueueActivity.class);
// intent.putExtra("RTC_ID", videoCall.getRtcId()); // Başlangıçta boş olabilir!
// startActivity(intent);

VideoCall Instance'ını Alma: Navigation sırasında iletilen rtcId ile ilişkili VideoCall object'ini alın. Çağrının artık mevcut olmayabileceği durumu ele alın.

Kotlin (Demo):

val rtcId: String = // navigation args'dan
var videoCall = AppState.sdkInstance?.getVideoCall(rtcId)
// Null ise ele alın

Java Eşdeğeri:

// Activity onCreate veya Fragment onViewCreated içinde
String rtcId = getIntent().getStringExtra("RTC_ID"); // Veya getArguments().getString(...)
VideoCall videoCall = MyApp.getSdkInstance().getVideoCall(rtcId);

if (videoCall == null) {
    Toast.makeText(this, "Call not found", Toast.LENGTH_SHORT).show();
    finish(); // Bu activity'yi kapatın
    return;
}
// videoCall'u bir member variable olarak saklayın
this.videoCall = videoCall;

Event Handling: Belirli videoCall için events toplayın/abone olun.

Kotlin (Demo - LaunchedEffect):

LaunchedEffect(videoCall) {
    if (videoCall.agentConnectedState) { /* Navigate */ return@LaunchedEffect }
    videoCall.eventFlow.collect { event ->
        when (event.type) {
            CallEventTypes.AgentConnected -> { /* CallActivity'ye gidin */ }
            CallEventTypes.Error, CallEventTypes.Hangup, CallEventTypes.CallEnded -> { /* Main'e geri gidin */ }
            else -> {}
        }
    }
}

Java Eşdeğeri (subscribe kullanarak):

// Activity onCreate veya Fragment onViewCreated içinde, videoCall alındıktan sonra
LifecycleOwner lifecycleOwner = this; // Activity/Fragment bir LifecycleOwner'dır

// Initial state'i kontrol edin
 if (videoCall.getAgentConnectedState()) {
     navigateToCallScreen(rtcId); // Sizin navigation method'unuz
     return; // Zaten bağlıysa abone olmayın
 }

videoCall.subscribe(lifecycleOwner, new EventCallback() {
    @Override
    public void onEvent(VideoCallEvent event) {
        runOnUiThread(() -> { // UI güncellemelerinin main thread'de olduğundan emin olun
            if (event.getType() == CallEventTypes.AgentConnected) {
                navigateToCallScreen(rtcId); // Sizin navigation method'unuz
            } else if (event.getType() == CallEventTypes.Error
                    || event.getType() == CallEventTypes.Hangup
                    || event.getType() == CallEventTypes.CallEnded) {
                String message = event.getDetail();
                if (message == null && event.getError() != null) {
                     message = event.getError().getMessage();
                }
                Toast.makeText(QueueActivity.this, "Exiting Queue: " + message, Toast.LENGTH_LONG).show();
                navigateBackToMainScreen(); // Sizin navigation method'unuz
            }
        });
    }
});

UI: Bir CircularProgressIndicator ve bekleme metni gösterin. Bir Hangup butonu sağlayın.

Cleanup: User ekranı erken terk ederse çağrıyı kapatın.

Kotlin (Demo - DisposableEffect):

DisposableEffect(videoCall) {
    onDispose {
        // Composable kaldırıldığında bu çalışır
        // Çağrının hala aktif olup olmadığını kontrol edin (zaten kapatılmamış veya bağlanıp uzaklaşılmamış)
        if (!videoCall.didHangup && !videoCall.agentConnectedState) {
             Log.d("QueueScreen", "Disposing QueueScreen, hanging up call ${videoCall.rtcId}")
             videoCall.hangup() // Queue ekranından erken ayrılırken çağrıyı temizleyin
        } else {
             Log.d("QueueScreen", "Disposing QueueScreen, call already handled (hung up or connected).")
        }
    }
}

Java Eşdeğeri (Activity onDestroy veya Fragment onDestroyView içinde):

@Override
protected void onDestroy() {
    super.onDestroy();
    if (videoCall != null && !videoCall.getDidHangup() && !videoCall.getAgentConnectedState()) {
        Log.d("QueueActivity", "onDestroy, hanging up call " + videoCall.getRtcId());
        // Hangup network calls içeriyorsa potansiyel olarak main thread dışında çalıştırın
        // onDestroy içinde uzun süren işlemler yapmaktan kaçının
         new Thread(() -> videoCall.hangup()).start(); // Basit threading örneği
    }
}

VideoCall ve WebRtcConnection Alma: QueueScreen'e benzer şekilde, rtcId aracılığıyla videoCall alın. videoCall.connect() ve webRtcConnection.startRoom(context) çağırın.

Kotlin (Demo):

val videoCall = remember(rtcId) { AppState.sdkInstance?.getVideoCall(rtcId) }
var webRtcConnection: WebRtcConnection? by remember { mutableStateOf<WebRtcConnection?>(null) }

LaunchedEffect(videoCall) {
    if (videoCall == null) { /* Handle error, navigate back */ return@LaunchedEffect }

    // Connection'ı alın veya oluşturun
    val connection = videoCall.connect() // ConnectParameters gerekirse iletin
    if (connection == null) { /* Handle error, navigate back */ return@LaunchedEffect }

    webRtcConnection = connection // State'i güncelleyin

    // WebRTC setup process'ini başlatın
    connection.startRoom(context)
}

Java Eşdeğeri:

// Activity onCreate veya Fragment onViewCreated içinde
String rtcId = getIntent().getStringExtra("RTC_ID");
VideoCall videoCall = MyApp.getSdkInstance().getVideoCall(rtcId);
if (videoCall == null) { /* handle error, finish */ return; }
this.videoCall = videoCall;

WebRtcConnection connection = videoCall.connect(null); // ConnectParameters gerekirse iletin
if (connection == null) { /* handle error, finish */ return; }
this.webRtcConnection = connection;

// WebRTC'yi başlatın - zamanlamayı düşünün, view setup'ını beklemeniz gerekebilir
webRtcConnection.startRoom(this); // Context iletin

Event Handling & UI State: videoCall.eventFlow (Kotlin) abone olun veya videoCall.subscribe (Java) kullanarak UI elements (sessize alma ikonları, hold overlay görünürlüğü vb.) SDK events'e göre güncelleyin. UI state'ini member variables veya ViewModel içinde saklayın.

Çağrı Kontrolleri: Button tıklamalarını SDK method'larına bağlayın.

Kotlin (Demo):

onToggleAudioMuteClick = { webRtcConnection?.setAudioEnabled(!audioState) }
onSwitchCameraClick = { webRtcConnection?.switchCamera() }
onHangupClick = { /* Show dialog */ videoCall?.hangup() }

Java Eşdeğeri:

// Sessize alma butonu için OnClickListener içinde
boolean currentAudioState = /* mevcut state'i alın, örn. boolean member'dan */;
if (webRtcConnection != null) {
    webRtcConnection.setAudioEnabled(!currentAudioState);
    // AudioMuted/Unmuted events'e göre buton ikonunu ve currentAudioState variable'ını güncelleyin
}

// Kamera değiştirme butonu için OnClickListener içinde
if (webRtcConnection != null) {
    webRtcConnection.switchCamera();
}

// Kapatma butonu için OnClickListener içinde
new AlertDialog.Builder(this)
    .setTitle("Confirm Hangup")
    // ... mesaj, butonlar ...
    .setPositiveButton("Hangup", (dialog, which) -> {
        if (videoCall != null) {
             new Thread(() -> videoCall.hangup()).start(); // Hangup'ı main thread dışında yapın
             // UI güncellemesi/navigation genellikle CallEnded event'i tarafından yönetilir
        }
    })
    .show();

Video Rendering: Bu, Compose ve geleneksel Views arasında önemli ölçüde farklılık gösterir.

• Compose: SDK_Kullanimi.md'de detaylandırıldığı ve VideoRenderer composable'ında gösterildiği gibi lifecycle management için factory, update ve onRelease ile AndroidView kullanır.

• Java/XML:

  1. XML layout'unuza <org.webrtc.SurfaceViewRenderer ... /> ekleyin.

  2. Renderers referanslarını alın (örn. ViewBinding kullanarak).

  3. Initialization: onCreate veya onViewCreated içinde, surfaceViewRenderer.init(webRtcConnection.getEglBase().getEglBaseContext(), null) çağırın.

  4. Attachment: Connection hazır olduğunda (örn. WebRtcConnected sonrasında veya view kullanılabilir olduğunda) webRtcConnection.attachLocalView(...) ve webRtcConnection.attachRemoteView(...) çağırın.

  5. Detachment & Release: Kritik olarak, onDestroy veya onDestroyView içinde, hem local hem de remote renderers için webRtcConnection.detachLocalView(...), webRtcConnection.detachRemoteView(...) ve surfaceViewRenderer.release() çağırın. Bunu doğru yapmamak leak'lere ve crash'lere neden olur.

Immersive Mode: onResume/onPause veya ilgili lifecycle events'de system bars gizlemek/göstermek için WindowInsetsControllerCompat kullanın.

Cleanup: onDestroy içinde, çağrı hala aktifse videoCall.hangup() çağrıldığından emin olun. Yukarıda belirtildiği gibi renderers release edin. videoCall.subscribe'ın LifecycleOwner'ı tarafından örtük olarak yönetilen event subscriptions durdurulur.

Kotlin (Demo - DisposableEffect):

DisposableEffect(Unit) {
    onDispose {
        Log.d("CallScreen", "Disposing CallScreen Scope...")
        // Yalnızca çağrı zaten doğal olarak sona ermediyse kapatın
        if (videoCall?.didHangup == false) { // SDK flag'ini kontrol edin (varsa)
             videoCall.hangup()
             Log.d("CallScreen", "Called hangup for ${videoCall.rtcId} on dispose")
        }
        // System bars geri yükleyin
        if (window != null && !isInPreview) {
            WindowCompat.getInsetsController(window, view)
                ?.apply { show(WindowInsetsCompat.Type.systemBars()) }
        }
    }
}

Kotlin (Flow): videoCall.eventFlow'a (SharedFlow<VideoCallEvent>) erişin ve Kotlin Coroutines kullanarak, tipik olarak bir LaunchedEffect veya lifecycleScope içinde events toplayın.

Java (Callback): videoCall.subscribe(lifecycleOwner, eventCallback) method'unu, bir Android LifecycleOwner (Activity veya Fragment gibi) ve bir EventCallback implementation sağlayarak kullanın. Subscription, LifecycleOwner tarafından otomatik olarak yönetilir.

Sabit Configuration: Uygulamanız yalnızca tek bir backend environment'ına (örn. production) bağlanıyorsa, ECVSdk'yı initialize ederken ECVSdkConfiguration değerlerini hardcode edebilirsiniz.

// Örnek: Application.onCreate veya DI module içinde
val prodConfig = ECVSdkConfiguration(
    serviceUrl = "https://sizin-prod.ecv.example.com",
)
val sdkInstance = ECVSdk("MyAppProdInstance", prodConfig)

// Örnek: Application onCreate veya DI module içinde
ECVSdkConfiguration prodConfig = new ECVSdkConfiguration(
    /* serviceUrl */ "https://sizin-prod.ecv.example.com",
    // ... diğer constructor args ...
    /* useQueueSocket */ true // Backend'in v1.75+ olduğunu varsayarsak
    // ...
);
ECVSdk sdkInstance = new ECVSdk("MyAppProdInstance", prodConfig);
// sdkInstance'ı global olarak saklayın

Dinamik Configuration: ECVSdk'yı initialize etmeden önce kendi uygulama backend'inizden configuration ayrıntılarını ( serviceUrl, webrtcUrl gibi) dinamik olarak alın. Bu, uygulama güncellemeleri gerektirmeden endpoints merkezi olarak yönetmenizi sağlar.

• Uygulamanız config'i server'ınızdan alır.

• ECVSdkConfiguration oluşturmak için alınan URL'leri kullanır.

• ECVSdk'yı initialize eder.

Hata: Could not find :ECV-175-SDK-vX.Y.Z: (veya diğer AAR'lar)

• Neden: Gradle gerekli .aar dosyalarını bulamıyor.

• Çözüm:

  • Üç gerekli .aar dosyasının (ECV SDK, M134-libwebrtc, `autobahn-android-legacy-20.2.1` ) doğrudan projenizin app/libs dizinine kopyalandığından emin olun.

  • Uygulama düzeyindeki build.gradle/.kts dosyanızın repositories { ... } bloğu içinde flatDir { dirs 'libs' } girişini içerdiğini doğrulayın.

  • Dependencies bloğunuzdaki implementation(name: '...', ext: 'aar') satırlarının libs dizinindeki dosya adlarıyla ( .aar uzantısı olmadan) tam olarak eşleştiğini onaylayın.

  • Bir Gradle Sync yapın (File > Sync Project with Gradle Files). Build > Clean Project ve Build > Rebuild Project deneyin.

Hata: Unresolved reference: lifecycle veya androidx.lifecycle ile ilgili benzer hatalar

• Neden: Gerekli androidx.lifecycle:lifecycle-runtime-ktx dependency'si uygulamanızın build dosyasında eksik. SDK bunu dahili olarak kullanır ancak api aracılığıyla expose etmez.

• Çözüm: implementation("androidx.lifecycle:lifecycle-runtime-ktx:VERSION") dependency'sini uygulama düzeyindeki build.gradle/.kts dosyanıza ekleyin, VERSION yerine projenizle uyumlu güncel bir stabil version (örn. 2.7.0) yazın. Detaylar için README_tr.md'ye bakın. Gradle'ı senkronize edin.

Hata: Duplicate Class Found...

• Neden: Projeniz veya başka bir library, SDK'nın AAR'ları tarafından dahili olarak kullanılan dependency'lerin çakışan version'larını içeriyor (örn. farklı WebRTC veya Autobahn version'ları, potansiyel Kotlin standard library sorunları).

• Çözüm:

  • Çakışan library'leri tanımlamak için build hata mesajını analiz edin.

  • Transitive dependency'leri exclude etmek veya belirli version'ları force etmek için Gradle'ın dependency resolution stratejilerini kullanın. Örnek (Groovy):

    implementation('some.other.library:1.0') {
        // ECV SDK'nın dependency'leri tarafından sağlanan çakışan bir module exclude et
        exclude group: 'org.webrtc', module: 'google-webrtc'
    }
    

  • Projenizin core library'lerin (Kotlin gibi) uyumlu version'larını kullandığından emin olun.

Hata: Manifest Merger Failed (Permissions)

• Neden: SDK'nın manifest'i, uygulamanızın manifest'i ile çakışan permissions veya features declare edebilir.

• Çözüm:

  • Build output'undaki belirli manifest merger hata mesajını inceleyin.

  • Uygulamanızın AndroidManifest.xml'inin CAMERA, RECORD_AUDIO, INTERNET, MODIFY_AUDIO_SETTINGS ve potansiyel olarak BLUETOOTH_CONNECT (API 31+ için) gibi gerekli permissions doğru şekilde declare ettiğinden emin olun.

  • Gerekirse manifest merger override kurallarını (tools:overrideLibrary, tools:node="replace") dikkatli kullanın, ancak sonuçlarını anlayın. Genellikle, uygulamanızın gerekli permissions declare etmesi yeterlidir.

Crash: UnsatisfiedLinkError (org.webrtc veya native method'larla ilgili)

• Neden: Native WebRTC library'leri (M134-libwebrtc.aar içindeki .so dosyaları) yüklenemedi. Bu genellikle architecture uyuşmazlıkları veya kurulum sorunlarından kaynaklanır.

• Çözüm:

  • M134-libwebrtc.aar'ın doğru şekilde dahil edildiğinden ve Gradle tarafından işlendiğinden emin olun.

  • Build'inizde ABI splits kullanıyorsanız, hedef cihaz/emulator için doğru architecture'ın .so dosyalarının dahil edildiğinden emin olun.

  • Projeyi clean edip rebuild yapın. Mümkünse farklı cihazlarda/emulator'lerde test edin.

  • Başka hiçbir library'nin native library yüklemesine müdahale etmediğini doğrulayın.

Crash: NullPointerException

• Neden: Bir SDK object'ine initialize edilmeden önce veya cleanup yapıldıktan sonra erişilmesi.

• Çözüm:

  • SDK Not Initialized: sdkInstance'a (örn. MyApp.getSdkInstance()) erişmeye çalışmadan önce ECVSdk(...) çağrıldığından emin olun. Log'larda initialization hatalarını kontrol edin.

  • getVideoCall Null Döndürüyor: rtcId geçersiz olabilir, çağrı zaten sona ermiş olabilir (CallEnded event'i) veya SDK instance'ı yeniden initialize edilmiş olabilir. Özellikle bir Activity/Fragment'ı resume ederken veya navigate ederken VideoCall object'ini kullanmadan önce getVideoCall(rtcId)'nin dönüş değerini her zaman null için kontrol edin.

  • WebRtcConnection Null: videoCall.connect()'in AgentConnected event'inden sonra ve webRtcConnection'a erişmeden önce başarıyla çağrıldığından emin olun. connect() veya startRoom() process'i sırasındaki hataları kontrol edin.

  • Context Null: Gerektiğinde geçerli Context iletildiğinden emin olun (örn. startRoom).

Crash: SurfaceViewRenderer.release() veya EGL hatalarıyla ilgili

• Neden: SurfaceViewRenderer'ın yanlış lifecycle management'ı.

• Çözüm:

  • Release MUTLAKA çağrılmalı: surfaceViewRenderer.release()'in uygun lifecycle callback'inde (onRelease Compose AndroidView'da, onDestroyView/onDestroy Fragments/Activities için) çağrıldığından emin olun.

  • Release Öncesi Detach: Kritik olarak, release() çağırmadan önce renderer üzerinde webRtcConnection.detachLocalView(...) ve webRtcConnection.detachRemoteView(...) çağırın.

  • Threading: init, attach/detach ve release'in doğru thread'den (genellikle main UI thread) çağrıldığından emin olun.

  • Double Release: release()'in aynı renderer instance'ında birden çok kez çağrılmadığından emin olun.

Crash: SecurityException (Permission Reddi)

• Neden: User tarafından verilen gerekli runtime permissions olmadan kamerayı veya mikrofonu başlatmaya çalışmak.

• Çözüm:

  • videoCall.start() veya webRtcConnection.startRoom() çağırmadan önce sağlam bir permission request mantığı implement edin.

  • Çağrı işlevini etkinleştirmeden önce permission durumunu kontrol edin.

  • User permissions reddettiği durumları zarifçe ele alın. Bir örnek için demo'nun MainScreen.kt'sine bakın.

Kötü Video/Ses Kalitesi (Lag, Donma, Pixelation, Bozuk Ses):

• Debugging:

  • Network: Bu en yaygın nedendir. Cihazdaki network bandwidth, latency ve packet loss kontrol edin (örn. hız testi uygulamaları, ping kullanarak). Farklı network'lerde test edin (Wi-Fi vs Cellular).

  • Cihaz Performance: Eski veya düşük seviye cihazlar, özellikle daha yüksek resolutions'da encoding/decoding ile mücadele edebilir.

  • ConnectParameters: Bandwidth sınırlıysa videoWidth/videoHeight/videoFps düşürmeyi veya bir videoMaxBitrate ayarlamayı düşünün. Mümkünse videoCodecHwAcceleration'ın etkinleştirildiğinden emin olun.

  • WebRTC Stats: Ayrıntılı WebRTC statistics toplamak için peerConnectionClient.enableStatsEvents kullanın (ancak bunları yorumlamak uzmanlık gerektirir).

Kamera Değiştirme Çalışmıyor:

• Debugging:

  • webRtcConnection.switchCamera() çağrıldığından emin olun.

  • Switch denemesi sırasındaki hatalar için log'ları kontrol edin.

  • Cihazın gerçekten birden fazla kamerası (ön/arka) olduğunu doğrulayın.

Hold/Pickup Otomatik Olarak Sessize Almıyor/Açmıyor:

• Debugging:

  • ConnectParameters içinde autoHandleHoldSideEffects = true olduğundan emin olun (bu default'tur).

  • StartHold / EndHold events doğru şekilde alınıp alınmadığını kontrol edin.

  • "HOLD|" veya "PICKUP|" ile ilgili TextChannelMessage events alınıp alınmadığını kontrol edin. Text channel'ın bağlı olduğunu doğrulayın (TextChannelConnected event'i).

Logcat'i Kontrol Edin: Bu en önemli aracınızdır. SDK'da kullanılan tag'lere (ECVSdk, VideoCall, WebRtcConnection, Signaling, QueueSocket, PeerConnectionClient, AppRTCAudioManager) ve kendi uygulama tag'lerinize (AppState, MainScreen, CallScreen, vb.) göre filtreleyin. Warnings ve errors arayın. Gerekirse loglama ayrıntı düzeyini artırın (SDK standart Android loglama seviyelerini kullanır).

Configuration Doğrulayın: ECVSdkConfiguration (URL'ler, useQueueSocket), DialCallParameters (attributes, queue) ve herhangi bir custom ConnectParameters hedef environment'ınız ve gereksinimlerinizle dikkatlice karşılaştırın.

Network Connectivity Kontrol Edin: Cihaz serviceUrl, webrtcUrl ve signalingUrl'e ulaşabiliyor mu? Browser/ping/network araçları kullanın. Wi-Fi/Cellular connection durumunu kontrol edin. Farklı network'leri test edin. Varsa kurumsal firewall'lar hakkında bilgi alın.

Basitleştirin: Karmaşık UI'yi, custom logic'i veya isteğe bağlı SDK feature'larını geçici olarak kaldırın. En temel, default configurations kullanın (ECVSdkConfiguration, DialCallParameters, ConnectParameters). Basit bir çağrı çalışıyor mu? Karmaşıklığı kademeli olarak yeniden ekleyin.

Phase'i İzole Edin: Hatanın ne zaman meydana geldiğini belirleyin: SDK init? Dialing? Queue? WebRTC connection? Media rendering? Bu, aramayı daraltmaya yardımcı olur.

Demo Uygulamasına Başvurun: Implementation logic'inizi, özellikle event handling, navigation ve SurfaceViewRenderer lifecycle management etrafında, sağlanan demo kaynak koduyla dikkatlice karşılaştırın.

Tüm Events Loglayın: Aldığınız her VideoCallEvent'i yazdırmak için event handling callback/collector'ınızın içine loglama ekleyin. Bu, çağrı flow'unu izlemeye ve nerede yanlış gidebileceğini veya hangi beklenen events eksik olduğunu görmeye yardımcı olur.