...

2025-07-16 12:56:56 +09:00
parent 3d65f30516
commit 405b8c8fed
14 changed files with 2926 additions and 2117 deletions
@@ -76,7 +76,6 @@ import bums.lunatic.launcher.LauncherActivity.Companion.lActivity
 import bums.lunatic.launcher.apps.AppDrawer
 import bums.lunatic.launcher.common.CommonActivity
 import bums.lunatic.launcher.databinding.LauncherActivityBinding
-import bums.lunatic.launcher.feeds.Feeds
 import bums.lunatic.launcher.feeds.WidgetHost
 import bums.lunatic.launcher.helpers.BluetoothManager
 import bums.lunatic.launcher.helpers.Constants.Companion.KEY_APPLICATION_THEME
@@ -1038,9 +1037,9 @@ internal class LauncherActivity : CommonActivity() {
 //        }
 //    }

-    fun switchFeeds() {
-        startActivity(Intent(this,Feeds::class.java))
-    }
+//    fun switchFeeds() {
+//        startActivity(Intent(this,Feeds::class.java))
+//    }

    //    inner class MyJavaScriptInterface(val webView: WebView) {
 //        @JavascriptInterface
@@ -0,0 +1,473 @@
+package bums.lunatic.launcher.home
+
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.os.Message
+import android.util.AttributeSet
+import android.util.Log
+import android.view.KeyEvent
+import android.view.KeyEvent.ACTION_UP
+import android.view.KeyEvent.KEYCODE_BUTTON_A
+import android.view.KeyEvent.KEYCODE_BUTTON_B
+import android.view.KeyEvent.KEYCODE_BUTTON_SELECT
+import android.view.KeyEvent.KEYCODE_BUTTON_START
+import android.view.KeyEvent.KEYCODE_BUTTON_X
+import android.view.KeyEvent.KEYCODE_BUTTON_Y
+import android.view.KeyEvent.KEYCODE_DPAD_DOWN
+import android.view.KeyEvent.KEYCODE_DPAD_UP
+import bums.lunatic.launcher.utils.Blog
+import com.google.gson.Gson
+import org.json.JSONObject
+import org.mozilla.gecko.util.ThreadUtils
+import org.mozilla.geckoview.ExperimentDelegate
+import org.mozilla.geckoview.GeckoResult
+import org.mozilla.geckoview.GeckoRuntime
+import org.mozilla.geckoview.GeckoRuntimeSettings
+import org.mozilla.geckoview.GeckoSession
+import org.mozilla.geckoview.GeckoView
+import org.mozilla.geckoview.MediaSession
+import org.mozilla.geckoview.WebExtension
+import org.mozilla.geckoview.WebExtension.MessageDelegate
+import org.mozilla.geckoview.WebExtension.PortDelegate
+import org.mozilla.geckoview.WebExtensionController.AddonManagerDelegate
+import org.mozilla.geckoview.WebRequestError
+
+class GeckoWeb : GeckoView {
+    constructor(context: Context?) : super(context) {
+        initWithContext(context)
+    }
+    constructor(context: Context?, attrs: AttributeSet?) : super(context, attrs) {
+        initWithContext(context)
+    }
+
+    fun loadUrl(url: String) {
+        Blog.LOGE("url >>>> ${url}")
+        if (url.split("//").size > 1) {
+            url.replace("//","/").replace("https:/","https://").let {
+                Blog.LOGE("url >> ${url} , it >>> ${it}")
+                this.session?.loadUri(url)
+            }
+        } else {
+            this.session?.loadUri(url)
+        }
+
+        currentRetryCount = 0;
+    }
+    val handle = object : Handler(Looper.getMainLooper()) {
+        override fun handleMessage(msg: Message) {
+            if (msg.what == 0) {
+                (msg.obj as? ReaderConfig)?.let {
+                }
+            }
+        }
+    }
+
+    var lastedUrl: String? = null
+    var canGoBack: Boolean? = null
+    var mPort: WebExtension.Port? = null
+
+    object WebExtensionInfo {
+        val mPortNam = "browser"
+        val extPath = "resource://android/assets/extensions/my_extension/"
+        val extId = "messaging@booktoki468.com"
+    }
+
+    var mExtension: WebExtension? = null
+    var mSession: GeckoSession? = null
+    val addonManagerDelegate = object : AddonManagerDelegate {
+        override fun onReady(extension: WebExtension) {
+            Blog.LOGE("onReady ${extension.id} from WebExtension")
+            mExtension = extension
+        }
+
+        override fun onEnabling(extension: WebExtension) {
+            Blog.LOGE("onEnabling ${extension.id} from WebExtension")
+        }
+
+        override fun onEnabled(extension: WebExtension) {
+            Blog.LOGE("onEnabled ${extension.id} from WebExtension")
+            mExtension = extension
+
+        }
+    }
+    private fun initWithContext(context: Context?) {
+        context?.let { context ->
+            initGeckoRuntime(context)
+            mSession = GeckoSession()
+            mSession?.contentDelegate = contentDelegate
+            mSession?.progressDelegate = progressDelegate
+            mSession?.navigationDelegate = navigationDelegate
+            sRuntime?.apply {
+                webExtensionController.setAddonManagerDelegate(addonManagerDelegate)
+                webExtensionController.ensureBuiltIn(WebExtensionInfo.extPath, WebExtensionInfo.extId)
+                    .accept( // Register message delegate for background script
+                        { extension: WebExtension? ->
+                            ThreadUtils.runOnUiThread(Runnable { mSession?.let{session-> extension?.let { session.webExtensionController.setMessageDelegate(it,messageDelegate,WebExtensionInfo.mPortNam) }} })
+                        },
+                        { e: Throwable? -> Log.e("MessageDelegate", "Error registering WebExtension", e) })
+
+                mSession?.mediaDelegate = mediaDelegate
+                mSession?.mediaSessionDelegate = mediaSessionDelegate
+                mSession?.open(sRuntime!!)
+
+            }.let {
+                this.setSession(mSession!!)
+                this.loadUrl("https://booktoki468.com") // Or any other URL...
+            }
+        }
+    }
+    val mediaDelegate = object : GeckoSession.MediaDelegate {
+        override fun onRecordingStatusChanged(
+            session: GeckoSession,
+            devices: Array<out GeckoSession.MediaDelegate.RecordingDevice?>
+        ) {
+            super.onRecordingStatusChanged(session, devices)
+        }
+    }
+    val mediaSessionDelegate = object : MediaSession.Delegate {
+        override fun onActivated(
+            session: GeckoSession,
+            mediaSession: MediaSession
+        ) {
+            Blog.LOGE("onActivated")
+            super.onActivated(session, mediaSession)
+        }
+
+        override fun onDeactivated(
+            session: GeckoSession,
+            mediaSession: MediaSession
+        ) {
+            Blog.LOGE("onDeactivated")
+            super.onDeactivated(session, mediaSession)
+        }
+
+        override fun onMetadata(
+            session: GeckoSession,
+            mediaSession: MediaSession,
+            meta: MediaSession.Metadata
+        ) {
+            Blog.LOGE("onMetadata ${Gson().toJson(meta)}")
+            super.onMetadata(session, mediaSession, meta)
+        }
+
+        override fun onFeatures(
+            session: GeckoSession,
+            mediaSession: MediaSession,
+            features: Long
+        ) {
+            Blog.LOGE("onFeatures $features")
+            super.onFeatures(session, mediaSession, features)
+        }
+
+        override fun onPlay(
+            session: GeckoSession,
+            mediaSession: MediaSession
+        ) {
+            Blog.LOGE("onPlay")
+            super.onPlay(session, mediaSession)
+        }
+
+        override fun onPause(
+            session: GeckoSession,
+            mediaSession: MediaSession
+        ) {
+            Blog.LOGE("onPause")
+            super.onPause(session, mediaSession)
+        }
+
+        override fun onStop(
+            session: GeckoSession,
+            mediaSession: MediaSession
+        ) {
+            Blog.LOGE("onStop")
+            super.onStop(session, mediaSession)
+        }
+
+        override fun onPositionState(
+            session: GeckoSession,
+            mediaSession: MediaSession,
+            state: MediaSession.PositionState
+        ) {
+            Blog.LOGE("onPositionState $state")
+            super.onPositionState(session, mediaSession, state)
+        }
+
+        override fun onFullscreen(
+            session: GeckoSession,
+            mediaSession: MediaSession,
+            enabled: Boolean,
+            meta: MediaSession.ElementMetadata?
+        ) {
+            Blog.LOGE("onFullscreen $Boolean ${Gson().toJson(meta)}")
+            super.onFullscreen(session, mediaSession, enabled, meta)
+        }
+    }
+    private fun initGeckoRuntime(context : Context) {
+        if (sRuntime == null) {
+            try {
+                val settings: GeckoRuntimeSettings =
+                    GeckoRuntimeSettings.Builder().extensionsProcessEnabled(true)
+                        .extensionsWebAPIEnabled(true)
+                        .experimentDelegate(experimentDelegate)
+                        .remoteDebuggingEnabled(true).build()
+
+                sRuntime = GeckoRuntime.create(context, settings)
+            } catch (e: Exception) {
+
+            }
+        }
+    }
+
+    val experimentDelegate = object : ExperimentDelegate {
+        override fun onGetExperimentFeature(feature: String): GeckoResult<JSONObject?> {
+            Blog.LOGE("onGetExperimentFeature $feature")
+            return super.onGetExperimentFeature(feature)
+        }
+
+        override fun onRecordExposureEvent(feature: String): GeckoResult<Void?> {
+            Blog.LOGE("onRecordExposureEvent $feature")
+            return super.onRecordExposureEvent(feature)
+        }
+
+        override fun onRecordExperimentExposureEvent(
+            feature: String,
+            slug: String
+        ): GeckoResult<Void?> {
+            Blog.LOGE("onRecordExperimentExposureEvent $feature , $slug")
+            return super.onRecordExperimentExposureEvent(feature, slug)
+        }
+
+        override fun onRecordMalformedConfigurationEvent(
+            feature: String,
+            part: String
+        ): GeckoResult<Void?> {
+            Blog.LOGE("onRecordMalformedConfigurationEvent $feature , $part")
+            return super.onRecordMalformedConfigurationEvent(feature, part)
+        }
+    }
+    val contentDelegate = object : GeckoSession.ContentDelegate {
+        override fun onTitleChange(
+            session: GeckoSession,
+            title: String?
+        ) {
+            Blog.LOGE("onTitleChange $title")
+            super.onTitleChange(session, title)
+        }
+
+        override fun onCrash(session: GeckoSession) {
+            Blog.LOGE("onCrash")
+            super.onCrash(session)
+        }
+
+        override fun onPaintStatusReset(session: GeckoSession) {
+            Blog.LOGE("onPaintStatusReset")
+            super.onPaintStatusReset(session)
+        }
+
+        override fun onFirstContentfulPaint(session: GeckoSession) {
+            Blog.LOGE("onFirstContentfulPaint")
+            super.onFirstContentfulPaint(session)
+        }
+    }
+    val progressDelegate = object : GeckoSession.ProgressDelegate {
+        override fun onSecurityChange(
+            session: GeckoSession,
+            securityInfo: GeckoSession.ProgressDelegate.SecurityInformation
+        ) {
+            Blog.LOGE("onSecurityChange $securityInfo from WebExtension")
+            super.onSecurityChange(session, securityInfo)
+        }
+
+        override fun onSessionStateChange(
+            session: GeckoSession,
+            sessionState: GeckoSession.SessionState
+        ) {
+            Blog.LOGE("onSessionStateChange $sessionState from WebExtension")
+            super.onSessionStateChange(session, sessionState)
+        }
+
+        override fun onPageStart(session: GeckoSession, url: String) {
+            super.onPageStart(session, url)
+        }
+
+        override fun onPageStop(session: GeckoSession, success: Boolean) {
+            Blog.LOGE("onPageStop $success from WebExtension")
+            super.onPageStop(session, success)
+            if (success && mPort != null) {
+                if (mPort == null) {
+                    // No extension registered yet, let's ignore this message
+                    return
+                }
+
+            }
+        }
+    }
+
+    val navigationDelegate = object : GeckoSession.NavigationDelegate {
+        override fun onLoadError(
+            session: GeckoSession,
+            uri: String?,
+            error: WebRequestError
+        ): GeckoResult<String>? {
+            error.printStackTrace()
+            Blog.LOGE("onLoadError >>> ${uri} ::>> ${error.category} , ${error.code}")
+            if (error.code == WebRequestError.ERROR_NET_RESET) {
+
+            }
+            return super.onLoadError(session, uri, error)
+        }
+
+        override fun onNewSession(
+            session: GeckoSession,
+            uri: String
+        ): GeckoResult<GeckoSession>? {
+            Blog.LOGE("GeckoView", "onNewSession: $session from WebExtension")
+
+
+            return super.onNewSession(session, uri)
+        }
+
+        override fun onLocationChange(
+            session: GeckoSession,
+            url: String?,
+            perms: MutableList<GeckoSession.PermissionDelegate.ContentPermission>,
+            hasUserGesture: Boolean
+        ) {
+            // url이 현재 로드된 주소입니다.
+            Blog.LOGE("GeckoView", "현재 주소: $url")
+            Blog.LOGE("GeckoView", "현재 session: $session")
+            url?.let { url ->
+                if (url.split("//").size > 1) {
+                    url.replace("//", "/").replace("https:/", "https://").let {
+                        Blog.LOGE("url >> ${url} , it >>> ${it}")
+                        lastedUrl = url
+                    }
+                } else {
+                    lastedUrl = url
+                }
+            }
+
+        }
+
+        override fun onCanGoBack(session: GeckoSession, canGoBack: Boolean) {
+            super.onCanGoBack(session, canGoBack)
+            this@GeckoWeb.canGoBack = canGoBack
+            if (canGoBack) {
+
+            }
+        }
+
+    }
+
+    val portDelegate: PortDelegate =
+        object : PortDelegate {
+            override fun onPortMessage(
+                message: Any, port: WebExtension.Port
+            ) {
+                Blog.LOGE("PortDelegate", "Received message from extension: $message")
+
+            }
+
+
+            override fun onDisconnect(port: WebExtension.Port) {
+                // This port is not usable anymore.
+                if (port === mPort) {
+                    mPort = null
+                }
+            }
+        }
+
+    val messageDelegate: MessageDelegate =
+        object : MessageDelegate {
+            override fun onConnect(port: WebExtension.Port) {
+                mPort = port
+                mPort!!.setDelegate(portDelegate)
+            }
+
+            override fun onMessage(
+                nativeApp: String,
+                message: Any,
+                sender: WebExtension.MessageSender
+            ): GeckoResult<in Any>? {
+                Blog.LOGE(
+                    "messageDelegate",
+                    "onMessage from WebExtension: ${nativeApp} , $message , ${sender.webExtension.id}"
+                )
+                return super.onMessage(nativeApp, message, sender)
+            }
+
+
+        }
+
+
+    fun onStart() {
+
+    }
+
+    fun onResume() {
+
+
+    }
+
+
+    fun onDestroy() {
+        sRuntime = null
+    }
+
+
+
+    override fun dispatchKeyEvent(ev: KeyEvent): Boolean {
+        Blog.LOGE("dispatch  ev?.device?.name >>> ${ev?.device?.name}")
+        if (ev?.device?.name?.contains("SM-031N Mouse") == true) {
+            when (ev.action) {
+                ACTION_UP -> {
+                    Blog.LOGE("dispatch dispatchKeyEvent>>> ${ev}")
+                    when (ev.keyCode) {
+                        KEYCODE_BUTTON_Y -> {
+                        }
+
+                        KEYCODE_BUTTON_X -> {
+
+                        }
+
+                        KEYCODE_BUTTON_A -> {
+                        }
+
+                        KEYCODE_BUTTON_B -> {
+
+                        }
+
+                        KEYCODE_DPAD_DOWN -> {
+
+                        }
+
+                        KEYCODE_DPAD_UP -> {
+
+                        }
+
+                        KEYCODE_BUTTON_START -> {
+                        }
+
+                        KEYCODE_BUTTON_SELECT -> {
+
+                        }
+
+                        else -> {}
+                    }
+                }
+
+                else -> {}
+            }
+            return true
+        }
+        return super.dispatchKeyEvent(ev)
+    }
+
+
+    companion object {
+        private const val TAG = "DualScreenStatus"
+        var sRuntime: GeckoRuntime? = null
+        var currentRetryCount = 0
+    }
+}
@@ -121,7 +121,7 @@ class RssViewerActivity  : AwesomeWebViewActivity(), View.OnGenericMotionListene
        } else {
            loadWithIntent = false
        }
-    webView?.setOnTouchListener(this)
+        webView?.setOnTouchListener(this)

    }
    private var startX = 0f
@@ -45,7 +45,7 @@ class OpenWeatherGetter(context: Context, workerParams: WorkerParameters) : Base
    }

    fun getWeather(latitude: Double, longitude: Double) {
-        Blog.LOGE("into getWeather")
+        Blog.LOGE("into getWeather ${PrefString.weatherApiKey.get()}")
        ///saved weatherForcast
        Retrofit.Builder()
            .baseUrl(URI_WEATHERAPI)