kandi background

bilibili-android-client | unofficial bilibili client | Reactive Programming library

by HotBitmapGG Java Version: V2.3.1 License: WTFPL

by HotBitmapGG Java Version: V2.3.1 License: WTFPL

Download this library from

kandi X-RAY | bilibili-android-client Summary

bilibili-android-client is a Java library typically used in Programming Style, Reactive Programming, Bilibili applications. bilibili-android-client has build file available, it has a Permissive License and it has medium support. However bilibili-android-client has 10 bugs and it has 1 vulnerabilities. You can download it from GitHub.

An android developer in Wuhan. If you want to make friends with me, You can focus on my weibo.

Support

Support

Quality

Quality

Security

Security

License

License

Reuse

Reuse

kandi-support Support

bilibili-android-client has a medium active ecosystem.
It has 4405 star(s) with 1482 fork(s). There are 165 watchers for this library.
It had no major release in the last 12 months.
There are 9 open issues and 59 have been closed. On average issues are closed in 67 days. There are no pull requests.
It has a neutral sentiment in the developer community.
The latest version of bilibili-android-client is V2.3.1

This Library - Support

Best in #Reactive Programming

Average in #Reactive Programming

This Library - Support

Best in #Reactive Programming

Average in #Reactive Programming

quality kandi Quality

bilibili-android-client has 10 bugs (1 blocker, 0 critical, 6 major, 3 minor) and 1281 code smells.

This Library - Quality

Best in #Reactive Programming

Average in #Reactive Programming

This Library - Quality

Best in #Reactive Programming

Average in #Reactive Programming

security Security

bilibili-android-client has no vulnerabilities reported, and its dependent libraries have no vulnerabilities reported.
bilibili-android-client code analysis shows 1 unresolved vulnerabilities (1 blocker, 0 critical, 0 major, 0 minor).
There are 14 security hotspots that need review.

This Library - Security

Best in #Reactive Programming

Average in #Reactive Programming

This Library - Security

Best in #Reactive Programming

Average in #Reactive Programming

license License

bilibili-android-client is licensed under the WTFPL License. This license is Permissive.
Permissive licenses have the least restrictions, and you can use them in most projects.

This Library - License

Best in #Reactive Programming

Average in #Reactive Programming

This Library - License

Best in #Reactive Programming

Average in #Reactive Programming

build Reuse

bilibili-android-client releases are available to install and integrate.
Build file is available. You can build the component from source.
bilibili-android-client saves you 17874 person hours of effort in developing the same functionality from scratch.
It has 35405 lines of code, 3634 functions and 407 files.
It has medium code complexity. Code complexity directly impacts maintainability of the code.

This Library - Reuse

Best in #Reactive Programming

Average in #Reactive Programming

This Library - Reuse

Best in #Reactive Programming

Average in #Reactive Programming

Top functions reviewed by kandi - BETA

kandi has reviewed bilibili-android-client and discovered the below as its top functions. This is intended to give you an instant insight into bilibili-android-client implemented functionality, and help decide if they suit your requirements.

Build banner .
Set the RecyclerView .
Creates and returns the view holder for the given view type .
Dispatches touch event .
This method is used to get all the data for the user
Launch rank activity .
Initialize the controller view
Set the type icon .
Called when a navigation item is selected .
Open video player .

bilibili-android-client Key Features

An unofficial bilibili client for android http://www.jianshu.com/p/f69a55b94c05 -- 该项目已停止维护！

bilibili-android-client Examples and Code Snippets

No Code Snippets are available at this moment for bilibili-android-client.

See all Code Snippets related to Reactive Programming

Community Discussions

Trending Discussions on Reactive Programming

How to use RXJS to share a pool of resources between multiple consumers
How to implement the logic without state variables
Caching parallel request in Spring Webflux Mono
Mirror at most 1 value from source, then temporarily drop values until another observable emits
Project Reactor: buffer with parallel execution
UseCases or Interactors with Kt Flow and Retrofit
DT: Dynamically change column values based on selectinput from another column in R shiny app
Send a list of objects one at time in reactive way
Changing the target of a `whenever` block from the inside
How to apply back pressure with Combine buffer operator to avoid flatMap to ask an infinite demand upstream?

Trending Discussions on Reactive Programming

QUESTION

How to use RXJS to share a pool of resources between multiple consumers

Asked 2022-Mar-31 at 12:55

How can we divide work of consumers over a limited set of resources in RXJS?

I have a Pool class here (simplified):

class Pool<TResource> {

  private readonly resource$: Observable<TResource>;

  constructor(resource$: Observable<TResource>) {
    this.resource$ = resource$.pipe(
      // We use share replay here, so multiple calls to `schedule` will share the resources
      shareReplay()
    );
  }

  /**
   * Schedules a task to be executed on resources in the pool. Each input is paired with a resource, which allows async work to be done.
   * @param input$ The inputs to pair up with a resource.
   * @param task The task to execute on each resource
   */
  public schedule<TIn, TOut>(input$: Observable<TIn>, task: (resource: TResource, input: TIn) => Promise<TOut> | TOut): Observable<TOut> {
    const recycleBin = new Subject<TResource>();
    const resource$ = merge(recycleBin, this.resource$);

    return zip(resource$, input$).pipe(
      mergeMap(async ([resource, input]) => {
        const output = await task(resource, input);
        //  Recycles a resource so its re-emitted from the `resource$` observable.
        recycleBin.next(resource);
        return output;
      }),
      tap({ complete: () => recycleBin.complete() })
    );
  }
}

You can use it like this:

class CalculatorResource {
  expensiveCalculation(n: number) {
    return new Promise<number>(res => setTimeout(() => res(n*2), 1000));
  }
}

const pool = new Pool(of(new CalculatorResource(), new CalculatorResource()));
const input$ = of(1, 2, 3, 4);
const output$ = pool.schedule(input$, (calc, n) => calc.expensiveCalculation(n));
output$.subscribe(console.log)
// ...wait 1 sec
// Logs 2
// Logs 4
// ...wait 1 sec
// Logs 6
// Logs 8

