creek

The AI Image Editor of 2030
git clone https://github.com/maydayv7/creek

MainActivity.kt (4410B)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
package com.creek.ui

import io.flutter.embedding.android.FlutterActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.plugin.common.MethodChannel
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import android.content.Intent

class MainActivity : FlutterActivity() {
    private val CHANNEL = "com.creek.ui/methods"
    private val scope = CoroutineScope(Dispatchers.Default)

    override fun onNewIntent(intent: Intent) {
        super.onNewIntent(intent)
        setIntent(intent) // This updates the activity's intent to the new one
    }

    override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
        super.configureFlutterEngine(flutterEngine)

        // Initialize Python immediately in the background
        scope.launch(Dispatchers.IO) {
            ImageAnalyzer.initializePython(context)
        }

        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler { call, result ->
            // Launch a new coroutine for every method call on the IO dispatcher for parallel execution
            scope.launch(Dispatchers.IO) {
                try {
                    val response: Any? = when (call.method) {
                        "analyzeLayout" -> {
                            val path = call.argument<String>("imagePath")!!
                            ImageAnalyzer.analyzeLayout(path)
                        }
                        "analyzeColorStyle" -> {
                            val path = call.argument<String>("imagePath")!!
                            ImageAnalyzer.analyzeColorStyle(path)
                        }
                        "downloadInstagramImage" -> {
                            val url = call.argument<String>("url")!!
                            val outputDir = call.argument<String>("outputDir")!!
                            ImageAnalyzer.downloadInstagramImage(url, outputDir)
                        }
                        "generateStylesheet" -> {
                            val jsonList = call.argument<List<String>>("jsonList")!!
                            ImageAnalyzer.generateStylesheet(jsonList)
                        }
                        "generateMagicPrompt" -> {
                            val stylesheetJson = call.argument<String>("stylesheetJson") ?: "{}"
                            val caption = call.argument<String>("caption") ?: ""
                            val userPrompt = call.argument<String>("userPrompt") ?: ""
                            ImageAnalyzer.generateMagicPrompt(stylesheetJson, caption, userPrompt)
                        }
                        "getShareSource" -> {
                            val componentName = intent.component?.className
                            when {
                                componentName?.contains("ShareToFiles") == true -> "files"
                                componentName?.contains("ShareToMoodboards") == true -> "moodboards"
                                else -> "moodboards"
                            }
                        }
                        else -> null
                    }

                    // Switch back to the Main Thread to send the result to Flutter
                    withContext(Dispatchers.Main) {
                        if (response != null) {
                            result.success(response)
                        } else {
                            if (call.method == "downloadInstagramImage") {
                                // Specific error handling for downloader if needed
                                result.error("ERROR", "Download returned null", null)
                            } else if (response == null) {
                                // Python returned null (error inside script)
                                result.error("PYTHON_ERROR", "Python returned null for ${call.method}", null)
                            } else {
                                result.notImplemented()
                            }
                        }
                    }
                } catch (e: Exception) {
                    withContext(Dispatchers.Main) {
                        result.error("EXCEPTION", e.message, e.stackTraceToString())
                    }
                }
            }
        }
    }
}