Esempio n. 1
0
 observable<T> get_observable() const {
     auto keepAlive = s;
     auto observable = make_observable_dynamic<T>([=](subscriber<T> o){
         if (keepAlive.get_subscription().is_subscribed()) {
             for (auto&& value: get_values())
                 o.on_next(value);
         }
         keepAlive.add(keepAlive.get_subscriber(), std::move(o));
     });
     return s.get_coordinator().in(observable);
 }
Esempio n. 2
0
    rx::observable<std::tuple<Touch*, TouchEventObservable>> touchEventObservable(Node* targetNode, std::function<bool(Touch*)> isBegan /* = nullptr */, bool isSwallow /* = shallow */) {

        RefPtr<Node> sharedTarget(targetNode);
        return rx::observable<>::defer(
                                       [sharedTarget, isSwallow, isBegan] () {
                                           auto subject = std::make_shared<rxsub::subject<std::tuple<Touch*, TouchEventObservable>>>();
                                           auto subscriber = subject->get_subscriber();
                                           
                                           auto listener = RefPtr<EventListenerTouchOneByOne>{EventListenerTouchOneByOne::create()};
                                           
                                           if (isSwallow) {
                                               listener->setSwallowTouches(isSwallow);
                                           }

                                           auto finalizer = Util::shared_finallizer([subject, subscriber]() {
                                               subscriber.on_completed();
                                           });

                                           listener->onTouchBegan = [isBegan, listener, subscriber, finalizer, subject](Touch* t, Event*) -> bool {
                                               if (isBegan) {
                                                   if (!isBegan(t)) {
                                                       return false;
                                                   }
                                               }
                                               rxsub::subject<Touch*> subj2{};
                                               auto subscriber2 = subj2.get_subscriber();
                                               listener->onTouchMoved = [=](Touch* t, Event*) {
                                                   subscriber2.on_next(t);
                                               };
                                               listener->onTouchEnded = [=](Touch* t, Event*) {
                                                   subscriber2.on_next(t);
                                                   subscriber2.on_completed();
                                               };
                                               listener->onTouchCancelled = [=](Touch* t, Event*) {
                                                   subscriber2.on_next(t);
                                                   subscriber2.on_completed();
                                               };
                                               
                                               auto ob = subj2.get_observable();
                                               subscriber.on_next(std::make_tuple(t, ob));
                                               return true;
                                           };
                                           
                                           
                                           Director::getInstance()->getEventDispatcher()->addEventListenerWithSceneGraphPriority(listener, sharedTarget.get());
                                           
                                           return subject->get_observable()
                                           .finally([=]() {
                                               subscriber.unsubscribe();
                                               Director::getInstance()->getEventDispatcher()->removeEventListener(listener);
                                           }).as_dynamic();
                                       }).as_dynamic();

    }
 observable<T> get_observable() const {
     auto keepAlive = s;
     return make_observable_dynamic<T>([=](subscriber<T> o) {
         keepAlive.add(keepAlive.get_subscriber(), std::move(o));
     });
 }