This works as expected.

However, when we call schedule in parallel, the resources will also be distributed in parallel. This is not good, we want the resources to be distributed evenly, since the nature of the tasks they do make it so they can't be called in parallel.

const pool = new Pool(of(new CalculatorResource(), new CalculatorResource()));
const input$ = of(1, 2, 3, 4);
const parallelInput$ = of(5, 6, 7, 8);
pool.schedule(input$, (calc, n) =>
  calc.expensiveCalculation(n)
).subscribe(console.log);
pool.schedule(parallelInput$, (calc, n) =>
  calc.expensiveCalculation(n)
).subscribe(console.log);
// Actual output:

// ...wait 1 sec
// Logs 2
// Logs 4
// Logs 10
// Logs 12
// ...wait 1 sec
// Logs 6
// Logs 8
// Logs 14
// Logs 16

// What i would like to see:
// ...wait 1 sec
// Logs 2
// Logs 4
// ...wait 1 sec
// Logs 10
// Logs 12
// ...wait 1 sec
// Logs 6
// Logs 8
// ...wait 1 sec
// Logs 14
// Logs 16

ANSWER

Answered 2022-Mar-31 at 12:55

So the main thing is you need to share the actual part that does the work, not only the resources.

Here's a solution from me:

https://stackblitz.com/edit/rxjs-yyxjh2?devToolsHeight=100&file=index.ts

import { merge, Observable, Observer, of, Subject, zip } from 'rxjs';
import { ignoreElements, concatMap, switchMap } from 'rxjs/operators';

class Pool<TResource> {
  private readonly resourceFree$ = new Subject<TResource>();
  private readonly dispatcher$ = new Subject<{
    execute: (resource: TResource) => any;
    observer: Observer<any>;
  }>();
  private freeResources$ = merge(this.resource$, this.resourceFree$);
  readonly doWork$ = zip(this.freeResources$, this.dispatcher$).pipe(
    switchMap(async ([resource, work]) => {
      try {
        const result = await work.execute(resource);
        work.observer.next(result);
        work.observer.complete();
      } catch (err) {
        work.observer.error(err);
      }
      this.resourceFree$.next(resource);
    }),
    ignoreElements()
  );

  constructor(private resource$: Observable<TResource>) {}

  public schedule<TIn, TOut>(
    input$: Observable<TIn>,
    task: (resource: TResource, input: TIn) => Promise<TOut> | TOut
  ): Observable<TOut> {
    return input$.pipe(
      //you can use mergeMap here as well, depends on how fast you want to consume inputs
      concatMap((input) => {
        const work = {
          execute: (r) => task(r, input),
          observer: new Subject<TOut>(),
        };
        this.dispatcher$.next(work);
        return work.observer;
      })
    );
  }
}

class CalculatorResource {
  expensiveCalculation(n: number) {
    return new Promise<number>((res) => setTimeout(() => res(n * 2), 1000));
  }
}

const pool = new Pool(of(new CalculatorResource(), new CalculatorResource()));
pool.doWork$.subscribe(); //this is to start the pool dispatcher

const input$ = of(1, 2, 3, 4);
const parallelInput$ = of(5, 6, 7, 8);
pool
  .schedule(input$, (calc, n) => calc.expensiveCalculation(n))
  .subscribe(console.log, undefined, () => console.log('1st done'));
pool
  .schedule(parallelInput$, (calc, n) => calc.expensiveCalculation(n))
  .subscribe(console.log, undefined, () => console.log('2nd done'));

setTimeout(() => {
  pool
    .schedule(parallelInput$, (calc, n) => calc.expensiveCalculation(n))
    .subscribe(console.log, undefined, () => console.log('3rd done'));
}, 5000);

Source https://stackoverflow.com/questions/71689376

QUESTION

How to implement the logic without state variables

Asked 2022-Mar-23 at 18:10

There are two observables: the first named activator emits booleans. The second named signaler emits void events. There's a function f() which must be called under the next conditions:

