The Developer's Guide to Seamless Check Processing SDK Integration

import com.chequesnap.sdk.CheckProcessingSDK
import com.chequesnap.sdk.model.*
import kotlinx.coroutines.*

class CheckDepositManager(private val context: Context) {
    
    private val sdk: CheckProcessingSDK by lazy {
        CheckProcessingSDK.Builder(context)
            .setApiKey(BuildConfig.CHECK_PROCESSING_API_KEY)
            .setEnvironment(if (BuildConfig.DEBUG) Environment.SANDBOX else Environment.PRODUCTION)
            .setConfiguration(createSDKConfiguration())
            .build()
    }
    
    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
    
    suspend fun startCheckCapture(activity: Activity): Result<CheckDepositResult> {
        return withContext(Dispatchers.IO) {
            try {
                // Initialize session
                val session = sdk.createSession(
                    customerID = UserManager.getCurrentUserID(),
                    accountID = AccountManager.getSelectedAccountID()
                )
                
                // Configure capture parameters
                val config = CaptureConfiguration.Builder()
                    .setImageQuality(ImageQuality.HIGH)
                    .setProcessingMode(ProcessingMode.REAL_TIME)
                    .setAllowedCheckTypes(
                        CheckType.PERSONAL,
                        CheckType.BUSINESS,
                        CheckType.PAYROLL
                    )
                    .setCustomTheme(createCustomTheme())
                    .setAccessibilityOptions(createAccessibilityOptions())
                    .build()
                
                // Start capture flow
                val result = session.captureCheck(activity, config)
                
                // Process result
                processCheckResult(result)
                
                Result.success(result)
                
            } catch (e: CheckProcessingException) {
                handleSDKError(e)
                Result.failure(e)
            }
        }
    }
    
    private fun createSDKConfiguration(): SDKConfiguration {
        return SDKConfiguration.Builder()
            .setDebugLogging(BuildConfig.DEBUG)
            .setMaxRetryAttempts(3)
            .setTimeoutSeconds(30)
            .setAnalyticsEnabled(true)
            .setCustomEndpoints(
                if (BuildConfig.DEBUG) debugEndpoints else productionEndpoints
            )
            .build()
    }
    
    private fun createCustomTheme(): CustomTheme {
        return CustomTheme.Builder()
            .setPrimaryColor(ContextCompat.getColor(context, R.color.brand_primary))
            .setSecondaryColor(ContextCompat.getColor(context, R.color.brand_secondary))
            .setFontFamily(ResourcesCompat.getFont(context, R.font.app_font))
            .setCornerRadius(context.resources.getDimensionPixelSize(R.dimen.corner_radius))
            .build()
    }
    
    private suspend fun processCheckResult(result: CheckDepositResult) {
        // Validate on background thread
        withContext(Dispatchers.Default) {
            validateCheckResult(result)
        }
        
        // Submit to backend
        val response = BackendAPI.submitDeposit(
            checkData = result.extractedData,
            frontImage = result.frontImage,
            backImage = result.backImage,
            metadata = result.metadata
        )
        
        // Update UI on main thread
        withContext(Dispatchers.Main) {
            EventBus.post(CheckDepositCompletedEvent(response))
        }
    }
    
    @Throws(ValidationException::class)
    private fun validateCheckResult(result: CheckDepositResult) {
        if (result.confidence < 0.8) {
            throw ValidationException("Low confidence score: ${result.confidence}")
        }
        
        if (result.extractedData.amount <= 0) {
            throw ValidationException("Invalid amount: ${result.extractedData.amount}")
        }
        
        // Business rule validation
        BusinessRules.validateDeposit(result.extractedData)
    }
    
    private fun handleSDKError(error: CheckProcessingException) {
        when (error.errorCode) {
            ErrorCode.CAMERA_PERMISSION_DENIED -> {
                // Handle permission error
                PermissionManager.requestCameraPermission()
            }
            ErrorCode.NETWORK_ERROR -> {
                // Handle network error
                NetworkErrorHandler.handle(error)
            }
            ErrorCode.INVALID_CONFIGURATION -> {
                // Handle configuration error
                CrashReporting.logError(error)
            }
            else -> {
                // Generic error handling
                ErrorManager.handleError(error)
            }
        }
    }
    
    fun cleanup() {
        scope.cancel()
        sdk.cleanup()
    }
}

// Android Integration Tests
@RunWith(AndroidJUnit4::class)
class CheckDepositIntegrationTest {
    
    @get:Rule
    val activityRule = ActivityScenarioRule(MainActivity::class.java)
    
    private lateinit var mockWebServer: MockWebServer
    private lateinit var checkDepositManager: CheckDepositManager
    
    @Before
    fun setUp() {
        mockWebServer = MockWebServer()
        mockWebServer.start()
        
        // Configure SDK to use mock server
        val config = TestSDKConfiguration.Builder()
            .setBaseUrl(mockWebServer.url("/").toString())
            .build()
            
        checkDepositManager = CheckDepositManager(
            InstrumentationRegistry.getInstrumentation().targetContext,
            config
        )
    }
    
    @Test
    fun testCompleteCheckDepositFlow() = runBlocking {
        // Mock successful API responses
        mockWebServer.enqueue(MockResponse().setBody(successfulSessionResponse))
        mockWebServer.enqueue(MockResponse().setBody(successfulDepositResponse))
        
        // Execute test
        activityRule.scenario.onActivity { activity ->
            val result = runBlocking {
                checkDepositManager.startCheckCapture(activity)
            }
            
            // Verify results
            assertTrue(result.isSuccess)
            assertEquals(2, mockWebServer.requestCount)
        }
    }
    
    @After
    fun tearDown() {
        mockWebServer.shutdown()
    }
}

// Android: Memory optimization
class ImageProcessor {
    
    companion object {
        private const val MAX_IMAGE_SIZE = 2048
        private const val JPEG_QUALITY = 85
    }
    
    fun optimizeForProcessing(bitmap: Bitmap): Bitmap {
        // Scale down large images
        val scaledBitmap = if (bitmap.width > MAX_IMAGE_SIZE || bitmap.height > MAX_IMAGE_SIZE) {
            val scale = maxOf(
                bitmap.width.toFloat() / MAX_IMAGE_SIZE,
                bitmap.height.toFloat() / MAX_IMAGE_SIZE
            )
            Bitmap.createScaledBitmap(
                bitmap,
                (bitmap.width / scale).toInt(),
                (bitmap.height / scale).toInt(),
                true
            ).also {
                bitmap.recycle() // Free original bitmap
            }
        } else {
            bitmap
        }
        
        return enhanceForOCR(scaledBitmap)
    }
    
    private fun enhanceForOCR(bitmap: Bitmap): Bitmap {
        // Apply image enhancements using native code for performance
        return nativeEnhanceImage(bitmap)
    }
    
    external fun nativeEnhanceImage(bitmap: Bitmap): Bitmap
}

// ❌ UI updates on background thread
GlobalScope.launch {
    val result = sdk.captureCheck()
    // This will crash!
    statusText.text = "Processing complete"
}

// ✅ Proper thread management
GlobalScope.launch {
    val result = sdk.captureCheck()
    withContext(Dispatchers.Main) {
        statusText.text = "Processing complete"
    }
}