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

2. 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)
   }
   

3. 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:

   // build.gradle (Groovy)
   dependencies {
       // ... diğer dependency'ler
       implementation libs.androidx.lifecycle.runtime.ktx // Veya belirli version string'i, örn. "androidx.lifecycle:lifecycle-runtime-ktx:2.7.0"
   
       // ECV SDK AAR'ları...
   }
   
   // build.gradle.kts (Kotlin)
   dependencies {
       // ... diğer dependency'ler
       implementation(libs.androidx.lifecycle.runtime.ktx) // Veya belirli version string'i, örn. "androidx.lifecycle:lifecycle-runtime-ktx:2.7.0"
   
       // ECV SDK AAR'ları...
   }
   

   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).

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

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

2. 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.

3. 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.

4. 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.

5. 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.

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

7. Ç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.

```
import androidx.compose.runtime.LaunchedEffect
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.repeatOnLifecycle
import group.ccr.ecv.sdk.videoCall.VideoCall // VideoCall class'ınızı import edin
import group.ccr.ecv.sdk.videoCall.events.CallEventTypes
import kotlinx.coroutines.flow.collect
import android.util.Log

// Bir Composable içinde (LaunchedEffect kullanarak)
@Composable
fun MyCallScreen(videoCall: VideoCall?) { // VideoCall instance'ını iletin
    LaunchedEffect(videoCall) { // videoCall instance'ına key'lenir
        videoCall?.eventFlow?.collect { event ->
            Log.d("MyApp", "SDK Event Alındı: ${event.type} - ${event.detail}")
            when (event.type) {
                CallEventTypes.GotRtcId -> { /* rtcId'yi saklayın: event.detail */ }
                CallEventTypes.DialSuccess -> { /* Çağrı aranıyor */ }
                CallEventTypes.OnQueue -> { /* Temsilci bekleniyor */ }
                CallEventTypes.AgentConnected -> { /* Çağrı ekranına gidin, videoCall.connect() çağırın */ }
                CallEventTypes.WebRtcConnected -> { /* Media bağlantısı kuruldu */ }
                CallEventTypes.VideoMuted -> { /* Yerel video sessize alma UI state'ini güncelleyin */ }
                CallEventTypes.RemoteVideoMuted -> { /* Uzak video sessize alma UI state'ini güncelleyin */ }
                CallEventTypes.StartHold -> { /* "Beklemede" UI'sini gösterin */ }
                CallEventTypes.CallEnded -> { /* Geri gidin, temizleyin. Detay: event.detail */ }
                CallEventTypes.Error -> { /* Hata mesajı gösterin: event.error / event.detail */ }
                // ... diğer ilgili events'i ele alın
                else -> { /* İsteğe bağlı: Ele alınmayan events'i loglayın */ }
            }
        }
    }
    // ... Composable UI'nin geri kalanı ...
}


// Bir Activity/Fragment içinde (lifecycleScope kullanarak)
// override fun onCreate(savedInstanceState: Bundle?) {
//     super.onCreate(savedInstanceState)
//     // ... setup ...
//     val videoCall = // ... VideoCall instance'ını alın ...
//
//     lifecycleScope.launch {
//         repeatOnLifecycle(Lifecycle.State.STARTED) {
//             videoCall?.eventFlow?.collect { event ->
//                 // Event'i yukarıdaki gibi ele alın
//             }
//         }
//     }
// }
```

