Untitled

import android.os.Bundle
import android.app.Activity
import android.view.Menu
import android.view.MenuItem
import android.annotation.TargetApi
import android.app.Activity
import android.app.AlertDialog
import android.content.ComponentName
import android.content.Context
import android.content.DialogInterface
import android.content.Intent
import android.os.Handler
import android.os.Message
import android.os.UserHandle
import android.util.Log
import android.view.KeyEvent
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.view.View.OnClickListener
import android.widget.EditText
import android.widget.LinearLayout
import android.widget.ViewFlipper
import android.widget.TextView
import android.hardware.SensorEvent
import android.hardware.SensorEventListener
import android.hardware.SensorManager
import android.hardware.Sensor
import android.media.AudioManager
import java.io.*
import java.util.ArrayList
import java.io.InputStream
import java.nio.ByteBuffer
import java.nio.ByteOrder
import java.nio.ShortBuffer
import java.util.List
import com.mediatek.twoworlds.factory.common.MtkTvFApiDisplayTestTypes.*
import com.mediatek.twoworlds.factory.MtkTvFApiDisplayTestBase
import com.mediatek.twoworlds.factory.MtkTvFApiDisplayTest
import com.mediatek.twoworlds.factory.model.MtkTvFApiDispTstPattern
import com.mediatek.twoworlds.factory.model.MtkTvFApiColor
import com.mediatek.twoworlds.tv.MtkTvUtil
import com.mediatek.twoworlds.tv.MtkTvUtilBase
import com.mediatek.twoworlds.factory.MtkTvFApiSystem
import com.mediatek.twoworlds.factory.common.MtkTvFApiResultTypeBase
import com.mediatek.twoworlds.tv.common.MtkTvConfigType
import com.mediatek.twoworlds.tv.common.MtkTvConfigTypeBase
import com.mediatek.twoworlds.tv.MtkTvConfig
import android.hardware.lights.Light
import android.hardware.lights.LightState
import android.hardware.lights.LightsManager
import static android.hardware.lights.LightsRequest.Builder

