kotlin AS PL grimoire

package com.example.json3

import android.os.AsyncTask
import android.support.v7.app.AppCompatActivity
import android.os.Bundle
import kotlinx.android.synthetic.main.activity_main.*
import org.json.JSONObject
import java.io.IOException
import java.io.InputStreamReader
import java.lang.Exception
import java.net.HttpURLConnection
import java.net.URL
import android.widget.Toast
import java.io.BufferedReader


class MainActivity : AppCompatActivity() {


    private var xmlString = ""
    private val XML_URL = "https://www.yotamarker.com"
    var XML_UR= "https://reqres.in/api/users/2"
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        getDataJSON()
        try {
            Thread.sleep(6000)
        } catch (e: InterruptedException) {
            e.printStackTrace()
        }

        txt1.text = xmlString


    }

    fun getDataJSON() {
        //we never use void in AsyncTask, we need to use Void
        object : AsyncTask<Void, Void, String>() {
            override fun doInBackground(vararg voids: Void): String {
                //we need to open HTTP URL Connection to our desired URL (www.boi.org.il)
                var connection: HttpURLConnection? = null
                try {
                    connection = URL(XML_URL).openConnection() as HttpURLConnection
                    val buf = BufferedReader(InputStreamReader(connection.inputStream))
                    var line: String?
                    line = buf.readLine()
                    while (line != null) {
                        line = buf.readLine()
                        xmlString += line
                    }
                } catch (e: IOException) {
                    e.printStackTrace()
                } finally {
                    connection!!.disconnect()
                }

                return xmlString
            }

            override fun onPostExecute(jsonString: String) {
                super.onPostExecute(jsonString)
                http@ http://Log.e("XML", "onPostExecute: " + jsonString);
                // display json string
                Toast.makeText(applicationContext, jsonString, Toast.LENGTH_LONG).show()

            }
        }.execute()
    }

}

package com.example.json3

import android.os.AsyncTask
import android.support.v7.app.AppCompatActivity
import android.os.Bundle
import kotlinx.android.synthetic.main.activity_main.*
import org.json.JSONObject
import java.io.IOException
import java.io.InputStreamReader
import java.lang.Exception
import java.net.HttpURLConnection
import java.net.URL
import android.widget.Toast
import java.io.BufferedReader
import org.json.JSONException




class MainActivity : AppCompatActivity() {


    private var jsonString = ""
    private val jsonURL = "https://swapi.co/api/people/1/"
    //var XML_UR= "https://reqres.in/api/users/2"
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        getDataJSON()
        try {
            Thread.sleep(6000)
        } catch (e: InterruptedException) {
            e.printStackTrace()
        }

        http://txt1.text = jsonString
        parseJson(jsonString)

    }

    fun getDataJSON() {
        //we never use void in AsyncTask, we need to use Void
        object : AsyncTask<Void, Void, String>() {
            override fun doInBackground(vararg voids: Void): String {
                //we need to open HTTP URL Connection to our desired URL (www.boi.org.il)
                var connection: HttpURLConnection? = null
                try {
                    connection = URL(jsonURL).openConnection() as HttpURLConnection
                    val buf = BufferedReader(InputStreamReader(connection.inputStream))
                    var line: String? = buf.readLine()
                    while (line != null) {
                        jsonString += line
                    }
                } catch (e: IOException) {
                    e.printStackTrace()
                } finally {
                    connection!!.disconnect()
                }

                return jsonString
            }

            override fun onPostExecute(jsonString: String) {
                super.onPostExecute(jsonString)
                http://Log.e("XML", "onPostExecute: $jsonString")
                parseJson(jsonString)
            }
        }.execute()
    }

    private fun parseJson(jsonString: String) {
        val jsonObj = JSONObject(jsonString)
        val namee = jsonObj.getString("name")

        txt1.text= namee

    }

}

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.os.BatteryManager
import android.support.v7.app.AppCompatActivity
import android.os.Bundle
import kotlinx.android.synthetic.main.activity_main.*

class MainActivity : AppCompatActivity() {
    var b8TRcounter = 0
    private val mBatInfoReceiver = object : BroadcastReceiver() {
        override fun onReceive(ctxt: Context, intent: Intent) {
            val level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, 0)
            b8TRcounter++;
            txtBox.setText("$level% $b8TRcounter")
            val status: Int = intent.getIntExtra(BatteryManager.EXTRA_STATUS, -1)
            val isCharging: Boolean = status == BatteryManager.BATTERY_STATUS_CHARGING
                    || status == BatteryManager.BATTERY_STATUS_FULL

            val chargePlug: Int = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1)
            val usbCharge: Boolean = chargePlug == BatteryManager.BATTERY_PLUGGED_USB
            val acCharge: Boolean = chargePlug == BatteryManager.BATTERY_PLUGGED_AC
            //txtBox.setText("$usbCharge")
        }
    }
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        this.registerReceiver(this.mBatInfoReceiver, IntentFilter(Intent.ACTION_BATTERY_CHANGED));
    }

}

 mediaPlayer = MediaPlayer.create(this, R.raw.hadouken)
                mediaPlayer.setNextMediaPlayer(MediaPlayer.create(this, R.raw.shouryuken))
                mediaPlayer.start()

