TypeScript Subscriber.next方法代码示例

 super((subscriber: Subscriber<boolean>) => {
   if (!notification || notification.permission === 'denied') {
     subscriber.next(false);
     subscriber.complete();
   }
   else if (notification.permission === 'granted') {
     subscriber.next(true);
     subscriber.complete();
   }
   else {
     notification.requestPermission().then(permission => {
       subscriber.next(permission === 'granted');
       subscriber.complete();
     });
   }
 });

    public showDialog(param: IDialogShowEventArg): Observable<IDialogPostEventArg> {

        const {
            header = "Default Header",
            bodyDescription = "Default Body Description",
            confirmButtonText = "OK",
            cancelButtonText = "Cancel",
            useConfirm = true,
            useCancel = false,
        } = param;

        this._dialogShowSubscriber.next({
            header: header,
            bodyDescription: bodyDescription,
            confirmButtonText: confirmButtonText,
            cancelButtonText: cancelButtonText,
            useConfirm: useConfirm,
            useCancel: useCancel,
        });

        this._dialogPostSeed = new Observable<IDialogPostEventArg>(observer => {
            this._dialogPostSubcriber = observer;
        });

        return this._dialogPostSeed;
    }

            (subscriber: Subscriber<ILoadStatusObject>): void => {
                if (!this.merged) {
                    let mesh: IMesh = { faces: [], vertices: [] };
                    subscriber.next({ loaded: { loaded: 0, total: 0 }, object: mesh });
                    subscriber.complete();

                    return;
                }

                let xmlHTTP: XMLHttpRequest = new XMLHttpRequest();
                xmlHTTP.open("GET", Urls.proto_mesh(this.key), true);
                xmlHTTP.responseType = "arraybuffer";
                xmlHTTP.onload = (e: any) => {
                    let mesh: IMesh;
                    if (xmlHTTP.status === 200) {
                        mesh = MeshReader.read(new Buffer(xmlHTTP.response));
                    } else {
                        mesh = { faces: [], vertices: [] };
                    }

                    subscriber.next({ loaded: { loaded: e.loaded, total: e.total }, object: mesh });
                    subscriber.complete();
                };

                xmlHTTP.onprogress = (e: any) => {
                    subscriber.next({ loaded: { loaded: e.loaded, total: e.total }, object: null });
                };

                xmlHTTP.send(null);
            });

 return new Observable((subscriber: Subscriber<Response>) => {
   const cachedData = requestOptions.cache === HttpCachePolicy.Update ?
   null : this.httpCacheService.getCacheData(url);
   if (cachedData !== null) {
     // Create new response to avoid side-effects
     subscriber.next(new Response(cachedData));
     subscriber.complete();
   } else {
     this.httpRequest(request, requestOptions).subscribe(
       (response: Response) => {
         // Store the serializable version of the response
         this.httpCacheService.setCacheData(url, null, new ResponseOptions({
           body: response.text(),
           status: response.status,
           headers: response.headers,
           statusText: response.statusText,
           type: response.type,
           url: response.url
         }));
         subscriber.next(response);
       },
       (error: any) => subscriber.error(error),
       () => subscriber.complete()
     );
   }
 });

 ref.orderByKey().on('child_added', (snapshot: any) => {
   let doc = snapshot.val();
   observer.next({
     changeType: EDocumentChangeType.NEW,
     newDocument: doc
   });
 });

  // Process promise response from _onNext.
  private _update(inner: Subscriber<EvalDataSet>, resp: EvalIterResponse): void {
    // Merge with everything collected so far.
    this.inFlight.merge(resp.data);

    // Filter out any scrapes that are no longer to be shown.
    let filter: FilterTimeSpec = this.timeSpecService.filter;
    if (filter.active)
      this.inFlight.retainIf((line) => filter.test(line.date));

    // Update request parameters for next request.
    this.params.set('begin', resp.newBegin.getTime().toString());
    this.params.set('cookie', resp.cookie);
    this.params.set('iter', resp.iter);

    // Only continue fetching more data if still live.
    if (!this.stopped) {
      // Emit copy of current inflight.
      inner.next(this.inFlight.clone());

      if (resp.last)  // Close after last item emit.
        inner.complete();
      else  // Continue fetching more data.
        this._onNext(inner);
    }
  }

 (value) => {
   try {
     subscriber.next(value);
   } catch (err) {
     subscriber.error(err);
   }
 },

                    image.onload = () => {
                        let texture: THREE.Texture = new THREE.Texture(image);
                        texture.minFilter = THREE.LinearFilter;
                        texture.needsUpdate = true;

                        subscriber.next(texture);
                        subscriber.complete();
                    };

      FB.getLoginStatus(response => {
        if (response.status === 'connected') {
          localStorage.setItem('token', `facebook ${response.authResponse.accessToken}`);
        }

        subscriber.next(response);
        subscriber.complete();
      });