• Java (Callback): subscribe method'unu bir LifecycleOwner ve bir EventCallback ile kullanın.

  import androidx.lifecycle.LifecycleOwner; // örn. Activity veya Fragment'ınız
  import group.ccr.ecv.sdk.EventCallback;
  import group.ccr.ecv.sdk.videoCall.VideoCall;
  import group.ccr.ecv.sdk.videoCall.events.CallEventTypes;
  import group.ccr.ecv.sdk.videoCall.events.VideoCallEvent;
  import android.util.Log;
  
  // Activity onCreate veya Fragment onViewCreated içinde
  LifecycleOwner lifecycleOwner = this; // Activity/Fragment'ınız LifecycleOwner uygular
  VideoCall videoCall = // ... videoCall instance'ını alın ...
  
  if (videoCall != null) {
      videoCall.subscribe(lifecycleOwner, new EventCallback() {
          @Override
          public void onEvent(VideoCallEvent event) {
              // UI güncellemelerini main thread'de yapmak genellikle daha güvenlidir
              runOnUiThread(() -> {
                   Log.d("MyApp", "SDK Event Alındı: " + event.getType() + " - " + event.getDetail());
                  // event.getType() üzerinde switch ifadesi veya if-else if kullanın
                  if (event.getType() == CallEventTypes.GotRtcId) {
                      // rtcId'yi saklayın: event.getDetail()
                  } else if (event.getType() == CallEventTypes.AgentConnected) {
                      // Çağrı ekranına gidin, videoCall.connect() çağırın
                  } else if (event.getType() == CallEventTypes.CallEnded) {
                      // Geri gidin, temizleyin. Detay: event.getDetail()
                  } else if (event.getType() == CallEventTypes.Error) {
                      // Hata mesajı gösterin: event.getError() / event.getDetail()
                  }
                  // ... diğer ilgili events'i ele alın
              });
          }
      });
  }
  
  // Alternatif olarak, ECVSdkModules aracılığıyla global events'e abone olun
  // sdkInstance.getModules().subscribe(lifecycleOwner, new EventCallback() { ... });
  

- Örnek: `"https://sirketiniz.ecv.backend.com"`

• webrtcUrl: String (İsteğe bağlı, default serviceUrl): Özellikle WebRTC signaling ile ilgili HTTP requests ( /join endpoint'i gibi) için kullanılan temel URL. WebRTC signaling infrastructure'ınız ayrı olarak host ediliyorsa, burada belirtin.

  • Örnek: "https://sirketiniz.ecv.webrtc.com"

• signalingUrl: String (İsteğe bağlı, default serviceUrl): WebSocket signaling server için temel URL. SDK, http/https yerine ws/wss kullanacaktır. WebSocket server'ınız ayrı olarak host ediliyorsa, burada belirtin.

  • Örnek: "https://sirketiniz.ecv.websocket.com"

• useQueueSocket: Boolean (İsteğe bağlı, default true): Queue state güncellemelerini ( AgentConnected gibi) alma mekanizmasını belirler.

  • true (ECV v1.75+ için önerilir): Real-time güncellemeler için özel bir WebSocket (QueueSocket) kullanır. Bu, ECV backend infrastructure'ınızın 1.75 veya daha yüksek bir version olmasını gerektirir. Polling'e kıyasla daha hızlı bildirimler sağlar.

- `candidateFilteringMode: CandidateFilteringMode = CandidateFilteringMode.ALL`: Hangi ICE candidates kullanılacağını kontrol eder (All, Relay only, Host only).
- `connectionTimeout: Int = 10000`: Genel WebRTC bağlantı denemesi için timeout (ms) (`WebRtcConnection`'daki manuel timer tarafından kullanılır).
- `joinHttpConnectTimeout: Int = 3000`: `/join` request'i için HTTP connect timeout (ms).
- `joinHttpReadTimeout: Int = 3000`: `/join` request'i için HTTP read timeout (ms).
- `additionalHeaders: Map<String, String> = emptyMap()`: `/join` request'ine ve WebSocket signaling connection handshake'ine eklenen custom HTTP headers. WebRTC/Signaling infrastructure'ına ulaşması gereken authentication tokens için kullanışlıdır.

• Media Control & Behavior:

  • videoCallEnabled: Boolean = true: Video tracks kurulup kurulmayacağı. Audio-only çağrılar için false olarak ayarlayın.
  • disableVideo: Boolean = false: Gerekirse video gönderme/alma işlemini tamamen devre dışı bırakmak için üst düzey flag (genellikle videoCallEnabled yeterlidir).
  • disableAudio: Boolean = false: Gerekirse ses gönderme/alma işlemini tamamen devre dışı bırakmak için üst düzey flag.
  • useSpeakerPhone: Boolean = true: Çağrıyı speakerphone kullanarak başlatın.
  • autoSwitchToEarPiece: Boolean = false: Proximity sensor tetiklendiğinde (telefon kulağa yakın) otomatik olarak earpiece'e geçin.
  • autoHandleCameraSwitch: Boolean = true: Belirli events meydana geldiğinde (örn. agent arka kamera ile fotoğraf istediğinde) SDK'nın kameraları otomatik olarak değiştirmesine izin verir.
  • autoHandleHoldSideEffects: Boolean = true: Agent çağrıyı hold'a aldığında veya devam ettirdiğinde yerel ses/videoyu otomatik olarak sessize alır/açar.

• Video Configuration:

  • videoWidth: Int = 480 / videoHeight: Int = 640: İstenen video resolution.
  • videoFps: Int = 0 (Default ~30): İstenen video frame rate.
  • videoMaxBitrate: Int = 0 (WebRTC default): Video encoding için maksimum bitrate (kbps).
  • videoCodec: String = "VP8": Tercih edilen video codec ("VP8", "VP9", "H264").
  • videoCodecHwAcceleration: Boolean = true: Varsa hardware acceleration'ı etkinleştirin.

• Audio Configuration:

  • audioCodec: String = "OPUS": Tercih edilen audio codec ("OPUS", "ISAC").
  • audioStartBitrate: Int = 0 (WebRTC default): Başlangıç audio bitrate (kbps).
  • noAudioProcessing: Boolean = false: Platform audio processing'i (AEC, AGC, NS) devre dışı bırakın.
  • useOpenSLES: Boolean = false: OpenSL ES audio backend'ini kullanın (Android'e özgü).
  • disableBuiltInAEC: Boolean = false / disableBuiltInNS: Boolean = false: Varsa hardware AEC/NS'yi devre dışı bırakın.

• Debugging:

  • tracing: Boolean = false: WebRTC dahili tracing'i etkinleştirin.
  • aecDump: Boolean = false: AEC diagnostic data'yı kaydedin.
  • saveInputAudioToFile: Boolean = false: Ham input audio'yu kaydedin (useOpenSLES = false gerektirir).
  • enableRtcEventLog: Boolean = false: WebRTC events'i bir dosyaya loglayın.

• Data Channel (textChannelConfig):

  • textChannelConfig: DataChannelConfig? = DataChannelConfig(...): FLASH_ON/OFF, HOLD/PICKUP vb. komutlar için kullanılan yerleşik text data channel configuration'ı. Genellikle default bırakılır. Detaylar için DataChannelConfig class'ına bakın.

- `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 ...
```

2. Data Toplama:

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

3. Ç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);
   