supportActionBar?.hide()

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        supportActionBar?.hide()
        this.registerReceiver(this.mBatInfoReceiver, IntentFilter(Intent.ACTION_BATTERY_CHANGED));
    }

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
                                            xmlns:tools="http://schemas.android.com/tools"
                                            android:layout_width="match_parent"
                                            android:layout_height="match_parent"
                                            tools:context="com.tutorialkart.texttospeechapp.MainActivity">

    <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:orientation="vertical"
            android:gravity="center">
        <EditText
                android:id="@+id/edittext_input"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:ems="10" >
            <requestFocus />
        </EditText>

        <Button
                android:id="@+id/button_speak"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="Speak" />
    </LinearLayout>
</android.support.constraint.ConstraintLayout>

package com.yotamarker.kotlintts

import android.support.v7.app.AppCompatActivity
import android.os.Bundle
import android.speech.tts.TextToSpeech
import android.util.Log
import android.widget.Button
import android.widget.EditText
import kotlinx.android.synthetic.main.activity_main.*
import java.util.*

class MainActivity : AppCompatActivity(), TextToSpeech.OnInitListener {

    private var tts: TextToSpeech? = null
    private var buttonSpeak: Button? = null
    private var editText: EditText? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        buttonSpeak = this.button_speak
        editText = this.edittext_input

        buttonSpeak!!.isEnabled = false;
        tts = TextToSpeech(this, this)

        buttonSpeak!!.setOnClickListener { speakOut() }
    }

    override fun onInit(status: Int) {

        if (status == TextToSpeech.SUCCESS) {
            // set US English as language for tts
            val result = tts!!.setLanguage(Locale.US)

            if (result == TextToSpeech.LANG_MISSING_DATA || result == TextToSpeech.LANG_NOT_SUPPORTED) {
                Log.e("TTS","The Language specified is not supported!")
            } else {
                buttonSpeak!!.isEnabled = true
            }

        } else {
            Log.e("TTS", "Initilization Failed!")
        }

    }

    private fun speakOut() {
        val text = editText!!.text.toString()
        tts!!.speak(text, TextToSpeech.QUEUE_FLUSH, null,"")
    }

    public override fun onDestroy() {
        // Shutdown TTS
        if (tts != null) {
            tts!!.stop()
            tts!!.shutdown()
        }
        super.onDestroy()
    }

}

imageView2.setOnLongClickListener {
            mbTTS.voiceIt("hadouken")
            true
        }

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.yotamarker.gyro3">
    <uses-permission android:name="android.permission.READ_PHONE_STATE"/>

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

interface AccelerometerListener {

    fun onAccelerationChanged(x: Float, y: Float, z: Float)

    fun onShake(force: Float)
}

import android.content.Context
import android.hardware.Sensor
import android.hardware.SensorEvent
import android.hardware.SensorEventListener
import android.hardware.SensorManager
import android.widget.Toast

object AccelerometerManager {

   private var context: Context? = null
   /**
   * Accuracy configuration
   */
   private var threshold = 15.0f
   private var interval = 200

   private var sensor: Sensor? = null
   private var sensorManager: SensorManager? = null
   // you could use an OrientationListener array instead
   // if you plans to use more than one listener
   private var listener: AccelerometerListener? = null

   /**
   * indicates whether or not Accelerometer Sensor is supported
   */
   private var supported: Boolean? = null
   /**
   * indicates whether or not Accelerometer Sensor is running
   */
   /**
   * Returns true if the manager is listening to orientation changes
   */
   var isListening = false
       private set