If the last event from activator is true, and event from signaler comes, call f(). Otherwise (the last activator's event is false, or activator has not yet emitted anything), "remember" that signaler sent the event. As soon as activator emits true, call f() and clear "remembered" flag.

Example:

let activator = PublishRelay<Bool>()
let signaler = PublishRelay<Void>()

signaler.accept(()) // activator not emitted yet, just remember that signal came
activator.accept(true) // go to active state. signal is waiting. call f()
signaler.accept(()) // already activated. call f()
activator.accept(false)// go to inactive state
activator.accept(true) // go to active state.
signaler.accept(()) // call f()
activator.accept(false)// go to inactive state
signaler.accept(()) // inactive state, remember that signal came
signaler.accept(()) // still inactive state, remember that signal came
activator.accept(true) // go to active state. there is signal waiting. call f().
signaler.accept(()) // active state. call f().

I can achieve the desired behaviour using two state variables _isActive and _waiting:

var _isActive = false
var _waiting = false

activator.bind { isActive in

    self._isActive = isActive
    if isActive && self._waiting {
        f()
        self._waiting = false
    }
}.disposed(by: _bag)

signaler.bind {

    if self._isActive {
        f()
    } else {
        self._waiting = true
    }
}.disposed(by: _bag)

The question is: can I implement it without state variables, only by means of reactive operators?

ANSWER

Answered 2022-Mar-23 at 18:10

You need a state machine, but you can contain the state so you aren't leaving the monad... Something like this:

func example(activator: Observable<Bool>, signaler: Observable<Void>) -> Observable<Void> {
    enum Action {
        case signal
        case active(Bool)
    }
    return Observable.merge(signaler.map(to: Action.signal), activator.map(Action.active))
        .scan((isWaiting: false, isActive: false, fire: Void?.none)) { state, action in
            switch action {
            case .signal:
                if state.isActive {
                    return (state.isWaiting, state.isActive, ())
                }
                else {
                    return (true, state.isActive, .none)
                }
            case .active(let active):
                if active && state.isWaiting {
                    return (false, active, ())
                }
                else {
                    return (state.isWaiting, active, .none)
                }
            }
        }
        .compactMap { $0.fire }
}

Note how the logic inside the scan closure is the same as the external logic you already have. With the above, you can now do something like this:

let activator = PublishRelay<Bool>()
let signaler = PublishRelay<Void>()

example(
    activator: activator.asObservable(),
    signaler: signaler.asObservable()
)
    .bind(onNext: f)

Lastly, as a bonus. Here's a unit test proving it works:

class RxSandboxTests: XCTestCase {
    func test() {
        let scheduler = TestScheduler(initialClock: 0)
        let activator = scheduler.createColdObservable([.next(20, true), .next(40, false), .next(50, true), .next(70, false), .next(100, true)])
        let signaler = scheduler.createColdObservable([.next(10, ()), .next(30, ()), .next(60, ()), .next(80, ()), .next(90, ()), .next(110, ())])
        
        let result = scheduler.start {
            example(activator: activator.asObservable(), signaler: signaler.asObservable())
        }

        XCTAssertEqual(result.events.map { $0.time }, [220, 230, 260, 300, 310])
    }
}

Source https://stackoverflow.com/questions/71590666

QUESTION

Caching parallel request in Spring Webflux Mono

Asked 2022-Mar-10 at 21:09

We are using spring webflux (project reactor), as part of the requirement we need to call one API from our server.

For the API call, we need to cache the response. So we are using Mono.cache operator.

It caches the response Mono<ResponseDto> and the next time the same API call happens, it will get it from the cache. Following is example implementation

public Mono<ResponseDto> getResponse() {
    if (res == null) {
      res =
          fetchResponse()
              .onErrorMap(Exception.class, (error) -> new CustomException())
              .cache(
                  r -> Duration.ofSeconds(r.expiresIn()),
                  error -> Duration.ZERO,
                  () -> Duration.ZERO);
    }
    return res;
  }

The problem is if the server calls the same API call twice ( for example Mono.zip) at the same time, then the response is not cached and we actually call it twice.

Is there any out of box solution available to this problem? Instead of caching the Response, can we cache the Mono itself so that both requests subscribe to the same Mono hence both are executed after a Single API call response?

It should also work with sequential execution too - I am afraid that if we cache the Mono then once the request is completed, the subscription is over and no other process can subscribe to it.

ANSWER

Answered 2022-Mar-03 at 14:54

You can initialize the Mono in the constructor (assuming it doesn't depend on any request time parameter). Using cache operator will prevent multiple subscriptions to the source.

class MyService {
    private final Mono<ResponseBodyDto> response;

    public MyService() {
        response = fetchResponse()
            .onErrorMap(Exception.class, (error) -> new CustomException())
            .cache(
                r -> Duration.ofSeconds(r.expiresIn()),
                error -> Duration.ZERO,
                () -> Duration.ZERO);
    }

    public Mono<ResponseDto> getResponse() {
        return response;
    }
}

If there is a dependency on request time parameters, you should consider some custom caching solution.

Source https://stackoverflow.com/questions/71311319

QUESTION

Project Reactor: buffer with parallel execution

Asked 2021-Dec-10 at 14:44

I need to copy date from one source (in parallel) to another with batches.

I did this:

 Flux.generate((SynchronousSink<String> sink) -> {
                    try {
                        String val = dataSource.getNextItem();
                        if (val == null) {
                            sink.complete();
                            return;
                        }
                        sink.next(val);

                    } catch (InterruptedException e) {
                        sink.error(e);
                    }
                })
                .parallel(4)
                .runOn(Schedulers.parallel())
                .doOnNext(dataTarget::write)
                .sequential()
                .blockLast();

class dataSource{
  public Item getNextItem(){ 
    //...
  }
}

class dataTarget{
  public void write(List<Item> items){ 
    //...
  }
}

It receives data in parallel, but writes one at a time.

I need to collect them in batches (like by 10 items) and then write the batch.

How can I do that?

UPDATE:

The main idea that the source is the messaging system (i.e. rabbitmq or nats) that's suitable to efficiently send messages one by one, but the target is the database which is more efficient on inserting a batch.

So the final result should be like — I receive messages in parallel until buffer is not filled up, then I write all the buffer into database by one shot.

It's easy to do in regular java, but in case of streams — I don't get how to do it. How to buffer the data and how to pause the reader till the writer is not ready to get next part.

ANSWER

Answered 2021-Dec-04 at 19:50

You need to do your heavy work in individual Publisher-s which will be materialized in flatMap() in parallel. Like this

Flux.generate((SynchronousSink<String> sink) -> {
    try {
        String val = dataSource.getNextItem();
        if (val == null) {
            sink.complete();
            return;
        }
        sink.next(val);

    } catch (InterruptedException e) {
        sink.error(e);
    }
})
.parallel(4)
.runOn(Schedulers.parallel())
.flatMap(item -> Mono.fromCallable(() -> dataTarget.write(item)))
.sequential()
.blockLast();

Source https://stackoverflow.com/questions/70083756

QUESTION

UseCases or Interactors with Kt Flow and Retrofit

Asked 2021-Dec-06 at 15:34

Context

I started working on a new project and I've decided to move from RxJava to Kotlin Coroutines. I'm using an MVVM clean architecture, meaning that my ViewModels communicate to UseCases classes, and these UseCases classes use one or many Repositories to fetch data from network.

Let me give you an example. Let's say we have a screen that is supposed to show the user profile information. So we have the UserProfileViewModel:

@HiltViewModel
class UserProfileViewModel @Inject constructor(
    private val getUserProfileUseCase: GetUserProfileUseCase
) : ViewModel() {
    sealed class State {
        data SuccessfullyFetchedUser(
            user: ExampleUser
        ) : State()
    }
    // ...
    val state = SingleLiveEvent<UserProfileViewModel.State>()
    // ...
    fun fetchUserProfile() {
        viewModelScope.launch {
            // ⚠️ We trigger the use case to fetch the user profile info
            getUserProfileUseCase()
                .collect {
                    when (it) {
                        is GetUserProfileUseCase.Result.UserProfileFetched -> {
                            state.postValue(State.SuccessfullyFetchedUser(it.user))
                        }
                        is GetUserProfileUseCase.Result.ErrorFetchingUserProfile -> {
                            // ...
                        }
                    }
                }
        }
    }
}

The GetUserProfileUseCase use case would look like this:

interface GetUserProfileUseCase {
    sealed class Result {
        object ErrorFetchingUserProfile : Result()
        data class UserProfileFetched(
            val user: ExampleUser
        ) : Result()
    }

    suspend operator fun invoke(email: String): Flow<Result>
}

class GetUserProfileUseCaseImpl(
    private val userRepository: UserRepository
) : GetUserProfileUseCase {
    override suspend fun invoke(email: String): Flow<GetUserProfileUseCase.Result> {
        // ⚠️ Hit the repository to fetch the info. Notice that if we have more 
        // complex scenarios, we might require zipping repository calls together, or
        // flatmap responses.
        return userRepository.getUserProfile().flatMapMerge { 
            when (it) {
                is ResultData.Success -> {
                    flow { emit(GetUserProfileUseCase.Result.UserProfileFetched(it.data.toUserExampleModel())) }
                }
                is ResultData.Error -> {
                    flow { emit(GetUserProfileUseCase.Result.ErrorFetchingUserProfile) }
                }
            }
        }
    }
}

The UserRepository repository would look like this:

interface UserRepository {
    fun getUserProfile(): Flow<ResultData<ApiUserProfileResponse>>
}

class UserRepositoryImpl(
    private val retrofitApi: RetrofitApi
) : UserRepository {
    override fun getUserProfile(): Flow<ResultData<ApiUserProfileResponse>> {
        return flow {
            val response = retrofitApi.getUserProfileFromApi()
            if (response.isSuccessful) {
                emit(ResultData.Success(response.body()!!))
            } else {
                emit(ResultData.Error(RetrofitNetworkError(response.code())))
            }
        }
    }
}

And finally, the RetrofitApi and the response class to model the backend API response would look like this:

data class ApiUserProfileResponse(
    @SerializedName("user_name") val userName: String
    // ...
)

interface RetrofitApi {
    @GET("api/user/profile")
    suspend fun getUserProfileFromApi(): Response<ApiUserProfileResponse>
}

Everything has been working fine so far, but I've started to run into some issues when implementing more complex features.

For example, there's a use case where I need to (1) post to a POST /send_email_link endpoint when the user first signs in, this endpoint will check if the email that I send in the body already exists, if it doesn't it will return a 404 error code, and (2) if everything goes okay, I'm supposed to hit a POST /peek endpoint that will return some info about the user account.

This is what I've implemented so far for this UserAccountVerificationUseCase:

interface UserAccountVerificationUseCase {
    sealed class Result {
        object ErrorVerifyingUserEmail : Result()
        object ErrorEmailDoesNotExist : Result()
        data class UserEmailVerifiedSuccessfully(
            val canSignIn: Boolean
        ) : Result()
    }

    suspend operator fun invoke(email: String): Flow<Result>
}

class UserAccountVerificationUseCaseImpl(
    private val userRepository: UserRepository
) : UserAccountVerificationUseCase {
    override suspend fun invoke(email: String): Flow<UserAccountVerificationUseCase.Result> {
        return userRepository.postSendEmailLink().flatMapMerge { 
            when (it) {
                is ResultData.Success -> {
                    userRepository.postPeek().flatMapMerge { 
                        when (it) {
                            is ResultData.Success -> {
                                val canSignIn = it.data?.userName == "Something"
                                flow { emit(UserAccountVerificationUseCase.Result.UserEmailVerifiedSuccessfully(canSignIn)) }
                            } else {
                                flow { emit(UserAccountVerificationUseCase.Result.ErrorVerifyingUserEmail) }
                            }
                        }
                    }
                }
                is ResultData.Error -> {
                    if (it.exception is RetrofitNetworkError) {
                        if (it.exception.errorCode == 404) {
                            flow { emit(UserAccountVerificationUseCase.Result.ErrorEmailDoesNotExist) }
                        } else {
                            flow { emit(UserAccountVerificationUseCase.Result.ErrorVerifyingUserEmail) }
                        }
                    } else {
                        flow { emit(UserAccountVerificationUseCase.Result.ErrorVerifyingUserEmail) }
                    }
                }
            }
        }
    }
}

Issue

The above solution is working as expected, if the first API call to the POST /send_email_link ever returns a 404, the use case will behave as expected and return the ErrorEmailDoesNotExist response so the ViewModel can pass that back to the UI and show the expected UX.

The problem as you can see is that this solution requires a ton of boilerplate code, I thought using Kotlin Coroutines would make things simpler than with RxJava, but it hasn't turned out like that yet. I'm quite sure that this is because I'm missing something or I haven't quite learned how to use Flow properly.

What I've tried so far

I've tried to change the way I emit the elements from the repositories, from this:

...
    override fun getUserProfile(): Flow<ResultData<ApiUserProfileResponse>> {
        return flow {
            val response = retrofitApi.getUserProfileFromApi()
            if (response.isSuccessful) {
                emit(ResultData.Success(response.body()!!))
            } else {
                emit(ResultData.Error(RetrofitNetworkError(response.code())))
            }
        }
    }
...

To something like this:

...
    override fun getUserProfile(): Flow<ResultData<ApiUserProfileResponse>> {
        return flow {
            val response = retrofitApi.getUserProfileFromApi()
            if (response.isSuccessful) {
                emit(ResultData.Success(response.body()!!))
            } else {
                error(RetrofitNetworkError(response.code()))
            }
        }
    }
..

So I can use the catch() function like I'd with RxJava's onErrorResume():

class UserAccountVerificationUseCaseImpl(
    private val userRepository: UserRepository
) : UserAccountVerificationUseCase {
    override suspend fun invoke(email: String): Flow<UserAccountVerificationUseCase.Result> {
        return userRepository.postSendEmailLink()
            .catch { e ->
                if (e is RetrofitNetworkError) {
                    if (e.errorCode == 404) {
                        flow { emit(UserAccountVerificationUseCase.Result.ErrorEmailDoesNotExist) }
                    } else {
                        flow { emit(UserAccountVerificationUseCase.Result.ErrorVerifyingUserEmail) }
                    }
                } else {
                    flow { emit(UserAccountVerificationUseCase.Result.ErrorVerifyingUserEmail) }
                }
            }
            .flatMapMerge {
                userRepository.postPeek().flatMapMerge {
                    when (it) {
                        is ResultData.Success -> {
                            val canSignIn = it.data?.userName == "Something"
                            flow { emit(UserAccountVerificationUseCase.Result.UserEmailVerifiedSuccessfully(canSignIn)) }
                        } else -> {
                            flow { emit(UserAccountVerificationUseCase.Result.ErrorVerifyingUserEmail) }
                        }
                    }
                }
            }
        }
    }
}

This does reduce the boilerplate code a bit, but I haven't been able to get it working because as soon as I try to run the use case like this I start getting errors saying that I shouldn't emit items in the catch().

Even if I could get this working, still, there's way too much boilerplate code here. I though doing things like this with Kotlin Coroutines would mean having much more simple, and readable, use cases. Something like:

...
class UserAccountVerificationUseCaseImpl(
    private val userRepository: AuthRepository
) : UserAccountVerificationUseCase {
    override suspend fun invoke(email: String): Flow<UserAccountVerificationUseCase.Result> {
        return flow {
            coroutineScope {
                val sendLinksResponse = userRepository.postSendEmailLink()
                if (sendLinksResponse is ResultData.Success) {
                    val peekAccount = userRepository.postPeek()
                    if (peekAccount is ResultData.Success) {
                        emit(UserAccountVerificationUseCase.Result.UserEmailVerifiedSuccessfully())
                    } else {
                        emit(UserAccountVerificationUseCase.Result.ErrorVerifyingUserEmail)
                    }
                } else {
                    if (sendLinksResponse is ResultData.Error) {
                        if (sendLinksResponse.error == 404) {
                            emit(UserAccountVerificationUseCase.Result.ErrorEmailDoesNotExist)
                        } else {
                            emit(UserAccountVerificationUseCase.Result.ErrorVerifyingUserEmail)
                        }
                    } else {
                        emit(UserAccountVerificationUseCase.Result.ErrorVerifyingUserEmail)
                    }
                }
            }
        }
    }
}
...

This is what I had pictured about working with Kotlin Coroutines. Ditching RxJava's zip(), contact(), delayError(), onErrorResume() and all those Observable functions in favor of something more readable.

Question

How can I reduce the amount of boilerplate code and make my use cases look more Coroutine-like?

Notes

I know some people just call the repositories directly from the ViewModel layer, but I like having this UseCase layer in the middle so I can contain all the code related to switching streams and handling errors here.

Any feedback is appreciated! Thanks!

Edit #1

Based on @Joffrey response, I've changed the code so it works like this:

The Retrofit API layer keeps returning suspendable function.

data class ApiUserProfileResponse(
    @SerializedName("user_name") val userName: String
    // ...
)

interface RetrofitApi {
    @GET("api/user/profile")
    suspend fun getUserProfileFromApi(): Response<ApiUserProfileResponse>
}

The repository now returns a suspendable function and I've removed the Flow wrapper:

interface UserRepository {
    suspend fun getUserProfile(): ResultData<ApiUserProfileResponse>
}

class UserRepositoryImpl(
    private val retrofitApi: RetrofitApi
) : UserRepository {
    override suspend fun getUserProfile(): ResultData<ApiUserProfileResponse> {
        val response = retrofitApi.getUserProfileFromApi()
        return if (response.isSuccessful) {
            ResultData.Success(response.body()!!)
        } else {
            ResultData.Error(RetrofitNetworkError(response.code()))
        }
    }
}

The use case keeps returning a Flow since I might also plug calls to a Room DB here:

interface GetUserProfileUseCase {
    sealed class Result {
        object ErrorFetchingUserProfile : Result()
        data class UserProfileFetched(
            val user: ExampleUser
        ) : Result()
    }

    suspend operator fun invoke(email: String): Flow<Result>
}

class GetUserProfileUseCaseImpl(
    private val userRepository: UserRepository
) : GetUserProfileUseCase {
    override suspend fun invoke(email: String): Flow<GetUserProfileUseCase.Result> {
        return flow {
            val userProfileResponse = userRepository.getUserProfile()
            when (userProfileResponse) {
                is ResultData.Success -> {
                    emit(GetUserProfileUseCase.Result.UserProfileFetched(it.toUserModel()))
                }
                is ResultData.Error -> {
                    emit(GetUserProfileUseCase.Result.ErrorFetchingUserProfile)
                }
            }
        }
    }
}

This looks much more clean. Now, applying the same thing to the UserAccountVerificationUseCase:

interface UserAccountVerificationUseCase {
    sealed class Result {
        object ErrorVerifyingUserEmail : Result()
        object ErrorEmailDoesNotExist : Result()
        data class UserEmailVerifiedSuccessfully(
            val canSignIn: Boolean
        ) : Result()
    }

    suspend operator fun invoke(email: String): Flow<Result>
}

class UserAccountVerificationUseCaseImpl(
    private val userRepository: UserRepository
) : UserAccountVerificationUseCase {
    override suspend fun invoke(email: String): Flow<UserAccountVerificationUseCase.Result> {
        return flow { 
            val sendEmailLinkResponse = userRepository.postSendEmailLink()
            when (sendEmailLinkResponse) {
                is ResultData.Success -> {
                    val peekResponse = userRepository.postPeek()
                    when (peekResponse) {
                        is ResultData.Success -> {
                            val canSignIn = peekResponse.data?.userName == "Something"
                            emit(UserAccountVerificationUseCase.Result.UserEmailVerifiedSuccessfully(canSignIn)
                        }
                        else -> {
                            emit(UserAccountVerificationUseCase.Result.ErrorVerifyingUserEmail)
                        }
                    }
                }
                is ResultData.Error -> {
                    if (sendEmailLinkResponse.isNetworkError(404)) {
                        emit(UserAccountVerificationUseCase.Result.ErrorEmailDoesNotExist)
                    } else {
                        emit(UserAccountVerificationUseCase.Result.ErrorVerifyingUserEmail)
                    }
                }
            }
        }
    }
}

This looks much more clean and it works perfectly. I still wonder if there's any more room for improvement here.

ANSWER

Answered 2021-Dec-06 at 14:53

The most obvious problem I see here is that you're using Flow for single values instead of suspend functions.

Coroutines makes the single-value use case much simpler by using suspend functions that return plain values or throw exceptions. You can of course also make them return Result-like classes to encapsulate errors instead of actually using exceptions, but the important part is that with suspend functions you are exposing a seemingly synchronous (thus convenient) API while still benefitting from asynchronous runtime.

In the provided examples you're not subscribing for updates anywhere, all flows actually just give a single element and complete, so there is no real reason to use flows and it complicates the code. It also makes it harder to read for people used to coroutines because it looks like multiple values are coming, and potentially collect being infinite, but it's not the case.

Each time you write flow { emit(x) } it should just be x.

Following the above, you're sometimes using flatMapMerge and in the lambda you create flows with a single element. Unless you're looking for parallelization of the computation, you should simply go for .map { ... } instead. So replace this:

val resultingFlow = sourceFlow.flatMapMerge {
    if (something) {
        flow { emit(x) }
    } else {
        flow { emit(y) }
    }
}

With this:

val resultingFlow = sourceFlow.map { if (something) x else y }

Source https://stackoverflow.com/questions/70246942

QUESTION

DT: Dynamically change column values based on selectinput from another column in R shiny app

Asked 2021-Nov-15 at 09:56

I am trying to create a table (with DT, pls don't use rhandsontable) which has few existing columns, one selectinput column (where each row will have options to choose) and finally another column which will be populated based on what user select from selectinput dropdown for each row.

in my example here, 'Feedback' column is the user dropdown selection column. I am not able to update the 'Score' column which will be based on the selection from 'Feedback' column dropdown.

if(interactive()){
  library(DT)
  library(shiny)
  tbl1 <- data.frame(A = c(1:10), B = LETTERS[1:10], C = c(11:20), D = LETTERS[1:10])
  ui <- fluidPage(
    DT::dataTableOutput(outputId = 'my_table')
  )
  server <- function(input, output, session) {
    rv <- reactiveValues(tbl = tbl1)
    observe({
      for (i in 1:nrow(rv$tbl)) {
        rv$tbl$Feedback[i] <- as.character(selectInput(paste0("sel", i), "",
                                                       choices = c(1,2,3,4)
        ))
        
        if(!is.null(input[[paste0("sel", i)]])) {
          if(input[[paste0("sel", i)]] == 1) {
            rv$tbl$Score[i] <- 10
          } else if(input[[paste0("sel", i)]] == 2) {
            rv$tbl$Score[i] <- 20
          } else if(input[[paste0("sel", i)]] == 3) {
            rv$tbl$Score[i] <- 25
          } else if(input[[paste0("sel", i)]] == 4) {
            rv$tbl$Score[i] <- 30
          }
        }
      }
    })
          
          output$my_table = DT::renderDataTable({
            
            datatable(
              rv$tbl, escape = FALSE, selection = 'none', rownames = F,
              options = list( paging = FALSE, ordering = FALSE, scrollx = T, dom = "t",
                              preDrawCallback = JS('function() { Shiny.unbindAll(this.api().table().node()); }'),
                              drawCallback = JS('function() { Shiny.bindAll(this.api().table().node()); } ')
              )
            )
          }, server = FALSE)
          
          
  }
  
  shinyApp(ui = ui, server = server)
}

ANSWER

Answered 2021-Sep-30 at 14:31

I'd suggest using dataTableProxy along with replaceData to realize the desired behaviour. This is faster than re-rendering the datatable.

Furthermore, re-rendering the table seems to be messing around with the bindings of the selectInputs.

Also please note: for this to work I needed to switch to server = TRUE

library(DT)
library(shiny)

selectInputIDs <- paste0("sel", 1:10)

initTbl <- data.frame(
  A = c(1:10),
  B = LETTERS[1:10],
  C = c(11:20),
  D = LETTERS[1:10],
  Feedback = sapply(selectInputIDs, function(x){as.character(selectInput(inputId = x, label = "", choices = c(1, 2, 3, 4), selected = 1))}),
  Score = rep(10, 10)
)

ui <- fluidPage(
  DT::dataTableOutput(outputId = 'my_table')
)

server <- function(input, output, session) {
  
  displayTbl <- reactive({
      data.frame(
        A = c(1:10),
        B = LETTERS[1:10],
        C = c(11:20),
        D = LETTERS[1:10],
        Feedback = sapply(selectInputIDs, function(x){as.character(selectInput(inputId = x, label = "", choices = c(1, 2, 3, 4), selected = input[[x]]))}),
        Score = sapply(selectInputIDs, function(x){as.integer(input[[x]])*10})
      )
  })
  
  output$my_table = DT::renderDataTable({
    DT::datatable(
      initTbl, escape = FALSE, selection = 'none', rownames = FALSE,
      options = list(paging = FALSE, ordering = FALSE, scrollx = TRUE, dom = "t",
                     preDrawCallback = JS('function() { Shiny.unbindAll(this.api().table().node()); }'),
                     drawCallback = JS('function() { Shiny.bindAll(this.api().table().node()); } ')
      )
    )
  }, server = TRUE)
  
  my_table_proxy <- dataTableProxy(outputId = "my_table", session = session)
  
  observeEvent({sapply(selectInputIDs, function(x){input[[x]]})}, {
    replaceData(proxy = my_table_proxy, data = displayTbl(), rownames = FALSE) # must repeat rownames = FALSE see ?replaceData and ?dataTableAjax
  }, ignoreInit = TRUE)
  
}

shinyApp(ui = ui, server = server)

Source https://stackoverflow.com/questions/69344974

QUESTION

Changing the target of a `whenever` block from the inside

Asked 2021-Oct-07 at 10:20

The following code attempts to react to one Supply and then, based on the content of some message, change its mind and react to messages from a different Supply. It's an attempt to provide similar behavior to Supply.migrate but with a bit more control.

my $c1 = Supplier.new;
my $c2 = Supplier.new;

my $s = supply {
    my $currently-listening-to = $c1.Supply;
    my $other-var = 'foo';
    whenever $currently-listening-to {
        say "got: $_";
        if .starts-with('3') {
            say "listening to something new";
            $currently-listening-to = $c2.Supply;
            $other-var = 'bar';
            say $other-var;
        }
    }
}

$s.tap;

for ^7 {
    $c1.emit: "$_ from \$c1";
    $c2.emit: "$_ from \$c2";
}
sleep 10;

If I understand the semantics of supply blocks correctly (highly doubtful!), this block should have exclusive and mutable access to any variables declared inside the supply block. Thus, I expected this to get the first 4 values from $c1 and then switch to $c2. However, it doesn't. Here's the output:

ot: 0 from $c1
got: 1 from $c1
got: 2 from $c1
got: 3 from $c1
listening to something new
bar
got: 4 from $c1
got: 5 from $c1
got: 6 from $c1

As that output shows, changing $other-var worked just as I expected it to, but the attempt to change $currently-listening-to failed (silently).

Is this behavior correct? If so, what am I missing about the semantics of supply blocks/other constructs that explains this behavior? I got the same results with react blocks and when using a Channel instead of a Supply, so the behavior is consistent across several multiple concurrency constructs.

(In the interest of avoiding an X-Y problem, the use case that triggered this question was an attempt implement Erlang-style error handling. To do so, I wanted to have a supervising supply block that listened to its children and could kill/re-launch any children that got into a bad state. But that means listening to the new children – which led directly to the issue described above.)

ANSWER

Answered 2021-Oct-07 at 10:20

I tend to consider whenever as the reactive equivalent of for. (It even supports the LAST loop phaser for doing something when the tapped Supply is done, as well as supporting next, last, and redo like an ordinary for loop!) Consider this:

my $x = (1,2,3);
for $x<> {
    .say;
    $x = (4,5,6);
}

The output is:

1
2
3

Because at the setup stage of a for loop, we obtain an iterator, and then work through that, not reading $x again on each iteration. It's the same with whenever: it taps the Supply and then the body is invoked per emit event.

Thus another whenever is needed to achieve a tap of the next Supply, while simultaneously closing the tap on the current one. When there are just two Supplys under consideration, the easy way to write it is like this:

my $c1 = Supplier.new;
my $c2 = Supplier.new;

my $s = supply {
    whenever $c1 {
        say "got: $_";
        if .starts-with('3') {
            say "listening to something new";
            # Tap the next Supply...
            whenever $c2 {
                say "got: $_";
            }
            # ...and close the tap on the current one.
            last;
        }
    }
}

$s.tap;

for ^7 {
    $c1.emit: "$_ from \$c1";
    $c2.emit: "$_ from \$c2";
}

Which will produce:

got: 0 from $c1
got: 1 from $c1
got: 2 from $c1
got: 3 from $c1
listening to something new
got: 3 from $c2
got: 4 from $c2
got: 5 from $c2
got: 6 from $c2

(Note that I removed the sleep 10 because there's no need for it; we aren't introducing any concurrency in this example, so everything runs synchronously.)

Clearly, if there were a dozen Supplys to move between then this approach won't scale so well. So how does migrate work? The key missing piece is that we can obtain the Tap handle when working with whenever, and thus we are able to close it from outside of the body of that whenever. This is exactly how migrate works (copied from the standard library, with comments added):

method migrate(Supply:D:) {
    supply {
        # The Tap of the Supply we are currently emitting values from
        my $current;
        # Tap the Supply of Supply that we'll migrate between
        whenever self -> \inner {
            # Make sure we produce a sensible error
            X::Supply::Migrate::Needs.new.throw
                unless inner ~~ Supply;
            # Close the tap on whatever we are currently tapping
            $current.close if $current;
            # Tap the new thing and store the Tap handle
            $current = do whenever inner -> \value {
                emit(value);
            }
        }
    }
}

In short: you don't change the target of the whenever, but rather start a new whenever and terminate the previous one.

Source https://stackoverflow.com/questions/69475222

QUESTION

How to apply back pressure with Combine buffer operator to avoid flatMap to ask an infinite demand upstream?

Asked 2021-Oct-05 at 15:18

I'm trying to use Combine to do several millions concurrent request through the network. Here is a mock up of the naive approach I'n using:

import Foundation
import Combine

let cancellable = (0..<1_000_000).publisher
  .map(some_preprocessing)
  .flatMap(maxPublishers: .max(32)) { request in
    URLSession.dataTaskPublisher(for: request)
      .map(\.data)
      .catch { _ in
        return Just(Data())
      }
  }
  .sink { completion in
    print(completion)
  } receiveValue: { value in
    print(value)
  }

// Required in a command line tool
sleep(100)

This pipeline first creates a request, the the request is done in flatMap to confine errors. Also, flatMap merges several requests to they are effectively done concurrently, which is great.

The issue is that it will literally make 1,000,000 requests concurrently, so I added the parameter maxPublishers which limits the number of publishers that are subscribed at the same time in flatMap. This kind of work, only 32 publishers are active at the same time, but unfortunately some_preprocessing will still be performed 1,000,000 times before flatMap will be executed.

I expected flatMap(maxPublishers: .max(32)) to apply some back pressure, i.e. only requesting items from the upstream publisher map when maxPublishers < 32. This does not seem to be the case, and it fills up the RAM rapidly and delays the processing.

I then tried to use the buffer operator that is used to introduce back pressure between a producer and a consumer, but Apple documentation is so poor I don't understand its functioning (more specifically the prefechStrategy argument).

So I tried different combinations such as:

import Foundation
import Combine

let cancellable = (0..<1_000_000).publisher
  .map(some_preprocessing)
  .buffer(size: 32, prefetch: .byRequest, whenFull: .dropNewest)
  .flatMap(maxPublishers: .max(32)) { request in
    URLSession.dataTaskPublisher(for: request)
      .map(\.data)
      .catch { _ in
        return Just(Data())
      }
  }
  .sink { completion in
    print(completion)
  } receiveValue: { value in
    print(value)
  }

// Required in a command line tool
sleep(100)

This does not seem to do anything useful though, flatMap still requests as much element as it can.

How to properly apply back pressure in this case? I.e I need the upstream map publisher to "wait" for demand asked by the downstream publisher flatMap, which should only ask items when it as an empty slot.

ANSWER

Answered 2021-Oct-05 at 15:18

The issue appears to be a Combine bug, as pointed out here. Using Publishers.Sequence causes the following operator to accumulate every value sent downstream before proceeding.

A workaround is to type-erase the sequence publisher:

import Foundation
import Combine

let cancellable = (0..<1_000_000).publisher
  .eraseToAnyPublisher()  // <----
  .map(some_preprocessing)
  .flatMap(maxPublishers: .max(32)) { request in
    URLSession.dataTaskPublisher(for: request)
      .map(\.data)
      .catch { _ in
        return Just(Data())
      }
  }
  .sink { completion in
    print(completion)
  } receiveValue: { value in
    print(value)
  }

// Required in a command line tool without running loop
sleep(.max)

Source https://stackoverflow.com/questions/69424516

Community Discussions, Code Snippets contain sources that include Stack Exchange Network

Vulnerabilities

No vulnerabilities reported

Install bilibili-android-client

You can download it from GitHub.
You can use bilibili-android-client like any standard Java library. Please include the the jar files in your classpath. You can also use any IDE and you can run and debug the bilibili-android-client component as you would do with any other Java program. Best practice is to use a build tool that supports dependency management such as Maven or Gradle. For Maven installation, please refer maven.apache.org. For Gradle installation, please refer gradle.org .

Support

For any new features, suggestions and bugs create an issue on GitHub. If you have any questions check and ask questions on community page Stack Overflow .

DOWNLOAD this Library from

Reuse Trending Solutions

14 best Python Telegram Bot

21 best C# Game Development

Build AI Fake News Detector

Build Text Summarizer in Python

Getting Started with Web3

24 best Python Blockchain

26 best Python Face Recognition

Build Ludo Game in Python

Build Location Based AR App

Build AI Study Assistant Bot

Find, review, and download reusable Libraries, Code Snippets, Cloud APIs from
over 430 million Knowledge Items

Find more libraries

Reuse Solution Kits and Libraries Curated by Popular Use Cases

Save this library and start creating your kit

Explore Related Topics

Programming Style

Reactive Programming

Share this Page

Reuse Java Kits

17 best Java Video Player

Implementing 2FA

7 best Java Recommender System libr

22 best Java Blockchain

11 best Java Ethereum

See all related Kits

Consider Popular Reactive Programming Libraries

async

by caolan

rxjs

by ReactiveX

mobx

by mobxjs

RxSwift

by ReactiveX

ReactiveCocoa

by ReactiveCocoa

See all Reactive Programming Libraries

Try Top Libraries by HotBitmapGG

CreditSesameRingView

by HotBitmapGG Java

RingProgressBar

by HotBitmapGG Java

gank.io-unofficial-android-client

by HotBitmapGG Java

MoeQuest

by HotBitmapGG Java

LeisureRead

by HotBitmapGG Java

See all Libraries by this author

Compare Reactive Programming Libraries with Highest Support

bluebird

by petkaantonov

starlette

by encode

vert.x

by eclipse-vertx

uvicorn

by encode

httpx

by encode

See all Reactive Programming Libraries

Compare Reactive Programming Libraries with Highest Quality

SuperS3t

by spartango

vertx-memcached

by ashertarno

vertx-gradle-template

by vert-x

playVertX

by fmasion

rxjava-android-example

by andrewhr

See all Reactive Programming Libraries

Compare Reactive Programming Libraries with Highest Security

JActor2

by laforge49

mod-rxvertx

by vert-x

mod-rxjava

by meez

JavaWebsocketClient

by jacek-marchwicki

vertx-elasticsearch-service

by ef-labs

See all Reactive Programming Libraries

Compare Reactive Programming Libraries with Permissive License

vertx-when

by ef-labs

humanize

by mfornos

parseq

by linkedin

SuperS3t

by spartango

jdeferred

by jdeferred

See all Reactive Programming Libraries

Compare Reactive Programming Libraries with Highest Reuse

vlingo-cluster

by vlingo

RxJavaFileUtils

by ReactiveX

future

by traneio

RxJavaReactiveStreams

by ReactiveX

smallrye-reactive-streams-operators

by smallrye

See all Reactive Programming Libraries

Find, review, and download reusable Libraries, Code Snippets, Cloud APIs from
over 430 million Knowledge Items

Find more libraries

Reuse Solution Kits and Libraries Curated by Popular Use Cases

Save this library and start creating your kit

© 2022 Open Weaver Inc.

© 2022 Open Weaver Inc.