FoodCooking_LandScape/app/src/main/java/com/develop/foodcooking/FoodCookingApp.kt

package com.develop.foodcooking

import android.annotation.SuppressLint
import android.content.Context
import android.content.Intent
import android.net.Uri
import android.os.Build
import android.os.PowerManager
import android.provider.Settings
import android.util.Log
import com.blankj.utilcode.util.AppUtils
import com.blankj.utilcode.util.PathUtils
import com.blankj.utilcode.util.ResourceUtils
import com.blankj.utilcode.util.Utils
import com.develop.base.app.BaseApp
import com.develop.base.ext.getBrandNum
import com.develop.base.ext.isNightTheme
import com.develop.base.ext.setNightTheme
import com.develop.base.util.MMkvUtils
import com.develop.common.data_repo.FoodDataProvider
import com.develop.common.data_repo.net.Api
import com.develop.common.data_repo.net.converter.SerializationConverter
import com.develop.common.data_repo.net.interceptor.FoodRequestInterceptor
import com.develop.common.food_sdk.GlobalDevEvent
import com.develop.common.food_sdk.SerialPortUtils
import com.develop.common.utils.compat.RecyclerViewCompat
import com.develop.common.utils.compat.ShapeableImageViewCompat
import com.develop.common.utils.compat.SmartRefreshLayoutCompat
import com.develop.common.utils.compat.StartViewCompat
import com.drake.net.convert.NetConverter
import com.drake.net.interceptor.RequestInterceptor
import com.drake.net.interfaces.NetErrorHandler
import com.drake.net.time.Interval
import com.kuyuntech.cofarcooking.device.sdk.constant.core.DevStatus
import com.kuyuntech.cofarcooking.device.sdk.eventbus.event.DevPromptEvent
import com.kuyuntech.cofarcooking.device.sdk.eventbus.event.DevStatusEvent
import com.kuyuntech.cofarcooking.device.sdk.util.core.CofarSDK
import org.alee.component.skin.compat.ConstraintLayoutCompat
import org.alee.component.skin.page.WindowManager
import org.alee.component.skin.service.Config
import org.alee.component.skin.service.IOptionFactory
import org.alee.component.skin.service.IThemeSkinOption
import org.alee.component.skin.service.ThemeSkinService
import org.greenrobot.eventbus.EventBus
import org.greenrobot.eventbus.Subscribe
import java.io.File
import java.lang.reflect.Method
import java.util.concurrent.TimeUnit


class FoodCookingApp : BaseApp() {
    companion object {
        init {
            Config.getInstance().skinMode = Config.SkinMode.REPLACE_ALL
            Config.getInstance().performanceMode = Config.PerformanceMode.EXPERIENCE_FIRST
            ConstraintLayoutCompat.init()
            RecyclerViewCompat.init()
            SmartRefreshLayoutCompat.init()
            ShapeableImageViewCompat.init()
            StartViewCompat.init()
        }
    }

    var mWakeLock: PowerManager.WakeLock? = null
    private lateinit var pm: PowerManager
    var minute = 0
    private  var heartBeatInterval :Interval?=null
    override fun onCreate() {
        hookWebView()
        super.onCreate()

        //FoodDataProvider.initFoodDataBase()
        ResourceUtils.copyFileFromAssets(
            ASSETS_NIGHT_SKIN_PACK,
            SKIN_PACK_PATH + NIGHT_SKIN_PACK_NAME
        )
        WindowManager.getInstance().init(this, OptionFactory())
        val isNight = !isNightTheme()
        //切换主题，theme=0 night= false 是0000的主题，而且需要AndroidManifest.xml主题设置为  android:theme="@style/SplashTheme"
        ThemeSkinService.getInstance().switchThemeSkin(1)
        setNightTheme(true)
        CofarSDK.init(getBrandNum())
        SerialPortUtils.init()
        CofarSDK.register(this)
        CofarSDK.stopNative()

//        val powerManager = getSystemService(POWER_SERVICE) as PowerManager
//        val wakeLock: PowerManager.WakeLock =
//            powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "motionDetection:keepAwake")
//        wakeLock.acquire()
        pm = getSystemService(POWER_SERVICE) as PowerManager
        minute = MMkvUtils.getInt("ScreenSaver")
        if (minute == 0) {
            minute = 5
        }
        Settings.System.putInt(
            contentResolver,
            Settings.System.SCREEN_OFF_TIMEOUT,
            (1000 * 60 * minute).toInt()
        )

        Settings.Secure.putInt(contentResolver, Settings.Secure.INSTALL_NON_MARKET_APPS, 1)

        val uri: Uri = Settings.System
            .getUriFor(Settings.System.SCREEN_OFF_TIMEOUT)
        contentResolver.notifyChange(uri, null)
        heartBeatInterval = Interval(1,1,TimeUnit.SECONDS,5).finish {
            //设备不通讯异常
           EventBus.getDefault().post(
                DevPromptEvent.builder()
                    .showCancelBtn(false)
                    .msg("dev_error")
                    .focus(true)
                    .build()
            )
        }.start()
    }


