Beiträge von benigern

private fun downloadFile(realFileId: String): ByteArrayOutputStream? {
    //   getString(R.string.api_key)  --> requestInitializer

    val drive = Drive.Builder(
        NetHttpTransport(),
        JacksonFactory.getDefaultInstance(),
        null// <-- requestInitializer
    )
        .setApplicationName(getString(R.string.app_name))
        .build()

    return try {
        val outputStream: OutputStream = ByteArrayOutputStream()
        drive.files()[realFileId]
            .executeMediaAndDownloadTo(outputStream)
        outputStream as ByteArrayOutputStream
    } catch (e: Exception) {
        Log.i("x", "$e")
        null
    }
}

package com.example.anrufdemo3

import android.content.Intent
import android.os.Bundle
import android.os.Handler
import android.os.IBinder
import android.os.Looper
import android.os.Message
import android.os.Messenger
import android.os.SystemClock
import android.telecom.Call
import android.telecom.CallScreeningService
import android.util.Log

const val TEL_PREFIX = "tel:"
const val MSG_CSS_RC = 0
const val MSG_CSS_IN = 1
const val MSG_CSS_OUT = 2
const val MSG_CSS_END = 3
const val MSG_CSS_DAT = 4
const val MSG_CSS_ASY = 5
class MyCallScreening: CallScreeningService() {

    private lateinit var mCallDetails: Call.Details //temporary fix for future later use
    private val mClients: ArrayList<Messenger> = ArrayList()
    private lateinit var messenger: Messenger

    override fun onBind(intent: Intent): IBinder? {
        messenger = Messenger(IncomingHandler(mClients))
        return messenger.binder
    }
    override fun onScreenCall(callDetails: Call.Details) {
        mCallDetails = callDetails
        Log.i("onScreenCall Service", callDetails.toString())
        if (mClients.size > 0) {
            try {
                val msg: Message = Message.obtain(null, MSG_CSS_DAT)
                msg.arg1 = callDetails.callDirection
                val b = Bundle()
                b.putString("telNr", callDetails.handle.toString())
                msg.data = b
                mClients[0].send(msg)
            } catch (ex: Exception) {
                Log.e("onScreenCall Service", "$ex")
            }
        }
        val response = CallResponse.Builder()
        if (callDetails.callDirection == Call.Details.DIRECTION_INCOMING) {
            response.apply {
                setRejectCall(true)
                setDisallowCall(true)
                setSkipCallLog(false)
            }
        }
        respondToCall(callDetails, response.build())
    }

    private class IncomingHandler(val clients: ArrayList<Messenger>):
                            Handler(Looper.getMainLooper()) {
        private val timer = Handler(Looper.getMainLooper())
        override fun handleMessage(msg: Message) {
            when (msg.what) {
                MSG_CSS_RC -> { // register client
                    clients.add(msg.replyTo)
                    Log.d("CSS incoming","init ${clients.size} $clients")
                }
                MSG_CSS_IN -> { // in out test
                    Log.d("CSS incoming","alive ${clients.size} $clients, ${msg.arg1}, ${msg.arg2}")
                    if (clients.size > 0) {
                        try {
                            msg.replyTo.send(Message.obtain(null, MSG_CSS_OUT, 6, 7))
                        } catch (ex: Exception) {
                            Log.e("onScreenCall Service", "$ex")
                        } // asynch out test
                        timer.postAtTime(asyMsg, SystemClock.uptimeMillis() + 500L)
                    }
                }
                MSG_CSS_END -> {
                    Log.d("CSS incoming","end ${clients.size} $clients")
                }
                else -> super.handleMessage(msg)
            }
        }
        private val asyMsg = Runnable {
            if (clients.size > 0) {
                try {
                    clients[0].send(Message.obtain(null, MSG_CSS_ASY, 8,9 ))
                } catch (ex: Exception) {
                    Log.e("onScreenCall asynch", "$ex")
                }
            }
        }
    }// val abc: (Int) -> Unit = {}
}

class MainActivity : AppCompatActivity() {
    private var msgService: Messenger? = null
    private val messenger = Messenger(IncomingHandler())

