rxbus | Event bus running on type safe RxJava queues | Pub Sub library

public class RxBus {

    public RxBus() {
    }

    private PublishSubject<String> bus = PublishSubject.create();

    public void send(String str) {
        bus.onNext(str);
    }

    public Observable<String> toObservable() {
        return bus;
    }

}

public void sendEvents(){
        rxBus.send("Trigger event");
    }

 public void startListener(){
        rxBus.toObservable().subscribe(str -> {
           //do action//This is executing multiple lines
        });
    }

internal class The8AppGCMListenerService : FirebaseMessagingService() {

override fun onNewToken(token: String) {
    super.onNewToken(token)
   
//save token

}

override fun onMessageReceived(message: RemoteMessage) {

        val from = message.from
        val data = message.data

        sendNotification(data)

    
}

private fun sendNotification(data: Map<String, String>) {
    if (Interactors.preferences.notificationsEnabled == true) {

        Timber.d(data.toString())
        val msg = data[KEY_MSG]
        val url = data[KEY_URL]

        sendNotification(msg, type, url)
    }
}

private fun sendNotification(message: String?, url: String?) {
    val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager

    val channelId = "Main"

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        val notificationChannel = NotificationChannel(channelId, "My Notifications", NotificationManager.IMPORTANCE_HIGH)


        notificationChannel.description = "Channel description"
        notificationChannel.enableLights(true)
        notificationChannel.lightColor = Color.RED
        notificationChannel.vibrationPattern = longArrayOf(0, 1000, 500, 1000)
        notificationChannel.enableVibration(true)
        notificationManager.createNotificationChannel(notificationChannel)
    }

    val pendingIntent = getNotificationIntent(url)//Build intent with data received from notifcation
    val defaultSoundUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION)
    val notificationBuilder = NotificationCompat.Builder(this, channelId)
    notificationBuilder.setSmallIcon(R.drawable.ic_notification)
    notificationBuilder.setLargeIcon(BitmapFactory.decodeResource(resources, R.drawable.notif))
    notificationBuilder.setContentTitle(getString(R.string.app_name))
    notificationBuilder.setContentText(message)
    notificationBuilder.setAutoCancel(true)
    notificationBuilder.setSound(defaultSoundUri)
    notificationBuilder.setContentIntent(pendingIntent)
    notificationManager.notify(0, notificationBuilder.build())
}

private fun getNotificationIntent(Long, url: String?): PendingIntent {


    val useState = UseState(UseState.COME_FROM_NOTIFICATION)
    val intent = getNotificationIntent(this, type, useState, offerId, url)

    return PendingIntent.getActivity(this, 0, intent, Intent.FLAG_ACTIVITY_SINGLE_TOP)
}


companion object {

    private const val KEY_MSG = "Text"
    private const val KEY_URL = "pushUrl"

    internal fun getNotificationIntent(context: Context, useState: UseState, url: String?): Intent =

           
             openSponsorTree(context,useState,ASponsorTree.TAB_FEED,url)
        

        }.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK).apply {
            if (The8CloudSdk.isSdkReady()) {
                RxBus.post(SponsorHubEvents.UpdateNotifications())
                SDKInternal.notifyBadgeListener()
            }
        }

    private fun openSponsorTree(context: Context, useState: UseState, startTab: Int, url: String?): Intent {
        val intent = ASponsorTree.newInstance(context, useState, startTab,url=url)
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
        return intent
    }
}

}

<service android:name="com.weare8.android.network.gcm.The8AppGCMListenerService">
        <intent-filter>
            <action android:name="com.google.firebase.MESSAGING_EVENT" />
        </intent-filter>
    </service>

    <meta-data
            android:name="com.google.firebase.messaging.default_notification_icon"
            android:resource="@drawable/ic_notification" />

    <meta-data
            android:name="com.google.firebase.messaging.default_notification_color"
            android:resource="@color/app_dark_blue" />

implementation('com.google.firebase:firebase-core:18.0.2')
implementation platform('com.google.firebase:firebase-bom:26.4.0')
implementation 'com.google.firebase:firebase-messaging-ktx'
implementation 'com.google.firebase:firebase-analytics-ktx'