    fun hookWebView() {
        val TAG = "ASDD"
        val sdkInt = Build.VERSION.SDK_INT
        try {
            val factoryClass = Class.forName("android.webkit.WebViewFactory")
            val field = factoryClass.getDeclaredField("sProviderInstance")
            field.isAccessible = true
            var sProviderInstance = field[null]
            if (sProviderInstance != null) {
                Log.d(TAG, "sProviderInstance isn't null")
                return
            }
            val getProviderClassMethod: Method
            getProviderClassMethod = if (sdkInt > 22) {
                factoryClass.getDeclaredMethod("getProviderClass")
            } else if (sdkInt == 22) {
                factoryClass.getDeclaredMethod("getFactoryClass")
            } else {
                Log.d(TAG, "Don't need to Hook WebView")
                return
            }
            getProviderClassMethod.isAccessible = true
            val providerClass = getProviderClassMethod.invoke(factoryClass) as Class<*>
            val delegateClass = Class.forName("android.webkit.WebViewDelegate")
            val providerConstructor = providerClass.getConstructor(delegateClass)
            if (providerConstructor != null) {
                providerConstructor.isAccessible = true
                val declaredConstructor = delegateClass.getDeclaredConstructor()
                declaredConstructor.isAccessible = true
                sProviderInstance =
                    providerConstructor.newInstance(declaredConstructor.newInstance())
                field["sProviderInstance"] = sProviderInstance
            }
            Log.d(TAG, "Hook done!")
        } catch (e: Throwable) {
        }
    }


    override fun createHostUrl(): String {
        return Api.HOST
    }

    override fun createRequestInterceptor(): RequestInterceptor {
        return FoodRequestInterceptor()
    }

    override fun createConverter(): NetConverter {
        return SerializationConverter()
    }

    override fun createErrorHandle(): NetErrorHandler {
        return NetErrorHandler.DEFAULT
    }

    override fun attachBaseContext(base: Context?) {
        super.attachBaseContext(base)
        FoodDataProvider.prepareData(this)
    }


    override fun onTerminate() {
        super.onTerminate()
        SerialPortUtils.destroy()
        CofarSDK.unregister(this)
    }

    @SuppressLint("InvalidWakeLockTag")
    @Subscribe
    @Synchronized
    fun globalCoverEvent(event: DevStatusEvent) {
        heartBeatInterval?.cancel()
        val devInfo = event.devInfo;
        val pm = getSystemService(POWER_SERVICE) as PowerManager
        if (devInfo.status == DevStatus.RUNNING.toInt() || devInfo.isWeightStatus) {
            if (mWakeLock == null) {
                mWakeLock = pm.newWakeLock(
                    PowerManager.SCREEN_BRIGHT_WAKE_LOCK or PowerManager.ON_AFTER_RELEASE or PowerManager.ACQUIRE_CAUSES_WAKEUP,
                    "tag"
                );
                mWakeLock?.setReferenceCounted(false);
                mWakeLock?.acquire()
            }
        } else if (devInfo.status != DevStatus.RUNNING.toInt()) {
            if (mWakeLock != null) {
                mWakeLock?.release()
                mWakeLock = null
                val intent = Intent()
                intent.action = "android.intent.action.SS_DEVICE_TOUCH"
                sendBroadcast(intent)
            }
        }
        GlobalDevEvent.globalCoverEvent(event, pm)
    }
}

class OptionFactory : IOptionFactory {
    override fun defaultTheme(): Int {
        return 0
    }

    override fun requireOption(theme: Int): IThemeSkinOption? {
        return when (theme) {
            1 -> NightOption()
            else -> null
        }
    }
}

class NightOption : IThemeSkinOption {
    override fun getStandardSkinPackPath(): LinkedHashSet<String> {
        val pathSet = LinkedHashSet<String>()

        pathSet.add(SKIN_PACK_PATH + NIGHT_SKIN_PACK_NAME)
        return pathSet
    }
}

const val NIGHT_SKIN_PACK_NAME = "night.skin"
const val ASSETS_NIGHT_SKIN_PACK = "skins/night.skin"

/**
 * 应用存储空间根路径
 */
private val ROOT_PATH =
    Utils.getApp().getExternalFilesDir(null)?.absolutePath?.run { this + File.separator }
        ?: (PathUtils.getExternalAppDataPath() + "." + AppUtils.getAppPackageName() + File.separator)

/**
 * 皮肤包根路径
 */
val SKIN_PACK_PATH = ROOT_PATH + ".SkinPack" + File.separator