    private val connection = object : ServiceConnection {
        override fun onServiceConnected(name: ComponentName, service: IBinder) {
            msgService = Messenger(service)
            msgService?.let {
                try { // register the Messenger(IncomingHandler()) for CallScreeningService events
                    val msg = Message.obtain(null, MSG_CSS_RC,0,0)
                    msg.replyTo = messenger
                    it.send(msg)
                } catch (ex: Exception) {
                    Log.d("Main Init CSS","$ex")
                }
            }
            B.buCall.isEnabled = true
        }
        override fun onServiceDisconnected(name: ComponentName) {
            msgService = null
        }
    }
.......

    private fun startService() {
        intent = Intent(this, MyCallScreening::class.java)
        if (roleManager.isRoleHeld(RoleManager.ROLE_CALL_SCREENING))
            bindService(intent, connection, Context.BIND_AUTO_CREATE)
    }

    override fun onDestroy() {
        super.onDestroy()
        msgService?.let { unbindService(connection) }
        msgService = null
    }

private fun callAction(action: Boolean) {
    //replacement for telecom.endCall() API28, telecom.acceptRingingCall() API26
    try { // true: "acceptRingingCall", false: "endCall"
        if (Build.VERSION.SDK_INT >= 26) {
            val c = Class.forName(telecom.javaClass.name)
            val m = c.getDeclaredMethod(if (action) "acceptRingingCall" else "endCall")
            m.isAccessible = true
            m.invoke(telecom)
        } else { // "acceptRingingCall" not supported, only "endCall"
            val tm = this.getSystemService(TELEPHONY_SERVICE) as TelephonyManager
            var c = Class.forName(tm.javaClass.name)
            var m = c.getDeclaredMethod("getITelephony")
            m.isAccessible = true
            val telephonyService = m.invoke(tm)
            c = Class.forName(telephonyService.javaClass.name)
            m = c.getDeclaredMethod("endCall")
            m.isAccessible = true
            m.invoke(telephonyService)
        }
    } catch (ex: Exception) {
        Log.i("callAction","${ex}")
    }
}

package com.example.bluetoothdemo2

import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.activity.result.contract.ActivityResultContracts
import com.example.bluetoothdemo2.databinding.ActivityMainBinding

class MainActivity : AppCompatActivity() {
    private lateinit var  B: ActivityMainBinding
    private val myPermissions = registerForActivityResult( ActivityResultContracts.RequestMultiplePermissions()) {
            result -> permissionResultCallback(result) }
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        B = ActivityMainBinding.inflate(layoutInflater)
        setContentView(B.root)
    }

    override fun onStart() {
        super.onStart()
        if (Permissions.get(myPermissions)) {

        } else {

        }
    }

    private fun permissionResultCallback(map: Map<String,Boolean>) {
        if (map.filterValues { it == false }.isEmpty()) {

        } else {

        }
    }
}

package com.example.bluetoothdemo2

import android.Manifest
import android.content.pm.PackageManager
import android.os.Build
import androidx.activity.result.ActivityResultLauncher
import androidx.core.app.ActivityCompat

object Permissions {

    fun get(myPermissions: ActivityResultLauncher<Array<String>> ) : Boolean {
        val rightsArray = if (Build.VERSION.SDK_INT < 31) arrayOf(
            Manifest.permission.BLUETOOTH,
            Manifest.permission.BLUETOOTH_ADMIN,
            Manifest.permission.ACCESS_FINE_LOCATION,
            Manifest.permission.ACCESS_COARSE_LOCATION) else arrayOf(
            Manifest.permission.BLUETOOTH_CONNECT)
        for (right in rightsArray) {
            if (ActivityCompat.checkSelfPermission(
                    this@MainActivity, right) != PackageManager.PERMISSION_GRANTED) {
                myPermissions.launch(rightsArray)
                return false
            }
        }
        return true
    }

    fun check() : Boolean {
        return (Build.VERSION.SDK_INT < 31 ||
                ActivityCompat.checkSelfPermission( this@MainActivity,
                    Manifest.permission.BLUETOOTH_CONNECT) == PackageManager.PERMISSION_GRANTED)
    }

}