companion object {
 
    const val KEY_URL = "pushUrl"


    fun newInstance(
        context: Context,
        useState: UseState,
        startTab: Int = TAB_FEED,
        url:String?,
        noPost: String? = null
    ): Intent {

            val intent = Intent(context, ASponsorTree::class.java).putExtra(KEY_URL,url)
           

        return intent
    }
}

val pushUrl = intent.getStringExtra(KEY_URL)

func picker(_ picker: PHPickerViewController, didFinishPicking results: [PHPickerResult]) {

    dismiss(animated: true, completion: nil)

    var selectedImageDatas = [Data?](repeating: nil, count: results.count) // Awkwardly named, sure
    var totalConversionsCompleted = 0

    for (index, result) in results.enumerated() {
        result.itemProvider.loadFileRepresentation(forTypeIdentifier: UTType.image.identifier) { (url, error) in
            guard let url = url else {
                totalConversionsCompleted += 1
                return
            }

            let sourceOptions = [kCGImageSourceShouldCache: false] as CFDictionary

            guard let source = CGImageSourceCreateWithURL(url as CFURL, sourceOptions) else {
                totalConversionsCompleted += 1
                return
            }

            let downsampleOptions = [
                kCGImageSourceCreateThumbnailFromImageAlways: true,
                kCGImageSourceCreateThumbnailWithTransform: true,
                kCGImageSourceThumbnailMaxPixelSize: 2_000,
            ] as CFDictionary

            guard let cgImage = CGImageSourceCreateThumbnailAtIndex(source, 0, downsampleOptions) else {
                totalConversionsCompleted += 1
                return
            }

            let data = NSMutableData()

            guard let imageDestination = CGImageDestinationCreateWithData(data, kUTTypeJPEG, 1, nil) else {
                totalConversionsCompleted += 1
                return
            }

            // Don't compress PNGs, they're too pretty
            let isPNG: Bool = {
                guard let utType = cgImage.utType else { return false }
                return (utType as String) == UTType.png.identifier
            }()

            let destinationProperties = [
                kCGImageDestinationLossyCompressionQuality: isPNG ? 1.0 : 0.75
            ] as CFDictionary

            CGImageDestinationAddImage(imageDestination, cgImage, destinationProperties)
            CGImageDestinationFinalize(imageDestination)

            selectedImageDatas[index] = data as Data
            totalConversionsCompleted += 1
        }
    }


    //I want to wait for the processing of images and then do this

    self.images.append(contentsOf: selectedImageDatas)

    RxBus.shared.post(event: Events.AlbumUpdated(images: self.images, indexPath: self.selectedIndexPath))

    self.collectionView.reloadData()

}

E/PictureIds@@@>>>: [4e6a3956bf8743b78fe4ffa546f627f0.png]
E/Utils: {"attachments":"4e6a3956bf8743b78fe4ffa546f627f0.png","status":"SUCCESS","message":"-"}

E/PictureIds@@@>>>: [7712b7f081d045e8b94f077e40994290.png]
E/Utils: {"attachments":"7712b7f081d045e8b94f077e40994290.png","status":"SUCCESS","message":"-"}

private Disposable picture; // this varaibale is set in onSuccessUpload to subscribe 

private void onSuccessUpload(){
setPicture(RxBus.sendResponseUploadLink()
                .subscribe(s1 -> {
                    String[] id = new String[]{s1.getString("attachments")};
                    Timber.tag("PictureIds@@@>>>").e(Arrays.toString(id));
                    setProfilePictureId(id[0]);  // problem is here
                    setWallpaperPictureId(id[1]); // problem is here
                }));
}

private void uploadPicture(String path){
        Upload uploadPicture = new Upload();
        uploadPicture.upload(getToken(), path);
    }

@Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.channel_profile_image:
                selectProfileImage();
                break;
            case R.id.channel_cover_image:
                selectCoverImage();
                break;
            case R.id.submit_social_channel:
                onSuccessUpload();
                uploadPicture(getProfileFilePath());
                uploadPicture(getWallpaperFilePath());
                

        }
    }

   buildFeatures {
    viewBinding = true
   }

apply plugin: 'com.android.application'