**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;
```

2. 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
               }
           });
       }
   });
   

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

4. 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
       }
   }
   

**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
```

2. 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.

3. Ç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();
   

4. 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.

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

6. 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()) }
           }
       }
   }
   

- **Ne zaman:** `sdkInstance.createCall()` backend'den benzersiz bir çağrı tanımlayıcısı başarıyla aldıktan sonra tetiklenir.
- **Data:** `event.detail`, `rtcId`'yi (String) içerir.
- **Yanıt:** `rtcId`'yi saklayın. Daha sonra `VideoCall` instance'ını almak ve dialing'i başlatmak (`call.start()`) için buna ihtiyacınız vardır.

• DialSuccess

  • Ne zaman: call.start() backend'e dial request'ini başarıyla gönderdikten ve onay aldıktan sonra (genellikle bir Interaction ID içerir) tetiklenir.
  • Data: event.detail, Interaction ID'yi içerebilir. event.objData, ham JSON response'u tutabilir.
  • Yanıt: Genellikle bekleme/queue state'ine geçebileceğinizi gösterir.

• Error (Init/Dial Sırasında)

  • Ne zaman: rtcId alma başarısız olursa, call.start() parameters geçersizse, backend dial request'ini reddederse veya network sorunları oluşursa meydana gelebilir.
  • Data: event.error, ECVError içerir. event.detail daha fazla context sağlayabilir. event.objData, bir HTTP response tutabilir. Spesifik ErrorTypes için error.error kontrol edin (CALL_NOT_INITIALIZED, DIAL_FAILED gibi).
  • Yanıt: User'a bir hata mesajı gösterin. Daha fazla çağrı ilerlemesini önleyin. Kullanılamaz durumdaysa VideoCall instance'ını potansiyel olarak temizleyin.

- **Ne zaman:** Başarılı bir dial sonrasında, arayanın şimdi bir agent beklediğini belirtmek için tetiklenir.
- **Data:** Genellikle belirli bir data gerekmez.
- **Yanıt:** Bir bekleme UI'si gösterin (`QueueScreen` gibi).

• AgentConnected

  • Ne zaman: Bir agent çağrıyı kabul ettiğinde tetiklenir. Bu, peer-to-peer media bağlantısını kurma tetiğidir.

  • Data: Spesifik bir şey yok.

  • Yanıt: WebRTC bağlantısını başlatın:

    1. WebRtcConnection almak için videoCall.connect() çağırın.
    2. WebRTC setup'ını başlatmak için webRtcConnection.startRoom(context) çağırın.
    3. Ana çağrı ekranına (CallScreen) gidin.

