scraplesh

class UdpActivity : AppCompatActivity(), NavigineNotification.Listener {
    private lateinit var binding: ActivityMtsliveBinding
    private var subLoc: SubLocation? = null
    private val locationId = 98872

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMtsliveBinding.inflate(layoutInflater)
            .apply { setContentView(root) }
        initNavigine()

scraplesh

import kotlinx.coroutines.FlowPreview
import kotlinx.coroutines.Job
import kotlinx.coroutines.cancelAndJoin
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.launch

/**

scraplesh

class FooBarFragment : Fragment() {

    companion object {
        fun newInstance(foo: String, bar: String?) = FooBarFragment().apply {
            this.foo = foo
            this.bar = bar
        }
    }

    private var foo: String by argumentNotNull()

scraplesh

import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import androidx.lifecycle.LifecycleOwner
import io.reactivex.functions.Consumer

class SharedEventBus : SharedEventOwner, Consumer<SharedEvent> {
  private val sharedEvents = mutableMapOf<EventId, SharedEvent>()
  private val sharedEventListeners = mutableMapOf<EventId, LifecycleAwareSharedEventListener>()

  override fun accept(t: SharedEvent?) {

scraplesh

package com.abdelmeged.ahmed.roundedlayout;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.ImageView;

import com.bumptech.glide.load.engine.DiskCacheStrategy;
import com.bumptech.glide.load.resource.drawable.DrawableTransitionOptions;

public class MainActivity extends AppCompatActivity {

scraplesh

import com.android.tools.lint.client.api.UElementHandler
import com.android.tools.lint.detector.api.*
import org.jetbrains.uast.UElement
import org.jetbrains.uast.UPostfixExpression

class NonNullAssertionDetector : Detector(), Detector.UastScanner {

    override fun getApplicableUastTypes(): List<Class<out UElement>>? {
        return listOf(UPostfixExpression::class.java)
    }

scraplesh

{
  "data": {
    "attributes": {
      "alias": "nikitin2",
      "bio": null,
      "birthdate": "09-22-1996",
      "displayName": "nikitin",
      "email": null,
      "fullName": "nikitin",
      "gender": "male",

scraplesh

import RxSwift

public typealias Bootstrapper<Action> = () -> Observable<Action>
public typealias WishToAction<Wish, Action> = (Wish) -> Action
public typealias Actor<State, Action, Effect> = (State, Action) -> Observable<Effect>
public typealias Reducer<State, Effect> = (State, Effect) -> State
public typealias PostProcessor<Action, Effect, State> = (Action, Effect, State) -> Action?
public typealias NewsPublisher<Action, Effect, State, News> = (Action, Effect, State) -> News?

open class Feature<Wish, Action, Effect, State, News> {

scraplesh

protocol InitConfigurable {
    init()
}

extension InitConfigurable {
    init(configure: (Self) -> Void) {
        self.init()
        configure(self)
    }
}

scraplesh

/**
 * Authenticator that attempts to refresh the client's access token. 
 * In the event that a refresh fails and a new token can't be issued an error 
 * is delivered to the caller. This authenticator blocks all requests while a token 
 * refresh is being performed. In-flight requests that fail with a 401 are 
 * automatically retried.
 */
class AccessTokenAuthenticator(
    private val tokenProvider: AccessTokenProvider
) : Authenticator {