android {
compileSdkVersion 28
buildToolsVersion "28.0.3"

defaultConfig {
    minSdkVersion 16
    targetSdkVersion 28
    versionCode 5
    versionName "1.2.0"
    resValue("string", "growingio_project_id", "8979dc98cc52320f")
    resValue("string", "growingio_url_scheme", "growing.1f3e3791e1d6aee5")
}
compileOptions {
    sourceCompatibility rootProject.ext.sourceCompatibilityVersion
    targetCompatibility rootProject.ext.targetCompatibilityVersion
}

    buildFeatures {
        viewBinding = true
    }

buildTypes {
    release {
        minifyEnabled false
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
    }
}
}

dependencies {
implementation fileTree(dir: 'libs', include: "*.jar")
implementation deps.swipeRevealLayout
implementation deps.glide
implementation deps.growingio
implementation(deps.rxbus) {
    exclude group: 'com.jakewharton.timber', module: 'timber'
}
implementation deps.androidasync
implementation deps.timber
}

Could not find method buildFeatures() for arguments [build_6zjavhoqnf2k7dfs2qrq542f3$_run_closure1$_closure5@6cd00094] on object of type com.android.build.gradle.internal.dsl.BaseAppModuleExtension.

///
  Future<String> _signUpWithGoogle() async {
    bool isLoggedIn = await _firebaseAuth.isLoggedIn();
    if (!isLoggedIn) {
      googleSignIn = GoogleSignIn();
      final GoogleSignInAccount googleSignInAccount =
          await googleSignIn.signIn();
      final GoogleSignInAuthentication googleSignInAuthentication =
          await googleSignInAccount.authentication;

      final AuthCredential credential = GoogleAuthProvider.getCredential(
        accessToken: googleSignInAuthentication.accessToken,
        idToken: googleSignInAuthentication.idToken,
      );

      final AuthResult authResult =
          await _firebaseAuth.signInWithCredential(credential);
      final FirebaseUser user = authResult.user;

      assert(!user.isAnonymous);
      assert(await user.getIdToken() != null);

      final FirebaseUser currentUser = await _firebaseAuth.getUser();
      assert(user.uid == currentUser.uid);

      return 'signInWithGoogle succeeded: $user';
    } else {
      FirebaseUser user = await _firebaseAuth.getUser();
      return 'signInWithGoogle succeeded: $user';
    }
  }

PlatformException(error, Concurrent operations detected: signIn, signIn, null)

dependencies:
  flutter:
    sdk: flutter
  cupertino_icons: ^0.1.2
  permission:
  intl_translation:
  flutter_svg:
  sqflite:
  path:
  path_provider:
  uuid:
  qr_flutter:
  vibration:
  reflectable:
  provider:
  launcher_module:
    path: ../modules/launcher_module
  individual:
    path: ../modules/individual
  common:
    path: ../packages/common
  persistence:
    path: ../packages/persistence
  resources:
    path: ../packages/resources
  authentication:
    path: ../packages/authentication
  screen:
  flutter_screen_scaler: ^0.0.1
  page_indicator:
  toast: ^0.1.5
  rxbus: ^0.0.2
  shared_preferences:

dependencies:
  flutter:
    sdk: flutter
  firebase_auth: ^0.15.3+1
  google_sign_in: ^4.1.1
  flutter_facebook_login:
  shared_preferences:
  common: 
    path: "../common"
  toast: ^0.1.5

    private fun <T> register(cls: Class<T>): Flowable<Pair<T, Long>> {
        return FlowableFromObservable(mRelay).onBackpressureBuffer(4).filter(
            /* filter target event. */
            EventPredictable(cls)
        ).cast(
            /* cast to target event */
            cls
        ).onBackpressureDrop {
            Log.i(TAG, "drop event: $it")
        }.concatMap { data ->
            /* start interval task blocking */
            val period = 1L
            val unit = TimeUnit.SECONDS
            MLog.d(TAG, "startInterval: data = $data")
            Flowable.interval(0, period, unit).take(DURATION.toLong()).takeUntil(
                getStopFlowable()
            ).map {
                Pair(data, it)
            }
        }
    }

    private fun getStopFlowable(): Flowable<StopIntervalEvent> {
        return RxBus.getDefault().register(StopIntervalEvent::class.java)
                    .toFlowable(BackpressureStrategy.LATEST)
    }