   private val sensorEventListener = object : SensorEventListener {

       private var now: Long = 0
       private var timeDiff: Long = 0
       private var lastUpdate: Long = 0
       private var lastShake: Long = 0

       private var x = 0f
       private var y = 0f
       private var z = 0f
       private var lastX = 0f
       private var lastY = 0f
       private var lastZ = 0f
       private var force = 0f

       override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {}

       override fun onSensorChanged(event: SensorEvent) {
           // use the event timestamp as reference
           // so the manager precision won't depends
           // on the AccelerometerListener implementation
           // processing time
           now = event.timestamp

           x = event.values[0]
           y = event.values[1]
           z = event.values[2]

           // if not interesting in shake events
           // just remove the whole if then else block
           if (lastUpdate == 0L) {
               lastUpdate = now
               lastShake = now
               lastX = x
               lastY = y
               lastZ = z
               Toast.makeText(context, "No Motion detected", Toast.LENGTH_SHORT).show()

           } else {
               timeDiff = now - lastUpdate

               if (timeDiff > 0) {

                   force = Math.abs(x + y + z - lastX - lastY - lastZ)

                   if (java.lang.Float.compare(force, threshold) > 0) {

                       if (now - lastShake >= interval) {
                           // trigger shake event
                           listener!!.onShake(force)
                       } else {
                           Toast.makeText(
                               context, "No Motion detected",
                               Toast.LENGTH_SHORT
                           ).show()

                       }
                       lastShake = now
                   }
                   lastX = x
                   lastY = y
                   lastZ = z
                   lastUpdate = now
               } else {
                   Toast.makeText(context, "No Motion detected", Toast.LENGTH_SHORT).show()
               }
           }
           // trigger change event
           listener!!.onAccelerationChanged(x, y, z)
       }
   }

   /**
   * Unregisters listeners
   */
   fun stopListening() {
       isListening = false
       try {
           if (sensorManager != null && sensorEventListener != null) {
               sensorManager!!.unregisterListener(sensorEventListener)
           }
       } catch (e: Exception) {
       }

   }

   /**
   * Returns true if at least one Accelerometer sensor is available
   */
   fun isSupported(cntxt: Context): Boolean {
       context = cntxt
       if (supported == null) {
           if (context != null) {

               sensorManager = context!!.getSystemService(Context.SENSOR_SERVICE) as SensorManager

               // Get all sensors in device
               val sensors = sensorManager!!.getSensorList(
                   Sensor.TYPE_ACCELEROMETER
               )

               supported = sensors.size > 0
           } else {
               supported = java.lang.Boolean.FALSE
           }
       }
       return supported!!
   }

   /**
   * Configure the listener for shaking
   *
   * @param threshold minimum acceleration variation for considering shaking
   * @param interval minimum interval between to shake events
   */
   fun configure(threshold: Int, interval: Int) {
       AccelerometerManager.threshold = threshold.toFloat()
       AccelerometerManager.interval = interval
   }

   /**
   * Registers a listener and start listening
   *
   * @param accelerometerListener callback for accelerometer events
   */
   fun startListening(accelerometerListener: AccelerometerListener) {

       sensorManager = context!!.getSystemService(Context.SENSOR_SERVICE) as SensorManager

       // Take all sensors in device
       val sensors = sensorManager!!.getSensorList(
           Sensor.TYPE_ACCELEROMETER
       )

       if (sensors.size > 0) {

           sensor = sensors[0]

           // Register Accelerometer Listener
           isListening = sensorManager!!.registerListener(
               sensorEventListener, sensor,
               SensorManager.SENSOR_DELAY_GAME
           )

           listener = accelerometerListener
       }
   }

   /**
   * Configures threshold and interval
   * And registers a listener and start listening
   *
   * @param accelerometerListener callback for accelerometer events
   * @param threshold minimum acceleration variation for considering shaking
   * @param interval minimum interval between to shake events
   */
   fun startListening(accelerometerListener: AccelerometerListener, threshold: Int, interval: Int) {
       configure(threshold, interval)
       startListening(accelerometerListener)
   }
}

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <TextView
        android:id="@+id/textView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:gravity="center"
        android:text="Main Screen"
        android:textColor="@android:color/black"
        android:textSize="32sp"/>
</LinearLayout>

package com.yotamarker.testgyro

import android.support.v7.app.AppCompatActivity
import android.os.Bundle
import android.widget.Toast
import kotlinx.android.synthetic.main.activity_main.*

class MainActivity : AppCompatActivity() , AccelerometerListener{
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

    }
    override protected fun onResume() {
        super.onResume()
        if (AccelerometerManager.isSupported(this))
        {
            AccelerometerManager.startListening(this)
        }
    }
    override fun onAccelerationChanged(x:Float, y:Float, z:Float) {
        tv1.setText("x: = " + x + " y= " + y + " z = " + z)
    }
    override fun onShake(force:Float) {
        Toast.makeText(this, "Motion detected", Toast.LENGTH_SHORT).show()
    }

    override fun onStop() {
        super.onStop()
        //Check device supported Accelerometer senssor or not
        if (AccelerometerManager.isListening())
        {
            //Start Accelerometer Listening
            AccelerometerManager.stopListening()
            Toast.makeText(this, "onStop Accelerometer Stopped", Toast.LENGTH_SHORT).show()
        }
    }
    override fun onDestroy() {
        super.onDestroy()
        if (AccelerometerManager.isListening())
        {
            AccelerometerManager.stopListening()
            Toast.makeText(this, "onDestroy Accelerometer Stopped", Toast.LENGTH_SHORT).show()
        }
    }
}