• Error (Queue Sırasında)

  • Ne zaman: Queue timeouts (QUEUE_SOCKET_TIMEOUT), queue mekanizmasıyla ilgili network sorunları (QUEUE_SOCKET_ERROR, QUEUE_SOCKET_CALL_DISCONNECTED) veya backend sorunları (WAIT_FOR_ROOM_FAILED, polling kullanılıyorsa) nedeniyle oluşabilir.
  • Data: event.error, ECVError içerir.
  • Yanıt: User'a çağrının bağlanamadığını bildirin. Queue ekranından geri gidin. SDK otomatik olarak CallEnded tetiklemezse cleanup sağlamak için videoCall.hangup() çağırın.

• Hangup / CallEnded (Queue Sırasında)

  • Ne zaman: User açıkça kapatırsa (videoCall.hangup()) veya çağrı bir agent bağlanmadan önce backend tarafından sonlandırılırsa.
  • Data: event.detail bir neden içerebilir ("LOCAL_HANGUP", vb.).
  • Yanıt: Queue ekranından geri gidin. UI'nin temizlendiğinden emin olun.

- **Ne zaman:** WebRTC PeerConnection (ICE ve DTLS) tamamen kurulduğunda ve media akışı başlayabildiğinde.
- **Data:** Spesifik bir şey yok.
- **Yanıt:** Genellikle media path'inin hazır olduğunu bilmek için bir tetikleyici olarak kullanılır. `CallScreen`'deki initial loading göstergelerini gizleyebilirsiniz.

• TextChannelConnected: Text komutları (hold, flash vb.) için kullanılan özel data channel açık. event.objData, DataChannel'ı tutar.
• WebRtcDisconnected / WebRtcFailed: WebRTC bağlantısı beklenmedik bir şekilde düştü veya başarısız oldu. Genellikle kısa süre sonra bir CallEnded event'ine yol açar.

- **Yanıt:** Uzak `SurfaceViewRenderer`'ın attach edildiğinden emin olun.

• AudioMuted / AudioUnmuted: Yerel ses gönderme state'i değişti (setAudioEnabled tarafından tetiklenir).

  • Yanıt: Mute butonu UI state'ini güncelleyin.

• VideoMuted / VideoUnmuted: Yerel video gönderme state'i değişti (setVideoEnabled tarafından tetiklenir).

  • Yanıt: Video mute butonu UI state'ini güncelleyin. Potansiyel olarak yerel video preview overlay'ini gösterin/gizleyin.

• RemoteAudioMuted / RemoteAudioUnmuted: Uzak katılımcı sesini sessize aldı/açtı.

  • Yanıt: İsteğe bağlı olarak uzak tarafın sessizde olduğunu gösteren bir indicator görüntüleyin.

• RemoteVideoMuted / RemoteVideoUnmuted: Uzak katılımcı videosunu sessize aldı/açtı.

  • Yanıt: Uzak video renderer üzerinde bir overlay veya indicator gösterin/gizleyin.

• StartHold / EndHold: Çağrı agent tarafından hold'a alındı veya hold'dan çıkarıldı (genellikle text data channel aracılığıyla tetiklenir).

  • Yanıt: "Call on Hold" overlay'ini gösterin/gizleyin. SDK (autoHandleHoldSideEffects true ise) yanıt olarak yerel medyayı otomatik olarak sessize alabilir/açabilir.

• TakePhotoOn / TakePhotoOff: Agent tarafından başlatılan fotoğraf yakalama feature'ları ile ilgili signals.

  • Yanıt: Gerekirse UI'yi ayarlayın (örn. potansiyel olarak yerel videoyu fullscreen zorlayın). SDK (autoHandleCameraSwitch true ise) kameraları otomatik olarak değiştirebilir.

• TextChannelMessage: Text data channel üzerinden alınan bir komut veya mesaj.

  • Data: event.detail, ham mesaj string'ini içerir (örn. "FLASH_ON", "STATUS|VIDEO|MUTED|rtcId").
  • Yanıt: SDK, birçok standart mesajı dahili olarak ele alır (HOLD, PICKUP, MUTE durumları, FLASH komutları gibi). Implementation'ınıza özgü custom mesajlara tepki verebilirsiniz.

