Observable<Object> observable = Observable.just(contentContainer);
        Recipe recipeDynamicParserVideos = Recipe.newInstance(mAppContext, "recipes/ContentsRecipe.json");
        Subscription subscription = observable
                .subscribeOn(Schedulers.newThread())
                .concatMap(contentContainerAsObject -> {
                    return mContentLoader.getLoadContentsObservable(Observable.just(contentContainerAsObject), recipeDynamicParserVideos);
                })
                .onBackpressureBuffer() // This must be right after concatMap.
                .doOnNext(o -> { })
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(
                        objectPair -> {
                        },
                        throwable -> {
                            ErrorHelper.injectErrorFragment( 
                                    mNavigator.getActiveActivity(),
                                    ErrorUtils.ERROR_CATEGORY.FEED_ERROR,
                                    (errorDialogFragment, errorButtonType, errorCategory) -> {
                                        if (errorButtonType == ErrorUtils.ERROR_BUTTON_TYPE.EXIT_APP) {
                                            mNavigator.getActiveActivity().finishAffinity();
                                        }
                                    });
                        },
                        () -> {
LocalBroadcastManager.getInstance(mNavigator.getActiveActivity()) 
                                    .sendBroadcast(new Intent(BROADCAST_DATA_LOADED));
                        });

public Observable<Object> getLoadContentsObservable(Observable<Object> observable, Recipe recipeDynamicParser) {
        return observable
                .map(contentContainerAsObject -> { 
                    // Делаем что-то с contentContainerAsObject
                    return contentContainerAsObject; 
                })
                .concatMap(contentContainerAsObject -> { 
                    ContentContainer contentContainer = (ContentContainer) contentContainerAsObject;
                        // Loading playlist videos 
                        return getPlaylistVideosFeedObservable(contentContainerAsObject);
                }) 
                // Parse videos feed to Content objects
                .concatMap(objectPair -> {
                    ContentContainer contentContainer = (ContentContainer) objectPair.first;
                    String feed = (String) objectPair.second;
                    String[] params = new String[] { contentContainer.getExtraStringValue(Recipe.KEY_DATA_TYPE_TAG) };

                    if (TextUtils.isEmpty(feed)) {
                        return Observable.just(Pair.create(contentContainer, null));
                    }
                    else {
                        return mDynamicParser
                                .cookRecipeObservable(recipeDynamicParser, feed, null, params)
                                .map(contentAsObject -> {
                                    Content content = (Content) contentAsObject; 
                                    if (content != null) {
                                        contentContainer.addContent(content);
                                    }
                                    return Pair.create(contentContainer, contentAsObject);
                                });
                    }
                });
    }

public Observable<Object> cookRecipeObservable(Recipe recipe, Object input, Bundle bundle,
                                                   String[] params) {

        Observable<Object> dynamicParserObservable = Observable.create(subscriber -> {

            try {
                // Make sure recipe and input is valid.
                checkCookRecipeInput(recipe, input);

                // Parse input into a list of maps for translation
                List<Map<String, Object>> resultList = parseInput(recipe, input.toString(), params);

                // Translate each map in the result list into the model object defined in the
                // recipe. Return each model once it completes translation via subscriber.
                translateMapsToObjects(false, recipe, resultList, new IRecipeCookerCallbacks() {

                    @Override
                    public void onPreRecipeCook(Recipe recipe, Object output, Bundle bundle) {

                    }

                    @Override
                    public void onRecipeCooked(Recipe recipe, Object output, Bundle bundle, boolean
                            done) {

                        if (!subscriber.isUnsubscribed()) {
                            subscriber.onNext(output);
                            if (done) {
                                subscriber.onCompleted();
                            }
                        }
                    }

                    @Override
                    public void onPostRecipeCooked(Recipe recipe, Object output, Bundle bundle) {

                    }

                    @Override
                    public void onRecipeError(Recipe recipe, Exception e, String msg) {

                        if (e instanceof ValueNotFoundException) {
                            Log.e(TAG, "Error during parsing, skipping an item:", e);
                        }
                        else {
                            subscriber.onError(e);
                        }
                    }
                }, bundle);

            }
            catch (Exception e) {
                subscriber.onError(e);
            }

        });

        return dynamicParserObservable;
    }

public final static <T> Observable<T> create(OnSubscribe<T> f) {
        return new Observable<T>(hook.onCreate(f));
    }