class MainActivity(Activity, SensorEventListener):
    TAG = "MicViewHolder"
    
    digitInputBuffer = []
    isRCCommandModeEnabled = False
    commandType = 0
    exit = 0
    micFactory = None
    FFAlsresultpath = "/vendor/tvconfig/config/FFALSTestresult.txt"
    count = "Fail"
    sensorManager = None
    lSensor = None
    mSensor = None
    numberOfSensorsOnDevice = 0
    luxvalue = 0.0
    result = False
    ON_TAN = 0xff00ff00
    ON_RED = 0xffff0000
    ON_WHT = 0xffffffff
    ON_YEL = 0xffffff00
    STATE_TAN = LightState(ON_TAN)
    STATE_RED = LightState(ON_RED)
    STATE_WHT = LightState(ON_WHT)
    STATE_YEL = LightState(ON_YEL)
    mManager = None
    mLights = None
    
    def onCreate(self, savedInstanceState: Bundle) -> None:
        super().onCreate(savedInstanceState)
        self.init()
        in = self.getResources().openRawResource(R.raw.onek_tone_48khz_16bit_10s)
        try:
            refData = in.read()
            if refData < 0:
                in.close()
            else:
                in.close()
                refShortData = self.toShortArray(refData)
                self.micFactory = MicFactory(refShortData)
        except IOException as e:
            e.printStackTrace()
        self.sensorManager = self.getSystemService(SENSOR_SERVICE)
        self.lSensor = self.sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT)
        self.result = self.sensorManager.registerListener(self, self.lSensor, SensorManager.SENSOR_DELAY_NORMAL)
        if not MtkTvFApiSystem.getInstance().isFileExist(self.FFAlsresultpath):
            MtkTvFApiSystem.getInstance().createFile(self.FFAlsresultpath)
            fileMode = 0666
            MtkTvFApiSystem.getInstance().changeFileMode(self.FFAlsresultpath, fileMode)
    
    def onResume(self) -> None:
        super().onResume()
    
    def onPause(self) -> None:
        Log.d(self.TAG, "Pausemurat:")
    
    def onStop(self) -> None:
        super().onStop()
    
    def onDestroy(self) -> None:
        super().onDestroy()
    
    def init(self) -> None:
        setContentView(R.layout.activity_main)
        self.count = "Start Test"
        testview = findViewById(R.id.SonucALS)
        testview.setText(self.count)
        testviewFF = findViewById(R.id.SonucFF)
        testviewFF.setText(self.count)
        testviewFFMute = findViewById(R.id.SonucFFMute)
        testviewFFMute.setText(self.count)
        testviewLed = findViewById(R.id.SonucFFLed)
        testviewLed.setText("KONTROL ET")
    
    def onAccuracyChanged(self, sensor: Sensor, accuracy: int) -> None:
        pass
    
    def onSensorChanged(self, event: SensorEvent) -> None:
        self.luxvalue = event.values[0]
    
    def get_sensor_value(self) -> float:
        return self.luxvalue
    
    listener = OnClickListener(
        def onClick(self, view: View) -> None:
            currentid = -1
            ret = -1
            if getCurrentFocus() != None:
                currentid = getCurrentFocus().getId()
    
    def onKeyDown(self, keyCode: int, event: KeyEvent) -> bool:
        bRet = True
        if keyCode == KeyEvent.KEYCODE_0:
            self.setInternalPattern(0)
        elif keyCode == KeyEvent.KEYCODE_1:
            self.setMaxVolume()
            self.getMicStatus()
        elif keyCode == KeyEvent.KEYCODE_2:
            sensor_value = self.get_sensor_value()
            Log.d(self.TAG, "GirdimuratALSsucces=" + sensor_value)
            if sensor_value > 50:
                self.count = "Success"
            else:
                self.count = "Fail"
            ALSsensorValue = "ALSSensorValue = " + str(sensor_value) + "\n" + "ALSTestResult=" + self.count
            MtkTvFApiSystem.getInstance().writeFile(self.FFAlsresultpath, ALSsensorValue, True, True)
            testview = findViewById(R.id.SonucALS)
            testview.setText(self.count)
        elif keyCode == KeyEvent.KEYCODE_3:
            self.testControlMultipleLights()
        elif keyCode == KeyEvent.KEYCODE_4:
            self.setMaxVolume()
            self.getMicMuteStatus()
        elif keyCode == KeyEvent.KEYCODE_BACK:
            finish()
        else:
            pass
        return bRet
    
    def wait(self, ms: int) -> None:
        try:
            Thread.sleep(ms)
        except InterruptedException as ex:
            Thread.currentThread().interrupt()
    
    def setInternalPattern(self, val: int) -> None:
        item = 0
        ret = -1
        mTvFApiDisplayTest = MtkTvFApiDisplayTest.getInstance()
        mTestPattern = MtkTvFApiDispTstPattern()
        if val == 0:
            MtkTvFApiDisplayTest.getInstance().setOsdLayerOnOff(EnumOsdLayerType.E_OSD_HD_LAYER, True)
            mTestPattern.mIsModEnable = False
            mTestPattern.mModRData = 0
            mTestPattern.mModGData = 0
            mTestPattern.mModBData = 0
            ret = mTvFApiDisplayTest.generateTestPattern(MtkTvFApiDisplayTestBase.XC_MOD_PATTERN_MODE, mTestPattern)
        elif val == 1:
            mTestPattern.mIsModEnable = True
            mTestPattern.mModRData = 1023
            mTestPattern.mModGData = 0
            mTestPattern.mModBData = 0
            ret = mTvFApiDisplayTest.generateTestPattern(MtkTvFApiDisplayTestBase.XC_MOD_PATTERN_MODE, mTestPattern)
            self.wait(2000)
            self.setInternalPattern(0)
        elif val == 2:
            mTestPattern.mIsModEnable = True
            mTestPattern.mModRData = 0
            mTestPattern.mModGData = 1023
            mTestPattern.mModBData = 0
            ret = mTvFApiDisplayTest.generateTestPattern(MtkTvFApiDisplayTestBase.XC_MOD_PATTERN_MODE, mTestPattern)
            self.wait(2000)
            self.setInternalPattern(0)
        elif val == 3:
            mTestPattern.mIsModEnable = True
            mTestPattern.mModRData = 0
            mTestPattern.mModGData = 0
            mTestPattern.mModBData = 1023
            ret = mTvFApiDisplayTest.generateTestPattern(MtkTvFApiDisplayTestBase.XC_MOD_PATTERN_MODE, mTestPattern)
        elif val == 4:
            mTestPattern.mIsModEnable = True
            mTestPattern.mModRData = 0
            mTestPattern.mModGData = 0
            mTestPattern.mModBData = 0
            ret = mTvFApiDisplayTest.generateTestPattern(MtkTvFApiDisplayTestBase.XC_MOD_PATTERN_MODE, mTestPattern)
        elif val == 5:
            mTestPattern.mIsModEnable = True
            mTestPattern.mModRData = 1023
            mTestPattern.mModGData = 1023
            mTestPattern.mModBData = 1023
            ret = mTvFApiDisplayTest.generateTestPattern(MtkTvFApiDisplayTestBase.XC_MOD_PATTERN_MODE, mTestPattern)
    
    def setMaxVolume(self) -> int:
        ret = MtkTvFApiResultTypeBase.MTKTV_FAPI_RET_OK
        MAX_VOLUME = 90
        context = MainActivity.this
        manager = getSystemService(Context.AUDIO_SERVICE)
        manager.setStreamVolume(AudioManager.STREAM_MUSIC, MAX_VOLUME, AudioManager.FLAG_SHOW_UI)
        configId = MtkTvConfigType.CFG_AUD_AUD_SPEAKER_VOLUME
        ret = MtkTvConfig.getInstance().setConfigValue(configId, MAX_VOLUME)
        Log.i(self.TAG, "setmax=")
        if ret != MtkTvFApiResultTypeBase.MTKTV_FAPI_RET_OK:
            return -1
        return 0
    
    def toShortArray(self, bytes: byte[]) -> short[]:
        buffer = ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN)
        sb = buffer.asShortBuffer()
        shortArray = sb.limit()
        sb.get(shortArray)
        return shortArray
    
    def getMicStatus(self) -> None:
        handler = Handler()
        Thread(
            def run(self) -> None:
                ret = self.micFactory.getMicStatus(True)
                if ret.mic1Result == MicFactory.RECORD_OCCUPY:
                    return
                handler.post(
                    def run(self) -> None:
                        if ret.mic1Result == MicFactory.TEST_SUCCESS:
                            Log.d(self.TAG, "Girdimuratsucces")
                            self.count = "Success"
                        else:
                            self.count = "Fail"
                        Log.d(self.TAG, "GirdimuratFZ" + str(ret.mic1Freq))
                        Log.d(self.TAG, "GirdimuratDB" + str(ret.mic1DB))
                        FFBoardFzValue = "MicFreq = " + str(ret.mic1Freq)
                        FFBoardDBValue = "MicDB = " + str(ret.mic1DB)
                        FFMicResult = "FFMicResult=" + self.count
                        MtkTvFApiSystem.getInstance().writeFile(self.FFAlsresultpath, FFBoardFzValue, True, True)
                        MtkTvFApiSystem.getInstance().writeFile(self.FFAlsresultpath, FFBoardDBValue, True, True)
                        MtkTvFApiSystem.getInstance().writeFile(self.FFAlsresultpath, FFMicResult, True, True)
                        testviewFF = findViewById(R.id.SonucFF)
                        testviewFF.setText(self.count)
                )
            ).start()
    
    def getMicMuteStatus(self) -> None:
        handler = Handler()
        Thread(
            def run(self) -> None:
                ret = self.micFactory.getMicStatus(True)
                if ret.mic1Result == MicFactory.RECORD_OCCUPY:
                    return
                handler.post(
                    def run(self) -> None:
                        Log.d(self.TAG, "GirdimuratFZ" + str(ret.mic1Freq))
                        Log.d(self.TAG, "GirdimuratDB" + str(ret.mic1DB))
                        FFBoardFzValue = "MicFreq = " + str(ret.mic1Freq)
                        FFBoardDBValue = str(ret.mic1DB)
                        FFBoardDBValueLog = "MicDB =" + str(ret.mic1DB)
                        MtkTvFApiSystem.getInstance().writeFile(self.FFAlsresultpath, FFBoardFzValue, True, True)
                        MtkTvFApiSystem.getInstance().writeFile(self.FFAlsresultpath, FFBoardDBValueLog, True, True)
                        count = "Test Start"
                        if ret.mic1Freq == 0 and FFBoardDBValue == "-Infinity":
                            Log.d(self.TAG, "Mic is Mute ")
                            count = "Success"
                        else:
                            count = "Fail"
                        FFMicMuteResult = "FFMicMuteResult=" + count + "\n"
                        MtkTvFApiSystem.getInstance().writeFile(self.FFAlsresultpath, FFMicMuteResult, True, True)
                        testviewFFMute = findViewById(R.id.SonucFFMute)
                        testviewFFMute.setText(count)
                )
            ).start()
    
    def setUp(self) -> None:
        try:
            p = Runtime.getRuntime().exec("am start -n com.google.android.tv.assistant/.led.DemoActivity")
        except IOException as e:
            e.printStackTrace()
    
    def testControlMultipleLights(self) -> None:
        self.mManager = self.getSystemService(LightsManager.class)
        self.mLights = self.mManager.getLights()
        Log.d(self.TAG, "Girdimuratled" + str(self.mLights))
        with self.mManager.openSession() as session:
            session.requestLights(
                Builder()
                .setLight(self.mLights.get(0), self.STATE_YEL)
                .setLight(self.mLights.get(1), self.STATE_WHT)
                .setLight(self.mLights.get(2), self.STATE_TAN)
                .setLight(self.mLights.get(3), self.STATE_RED)
                .build()
            )
        self.wait(500)
        with self.mManager.openSession() as session2:
            session2.requestLights(
                Builder()
                .setLight(self.mLights.get(0), self.STATE_YEL)
                .setLight(self.mLights.get(1), self.STATE_WHT)
                .setLight(self.mLights.get(2), self.STATE_TAN)
                .setLight(self.mLights.get(3), self.STATE_RED)
                .build()
            )
        Log.d(self.TAG, "Girdimuratleddeneme" + str(self.mManager.getLightState(self.mLights.get(0)).getColor()))
        LedtestResult = "Led testi yapıldı"
        MtkTvFApiSystem.getInstance().writeFile(self.FFAlsresultpath, LedtestResult, True, True)