- **Ne zaman:** Yerel olarak `videoCall.hangup()` çağrıldığında hemen tetiklenir.
- **Data:** Spesifik bir şey yok.
- **Yanıt:** Backend çağrının sona erdiğini onaylamadan *önce* UI cleanup'ını başlatmak için kullanılabilir. Unutmayın ki `CallEnded` kesin bitiş event'idir.

• CallEnded

  • Ne zaman: Çağrı session'ının tamamen sona erdiğini gösteren son event; yerel olarak (hangup() tamamlanması), uzaktan (agent/peer kapatır) veya kurtarılamaz bir error nedeniyle.

  • Data: event.detail genellikle bir neden içerir (örn. "LOCAL_HANGUP", "REMOTE_HANGUP", "PEER_DISCONNECTED", "CONNECTION_TIMEOUT", error açıklaması).

  • Yanıt: Bu, aşağıdakileri yapmak için kesin sinyaldir:

    1. Tüm çağrıyla ilgili UI'yi (renderers, kontroller) temizleyin.
    2. Çağrı ekranından uzaklaşın.
    3. Belirli VideoCall'a bağlı tüm resources serbest bırakın. SDK tipik olarak bu event'ten sonra VideoCall instance'ına olan dahili reference'ını kaldırır.

- `rtcId: String`: Benzersiz çağrı tanımlayıcısı (`GotRtcId` sonrası kullanılabilir).
- `agentConnectedState: Boolean`: `AgentConnected` event'i gerçekleştiyse true.
- `didHangup: Boolean`: Yerel olarak `hangup()` çağrıldıysa true.
- `webRtcConnection: WebRtcConnection?`: İlişkili WebRTC connection (`connect()` çağrıldıktan sonra kullanılabilir).

• WebRtcConnection Üzerinde:

  • audioEnabled: Boolean: Yerel ses göndermenin mevcut state'i (son setAudioEnabled çağrısını yansıtır).
  • videoEnabled: Boolean: Yerel video göndermenin mevcut state'i (son setVideoEnabled çağrısını yansıtır).
  • isClosing: Boolean: Bu connection için cleanup process'i başladıysa true.

- **Permissions:** Çağrıyı başlatmadan önce Kamera, Mikrofon (ve S+ için Bluetooth Connect) permissions istemeli ve yönetmelisiniz.
- **Video Renderers:** Videoyu görüntülemek için layout'unuzda `org.webrtc.SurfaceViewRenderer` instance'ları sağlamanız gerekir.
- **Renderer Lifecycle:** **Bu kritiktir.** `SurfaceViewRenderer`'ların lifecycle'ını doğru şekilde yönetmelisiniz:
    
    
    - `webRtcConnection.eglBase.eglBaseContext` kullanarak initialize edin.
    - `webRtcConnection.attachLocalView`/`attachRemoteView` kullanarak yerel/uzak streams attach edin.
    - `webRtcConnection.detachLocalView`/`detachRemoteView` kullanarak detach edin.
    - **Artık gerekmediğinde (örn.** `onDestroyView`**,** `onDispose`**, Activity** `onDestroy`**)** `surfaceViewRenderer.release()` **kullanarak release edin. Doğru şekilde release etmemek, crash'lerin ve memory leak'lerin yaygın bir nedenidir.** (`SDK_Kullanimi.md` ve `Demo_Uygulama_Rehberi.md`'deki örneklere bakın).
- **Çağrı State Gösterimi:** UI'niz, SDK events'e dayalı olarak mevcut çağrı durumunu (örn. "Connecting...", "Waiting for agent...", "Connected", "On Hold") yansıtmalıdır.
- **Çağrı Kontrolleri:** Aşağıdakiler için UI elements (Buttons, Icons) implement edin:
    
    
    - Sesi Sessize Alma/Açma (`webRtcConnection.setAudioEnabled(...)`)
    - Videoyu Açma/Kapatma (`webRtcConnection.setVideoEnabled(...)`)
    - Kamerayı Değiştirme (`webRtcConnection.switchCamera(...)`)
    - Kapatma (`videoCall.hangup()`)
- **Event Handling:** UI layer'ınız, state'ini güncellemek, ekranlar arasında gezinmek ve hataları ele almak için SDK events (bkz. `Olaylar_ve_Durum_Yonetimi.md`) dinlemelidir.

```
// Ö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
```

2. 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.

- **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.

2. 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.

3. 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.

4. 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.

- **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.

2. 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).

3. 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.

4. 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.

- **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).

- **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.

2. 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).