class JikanMon {
    private val playGround = PlayGround()
    private var x = -1
    private var timePause = 3
    val isBlocked:Boolean
        get() {
            val nowSeconds = playGround.getSecondsAsInt()
            if ((x < 0 || nowSeconds > x) || (x > 60 && nowSeconds > (x - 60)))
            {
                x = -1
                return false
            }
            return true
        }
    fun block() {
        this.x = playGround.getSecondsAsInt() + timePause
    }
    fun setTimePause(timePause:Int) {
        if ((timePause > 0) && (timePause < 30))
        {
            this.timePause = timePause
        }
    }
}

override fun onAccelerationChanged(x:Float, y:Float, z:Float) {
        // *add gyroy below
        if((gyroX - x) > 2 && !gyroGate.isBlocked){
            gyroCounter++
            gyroGate.block()
            Toast.makeText(this, "moved $gyroCounter", Toast.LENGTH_SHORT).show()
            // out put uses this 4 lines :
            //var resultStr = chii.doIt("","shake","")
            //editText.setText("")
            //mbTTS.voiceIt(resultStr)
            //if (mbTTS.TTS){speakOut(resultStr)}
            //face(chii.getEmot())
             }
        else{}
        gyroX=x;gyroY=y;
    }

val mgr = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        mgr.hideSoftInputFromWindow(editText.windowToken,0)

val handler = Handler()

        val run = object : Runnable {
            override fun run() {
                Log.i("hadouken", "A second passed by")

                handler.postDelayed(this, 1000)
            }
        }

        handler.post(run)

editText.setOnKeyListener(View.OnKeyListener { v, keyCode, event ->
            if (event.action == KeyEvent.ACTION_DOWN && keyCode == KeyEvent.KEYCODE_ENTER) {
                // code goes here
                return@OnKeyListener true
            }
            false
        })

fun placeToString() {
        // convert gps coordinates into place name
        var returnString = ""
        val gcdLocale = Geocoder(this, Locale.ENGLISH) //new Geocoder(this, Locale.ENGLISH)
        var localeAdd:List<Address>? = null
        try
        {

            localeAdd = gcdLocale.getFromLocation(Tokoro.lat, Tokoro.lon, 1)
        }
        catch (e: IOException) {
            e.printStackTrace()
        }
        //if localeAdd is null (false) get out of the function (method)
        assert(localeAdd != null)
        if (localeAdd!!.size > 0)
        {
            val myAdd = localeAdd.get(0).getAddressLine(0)
            returnString = myAdd
        }
        Tokoro.placeName = returnString
    }

override
   fun onRequestPermissionsResult(requestCode:Int, @NonNull permissions:Array<String>, @NonNull grantResults:IntArray) {
       super.onRequestPermissionsResult(requestCode, permissions, grantResults)
       if (grantResults.size > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED)
       {
           if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) === PackageManager.PERMISSION_GRANTED)
           {
               locationManager!!.requestLocationUpdates(LocationManager.GPS_PROVIDER, 10, 1.1f, locationListener)
           }
       }
   }

locationManager = this.getSystemService(Context.LOCATION_SERVICE) as LocationManager
        locationListener = object:LocationListener {
            override
            fun onLocationChanged(location: Location) {
                try {
                    Log.i("Location", "latcpp: " + location.getLatitude() + "lon: " + location.getLongitude()) // modify hya
                    Tokoro.lat = location.getLatitude();Tokoro.lon = location.getLongitude()
                    placeToString()
                } catch (e: Exception) {
                }


            }
            override
            fun onStatusChanged(s:String, i:Int, bundle:Bundle) {
            }
            override
            fun onProviderEnabled(s:String) {
            }
            override
            fun onProviderDisabled(s:String) {
            }
        }
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) !== PackageManager.PERMISSION_GRANTED)
        {
            ActivityCompat.requestPermissions(this, arrayOf<String>(Manifest.permission.ACCESS_FINE_LOCATION), 1)
        }
        else
        {
            locationManager!!.requestLocationUpdates(LocationManager.GPS_PROVIDER, 10, 1f, locationListener)
        }